（转）Spring4.2.5+Hibernate4.3.11+Struts2.3.24整合开发

http://blog.****.net/yerenyuan_pku/article/details/52902851

前面我们已经学会了Spring4.2.5+Hibernate4.3.11+Struts1.3.8的整合开发，现在再来学习Spring4.2.5+Hibernate4.3.11+Struts2.3.24的整合开发应该是得心应手的事了，但我们还是有必要说一下，下面开始本文的介绍。
在学习Spring4.2.5+Hibernate4.3.11+Struts2.3.24的整合开发时，不要一口气的把这3个框架整合好，而是应该分步整合，通常应该先整合Spring4.2.5+Hibernate4.3.11这2个框架，这2个框架整合好之后，再来整合Struts2.3.24框架。

搭建和配置Spring与Hibernate整合的环境

我们首先新建一个动态web项目，名称为SSH2，顺便将项目的整个编码设置为UTF-8，过程省略。
然后我们来分步集成Spring4.2.5+Hibernate4.3.11这2个框架，先向SSH2项目中导入Hibernate4.3.11框架所需的jar文件，如图所示：
（转）Spring4.2.5+Hibernate4.3.11+Struts2.3.24整合开发
然后再向SSH2项目中导入Spring4.2.5框架所需的jar文件，如图所示：

最后，不要忘记导入数据库驱动jar文件：

接下来，我们在src目录下新建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.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context-4.2.xsd

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd

        http://www.springframework.org/schema/tx

        http://www.springframework.org/schema/tx/spring-tx-4.2.xsd">

    <context:annotation-config />

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

        destroy-method="close">

        <property name="driverClassName" value="com.mysql.jdbc.Driver" />

        <property name="url"

            value="jdbc:mysql://localhost:3306/jdbc?useUnicode=true&amp;characterEncoding=UTF-8" />

        <property name="username" value="root" />

        <property name="password" value="yezi" />

        <!-- 连接池启动时的初始值 -->

        <property name="initialSize" value="1" />

        <!-- 连接池的最大值 -->

        <property name="maxActive" value="500" />

        <!-- 最大空闲值。当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->

        <property name="maxIdle" value="2" />

        <!-- 最小空闲值。当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->

        <property name="minIdle" value="1" />

    </bean>

</beans>

从上可以看出Spring的配置文件保留了DBCP数据源的配置。
在整合Spring4.2.5+Hibernate4.3.11这2个框架时，我们需要将sessionFactory交给Spring容器管理，org.springframework.orm.hibernate4.LocalSessionFactoryBean这个类对sessionFactory做了一层包装，包装的目的是用于管理sessionFactory底下的session，通过这个类对由sessionFactory这个对象创建的session进行管理，管理就好比开启事务，提交事务等。所以需要将以下配置添加到Spring的配置文件中。

<bean id="sessionFactory"

    class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">

    <property name="dataSource" ref="dataSource" /> <!-- 数据源  -->

    <property name="mappingResources">

        <list>

            <value>cn/itcast/bean/Person.hbm.xml</value> <!-- Hibernate的实体bean的映射文件(可有多个) -->

        </list>

    </property>

    <!-- hibernateProperties是用来配置Hibernate的属性信息 -->

    <property name="hibernateProperties">

        <value>

            hibernate.dialect=org.hibernate.dialect.MySQLDialect

            hibernate.hbm2ddl.auto=update

            hibernate.show_sql=false

            hibernate.format_sql=false

            hibernate.cache.use_second_level_cache=true

            hibernate.cache.use_query_cache=false

            hibernate.cache.provider_class=net.sf.ehcache.hibernate.EhCacheProvider

            hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory

        </value>

    </property>

</bean>

从上面配置中可以看出我们还使用了Hibernate的二级缓存。
接下来还需要配置针对Hibernate的事务管理器，事务管理器对sessionFactory对象创建出来的session进行管理。所以需要将以下配置添加到Spring的配置文件中。

<bean id="txManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">

    <property name="sessionFactory" ref="sessionFactory"/>

</bean>

由于我们采用注解——@Transactional的方式来配置声明式事务，所以我们还要在Spring配置文件中添加如下内容：

