集成方式1：核心
我们没有创建applicationContext-action.xml配置文件，在该配置文件里面让Spring去管理我们的AddUserAction，但是AddUserAction的创建却是Spring产生的，但是没有对AddUserAction进行管理，
AddUserAction中使用到的依赖对象，Spring默认会根据名称自动装配
在该方式中Spring创建action对象依赖于struts2-spring-plugin.jar，该struts2-spring-plugin.jar中 在struts2-spring-plugin.jar中有一个struts-plugin.xml，里面声明了action类由spring工厂创建
上面这个属性表示的就是action由Spring来进行创建
在我们集成struts2+spring+hibernate，也就是所谓的S2SH，不可避免的要引入struts2-spring-plugin.jar插件。当引入这个插件后，原先所struts创建的action类，交给了spring创建。在struts2-spring-plugin.jar中有一个struts-plugin.xml，里面声明了action类由spring工厂创建
我们来看下具体的操作步骤：
集成Struts2+Spring+Hibernate
第一种方案：让Spring创建Struts2的Action，不让Spring完全管理Struts2的Action
Struts2 Action中的依赖对象，默认会根据名称自动装配
1、创建web项目
2、引入Struts2的依赖包，将依赖包拷贝到WEB-INF/lib下
* commons-logging-1.0.4.jar
* freemarker-2.3.15.jar
* ognl-2.7.3.jar
* struts2-core-2.1.8.1.jar
* xwork-core-2.1.6.jar
* commons-fileupload-1.2.1.jar
3、引入Spring的依赖包，将依赖包拷贝到WEB-INF/lib下
* spring.jar
* lib/aspectj/*.jar
4、引入hibernate相关依赖包，将依赖包拷贝到WEB-INF/lib下
* hibernate3.jar
* lib/*.jar
5、数据库驱动
* MySQl JDBC Driver
6、将Struts2和Spring集成的依赖包拷贝到WEB-INF/lib下
* struts2-spring-plugin-2.1.8.1.jar
7、在web.xml文件中配置StrutsPrepareAndExecuteFilter
<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>
8、提供struts.xml配置文件，提供必要属性的配置
* struts.i18n.encoding=GB18030
* struts.configuration.xml.reload=true
* struts.devMode=true
9、提供Spring的配置文件
* applicationContext-service.xml
* applicationContext-dao.xml
* applicationContext-common.xml
10、提供hibernate.cfg.xml配置文件，提供log4j
11、在web.xml文件中配置Spring的ContextLoaderListener,创建BeanFactory
<context-param>
<param-name>contextConfigLocation</param-name>
<!--
<param-value>classpath:applicationContext-*.xml</param-value>
-->
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>、
11、在web.xml文件中配置OpenSessionInViewFilter（需要放到Struts2的Filter前面）
<filter>
<filter-name>OpenSessionInViewFilter</filter-name>
<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>OpenSessionInViewFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
12、提供用户添加表单和add_success.jsp
13、建立User实体类，编写hibernate映射文件，将映射文件加入到hibernate.cfg.xml中
14、建立UserDao和UserService，并进行实现
15、建立Struts2的Action，并配置到Struts2的配置文件中
16、在jsp中调用Action
17、我们没有创建applicationContext-action.xml配置文件，在该配置文件里面去管理我们的AddUserAction，但是AddUserAction的创建却是Spring产生的，但是没有对AddUserAction进行管理，
AddUserAction中使用到的依赖对象，Spring默认会根据名称自动装配
我们来看下整个项目的视图
首先来看配置文件
注意点：
第一hibernate的配置文件：
hibernate.cfg.xml
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">123456</property> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <property name="hibernate.show_sql">true</property> <property name="hibernate.hbm2ddl.auto">update</property> <mapping resource="/com/weiyuan/test/domain/User.hbm.xml"/> </session-factory> </hibernate-configuration>
表示要连接的数据库是test，用户名是root，密码是123456
如果使用的mysql必须配置 <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>表示在打印台输出创建的sql语言
Hibernate配置文件的hbm2ddl.auto属性
问题就出在我把hbm2ddl.auto的值设为create了，根据Hibernate的文档，hbm2ddl.auto有四个可选值：
值 定义
update 最常用的值，第一次加载hibernate时根据model类会自动建立起表的结构（前提是先建立好数据库），以后加载hibernate时根据 model类自动更新表结构，即使表结构改变了但表中的行仍然存在不会删除以前的行。要注意的是当部署到服务器后，表结构是不会被马上建立起来的，是要等 应用第一次运行起来后才会
validate 每次加载hibernate时，验证创建数据库表结构，只会和数据库中的表进行比较，不会创建新表，但是会插入新值
create 每次加载hibernate时都会删除上一次的生成的表，然后根据你的model类再重新来生成新表，哪怕两次没有任何改变也要这样执行
create-drop 每次加载hibernate时根据model类生成表，但是sessionFactory一关闭,表就自动删除
<mapping resource="/com/weiyuan/test/domain/User.hbm.xml"/> 表示通过实体类和数据库映射的配置文件，表示把/com/weiyuan/test/domain/User映射到数据库中的字段
当程序运行的时候，会自动运行加载hibernate.cfg.xml，和数据库进行连接，然后通过mapping 对于的配置文件，在数据库中创建对应的数据库表
2、配置Spring的配置文件
先在web.xml中进行配置
<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0"> <display-name>SSH_01</display-name> <welcome-file-list> <welcome-file>index.html</welcome-file> <welcome-file>index.htm</welcome-file> <welcome-file>index.jsp</welcome-file> <welcome-file>default.html</welcome-file> <welcome-file>default.htm</welcome-file> <welcome-file>default.jsp</welcome-file> </welcome-file-list> <!-- 需要配置在struct2的OpenSessionInView要放在struts2的过滤器的前面 --> <filter> <filter-name>OpenSessionInViewFilter</filter-name> <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class> </filter> <filter-mapping> <filter-name>OpenSessionInViewFilter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> <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> <!-- 配置spring的配置文件 --> <context-param> <param-name>contextConfigLocation</param-name> <!-- <param-value>classpath:applicationContext-*.xml</param-value> --> <param-value>classpath:applicationContext.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> </web-app>
web.xml配置了三种：
1、配置了struct2
<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>
2、配置了spring
<!-- 配置spring的配置文件 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<!--
<param-value>classpath:applicationContext-*.xml</param-value>
-->
<param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
3、配置了OpenSessionInViewFilter
该类主要实现Hibernate延迟加载，但是必须注意的是在web.xml中该类配置的顺序必须在配置struct2之前才有效果
不能写成
<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>
<filter>
<filter-name>OpenSessionInViewFilter</filter-name>
<filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>OpenSessionInViewFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
4、我们来分析下web.xml中对spring配置文件的理解
<!-- 配置spring的配置文件 --> <context-param> <param-name>contextConfigLocation</param-name> <!-- <param-value>classpath:applicationContext-*.xml</param-value> --> <param-value>classpath:applicationContext.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>
这里<param-value>classpath:applicationContext.xml</param-value> 表示要加载的配置文件的路径在当前classpath目录下，就是src目录下
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" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <import resource="applicationContext-service.xml"/> <import resource="applicationContext-dao.xml"/> <import resource="applicationContext-common.xml"/> </beans>
在该文件夹中加载applicationContext-service.xml，applicationContext-dao.xml，applicationContext-common.xml配置文件，就是在程序运行的时候就去加载这三个配置文件
applicationContext-service.xml该配置文件主要用于spring对mvc中的业务层serivice对象进行管理，所有的Service层都需要在该配置文件中配置
applicationContext-dao.xml该配置文件主要对mvc层中的数据库dao层进行配置管理
applicationContext-common.xml主要对一些常用的公共类进行配置和管理，一些常用的Utils工具类就在该文件中进行配置
3、现在我们来看看具体的实体类，先创建实体类，对应
package com.weiyuan.test.domain; public class User { private String userCode; private String userName; private String age; public String getUserCode() { return userCode; } public void setUserCode(String userCode) { this.userCode = userCode; } public String getUserName() { return userName; } public void setUserName(String userName) { this.userName = userName; } public String getAge() { return age; } public void setAge(String age) { this.age = age; } @Override public String toString() { return "User [userCode=" + userCode + ", userName=" + userName + ", age=" + age + "]"; } }
然后在该名下com.weiyuan.test.domain下创建对应的hibernate的配置文件，该配置文件为
配置文件必须和实体类在同一个包名下User.hbm.xml，中User必须和实体类的名字一样，hbm.xml后面是默认的
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="com.weiyuan.test.domain.User" table="t_user"> <id name="userCode"> <generator class="assigned"/> </id> <property name="userName"/> <property name="age"/> </class> </hibernate-mapping>
该文件的内容
property 属性的值必须和实体类的属性的名称一一对应
在hibernate中一个数据模型的主键常用有三种形式：uuid、native、assigned,分别是通用唯一标识、自增、自定义。
1、uuid是系统产生的，insert数据库时相比native要快很多，但是uuid是一长串无序字符串，理论上讲查找起来会慢一点，但是不太会影响开发的。而native是数据库生成，在insert时会先计算所以会比uuid慢一点，但是在查找和删除数据时，会比较方便。
2、uuid和assigned的生成是在程序中完成的，一个是自动，一个是手动。所以在进行session.save（）时，不会产生sql语句，数据库中也不会有数据。而native需要读取数据库数据才能完成自动递增，所以在执行session.save（）时，就会产生相应的sql语句，数据库中就会有数据（缓存中id是有值的）。
这样当程序运行的就会在数据库中创建t_user这张表
CREATE TABLE `t_user` ( `userCode` varchar(255) NOT NULL, `userName` varchar(255) default NULL, `age` varchar(255) default NULL, PRIMARY KEY (`userCode`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
4、创建dao类
package com.weiyuan.test.dao; import com.weiyuan.test.domain.User; public interface UserDao { public void add(User user) ; }
对应的实现类为：
package com.weiyuan.test.dao; import org.springframework.orm.hibernate3.support.HibernateDaoSupport; import com.weiyuan.test.domain.User; /** * * 继承：HibernateDaoSupport中使用到了sessionFactroy * 我们需要在配置文件中使用spring自动产生sessionFactroy * 我们需要在配置文件中使用spring自动产生UserDaoImpl * */ public class UserDaoImpl extends HibernateDaoSupport implements UserDao { /** * 需要hibernate的sessionFactory将用户添加到数据库中 * */ @Override public void add(User user) { // TODO Auto-generated method stub getHibernateTemplate().save(user); } }
该实现类继承了HibernateDaoSupport ，然后将对象插入到数据库表t_user中
由于Hibernate集成了JDBC，所以在访问数据库时，与直接使用JDBC访问数据库相比，Hibernate在连接、访问数据库时的代码减少了很大一大半。但由此而来也相应必须增加访问Hibernate配置文件和SessionFactory、Session的打开、关闭的代码。为了解决以上相同代码出现的复用问题，Hibernate对此又进行了再一次封装，于是，幸运地出现了HibernateDaoSupport。因此，在使用HibernateDaoSupport模板对数据库访问时，更加方便、简单，特别是进行简单的增删改查。 下面是我自己写的一点代码参考： /** * @author wifygoo * 对企业信息的简单增删改查。 */ public class EnterpriseDaoImpl extends HibernateDaoSupport implements EnterpriseDao { /** * @param Enterprise * 删除某条企业信息。 */ public void del(Enterprise enterprise) { this.getHibernateTemplate().delete(enterprise); } /** * @return 所有的企业信息。 * 查询所有的企业信息。 */ @SuppressWarnings("unchecked") public List<Enterprise> findAllEnterprises() { String hql = "from Enterprise enterprise"; return this.getHibernateTemplate().find(hql); } /** * @param Integer，企业编号。 * @return 某个企业信息。 * 通过企业编号查询企业信息。 */ public Enterprise findEnterpriseById(Integer id) { return (Enterprise) this.getHibernateTemplate().load(Enterprise.class, id); } /** * @param Enterprise * 添加企业信息。 */ public void save(Enterprise enterprise) { this.getHibernateTemplate().save(enterprise); } /** * @param Enterprise * 修改企业信息。 */ public void update(Enterprise enterprise) { this.getHibernateTemplate().update(enterprise); } }
使用借助于HibernateTemplate的模板访问方式访问数据库，大大减少了代码，但是必须依赖于SessionFactory这个对象，这个SessionFactory对象的产生我们可以让Spring来给我们产生，并对该对象进行管理，我们可以在上面创建的applicationContext-common.xml来产生了管理SessionFactory这个对象
applicationContext-common.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" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <!-- 配置SessionFactory --> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation" value="classpath:hibernate.cfg.xml"/> </bean> <!-- 配置事务管理器 --> <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/> </bean> <!-- 配置事务的传播特性（配置Advice） --> <tx:advice id="txAdvice" transaction-manager="transactionManager"> <tx:attributes> <tx:method name="add*" propagation="REQUIRED" rollback-for="java.lang.Exception"/> <tx:method name="del*" propagation="REQUIRED" rollback-for="java.lang.Exception"/> <tx:method name="update*" propagation="REQUIRED" rollback-for="java.lang.Exception"/> <tx:method name="*" propagation="REQUIRED" read-only="true"/> </tx:attributes> </tx:advice> <!-- 配置哪些类的哪些方法使用事务（配置事务边界，配置Pointcut） --> <aop:config> <aop:pointcut id="allManagerMethod" expression="execution(* com.weiyuan.test.service.*.*(..))"/> <aop:advisor pointcut-ref="allManagerMethod" advice-ref="txAdvice"/> </aop:config> </beans>
上面这个配置文件有两个地方需要注意的：
<property name="configLocation" value="classpath:hibernate.cfg.xml"/> 加载hibernate配置文件的路径和名称是当前的src目录下
<aop:pointcut id="allManagerMethod" expression="execution(* com.weiyuan.test.service.*.*(..))"/>事务有效的函数的名称是在所有的包名下com.weiyuan.test.service的函数调用dao层访问数据库事务都有效
然后在applicationContext-dao.xml对dao进行配置，让Spring进行管理和配置
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <bean id="userDao" class="com.weiyuan.test.dao.UserDaoImpl"> <property name="sessionFactory" ref="sessionFactory"/> </bean> </beans>
上面就是创建userDao对象的时候，因为该对象继承了HibernateDaoSupport ，创建HibernateDaoSupport 对象的时候需要使用到sessionFactory对象，所以上面ref了applicationContext-common.xml中配置的sessionFactory对象
5、编写Service业务操作类
package com.weiyuan.test.service; import com.weiyuan.test.domain.User; public interface UserService { public void add(User user); }
实现类：
package com.weiyuan.test.service; import com.weiyuan.test.dao.UserDao; import com.weiyuan.test.domain.User; public class UserServiceImpl implements UserService { /** * 记得在applicationContext-service.xml配置使用Spring自动产生UserDao类 * */ private UserDao userDao; @Override public void add(User user) { // TODO Auto-generated method stub userDao.add(user); } public UserDao getUserDao() { return userDao; } public void setUserDao(UserDao userDao) { this.userDao = userDao; } }
现在我们要在applicationContext-service.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" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> <bean id="userService" class="com.weiyuan.test.service.UserServiceImpl"> <property name="userDao" ref="userDao"/> </bean> </beans>
5、接下来创建文明的action
package com.weiyuan.test.web.action; import com.weiyuan.test.domain.User; import com.weiyuan.test.service.UserService; public class AddUserAction { private User user; /** * 这里的名字必须和applicationContext-service.xml中配置的名字一一对应起来 * <bean id="userService" class="com.weiyuan.test.service.UserServiceImpl"> * */ private UserService userService; public User getUser() { return user; } public void setUser(User user) { this.user = user; } public UserService getUserService() { return userService; } public void setUserService(UserService userService) { this.userService = userService; } public String execute() throws Exception{ System.out.println(""+user.toString()); userService.add(user); return "sucess"; } }
这里action的创建和管理就没有单独的applicationContext-action.xml对其进行配置，因为引入了
它会由spring自动创建action对象，但是不会对action对象进行管理，
我们没有创建applicationContext-action.xml配置文件，在该配置文件里面让Spring去管理我们的AddUserAction，但是AddUserAction的创建却是Spring产生的，但是没有对AddUserAction进行管理，
AddUserAction中使用到的依赖对象private UserService userService;，Spring默认会根据名称自动装配，名称必须和
这里的名字必须和applicationContext-service.xml中配置的名字一一对应起来
* <bean id="userService" class="com.weiyuan.test.service.UserServiceImpl">
文明来看看struct.xml对action的配置
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd"> <struts> <constant name="struts.i18n.encoding" value="GB18030"/> <constant name="struts.configuration.xml.reload" value="true"/> <constant name="struts.devMode" value="true"/> <package name="user" extends="struts-default" > <action name="add" class="com.weiyuan.test.web.action.AddUserAction"> <result name="sucess">/add_success.jsp</result> </action> </package> </struts>
文明来看看index.jsp文件，该文件就是程序的入口文件
<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%> <% String path = request.getContextPath(); String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/"; %> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> <html> <head> </head> <body> <form action="add.action" method="post"> 用户代码：<input type="text" name="user.userCode"><br> 用户姓名：<input type="text" name="user.userName"><br> 年龄：<input type="text" name="user.age"><br> <input type="submit" value="添加"> </form> </body> </html>
添加用户成功的页面：
add_success.jsp
代码下载地址为：
https://pan.baidu.com/s/1bVF9pG