Spring：事务管理

来源：http://www.360doc.com/content/10/0906/22/3183606_51725538.shtml


Spring不会直接去管理事务，它提供了很多可供选择的事务管理器,将事务委托给JTA或某些特定的平台事务实现。常见的Spring事务管理器:
       
        org.springframework.jdbc.datasource.DataSourceTransactionManager
      提供JDBC事务支持,也可以用来支持iBatis
        org.springframework.orm.hibernate.HibernateTransactionManager
      Hibernate2持久事务支持
        org.springframework.orm.hibernate.HibernateTransactionManager
      Hibernate3持久事务支持
        org.springframework.orm.jpa.JpaTransactionManager JPA持久事务支持

       这些都是一些持久性事务，也是平时用的最多的（尤其是对我这种天天CRUD的人）

      OK!知道了这一点我们便可以在Spring中编写事务,最常用的方法是使用TransactionTemplate,如果你用过Spring的JdbcTemplate的话就会觉的它跟这个用法很像。
      首先我们需要声明一个Spring的事务管理器。我们知道，使用JdbcTemplate需要一个数据源，使用事务那么也需要一个声明一个事务管理器:
                 

      <bean id="transactionManager"
      class="org.springframework.jdbc.datasoure.DataSoureTransactionManager">
         <property name="dataSource" ref="dataSource"/>
      </bean>

      这是JDBC的事务管理器，它有一个dataSource属性，指向要操作的数据源.接下来我们要写一个用户注册的服务（我实在举不出什么好例子来了）：

      public class UserService {
         
          @Autowired
          private TransactionTemplate transactionTemplate;
         
              @Autowired
          private UserDAO userDAO; 
         
              @Autowired
          private MailSender sender;
         
          public UserService(){
             
          }

          public void reg(final User user){
              transactionTemplate.execute(new TransactionCallback(){
                  public Object doInTransaction(TransactionStatus ts){
                      try{
                          userDAO.insert(user);
                          sender.send();
                      }
                      catch(Exception e){
                          ts.setRollbackOnly();
                      }
                     
                      return null;
                  }
              });
          }
      }

      注册服务分为两个步骤，一个是将用户的信息插入到数据库，二是向用户发送邮件激活通知。这两个步骤是原子性的（好吧），因此需要使用事务支持,事务操作主要是通过

      TransactionTemplate来实现的,我们需要在Spring配置文件中配置它：
      <bean id="transactionTemplate"
      class="org.springframework.transaction.support.TransactionTemplate">
          <property name="transactionManager" ref="transactionManager"/>
      </bean>
      属性transactionManager指向前面声明的JDBC事务管理器
      我们只需要将事务代码放入到doInTransaction方法中即可，如果doIntransaction能够被成功执行到return，则事务将被提交，如果中途遇到问题，如Exception,则调用

      setRollbackOnly()方法回滚整个事务

      Spring对声明式事务的支持：
      嗯~~上面这段代码不是很好，为啥？因为reg服务应该只去管用户注册这个事情，但是它现在却包含了很多事务处理的代码，违反了单一原则，这时候你可能会想到AOP,能不

      能使用AOP来处理事务呢？嗯，开发Spring的大牛们当然会去想到这一点，他们为此提供了声明式事务的支持，这个支持也是通过Spring的AOP框架来实现的。

      什么是声明式事务？就是通过配置文件和注解等方式来进行事务的声明，而不去侵犯程序代码，这样就不会违背单一职责原则了。

      Spring中的声明式事务是使用参数来定义的，一个参数就是对事务策略应该如何应用到某个方法的一段描述，这些参数名字很长，比我的发型还恶心。
      传播行为：传播行为定义了关于客户端和被调用方法的事务边界
      1. PROPAGATION_REQUIRED: 如果存在一个事务，则支持当前事务。如果没有事务则开启
      2. PROPAGATION_SUPPORTS: 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行
      3. PROPAGATION_MANDATORY: 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。
      4. PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。
      5. PROPAGATION_NOT_SUPPORTED: 总是非事务地执行，并挂起任何存在的事务。
      6. PROPAGATION_NEVER: 总是非事务地执行，如果存在一个活动事务，则抛出异常
      7. PROPAGATION_NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务,
      则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行
      隔离级别：隔离级别定义了事务受并发活动的影响程度
      1. ISOLATION_DEFAULT：