<tx:annotation-driven transaction-manager="txManager" />

这样，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: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.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context-4.2.xsd

        http://www.springframework.org/schema/aop

        http://www.springframework.org/schema/aop/spring-aop-4.2.xsd

        http://www.springframework.org/schema/tx

        http://www.springframework.org/schema/tx/spring-tx-4.2.xsd">

    <context:annotation-config />

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"

        destroy-method="close">

        <property name="driverClassName" value="com.mysql.jdbc.Driver" />

        <property name="url"

            value="jdbc:mysql://localhost:3306/jdbc?useUnicode=true&amp;characterEncoding=UTF-8" />

        <property name="username" value="root" />

        <property name="password" value="yezi" />

        <!-- 连接池启动时的初始值 -->

        <property name="initialSize" value="1" />

        <!-- 连接池的最大值 -->

        <property name="maxActive" value="500" />

        <!-- 最大空闲值。当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->

        <property name="maxIdle" value="2" />

        <!-- 最小空闲值。当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->

        <property name="minIdle" value="1" />

    </bean>

    <bean id="sessionFactory"

        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">

        <property name="dataSource" ref="dataSource" /> <!-- 数据源  -->

        <property name="mappingResources">

            <list>

                <value>cn/itcast/bean/Person.hbm.xml</value> <!-- Hibernate的实体bean的映射文件(可有多个) -->

            </list>

        </property>

        <!-- hibernateProperties是用来配置Hibernate的属性信息 -->

        <property name="hibernateProperties">

            <value>

                hibernate.dialect=org.hibernate.dialect.MySQLDialect

                hibernate.hbm2ddl.auto=update

                hibernate.show_sql=false

                hibernate.format_sql=false

                hibernate.cache.use_second_level_cache=true

                hibernate.cache.use_query_cache=false

                hibernate.cache.provider_class=net.sf.ehcache.hibernate.EhCacheProvider

                hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory

            </value>

        </property>

    </bean>

    <!-- 配置针对Hibernate的事务管理器，事务管理器对sessionFactory对象创建出来的session进行管理 -->

    <bean id="txManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">

        <property name="sessionFactory" ref="sessionFactory"/>

    </bean>

    <tx:annotation-driven transaction-manager="txManager" />

</beans>

至此，Spring4.2.5与Hibernate4.3.11整合的环境就算搭建好了。

Spring集成的Hibernate编码与测试

我们首先在src目录下新建一个cn.itcast.bean包，并在该包下新建一个JavaBean——Person.Java，其代码为：

public class Person {

    private Integer id;

    private String name;

    // 实体bean必须要有一个无参构造函数

    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;

    }

}

然后我们还应在该包新建该实体bean的映射文件——Person.hbm.xml，其内容为：

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"

        "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="cn.itcast.bean">

    <class name="Person" table="person">

        <cache usage="read-write" region="cn.itcast.bean.Person" />

        <id name="id" type="int" column="id">

            <generator class="native"/>

        </id>

        <property name="name" type="string" length="20" not-null="true" column="name" />

    </class>

</hibernate-mapping>

从以上配置中，可以看出我们在需要缓存的实体bean配置文件中加入了缓存配置项，所以我们还需要在类路径下新建Ehcache默认的配置文件ehcache.xml，其内容为：

<?xml version="1.0" encoding="UTF-8"?>

<ehcache>

    <diskStore path="D:\cache" />

    <defaultCache maxElementsInMemory="1000" eternal="false" overflowToDisk="true"

        timeToIdleSeconds="120"

        timeToLiveSeconds="180"

        diskPersistent="false"

        diskExpiryThreadIntervalSeconds="60" />

    <cache name="cn.itcast.bean.Person" maxElementsInMemory="100" eternal="false"

           overflowToDisk="true"

           timeToIdleSeconds="300"

           timeToLiveSeconds="600"

           diskPersistent="false"/>

</ehcache>

接下来我们就要做的一步是在业务层(或数据访问层)里面通过Spring来使用sessionFactory。首先在src目录下新建一个cn.itcast.service包，并在该包下新建一个接口——PersonService.java，其代码为：

public interface PersonService {

    void save(Person person);

