整合Struts2、Hibernate4.3和Spring4.2

整合Struts2、Hibernate4.3和Spring4.2

===================================================================

2016年netty/mina/java nio视频教程java游戏服务器设计教程

互联网架构师教程： http://blog.csdn.net/pplcheer/article/details/71887910

互联网架构师视频课程 Dubbo ActiveMQ spring Netty MongoDB Jvm :http://blog.csdn.net/pplcheer/article/details/72794970

需要的加qq：1225462853，备注：程序员学习视频

其他视频都可以索要（Netty   NET    C++ 等等）

===================================================================

 

主要总结一下如何整合Struts2、Hibernate4.3和Spring4.2。
整合三大框架得先从搭建各部分环境开始，也就是说首先得把spring，hibernate和Struts2的环境搭建好，确保它们没有问题了，再做整合。
这篇博文遵从的顺序是：先搭建Spring环境-->然后搭建Hibernate环境--> 整合Spring和Hibernate --> 搭建Struts2环境 --> 整合Spring和Struts2。

代码下载：http://download.csdn.net/detail/pplsunny/9798207

1. 整个项目jar包的管理

Spring的jar包很多，开发的时候建议将它们分个类，然后依次添加到User Library，方便管理，也一目了然。这里我总结一下整个SSH所需要的基本jar包，看下图：

最终项目结构如下：

2.搭建Spring环境

上面的jar包截图是最后整合好的所有jar包，刚开始搭建环境的时候不需要一次性全部加进来，可以一点一点的加，这样也更利于理解每个部分的jar包都有什么作用，当然，一次都加进来也是可以的。

2.1 添加配置文件beans.xml和相应的jar包

新建一个工程，然后添加在User Library中添加自己的库，这里主要添加两个，即spring-4.2.4-core和spring4.2.4-aop，添加jar包不再赘述。添加完了后，在src目录下添加beans.xml文件，这个文件的模板网上很多，Spring自带的例子里也有，考一份过来就行，见下图：

2.2 测试Spring的IoC环境

我们写一个普通的Java类java.util.Date类来测试一下Spring IoC是否正常，如果在测试程序中能正常注入，则说明Spring的IoC环境搭建成功，下面我们写一个测试用例：

/**
* com.ppl.test.SSHTest.java
* @author 作者 : pplsunny
* @version 创建时间：2017年3月28日 下午9:34:23
* 类说明
*/
package com.ppl.test;

import java.util.Date;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.ppl.model.Category;
import com.ppl.service.CategoryService;
import com.ppl.service.impl.CategoryServiceImpl;


/* 
 * Spring3.1后多了个spring-test-4.2.4.RELEASE.jar包，这个jar包专门用来支持JUnit基于注解的测试的，该jar包在spring-4.2.4-core中 
 * 该jar包里有个SpringJUnit4ClassRunner.class，用@RunWith注解加进来即可 
 *  
 * 注解@ContextConfiguration表示将ApplicationContext对象注入进来，就不用像以往那样在测试程序里先new了，直接使用 
 */  
@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(locations="classpath:beans.xml")  
public class SSHTest {  
      
    @Resource  
    private Date date;
    @Resource
    private CategoryService categoryService;
      
    @Test //测试Spring IOC的开发环境  
    public void springIoc() {  
        System.out.println(date);  
    } 

    @Test  //测试Hibernate的开发环境，因为没有整合，可以直接new  
    public void hihernateTest() {  
        CategoryService categoryService = new CategoryServiceImpl();  
        Category category = new Category("PPLSUNNY", true);  
        categoryService.save(category);  
    } 
    
	@Test //测试Hibernate和Spring整合后
	public void hibernateAndSpring() {
		categoryService.update(new Category(1, "SUNNY", true)); //categoryService通过Spring从上面注入进来的
	}
}  

最后能正常输出：Wed Mar 29 21:51:45 CST 2017。说明Date对象已经被Spring给注入进来了，从而验证了Spring IoC功能正常，为此，Spring的环境搭建完成。

3. 搭建Hibernate环境

Hibernate的环境搭建相比于Spring要复杂一些，因为用到了MyEclipse中的逆向工程。我们按以下步骤来搭建Hibernate开发环境：

