转载

SSH电商项目实战之一：整合Struts2、Hibernate和Spring

（友情提示：本文介绍的SSH整合中所需要的完整jar包免费下载地址： http://download.csdn.net/detail/eson_15/9522068 ）

今天开始做一个网上商城的项目，首先从搭建环境开始，一步步整合S2SH。这篇博文主要总结一下如何整合Struts2 、Hibernate4.3和Spring4.2。

整合三大框架得先从搭建各部分环境开始，也就是说首先得把Spring，Hibernate和Struts2的环境搭建好，确保它们 没有问题了，再做整合。这篇博文遵从的顺序是：先搭建Spring环境-->然后搭建Hibernate环境--> 整合Spring和 Hibernate --> 搭建Struts2环境 --> 整合Spring和Struts2。

1. 整个项目jar包的管理

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

SSH电商项目实战之一：整合Struts2、Hibernate和Spring

从图中可以看出，首先将Spring的jar分为四类：spring-4.2.4-core、spring-4.2.4-aop、spring-4.2.4-persistence 以及spring-4.2.4-web。将spring的核心包都放到core中，与aop相关的都放到aop中，与持久化（与Hibernate整合）相关的 放到persistence中，与web（与struts2整合）相关的放到web中。每个部分都有哪些jar包呢？请看下面的截图：

SSH电商项目实战之一：整合Struts2、Hibernate和Spring SSH电商项目实战之一：整合Struts2、Hibernate和Spring

注：以上每个分类的包中，并非包含原来包中所有的jar，有些jar文件并没有用到，等具体项目需要的时候再往里加 就行了，上图是保证项目的环境可以搭建所需要的的最基本的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自带的例子里也 有，考一份过来就行，见下图：

SSH电商项目实战之一：整合Struts2、Hibernate和Spring

2.2 测试Spring的IoC环境

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

Java代码

/**  
 * @Description TODO(采用Spring的注解调试，仅仅支持Spring3.1及以上)  
 * @author Ni Shengwu  
 *  
 */    