    void update(Person person);

    Person getPerson(Integer personid);

    void delete(Integer personid);

    List<Person> getPersons();

}

紧接着我们就要在src目录下新建一个cn.itcast.service.impl包，并在该包下新建一个PersonService接口的实现类——PersonServiceBean.java，其代码为：

@Transactional

public class PersonServiceBean implements PersonService {

    @Resource private SessionFactory sessionFactory; // 用@Resource注解方式进行依赖注入

    public void save(Person person) {

        /**

         * 以前我们通过sessionFactory对象得到session，是通过sessionFactory.openSession()得到的，

         * 但在此，我们需要注意一点，因为Spring会自动地帮我们管理事务，就是说它会自动地帮我们管理session对象，

         * 所以这时我们只须通过sessionFactory.getCurrentSession()从Spring容器里面得到当前

         * 被Spring容器管理的session对象。

         */

        sessionFactory.getCurrentSession().persist(person); // 建议使用persist()方法，和JTA规范保持一致，与save()作用一样

    }

    /**

     * 当对象处于游离状态时，这时才需要对它进行更新

     */

    public void update(Person person) {

        sessionFactory.getCurrentSession().merge(person); // 建议使用merge()方法，和JTA规范保持一致，把对游离状态对象的更新同步到数据库

    }

    @Transactional(propagation=Propagation.NOT_SUPPORTED, readOnly=true)

    public Person getPerson(Integer personid) {

        return (Person) sessionFactory.getCurrentSession().get(Person.class, personid);

    }

    public void delete(Integer personid) {

        /**

         * 建议使用load()方法，load()方法比get()方法性能要好一些，

         * 因为get()方法有一个数据装配的过程，也即把数据从数据库查询出来之后，还要把数据封装到实体对象里面去，

         * 而load()方法没有封装的过程，相对来说，效率要高很多。

         */

        sessionFactory.getCurrentSession().delete(

                sessionFactory.getCurrentSession().load(Person.class, personid));

    }

    @Transactional(propagation=Propagation.NOT_SUPPORTED, readOnly=true)

    @SuppressWarnings("unchecked")

    public List<Person> getPersons() {

        return sessionFactory.getCurrentSession().createQuery("from Person").list();

    }

}

提示：在该类中为何不采用HibernateTemplate这个类进行操作呢？因为这个类给我们提供的帮助并不是很大，我们通过session就完成了增删改查，代码量并不是很多，所以没必要使用它，而且使用它，它对Hibernate进行了一个封装，我们还要进行学习，有学习成本的花销。
接着不要忘了把该业务bean交给Spring容器进行管理，所以应向Spring配置文件中添加如下内容：

<bean id="personService" class="cn.itcast.service.impl.PersonServiceBean" />

每当开发完业务bean之后，大家千万别急于跟控制层进行集成，也就是说不要在控制层使用业务层对象，我们在开发完业务层后，需要对业务方法进行单元测试。所以我们要在src目录下新建一个junit.test包，并在该包下新建一个单元测试类——PersonServiceTest.java，其代码为：

public class PersonServiceTest {

    private static PersonService personService;

    /**

     * 当单元测试实例被构建出来之后，就执行该方法，

     * 所以我们可以在这个方法里面做一些初始化的操作。

     * @throws Exception

     */

    @BeforeClass

    public static void setUpBeforeClass() throws Exception {

        try {

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

            personService = (PersonService) cxt.getBean("personService");

        } catch (Exception e) { // 若出错，则打印在控制台上

            e.printStackTrace();

        }

    }

    @Test

    public void testSave() {

        personService.save(new Person("李子一"));

    }

    @Test

