12.Spring + Hibernate + Struts2

故事：Struts的公司，在开发了Struts1之后，一直发展到大概Struts1.4，struts

与webwork的开发团队合并的原因，然后才开发了Struts2.x系列，因为struts2实质上

是得益于webwork的架构，而不是源于struts1。

一.Spring + Hibernate

导入双方的包：这个不做多提，前面Spring + Hibernate + Struts 有。

设计实体类（表）:

package com.zyy.bean;


public class Person {

    private Integer id;

    private String name;

    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

实体类对应的配置文件(Person.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 package="com.zyy.bean">

    <class name="com.zyy.bean.Person">
    <!-- 配置ehcache缓存 -->
    <cache usage="read-write" region="com.zyy.service.Person"></cache>
        <id name="id">
            <generator class="native"></generator>
        </id>

        <property name="name"></property>

    </class>

</hibernate-mapping>

创建对应的ehcache缓存配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<!-- 
    defaultCache节点为缺省的缓存策略
     maxElementsInMemory 内存中最大允许存在的对象数量
     eternal 设置缓存中的对象是否永远不过期
     overflowToDisk 把溢出的对象存放到硬盘上
     timeToIdleSeconds 指定缓存对象空闲多长时间就过期,过期的对象会被清除掉
     timeToLiveSeconds 指定缓存对象总的存活时间
     diskPersistent 当jvm结束是是否持久化对象
     diskExpiryThreadIntervalSeconds 指定专门用于清除过期对象的监听线程的轮询时间
 -->
<ehcache>
    <diskStore path="D:\cache"/>
    <defaultCache maxElementsInMemory="1000" eternal="false" overflowToDisk="true"
                  timeToIdleSeconds="120"
                  timeToLiveSeconds="180"
                  diskPersistent="false"
                  diskExpiryThreadIntervalSeconds="60"/>
    <cache name="com.zyy.service.Person" maxElementsInMemory="100" eternal="false"
           overflowToDisk="true" timeToIdleSeconds="300" timeToLiveSeconds="600" diskPersistent="false"/>
</ehcache>

然后配置Spring的beans.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:context="http://www.springframework.org/schema/context"
        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/context
           http://www.springframework.org/schema/context/spring-context-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 包含注解 -->
    <context:component-scan base-package="com.zyy.service"></context:component-scan>
    <context:component-scan base-package="com.zyy.control"></context:component-scan>


    <!-- 配置AOP -->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>


    <!-- 配置资源文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>

    <!-- 配置数据源 -->
    <bean id="dataSource" class="${dataSource}" destroy-method="close">
        <property name="driverClassName" value="${driverClassName}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
        <!-- 连接池启动时的初始值 -->
        <property name="initialSize" value="${initialSize}"/>
        <!-- 连接池的最大值 -->
        <property name="maxActive" value="${maxActive}"/>
        <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
        <property name="maxIdle" value="${maxIdle}"/>
        <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
        <property name="minIdle" value="${minIdle}"/>
    </bean>


    <!-- 配置Hibernate二级缓存 -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="mappingResources">
            <list>
                <value>com/zyy/bean/Person.hbm.xml</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <value>
                hibernate.dialect=org.hibernate.dialect.MySQLDialect
                hibernate.hbm2ddl.auto=update
                hibernate.show_sql=false
                hibernate.format_sql=false

                <!-- 配置hibernate二级缓存 -->
                hibernate.cache.use_second_level_cache=true
                <!-- 不配置查询缓存 -->
                hibernate.cache.use_query_cache=false
                <!-- 配置EhCache -->
                hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider

            </value>
        </property>
    </bean>

    <!-- 配置事务 -->
    <!-- 这里使用Spring的bean和Spring对Hibernate支持的HibernateTransactionManager -->
    <!-- 属性注入的是Hibernate的二级缓存 -->
    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>

    <!-- 打开事务注解的支持 -->
    <tx:annotation-driven transaction-manager="txManager"/>


</beans>

创建beans.xml所需的资源文件jdbc.properties：

dataSource = org.apache.commons.dbcp.BasicDataSource

driverClassName = org.gjt.mm.mysql.Driver

url = jdbc:mysql://localhost:3306/ceshi_1?useUnicode=true&characterEncoding=UTF-8

username = root

password = root

initialSize = 1

maxActive = 500

maxIdle = 2

minIdle = 1

建立数据库操作的 接口 和 实现bean ： 

PersonService

package com.zyy.service;

import com.zyy.bean.Person;

import java.util.List;


public interface PersonService {

    /**
     * 保存对象
     *
     * @param peroson
     */
    public void save(Person peroson);

    /**
     * 更新对象
     *
     * @param peroson
     */
    public void update(Person peroson);

    /**
     * 删除单个对象
     *
     * @param personId
     */
    public void delete(Integer personId);

    /**
     * 取得单个对象
     *
     * @return
     */
    public Person getPerson(Integer personId);

    /**
     * 取得全部对象
     *
     * @return
     */
    public List<Person> getPersons();


}

PersonServiceBean

package com.zyy.service.impl;

import com.zyy.bean.Person;
import com.zyy.service.PersonService;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;


@Service("personService")
@Transactional
public class PersonServiceBean implements PersonService {


    /**
     * 将Autowired转换为按 名称匹配
     * 就加上 @Qualifier("sessionFactory")
     * 按名称查找sessionFactory 为名字的bean
     */

    @Autowired
    @Qualifier("sessionFactory")
    private SessionFactory sessionFactory;

    public void save(Person peroson) {

        this.sessionFactory.getCurrentSession().persist(peroson);

    }

    public void update(Person peroson) {

        this.sessionFactory.getCurrentSession().merge(peroson);

    }

    public void delete(Integer personId) {

        this.sessionFactory.getCurrentSession().delete(
                this.sessionFactory.getCurrentSession().load(Person.class, personId));

    }

    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public Person getPerson(Integer personId) {

        return (Person) this.sessionFactory.getCurrentSession().get(Person.class, personId);

    }

    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public List<Person> getPersons() {

        //from 类名   不是from 数据库里的表名
        //noinspection JpaQlInspection
        String hql = "from Person";

        return this.sessionFactory.getCurrentSession().createQuery(hql).list();


    }
}

在类路径（src）下可选择性添加： 

log4j.properties

log4j.rootLogger=WARN, Console

log4j.appender.Console=org.apache.log4j.ConsoleAppender
log4j.appender.Console.layout=org.apache.log4j.PatternLayout
log4j.appender.Console.layout.ConversionPattern=(%r ms) [%t] %-5p: %c#%M %x: %m%n

log4j.logger.com.genuitec.eclipse.sqlexplorer=DEBUG
log4j.logger.org.apache=WARN
log4j.logger.org.hibernate=WARN

最后编写一个junit4.4测试类，进行测试：

package test.com.zyy.service.impl;

import com.zyy.bean.Person;
import com.zyy.service.PersonService;
import org.junit.Test;
import org.junit.Before;
import org.junit.After;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * PersonServiceBean Tester.
 *
 * @author <Authors name>
 * @version 1.0
 */
public class PersonServiceBeanTest {


    private PersonService personService;

    @Before
    public void before() throws Exception {


        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");

        this.personService = (PersonService) applicationContext.getBean("personService");


    }

    @After
    public void after() throws Exception {
    }

    /**
     * Method: save(Person peroson)
     */
    @Test
    public void testSave() throws Exception {

        this.personService.save(new Person("CaMnter_SSH_save"));

        for (int i = 0; i < 15; i++) {

            this.personService.save(new Person("CaMnter_SSH_save_" + i));

        }


    }

    /**
     * Method: update(Person peroson)
     */
    @Test
    public void testUpdate() throws Exception {

        Person person = new Person("CaMnter_SSH_update");

        person.setId(4);

        this.personService.update(person);

    }

    /**
     * Method: delete(Integer personId)
     */
    @Test
    public void testDelete() throws Exception {

        this.personService.delete(6);

    }

    /**
     * Method: getPerson(Integer personId)
     */
    @Test
    public void testGetPerson() throws Exception {

        Person person = this.personService.getPerson(7);

        System.out.println("id: " + person.getId() + "    name: " + person.getName());

    }

    /**
     * Method: getPersons()
     */
    @Test
    public void testGetPersons() throws Exception {

        for (Person person : this.personService.getPersons()) {
            System.out.println("id: " + person.getId() + "    name: " + person.getName());
        }


    }

    @Test
    public void testCache() {

        Person person = this.personService.getPerson(7);

        System.out.println("id: " + person.getId() + "    name: " + person.getName());

        try {
            Thread.sleep(1000 * 7);

            System.out.println("请关闭Mysql数据库");

        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("第二次获取");

        person = this.personService.getPerson(7);

        System.out.println("id: " + person.getId() + "    name: " + person.getName());


    }


} 

这里，我就测试了getPersons()方法：

如上，成了搭建 Spring + HIbernate。

二. Spring + Hibernate + Struts2

在类路径（src）下创建一个struts.xml

<?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>
    <!-- 该属性指定需要Struts 2处理的请求后缀，该属性的默认值是action，即所有匹配*.action的请求都由Struts2处理。
     如果用户需要指定多个请求后缀，则多个后缀之间以英文逗号（,）隔开。 -->
    <constant name="struts.action.extension" value="action"/>
    <!-- 设置浏览器是否缓存静态内容,默认值为true(生产环境下使用),开发阶段最好关闭 -->
    <constant name="struts.serve.static.browserCache" value="false"/>
    <!-- 当struts的配置文件修改后,系统是否自动重新加载该文件,默认值为false(生产环境下使用),开发阶段最好打开 -->
    <constant name="struts.configuration.xml.reload" value="true"/>
    <!-- 开发模式下使用,这样可以打印出更详细的错误信息 -->
    <constant name="struts.devMode" value="true"/>
    <!-- 默认的视图主题 -->
    <constant name="struts.ui.theme" value="simple"/>

    <!-- 这里才是真正的Struts2.x把action交付给Spring容器管理 -->
    <!-- 配置Action类 由Spring负责创建 -->
    <constant name="struts.objectFactory" value="spring"/>


    <package name="person" namespace="/person" extends="struts-default">
        <global-results>
            <result name="message">/WEB-INF/jsp/message.jsp</result>
        </global-results>
        <action name="action_*" class="personList" method="{1}">

            <!-- 相当于struts1.x中的forward -->
            <result name="list">/WEB-INF/jsp/personlist.jsp</result>
            <result name="add">/WEB-INF/jsp/add_person.jsp</result>

        </action>
    </package>
</struts>

其中：

1.<constant name="struts.objectFactory" value="spring"/>  这里才是真正的

  Struts2.x把action交付给Spring容器管理，相当于struts1.x在配置文件中定义一个

  Spring 的controller一样交付Sping容器管理。

2.这里定义了一个package，所以想访问package里的action的话需要加上package的namespace

  即 /person。

3.action里定义了一个class，这个就是action要交付给Spring管理时，Spring用注解

  命名必须与这个class保持一致，即personList。

4.<action name="action_*" class="personList" method="{1}">如果想访问

  action 就必须加上package 的namespace 和action 的name。即 /person/action_*。

  这里用*指定了一个占位符，后面的method={1}，提醒了第一个*表示的是方法的名字，由此可

  得访问路径最终为：/person/action_（action中的方法名）。

由于Struts2的配置文件需求，在WEB-INF下创建JSP文件夹，再分别建立personlist.jsp、

message.jsp、add_person.jsp：

personlist.jsp

<%--
  Created by IntelliJ IDEA.
  User: CaMnter
  Date: 2014/8/23
  Time: 0:52
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
  <head>
    <title></title>
  </head>
  <body>

    <s:iterator value="persons" >

        <h4>id=<s:property value="id"></s:property>   name=<s:property value="name"></s:property></h4>

    </s:iterator>

  </body>
</html>

add_person.jsp

<%--
  Created by IntelliJ IDEA.
  User: CaMnter
  Date: 2014/8/23
  Time: 0:52
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
  <head>
    <title></title>
  </head>
  <body>

    <s:form action="action_add" namespace="/person">

        名称：<s:textfield name="person.name"></s:textfield>
        <input type="submit" value="添加">

    </s:form>

  </body>
</html>

message.jsp

<%--
  Created by IntelliJ IDEA.
  User: CaMnter
  Date: 2014/8/23
  Time: 0:52
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="s" uri="/struts-tags" %>
<html>
  <head>
    <title></title>
  </head>
  <body>

     <s:property value="message"></s:property>

  </body>
</html>

接下来我们设计一个符合@Service("personList") - > 与action中的class保

持一致的Action ：

package com.zyy.control.action;

import com.zyy.bean.Person;
import com.zyy.service.PersonService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * 交给Spring管理的 Struts1.x 的action 必须与配置文件的 action 中的path一致
 *
 * 但是
 * 
 * 交给Spring管理的 Struts2.x 的action 必须与配置文件的 action 中的class一致
 */
@Service("personList")
@Transactional
public class PersonAction {

    @Autowired
    @Qualifier("personService")
    private PersonService personService;

    private String message;

    private List<Person> persons;

    private Person person;


    /**
     * 人员列表显示
     *
     * @return
     */
    public String list() {

        this.persons = this.personService.getPersons();

        //返回到 result 的path上
        return "list";

    }

    /**
     * 人员添加界面
     *
     * @return
     */
    public String addUI() {

        return "add";

    }

    /**
     * 人员添加
     *
     * @return
     */
    public String add() {

        this.personService.save(this.person);

        this.message = "添加成功";

        return "message";

    }

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }

    public List<Person> getPersons() {
        return persons;
    }

    public void setPersons(List<Person> persons) {
        this.persons = persons;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

以上：

1.每个方法的名字都可以表示配置文件中action_*里面的*的内容。例如：action_list、

  action_addUI、action_add，都可以。不过切记，别忘了后缀.action，当然也可以

  改为.do，这需要修改Strut2.x的配置文件。

2.return “String” ，这里的String 表示的是action的子节点result的name属性。

  这就好比，是返回了一个ActionMapping，在Struts1.x里是需要找到forward的name

  只不过Struts2.x简化了操作，十分类似，你只要以String的形式直接返回，result的name

  就相当于执行ActionMapping，Struts2.x对Action和ActionMapping进行了封装，所

  以简化了操作

3.注解@Service("personList")指定Action的名字时，必须和 action 的 class名字保持一致

4.Action里属性的名字，对应的各个页面的表单提交过来或者响应出去的数据的类型和名字，特

  别是名字必须保持一致。

  譬如：<1>.执行了list()方法后，返回result中的“list”，封装成ActionMapping

           后跳转到personlist.jsp，Action的private List<Person> persons

           与其打印的persons对应；

       <2>. 执行了add()方法后，返回result中的“message”，封装成ActionMapping

            后跳转到message.jsp，Action的private String message与其打印的

            message对应；

最后，再修改WEB-INF下的web.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
         version="3.1">

    <!-- 指定spring的配置文件，默认从web根目录寻找配置文件，我们可以通过spring提供的classpath:前缀指定从类路径下寻找 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:beans.xml</param-value>
    </context-param>


    <!-- 对Spring容器进行实例化 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 使用spring解决hibernate因session关闭导致的延迟加载例外问题 -->
    <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>

    <!-- 配置struts2 -->
    <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>struts2</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>


</web-app>

这里，其实和SH+Struts1.x混搭基本一样，只不过这里配置的是Struts2.x。

三.测试

输入：http://localhost:8080/SSH2/person/action_list.action

这里，上面已经反复强调过了：/person = pageage的namespace、/action_list =

 action_*，这里的list是PersonAction里的方法list()，用list指明了*的内容，所

以是/action_list。struts2.x的后缀不是.do ，是.actin 。当然在struts2.x的配

置文件中可以进行修改。

由于PersonAction中有一个addUI方法。所以输入：http://localhost:8080/SSH2

/person/action_addUI.action。

四.总结（对以上内容和SH+Struts2搭建的心得）

1.Spring + Hibernate + Struts2.x 比 Spring + Hibernate + Struts1.x  简

  化了很多操作，没了ActiomForm，优化了Action的代码，使得Action变成了POJO类型的类。

2.切记访问路径的设置，与package的namespace 和 action的name 息息相关，一定要加上

  namespace/action的name，这里namespace 一定要有前缀/，然后根据action的name是

  否有*，并在跳转的时候指定对应的方法名字，最后再加上Struts2.x的后缀.action，也可以

  通过更改Struts2.x配置文件改为.do。

3.Struts2.x的Action交付给Spring容器管理的时候，注解@Service("***")指定Action的

  名字时，必须和 action 的 class名字保持一致。

4.切记，在Struts2.x配置文件中，真正意义上起到Struts2.x把action交付给Spring容器管理

  作用的是<constant name="struts.objectFactory" value="spring"/>

5.Action中方法返回的String类型，就必须是result其中一个的name的值，这里优化了Action跳

  转时的操作，String返回后，根据String的值生成ActionMapping后，就可以跳转了。

6.Action里属性的名字，对应的各个页面的表单提交过来或者响应出去的数据的类型和名字，特

  别是名字必须保持一致。

  譬如：<1>.执行了list()方法后，返回result中的“list”，封装成ActionMapping

           后跳转到personlist.jsp，Action的private List<Person> persons

           与其打印的persons对应；

       <2>. 执行了add()方法后，返回result中的“message”，封装成ActionMapping

            后跳转到message.jsp，Action的private String message与其打印的

            message对应；

7.虽然开始有点不适应，因为代码优化的原因，但是建议多多使用SH+Struts2.x。 Struts2.x

  和 Struts1.x 关系很小，Struts2是以Webwork的设计思想为核心，吸收了Struts1的优点

  因此，可以认为Struts2是Struts1和Webwork。