这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.
            另外四个与JDBC的隔离级别相对应
      2. ISOLATION_READ_UNCOMMITTED： 这是事务最低的隔离级别，它充许令外一个事务可以看到这个事务未提交的数据。
            这种隔离级别会产生脏读，不可重复读和幻像读。
      3. ISOLATION_READ_COMMITTED： 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据
      4. ISOLATION_REPEATABLE_READ： 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。
            它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。
      5. ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。
            除了防止脏读，不可重复读外，还避免了幻像读

      关于脏读(Dirty read)、不可重复读(Nonrepeatable read)和幻读(Phantom reads)的介绍：
      脏读：如果事务A读取了事务B改写但是尚未提交的数据，事务B发生了问题（来了大姨妈？）回滚了，那么A所读取的数据是无效的，这个故事叫做脏读
      不可重复读：如果一个事务多次读取数据，每一次结果都不同，这是由于另一个事务在更改数据，这个故事叫做不可重复读
      幻读：幻读跟不可重复读差不多，如果一个事务A读取了数据，事务B又插入了一些数据，在后来的查询中事务A发现了一些额外的记录

      很简单？哈哈.看看在Spring中如何使用声明式事务:
      Spring2.0开始为事务提供了配置元素
      首先需要在Spring配置文件中添加AOP支持，因为Spring声明式事务是基于AOP的，然后在加入事务标签支持：
      命名空间：
       xmlns:tx="http://www.springframework.org/schema/tx"
      Schema声明：
       http://www.springframework.org/schema/tx
      http://www.springframework.org/schema/tx/spring-tx-2.0.xsd

      接下来我们只需要添加如下配置内容就可以使用声明式事务了：
      <!- 这个就不详细说了，添加AOP支持  -->
      <aop:config>
         <aop:pointcut  expression="execution(* *. .UserServicce.reg(..)"/>
         <aop:advisor  advice-ref="txAdvice"/>
      </aop:config>
      <!-- 重点是下面 -->
      <tx:advice id="txAdvice" transaction-manager="transactionManager">
         <tx:attributes>
          <tx:method name="reg" propagation="REQUIRED"/>
         </tx:attributes>
      </tx:advice>

      <tx:advice>用来声明事务策略，同样需要指定一个事务管理器，这个是必须的，我们知道Spring不会自己去管理事务的，它一向喜欢代理，让人看起来好像一切都是它的功

      劳，嗯！

      <tx:attribute>声明了事务参数，<tx:method>是需要提供事务支持的方法，需要注意的是它有这么几个参数:
      isolation:指定事务隔离级别
      no-rollback-for:对于哪些异常不回滚（设计者咋就想的这么周到呢！？）
      propagation:事务的传播级别
      read-only:该事务只读
      rollback-for:哪些异常发生之后回滚
      timeout:定义事务超时

      唉~~配置文件还是太恶心了，要是有注解~~嗯，还真有：
      首先要添加一个注解驱动标签：<tx:annotation-driven transaction-manager="txManager"/>
      然后我们使用@Transactional注解，这个注解可以修饰类也可以修饰方法，修饰类的话将作用于该类所有的方法，注解的参数同<tx:method>的参数，另外有一个很酷的地方

      是如果UserService是一个接口，那么我给他使用了@Transactional()注解，那么它的一系列实现类UserServiceImpl1、UserServiceImpl2……UserServiceImpl10000都会自

      动支持该声明事务

      完！事务很重要！