深刻理解Spring声明式事务

问题引入

Spring中事务传播有哪几种，分别是怎样的？

理解注解事务的自动配置？

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

声明式事务的实现原理？（待补充）

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注解

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。

参考文档