3.1 添加相应的jar包

这里主要是向User Library中添加两项jar包：hibernate4.3.11和MySQL驱动包mysql-connector-java-5.1.26，不再赘述。

3.2 新建数据库和表

drop database if exists shop;
create database shop default character set utf8;
use shop;
drop table if exists category;
create table category
(
   /* 类别编号，自动增长 */
   id  int not null auto_increment,
   /* 类别名称 */
   type varchar(20),
   /* 类别是否为热点类别，热点类别才有可能显示在首页*/
   hot  bool default false,
   /* 设置类别编号为主键*/
   primary key (id)
);

3.3 创建xml映射文件和sessionFactory

我们简单看一下创建的sessionFactory

/**
 * 
 */

package com.ppl.utils;

import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;

/**
* com.ppl.utils.HibernateSessionFactory.java
* @author 作者 : pplsunny
* @version 创建时间：2017年3月28日 下午9:53:50
* 类说明
*/
public class HibernateSessionFactory {  
    
    private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>(); //sessionFactory中用的是线程池技术  
    private static org.hibernate.SessionFactory sessionFactory; //sessionFactory：创建session的工厂  
      
    private static Configuration configuration = new Configuration();  
    private static ServiceRegistry serviceRegistry;   
  
    static { //类加载时初始化sessionFactory  
        try {  
        configuration.configure();  
        serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();  
        sessionFactory = configuration.buildSessionFactory(serviceRegistry); //Hibernate4中创建sessionFactory的方法  
    } catch (Exception e) {  
        System.err.println("%%%% Error Creating SessionFactory %%%%");  
        e.printStackTrace();  
    }  
    }  
    private HibernateSessionFactory() { //私有构造方法阻止new出对象，保证sessionFactory的单例  
    }  
      
    public static Session getSession() throws HibernateException {  
        Session session = (Session) threadLocal.get();  //从线程池中拿session  
  
        if (session == null || !session.isOpen()) { //如果线程池是空的，或者session打开失败  
            if (sessionFactory == null) {  
                rebuildSessionFactory(); //如果sessionFactory是空的，那就再创建一次，和static部分一样的  
            }  
            session = (sessionFactory != null) ? sessionFactory.openSession() : null; //sessionFactory不为空就创建一个session  
            threadLocal.set(session); //然后把这个session放到线程池中，下次再拿  
        }  
  
        return session;  
    }  
  
    public static void rebuildSessionFactory() {  
    try {  
        configuration.configure();  
        serviceRegistry = new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();  
        sessionFactory = configuration.buildSessionFactory(serviceRegistry);  
    } catch (Exception e) {  
        System.err.println("%%%% Error Creating SessionFactory %%%%");  
        e.printStackTrace();  
    }  
    }  
  
    public static void closeSession() throws HibernateException {  
        Session session = (Session) threadLocal.get();  
        threadLocal.set(null);  
  
        if (session != null) {  
            session.close();  
        }  
    }  
  
    public static org.hibernate.SessionFactory getSessionFactory() {//提供一个公共接口让外界获得这个单例sessionFactory  
    return sessionFactory;  
    }  
  
    public static Configuration getConfiguration() {  
    return configuration;  
    }  
  
}  

hibernate.cfg.xml

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<!-- Generated by MyEclipse Hibernate Tools.                   -->
<hibernate-configuration>

	<session-factory>
		<property name="dialect">
			org.hibernate.dialect.MySQLDialect
		</property>
		
			<property name="connection.url">
			jdbc:mysql://localhost:3306/shop
			</property>
			<property name="connection.username">ppl</property>
			<property name="connection.password">1qazxsw2</property>
			<property name="connection.driver_class">
			com.mysql.jdbc.Driver
			</property>
	
		<property name="show_sql">true</property>
		<mapping class="com.ppl.model.Category" />

	</session-factory>

</hibernate-configuration>

3.4 通过逆向工程生成model（基于注解的，orm映射文件提供另一个参考）

package com.ppl.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

/**
 * Category entity. @author MyEclipse Persistence Tools
 */
@Entity
public class Category implements java.io.Serializable {

	// Fields

	private Integer id;
	private String type;
	private Boolean hot;

	/** default constructor */
	public Category() {
	}

