一、spring事务管理架构

image

1. PlatformTranscationManager

• 通过这个接口，spring为各个平台如JDBC、Hibernate、JtA、JPA等提供了统一的事务管理API，所以spring本身并不直接管理事务，而是将事务的管理托管给各个持久化平台的实现。

2. TranscationStatus

• 描述事务状态
  • isNewTransaction
  • hasSavePoint
  • isRollBackOnly
  • isConpleted

3. TranscationManager

• 事务管理器
  • 在这里顺便提一下，问什么要使用spring的事务管理，如果不使用的话，即手动进行事务管理，那么如果底层用的是JDBC事务，就需要在services层（处理事务的层）加入很多JDBC依赖的事务处理代码（Connection、Datasource），如果是Hibernate，就需要加入很多Session相关的代码，所以如果需要在这几种平台之间互换的话，需要改很多业务层的代码，而Spring的事务管理就相当于为这些不同平台的事务管理接口提供了一个统一的API，这样即使平台不同，但是在业务层使用的代码都是相同的（都是使用PlatFormTransactionManager这个接口提供的API），这样一来，如果需要更改平台，就不需要更改业务层的代码。
  • spring事务管理就是一个典型的策略模式，通过为其注入不同的事务管理器的实现，进而支持不同持久化方案的事务管理**
  • JDBC：JDBC是通过java.sql.connection来管理事务，后者是由datasource获得的。

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

  • HIbernate：Hibernate的事务是通过org.hibernate.Transcation来实现的，后者是从Hibernate Session 获得的。

  <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
      <property name="sessionFactory" ref="sessionFactory" />
  </bean>
  

4. TranscationDefinition

• 定义事务属性

image

5. 事务传播行为

• 当在一个事务方法中调用另一个事务方法时，要指定事务应该如何传播，比如是新建一个事务还是在当前事务继续执行。

• 嵌套事务的特点是：外层事务失败的时候回回滚内层事务，而内层事务的异常不会引起外层事务的回滚，嵌套事务是外部事务的一部分，启动嵌套事务的时候回保存一个savepoint，如果失败回回滚到这个保存点，嵌套事务只有在外层事务执行成功的时候才会commit。

• 而require_new不会回滚内层事务，它是启动一个新的，不依赖于当前事务的环境，

• 隔离规则

  • 定义一个事务可能受其他并发事务的影响程度
  • 并发事务引起的问题

6. 回滚规则

• 定义了事务在遇到哪些异常才会回滚，

7. 是否只读

• 事务设置为只读之后有利于数据库对该操作进行相关的优化

8. 事务超时

• 事务一旦超时就会自动回

二 、 Spring编程式事务

1. 使用TransactionTemplate

image

• 由上可知，TransactionDefinition是用来定义事务的属性的，所以TransactionTemplate也就具备了配置事务的能力，另外还需要为其指定TransactionManager，用来实现底层事务的管理。

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">  
    <property name="driverClassName">  
        <value>com.mysql.jdbc.Driver</value>  
    </property>  
    <property name="url">  
        <value>${jdbc.mgr.url}</value>  
    </property>  
    <property name="username">  
        <value>${jdbc.mgr.user}</value>  
    </property>  
    <property name="password">  
        <value>${jdbc.mgr.password}</value>  
    </property>  
</bean>
<bean id="sessionFactory"  
      class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">  
    <property name="dataSource" ref="dataSource"/>  
    <property name="packagesToScan">  
        <list>  
            <!-- 可以加多个包 -->  
            <value>com.cuilei01.mgr.utils</value>  
        </list>  
    </property>  
    <property name="hibernateProperties">  
        <props>  
  
            <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>  
            <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>  
        </props>  
    </property>  
</bean>  
<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
    <property name="sessionFactory" ref="sessionFactory"></property>  
</bean>  
<!-- 配置transactionTemplate -->  
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">  
    <property name="transactionManager" ref="transactionManager"></property>  
    <!--定义事务隔离级别,-1表示使用数据库默认级别-->  
    <property name="readOnly" value="false"></property>  
    <property name="isolationLevelName" value="ISOLATION_DEFAULT"></property>  
    <property name="propagationBehaviorName" value="PROPAGATION_REQUIRED"></property>  
</bean>  

• 然后就可以在代码中注入bean并使用

@ContextConfiguration(locations = {"classpath:applicationContext.xml"})  
@RunWith(SpringJUnit4ClassRunner.class)  
public class TransactionTest {  
  
    private final Logger logger = LoggerFactory.getLogger(TransactionTest.class);  
  
    @Resource  
    private TransactionTemplate transactionTemplate;  
  
    @Test  
    public void testProgrammaticTransaction() {  
        logger.info("Begin test programmatic transaction!########################");  
        // 第一个事务  
        Integer result = transactionTemplate.execute(new TransactionCallback<Integer>() {  
            @Override  
            public Integer doInTransaction(TransactionStatus status) {  
                logger.info("Do in transaction with a return value!#####################################");  
                // 在事务中执行, 有返回值  
                return 1;  
            }  
        });  
  
        logger.info("result:{}", result);  
  
        // 第二个事务  
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {  
            @Override  
            protected void doInTransactionWithoutResult(TransactionStatus status) {  
                logger.info("Do in transaction without a return value!#####################################");  
                // 在事务中执行,没有返回值  
            }  
        });  
    }  

• 2. 使用PlatformTranscationManager
  • 其实现步骤基本和TransactionTemplate相同，spring推荐使用后者

三、Spring声明式事务管理

• 声明式事务管理式建立在AOP基础上的，其本质是在方法执行的前后进行拦截，然后再目标方法开始之前开启一个事务，或者加入一个已经存在的事务， 在执行完方法之后根据情况是否提交或者回滚，。声明式事务管理的优点就是不需要使用代码管理事务，所以也就不需要再业务层加入事务管理相关的代码，将所有事务管理相关的代码都放到配置文件中。此外，声明式事务管理还符合spring的“非侵入式”的编程原则，使得业务代码不受污染，一个普通的POJO只需要简单的加上注解就可以获得事务管理的支持，相比于编程式事务的缺点是粒度比后者大，只到方法级别，编程式事务可以管理到代码块级别。
• 以mybatis为例，基于上面一步已经配置好数据源和对应平台的事务管理器.
  • 开启注解支持

  <!-- 开启事务控制的注解支持 -->  
  <tx:annotation-driven transaction-manager="transactionManager"/></span></span>  
  

  • 添加tx名字空间

  xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd"  
  

  • 在需要使用事务的方法或者类上加上注解，并设置相关事务属性

  @Autowired  
  private MyBatisDao dao;  
    
  @Transactional  
  @Override  
  public void insert(Test test) {  
      dao.insert(test);  
      throw new RuntimeException("test");//抛出unchecked异常，触发事物，回滚  
  } 
  

• 相关事务属性如下：

noRollbackForClassName 类名数组，必须继承自Throwable 不会导致事务回滚的异常类名字数组