Spring事务管理详解

喜欢ヅ旅行 2023-09-29 15:49 8阅读 0赞

## 什么是事务 ##

**事务是逻辑上的一组操作，要么都执行，要么都不执行。**

需要注意的是：**事务能否生效数据库引擎是否支持事务是关键。比如常用的 MySQL 数据库默认使用支持事务的 innodb引擎。但是，如果把数据库引擎变为 myisam，那么程序也就不再支持事务了！**

## 事务的特性（ACID） ##

*  **原子性**：一个事务（transaction）中的所有操作，或者全部完成，或者全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。即，事务不可分割、不可约简。
 *  **一致性**：在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设约束、触发器、级联回滚等。
 *  **隔离性**：数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离分为不同级别，包括未提交读（Read uncommitted）、提交读（read committed）、可重复读（repeatable read）和串行化（Serializable）。
 *  **持久性**：事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

## spring支持两种方式的事务管理 ##

### 一、编程式事务管理 ###

通过 TransactionTemplate或者TransactionManager手动管理事务，实际应用中很少使用，但是对于你理解 Spring 事务管理原理有帮助。  
使用TransactionTemplate 进行编程式事务管理的示例代码如下：

@Autowired
    private TransactionTemplate transactionTemplate;
    public void testTransaction() {
        
    
            transactionTemplate.execute(new TransactionCallbackWithoutResult() {
        
                @Override
                protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
        
    
                    try {
        
    
                        // ....  业务代码
                    } catch (Exception e){
        
                        //回滚
                        transactionStatus.setRollbackOnly();
                    }
    
                }
            });
    }

使用 TransactionManager 进行编程式事务管理的示例代码如下：

@Autowired
    private PlatformTransactionManager transactionManager;
    
    public void testTransaction() {
        
    
      TransactionStatus status = transactionManager.getTransaction(new DefaultTransactionDefinition());
              try {
        
                   // ....  业务代码
                  transactionManager.commit(status);
              } catch (Exception e) {
        
                  transactionManager.rollback(status);
              }
    }

### 二、声明式事务管理 ###

推荐使用（代码侵入性最小），**实际是通过 AOP 实现**（基于@Transactional 的全注解方式使用最多）。  
使用 @Transactional注解进行事务管理的示例代码如下：

@Transactional(propagation=propagation.PROPAGATION_REQUIRED)
    public void aMethod {
        
      //do something
      B b = new B();
      C c = new C();
      b.bMethod();
      c.cMethod();
    }

## Spring事务管理接口介绍 ##

Spring 框架中，事务管理相关最重要的 3 个接口如下：

*  **PlatformTransactionManager**： （平台）事务管理器，Spring 事务策略的核心。
 *  **TransactionDefinition**： 事务定义信息(事务隔离级别、传播行为、超时、只读、回滚规则)。
 *  TransactionStatus：事务运行状态

我们可以把 PlatformTransactionManager 接口可以被看作是**事务上层的管理者**，而 TransactionDefinition 和 TransactionStatus 这两个接口可以看作是事务的描述。

PlatformTransactionManager 会根据 TransactionDefinition 的定义比如事务超时时间、隔离级别、传播行为等来进行事务管理 ，而 TransactionStatus 接口则提供了一些方法来获取事务相应的状态比如是否新事务、是否可以回滚等等。

### PlatformTransactionManager:事务管理接口 ###

Spring 并不直接管理事务，而是提供了多种事务管理器 。Spring 事务管理器的接口是：**PlatformTransactionManager**。

通过这个接口，Spring 为各个平台如 JDBC(DataSourceTransactionManager)、Hibernate(HibernateTransactionManager)、JPA(JpaTransactionManager)等都提供了对应的事务管理器，但是具体的实现就是各个平台自己的事情了。

PlatformTransactionManager接口中定义了三个方法：

package org.springframework.transaction;
    
    import org.springframework.lang.Nullable;
    
    public interface PlatformTransactionManager {
        
        //获得事务
        TransactionStatus getTransaction(@Nullable TransactionDefinition var1) throws TransactionException;
        //提交事务
        void commit(TransactionStatus var1) throws TransactionException;
        //回滚事务
        void rollback(TransactionStatus var1) throws TransactionException;
    }

**为什么要定义或者抽象出来PlatformTransactionManager这个接口呢？**  
主要是因为要将事务管理行为抽象出来，然后不同的平台去实现它，这样我们可以保证提供给外部的行为不变，方便我们扩展。