	@Override
	public String toString() {
		return "Category [id=" + id + ",  type=" + type + ", hot=" + hot + "]";
	}

	public Category(Integer id, String type, Boolean hot) {
		super();
		this.id = id;
		this.type = type;
		this.hot = hot;
	}

	public Category(String type, Boolean hot) {
		super();
		this.type = type;
		this.hot = hot;
	}

	// Property accessors
	@Id
	@GeneratedValue
	@Column(name = "id", unique = true, nullable = false)
	public Integer getId() {
		return this.id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	@Column(name = "type", length = 20)
	public String getType() {
		return this.type;
	}

	public void setType(String type) {
		this.type = type;
	}

	@Column(name = "hot")
	public Boolean getHot() {
		return this.hot;
	}

	public void setHot(Boolean hot) {
		this.hot = hot;
	}

}

User.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>
	<!-- 1 配置类和表对应 
		class标签
		name属性：实体类全路径
		table属性：数据库表名称
	-->
	<class name="cn.itcast.entity.User" table="t_user">
		<!-- 2 配置实体类id和表id对应 
			hibernate要求实体类有一个属性唯一值
			hibernate要求表有字段作为唯一值
		-->
		<!-- id标签
			name属性：实体类里面id属性名称
			column属性：生成的表字段名称
		 -->
		<id name="uid" column="uid">
			<!-- 设置数据库表id增长策略 
				native:生成表id值就是主键自动增长
			-->
			<generator class="uuid"></generator>
		</id>
		<!-- 配置其他属性和表字段对应 
			name属性：实体类属性名称
			column属性：生成表字段名称
		-->
		<property name="username" column="username"></property>
		<property name="password" column="password"></property>
		<property name="address" column="address"></property>
	</class>
</hibernate-mapping>

完成后，查看Category的model类，同时在hibernate.cfg.xml文件中添加相应的映射（基于配置文件方式），前面基于配置文件的和基于注解的在hibernate.cfg.xml中生成的映射时不同的。

3.5 测试Hibernate持久化数据库

因为这里还没有与Spring整合，只是单纯的搭建Hibernate开发环境，所以我们没有必要使用注解，我们通过直接new一个service的方式执行数据入库。
先写CategoryService接口和实现类：

/**
 * 
 */

package com.ppl.service;

import com.ppl.model.Category;

/**
 * com.ppl.service.CategoryService.java
 * 
 * @author 作者 : pplsunny
 * @version 创建时间：2017年3月28日 下午9:56:46 类说明
 */
public interface CategoryService {
	public void save(Category category); // 用来测试Hibernate环境

	public void update(Category category);// 用来测试Spring和Hibernate整合后
}

/**
 * 
 */

package com.ppl.service.impl;

import org.hibernate.Session;
import org.hibernate.SessionFactory;

import com.ppl.model.Category;
import com.ppl.service.CategoryService;
import com.ppl.utils.HibernateSessionFactory;

/**
 * com.ppl.service.CategoryServiceImpl.java
 * 
 * @author 作者 : pplsunny
 * @version 创建时间：2017年3月28日 下午9:57:27 类说明
 */
public class CategoryServiceImpl implements CategoryService {

	@Override // 没有和Spring整合的情况
	public void save(Category category) {
		// 通过工具类获取session
		Session session = HibernateSessionFactory.getSession();
		try {
			// 手动事务
			session.getTransaction().begin();
			// 执行业务逻辑
			session.save(category);
			// 手动提交
			session.getTransaction().commit();
		} catch (Exception e) {
			session.getTransaction().rollback();
			throw new RuntimeException(e);
		} finally {
			HibernateSessionFactory.closeSession();
		}

	}

	/* Spring和Hibernate整个后 */
	private SessionFactory sessionFactory; // 定义一个sessionFactory

	// 当需要使用sessoinFactory的时候，Spring会将sessionFactory注入进来
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}

	protected Session getSession() {
		// 从当前线程获取session，如果没有则创建一个新的session
		return sessionFactory.getCurrentSession();
	}

	@Override // Spring和Hibernate整合后的情况
	public void update(Category category) {
		getSession().update(category);
	}
}