    public void testGetPerson() {

        Person person = personService.getPerson(2);

        System.out.println(person.getName());

        try {

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

            Thread.sleep(1000*60);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

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

        person = personService.getPerson(2);

        System.out.println(person.getName());

    }

    /**

     * 更新操作：一般在实际业务中，会先得到person对象，从web请求参数里面接收到

     * 一些参数值之后，把这些参数设置进person实体对象中，然后就来更新。

     */

    @Test

    public void testUpdate() {

        Person person = personService.getPerson(1);

        // ...

        person.setName("小李");

        personService.update(person);

    }

    @Test

    public void testGetPersons() {

        List<Person> persons = personService.getPersons();

        for (Person person : persons) {

            System.out.println(person.getName());

        }

    }

    @Test

    public void testDelete() {

        personService.delete(1);

    }

}

可以发现业务bean——PersonServiceBean中的所有业务方法都通过单元测试，说明业务层的代码没有任何问题，那么接下来我们就要集成web层框架——Struts2.3.24了。

使用Spring集成Struts2

上面我们已经集成了Spring4.2.5+Hibernate4.3.11这两个框架，现在是时候集成web层框架——Struts2.3.24了。
我们首先向SSH2项目中导入Struts2.3.24框架所需的jar文件，如图所示：
（转）Spring4.2.5+Hibernate4.3.11+Struts2.3.24整合开发
这样，总共需要向SSH2项目中导入的jar文件有39个：

接下来，我们在web层中要做两项工作：
第一项工作，原来Spring容器的实例化由我们手工编码实例化，现在不再需要我们手工编码去实例化Spring容器了，可以使用Spring给我们提供的监听器——org.springframework.web.context.ContextLoaderListener来实例化Spring容器。这个类实例化Spring容器后，它会把Spring容器实例放到什么范围里面去呢？答案是它将把Spring容器实例放在servletContext对象里面(即application范围内)，往这个对象里面放进去的实例，随着web应用启动时它就被放进去了，一直到web应用关闭时它才被销毁。若以后我们要得到Spring容器的实例，可以从application范围内根据名称WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE来得到Spring容器实例。
第一项工作，说白了就是在web容器中实例化Spring容器，所以需要在WEB-INF/web.xml文件中添加如下配置：

<!-- 指定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>

第二项工作，在web容器中配置Struts2，即需要在WEB-INF/web.xml文件中添加如下配置：

<filter>

    <filter-name>struts2</filter-name>

    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>

    <!--

        自从Struts2.1.3以后，下面的FilterDiapatcher已经标注为过时

        <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>

    -->

</filter>

<filter-mapping>

    <filter-name>struts2</filter-name>

    <url-pattern>/*</url-pattern>

</filter-mapping>

接下来，我们在src目录下新建一个cn.itcast.web.action包，并在该包下新建一个Action——PersonAction.Java，用于处理客户端请求。

public class PersonAction {

    @Resource PersonService personService;

    private String message;

    private List<Person> persons;

    private Person person;

    public Person getPerson() {

        return person;

    }

    public void setPerson(Person person) {

        this.person = person;

    }

    /**

     * 人员列表显示

     * @return

     */

    public String list() {

        this.persons = personService.getPersons();

        return "list";

    }

    /**

     * 人员添加界面

     * @return

     */

    public String addUI() {

        return "add";

    }

    /**

     * 人员添加

     * @return

     */

    public String add() {

        this.personService.save(this.person);

        this.message = "添加成功";

        return "message";

    }

    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;

    }

}

千万别忘了要将PersonAction交给Spring管理，即须在Spring配置文件中添加如下内容：

<bean id="personList" class="cn.itcast.web.action.PersonAction" />

紧接着，我们在类路径下新建Struts2的配置文件——struts.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>

    <!-- 指定Web应用的默认编码集，相当于调用HttpServletRequest的setCharacterEncoding方法 -->

    <constant name="struts.i18n.encoding" value="UTF-8"/>

    <!-- 该属性指定需要Struts2处理的请求后缀，该属性的默认值是action，即所有匹配*.action的请求都由Struts2处理。

        如果用户需要指定多个请求后缀，则多个后缀之间以英文逗号（,）隔开。 -->

    <constant name="struts.action.extension" value="do" />

    <!-- 设置浏览器是否缓存静态内容，默认值为true(生产环境下使用)，开发阶段最好关闭 -->

    <constant name="struts.serve.static.browserCache" value="false" />

    <!-- 当struts2的配置文件修改后，系统是否自动重新加载该文件，默认值为false(生产环境下使用)，开发阶段最好打开 -->

    <constant name="struts.configuration.xml.reload" value="true" />

    <!-- 开发模式下使用，这样可以打印出更详细的错误信息 -->

    <constant name="struts.devMode" value="true" />

    <!-- 默认的视图主题 -->

    <constant name="struts.ui.theme" value="simple" />

    <!-- Struts2和Spring集成的一个比较关键的配置，与Spring集成时，指定由Spring负责action对象的创建    -->

    <constant name="struts.objectFactory" value="spring" />

    <package name="person" namespace="/person" extends="struts-default">

        <global-results>

            <result name="message">/WEB-INF/page/message.jsp</result>

        </global-results>

        <action name="action_*" class="personList" method="{1}">

            <result name="list">/WEB-INF/page/personlist.jsp</result>

            <result name="add">/WEB-INF/page/addPerson.jsp</result>

            <!-- <result name="edit">/WEB-INF/page/edit_person.jsp</result> -->

        </action>

    </package>

