Spring事务以及三大框架整合

一、Spring事务管理

1.1 事务的特性

  事务使用ACID特性来衡量事务的质量。介绍如下： 
1，原子性 
    事务必须是原子的，在事务结束的时候，事务中的所有任务必须全部成功完成，否则全部失败，事务回滚到事务开始之间的状态。 
2，一致性 
    事务必须保证和数据库的一致性，即数据库中的所有数据和现实保持一致。如果事务失败数据必须返回到事务执行之前的状态，反之修改数据和现实的同步。 
3，隔离性 
    隔离性是事务与事务之间的屏障，每个事务必须与其他事务的执行结果隔离开，直到该事务执行完毕，它保证了事务的访问的任何数据不会受其他事务执行结果的影响。 
4，持久性 
    如果事务成功执行，无论系统发生任何情况，事务的持久性都必须保证事务的执行结果是永久的。 

1.2 Spring事务概念

事务管理在应用程序中起着至关重要的作用：它是一系列任务的组成工作单元，在这个工作单元中，所有的任务必须同时执行。它们只有二种可能执行结果，
要么所有任务全部执行成功，要么所有任务全部执行失败。 
Spring中提供了丰富的事务管理功能，它们超过了EJB并且和EJB一样支持声明式事务，重要的是Spring提供了致的事务管理，它有如下优点。 
1，为不同的事务的API提供一致的编程模式 
2，提供更简单，更易地使用的编程式事务管理 
3，支持Spring声明事务 
4，整合Spring对数据访问的抽像 

1.3 事务的属性

1，事务的传播行为 
    传播行为是事务应用于方法的边界，它定义了事务的建立，暂停等行为属性。 

在Spring中共有7种， 

*PROPAGATION_MANDATORY: 
规定了方法必须在事务中运行，否则会抛出异常 

*PROPAGATION_NESTED: 
使方法运行在嵌套事务中，否则这个属性和PROPAGATION_REQUIRED属性的义相同 

PROPAGATION_NEVER 
使当前方法永远不在事务中运行，否则抛出异常 

PROPAGATION_NOT_SUPPORTED 
定义为当前事务不支持的方法，在该方法运行期间正在运行的事务会被暂停 

*PROPAGATION_REQUIRED 
规定当前的方法必须在事务中，如果没有事务就创建一个新事务，一个新事务和方法一同开始，随着方法的返回或抛出异常而终止 

*PROPAGATION_REQUIRED_NEW 
当前方法必须创建新的事务来运行，如果现存的事务正在运行就暂停它 

PROPAGATION_SUPPORTS 
规定当前方法支持当前事务处理，但如果没有事务在运行就使用非事务方法执行 

以上定义Spring在事务中的传播行为分别对应EJB的事务CMT中的所有传播行为，其在PROPAGATION_NESTED是Spring在CMT之外定义的事务传播行为。 

例如： 
<property name="transactionAttributes"> 
        <props> 
            <prop key="query*">PROPAGATION_REQUIRED,timeout_5,readOnly</prop> 
            <prop key="insert*">PROPAGATION_REQUIRED</prop> 
            <prop key="delete*">PROPAGATION_REQUIRED</prop> 
        </props> 
    </property>     


2，事务的隔离级别 
    为解决事务之间的3个缺陷，必须在事务之间建立隔离关系来保证事务的完整性。 
ISOLATION_DEFAULT         
    使用数据库默认的隔离级别 
ISOLATION_COMMITTED     
    允许读取其他并发事务已经提交的更新（防此脏读） 
ISOLATION_READ_UNCOMMITTED 
    允许读取其他并发事务还未提交的更新，会导致事务之间的3个缺陷发生，这是速度最快的一个隔离级别，
    但同时它的隔离级别也是最低 
ISOLATION_REPEATABLE_READ 
    除非事务自身修改了数据，否则规定事务多次重复读取        数据必须相同（防此脏读，不可重复读） 