上面在刚刚的测试用例中添加对Hibernate的测试：

    @Test  //测试Hibernate的开发环境，因为没有整合，可以直接new  
    public void hihernateTest() {  
        CategoryService categoryService = new CategoryServiceImpl();  
        Category category = new Category("PPLSUNNY", true);  
        categoryService.save(category);  
    } 

我们查看数据库，发现多了刚刚插入的这项，说明Hibernate环境没有问题。至此，Hibernate的开发环境我们就搭建好了。

4. 整合Spring和Hibernate

搭建好了Spring和Hibernate的开发环境后，我们开始整合这两者。整合Spring和Hibernate后就可以使用AOP让Spring来管理Hibernate的事务了。整合Spring和Hibernate主要从两大方面入手，一是导入必要的jar包，二是配置beans.xml文件。下面我们一步步整合Spring和Hibernate。

4.1 导入相应的jar包

整合Spring和Hibernate时需要导入的jar包有两大块，spring4.2.4-persistence和c3p0-0.9.5.1，每一块jar包中的具体jar文件请参见上面的截图，这里不再赘述。下面开始配置beans.xml文件了。

4.2 配置数据源dataSource

首先配置一下dataSource，然后hibernate.cfg.xml中相应的部分可以干掉了。因为在Spring中配置好了，Spring会去初始化这个dataSource，也就是说这就交给Spring来完成了，hibernate.cfg.xml中的相应部分可以删掉了。如下：

beans.xml

	<!--############################## 整合Spring和Hibernate START################################ -->
	<!-- 所有的properties文件应该交给Spring管理，而且在启动的时候加载 Spring支持两种方式，property-placeholder仅仅在xml中使用，即在beans.xml中获取properties文件中的对应的value -->
	<!-- <context:property-placeholder location="classpath:conn.properties"/> -->
	<!-- 与下面的配置等价，下面的更容易理解 -->
	<bean
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<array>
				<!-- <value>classpath:remote.properties</value> -->
				<value>classpath:conn.properties</value>
			</array>
		</property>
	</bean>
	<!-- com.mchange.v2.c3p0.ComboPooledDataSource类在c3p0-0.9.5.1.jar包的com.mchange.v2.c3p0包中 -->
	<bean id="dataSource" class="${dataSource}">
		<property name="driverClass" value="${driverClass}" />
		<property name="jdbcUrl" value="${jdbcUrl}" />
		<property name="user" value="${user}" />
		<property name="password" value="${password}" />
	</bean>

hibernate.cfg.xml

<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 
<hibernate-configuration>

	<session-factory>
		<property name="dialect">
			org.hibernate.dialect.MySQLDialect
		</property>
	<!--  
			<property name="connection.url">
			jdbc:mysql://localhost:3306/shop
			</property>
			<property name="connection.username">ppl</property>
			<property name="connection.password">1qazxsw2</property>
			<property name="connection.driver_class">
			com.mysql.jdbc.Driver
			</property>
	-->	
		<property name="show_sql">true</property>
		<mapping class="com.ppl.model.Category" />

	</session-factory>

</hibernate-configuration>

4.3 配置sessionFactory

配置sessionFactory是用来产生一个session的，另外HibernateTemplate也可以，但是这里采用sessionFactory而不用HibernateTemplate，是因为HibernateTemplate是Spring提供的，依赖于Spring，如果哪天不用Spring了，就会报错。而sessionFactory是Hibernate提供的，没有问题。HibernateTemplate的依赖性太强了。下面看一下具体配置：

	<!-- 配置sessionFactory -->
	<!-- org.springframework.orm.hibernate4.LocalSessionFactoryBean类在spring-orm-4.2.4.RELEASE.jar包的org.springframework.orm.hibernate4包中 -->
	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="configLocation" value="classpath:hibernate.cfg.xml" /> <!-- 加载hibernate配置文件 -->
	</bean>

sessionFactory中的dataSource我们用刚刚配好的dataSource，用ref属性引用进来即可，configLocation我们不在这配了，直接加载hibernate.cfg.xml文件，使用hibernate配置文件中的配置，更加简洁方便。

4.4 配置事务管理器

