基本概念

Spring家事务中的几个关键类：

1. TransactionManager
   1. PlatformTransactionManager ：用于命令式事务管理的事务管理器,定义了获取事务，回滚事务和提交事务的规范
   2. ReactiveTransactionManager ：用于响应式事务管理的事务管理器
2. TransactionException：事务异常，Spring家定义的事务超类，我们自定义事务异常时可以继承TransactionException
3. TransactionStatus ：getTransaction方法的返回值；TransactionStatus 可能表示新事务或可以表示现有事务
4. TransactionDefinition ：标准事务概念，包含了事务的传播行为，隔离级别，超时设置，是否只读状态等信息

声明式事务

1.使用说明

Spring的声明式事务可谓是其一大亮点了，做到了代码侵入性最小：在开启Spring声明式事务的环境下（即在配置类上标注EnableTransactionManagement注解），我们仅仅需要在需要事务管理的方法上标注@Transactional就能为该方法开启事务。既然是这两个注解就能让我们把事务交给Spring来管理，我们就来看看这两个注解的使用吧，具体的原理我们下节再来讲述。

2.@EnableTransactionManagement注解的源码解释

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {

    /**
     * 是否开启基于子类的Cglib动态代理，默认是基于接口的JDK动态代理
     */
    boolean proxyTargetClass() default false;

    /**
     * AOP的模式：基于代理的模式和基于Aspect织入的模式
     */
    AdviceMode mode() default AdviceMode.PROXY;

    /**
     * 设置增强器Advice的优先级order,从而可以控制事务控制逻辑在增强器链中的执行时机,
     * 默认是Ordered#LOWEST_PRECEDENCE
     */
    int order() default Ordered.LOWEST_PRECEDENCE;

}

3.@Transactional注解的源码解释：

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

    /**
     * 用来指定事务管理器
     */
    @AliasFor("transactionManager")
    String value() default "";
    /**
     * 用来指定事务管理器
     */
    @AliasFor("value")
    String transactionManager() default "";
    /**
     * 标签
     */
    String[] label() default {};
    /**
     * 事务的传播行为
     */
    Propagation propagation() default Propagation.REQUIRED;
    /**
     * 事务的隔离级别
     */
    Isolation isolation() default Isolation.DEFAULT;
    /**
     * 事务的超时时间int格式
     */
    int timeout() default TransactionDefinition.TIMEOUT_DEFAULT;
    /**
     * 事务的超时时间String格式
     */
    String timeoutString() default "";
    /**
     * 是否开启只读事务
     */
    boolean readOnly() default false;
    /**
     * 自动回滚的异常Class
     */
    Class<? extends Throwable>[] rollbackFor() default {};
    /**
     * 自动回滚的异常ClassName
     */
    String[] rollbackForClassName() default {};
    /**
     * 不自动回滚的异常Class
     */
    Class<? extends Throwable>[] noRollbackFor() default {};
    /**
     * 不自动回滚的异常ClassName
     */
    String[] noRollbackForClassName() default {};

}

使用案例：

    @Transactional
    public String sayHello(String name) {
        String result = "你好2" + name;
        applicationContext.publishEvent(new TransactionEvent(name));
        System.out.println(result);
        int length = name.length();
        return result + "-------2" + length;
    }

4.存在的问题：

失效的场景：（面试中常问的两种场景吧）

1. @Transactional 应用在非 public 修饰的方法上
2. 同一个类中方法调用（自调用），导致@Transactional失效

具体失效的原理我们后面说

    // 1.@Transactional 应用在非 public 修饰的方法上
    @Transactional
    private String sayHello(String name) {
        String result = "你好2" + name;
        applicationContext.publishEvent(new TransactionEvent(name));
        System.out.println(result);
        int length = name.length();
        return result + "-------2" + length;
    }

    // 2.自调用导致失效
    public void testA() {
        testB();
    }

    @Transactional
    public void testB() {
        System.out.println(" testB.... ");
    }

编程式事务

相较于声明式事务，可能编程式事务对于读者来说可能用的不多，Spring提供了两种程序化管理的方法：

1. 通过TransactionTemplate（命令式）或者TransactionalOperator（响应式）
2. 直接通过TransactionManager来实现

