SSH框架：
(1)action层:控制层(表示层) : struts2 SpringMVC
是一个控制器,管理业务调度和管理跳转的,从这可以跳转到Service层,调用Service中的方法,可以对前端请求进行业务逻辑处理
(2)service层: 业务层 Spring:
负责所有层之间的关系处理(通过依赖注入),松耦合降低耦合度. Spring AOP
管理具体的功能(做相应的业务逻辑处理),Action只是负责管理,Servcie负责实施.
(3) Dao层:数据库访问层(持久层) Hibernate Mybatis
主要做数据库的交互工作,数据访问层,用来访问数据实现数据库的持久化(把内存中的数据永久的保存到硬盘中).
这里连接数据库操作的是Hibernate,完成增删改查
Hibernate最大的好处是根据数据库中的表,反向生成实体类,并且还有关系在里面,还有它对数据的操作也很方便.
(4)entity层(数据实体层) Hibernate
Spring的出现,减少了各类中的调用关系,将这些关系都转化到配置文件中
ApplicationContext.xml:控制struts和后台逻辑之间的关系
Struts:控制界面和Action之间的关系 -->
ContextLoaderListener 监听器(web.xml里面的)-->
Spring-->
LocalSessionFactoryBean(sessionFactory.xml,配置hibernate session工厂类似于 cfg配置)-->
hibernate
SSH中各个框架的作用
/*
* struts2: 整个应用架构的骨架,负责应用中MVC模块的实现,向下层传递前端请求,向上层传递服务响应,主要作用于action层
* Spring: 主要作用于依赖注入(DI)和控制反转(IOC)以达到解耦的目的,用于对整个与应用中的bean实例进行管理,作用SSH各个层
* Hibernate: 主要用于数据库操作,提供更加便捷的数据库操作框架,主要作用于Dao层
*/
SSH整合步骤
1.Struts2框架的web项目搭建起来
2.将Spring框架整合到web项目中,在web.xml中通过监听器记载Spring的配置文件.
<!-- 设置配置文件的位置 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:ApplicationContext.xml</param-value>
</context-param>
<listener>
<!--监听器-->
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- struts2过滤器 -->
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern> <!-- /* 所有的经过 *.action 表示以action结尾的经过过滤器 -->
</filter-mapping>
3.将action相关的对象配置到Spring中,action的对象时多例模式,需要将scope设置为原型模式.
在struts.xml中使用action时,将class配置为spring中的id名称
<!-- action的配置，action是多例模式，需要将scope设置为原型模式 依赖service层的bean -->
<bean id="employeeAction" class="com.xalo.action.EmployeeAction" scope="prototype">
<property name="employeeService" ref="employeeService"></property>
</bean>
<struts>
<!-- 修改default.properties常量 -->
<!-- 配置action的后缀名,如果有多个以逗号隔开 -->
<constant name="struts.action.extension" value="action,,"></constant>
<!-- 配置是否是开发模式,报错更详细,如果项目上线, 关闭开发模式 -->
<constant name="struts.devMode" value="true"></constant>
<!-- 配置文件加载之后,是否重新加载 -->
<constant name="struts.configuration.xml.reload" value="true"></constant>
<!-- 浏览器是否缓存静态文件 ,开发阶段关闭,上线后打开 -->
<constant name="struts.freemarker.beanwrapperCache" value="flase"></constant>
<!--如果我们只是给前端返回json数据,并不进行页面的跳转,package就继承自json-default 要使用json-default包需要导入struts2的json插件(struts2-json-plugin-jar)-->
<!--将class改为spring配置文件中的bean的id,将spring交给struts.xml进行管理-->
<package name = "User" extends="json-default" namespace="/employee">
<action name = "queryUser" class="employeeAction" method="queryUser">
<!--不写默认为转发-->
<result name="success" type="json">
<param name="root">result</param>
</result>
</action>
</package>
</struts>
<!--package: 将统一模块的action放在同一个package中,目的是方便管理维护.package中可以放多个action,
name:package的唯一标识符 namespace: 用于声明第一层请求web路径 extends:继承其它package,一般我们继承struts-default
action: 处理发送过来的业务逻辑,并为页面提供输出的数据
name: action的名称,相当于action的访问路径 class: action对应的类
method: 方法名,该name路径下要执行的对应action中的对应方法
result: 跳转页面使用
name: 方法的返回值和result的name值一样,就根据该result跳转页面
type: 设置跳转方式 type的属性值默认是dispatcher.
redirect重定向(会丢失请求参数) forward 转发 chain: 将action和另一个action链接起来
plaintext: 返回网页源代码 stream: 返回inputstream用于文件下载
param: 作用是返回的类型传递
name: 缺省值为location,用来设置action的初始变量值,result中可以设置返回数据
include: 包含其它配置文件
file: 要包含的xml文件的路径,如果是在src下,直接写文件名, 如果是在某个包下,包路径+ 文件名
<include file=“include.xml”></include> 在src下
<include file=“com/xalo/servlet/Servlet.xml”></include>在包下
constant: 设置常量配置,修改default.properties常量
-->
4.在Spring中配置数据源(DataSource)
<!-- 四本设置 -->
<!-- 配置数据源,数据库连接池配置 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- 数据库驱动 -->
<property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
<!-- 数据库地址 -->
<property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/MHMS?useUnicode=true&characterEncoding=utf8&useSSL=false"/>
<!-- 数据库用户名 -->
<property name="user" value="root"/>
<!--数据库密码 -->
<property name="password" value="12345678"/>
<property name="maxPoolSize" value="10"></property>
<property name="minPoolSize" value="3"></property>
<property name="maxIdleTime" value="600"></property>
<property name="initialPoolSize" value="3"></property>
<property name="acquireIncrement" value="5" />
<property name="checkoutTimeout" value="300000"></property>
<property name="idleConnectionTestPeriod" value="800"></property>
<property name="acquireRetryAttempts" value="30" />
<property name="maxStatements" value="0" />
<property name="breakAfterAcquireFailure" value="false" />
</bean>
5.Hibernate的sessionFactory对象交给Spring进行管理,配置sessionFactory(LocalSessionFactoryBean)
6.配置Spring的事务
<!-- 配置hibernate session工厂类似于 cfg 配置 -->
<bean id="sessionFactory"
class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<!-- 其它配置 -->
<property name="hibernateProperties">
<props>
<!-- 数据库方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
<!-- 自动建表 -->
<prop key="hibernate.hbm2ddl.auto">update</prop>
<!-- 控制台是否显示sql语句 -->
<!--show_sql: 是否把hibernate运行的sql语句显示到控制台 -->
<prop key="hibernate.show_sql">true</prop>
<!-- format_sql:输出到控制台的sql语句是否进行排版,便于阅读 -->
<prop key="hibernate.format_sql">true</prop>
</props>
</property>
<!-- 交由spring注解扫描实体类,省去了以前hibernate的配置文件,自动生成数据表 -->
<property name="packagesToScan" value="com.xalo.model." />
</bean>
<!--spring中hibernate事务配置 -->
<bean id="transactionManager"
class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!--设置事务通知中的方法 -->
<tx:advice transaction-manager="transactionManager" id="tx">
<tx:attributes>
<tx:method name="*" read-only="false" />
</tx:attributes>
</tx:advice>
<!--哪些方法需要添加增强功能 -->
<!-- aop配置 代理配置 proxy-target-class:不使用自动代理 -->
<aop:config proxy-target-class="false">
<!-- 切入点的配置 expression:要额外增加功能的方法 返回值 包名 类名 方法名-->
<aop:pointcut expression="execution(* com.xalo.daoImpl.*.*(..))" id="mypointcut" />
<!--环绕增强 -->
<aop:advisor advice-ref="tx" pointcut-ref="mypointcut" />
</aop:config>
<!-- 自动指定代理 -->
<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
</beans>
7.将Sevice对象, dao对象在Spring中进行配置,进行依赖注入.
将Service对象注入到action中
将dao对象注入到service中
<bean id="employeeDao" class="com.xalo.daoImpl.EmployeeDaoImpl>
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<bean id="employeeService" class="com.xalo.serviceImpl.EmployeeServiceImpl">
<property name = "employeeDao" ref="employeeDao"/>
</bean>
<!-- action的配置，action是多例模式，需要将scope设置为原型模式 依赖service层的bean -->
<bean id="employeeAction" class="com.xalo.action.EmployeeAction" scope="prototype" >
<property name="employeeService" ref="employeeService"/>
</bean>
8.将所有的配置文件在ApplicationContext.xml中导入
<!-- 自动扫描指定包及其包下的所有Bean类 -->
<context:component-scan base-package="com.xalo.*"/>
<!-- 数据源的配置文件 Spring中引入其他配置文件 -->
<import resource="classpath:dateSource.xml" />
<!-- sessionFactory 的配置文件 -->
<import resource="classpath:sessionFactory.xml" />
<!-- 引入beans的配置文件 -->
<import resource="classpath:beans_employee.xml"/>
<!-- classpath:内路径-->
SSH框架继承的两个类和一个接口
Serializable接口
/*
*Serializable:序列化
* hibernate有二级缓存,缓存会将对象写进硬盘,就必须序列化,只有序列化的对象
* 才可以存储在储存设备上,以及兼容对象在网络中的传输等
*/
public class User implements Serializable {
}
HibernateDaoSupport类
/*
* 对hibernate的增删改查操作的封装,通过依赖注入将sessionFactory注入给当前对象
*通过getHibernateTemplate()进行增删改查
*/
public class BaseDaoImpl extends HibernateDaoSupport implements BaseDaoInter {
/*
* 在对数据库进行增删改查中,需要使用try...catch,
*因为有时会莫名失败,解决报错信息返回用户界面问题.
*get():只能根据id查询,并且查询出来的只是一条记录
*load(): 采用延迟加载,getHibernateTemplate().load(User.class, user)
*find(): 查询出来的是一个集合
*/
//清理缓存,常常用于,先删除,后增加,再查询的情况
getHibernateTemplate().clear();
//刷新缓存,把内存中的sql文及时给执行
getHibernateTemplate().flush();
}
ActionSupport类
/*ActionSupport:
* ActionSupport类是一个工具类,它已经实现了Action接口.除此之外,它还实现了Validateable接口
* 提供了数据效验功能.通过继承该ActionSupport类,可以简化Struts2的Action开发
* 在validatable接口中定义了一个validate()方法,重写该方法,它会在execute()方法之前执行
* 如果效验失败,会转入input处,必须在配置该Action时配置input属性.
* 如果效验单输入域出现错误,则将错误添加到ActionSupport类的fieldErrors域中,然后通过OGNL表达式负责输出.
* ActionSupport还提供了一个getTex(string key)方法还实现了国际化,该方法从资源文件上获取国际化信息
* struts2通常直接使用Action封装HTTP请求参数,因此Action类里还应该包含与请求参数对应的属为属性提供setter和getter方法
*/
Action接口有:
public static final java.lang.String SUCCESS = "success";
public static final java.lang.String NONE = "none";
public static final java.lang.String ERROR = "error";
public static final java.lang.String INPUT = "input";
public static final java.lang.String LOGIN = "login";
public abstract java.lang.String execute() throws java.lang.Exception;
public class UserAction extends ActionSupport {
}
Struts2访问Servlet的三种方式:
在Struts2中,Action并没有直接和Servlet API耦合,在实现业务逻辑时,经常要访问Servlet中的对象,
如: request session appllication等
在Struts2中,访问Servlet API有三种方法: 分别是实现特定接口,通过ServletActionContext类, 通过ActionContext类
/*
*通过ServletConfig对对象传递
*在action中使用servletAPI
*第一种方式:
* 通过实现struts2提供的接口使用,不推荐使用,和ServletAPI耦合度过高,action类对servlet包的依赖度过高
* 当servlet中的包进行修改时或者更新,对应的action中也需要进行更新,维护action成本高
* 接口: ServletRequestAware ServletResponseAware SessionAware ApplicationAware ServletContextAware
* 第二种方式: 继承自 ActionSupport
* struts2将servlet相关的API都封装在了 ServletActionContext中,通过该对象直接获取
* 第三种方式:
* 通过action的上下文(actionContext)获取
*/
//第二种方式
public class SecondServletAction extends ActionSupport {
@Override
public String execute() throws Exception {
HttpServletRequest request = ServletActionContext.getRequest();
HttpSession session = request.getSession();
User user = (User) request.getAttribute("user");
ServletActionContext.getResponse();
ServletActionContext.getServletContext();
return NONE;
}
}
//第三种方式
public class ThridServletAction extends ActionSupport{
@Override
public String execute() throws Exception {
ActionContext context = ActionContext.getContext(); //获取action的上下文对象,本质上就是map
context.put("name","张小凡");//等同于request.setAttribute(key, value);
HttpParameters parameters = context.getParameters(); //获取request中的参数列表
//获取前端提交的name信息
//如果前端提交的数据中有多个参数的键一样,我们根据这个键获取的结果就是一个数组
Parameter parameters = parameters.get("name");
String[] ps = parameter.getMultipleValues();
for (String string : ps) {
System.out.println(string);
}
//如果url里面只有一个name,就用getValue()方法
System.out.println(parameter.getValue());
//获取servlet 中的对象
HttpServletRequest request = (HttpServletRequest) context.get(StrutsStatics.HTTP_REQUEST);
context.get(StrutsStatics.HTTP_RESPONSE);
context.get(StrutsStatics.PAGE_CONTEXT);
context.get(StrutsStatics.SERVLET_CONTEXT); //转发或者调用include方法用
context.get(StrutsStatics.SERVLET_DISPATCHER);
return NONE;
}
}
ActionContext.getContext.getSession()方法
/*
*JSP/Servlet有个原生的session对象,这是九大内置对象中的一个,类型是HttpSession session
*函数方法是setAttrribute(), getAttribute().
*struts2中对底层的web容器对象做了二次封装,封装为Map的类型用于封装全局变量
*在struts2中获取和获取对象通过: ActionContext.getContext.getSession()方法获得
* Map<Strring,Object> map对象
*/
Struts2 Result 返回JSON对象详解
https://blog.csdn.net/qq_29663071/article/details/53103021
SSH中的注解
Hibernate注解
@Entity
@Table(name="classRoom")
@Id //映射生成主键
@GeneratedValue(strategy = GenerationType.IDENTITY) //定义主键生成策略,自动递增
@Column(name = "cid")
private Integer cid;
@Basic(fetch = FetchType.EAGER, optional = true) //声明属性的存取策略,立即获取
@Column(name = "name")
private String name;
//关联映射
//(1)一对多(教室---学生)
//mappedBy = "多端的关联属性名"表明当前类放弃关联关系的维护,交由对方的关联数属性维护 targetEntity:写对方的实体类型
@OneToMany(mappedBy = "classRoom", targetEntity = Student.class)
private Set<Student> students = new HashSet<>();
@ManyToOne(targetEntity = ClassRoom.class, cascade = CascadeType.ALL)
//@JoinColum(name="对方的数据库外键名称")
@joinColumn(name = "id")
private ClassRoom classRoom;
//(2)多对多(教师---学科)
//teachers: 当前类Course放弃了维护权,由对方的关联属性courses来维护
@ManyToMany(mappedBy = "teachers", targetEntity = Course.class)
private Set<Course> courses = new HashSet<>();
//当前类teacher独立拥有了维护权,所以其关联关系上设置cascade属性,否则无法维护关联关系
@ManyToMany(cascade = CascadeType.ALL)
private Set<Teacher> teachers = new HashSet<>();
//(3)一对一(man---woman)
@OneToOne(mappedBy = "man", targetEntity = Woman.class)
private Woman woman;
@OneToOne(targetEntity = Man.class, cascade = CascadeType.ALL)
@JoinColumn(name = "id") //指定外键的名称
private Man man;
Hibernate.cfg.xml配置
<hibernate-configuration>
<!-- 对session工厂的设置 -->
<session-factory>
<!-- 四本一言的设置 -->
<!--数据库地址 -->
<property name="hibernate.connection.url">jdbc:mysql://127.0.0.1:3306/hibernatem?characterEncoding=utf8</property>
<!-- 数据库用户名 -->
<property name="hibernate.connection.username">root</property>
<!-- 数据库密码 -->
<property name="hibernate.connection.password">12345678</property>
<!-- 数据库驱动 -->
<property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>
<!-- 方言 -->
<property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
<!-- 控制台是否显示sql语句 -->
<!--show_sql: 是否把Hibernate运行时的SQL语句输出到控制台 -->
<property name="show_sql">true</property>
<!--format_sql 输出到控制台的SQL语句是否进行排版,便于阅读 -->
<property name="format_sql">true</property>
<!--hbm2ddl.auto 自动建表: 可以帮助由java代码生成数据库脚本,进而生成具体的表结构 -->
<property name="hbm2ddl.auto">create</property>
<!-- 加载使用了注解的实体 -->
<mapping class="com.xalo.model.ClassRoom"/>
<mapping class="com.xalo.model.Student"/>
<mapping class="com.xalo.model.Man"/>
<mapping class="com.xalo.model.Woman"/>
<mapping class="com.xalo.model.Teacher"/>
<mapping class="com.xalo.model.Course"/>
</session-factory>
</hibernate-configuration>
Struts2常用注解
Struts.xml
用了注解就不需要配置Struts.xml文件了.
<struts>
<!-- 修改default.properties常量 -->
<!-- 配置action的后缀名,如果有多个以逗号隔开 -->
<constant name="struts.action.extension" value="action,,"></constant>
<!-- 配置是否是开发模式,报错更详细,如果项目上线, 关闭开发模式 -->
<constant name="struts.devMode" value="true"></constant>
<!-- 配置文件加载之后,是否重新加载 -->
<constant name="struts.configuration.xml.reload" value="true"></constant>
<!-- 浏览器是否缓存静态文件 ,开发阶段关闭,上线后打开 -->
<constant name="struts.freemarker.beanwrapperCache" value="flase"></constant>
<package name="User" extends="json-default" namespace="/employee">
<!-- 将class改为spring配置文件中bean的id,将spring交给struts.xml进行管理 -->
<!--根据id查询某个用户信息-->
<action name="uqueryUser" class="userAction" namespace="/user">
<result name="success" type="json">
<param name="root"></param>
</result>
</action>
</package>
</struts>
@Controller("userAction")
/*如果我们只是给前端返回json数据,并不进行界面的跳转,package就继承自json-default.
要使用json-default包需要导入struts2的json插件(struts2-json-plugin-jar)*/
@ParentPackage("json-default")
@Namespace("/user")
@Action(value = "queryUser", results = { @Result(name = "success", type = "json", params = { "root", "result" }) })
Spring常用注解
Spring的一个核心功能是IOC,就是将Bean初始化加载到容器中.
Bean加载到容器的方法: Spring注解方式和SpringXML方式
//下面这四个注解实质上属于同一类注解,用法相同,功能相同,区别在于表示组件的类型.
@Component可以代替@Repository、@Service、@Controller，因为这三个注解是被@Component标注的。
@Component: // 标准一个普通的spring Bean类
@Repository: //标注一个dao组件类
@Service: //标注一个业务逻辑组件类
@Controller: //标注一个控制器组件类,表明当前类是一个处理器
将当前实体交给spring管理,等同于在IOC配置了<bean id="FirstController" class="包名.类名">
value指定Bean的id名称,如果不指定默认为类名,如果Controller中只配置value,可以省略value直接写值
@Scope("prototype") // action是多例模式,需要将scope设置为原型模式
//在Spring的IOC容器中指定一个dao层的bean,如果value不指定默认该对象的类名,如果指定,id为value的值
@Repository(value = "userDao")
//接收前端传递过来的json数据, 当返回值不是逻辑视图名称,而是一组数据, 相当于response中的writer方法 response.getWriter().writer("方法返回值")
@ResponseBody
/*依赖注入
*@Autowired(required = false):默认是按照type注入,如果想按照id注入,就要配合@Qualifier来使用
* required:如果找不到bean注入 true(默认) 异常:false: 不注入即可,不会报异常
*@Qualifier:配合上面的注解使用, byName
*@Resourse: 按照id注入 javaEE提供的依赖注入的注解1.6之后才可以使用
*/
@Autowired
@Qualifier("userDao")
@Resourse
@Repository(value = "userDao")
public class UserDaoImpl extends BaseDaoImpl implements UserDaoInter {
@Resourse(name = "sessionFactory")
public void setMySessionFactory(SessionFactory sessionFactory){
super.setSessionFactory(sessionFactory);
}
//根据id查询某个用户信息
/*
*get()方法根据id查询出来的只是一条记录.
*load()方法采用延迟加载:getHibernateTemplate().load(PurchaserOrder.class,purOrderId);
* find()
*/
@Override
public User uqueryUser(Integer uId) {
try {
User user = getHibernateTemplate().get(User.class, uId);
System.out.println(user);
return user;
} catch (Exception e) {
e.printStackTrace();
}
return nul
}
@Service("userService")
public class UserSeviceImpl implements UserServiceInter {
@Autowired
@Qualifier("userDao")
//将dao层对象注入service层
private UserDaoInter userDao;
private HashMap<String, Object> map = new HashMap<>();
public void setUserDao(UserDaoInter userDao) {
this.userDao = userDao;
}
public HashMap<String, Object> getMap() {
return map;
}
public void setMap(HashMap<String, Object> map) {
this.map = map;
}
// 根据id查询用户
@Override
public Map<String, Object> uqueryUser(Integer uId) {
User user = userDao.uqueryUser(uId);
if (user == null) {
map.put("code", CodeInter.FAILED);
map.put("msg", "没有查询到用户信息");
} else {
map.put("code", CodeInter.SUCCESS);
map.put("msg", "查询成功");
map.put("queryUser", user);
}
return map;
}
@Controller("userAction")
@Scope("prototype")
@ParentPackage("json-default")
@Namespace("/user")
public class UserAction extends ActionSupport {
@Autowired
@Qualifier("userService")
// 将service依赖注入action层
private UserServiceInter userService;
//接收前端传递过来的参数
private User user;
public void setUserService(UserServiceInter userService) {
this.userService = userService;
}
//接收前端传递过来的json数据
@ResponseBody
public User getUser() {
return user;
}
public void setUser(User user) {
this.user = user;
}
@Action(value = "queryUser", results = { @Result(name = "success", type = "json", params = { "root", "result" }) })
// 根据uId查询用户信息
public String uqueryUser() {
result = userService.uqueryUser(user.getuId());
System.out.println(result);
//Action层里面方法的返回值return " ",后面写的是视图名称, SUCCESS:里面封装的是"success"
return SUCCESS;
}
}
向前端返回值的方式:
一般情况下,给前端返回集合就行,就不需要进行json解析了.
在SSH整合时,返回字符串会莫名奇妙的报错.
Json解析:
前后台传输的信息其实都是字符串,解析是把字符串重新变成json类型的对象,这样就能对里面的各种类型的属性或对象做操作了.
(1)返回集合
//(1)ManagerAction.java
public class ManagerAction extends ActionSupport {
private User user; //接收前端传递过来的参数
private HashMap<String, Object> result; //给前端返回结果
private ManagerServiceInter managerService; //setter依赖注入ManagerServiceImpl对象
public void setManagerService(ManagerServiceInter managerService) {
this.managerService = managerService;
}
//给传过来的参数跟返回的结果提供setter和getter方法
//根据id查询某个用户信息
public String uqueryUser() {
result = managerService.uqueryUser(user.getuId());
System.out.println(result);
return SUCCESS;
}
}
//(2)ManagerServiceImpl.java
private ManagerDaoInter managerDao; //setter依赖注入ManagerDaoImpl的对象
private HashMap<String, Object> map = new HashMap<>();
public void setManagerDao(ManagerDaoInter managerDao) {
this.managerDao = managerDao;
}
public class ManagerServiceImpl implements ManagerServiceInter {
// 根据id查询某个用户信息
@Override
public HashMap<String, Object> uqueryUser(Integer uId) {
User user = managerDao.uqueryUser(uId);
if (user == null) {
map.put("code", CodeInter.FAILED);
map.put("msg", "查询失败");
} else {
map.put("code", CodeInter.SUCCESS);
map.put("msg", "查询成功");
map.put("queryUser", user);
}
return map;
}
}
//(3)ManagerDaoImpl.java
//BaseDaoImpl里面封装着公共的方法,继承自HibernateDaoSupport
public class ManagerDaoImpl extends BaseDaoImpl implements ManagerDaoInter{
// 根据id查询某个用户信息
@Override
public User uqueryUser(Integer uId) {
try {
User user = getHibernateTemplate().get(User.class, uId);
System.out.println(user);
return user;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
(2)返回字符串
private JSONObject json = new JSONObject();
if (user != null) {
json.put("code", ErrorCode.SUCCESS);
json.put("msg", "登录成功");
} else {
json.put("code", ErrorCode.LOGINERROR);
json.put("msg", "登录失败"); }
}
return json.toString();
添加一个输入框
<label>用户id</label>
<!--disabled:不可编辑,当设置这个属性时,当前输入框不能输入内容
border:black solid:边界: 黑色实心-->
<input id="IDQuery" type="uId" disabled="disabled" style=" border:black solid; width: 150px"/>
<button id="selects">查询</button>
<!--添加点击事件-->
$("#selects").click(function(){
var uId = $("#IDQuery").val(); <!--ajax获取输入(input)的值-->
$.ajax({
type: "post",
url: "user/queryUser.action",
data: "user.uId=" + uId, <!--data: 前端发送给服务器的数据-->
success:function(respdate){ <!--respdata:给前端返回的数据-->
var code = respdata["code"];
var msg = respdata["msg"];
var users = respdata["queryUser"]; <!--map.put("queryUser", user)-->
console.log(users);
},
});
});
JavaScript:
<!-- 将html文件转换为jsp文件 -->
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!-- 导入jsp标签库, 三大指令:page include taglib -->
<%@ taglib prefix="s" uri="/struts-tags"%>
<!-- spring提供的标签库 -->
<%@taglib prefix="spring" uri="http://www.springframework.org/tags" %>
<!--(1)引入CSS文件-->
<link rel = “stylesheet” type = “text/css” href = “”/>
<!--(2)引入js文件-->
<script type="text/javascript" src = "js/文件名"></script>
<!--(3)执行定义好的方法-->
<button id="selects" onclick = " ">点击按钮</button>
<!--JQuery入口函数(脚本)和JavaScript入口函数(脚本)的区别:
JQuery: 在html所有标签(DOM)都加载之后,就会执行
JavaScript的window.onload事件是等到所有内容,包括外部图片之类的文件加载完后,才会执行-->
<!--JQuery入口函数(脚本)-->
<!--(1)当文档加载完毕之后就会执行该方法, 这三种都是任选一种,JQuery默认参数是:"document"-->
<!--JavaScript文档加载完成事件: document.ready和onload的区别
页面完成加载有两种事件:
1.ready:文档结构已经完成加载(不包含图片等非文字媒体文件)
2.onload: 页面包含图片等文件在内的所有元素都加载完成-->
$(document).ready(function(){
});
$(function(){
});
$().ready(function(){
});
<!--(2)给按钮绑定点击事件-->
$("#selects").click(function(){
});
<!--javaScript入口函数-->
window.onload = function(){
//执行代码
}
<!--JQuery选择器-->
<!--1.元素选择器:用户点击按钮后,所有<p>元素都隐藏-->
$(document).ready(function(){
$("#selects").click(function(){
$("p").hide();
});
});
<!--#id选择器: 当用户点击按钮后, 有 id = "test" 属性的元素将被隐藏-->
$(document).ready(function(){
$("#selects").click(function{
$("#test").hide();
});
});
<!--3. .class选择器: 用户点击按钮后,所有带有 class = "test"属性的元素都隐藏-->
$(document).ready(function(){
$("#selects").click((){
$(".test").hide();
});
});
<!--Js的三大事件:
1.键盘事件:
keydown: 按键按下 keyup:按键抬起 keypress: 按键按下抬起
2.鼠标事件:
click: 单击 dblclick:双击 mousedown: 鼠标按下 mouseup: 鼠标抬起
mouseover: 鼠标悬浮 mouseout: 鼠标离开 mousemove: 鼠标移动
mouseenter:鼠标进入 mouseleave: 鼠标离开
3.HTML事件:
load: 文档加载完成 select: 被选中的时候 change: 内容被改变
focus:得到光标 resize: 窗口尺寸变化 scroll: 滚动条移动-->
<!--click():
该方法是当前按钮点击事件被触发时会调用的一个函数-->
<!--使用var关键词来声明变量.可以在一条语句中声明很多变量.
全局变量不能用var声明,用var声明的变量是局部变量
全局变量可以在声明的函数外调用,局部变量不能再函数外调用->
<!--设置内容
var(): 声明变量
alert(): 使用变量,打印出来
val(): 设置或返回表单字段的值
text(): 设置或返回所选元素的文本内容
html(): 设置或返回所选元素的内容(包括HTML标记)
attr(): 用于设置/改变属性值. 也允许同时设置多个属性-->
<div class="kv-item ue-clear">
<label><span class="impInfo">*</span>性 别</label>
<div class="kv-item-content">
<span class="choose">
<span class="checkboxouter">
<input type="radio" name="sex" value="男" />
<span class="radio"></span>
</span>
<span class="text">男</span>
</span>
<span class="choose">
<span class="checkboxouter">
<input type="radio" name="sex" value="女" />
<span class="radio"></span>
</span>
<span class="text">女</span>
</span>
</div>
<span class="choose">
<span class="checkboxouter">
<input type="radio" name="sex" value="保密" checked/>
<span class="radio"></span>
</span>
<span class="text">保密</span>
</span>
</div>
<!--jquery获取radio单选按钮的值 判断radio(种类)是否选中并去取得选中的值-->
var sex = $("input[name = 'sex']:checked").val();
<!--alert(): 用于显示带有一条指定消息和一个OK按钮的警告框-->
alert(code + ":" + msg);
<!--在javascript编程中,多使用location.reload是实现页面刷新-->
location.reload();
<!--dataType: 指定返回数据的格式,常用为两种:
text(先进行解析json)
json 如果为json就直接用,不用再进行解析,进行全局页面的跳转,返回的就是json字符串-->
<!--一般进行局部刷新,给前端返回的就是集合,不需要进行json解析-->
<!--json解析-->
var jsondata = JSON.parse(jsondata);
<!--将对象转化为json字符串-->
console.log("jsondata" + JSON.stringify(jsondata));
var msg = jsondata["msg"];
<!--将连接后的字符串放到class="msg"标签中-->
$(".msg").test(msg);
console.log("msg:" + msg);
JQuery判断radio(单选框)是否选中和获取选中值方法总结
https://www.jb51.net/article/64141.htm
前端页面知识点: 十分全面
http://www.runoob.com
javaScript刷新页面location.reload()用法:
http://www.jquerycn.cn/a_11620
//在js编程中多使用location.reload实现页面刷新
//这两句在某些情况下可以代替location.reload()而不会出现重试对话框达到刷新效果
window.location.href="";
window.location.reload;
国际化:
loginAndRegisterForManager.jsp
<!-- 将html文件转换为jsp文件 -->
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!-- 导入jsp标签库, 三大指令:page include taglib -->
<%@ taglib prefix="s" uri="/struts-tags"%>
<h2><s:test namer="loginTitle"></s:test></h2>
<div>
<div class="msg" style="color: red">
<s:text name="loginName"></s:text>
<input id="mAccount" type="text" placeholder='<s:text name="loginName"></s:text>'><br>
<s:text name="loginPassword"></s:text>
<input id="mPassword" type="password" placeholder='<s:text name="loginPassword"></s:text>'><br>
<input id="submit" type="button" value='<s:text name="loginTitle"></s:text>' style="margin-top:10px; width: 120px; height: 30px; background-color: red; font-size: 15px; border-radius: 5px; margin-left: 155px"/>
</div>
<!--当我们访问name为aa的action时,肯定会经过i18n的拦截器,在此拦截器中会获取到我们提交的request_locale参数
根据参数的值我们当前界面会从对应的properties文件中按照键获取值
例如: 参数为zh_CN那么我们就从xalo_zh_CN中按键取值-->
<a href="aa.action?request_locale=zh_CN"><s:text name="chinese"></s:text></a>
<a href="aa.action?request_locale=en_US"><s:text name="english"></s:text></a>
struts_loginAndRegister.xml
<struts>
<!-- 修改default.properties常量 -->
<!-- 配置action的后缀名,如果有多个以逗号隔开 -->
<constant name="struts.action.extension" value="action,,"></constant>
<!-- 配置是否是开发模式,报错更详细,如果项目上线, 关闭开发模式 -->
<constant name="struts.devMode" value="true"></constant>
<!-- 配置文件加载之后,是否重新加载 -->
<constant name="struts.configuration.xml.reload" value="true"></constant>
<!-- 浏览器是否缓存静态文件 ,开发阶段关闭,上线后打开 -->
<constant name="struts.freemarker.beanwrapperCache" value="flase"></constant>
<!-- 本地语言的设置 -->
<constant name="struts.custom.i18n.resources" value="xalo"/>
<package name="login" extends="json-default">
<action name="aa" class="com.xalo.action.CCAction">
<!--不写默认为转发-->
<result name="success">/loginAndRegisterForManager.jsp</result>
</action>
</package>
beans_loginAndRegister.xml
<bean id="loginAndRegisterDao" class="com.xalo.daoImpl.LoginAndRegisterDaoImpl">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<bean id="loginAndRegisterService" class="com.xalo.serviceImpl.LoginAndRegisterServiceImpl">
<property name="loginAndRegisterDao" ref="loginAndRegisterDao"></property>
</bean>
<!-- action的配置，action是多例模式，需要将scope设置为原型模式 依赖service层的bean -->
<bean id="loginAndRegisterAction" class="com.xalo.action.LoginAndRegisterAction" scope="prototype">
<property name="loginAndRegisterService" ref="loginAndRegisterService"></property>
</bean>
xalo_en_US.properties
loginTitle=login
loginName=name
loginPassWord=passWord
chinese=chinese
xalo_zh_CN.properties
loginTitle=\u767B\u5F55
loginName=\u767B\u5F55\u7528\u6237\u540D
loginPassword=\u767B\u5F55\u5BC6\u7801
chinese=\u4E2D\u6587
CCAction
public class CCAction extends ActionSupport {
@Override
public String execute() throws Exception {
return SUCCESS;
}
}
4579
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