</struts>

接下来，我们就在WEB-INF/page目录下新建以下三个JSP页面，如图：
（转）Spring4.2.5+Hibernate4.3.11+Struts2.3.24整合开发

addPerson.jsp的内容为：

<%@ page language="java" contentType="text/html; charset=UTF-8"

    pageEncoding="UTF-8"%>

<%@ taglib uri="/struts-tags" prefix="s" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>人员添加</title>

</head>

<body>

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

        名称：<s:textfield name="person.name" />

        <input type="submit" value="添加" />

    </s:form>

</body>

</html>

message.jsp的内容为：

<%@ page language="java" contentType="text/html; charset=UTF-8"

    pageEncoding="UTF-8"%>

<%@ taglib uri="/struts-tags" prefix="s" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>Insert title here</title>

</head>

<body>

    <s:property value="message" />

</body>

</html>

personlist.jsp的内容为：

<%@ page language="java" contentType="text/html; charset=UTF-8"

    pageEncoding="UTF-8"%>

<%@ taglib uri="/struts-tags" prefix="s" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>人员列表</title>

</head>

<body>

    <s:iterator value="persons">

        id=<s:property value="id" />，name=<s:property value="name" /><br/>

    </s:iterator>

</body>

</html>

当我们使用Struts2.3.24、Spring4.2.5、Hibernate4.3.11进行开发时，有一个问题——我们经常使用Hibernate的延迟属性时，经常遇到这样的异常，说session被关闭了，导致获取延迟属性的时候，出现一个延迟加载异常，我们在开发应用的时候，经常会出现这种错误。这种错误我们在Web应用里面可以使用Spring给我们提供的Filter来解决这个问题。即在web.xml文件中添加如下配置：

<filter>

    <filter-name>OpenSessionInViewFilter</filter-name>

    <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>

</filter>

<filter-mapping>

    <filter-name>OpenSessionInViewFilter</filter-name>

    <url-pattern>/*</url-pattern>

</filter-mapping>

这样，使用Spring就解决了Hibernate因session关闭导致的延迟加载异常问题。解决这个问题之后，session是在请求到来时打开，在请求结束时关闭，它横跨Servlet和Jsp，所以当Jsp需要用到某个延迟属性时，这时session仍然处于一种打开状态，所以说它不会出现延迟加载异常。这个在实际开发中非常有用，非常方便。
至此，Spring4.2.5+Hibernate4.3.11+Struts2.3.24这三大框架的集成就弄好了，现在我们来测试一下是不是真的如我们所想的那样呢？我们通过浏览器访问url地址：http://localhost:8080/SSH2/person/action_addUI.do，可以看到如下结果：
（转）Spring4.2.5+Hibernate4.3.11+Struts2.3.24整合开发
这时，查询数据库person表，可以发现多了一条name为孙悟空的记录。这就已然说明了Spring4.2.5+Hibernate4.3.11+Struts2.3.24这三大框架整合成功了！
如须查看源码，可点击Spring4.2.5+Hibernate4.3.11+Struts2.3.24整合开发进行下载。

秒客网

（转）Spring4.2.5+Hibernate4.3.11+Struts2.3.24整合开发

搭建和配置Spring与Hibernate整合的环境

Spring集成的Hibernate编码与测试

使用Spring集成Struts2

相关文章