### TransactionDefinition:事务属性 ###

事务管理器接口 PlatformTransactionManager 通过 getTransaction(TransactionDefinition definition) 方法来得到一个事务，这个方法里面的参数是 TransactionDefinition 类 ，这个类就定义了一些基本的事务属性。

**什么是事务属性？**  
事务属性可以理解成事务的一些基本配置，描述了事务策略如何应用到方法上。

事务属性包含了5个方面：

*  隔离级别
 *  传播行为
 *  回滚规则
 *  是否只读
 *  事务超时

TransactionDefinition 接口中定义了 5 个方法以及一些表示事务属性的常量比如隔离级别、传播行为等等。

package org.springframework.transaction;
    
    import org.springframework.lang.Nullable;
    
    public interface TransactionDefinition {
        
        int PROPAGATION_REQUIRED = 0;
        int PROPAGATION_SUPPORTS = 1;
        int PROPAGATION_MANDATORY = 2;
        int PROPAGATION_REQUIRES_NEW = 3;
        int PROPAGATION_NOT_SUPPORTED = 4;
        int PROPAGATION_NEVER = 5;
        int PROPAGATION_NESTED = 6;
        int ISOLATION_DEFAULT = -1;
        int ISOLATION_READ_UNCOMMITTED = 1;
        int ISOLATION_READ_COMMITTED = 2;
        int ISOLATION_REPEATABLE_READ = 4;
        int ISOLATION_SERIALIZABLE = 8;
        int TIMEOUT_DEFAULT = -1;
        // 返回事务的传播行为，默认值为 REQUIRED。
        int getPropagationBehavior();
        //返回事务的隔离级别，默认值是 DEFAULT
        int getIsolationLevel();
        // 返回事务的超时时间，默认值为-1。如果超过该时间限制但事务还没有完成，则自动回滚事务。
        int getTimeout();
        // 返回是否为只读事务，默认值为 false
        boolean isReadOnly();
    
        @Nullable
        String getName();
    }

### TransactionStatus:事务状态 ###

**TransactionStatus接口用来记录事务的状态 该接口定义了一组方法,用来获取或判断事务的相应状态信息。**

PlatformTransactionManager.getTransaction(…)方法返回一个 TransactionStatus 对象。

**TransactionStatus接口内容：**

public interface TransactionStatus{
        
        boolean isNewTransaction(); // 是否是新的事务
        boolean hasSavepoint(); // 是否有恢复点
        void setRollbackOnly();  // 设置为只回滚
        boolean isRollbackOnly(); // 是否为只回滚
        boolean isCompleted; // 是否已完成
    }

## 事务传播行为 ##

**事务传播行为是为了解决业务层方法之间互相调用的事务问题。**

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事物，并在自己的事务中运行。

举个例子：我们在 A 类的aMethod（）方法中调用了 B 类的 bMethod() 方法。这个时候就涉及到业务层方法之间互相调用的事务问题。如果我们的 bMethod()如果发生异常需要回滚，如何配置事务传播行为才能让 aMethod()也跟着回滚呢？这个时候就需要事务传播行为的知识了，如果你不知道的话一定要好好看一下。

Class A {
        
        @Transactional(propagation=propagation.xxx)
        public void aMethod {
        
            //do something
            B b = new B();
            b.bMethod();
        }
    }
    
    Class B {
        
        @Transactional(propagation=propagation.xxx)
        public void bMethod {
        
           //do something
        }
    }

在TransactionDefinition定义中包括了如下几个表示传播行为的常量：

public interface TransactionDefinition {
        
        int PROPAGATION_REQUIRED = 0;
        int PROPAGATION_SUPPORTS = 1;
        int PROPAGATION_MANDATORY = 2;
        int PROPAGATION_REQUIRES_NEW = 3;
        int PROPAGATION_NOT_SUPPORTED = 4;
        int PROPAGATION_NEVER = 5;
        int PROPAGATION_NESTED = 6;
        ......
    }

不过如此，为了方便使用，Spring 会相应地定义了一个枚举类：Propagation