配置事务管理器，是用来管理sessionFactory的，这样所有的由sessionFactory产生的session将会有声明式的管理。配置如下：

	<!-- 配置事务管理器，配置事务管理器，是用来管理sessionFactory的，这样所有的由sessionFactory产生的session将会有声明式的管理 -->

	<!-- org.springframework.orm.hibernate4.HibernateTransactionManager类spring-orm-4.2.4.RELEASE.jar包的org.springframework.orm.hibernate4包中 -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate4.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

同样，sessionFactory我们用刚刚配置好的sessionFactory，用ref属性引用进来即可。到这里就会发现，从上面一直配下来，都是一连串的操作，一个个引用下来。

4.5 配置advice（通知）

配置advice的目的是指定哪些方法需要什么类型的事务模式。看配置：

	<!--配置advice（通知），配置advice的目的是指定哪些方法需要什么类型的事务模式。REQUIRED表示如果存在事务，则支持当前的事务，如果没有则创建一个新的事务，这个事务模式应用在所有以save、update和delete开头的方法上，也就是说对数据库的增删改的时候需要添加事务支持。SUPPORTS表示如果存在事务，则支持当前的事务，如果没有就算了 -->

	<tx:advice id="advice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="save*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="delete*" propagation="REQUIRED" />
			<tx:method name="*" propagation="SUPPORTS" />
		</tx:attributes>
	</tx:advice>

REQUIRED表示如果存在事务，则支持当前的事务，如果没有则创建一个新的事务，这个事务模式应用在所有以save、update和delete开头的方法上，也就是说对数据库的增删改的时候需要添加事务支持。SUPPORTS表示如果存在事务，则支持当前的事务，如果没有就算了。

4.6 配置AOP切面

	<!--配置AOP切面 -->
	<aop:config>
		<!-- 配置哪些包的类要切入事务 -->
		<aop:pointcut id="pointcut"
			expression="execution(* com.ppl.service.impl.*.*(..))" />
		<aop:advisor advice-ref="advice" pointcut-ref="pointcut" /><!-- 
			连接了上面的advice和上面的pointcut -->
		<!-- 出现一个很奇怪的问题，aop:pointcut要写在aop:advisor上面，否则会报错 -->
	</aop:config>
	<!--############################## 整合Spring和Hibernate END################################ -->
	

AOP即面向切面编程，aop:pointcut定义一个切面，expression属性中配置的意思是所有cn.it.shop.service.impl包下的所有方法，不管返回值和参数是什么，都要切入事务。该包是属于dao层的，直接操作数据库的。aop:advice将通知和切面结合起来，我们直接使用上面配置好的advice和pointcut，将其引入进来即可。这样配置好了后，意思就是说，凡是cn.it.shop.service.impl包下的方法都需要切入事务管理，具体地，以save、update、delete开头的方法使用REQUIED方式，其他方法使用SUPPORTS方式。这样就很好理解这个配置的意思了。

4.7 测试整合结果

之前搭建Hibernate环境的时候，我们测试是直接new了一个Service来操作数据库，因为当时还没有和Spring整合。现在通过配置beans.xml后，让Spring去管理Hibernate的事务了，所以现在的测试要把Service交给Spring管理，通过Spring注入进来，并且依赖sessionFactory，如果能插入数据到数据库，则说明声明事务OK。
首先，我们要在Spring的配置文件beans.xml中配一下这个Service：

	<bean id="categoryService" class="com.ppl.service.impl.CategoryServiceImpl">
		<property name="sessionFactory" ref="sessionFactory" /><!-- 依赖的sessionFactory用我们之前配好的sessionFactory -->
	</bean>

其次，我们需要在CategoryService接口和它的实现类CategoryServiceImpl中增加一个方法用来测试整合后的情况：上面已经给出对应代码。

现在我们可以去测试类中增添测试方法，来测试Spring和Hibernate整合后的结果了：

/**
* com.ppl.test.SSHTest.java
* @author 作者 : pplsunny
* @version 创建时间：2017年3月28日 下午9:34:23
* 类说明
*/
package com.ppl.test;

import java.util.Date;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.ppl.model.Category;
import com.ppl.service.CategoryService;
import com.ppl.service.impl.CategoryServiceImpl;


