Struts2+Spring+Hibernate框架整合总结详细教程

一.SSH三大框架知识总结

　　Struts 2是Struts的下一代产品，是在 struts 1和WebWork的技术基础上进行了合并的全新的Struts 2框架。其全新的Struts 2的体系结构与Struts 1的体系结构差别巨大。Struts 2以WebWork为核心，采用拦截器的机制来处理用户的请求，这样的设计也使得业务逻辑控制器能够与ServletAPI完全脱离开，所以Struts 2可以理解为WebWork的更新产品。虽然从Struts 1到Struts 2有着太大的变化，但是相对于WebWork，Struts 2的变化很小。

一 Struts2工作原理

　　在Struts2框架中的处理大概分为以下几个步骤 
　　1 客户端初始化一个指向Servlet容器（例如Tomcat）的请求 
　　2 这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，

　　　这个过滤器对于Struts2和其他框架的集成很有帮助，例　如:SiteMesh Plugin） 
　　3 接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请求是否需要调用某个Action 
　　4 如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy 
　　5 ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类 
　　6 ActionProxy创建一个ActionInvocation的实例。 
　　7 ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。 
　　8 一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。

　　　返回结果通常是（但不总是，也可 能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。

　　　在表示的过程中可以使用Struts2 框架中继承的标签。在这个过程中需要涉及到ActionMapper 

二 Struts2工作流程

　　1、客户端浏览器发出HTTP请求.

　　2、根据web.xml配置，该请求被FilterDispatcher接收

　　3、根据struts.xml配置，找到需要调用的Action类和方法， 并通过IoC方式，将值注入给Aciton

　　4、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。

　　5、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面

　　6、返回HTTP响应到客户端浏览器

 

　　Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性的角度而言，绝大部分Java应用都可以从Spring中受益。◆目的：解决企业应用开发的复杂性◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能◆范围：任何Java应用Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。

Spring内部最核心的就是IOC了，动态注入，让一个对象的创建不用new了，可以自动的生产，这其实就是利用java里的反射，反射其实就是在运行时动态的去创建、调用对象，Spring就是在运行时，跟xml Spring的配置文件来动态的创建对象，和调用对象里的方法的 。  
      Spring还有一个核心就是AOP这个就是面向切面编程，可以为某一类对象 进行监督和控制（也就是 在调用这类对象的具体方法的前后去调用你指定的 模块）从而达到对一个模块扩充的功能。这些都是通过  配置类达到的。  
      Spring目的：就是让对象与对象（模块与模块）之间的关系没有通过代码来关联，都是通过配置类说明管理的（Spring根据这些配置 内部通过反射去动态的组装对象）  
      要记住：Spring是一个容器，凡是在容器里的对象才会有Spring所提供的这些服务和功能。  
Spring里用的最经典的一个设计模式就是：模板方法模式。(这里我都不介绍了，是一个很常用的设计模式)， Spring里的配置是很多的，很难都记住，但是Spring里的精华也无非就是以上的两点，把以上两点跟理解了 也就基本上掌握了Spring.

一、 IoC(Inversion of control): 控制反转  
1、IoC：  
概念：控制权由对象本身转向容器；由容器根据配置文件去创建实例并创建各个实例之间的依赖关系  
核心：bean工厂；在Spring中，bean工厂创建的各个实例称作bean  
二、AOP(Aspect-Oriented Programming): 面向方面编程  
1、 代理的两种方式：  
静态代理：  
 针对每个具体类分别编写代理类；  
 针对一个接口编写一个代理类；  
动态代理：  
针对一个方面编写一个InvocationHandler，然后借用JDK反射包中的Proxy类为各种接口动态生成相应的代理类

2、动态代理:

不用写代理类，虚拟机根据真实对象实现的接口产生一个类，通过类实例化一个动态代理，在实例化动态代理时将真实对象及装备注入到动态代理中，向客户端公开的是动态代理，当客户端调用动态代理方法时，动态代理根据类的反射得到真实对象的Method,调用装备的invoke方法，将动态代理、 Method、方法参数传与装备的invoke方法，invoke方法在唤起method方法前或后做一些处理。

1、产生动态代理的类:

java.lang.refect.Proxy

2、装备必须实现InvocationHandler接口实现invoke方法

3、反射

什么是类的返射?