/*  
 * 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;    
        
    @Test //测试Spring IOC的开发环境    
    public void springIoc() {    
        System.out.println(date);    
    }    
}    

最后能正常输出：Thu Apr 28 22:45:13 CST 2016。说明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 新建数据库和表

SQL代码

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 DB浏览器连接到Mysql数据库

DB浏览器指的是MyEclipse中的一个视图窗口，可以很直观的看到MySQL中都有哪些数据库和表，打开DB浏览器的 方法：Window->Open Perspective->DB Browser打开DB浏览器工作窗口。如果没有DB Browser，按照下面： Window->Show View->other->输入DB Browser，找到打开即可。

打开后，我们开始连接到MySQL数据库了，在DB Browser窗口的空白处右键->new，就会弹出下面的对话框：

SSH电商项目实战之一：整合Struts2、Hibernate和Spring

填好后，点击Test Driver测试一下，测试通过表示DataBase connection Driver已经配置好，然后finish即可，这样 我们就能在DB浏览器窗口中看到数据库MySQL5.6了，右键打开就能看到数据库中已有的库和表了，如下：

SSH电商项目实战之一：整合Struts2、Hibernate和Spring

3.4 创建xml映射文件和sessionFactory

sessionFactory是用来创建session的，我们通过如下方式创建：工程名右键->myeclipse->Add Hibernate Capabilities，如果没有Add Hibernate Capabilities，就点击project facets->Install Hibernate Facets，会弹出如下窗口 ：

SSH电商项目实战之一：整合Struts2、Hibernate和Spring

下一步，在MyEclipse中添加Hibernate Support，即hibernate.cfg.xml映射文件和sessionFactory。这里主要是给 sessionFactory建个包，默认包不行。

SSH电商项目实战之一：整合Struts2、Hibernate和Spring

下一步，添加驱动，由于我们之前已经配置好了一个驱动了，所以在这里直接选择刚刚配置好的即可。

SSH电商项目实战之一：整合Struts2、Hibernate和Spring

下一步，由于之前我们已经添加过自己的jar保留，这里不用选择，直接finish。

SSH电商项目实战之一：整合Struts2、Hibernate和Spring

这样我们就完成了Hibernate配置文件和sessionFactory的创建。下面我们简单看一下MyEclipse创建的 sessionFactory里面都有啥：

Java代码

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;    
    }    
    
}

从创建的HibernateSessionFactory中可以看出，主要用到了单例模式和线程池技术。也不难理解。

3.5 通过逆向工程生成model、orm映射文件

下面开始使用逆向工程创建实例对象了，也就是数据库的表对应的model。在DB Browsera窗口右击我们刚刚创建的 表shop，选择Hibernate Reverse Engineering开始创建：

SSH电商项目实战之一：整合Struts2、Hibernate和Spring

创建的时候有两种方式，基于配置文件的和基于注解的，具体的看开发人员心情了，可以选择：

SSH电商项目实战之一：整合Struts2、Hibernate和Spring

然后下一步，选择一下native主键自增方式，然后便完成了逆向工程创建model和orm映射了。

SSH电商项目实战之一：整合Struts2、Hibernate和Spring

完成后，会有Category的model生成，同时在hibernate.cfg.xml文件中也会生成相应的映射，前面基于配置文件的 和基于注解的在hibernate.cfg.xml中生成的映射时不同的。

3.6 测试Hibernate持久化数据库

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

先写CategoryService接口和实现类：

Java代码

public interface CategoryService {    
    public void save(Category category); //用来测试Hibernate环境    
}    
    
public class CategoryServiceImpl implements CategoryService {    
    
    @Override //没有和Spring整合的情况    
    public void save(Category category) {    
        //通过刚刚生成的sessionFactory获取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();    
        }           
    }    
}

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

Java代码

@RunWith(SpringJUnit4ClassRunner.class)    
@ContextConfiguration(locations="classpath:beans.xml")    
public class SSHTest {    
        
    @Resource    
    private Date date;      
        
    @Test //测试Spring IOC的开发环境    
    public void springIoc() {    
        System.out.println(date);    
    }    
        
    @Test  //测试Hibernate的开发环境，因为没有整合，可以直接new    
    public void hihernate() {    
        CategoryService categoryService = new CategoryServiceImpl();    
        Category category = new Category("男士休闲", 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中的相应部分可以删掉了。如下：

XML/HTML代码

<!-- com.mchange.v2.c3p0.ComboPooledDataSource类在c3p0-0.9.5.1.jar包的com.mchange.v2.c3p0包中 -->    
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">    
    <property name="driverClass" value="com.mysql.jdbc.Driver" />    
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/shop" />    
    <property name="user" value="root" />    
    <property name="password" value="root" />    
</bean>   

hibernate.cfg.xml中需要干掉的部分：

SSH电商项目实战之一：整合Struts2、Hibernate和Spring

4.3 配置sessionFactory

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

XML/HTML代码

<!-- 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将会有声明式的管理。 配置如下：

XML/HTML代码

<!-- 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的目的是指定哪些方法需要什么类型的事务模式。看配置：

XML/HTML代码

<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切面

XML/HTML代码

<aop:config>    
    <!-- 配置哪些包的类要切入事务 -->    
    <aop:pointcut id="pointcut" expression="execution(* cn.it.shop.service.impl.*.*(..))" />    
    <aop:advisor advice-ref="advice" pointcut-ref="pointcut"/><!-- 连接了<span style="font-family:Microsoft YaHei;">上</span>面的advice和上面的pointcut -->    
    <!-- aop:pointcut要写在aop:advisor上面，否则会报错 -->    
 </aop:config>    

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：

XML/HTML代码

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

其次，我们需要在CategoryService接口和它的实现类CategoryServiceImpl中增加一个方法用来测试整合后的情况 ：

Java代码

public interface CategoryService {    
    public void save(Category category); //用来测试Hibernate环境    
    public void update(Category category); //用来测试Spring和Hibernate整合后    
}    
    
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);        
    }    
}

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

Java代码

@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 hihernate() {    
        CategoryService categoryService = new CategoryServiceImpl();    
        Category category = new Category("男士休闲", true);    
        categoryService.save(category);    
    }    
        
    @Test //测试Hibernate和Spring整合后    
    public void hibernateAndSpring() {    
        categoryService.update(new Category(1, "休闲女式", true)); //categoryService通过Spring从上面注入进来的    
    }    
}   

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

5. 搭建Struts2环境

5.1 添加相应的配置和jar包

struts2运行所需的jar包我放在struts2.3.41的Library中了，直接引入即可，不再赘述。另外，还要对web.xml文件进 行配置，配置如下：

XML/HTML代码

<?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>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如下：

Java代码

public class CategoryAction extends ActionSupport {    
    private CategoryService categoryService; //设置categoryService是为了很直观的看出与Spring整合前后的不同    
        
    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/HTML代码

<?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="cn.it.shop.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

XML/HTML代码

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>    
    
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">    
<html>    
  <head>    
    <title>My JSP 'index.jsp' starting page</title>    
  </head>    
      
  <body>     
    <!-- 下面两种写法都可以访问 --></span>    
    <a href="${pageContext.request.contextPath }/category_update.action">访问update</a>    
    <a href="category_save.action">访问save</a>    
  </body>    
</html>    

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

XML/HTML代码

----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，配置如下所示：

XML/HTML代码

<bean id="date" class="java.util.Date" />    
<bean id="categoryAction" class="cn.it.shop.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/HTML代码

<struts>    
    <package name="shop" extends="struts-default">    
    
        <!-- class对应的是Spring中配置该Action的id值，因为要交给Spring管理 -->    
        <action name="category_*" class="categoryAction" method="{1}">    
            <result name="index">/index.jsp</result>    
        </action>    
    </package>    
    
</struts>    

6.4 配置监听器

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

XML/HTML代码

<?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>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中新加一句更新数据库的语句，如下：

Java代码

public class CategoryAction extends ActionSupport {    
        
    private Category category;//设置一个私有成员变量接收url带过来的参数，注意下面要写好get和set方法    
        
    private CategoryService categoryService;    
        
    public void setCategoryService(CategoryService categoryService) {    
        this.categoryService = categoryService;    
    }    
        
    public String update() {    
        System.out.println("----update----");    
        System.out.println(categoryService);//由于已经和Spring整合，所以可以拿到这个categoryService了，打印出来就不是null了    
        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;    
    }    
}    

然后我们修改一下index.jsp文件，如下：

XML/HTML代码

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>    
    
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">    
<html>    
  <head>    
    <title>My JSP 'index.jsp' starting page</title>    
  </head>    
      
  <body>    
    <a href="${pageContext.request.contextPath }/category_update.action?category.id=2&category.type=gga&category.hot=false">访问update</a>    
    <a href="category_save.action">访问save</a>    
  </body>    
</html>    

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

XML/HTML代码

----update----    
cn.it.shop.service.impl.CategoryServiceImpl@7c5ecf80    
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环境下进行开发了！

整个项目的源码下载地址： http://blog.csdn.net/eson_15/article/details/51479994

转自：倪升武的CSDN博客

原文  http://www.jizhuomi.com/software/759.html
正文到此结束
所属分类： 编程技术 Spring

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 Ant教程 ANTLR教程 SpringCloud java实例教程 springcloud-demo XStream教程 Hazelcast教程 Elastic-Job-Lite 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 solr教程 Hadoop教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 java-demo Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 Spring Cloud Consul实现选举机制
  2. 2 Spring Boot集成ShedLock实现分布式定时任务
  3. 3 利用oss进行数据库和网站图片备份
  4. 4 Spring Cloud Stream实现数据流处理
  5. 5 Python3访问MySQL数据库快速入门Demo
  6. 6 Github开源项目作者可以免费申请 JetBrains 全家桶
  7. 7 Spring Cloud Vault快速入门Demo
  8. 8 Spring Cloud Gateway快速入门Demo
  9. 9 Spring Cloud Contract快速入门Demo
  10. 10 Spring Cloud Consul快速入门Demo
网站信息
  • 文章总数：82,714 篇
  • 文件总数：284,287 个
  • 标签总数：2,393 个
  • 分类总数：85 个
  • 留言数量：2,560 条
  • 在线人数：612 人
  • 运行天数：4,408天
  • 最后更新：2024年11月21日19点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG