问题引入

1. Spring中事务传播有哪几种，分别是怎样的？
2. 理解注解事务的自动配置？
3. SpringBoot启动类为什么不需要加@EnableTransactionManagement注解？
4. 声明式事务的实现原理？（待补充）

1 声明式事务

系统开发中必然与数据打交道，事务管理必不可少。Spring支持声明式事务，通过*@Transactional注解控制方法是否支持事务。声明式事务，基于AOP实现，将具体业务和业务逻辑解耦。

Spring提供了@EnableTransactionManagement注解在配置类（启动类）上启用支持事务，此时Spring会自动扫描具有@Transactional注解的类和方法。该注解相当于xml配置方式的 <tx:annotation-driven />。通过设置mode属性，决定使用spring代理，还是ASPECTJ扩展。

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
   boolean proxyTargetClass() default false;
   AdviceMode mode() default AdviceMode.PROXY; // 代理模式
   int order() default Ordered.LOWEST_PRECEDENCE; // LOWEST_PRECEDENCE最低优先级，所以在执行链的最外面，而自己实现的AOP拦截器优先级都高于事务，所以被嵌套在里面，越贴近业务代码。
}
复制代码

2 @Transactional注解的使用

2.1 @Transactional注解属性

@Transactional注解可以应用于类和方法。声明类时，该注解默认作用于类和子类的所有方法，应用于public方法才有效；父类方法要加入同等级别的注解，需要单独声明。

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Transactional {

    @AliasFor("transactionManager")
    String value() default "";

    // 用来确定目标事务管理器
    @AliasFor("value")
    String transactionManager() default "";

    // 事务的传播，默认Propagation.REQUIRED
    Propagation propagation() default Propagation.REQUIRED;

    // 事务隔离级别，默认是Isolation.DEFAULT
    Isolation isolation() default Isolation.DEFAULT;

    // 事务超时时间，默认是-1
    int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;

    // 指定事务是否为只读事务，默认为false，仅仅是个提示
    boolean readOnly() default false;

    // 标识能触发事务回滚的异常类型，默认是RuntimeException和Error，不包含检查异常。
    Class<? extends Throwable>[] rollbackFor() default {};

    // 标识哪些异常不需要回滚事务
    Class<? extends Throwable>[] noRollbackFor() default {};

    String[] noRollbackForClassName() default {};
    String[] rollbackForClassName() default {};
}
复制代码

特别注意：isolation和timeout两个属性仅对新启动的事务有效，专为Propagation.REQUIRED和Propagation.REQUIRES_NEW使用而设计。

2.2 事务的传播行为-Propagation

Propagation定义了事务的传播，一共有7种级别。

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;
    }
}
复制代码

• REQUIRED：使用当前的事务，如果当前没有事务，则自己新建一个事务，子方法是必须运行在一个事务中的；如果当前存在事务，则加入这个事务，成为一个整体。
  举例：领导没饭吃，我有钱，那么我会自己买了吃；领导有的吃，会分给你一起吃。
• SUPPORTS：如果当前有事务，则使用事务；如果当前没有事务，则不使用事务。多用于查询。
  举例：领导没饭吃，我也没饭吃；领导有饭吃，我也有饭吃。
• MANDATORY：传播属性强制必须存在一个事务，如果不存在，则会抛出异常。
  举例：领导必须管饭，不管饭就没饭吃，我就不干了（就会抛出异常）。
• REQUIRES_NEW：如果当前有事务，则挂起该事务，并且自己创建一个新的事务给自己使用；如果当前没有事务，则同意 REQUIRED
  举例：领导有饭吃，我偏不要，自己买东西自己吃 1.标志REQUIRES_NEW会新开启事务，外层事务不会影响内部事务的提交/回滚。内部提交修改，会导致A的脏读。 2.标志REQUIRES_NEW的内部事务异常，会影响外部事务的回滚
• NOT_SUPPORTED：如果当前有事务，则把事务挂起，自己不使用事务运行数据库操作
  举例：领导有饭吃，分一点给你，我太忙了，放一边，我不吃
• NEVER：如果当前有事务存在，则抛出异常
  举例：领导有饭给你吃，我不想吃，果断抛出异常
• NESTED：如果当前存在事务，则开启子事务（嵌套事务）；如果当前没有事务，则同 REQUIRED。但是*如果主事务提交，则会携带子事务一起提交。如果主事务会回滚，则子事务会一起回滚。*相反，子事务异常，则父事务可以回滚或不回滚（trycatch）。
  举例：领导决策不对，老板怪罪，领导带着小弟一同受罪；小弟出了差错，领导可以推卸责任。

区分NESTED与REQUIRES_NEW

最根本的区别是NESTED还在一个事务中，但是与主事务一块提交。