/* 
 * Spring3.1后多了个spring-test-4.2.4.RELEASE.jar包，这个jar包专门用来支持JUnit基于注解的测试的，该jar包在spring-4.2.4-core中 
 * 该jar包里有个SpringJUnit4ClassRunner.class，用@RunWith注解加进来即可 
 *  
 * 注解@ContextConfiguration表示将ApplicationContext对象注入进来，就不用像以往那样在测试程序里先new了，直接使用 
 */  
@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(locations="classpath:beans.xml")  
public class SSHTest {  
      
    @Resource  
    private Date date;
    @Resource
    private CategoryService categoryService;
      
    @Test //测试Spring IOC的开发环境  
    public void springIoc() {  
        System.out.println(date);  
    } 

    @Test  //测试Hibernate的开发环境，因为没有整合，可以直接new  
    public void hihernateTest() {  
        CategoryService categoryService = new CategoryServiceImpl();  
        Category category = new Category("PPLSUNNY", true);  
        categoryService.save(category);  
    } 
    
	@Test //测试Hibernate和Spring整合后
	public void hibernateAndSpring() {
		categoryService.update(new Category(1, "SUNNY", true)); //categoryService通过Spring从上面注入进来的
	}
}  

然后我们查看数据库，发现id=1的category被修改成了SUNNY了，说明更新成功。至此，Spring和Hibernate整合成功。

5. 搭建Struts2环境

5.1 添加相应的配置和jar包

struts2运行所需的jar包我放在struts2.3.41的Library中了，直接引入即可，不再赘述。另外，还要对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_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>E_shop</display-name>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  
  <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>*.action</url-pattern>
  </filter-mapping>
  
</web-app>

 如上，我们配置了一个StrutsPrepareAndExecuteFilter过滤器，并将过滤器的url-pattern设置为*.action，即所有.action后缀的都会首先经过这个过滤器，这也是struts2的入口处。

5.2 创建Action并且配置到struts.xml文件中

我们创建一个Action如下：

/**
 * 
 */

package com.ppl.action;

import com.opensymphony.xwork2.ActionSupport;
import com.ppl.service.CategoryService;

/**
 * com.ppl.action.CategoryAction.java
 * 
 * @author 作者 : pplsunny
 * @version 创建时间：2017年3月29日 下午9:12:03 类说明
 */
public class CategoryAction extends ActionSupport {

	// 设置categoryService是为了很直观的看出与Spring整合前后的不同
	private CategoryService categoryService;


	public void setCategoryService(CategoryService categoryService) {
		this.categoryService = categoryService;
	}

	public String update() {
		System.out.println("----update----");

		System.out.println(categoryService);

		return "index";
	}

	public String save() {
		System.out.println("----save----");
		System.out.println(categoryService);
		return "index";
	}

}

然后我们配置struts.xml文件，该文件放在src目录下：

<?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="shop" extends="struts-default">
		<!-- category_update.actiocan： 访问update方法 -->
		<action name="category_*" class="com.ppl.action.CategoryAction" method="{1}">
			<result name="index">/index.jsp</result>
		</action>
	</package>

</struts>

5.3 测试Struts2环境

测试方法是：写一个jsp访问Action，如果Action可以创建，则表示struts2环境OK。即struts2的一连串流程可以正常走完：jsp-->struts.xml-->Action-->struts.xml-->jsp，这样struts2的环境就算搭好了。我们写一个简单的index.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
          <title>TEST DEMO</title> 
  </head>
  
  <body>
         <!-- 下面两种写法都可以访问 -->
         <a href="${pageContext.request.contextPath}/category_update.action">访问update</a>
         <a href="category_save.action">访问save</a>
         <a href="${pageContext.request.contextPath}/category_update.action?category.id=1&category.type=gga&category.hot=false">访问update</a>
  </body>
</html>

 然后我们部署以下工程，打开tomcat服务器，在浏览器中输入：http://localhost:8080/E_shop/index.jsp后，能出现正常jsp页面，然后点击两个按钮，仍然跳转到index.jsp，然后我们看一下控制台的输出信息：

----update----
null
----save----
null