通过类说明可以得到类的父类、实现的接口、内部类、构造函数、方法、属性并可以根据构造器实例化一个对象，唤起一个方法，取属性值，改属性值。如何得到一个类说明：

Class cls=类.class;

Class cls=对象.getClass();

Class.forName("类路径");

如何得到一个方法并唤起它?

Class cls=类.class;

Constructor cons=cls.getConstructor(new Class[]{String.class});

Object obj=cons.newInstance(new Object[]{"aaa"});

Method method=cls.getMethod("方法名",new Class[]{String.class,Integer.class});

method.invoke(obj,new Object[]{"aa",new Integer(1)});

4、spring的三种注入方式是什么?

setter

interface

constructor

5、spring的核心接口及核类配置文件是什么?

FactoryBean:工厂bean主要实现ioc/di

ApplicationContext ac=new FileXmlApplicationContext("applicationContext.xml");

Object obj=ac.getBean("id值");

　　Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。Hibernate的核心接口一共有6个，分别为:Session、SessionFactory、Transaction、Query、Criteria和Configuration。

Hibernate工作原理和作用：

原理：
1.通过Configuration().configure();读取并解析hibernate.cfg.xml配置文件
2.由hibernate.cfg.xml中的<mapping resource="com/xx/User.hbm.xml"/>读取并解析映射信息
3.通过config.buildSessionFactory();//创建SessionFactory
4.sessionFactory.openSession();//打开Sesssion
5.session.beginTransaction();//创建事务Transation
6.persistent operate持久化操作
7.session.getTransaction().commit();//提交事务
8.关闭Session
9.关闭SesstionFactory

作用：
1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作

3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。

4. hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。
 
2． Hibernate是如何延迟加载?
1. Hibernate2延迟加载实现：a)实体对象 b)集合（Collection）

2. Hibernate3 提供了属性的延迟加载功能

当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。

3．Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)

类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、

4． 说下Hibernate的缓存机制

1. 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存

2. 二级缓存：
a) 应用及缓存
b) 分布式缓存
条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非 关键数据
c) 第三方缓存的实现
////////一级缓存：session级的缓存也叫事务级的缓存，只缓存实体，生命周期和session一致。不能对其进行管理。

不用显示的调用。

二级缓存：sessionFactory缓存，也叫进程级的缓存，使用第3方插件实现的，也值缓存实体，生命周期和sessionFactory一致，可以进行管理。

首先配置第3放插件，我们用的是EHCache，在hibernate.cfg.xml文件中加入

<property name="hibernate.cache.user_second_level_cache">true</property>

在映射中也要显示的调用，<cache usage="read-only"/>

二级缓存之查询缓存：对普通属性进行缓存。如果关联的表发生了修改，那么查询缓存的生命周期也结束了。

在程序中必须手动启用查询缓存：query.setCacheable(true);/////////

5． Hibernate的查询方式
Sql、Criteria,object comptosition
Hql：
1、 属性查询
2、 参数查询、命名参数查询
3、 关联查询
4、 分页查询
5、 统计函数

6． 如何优化Hibernate？
1.使用双向一对多关联，不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一，用多对一取代
4.配置对象缓存，不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6. 继承类使用显式多态
7. 表字段要少，表关联不要怕多，有二级缓存撑腰

二,创建数据库并并设置编码。

1.create database  dataname;注意：hibernate不会自己创建数据库；

2.default character set utf8;原因：避免出现乱码;

三,Eclipse项目

1.在eclipse里创建web项目，并设置编码为utf-8;原因：避免出现乱码;

四.搭建SSH三大框架环境

1.到SSH各官网下载插件(注意版本！)：struts-2.3.30、spring-framework-4.2.2.RELEASE,hibernate-release-5.2.2.Final；

2.把各大插件的jar包导入到项目的lib文件夹下：

1).Struts2必需的jar包(注意版本！)

2).spring必需的jar包(注意版本！)：

注意：struts2-spring-plugin-2.3.30.jar,commons-logging-1.1.3.jar是struts的jar包

3).hibernate必需的jar包(注意版本！在required文件夹下)：

还有在optional文件夹下的c3p0jar包(它既是数据库连接池包,类似的还有dbcp):

其它可选的到用到的时候再导入吧！注意：三大框架全部都导进来可能会产生包冲突！

3.配置web.xml文件：

1).配置默认首页等等其它的;

2).配置struts,struts就是一个过滤器,在客服端发送请求之后和响应客户端之前进行适当的处理；