package org.springframework.transaction.annotation;
    
    import org.springframework.transaction.TransactionDefinition;
    
    public enum Propagation {
        
    
        REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),
    
        SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),
    
        MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),
    
        REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),
    
        NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),
    
        NEVER(TransactionDefinition.PROPAGATION_NEVER),
    
        NESTED(TransactionDefinition.PROPAGATION_NESTED);
    
        private final int value;
    
        Propagation(int value) {
        
            this.value = value;
        }
    
        public int value() {
        
            return this.value;
        }
    
    }

**正确的事务传播行为可能的值如下：**  
**1、TransactionDefinition.PROPAGATION\_REQUIRED**  
使用的最多的一个事务传播行为，我们平时经常使用的@Transactional注解默认使用就是这个事务传播行为。如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。也就是说：

*  如果外部方法没有开启事务的话，Propagation.REQUIRED修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰。
 *  如果外部方法开启事务并且被Propagation.REQUIRED的话，所有Propagation.REQUIRED修饰的内部方法和外部方法均属于同一事务 ，只要一个方法回滚，整个事务均回滚。

举个例子：**如果我们上面的aMethod()和bMethod()使用的都是PROPAGATION\_REQUIRED传播行为的话，两者使用的就是同一个事务，只要其中一个方法回滚，整个事务均回滚。**

Class A {
        
        @Transactional(propagation=propagation.PROPAGATION_REQUIRED)
        public void aMethod {
        
            //do something
            B b = new B();
            b.bMethod();
        }
    }
    
    Class B {
        
        @Transactional(propagation=propagation.PROPAGATION_REQUIRED)
        public void bMethod {
        
           //do something
        }
    }

**2、TransactionDefinition.PROPAGATION\_REQUIRES\_NEW**  
![在这里插入图片描述][220e54fb49d145a0bf439fc516579863.png]  
**PROPAGATION\_REQUIRES\_NEW内层事务执行完就立即提交。与外层毫无关联**

创建一个新的事务，如果当前存在事务，则把当前事务挂起。也就是说不管外部方法是否开启事务，**Propagation.REQUIRES\_NEW修饰的内部方法会新开启自己的事务，且开启的事务相互独立，互不干扰**。

举个例子：如果我们上面的bMethod()使用PROPAGATION\_REQUIRES\_NEW事务传播行为修饰，aMethod还是用PROPAGATION\_REQUIRED修饰的话。如果aMethod()发生异常回滚，bMethod()不会跟着回滚，因为 bMethod()开启了独立的事务。但是，如果 bMethod()抛出了未被捕获的异常并且这个异常满足事务回滚规则的话,aMethod()同样也会回滚，因为这个异常被 aMethod()的事务管理机制检测到了。

Class A {
        
        @Transactional(propagation=propagation.PROPAGATION_REQUIRED)
        public void aMethod {
        
            //do something
            B b = new B();
            b.bMethod();
        }
    }
    
    Class B {
        
        @Transactional(propagation=propagation.REQUIRES_NEW)
        public void bMethod {
        
           //do something
        }
    }

**3、TransactionDefinition.PROPAGATION\_NESTED**  
如果当前存在事务，就在嵌套事务内执行；如果当前没有事务，就执行与TransactionDefinition.PROPAGATION\_REQUIRED类似的操作。  
![在这里插入图片描述][4427ca2d1bb941d49316ecdf241c9736.png]  
PROPAGATION\_NESTED：嵌套事务呈现父子事务概念，二者之间是有关联的，**核心思想就是子事务不会独立提交，而是取决于父事务，当父事务提交，那么子事务才会随之提交；如果父事务回滚，那么子事务也回滚**。

但是子事务又有自己的特性，**那就是可以独立进行回滚，不会引发父事务整体的回滚(当然需要try catch子事务，避免异常传递至父层事务，如果没有，则也会引发父事务整体回滚)。这个特性比较有意思，虽然不能独立提交，但是可以独立回滚。**

子事务可以独立回滚，也可以通过传递异常，让父事务也回滚，根源在于用户策略，在父事务通过try catch 对子事务进行包裹，灵活策略；

**4、TransactionDefinition.PROPAGATION\_MANDATORY**  
如果当前存在事务，则加入该事务，如果当前没有事务，则抛出异常（mandatory：强制性）。

## 事务隔离级别 ##

TransactionDefinition 接口中定义了五个表示隔离级别的常量：

public interface TransactionDefinition {
        