ISOLATION_SERIALIZABLE 
    这是最高的隔离级别，它可以防此脏读，不可重复读和        幻读等问题，但因其侵占式的数据记录完全锁定，导致 
    它影响事务的性能，成为隔离级别中最展慢的一个。 
注意：并不是所有的资源管理器都支持所有的隔离级别，可针对不同的资源管理使用以上的隔离级别。 

3，事务的只读属性 
    在对数据库的操作中，查询是使用最频繁的操作，每次执行查询时都要从数据库中重新读取数据，有时多次读取的数据都是相同的，
    这样的数据操作不仅浪费了系统资源，还影响了系统速度。对访问量大的程序来说，节省这部分资源可以大大提升系统速度。 
    如果将事务声明为只读的，那么数据库可以根据事务的特性优化事务的读取操作。事务的只读属性需要配合事务的传播行为共同设置。例如： 
    <prop key="query*">PROPAGATION_REQUIRED,readOnly</prop> 

4，事务的超时属性     
    这个属性和事务的只读属性一样需要搭配事务的传播行为共同设置，它设置了事务的超时时间，事务本身可能会因某种原因很长没有回应，
    在这期间事务可能锁定了数据库的表格，这样会出现严重的性能问题。通过设置事务的超时时间，从开始执行事务起，在规定的超时时间内如果没有事务就将它回滚。
    事务的超时属性以timeout_为前缀和一个整型数字定义，例如： 
  <prop key="query*">PROPAGATION_REGUIRED,timeout_5,readOnly</prop> 

1.4 Spring的事务管理器

Spring的事务管理器有5个，都实现了PlatformTransactionManager接口，如下所示： 

DataSourceTransactionManager           JDBC事务管理器 
HibernateTransactionManager            Hibernate事务管理器 
JdoTransactionManager                  JDO事务管理器 
JtaTransactionManager                   JTA事务管理器      
PersistenceBrokerTransactionManager    Apache的OJB事务管理器         
<!-- 配置JDBC事务管理器 --> 
    <bean id="transactionManager" 
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
        <property name="dataSource"> 
            <ref bean="dataSource"/> 
        </property> 
    </bean> 

---

<!-- 配置HibernateSessionFactory工厂 --> 
    <bean id="sessionFactory" 
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
        <property name="dataSource" ref="dataSource" /> 
        <property name="mappingResources"> 
            <list> 
                <value>tarena/hbm/catelog.hbm.xml</value> 
                <value>tarena/hbm/bookinfo.hbm.xml</value> 
                <value>tarena/hbm/userinfo.hbm.xml</value> 
                <value>tarena/hbm/order.hbm.xml</value> 
            </list> 
        </property> 
        <property name="hibernateProperties"> 
            <props> 
                <prop key="hibernate.dialect"> 
                    org.hibernate.dialect.MySQL5Dialect 
                </prop> 
                <prop key="hibernate.query.substitutions"> 
                    true 'Y', false 'N' 
                </prop> 
                <prop key="hibernate.show_sql">true</prop> 
            </props> 
        </property> 
    </bean> 

    <!-- 配置Hibernate事务管理器 --> 
    <bean id="transactionManager" 
        class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
        <property name="sessionFactory" ref="sessionFactory" /> 
    </bean> 

　1.５　声明式事务