Spring家是十分推荐我们使用方法一来进行编程市事务的。TransactionTemplate中帮我们处理好了开启，回滚，提交事务等公共的方法，并且把业务的逻辑通过TransactionCallback的形式暴露给开发人员，这样我们只需要关注自己的业务逻辑代码就可以了，无需过多的关心事务的管理，一个例子如下：

    public class SimpleService implements Service {

    private final TransactionTemplate transactionTemplate;

    public SimpleService(PlatformTransactionManager transactionManager) {
        this.transactionTemplate = new TransactionTemplate(transactionManager);
    }

    public Object someServiceMethod() {
        return transactionTemplate.execute(new TransactionCallback() {
            public Object doInTransaction(TransactionStatus status) {
                updateOperation1();
                return resultOfUpdateOperation2();
            }
        });
    }
}

如果你的业务代码是没有返回值的，则可以实现TransactionCallbackWithoutResult来编写自己的业务逻辑：

    transactionTemplate.execute(new TransactionCallbackWithoutResult() {
    protected void doInTransactionWithoutResult(TransactionStatus status) {
        updateOperation1();
        updateOperation2();
    }
});

而基于TransactionManager来完成编程式事务，则是把开启事务，提交以及回滚的操作都完全交给程序员们来实现，因为我们发现TransactionTemplate的底层就是帮助我们实现了开启事务，提交以及回滚的这些公共操作，就好比是一个工具类嘛，这也是Spring推荐我们使用TransactionTemplate的原因，更方便，更安全。最后看一下，怎么完全基于TransactionManager来实现：

DefaultTransactionDefinition def = new DefaultTransactionDefinition();
// explicitly setting the transaction name is something that can be done only programmatically
def.setName("SomeTxName");
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

TransactionStatus status = txManager.getTransaction(def);
try {
    // put your business logic here
} catch (MyException ex) {
    txManager.rollback(status);
    throw ex;
}
txManager.commit(status);

事务绑定事件

前面我们就已经有讲解过Spring的常规事务逻辑，即我们可以通过@EventListener注册常规事件侦听器，没有看过而且不理解的可以去看看之前的文章，@EventListener的监听器会在监听到事件后就立即出发监听逻辑。而如果我们需要将其绑定到事务，即我们可以指定在事务的什么状态下执行这个监听器的逻辑，我们就需要使用@TransactionalEventListener。默认情况下侦听器绑定到事务的提交阶段，也就是当事务正常的提交了才会出发监听器的逻辑，这个的原理我们后面也会详细的讲解，在此先就介绍下如何使用。

关于监听器触发的时机，我们可以通过配置注解的phase属性来设置触发的时机，TransactionPhase的枚举有一下几个值：

1. AFTER_COMMIT - 默认设置，在事务提交后执行
2. AFTER_ROLLBACK - 在事务回滚后执行
3. AFTER_COMPLETION - 在事务完成后执行（不管是否成功）
4. BEFORE_COMMIT - 在事务提交前执行

使用案例：

@Service
public class CustomerService {

    private final UserRepository userRepository;
    private final ApplicationEventPublisher applicationEventPublisher;

    public CustomerService(UserRepository userRepository, ApplicationEventPublisher applicationEventPublisher) {
        this.userRepository = userRepository;
        this.applicationEventPublisher = applicationEventPublisher;
    }

    @Transactional
    public Customer createCustomer(User user) {
        User newUser = userRepository.save(user);
        final UserCreatedEvent event = new UserCreatedEvent(newUser);
        // 客户创建成功了才会发送短信
        applicationEventPublisher.publishEvent(event);
        return newUser;
    }
}

    
@Component
public class UserCreatedEventListener {

    private final EmailService emailService;

    public UserCreatedEventListener(EmailService emailService) {
        this.emailService = emailService;
    }

    @TransactionalEventListener
    public void processUserCreatedEvent(UserCreatedEvent event) {
        emailService.sendEmail(event.getUser().getEmail());
    }
}

总结

本文仅仅是介绍了Spring事务的相关概念，包含声明式事务、编程式事务以及事务监听相关的内容，具体的原理我们后面一一道来。