Spring—事务处理机制原理

本章内容大纲

使用JDBC传统方式处理事务：

//在一个需要事务处理的业务方法中必须的内容
Connection conn = getConnection();
conn.setAutoCommit(false);
...
// 业务实现的逻辑
...
if (true)
    conn.commit();
else if (false)
    conn.rollback();

• 由上述代码可以看出，在使用传统的事务处理策略时，对事务的管理并不全面，控制的模式相对单一许多功能无法实现。而spring的事务处理机制为这种问题提供了解决方案。

spring中事务处理机制的相关API

事务管理，其实就是根据给定的规则对事务执行提交或者回滚操作。spring中相关的接口有以下三个：
TransactionDefinition、PlatformTransactionManager 和 TransactionStatus

1. PlatformTransactionManager

// 事务管理器--用于对事务的管理
public interface PlatformTransactionManager {
    //获得事务状态
    TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException;
    //平事务提交方法
    void commit(TransactionStatus status) throws TransactionException;
    //事务回滚方法
    void rollback(TransactionStatus status) throws TransactionException;
}

2. TransactionDefinition

// 规则信息定义--定义事务相关的属性
public interface TransactionDefinition{
	// 获取隔离级别
    int getIsolationLevel();
    // 获取传播行为
    int getPropagationBehavior();
    // 获取超时时间
    int getTimeout();
    // 是否可读
    boolean isReadOnly();
}

3. TransactionStatus

// 事务的状态获取--事务管理的过程中，可以通过该接口中的方法获取事务的状态信息
public  interface TransactionStatus{
	// 当前事务是否是新的事务
    boolean isNewTransaction();
    // 是否有保存点
    boolean hasSavepoint();
    void setRollbackOnly();
    // 是否已被标记为回滚
    boolean isRollbackOnly();
}

TransactionDefinition 接口定义的事务规则

事务隔离级别、事务传播行为、事务超时、事务的只读属性和事务的回滚规则，下面我们一一详细介绍。

1. 事务隔离级别

• 所谓事务的隔离级别是指若干个并发的事务之间的隔离程度。TransactionDefinition 接口中定义了五个表示隔离级别的常量：
  

2. 事务传播行为

• 所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。TransactionDefinition接口定义了如下几个表示传播行为的常量：
  1. PROPAGATION_REQUIRED :支持当前事务，如果不存在 就新建一个
  - 如果A有事务，B使用A的事务，如果A没有事务，B就开启一个新的事务.(A,B是在一个事务中。)
  2. PROPAGATION_SUPPORTS :支持当前事务，如果不存在，就不使用事务
  - 如果A有事务，B使用A的事务，如果A没有事务，B就不使用事务.
  3. PROPAGATION_MANDATORY :支持当前事务，如果不存在，抛出异常
  - 如果A有事务，B使用A的事务，如果A没有事务，抛出异常.
  4. PROPAGATION_REQUIRES_NEW 如果有事务存在，挂起当前事务，创建一个新的事务
  - 如果A有事务，B将A的事务挂起，重新创建一个新的事务.(A,B不在一个事务中.事务互不影响.)
  5. PROPAGATION_NOT_SUPPORTED 以非事务方式运行，如果有事务存在，挂起当前事务
  - 非事务的方式运行，A有事务，就会挂起当前的事务.
  6. PROPAGATION_NEVER 以非事务方式运行，如果有事务存在，抛出异常
  7. PROPAGATION_NESTED 如果当前事务存在，则嵌套事务执行

3. 事务超时
   　　事务超时，就是指一个事务被允许执行的最长时间，如果超过该时间限制且事务还没有完成，就会自动回滚事务。(单位是秒)
4. 事务的只读属性
   　　事务的只读属性是指，对事务性资源进行只读操作或者是读写操作。如果确定只对事务性资源进行查询操作，那么我们可以将事务标志为只读的，可以提高事务处理的性能。（boolean控制）
5. 事务的回滚规则
   　　通常情况下，如果在事务中抛出了未检查异常，则默认将回滚事务。如果没有抛出任何异常，或者抛出了已检查异常，则仍然提交事务。

一、编程式事务

编程式事务是基于传统的事务处理思路，采用在程序中显式的调用commit()、rollback()等事务管理的方法，来实现对事务的控制。编程式事务有两种实现方法，下面为编程式事务的实例：

1. 基于API