        ......
        int ISOLATION_DEFAULT = -1;
        int ISOLATION_READ_UNCOMMITTED = 1;
        int ISOLATION_READ_COMMITTED = 2;
        int ISOLATION_REPEATABLE_READ = 4;
        int ISOLATION_SERIALIZABLE = 8;
        ......
    }

和事务传播行为这块一样，为了方便使用，Spring 也相应地定义了一个枚举类：**Isolation**

public enum Isolation {
        
    
      DEFAULT(TransactionDefinition.ISOLATION_DEFAULT),
    
      READ_UNCOMMITTED(TransactionDefinition.ISOLATION_READ_UNCOMMITTED),
    
      READ_COMMITTED(TransactionDefinition.ISOLATION_READ_COMMITTED),
    
      REPEATABLE_READ(TransactionDefinition.ISOLATION_REPEATABLE_READ),
    
      SERIALIZABLE(TransactionDefinition.ISOLATION_SERIALIZABLE);
    
      private final int value;
    
      Isolation(int value) {
        
        this.value = value;
      }
    
      public int value() {
        
        return this.value;
      }
    
    }

下面我依次对每一种事务隔离级别进行介绍：  
1）TransactionDefinition.ISOLATION\_DEFAULT : 使用后端数据库默认的隔离级别，**MySQL 默认采用的 REPEATABLE\_READ（可重复读） 隔离级别** Oracle 默认采用的 READ\_COMMITTED 隔离级别。

2）TransactionDefinition.ISOLATION\_READ\_UNCOMMITTED :最低的隔离级别，使用这个隔离级别很少，因为它允许读取尚未提交的数据变更，**可能会导致脏读、幻读或不可重复读**。

3）TransactionDefinition.ISOLATION\_READ\_COMMITTED : 允许读取并发事务已经提交的数据，**可以阻止脏读，但是幻读或不可重复读仍有可能发生。**

4）TransactionDefinition.ISOLATION\_REPEATABLE\_READ : 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，**可以阻止脏读和不可重复读，但幻读仍有可能发生。**

5）TransactionDefinition.ISOLATION\_SERIALIZABLE : 最高的隔离级别，完全服从 ACID 的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，**该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。**

## 事务超时属性 ##

所谓事务超时，**就是指一个事务所允许执行的最长时间，如果超过该时间限制但事务还没有完成，则自动回滚事务**。在 TransactionDefinition 中以 int 的值来表示超时时间，其单位是秒，默认值为-1。

## 事务只读属性 ##

package org.springframework.transaction;
    
    import org.springframework.lang.Nullable;
    
    public interface TransactionDefinition {
        
        ......
        // 返回是否为只读事务，默认值为 false
        boolean isReadOnly();
    
    }

对于只有读取数据查询的事务，可以指定事务类型为 readonly，即只读事务。只读事务不涉及数据的修改，数据库会提供一些优化手段，适合用在有多条数据库查询操作的方法中。

**很多人就会疑问了，为什么我一个数据查询操作还要启用事务支持呢？**  
如果不加Transactional，每条sql会开启一个单独的事务，中间被其它事务改了数据，都会实时读取到最新值。

分享一下关于事务只读属性，其他人的解答：  
**1）如果你一次执行单条查询语句，则没有必要启用事务支持，数据库默认支持sql执行期间的读一致性。  
2）如果你一次执行多条查询语句，例如统计查询，报表查询，这这种场景下，多查询sql必须保证整个的读一致性，否则，在前条sql查询之后，后条sql查询之前，数据被其他用户改变，则该此整体的统计查询将会出现读数据不一致的状态，此时，应该启用事务支持。**

## 事务回滚规则 ##

这些规则定义了哪些异常会导致事务回滚而哪些不会。默认情况下\*\*，事务只有遇到运行期异常（RuntimeException 的子类）时才会回滚，Error 也会导致事务回滚，但是，在遇到检查型（Checked）异常时不会回滚。\*\*  
![在这里插入图片描述][259e7815736744f5affa5e559e0fa214.png]  
如果你想要回滚你定义的特定的异常类型的话，可以这样：

@Transactional(rollbackFor= MyException.class)

## @Transactional 注解使用详解 ##

### 1、作用范围 ###

1）方法：推荐将注解使用于方法上，不过需要注意的是：**该注解只能应用到 public 方法上，否则不生效。**

2）类：如果这个注解使用在类上的话，**表明该注解对该类中所有的 public 方法都生效**。