因为Spring中的事务是基于AOP实现的，而Spring的AOP是以方法为单位的，所以Spring的事务属性就对事务应用到方法上的策略描述，
这些属性为：传播行为，隔离级别，只读和超时属性。 
Spring的声明式事务不涉及组建依赖关系，它通过AOP实现事务管理。Spring本身就是一个容器，相对EJB容器而言，Spring显得更为轻便，
在使用Spring的声明式事务时不须编写任何代码，便可通过实现基于容器的事务管理。Spring提供了一些可供选择的辅助类，这些辅助类简化了传统的数据库操作流程，
在一定程度上节省了工作量，提高了编码效率，所以推荐使用声明事务。 
1，优化DataSource 
    DriverManagerDataSource数据源，它在每次获得数据连接时都创建一个新的连接对象，完全没有缓冲能力。
    Spring没有提供连接的实现，因为一些开源项目已经实现了带有连接池功能的数据源，例如Apache Commons DBCP的BasicDataSource数据源。
    这个数据源不仅提供了缓冲的连接池功能，而且它是一个完全轻量级的数据源。
    在Spring中的配置方法如下： 
        <bean id="dataSource" 
    class="org.apache.commons.dbcp.BasicDataSource"> 
        <property name="driverClassName"> 
            <value>org.gjt.mm.mysql.Driver</value> 
        </property> 
        <property name="url"> 
<value>jdbc:mysql://localhost:3306/dbname</value> 
    </property> 
    <property name="username"> 
        <value>root</value> 
    </property> 
    <property name="password"> 
        <value>admin</value> 
    </property> 
</bean> 


2，使用事务代理工厂 
    事务代理工厂TransactionProxyFactoryBean包括了事务拦截器，目标代理和事务的属性设置，它配置方便，使用灵活，在声明式事务中广泛使用。 
使用TransactionProxyFactoryBean需要注入它所依赖的事务管理器，设置代理的目标对象，代理对象的生成方式和事务属性。
代理对象是在目标对象上生成的包括事物和AOP切面的新对象，
这个新的对象用来替代目标对象以支持事物或AOP提供的切面功能。 
其中对象代理的生成方式可根据CGLIB生成代理，例如： 
<property name="proxyTargetClass" value="true"/> 
最后再介绍一个TransactionProxyFactoryBean中如何设置事务的属性。TransactionProxyFactoryBean的transactionAttributes属性用于指定事务的属性，
它是一个Properties类型的属性集合，以方法名和事务属性组成键值对，给不同的方法指定不同的事务属性。例如: 
<prop key="query*">PROPAGATION_REQUIRED,timeout_5,readOnly</prop> 
方法名作为声明时，可以使用*通配符，上述代码定义对所有以query作前缀的方法，并在定义的事务中完成操作，事务的不同属性之间以","分隔。 
通过一个实例介绍如何使用TransactionProxyFactoryBean完全成Spring的声明式事务管理。 

<!-- 配置数据源 --> 
    <bean id="dataSource" 
class="org.apache.commons.dbcp.BasicDataSource"> 
    <property name="driverClassName"> 
        <value>org.gjt.mm.mysql.Driver</value> 
    </property> 
    <property name="url"> 
        <value>jdbc:mysql://localhost:3306/数据库Schema</value> 
    </property> 
    <property name="username"> 
        <value>root</value> 
    </property> 
    <property name="password"> 
        <value>admin</value> 
    </property> 
</bean> 
<!-- 配置JDBC事务管理器 --> 
<bean id="transactionManager" 
class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
    <property name="dataSource"> 
        <ref bean="dataSource" /> 
    </property> 
</bean> 

<!-- 配置事件代理工厂 --> 
<bean id="transactionProxy" 
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> 
    <!-- 要依赖事务管理器 --> 
    <property name="transactionManager"> 
        <ref bean="transactionManager"/> 
    </property> 

    <!-- 要依赖目标对象 --> 
    <property name="target"> 
        <bean id="userDAO" class="tarena.dao.UserDAO"> 
            <property name="dataSource"> 
                <ref bean="dataSource"/> 
            </property> 
        </bean> 
    </property> 

    <!-- 要依赖代理方式 --> 
    <property name="proxyTargetClass" value="true"></property> 

    <!-- 要依赖事务属性 --> 
    <property name="transactionAttributes"> 
        <props> 
            <prop key="query*">PROPAGATION_REQUIRED,timeout_1,readOnly</prop> 
            <prop key="insert*">PROPAGATION_REQUIRED,timeout_2</prop> 
            <prop key="delete*">PROPAGATION_REQUIRED</prop> 
        </props> 
    </property> 
