Spring注解驱动之后再说事务

问题引入

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

1 声明式事务

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

Spring提供了@
EnableTransactionManagement注解在配置类（启动类）上启用支持事务，此时Spring会自动扫描具有@Transactional注解的类和方法。该注解相当于xml配置方式的 。通过设置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@Documentedpublic @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，不包含检查异常。    Classextends Throwable>[] rollbackFor() default {};    // 标识哪些异常不需要回滚事务    Classextends 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)@Overridepublic void testPropagation() {    stuService.saveParent();    stuService.saveChildren();    int a = 1 / 0;}// StuServiceImpl/* 测试事务传播 */@Transactional(propagation = Propagation.NESTED) // 切换NESTED/REQUIRES_NEW@Overridepublic void saveParent() {Stu stu = new Stu();stu.setName("parent");stu.setScore(100);stuMapper.insert(stu);}@Transactional(propagation = Propagation.NESTED)@Overridepublic void saveChildren() {saveChild1();int a = 1 / 0;saveChild2();}

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

// 同一个类@Transactional(propagation = Propagation.REQUIRED)@Overridepublic 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);}

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种，隔离级别的设置依赖当前数据库是否支持。

1. DEFAULT：使用当前数据库的默认隔离级别。例如Oracle是READ_COMMITED，MySQL是READ_REPEATED。
2. READ_UNCOMMITED：可导致脏读、不可重复读、幻读。
3. READ_COMMITTED：阻止脏读，可导致不可重复读、幻读。
4. REPEATABLE_READ：阻止脏读和不可重复读，可导致幻读。
5. 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。