说明struts2的一条线走完了，环境没有问题，至此，struts2开发环境搭建完毕。
我们看控制台输出了null，也就是说categoryService是空，也就是说根本没拿到categoryService，因为我们没有和Spring进行整合，没有被注入进来，所以null是正常的。我们沿着控制台输出的信息往上翻，会发现一条信息：Choosing bean (struts) for (com.opensymphony.xwork2.ObjectFactory)。括号里是struts说明没有和Spring整合前，Action是有Struts2产生的。

6. Spring和Struts2整合

6.1 添加相应的jar包

Spring与Struts2整合时的jar包主要在spring4.2.4-web里面，里面包括struts2-spring-plugin-2.3.24.1.jar，导包不再赘述。

6.2 把Action和它的依赖交给Spring管理

在Spring的配置文件beans.xml中配置Action和它的依赖，我们目前只有一个Action，配置如下所示：

	<bean id="categoryAction" class="com.ppl.action.CategoryAction"
		scope="prototype">
		<property name="categoryService" ref="categoryService" /> <!-- 依赖的categoryService用上面和Hibernate整合时配置好的categoryService -->
	</bean>

6.3 修改struts.xml中的配置

原来在struts.xml中，class属性对应的是具体Action的完全限定名，现在将class属性的值改为Spring中配置action的id值，即categoryAction，如下：

<?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="shop" extends="struts-default">
		<!-- category_update.actiocan： 访问update方法 -->
		<action name="category_*" class="categoryAction" method="{1}">
			<result name="index">/index.jsp</result>
		</action>
	</package>

</struts>

6.4 配置监听器

在web.xml中配置监听器ContextLoaderListener，这样在服务器启动的时候就可以加载Spring的配置文件了。如下：

<?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_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>E_shop</display-name>
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
  
  <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>*.action</url-pattern>
  </filter-mapping>
  
    <!-- web.xml中监听器的启动优先级要高于过滤器，所以配在下面无所谓的 -->
  <listener>
  	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  
  <context-param>
  	<param-name>contextConfigLocation</param-name>
  	<param-value>classpath:beans.xml</param-value>
  </context-param>
  
</web-app>

6.5 测试整合结果

我们在Action中新加一句更新数据库的语句，如下：

package com.ppl.action;

import com.opensymphony.xwork2.ActionSupport;
import com.ppl.model.Category;
import com.ppl.service.CategoryService;

/**
 * com.ppl.action.CategoryAction.java
 * 
 * @author 作者 : pplsunny
 * @version 创建时间：2017年3月29日 下午9:12:03 类说明
 */
public class CategoryAction extends ActionSupport {

	// 设置categoryService是为了很直观的看出与Spring整合前后的不同
	private CategoryService categoryService;

	// 设置一个私有成员变量接收url带过来的参数，注意下面要写好get和set方法
	private Category category;

	public void setCategoryService(CategoryService categoryService) {
		this.categoryService = categoryService;
	}

	public String update() {
		System.out.println("----update----");

		// 由于已经和Spring整合，所以可以拿到这个categoryService了，打印出来就不是null了
		System.out.println(categoryService);

		// 新加一条语句，来更新数据库
		categoryService.update(category);
		return "index";
	}

	public String save() {
		System.out.println("----save----");
		System.out.println(categoryService);
		return "index";
	}

	public Category getCategory() {
		return category;
	}

	public void setCategory(Category category) {
		this.category = category;
	}
}

 然后我们部署以下工程，打开tomcat服务器，在浏览器中输入：http://localhost:8080/E_shop/index.jsp后，能出现正常jsp页面，然后点击“访问update”按钮，仍然跳转到index.jsp，然后我们看一下控制台的输出信息：

----update----
com.ppl.service.impl.CategoryServiceImpl@4ccc407
Hibernate: update Category set hot=?, type=? where id=?

我们看到可以输出categoryService这个对象的信息了，也可以输出执行update语句时的SQL语句，然后我们查询一下数据库，发现id=2的数据的type被更新为gga，hot更新为false。我们沿着控制台输出的信息往上翻，会发现一条信息：Choosing bean (spring) for (com.opensymphony.xwork2.ObjectFactory)，括号里为spring，与上面的情况对比可知，Struts2在与Spring整合后，Action交给了Spring去管理了。

至此，Struts2、Hibernate4和Spring4整合工作已经全部完成。接下来就可以在SSH环境下进行开发了！