</bean> 

　1.６　使用注解声明事务

１、 applicationContext.xml
    <!-- 扫描注解组件 -->
    <context:component-scan base-package="cn.lx"></context:component-scan>
    <!--开启事务注解驱动,并指明使用的事务管理器 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>
     <!-- C3P0数据源 --> 
  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
      <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
      <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/shhtest"></property>
      <property name="user" value="root"></property>
      <property name="password" value="root"></property>
  </bean>

 <!-- 配置JabcTemplate -->  
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

  <!--  配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>
2、DAO实现类
    @Repository("accountDao")
    public class AccountDaoImpl  implements AccountDao{
        @Autowired
        @Qualifier("jdbcTemplate")
        private JdbcTemplate jdbcTemplate;}
3、Servcie实现类
    @Service("accountService")
    @Transactional//表示该类中的方法都要开启事务，也可以单独放在指定方法上，将指定方法开启事务
    public class AccountServiceimpl implements AccountService {
        @Autowired
        @Qualifier("accountDao")
        private AccountDao accountDao;

        public void setAccountDao(AccountDao accountDao) {
            this.accountDao = accountDao;
        }
    }

二、Struts2、Spring、Hibernate三大框架整合

2.1 Struts2与Spring集成

1、web.xml配置文件
    a.配置Struts2核心控制器
         <!--配置Struts2核心控制器  -->
      <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>/*</url-pattern>
      </filter-mapping>
    b.配置监听器，用于加载Spring配置文件
    listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
    配置全局参数，用于指明spring配置文件位置
        <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
      </context-param>
2、applicationContext.xml
    将struts2中用到的对象都由Spring生成进行管理
    <!--配置AccountAction  -->
    <bean id="accountAction" class="cn.lx.web.action.AccountAction" scope="prototype">
        <property name="accountService" ref="accountService"></property>
    </bean>
3、struts.xml
    配置action时，class属性原来写的是类全限定类名，现在改成applicationContext.xml中配置的id
    <action name="accountAction_*" class="accountAction" method="{1}">
                <result name="success">/index1.jsp</result>
            </action>
4、整合完成
重点是struts中用的对象的class属性都为spring中配置对象的id值

2.2 Spring与Hibernate整合

1、ApplicationContext.xml文件中
    a.配置数据源
    <!--配置C3P0数据源  -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/shhtest"></property>
        <property name="user" value="root"></property>
        <property name="password" value="root"></property>
    </bean>
    b.配置SessionFactory对象
    <!--配置SessionFactory 此步为Spring与Hibernate整合的关键  -->
    <bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="configLocations" value="classpath:hibernate.cfg.xml"></property>
    </bean>
    c.配置Hibernate事务管理器
    <!-- 配置Hibernate事务管理器 -->
    <bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    d.配置Hibernate模板
    <!--配置Hibernate模板  -->
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
        <property name="sessionFactory" ref="sessionFactory"></property>
    </bean>
    e.配置事务通知
    <!-- 配置事务通知 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="find*" read-only="true"/>
            <tx:method name="save*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    f.配置AOP切点与事务通知组装
    <!--配置事务通知与aop切点组装  -->
    <aop:config>
        <aop:pointcut expression="execution(* cn.lx.service.impl.*.*(..))" id="myPointcut"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut"/>
    </aop:config>
2、hibernate.cfg.xml文件中
    除了不需要配置连接数据库信息，其他和以前一样
3、DAO实现类
    //HiernateTemplate模板，用于简化JDBC操作
    private HibernateTemplate hibernateTemplate;

    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }

其他知识点

1、Spring与Junit单元测试集成
    导入spring-test.jar包
    测试类中，加上注解
    @RunWith(SpringJUnit4ClassRunner.class)//表示使用spring的junit测试
    @ContextConfiguration("classpath:applicationContext.xml")//加载配置文件，获取容器
    @Autowired
    @Qualifier("accountService")
    private AccountService accountService;