// TransactionalServiceImpl
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void testPropagation() {
    stuService.saveParent();
    stuService.saveChildren();
    int a = 1 / 0;
}

// StuServiceImpl
/* 测试事务传播 */
@Transactional(propagation = Propagation.NESTED) // 切换NESTED/REQUIRES_NEW
@Override
public void saveParent() {
	Stu stu = new Stu();
	stu.setName("parent");
	stu.setScore(100);
	stuMapper.insert(stu);
}

@Transactional(propagation = Propagation.NESTED)
@Override
public void saveChildren() {
	saveChild1();
	int a = 1 / 0;
	saveChild2();
}
复制代码

一个容易疏漏的点

在代理模式（默认）下，仅可接通过代理传入的外部方法调用。这意味着同一个目标对象内部的方法调用，即使调用的方法标记有@Transactional，也不会在运行时导致事务拦截。

// 同一个类
@Transactional(propagation = Propagation.REQUIRED)
@Override
public void saveChildren() {
    saveChild1();
    int a = 1 / 0;
    saveChild2();
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void saveChild1() {
    Stu stu = new Stu();
    stu.setName("child-1");
    stu.setScore(60);
    stuMapper.insert(stu);
}
复制代码

参考官方文档

In proxy mode (which is the default), only external method calls coming in through the proxy 
are intercepted. This means that self-invocation, in effect, a method within the target object 
calling another method of the target object, will not lead to an actual transaction at runtime 
even if the invoked method is marked with @Transactional. Also, the proxy must be fully 
initialized to provide the expected behaviour so you should not rely on this feature in your 
initialization code, i.e. @PostConstruct.

在代理模式下（默认），只有通过代理进入的外部方法调用才会被拦截。 这意味着自调用实际上是目标对象中的一个方
法调用目标对象的另一个方法，即使被调用的方法用@Transactional 标记，也不会在运行时导致实际事务。 此外，
代理必须完全初始化以提供预期的行为，因此您不应在初始化代码中依赖此功能，即@PostConstruct。

复制代码

2.3 事务的隔离级别-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;
    }
}
复制代码

Spring事务隔离级别共有5种，隔离级别的设置依赖当前数据库是否支持。

• DEFAULT：使用当前数据库的默认隔离级别。例如Oracle是READ_COMMITED，MySQL是READ_REPEATED。
• READ_UNCOMMITED：可导致脏读、不可重复读、幻读。
• READ_COMMITTED：阻止脏读，可导致不可重复读、幻读。
• REPEATABLE_READ：阻止脏读和不可重复读，可导致幻读。
• SERIALIZABLE：该级别下事务顺序执行，阻止上面的缺陷，开销很大。

3 SpringBoot启动类为什么不需要加@EnableTransactionManagement注解

其实我自己很关注的是这个点，一般现在开发都是使用SpringBoot平台了。

org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration
复制代码

SpringBoot加载spring.factories时，会加载事务配置类TransactionAutoConfiguration，内部有开启事务管理的配置。

// ~TransactionAutoConfiguration中的内部类
@Configuration(proxyBeanMethods = false)
@ConditionalOnBean(TransactionManager.class)
@ConditionalOnMissingBean(AbstractTransactionManagementConfiguration.class)
public static class EnableTransactionManagementConfiguration {

    @Configuration(proxyBeanMethods = false)
    @EnableTransactionManagement(proxyTargetClass = false)
    @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false", matchIfMissing = false)
    public static class JdkDynamicAutoProxyConfiguration {

    }

    @Configuration(proxyBeanMethods = false)
    @EnableTransactionManagement(proxyTargetClass = true)
    @ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",matchIfMissing = true)
    public static class CglibAutoProxyConfiguration {

    }
}
复制代码

4 Spring声明式事务的内部实现机制

在应用系统调用声明@Transactional 的目标方法时，Spring Framework 默认使用 AOP 代理，结合AOP和事务元数据（注解）在代码运行时生成一个代理对象，根据@Transactional 的属性配置信息，这个代理对象决定该声明@Transactional 目标方法是否有拦截器 TransactionInterceptor 来使用拦截，在 TransactionInterceptor 拦截时，会在目标方法开始执行之前创建并加入事务，并执行目标方法的逻辑, 最后根据执行情况是否出现异常，利用抽象事务管理器AbstractPlatformTransactionManager 操作数据源 DataSource 提交或回滚事务。

事务管理的框架是由抽象事务管理器 AbstractPlatformTransactionManager 来提供的，而具体的底层事务处理实现由 PlatformTransactionManager 的具体实现类型来实现，如事务管理器 DataSourceTransactionManager。不同的事务管理器管理不同的数据资源 DataSource，比如 DataSourceTransactionManager 管理 JDBC 的 Connection。