3）接口 ：**不推荐在接口上使用**。

### @Transactional 的常用配置参数 ###

@Transactional注解源码如下，里面包含了基本事务属性的配置：

@Target({
        ElementType.TYPE, ElementType.METHOD})
    @Retention(RetentionPolicy.RUNTIME)
    @Inherited
    @Documented
    public @interface Transactional {
        
    
    	@AliasFor("transactionManager")
    	String value() default "";
    
    	@AliasFor("value")
    	String transactionManager() default "";
    
    	Propagation propagation() default Propagation.REQUIRED;
    
    	Isolation isolation() default Isolation.DEFAULT;
    
    	int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
    
    	boolean readOnly() default false;
    
    	Class<? extends Throwable>[] rollbackFor() default {
        };
    
    	String[] rollbackForClassName() default {
        };
    
    	Class<? extends Throwable>[] noRollbackFor() default {
        };
    
    	String[] noRollbackForClassName() default {
        };
    
    }

**@Transactional 的常用配置参数总结**  
![在这里插入图片描述][3c258a63c02c45e68cd62ab4fd83532f.png]

### 2、@Transactional事务注解原理 ###

我们知道，**@Transactional 的工作机制是基于 AOP 实现的，AOP 又是使用动态代理实现的。如果目标对象实现了接口，默认情况下会采用 JDK 的动态代理，如果目标对象没有实现了接口,会使用 CGLIB 动态代理**。  
多提一嘴：createAopProxy() 方法 决定了是使用 JDK 还是 Cglib 来做动态代理，源码如下：

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
        
    
    	@Override
    	public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        
    		if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
        
    			Class<?> targetClass = config.getTargetClass();
    			if (targetClass == null) {
        
    				throw new AopConfigException("TargetSource cannot determine target class: " +
    						"Either an interface or a target is required for proxy creation.");
    			}
    			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
        
    				return new JdkDynamicAopProxy(config);
    			}
    			return new ObjenesisCglibAopProxy(config);
    		}
    		else {
        
    			return new JdkDynamicAopProxy(config);
    		}
    	}
      .......
    }

**如果一个类或者一个类中的 public 方法上被标注@Transactional 注解的话，Spring 容器就会在启动的时候为其创建一个代理类，在调用被@Transactional 注解的 public 方法的时候，实际调用的是，TransactionInterceptor 类中的 invoke()方法。这个方法的作用就是在目标方法之前开启事务，方法执行过程中如果遇到异常的时候回滚事务，方法调用完成之后提交事务。**

## Spring AOP自调用问题 ##

**如果同一个类中的其他没有@Transactional注解的方法内部调用有@Transactional 注解的方法，有@Transactional 注解的方法的事务会失效。**

这是由于Spring AOP代理的原因造成的，因为**只有当 @Transactional 注解的方法在类以外被调用的时候，Spring 事务管理才生效**。

MyService 类中的method1()调用method2()就会导致method2()的事务失效

@Service
    public class MyService {
        
    
    private void method1() {
        
         method2();
         //......
    }
    @Transactional
     public void method2() {
        
         //......
      }
    }

解决办法就是避免同一类中自调用或者使用 AspectJ 取代 Spring AOP 代理。

## @Transactional 的使用注意事项总结 ##

1）@Transactional 注解只有作用到 public 方法上事务才生效，不推荐在接口上使用；  
2）避免同一个类中调用 @Transactional 注解的方法，这样会导致事务失效；  
3）正确的设置 @Transactional 的 rollbackFor 和 propagation 属性，否则事务可能会回滚失败;  
4）被 @Transactional 注解的方法所在的类必须被 Spring 管理，否则不生效；  
5）底层使用的数据库必须支持事务机制，否则不生效。

[220e54fb49d145a0bf439fc516579863.png]: https://img-blog.csdnimg.cn/220e54fb49d145a0bf439fc516579863.png
[4427ca2d1bb941d49316ecdf241c9736.png]: https://img-blog.csdnimg.cn/4427ca2d1bb941d49316ecdf241c9736.png
[259e7815736744f5affa5e559e0fa214.png]: https://img-blog.csdnimg.cn/259e7815736744f5affa5e559e0fa214.png
[3c258a63c02c45e68cd62ab4fd83532f.png]: https://img-blog.csdnimg.cn/3c258a63c02c45e68cd62ab4fd83532f.png