标签:springmvc hibernate structs2 s2sh
前面几篇博客学习了spring中IOC,和springAOP以及spring通过jdbc操作数据库的方法。我们的目标是学习springMVC,那么在正式学习springMVC之前呢,我还是想到先写一篇文章来讲解S2SH整合吧,这样大家简单了解了structs2,对于后面学习springMVC也是有很大好处的。
我们先来整合spring和hibernate吧,我这里新建一个web工程叫做ssh。
将spring和hibernate需要的jar文件添加到WEB-INFO下的lib目录中。需要的jar文件如下:
hibernate3.jar
hibernate-jpa-2.0-api-1.0.0.Final.jar
antlr-2.7.6.jar
commons-collections-3.1.jar
dom4j-1.6.1.jar
javassist-3.12.0.GA.jar
jta-1.1.jar
slf4j-api-1.6.1.jar
spring.jar
commons-logging.jar
log4j-1.2.15.jar
mysql-connector-java-3.0.10-stable-bin.jar
commons-dbcp.jar
commons-pool.jar
创建实体类和映射对象,这里我依然通过一个user实体来操作,因此我需要新建一个Userinfo实体类,如下:
package com.test.entity;
import java.io.Serializable;
public class Userinfo implements Serializable {
private int uid;
private String uname;
private String upass;
public int getUid() {
return uid;
}
public void setUid(int uid) {
this.uid = uid;
}
public String getUname() {
return uname;
}
public void setUname(String uname) {
this.uname = uname;
}
public String getUpass() {
return upass;
}
public void setUpass(String upass) {
this.upass = upass;
}
}
这里,由于UserInfo实体类,以后会在网络上传输,所以需要实现Serializable接口。然后需要创建对应的实体类映射,我们需要在实体类同样的包下,新建一个Userinfo.hbm.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.test.entity.Userinfo" table="userinfo">
<id name="uid" column="uid">
<generator class="native"></generator>
</id>
<property name="uname"></property>
<property name="upass"></property>
</class>
</hibernate-mapping>
这里class标签中的name的值就是需要映射的实体类的全类名,table的值就是数据库中该实体类对应的表的名称,有一个id,标签,就是该userinfo表所对应的主键,这里我们逐渐的生成测试采用"native",该中方式可以根据不同的底层数据库采用不同的主键生成方式,说明一下genernator的属性吧。
在hibernate中genernator的属性一共有七种,我们来看几个常用的:
1.identity用于mysql数据库的递增,注意需要在mysql中建表的时候将对应的字段设置为auto_increment
2.sequence用于orecale数据库
3.native 跨数据库时候使用,屏蔽了底层的方言
4.assigned 用户自定义id
5.foreign 用于外键关联时候使用
6.increment 用于为long,short,int类型生成唯一的表示,在高并发下不能使用
<property name="uname"></property>
<property name="upass"></property>
表示实体类对应到表中的字段,name表示实体类中的属性,如果我们不为该property标签指定column=""属性,那么对应的userinfo表中的字段名称和类中的属性名是相同的,如果指定了column="",比如<property name="uname" column="t_uname"></property> 此时userinfo表中uname属性对应的字段名称就叫做"t_uname"
编写dao以及实现类,用来操作数据库的(dao需要集成HibernateDaoSupport),首先编写一个UserinfoDao的接口:
package com.test.dao;
import java.util.List;
import com.test.entity.Userinfo;
public interface UserinfoDao {
public int addUserinfo(Userinfo user);
public int updateUserinfo(Userinfo user);
public int deleteUserinfo(int uid);
public List<Userinfo> getAll();
public Userinfo getUserinfoById(int uid);
}
可以看到,在该接口中定义了"增删改查"四个方法,然后编写UserinfoDao的实现类,UserinfoDaoImpl.java
package com.test.dao.impl;
import java.util.List;
import org.springframework.dao.DataAccessException;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.test.dao.UserinfoDao;
import com.test.entity.Userinfo;
public class UserinfoDaoImpl extends HibernateDaoSupport implements UserinfoDao {
public int addUserinfo(Userinfo user) {
int count=0;
try {
this.getHibernateTemplate().save(user);
count=1;
} catch (DataAccessException e) {
e.printStackTrace();
}
return count;
}
public int deleteUserinfo(int uid) {
int count=0;
Userinfo user = getUserinfoById(uid);
try {
this.getHibernateTemplate().delete(user);
count=1;
} catch (DataAccessException e) {
e.printStackTrace();
}
return count;
}
public List<Userinfo> getAll() {
return this.getHibernateTemplate().find("from Userinfo");
}
public Userinfo getUserinfoById(int uid) {
return (Userinfo)this.getHibernateTemplate().get(Userinfo.class, uid);
}
public int updateUserinfo(Userinfo user) {
int count=0;
try {
this.getHibernateTemplate().update(user);
count=1;
} catch (DataAccessException e) {
e.printStackTrace();
}
return count;
}
}
我们可以看到通过this.getHibernateTemplate();就可以得到HibernateTemplate 对象,然后通过该对象操作数据库是很方便的,HibernateTemplate 为我们提供的方法,我们只需要将对应的实体类,或该实体类的id传进去就可以操作数据库了,大大的提高了开发效率。
下面我写一个UserinfoBiz接口,并且让UserinfoBizImpl实现该接口同时在UserinfoBizImpl中声明一个UserInfoDao的属性,并且设置set方法,这样做是为了后边将UserInfoDao通过IOC注入给UserinfoBizImpl。
package com.test.biz;
import java.util.List;
import com.test.entity.Userinfo;
public interface UserinfoBiz {
public int addUserinfo(Userinfo user);
public int updateUserinfo(Userinfo user);
public int deleteUserinfo(int uid);
public List<Userinfo> getAll();
public Userinfo getUserinfoById(int uid);
}
package com.test.biz.impl;
import java.util.List;
import com.test.biz.UserinfoBiz;
import com.test.dao.UserinfoDao;
import com.test.entity.Userinfo;
public class UserinfoBizImpl implements UserinfoBiz {
private UserinfoDao userDao;
public void setUserDao(UserinfoDao userDao) {
this.userDao = userDao;
}
public int addUserinfo(Userinfo user) {
return userDao.addUserinfo(user);
}
public int deleteUserinfo(int uid) {
return userDao.deleteUserinfo(uid);
}
public List<Userinfo> getAll() {
return userDao.getAll();
}
public Userinfo getUserinfoById(int uid) {
return userDao.getUserinfoById(uid);
}
public int updateUserinfo(Userinfo user) {
return userDao.updateUserinfo(user);
}
}
创建spring容器,配置数据源和sessionFactory,在src下新建spring的配置文件applicationContext.xml配置数据源。
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<!-- 驱动名称 -->
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<!-- url -->
<property name="url" value="jdbc:mysql://localhost:3306/mydb?useUnicode=true&characterEncoding=UTF-8"></property>
<!-- 用户名 -->
<property name="username" value="root"></property>
<!-- 密码 -->
<property name="password" value="root"></property>
</bean>
</beans>
接下来配置sessionFactory,并将datasource注入:
<!-- 配置sessionFactory,注入dataSource -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!-- 注入dataSource -->
<property name="dataSource" ref="dataSource"></property>
<!-- 引入映射文件的位置 -->
<property name="mappingResources">
<list>
<value>com/test/entity/Userinfo.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
</props>
</property>
</bean>
在org.springframework.orm.hibernate3.LocalSessionFactoryBean中有一个dataSource属性,<property name="dataSource" ref="dataSource"></property>就是将上面配置的dataSource注入给该属性。
<property name="mappingResources">
<list>
<value>com/test/entity/Userinfo.hbm.xml</value>
</list>
</property>
mappResources,就是映射所有的实体类到数据库中的,注意这里是一个list,由于我们现在只有一个UserInfo,所以只写了这么一个,这里value的值,是实体类对应的映射文件的路径。
<property name="hibernateProperties">
<props>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
</props>
</property>
hibernateProperties配置的是数据库的方言,即hibernate.dialect的值。这里是mysql的方言。hibernate.show_sql的值是true表示在程序运行期间是否打印sql语句,在开发调试期间最好打开,这样便于观察生成的sql语句是否正常。
接下来需要配置Dao,并将sessionFactory注入:
<!-- 配置Dao,并注入sessionFactory -->
<bean id="userDao" class="com.test.dao.impl.UserinfoDaoImpl">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
这里整个过程和spring的IOC配置是一样的,其实这里就是spring的ioc配置,最后需要配置Biz,并将Dao注入。
<!-- 配置Biz,并注入Dao -->
<bean id="userBiz" class="com.test.biz.impl.UserinfoBizImpl">
<property name="userDao" ref="userDao"></property>
</bean>
这里,因为我在UserinfoBizImpl类中声明了userDao属性,并且为该属性设置了set方法,可以通过spring来为其赋值,这里我是通过ref引用上一步定义的userDao,可以发现我们整个过程都是一步一步通过IOC赋值的:
dataSource-->sessionFactory-->Dao-->Biz
此时,万事俱备,只欠东风,新建一个dataSource中配置的数据库mydb,然后新建一个userinfo表,该表有三个字段uid,uname,upass,注意建表的时候字段类型需要和实体类中对应哦。创建好了表以后,就可以编写测试类来测试我们的spring和hbiernate整合是否成功。
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
UserinfoBiz userBiz = (UserinfoBiz)ac.getBean("userBiz");
Userinfo user = new Userinfo();
user.setUname("bb");
user.setUpass("123");
userBiz.addUserinfo(user);
List<Userinfo> list = userBiz.getAll();
for (Userinfo userinfo : list) {
System.out.println(userinfo.getUid()+"\t"+userinfo.getUname()+"\t"+userinfo.getUpass());
}
这里,我首先插入一条记录到userinfo表中,然后调用getAll()查询所有数据,打印如下:
Hibernate: insert into userinfo (uname, upass) values (?, ?)
Hibernate: select userinfo0_.uid as uid0_, userinfo0_.uname as uname0_, userinfo0_.upass as upass0_ from userinfo userinfo0_
1 bb 123
可以看到,这时查询所用的sql语句也一并给我们打印出来了,此时spring和hibernate整合就成功了,可是有时候在对数据库进行增删改查的时候,难免会需要使用事物,接下来我们就来配置hibernate事物。
<!-- 配置声明式事务 -->
<!-- 配置事务管理器,注入sessionFactory -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<!-- 配置事务通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="add*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="delete*" propagation="REQUIRED"/>
<tx:method name="*" propagation="SUPPORTS"/>
</tx:attributes>
</tx:advice>
<aop:config>
<!-- 定义切入点 -->
<aop:pointcut expression="execution(* com.test.biz.*.*(..))" id="bizMethods"/>
<!-- 将事务通知和切入点告知给通知者 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="bizMethods"/>
</aop:config>
配置hibernate事物主要有一下几步:
1.配置事务管理器,注入sessionFactory
2.配置事务通知
3.定义切入点,将事务通知和切入点告知给通知者
在配置事物通知的时候,我将以add,update,delete开头的方法是必须开启事物的,另外一个"*"表示如果存在一个事务,支持当前事务。如果没有事务,则非事务的执行,propagation有一下一些值:
REQUIRED: 如果存在一个事务,则支持当前事务。如果没有事务则开启
SUPPORTS: 如果存在一个事务,支持当前事务。如果没有事务,则非事务的执行
MANDATORY: 如果已经存在一个事务,支持当前事务。如果没有一个活动的事务,则抛出异常
REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在,则将这个存在的事务挂起
NOT_SUPPORTED: 总是非事务地执行,并挂起任何存在的事务
NEVER: 总是非事务地执行,如果存在一个活动事务,则抛出异常
NESTED:如果一个活动的事务存在,则运行在一个嵌套的事务中. 如果没有活动事务, 则按 TransactionDefinition.PROPAGATION_REQUIRED 属性执行
<aop:pointcut expression="execution(* com.test.biz.*.*(..))" id="bizMethods"/>
这里我们的切入点是com.test.biz包下的所有方法,在说一遍吧:
第一个"*"表示方法的返回值类型
第二个"*"表示类名
第三个"*"表示方法名
第四个".."表示方法中存在0个或者多个参数。
记住,添加aop所需要的jar:aspectjrt.jar,aspectjweaver.jar
此时hibernate的事物就配置好了,此时当我运行add,update,delete方法时都会开启事物,如果操作失败,事物将会回滚。接下来就是将struts2整合进来拉。
同样将strust2整合进来,
首先需要添加struts2的jar文件:
commons-fileupload-1.2.2.jar
commons-io-2.0.1.jar
commons-lang3-3.1.jar
commons-logging-1.1.1.jar
freemarker-2.3.19.jar
javassist-3.11.0.GA.jar
ognl-3.0.5.jar
sqljdbc.jar
struts2-core-2.3.4.1.jar
struts2-dojo-plugin-2.3.4.1.jar
xwork-core-2.3.4.1.jar
同时需要添加struts2和spring整合的jar:struts2-spring-plugin-2.3.4.1.jar,有一些jar在spring和hibernate整合的时候已经添加过了,这里就不需要重复添加了,否则可能引起jar包冲突。
在web.xml中配置struts2的核心过滤器和ContextLoaderListener
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<!-- 加载spring的配置文件 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- 指定spring配置文件的位置 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath*:applicationContext.xml</param-value>
</context-param>
<!-- OSIVFilter:解决hibernate懒加载问题 -->
<filter>
<filter-name>osivFilter</filter-name>
<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>osivFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<!-- struts2核心过滤器 -->
<filter>
<filter-name>struts2</filter-name>
<filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>struts2</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
编写UserInfoAction,我们在编写action的时候,为该UserInfoAction声明一个UserInfoBiz属性,并且设置set方法,这样做是为了后边通过springIOC将UserInfoBiz注入给UserInfoAction,完美的实现了三层架构,注意:UserInfoAction必须继承自ActionSupport,如果我们需要用到HttpServletRequest,那么UserInfoAction需要声明一个HttpServletRequest request;属性,并且实现ServletRequestAware接口,实现了ServletRequestAware接口之后,需要重写一下方法:
public void setServletRequest(HttpServletRequest arg0) {
request=arg0;
}
这里是将arg0赋值给我们自己的属性。
package com.test.action;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.apache.struts2.interceptor.ServletRequestAware;
import com.opensymphony.xwork2.ActionSupport;
import com.test.biz.UserinfoBiz;
import com.test.entity.Userinfo;
public class UserinfoAction extends ActionSupport implements ServletRequestAware{
private UserinfoBiz userBiz;
private HttpServletRequest request;
private Userinfo user;
public Userinfo getUser() {
return user;
}
public void setUser(Userinfo user) {
this.user = user;
}
public void setUserBiz(UserinfoBiz userBiz) {
this.userBiz = userBiz;
}
public String getAll() throws Exception {
List<Userinfo> list = userBiz.getAll();
request.setAttribute("list", list);
return "list";
}
public String doRegister() throws Exception {
int result = userBiz.addUserinfo(user);
if(result>0){
return this.SUCCESS;
}
return this.ERROR;
}
public String doDelete() throws Exception {
int result = userBiz.deleteUserinfo(user.getUid());
if(result>0){
return this.SUCCESS;
}
return this.ERROR;
}
public String doDetail() throws Exception {
Userinfo userinfo = userBiz.getUserinfoById(user.getUid());
request.setAttribute("userinfo", userinfo);
return "detail";
}
public String doUpdate() throws Exception {
int result = userBiz.updateUserinfo(user);
if(result>0){
return this.SUCCESS;
}
return this.ERROR;
}
public void setServletRequest(HttpServletRequest arg0) {
request=arg0;
}
}
这里我们每个方法都返回的是一个string类型的数据,这是因为structs2会根据该返回值来跳转到对应的界面。如果需要将数据传递到jsp页面来显示的话,可以使用request.setAttribute("list", list);这样的形式来传递。其他的没什么可说的了。
在spring的配置文件中配置action并设置biz
<!-- 配置Action,并注入Biz -->
<bean id="userAction" class="com.test.action.UserinfoAction">
<property name="userBiz" ref="userBiz"></property>
</bean>
这里我们是将structs2的action交给spring来管理。
配置structs2的配置文件structs.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"http://struts.apache.org/dtds/struts-2.3.dtd">
<struts>
<package name="sshDemo" extends="struts-default">
<!-- class="伪类(spring配置文件中action的id)" -->
<action name="user-*" class="userAction" method="{1}">
<result name="list">/list.jsp</result>
<result name="success" type="redirectAction">user-getAll</result>
<result name="error">/error.jsp</result>
<result name="detail">/detail.jsp</result>
</action>
</package>
</struts>
这里"package"标签的名称可以随便起,但是必须继承自"struts-default",action标签中的class是spring中配置的id,因为我们完全将action交给spring来处理了,我可看到我在这里利用"*"通配符和method="{1}"来匹配,什么意思呢?举个栗子,比如我传入的是"http://localhost:8080/xiangmuming/user-add.action",此时将会执行UserinfoAction.java类中的add方法,如果该方法返回"list"这个字符串,那么此时系统将会跳转到根目录下的"list.jsp"页面。
下面是时候编写我们的页面了。在web.xml中配置我的项目的默认主页面是index.jsp,如下:
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
我在index.jsp中创建一个连接,通过该连接可以查询所有的数据:
<a href="user-getAll.action">用户列表</a>
可以看到,"用户列表"会执行到UserInfoAction.java中的getAll方法,通过返回值和structs.xml分析,此方法会跳转到list.jsp,下面是list.jsp的代码:
<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ taglib uri="/struts-tags" prefix="s"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<body>
<table width="70%" align="center" border="1">
<tr>
<td>编号</td><td>用户名</td><td>密码</td><td>操作</td>
</tr>
<s:if test="#request.list.size==0">
<tr>
<td colspan="4">暂无用户信息!</td>
</tr>
</s:if>
<s:else>
<s:iterator value="#request.list" var="user">
<tr>
<td><s:property value="#user.uid"/> </td>
<td><s:property value="#user.uname"/></td>
<td><s:property value="#user.upass"/></td>
<td>
<a href="user-doDelete.action?user.uid=<s:property value="#user.uid"/>">删除 </a>
<a href="user-doDetail.action?user.uid=<s:property value="#user.uid"/>">修改</a></td>
</tr>
</s:iterator>
</s:else>
</table>
</body>
</html>
在list.jsp中使用了structs2的标签,因此需要导入struct2的标签"<%@ taglib uri="/struts-tags" prefix="s"%>"
在structs2标签中有<s:if>和<s:else>以及<s:iterator>等标签。
<s:if test="#request.list.size==0">
<tr>
<td colspan="4">暂无用户信息!</td>
</tr>
</s:if>
上面的if表示如果request中存在list的长度==0的情况,如果request中的list是有数据的:
<s:else>
<s:iterator value="#request.list" var="user">
<tr>
<td><s:property value="#user.uid"/> </td>
<td><s:property value="#user.uname"/></td>
<td><s:property value="#user.upass"/></td>
<td>
<a href="user-doDelete.action?user.uid=<s:property value="#user.uid"/>">删除 </a>
<a href="user-doDetail.action?user.uid=<s:property value="#user.uid"/>">修改</a></td>
</tr>
</s:iterator>
</s:else>
通过<s:iterator>标签来遍历list集合,这里和forech循环比较相似。user.uid,user.uname,user.upass是UserInfo中的属性。可以看到当我点击删除的时候,会跳转到UserInfoAction中的doDelete方法,删除的连接是跳转到doDetail方法。
运行截图:
![list列表](http://img.blog.csdn.net/20150502231957649)
[**源码下载**](http://download.csdn.net/detail/mockingbirds/8655299)
标签:springmvc hibernate structs2 s2sh
原文地址:http://blog.csdn.net/mockingbirds/article/details/45444793