public class AdminServiceImpl implements AdminService {
    private AdminDao adminDao;
    // 定义规则信息接口的对象
    private TransactionDefinition txDefinition;
    // 事务管理器接口的对象
    private PlatformTransactionManager txManager;
    // 通过id修改admin的信息
    public boolean modifyAdminInf(Integer id, Admin admin) {
        // 通过管理器使用规则信息获取一个事务,并启动
        TransactionStatus txStatus = txManager.getTransaction(txDefinition);
        boolean result = false;
        try {
            result = adminDao.updateAdminById(id, admin);
            txManager.commit(txStatus);// 事务提交
        } catch (Exception e) {
            result = false;
            txManager.rollback(txStatus);// 事务回滚
            System.out.println("Modify Error!");
        }
        return result;
    }
}

<bean id="AdminService " class="org.lanqiao.service.AdminServiceImpl ">
    <property name="adminDao" ref="adminDao"/>
    <property name="txManager" ref="transactionManager"/>
    <property name="txDefinition">
    <bean class="org.springframework.transaction.support.DefaultTransactionDefinition">
        <property name="propagationBehaviorName" value="PROPAGATION_REQUIRED"/>
    </bean>
    </property>
</bean>

2. 基于 TransactionTemplate

public class AdminServiceImpl implements AdminService {
	private AdminDao adminDao;
    private TransactionTemplate transactionTemplate;
    ......
    public boolean modifyAdminInf(Integer id, Admin admin) {
    	return (Boolean) transactionTemplate.execute(new TransactionCallback(){
            public Object doInTransaction(TransactionStatus status) {
                Object result;
                try {
                	result = adminDao.updateAdminById(id, admin);
                } catch (Exception e) {
                	status.setRollbackOnly();
                	result = false;
                	System.out.println("Modify Error!");
                }
                return result;
            }
        });
    }
}

<bean id="AdminService " class="org.lanqiao.service.AdminServiceImpl ">
    <property name="adminDao" ref="adminDao"/>
    <property name="transactionTemplate" ref="transactionTemplate"/>
</bean>

从以上两个实现方式可以看出，虽然使用TransactionTemplate可以解决事务处理与程序之间耦合的问题，但是过程过于繁琐。spring中有以下声明式事务来解决耦合和处理复杂的问题。

二、声明式事务

Spring 的声明式事务管理是建立在 Spring AOP 机制之上的，他本质是对目标方法所在的切面织入事务操作（创建或者加入一个事务；执行提交或者回滚事务。）

1、使用 Spring 的事务注解管理事务

通过@Transactional 注解方式，可将事务织入到相应 public 方法中，实
现事务管理。

1. @Transactional 的所有可选属性如下所示：
   1. propagation：用于设置事务传播属性。该属性类型为 Propagation 枚举，
      默认值为 Propagation.REQUIRED。
   2. isolation：用于设置事务的隔离级别。该属性类型为 Isolation 枚举，默认
      值为 Isolation.DEFAULT。
   3. readOnly：用于设置该方法对数据
      库的操作是否是只读的。该属性为
      boolean，默认值为 false。
   4. timeout：用于设置本操作与数据库连接的超时时限。单位为秒，类型为 int，
      默认值为-1，即没有时限。
   5. rollbackFor：指定需要回滚的异常类。类型为 Class[]，默认值为空数组。
      当然，若只有一个异常类时，可以不使用数组。
   6. rollbackForClassName：指定需要回滚的异常类类名。类型为 String[]，默
      认值为空数组。当然，若只有一个异常类时，可以不使用数组。
   7. noRollbackFor：指定不需要回滚的异常类。类型为 Class[]，默认值为空数
      组。当然，若只有一个异常类时，可以不使用数组。
   8. noRollbackForClassName：指定不需要回滚的异常类类名。类型为 String[]，
      默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

• Spring 会忽略掉所有非public 方法上的@Transaction 注解。
• 若@Transaction 注解在类上，则表示该类上所有的方法均将在执行时织入事务。

2. 具体步骤

   1. 声明事务管理器
      

   2. 开启注解驱动
      

   3. 业务层 public 方法加入事务属性

2、使用 AspectJ的AOP配置管理事务

使用 XML 配置事务代理的方式的不足是，每个目标类都需要配置事务代理。当目标类较多，配置文件会变得非常臃肿。而解决这个问题可以使用 XML 配置顾问方式可以自动为每个符合切入点表达式的类生成事务代理。

1. maven 依赖 pom.xml，新加入 aspectj 的依赖坐标

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aspects</artifactId>
	<version>5.2.5.RELEASE</version>
</dependency>

2. 在容器中添加事务管理器
3. 配置事务通知，为事务通知设置相关属性。用于指定要将事务以什么方式织入给哪些方法。
   
4. 配置增强器，指定将配置好的事务织入给哪个方法。