3).配置spring,spring就是一个监听器，监听Context(上下文)，它管理所有类的实例的创建,就像会计所有人要钱都要去找她；

4).配置classpath路径,因为默认路径是/WEB-INF/***.xml而src文件夹路径是/WEB-INF/classes/***.xml;

 <?xml version="1.0" encoding="UTF-8"?>
 <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
   <display-name>stuAciton</display-name>
   <welcome-file-list>
     <welcome-file>default.jsp</welcome-file>
   </welcome-file-list>

     <filter>
         <filter-name>struts2</filter-name>
 　　　　 <!-- 2.3.3版本 -->
         <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>

     <context-param>
20 　　　　　<!-- XML文件src路径 -->
         <param-name>contextConfigLocation</param-name>
         <param-value>/WEB-INF/classes/applicationContext.xml</param-value>
     </context-param>

     <listener>
         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
     </listener>
 </web-app>

注意：每个版本有相应的配置,可以去下载的jar包里的示例代码中找；

4.在src文件夹创建或拷贝SSH框架的配置文件：

1). struts.xml的文件配置：(可以拷贝一个struts.xml模版到src目录)

struts.xml是struts2核心的核心，它负责跳转，传递参数；可以用struts.properties代替；

 <?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">
 <!-- 上面的头，注意版本，从样例里复制过来 showcase.war\WEB-INF\src\java\struts.xml -->

 <!-- include文件用于分割，实现多人并发不冲突 -->
 <struts>
     <!-- 告知Struts2运行时使用Spring来创建对象 -->
     <constant name="struts.objectFactory" value="spring"></constant>

     <!--指定Struts2默认的ObjectFactory Bean,该属性默认值是spring-->
     <package name="mypkg" extends="struts-default">
         <!-- StudentAction是请求地址、myStudentAction是Action类、execute2是Action类里的方法-->
         <action name="StudentAction"  class="myStudentAction" method="execute2">
             <!-- Action类里return的字符串，这个必须要一致，有默认的 -->
             <result name="success">/WEB-INF/jsp/student.jsp</result>
             <result name="error">/WEB-INF/jsp/error.jsp</result>
         </action>
     </package>
 </struts>  

2).applicationContext.xml文件的配置：

applicationContext.xml是spring框架的入口点，是struts关联spring的桥梁也是spring关联hibernate的桥梁；

<?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:p="http://www.springframework.org/schema/p"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:jee="http://www.springframework.org/schema/jee"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.2.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd">
    <!-- 类似于财务部门一样，类就是钱，所有需要类的实例都由srping去管理 -->
    <!-- id属性的值是接口、class属性的值为id接口的一个实例、prototype属性值为非单例 -->
    <bean id="myStudentAction" class="action.StudentAction" scope="prototype">
        <!-- ss是class实例里的一个全局属性，给ss设置一个 StudentService实例的值-->
        <property name="ss" ref="StudentService"></property><!-- Spring依赖注入 -->
    </bean>
    <!-- id属性的值是接口、class属性的值为id接口的一个实例、prototype属性值为非单例 -->
    <bean id="StudentService" class="serverce.StudentServiceImpl" scope="prototype">
        <!-- sdd是class实例里的一个全局属性，给sdd设置一个 StudentDao实例的值-->
        <property name="sdd" ref="StudentDao"></property><!-- Spring依赖注入 -->
    </bean>
    <bean id="StudentDao" class="dao.StudentDaoImpl" scope="prototype">
        <!-- 注入两个hibernate类 一个用来查询一个用来插入-->
        <property name="sessionfactory" ref="sessionfactory"></property><!-- Spring依赖注入 -->
        <property name="sessionfactory2" ref="sessionfactory2"></property><!-- Spring依赖注入 -->
    </bean>
    <!-- org.springframework.orm.hibernate5.LocalSessionFactoryBean是hibernate的jar包 -->
    <bean id="sessionfactory"
        class="org.springframework.orm.hibernate5.LocalSessionFactoryBean"
        scope="prototype">
        <!-- 注入一个数据库连接池 -->
        <property name="dataSource" ref="SQLServerDatasource"></property>
        <!--配置hibernateproperties替换hibernate.cfg.xml文件  -->
        <property name="hibernateProperties">
            <props>
                <!-- 方言是必需的 -->
                <prop key="hibernate.dialect">org.hibernate.dialect.SQLServer2008Dialect</prop>
                <!-- 显示SQL语句  -->
                <prop key="hibernate.show_sql">true</prop>
                <!-- 格式化SQL语句 -->
                <prop key="hibernate.format_sql">true</prop>
                <!-- 是否自动提交 -->
                <prop key="hibernate.connection.autocommit">false</prop>
                <!-- 自动创建修改表 -->
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
        <!-- 关联数据映射文件  -->
        <property name="mappingResources">
            <!-- 数据表映射配置文件 -->
            <list>
                <value>Student.hbm.xml</value>
            </list>
        </property>
    </bean>
    <!-- 同上  -->
     <bean id="sessionfactory2" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean" scope="prototype">
        <!-- <property name="configLocation" value="/WEB-INF/classes/hibernate2.cfg.xml"></property> -->
        <property name="dataSource" ref="MySQLDatasource"></property>

        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.connection.autocommit">false</prop>
                <prop key="hibernate.hbm2ddl.auto">create</prop>
            </props>
        </property>
        <property name="mappingResources">
            <list><value>Student.hbm.xml</value></list>
        </property>
    </bean> 

    <!--SQLServer连接池  -->
    <bean id="SQLServerDatasource" class="org.apache.commons.dbcp.BasicDataSource" >
        <property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/>
        <property name="url" value="jdbc:sqlserver://localhost:1433;DatabaseName=StuSys"/>
        <property name="username" value="sa"/>
        <property name="password" value="123456"/>
        <!--每300秒检查连接池中的空闲连接  -->
        <property name="numTestsPerEvictionRun" value="300"></property>
        <!-- 最大空闲时间,900秒未使用则丢弃，若是0则永远不丢弃 -->
        <property name="minEvictableIdleTimeMillis" value="900"></property>
        <!-- 最大连接数 -->
        <property name="maxIdle" value="2"></property>
    </bean>

    <!--MySQL连接池  org.apache.commons.dbcp.BasicDataSource是dbcp的jar包的类-->
    <bean id="MySQLDatasource" class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/StuSys"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
        <!--每300秒检查连接池中的空闲连接  -->
        <property name="numTestsPerEvictionRun" value="300"></property>
        <!-- 最大空闲时间,900秒未使用则丢弃，若是0则永远不丢弃 -->
        <property name="minEvictableIdleTimeMillis" value="900"></property>
        <!-- 最大连接数 -->
        <property name="maxIdle" value="2"></property>
    </bean>
</beans>
            

3).类名.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>
    <!-- class代表实体类跟数据库表之间的映射 -->
    <class name="entity.Student" table="student">
        <id name="id" column="ID"><!-- ID的类型要注意对应，否则会出现异常 -->
            <generator class="native"/><!-- class要根据不的数据库填写不同的值 -->
        </id>
        <!--类的每个属性对应表里的每个字段，要注意类型的对应  -->
        <property name="name" column="NAME"/>
        <property name="sex" column="SEX"/>
        <property name="age"  column="AGE"/>
        <property name="addres" column="ADDRES"/>
     </class>
</hibernate-mapping>

5.在src目录下构建项目的包和类：

1).在entity包里创建student.java,实体类属性的类型要正确这很重要;

 package entity;

 public class Student {
     private int id;
     private String name;
     private String sex;
     private int age;
     private String addres;

     public Student(){}

     public Student(int id, String name, String sex, int age, String addres) {
         super();
         this.id = id;
         this.name = name;
         this.sex = sex;
         this.age = age;
         this.addres = addres;
     }

     public Student(String name, String sex, int age, String addres) {
         super();
         this.name = name;
         this.sex = sex;
         this.age = age;
         this.addres = addres;
     }

     public int getId() {
         return id;
     }

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

     public String getName() {
         return name;
     }

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

     public String getSex() {
         return sex;
     }

     public void setSex(String sex) {
         this.sex = sex;
     }

     public int getAge() {
         return age;
     }

     public void setAge(int age) {
         this.age = age;
     }

     public String getAddres() {
         return addres;
     }

     public void setAddres(String addres) {
         this.addres = addres;
     }

 }

2).客服端发送请求到服务器被struts拦下让Action.java来处理：

 package action;

 import java.util.List;

 import com.opensymphony.xwork2.ActionSupport;

 import entity.Student;
 import serverce.StudentService;

 //Action类就是继承ActionSupport类的普通类
 public class StudentAction extends ActionSupport {

     //设置私有属性用于向JSP传递数据
     private List<Student> myStuList;
     //或从外部注入实例到本类；
     private StudentService ss;
     //这里采用set注入方法，还可以用构造函数方法、接口的方法；
     public void setSs(StudentService ss) {
         this.ss = ss;
     }
     public List<Student> getMyStuList() {
         return myStuList;
     }
     public void setMyStuList(List<Student> myStuList) {
         this.myStuList = myStuList;
     }

     //返回的类型必需是字符串类型，可以创建多个方法用于不同的跳转
     public String execute1(){
         myStuList=ss.getStuAll();
         System.out.println("全部在："+myStuList);
         return "success";
     }
     public String execute2(){
         return "error";
     }
 }

3).在Action处理业务逻辑的时候，struts会调用spring为所有类提供实例

 package serverce;

 import java.util.List;

 import dao.StudentDao;
 import entity.Student;

 public class StudentServiceImpl implements StudentService {
     //set注入
     private StudentDao sdd;

     /* (non-Javadoc)
      * @see serverce.StudentService#setSdd(dao.StudentDao)
      */
     @Override
     public void setSdd(StudentDao sdd) {
         this.sdd = sdd;
     }

     /* (non-Javadoc)
      * @see serverce.StudentService#getStuAll()
      */
     @Override
     public List<Student> getStuAll(){        //解耦合
         List<Student> list=sdd.getStudentAll();
         return list;
     }
 }

4).处理业务逻辑要用到数据，hibernate提供了sessionfactory类替代JDBC帮我们自动创建表

 package dao;

 import java.util.List;

 import org.hibernate.Session;
 import org.hibernate.SessionFactory;
 import org.hibernate.cfg.Configuration;

 import entity.Student;
 import util.MyConnection;

 public class StudentDaoImpl implements StudentDao {
     //注入sessionfactory工厂类
     private SessionFactory sessionfactory;
     private SessionFactory sessionfactory2;

     public void setSessionfactory(SessionFactory sessionfactory) {
         this.sessionfactory = sessionfactory;
     }
     public void setSessionfactory2(SessionFactory sessionfactory2) {
         this.sessionfactory2 = sessionfactory2;
     }
     /* (non-Javadoc)
      * @see dao.StudentDao#getStudentAll()
      */
     @Override
     public List<Student> getStudentAll(){
         System.out.println("获得一个非常重要的对象sessionFactory"+sessionfactory);
         Session session=sessionfactory.openSession();
         Session session2=sessionfactory2.openSession();
         //读取全部数据打印
         //创建事务，执行插入数据操作
         session.beginTransaction();
         session2.beginTransaction();
         session.save(new Student("胡歌","男",30,"上海"));
         session.save(new Student("胡兵","男",35,"深圳"));
         //获得数据库结果集
         List<Student> result=session.createQuery("from Student").getResultList();
         for(Student stu:result){
             System.out.println("ok");
             session2.save(stu);
         }
         session.getTransaction().commit();
         session2.getTransaction().commit();
         sessionfactory.close();
         sessionfactory2.close();
         session.close();
         session2.close();

         return result;
     }
 }

5).这样我们就可以把结果集跳转传递到JSP页面去：

 <%@ page language="java" contentType="text/html; charset=UTF-8"
     pageEncoding="UTF-8"%>
     <%@ taglib prefix="s" uri="/struts-tags" %>
 <!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>
     <table border="1">
         <tr>
             <td>全选</td>
             <td>序号</td>
             <td>编号</td>
             <td>姓名</td>
             <td>性别</td>
             <td>年龄</td>
             <td>住址</td>
         </tr>
         <s:iterator value="myStuList" status="bcs">
             <tr>
                 <td></td>
                 <td><s:property value="#bcs.count" /></td>
                 <td><s:property value="id"></s:property></td>
                 <td><s:property value="name"></s:property></td>
                 <td><s:property value="sex"></s:property></td>
                 <td><s:property value="age"></s:property></td>
                 <td><s:property value="addres"></s:property></td>
             </tr>
         </s:iterator>
         <s:if test="myStuList.size()==0">
             <tr>
                 <td colspan="7">没有查找到数据</td>
             </tr>
         </s:if>
     </table>
 </body>
 </html>

6).测试：http://localhost:8080/studentSys/StudentAction.action