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

 复制代码 隐藏代码// 单元测试
class TransactionTemplateTest(){
  @Autowired
  private ProgrammaticTrasaction programmaticTrasaction;
/**
   * 使用TransactionTemplate 进行事务处理
   */
  @Test
  public void transactionTemplateTest(){
    programmaticTrasaction.insert();
  }
}

@Component
public class ProgrammaticTrasaction {
        // 异常触发开关
    private static final boolean EXCEPTION_FLAG = true;

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Autowired
    private TransactionTemplate transactionTemplate;

    public void insert(){
        // 1. 构建事务管理器，同时使用系统的数据源进行设置
        PlatformTransactionManager platformTransactionManager = new DataSourceTransactionManager(Objects.requireNonNull(jdbcTemplate.getDataSource()));
        // 2. 配置事务的属性，比如事务的隔离级别，事务的超时时间以及隔离方式等等
        TransactionDefinition transactionDefinition = new DefaultTransactionDefinition();
        // 3. 开启事务，通过默认的事务属性配置，调用platformTransactionManager.getTransaction开启事务操作，此时获取到事务的状态 TransactionStatus
        TransactionStatus transaction = platformTransactionManager.getTransaction(transactionDefinition);
        // 4. 执行和事务有关操作，这里用新增作为处理
        System.err.println("查询数据列表");

        try {
            System.err.println(jdbcTemplate.queryForList("select * from admin"));
            // 注意，jdbctemplate 把所有对于数据的改动操作统一为 update 操作，而查询则以 query 开头
            jdbcTemplate.update("insert into admin (id, username, password) values (51, '老王', '123')");
            jdbcTemplate.update("insert into admin (id, username, password) values (21, '老张', '222')");
            // 5. 提交事务
            platformTransactionManager.commit(transaction);
            // 6. 手动抛出异常进行回滚
            //if(EXCEPTION_FLAG){
            //  throw new RuntimeException("手动抛出异常");
            //}
        } catch (Exception e) {
            // 6. 我们需要使用事务管理器的rollback方法回滚整个事务
            System.err.println("异常：触发事务回滚");
            platformTransactionManager.rollback(transaction);
        }
        System.err.println("插入数据之后");
        System.err.println(jdbcTemplate.queryForList("select * from admin"));

    }/*运行结果：
    第一次执行
    查询数据列表
    [{id=1, username=admin, password=123456}]
    插入数据之后
    [{id=1, username=admin, password=123456}, {id=21, username=老张, password=222}, {id=51, username=老王, password=123}]
    第二次执行：
    查询数据列表
    [{id=1, username=admin, password=123456}, {id=21, username=老张, password=222}, {id=51, username=老王, password=123}]
    触发事务回滚
    插入数据之后
[{id=1, username=admin, password=123456}, {id=21, username=老张, password=222}, {id=51, username=老王, password=123}]
    */

}

 复制代码 隐藏代码public interface PlatformTransactionManager extends TransactionManager {

   /**
   开启一个新的事务
  */
  TransactionStatus getTransaction(home.php?mod=space&uid=1043391 TransactionDefinition definition)
      throws TransactionException;

  /**
   提交一个事务
   */
  void commit(TransactionStatus status) throws TransactionException;

  /**
   事务回滚
   */
  void rollback(TransactionStatus status) throws TransactionException;

}

复制代码 隐藏代码@Override
   public final TransactionStatus getTransaction(@Nullable TransactionDefinition definition)
           throws TransactionException {

       // 检查是否传递事务属性TransactionDefinition，如果没有则使用默认配置。
       TransactionDefinition def = (definition != null ? definition : TransactionDefinition.withDefaults());
       // 由具体的数据源获取一个事务，比较常用的是
       Object transaction = doGetTransaction();
       boolean debugEnabled = logger.isDebugEnabled();

       if (isExistingTransaction(transaction)) {
           // 检查当前是否已经存在事务，则根据事务的传播等级进行判断，新建事务或者抛出异常等处理
           return handleExistingTransaction(def, transaction, debugEnabled);
       }

       // 检查事务超时时间是否设置 
       if (def.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
           throw new InvalidTimeoutException("Invalid transaction timeout", def.getTimeout());
       }

       // 如果没有发现事务，则检查是否事务传播级别异常
       if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
           throw new IllegalTransactionStateException(
                   "No existing transaction found for transaction marked with propagation 'mandatory'");
       }
       else if (def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
               def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
               def.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
           SuspendedResourcesHolder suspendedResources = suspend(null);
           if (debugEnabled) {
               logger.debug("Creating new transaction with name [" + def.getName() + "]: " + def);
           }
           try {
        // 开启事务
               return startTransaction(def, transaction, debugEnabled, suspendedResources);
           }
           catch (RuntimeException | Error ex) {
               resume(null, suspendedResources);
               throw ex;
           }
       }
       else {
           // 创建“空”事务：没有实际事务，但可能是同步的。
           if (def.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
               logger.warn("Custom isolation level specified but no actual transaction initiated; " +
                       "isolation level will effectively be ignored: " + def);
           }

           boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
           return prepareTransactionStatus(def, null, true, newSynchronization, debugEnabled, null);
       }
   }

 复制代码 隐藏代码// 使用threadlocal 绑定一个全局共享的全局变量
private static final ThreadLocal<Map<Object, Object>> resources =
      new NamedThreadLocal<>("Transactional resources");

DataSource dataSource = platformTransactionManager.getDataSource();
// 下面为事务管理器获取细节 ====>
// 从全局共享变量获取当前线程对应的资源池
Map map = resources.get();
// actualKey => 为实际的对象（aop为实际对象）
ConnectionHolder localConnectionHolder = resources.get(actualKey, map.get(actualKey));
if(map.isEmpty()){
// 额外检查当前线程是否还存在连接器存在于全局变量中，如果不存在则移除当前的线程资源释放，避免被释放的线程对象堆积在共享资源
  resources.remove();
}
//设置手动提交事务
localConnectionHolder.setAutoCommit(false);
map.put(datasource,connection);
resources.set(map);
// <==========

复制代码 隐藏代码public void update(){
       // 1.2 不需要使用事务管理器，而是直接在transactionTemplate内部集成
       // 3. 区别点，这里使用了transactionTemplate进行事务的开启和控制，下面介绍他的两种主要使用方式
       // 3.1  transactionTemplate.executeWithoutResult(Consumer<TransactionStatus> action)：
       // 没有返回值的，需传递一个Consumer对象，在accept方法中做业务操作。（类似切面）
       // 3.2 <T> T execute(TransactionCallback<T> action)：有返回值的，需要传递一个TransactionCallback对象，在doInTransaction方法中做业务操作
       // 调用execute方法或者executeWithoutResult方法执行完毕之后，事务管理器会自动提交事务或者回滚事务。
       // 事务在什么情况下会进行回滚？需要满足下面的条件：
       // （1）transactionStatus.setRollbackOnly();将事务状态标注为回滚状态
       // （2）execute方法或者executeWithoutResult方法内部抛出异常
       //  什么时候事务会提交？
       //  方法没有异常 && 未调用过transactionStatus.setRollbackOnly();
       System.err.println("事务处理前");
       System.err.println(jdbcTemplate.queryForList("select * from admin"));
       // 第一种使用方式
       transactionTemplate.executeWithoutResult(transactionStatus -> {
           jdbcTemplate.update("update admin set username ='test2'  where id = '51'");

           jdbcTemplate.update("update admin set username ='test2',password='1111'  where id = '21'");
       });
       // 第二种使用方式
       DefaultTransactionStatus execute = (DefaultTransactionStatus) transactionTemplate.execute((TransactionCallback<Object>) status -> {
           jdbcTemplate.update("update admin set username ='test2'  where id = '51'");

           jdbcTemplate.update("update admin set username ='test2',password='1111'  where id = '21'");
           return status;
       });
       System.err.println("事务处理后");
       System.err.println(jdbcTemplate.queryForList("select * from admin"));
   }/*运行结果：
       事务处理前
       [{id=1, username=admin, password=123456}, {id=21, username=老张, password=222}, {id=51, username=老王, password=123}]
       事务处理后
       [{id=1, username=admin, password=123456}, {id=21, username=test2, password=1111}, {id=51, username=test2, password=123}]
   */

 复制代码 隐藏代码class TransactionOperations{
    /**
    带返回值的方法
  */
  @Nullable
    <T> T execute(TransactionCallback<T> action) throws TransactionException;

  /**
  jdk8 的接口默认方法,不带返回值的使用方式
  @since：5.2
  */
  default void executeWithoutResult(Consumer<TransactionStatus> action) throws TransactionException {
        execute(status -> {
            action.accept(status);
            return null;
        });
    }
    /**
        返回 TransactionOperations 接口的实现，该接口在没有实际事务的情况下执行给定的 TransactionCallback。通常在测试的时候使用：该行为相当于在没有实际事务 (PROPAGATION_SUPPORTS) 和没有同步 (SYNCHRONIZATION_NEVER) 的情况下使用事务管理器运行。
  对于具有实际事务处理的 TransactionOperations 实现，将 TransactionTemplate 与适当的 PlatformTransactionManager 一起使用。
  @since：5.2
  @see：
  TransactionDefinition.PROPAGATION_SUPPORTS, 
  AbstractPlatformTransactionManager.SYNCHRONIZATION_NEVER, 
  TransactionTemplate

    */
  static TransactionOperations withoutTransaction() {
        return WithoutTransactionOperations.INSTANCE;
    }
}

 复制代码 隐藏代码
/**
说明：
  在事务中执行给定回调对象指定的操作。允许返回在事务中创建的结果对象，
  即域对象或域对象的集合。回调抛出的 RuntimeException 被视为强制回滚的异常。
  这样的异常会传播到模板的调用者。
参数：
  action - 指定事务操作的回调对象
  返回：
    回调返回的结果对象，如果没有，则为 null
    抛出：
      TransactionException - 在初始化、回滚或系统错误的情况下
      RuntimeException - 由 TransactionCallback 抛出

*/
@Override
  @Nullable
  public <T> T execute(TransactionCallback<T> action) throws TransactionException {
  // 检查当前是否存在事务管理器（不允许为空）
    Assert.state(this.transactionManager != null, "No PlatformTransactionManager set");
  // 如果当前事务管理器支持自动回调处理，则使用事务管理器自动回调方法的实现，CallbackPreferringPlatformTransactionManager 类扩展自PlatformTransactionManager，公开了在事务中执行给定回调的方法。
    if (this.transactionManager instanceof CallbackPreferringPlatformTransactionManager) {
      return ((CallbackPreferringPlatformTransactionManager) this.transactionManager).execute(this, action);
    }
    else {
    // 如果不支持自动回调，则转入到传统的处理模式，这部分代码和原始的事务管理操作类似
      TransactionStatus status = this.transactionManager.getTransaction(this);
      T result;
      try {
      // 核心部分，使用action的函数式调用实现内部的事务处理
        result = action.doInTransaction(status);
      }
      catch (RuntimeException | Error ex) {
        // 如何出现 RuntimeException 或者 错误 回滚
        rollbackOnException(status, ex);
        throw ex;
      }
      catch (Throwable ex) {
         // 异常则根据事务级别进行回滚
        rollbackOnException(status, ex);
        throw new UndeclaredThrowableException(ex, "TransactionCallback threw undeclared checked exception");
      }
      // 如果没有出现异常，则正常提交
      this.transactionManager.commit(status);
      // 返回事务执行的结果
      return result;
    }
  }

 复制代码 隐藏代码/**
在事务中执行给定 Runnable 指定的操作。
如果需要从回调中返回一个对象或从回调中访问 TransactionStatus，可以改用 execute(TransactionCallback)。
这样的变体类似于使用 TransactionCallbackWithoutResult 但具有针对常见情况的简化签名 - 并且可以方便地与 Java 8 lambda 表达式一起使用。
参数：
action - 指定事务操作的 Runnable
抛出：
TransactionException - 在初始化、回滚或系统错误的情况下
RuntimeException - 如果由 Runnable 抛出
*/
default void executeWithoutResult(Consumer<TransactionStatus> action) throws TransactionException {
    execute(status -> {
      action.accept(status);
      return null;
    });
  }

复制代码 隐藏代码  @Override
   @Transactional(rollbackFor = Exception.class)
   public void testAdd() {
       //dosomething
   }

 复制代码 隐藏代码@Configuration
@EnableTransactionManagement
public class MySpringConfig {

    @Bean
    public PlatformTransactionManager txManager() {
        // dosomething 可以自己配置事一些事务管理器的配置。
        return yourTxManager; 
    }

}

 复制代码 隐藏代码public void createCourseDefaultRatingProgramatic(Course course) {
    try {
       courseDao.create(course);
    } catch (Exception e) {
        // 手动回滚
       TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
}

 复制代码 隐藏代码@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Transactional(transactionManager = "order", label = "causal-consistency")
public @interface OrderTx {
}

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Transactional(transactionManager = "account", label = "retryable")
public @interface AccountTx {
}

 复制代码 隐藏代码@Component
public class MyComponent {

    @TransactionalEventListener
    public void handleOrderCreatedEvent(CreationEvent<Order> creationEvent) {
        // ...
    }
}

 复制代码 隐藏代码
TransactionPhase phase() default TransactionPhase.AFTER_COMMIT;

 复制代码 隐藏代码public class UserService {

    @Autowired
    private SessionFactory sessionFactory; // (1)

    public void registerUser(User user) {
        // 开启连接
        Session session = sessionFactory.openSession(); // (2)

        // 开启一个JPA的事务
        session.beginTransaction();

        // 执行一个insert操作
        session.save(user);

        // 提交事务
        session.getTransaction().commit();

        // 关闭连接
        session.close();
    }
}

 复制代码 隐藏代码
@Transactional(isolation=Isolation.DEFAULT,propagation=Propagation.REQUIRED,rollbackFor=BuyStockException.class) 

 复制代码 隐藏代码@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement

 复制代码 隐藏代码AdviceMode mode() default AdviceMode.PROXY;

-----分割线----
/**
    根据选择的代理模式生成不同的代理器
*/
@Override
    protected String[] selectImports(AdviceMode adviceMode) {
        switch (adviceMode) {
        // 默认都会走JDK的代理
            case PROXY:
                return new String[] {AutoProxyRegistrar.class.getName(),
                        ProxyTransactionManagementConfiguration.class.getName()};
        // 如果选择ApectJ，可以参考下面的代码
            case ASPECTJ:
                return new String[] {determineTransactionAspectClass()};
            default:
                return null;
        }
    }

复制代码 隐藏代码@Override
   public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
       boolean candidateFound = false;
       Set<String> annTypes = importingClassMetadata.getAnnotationTypes();
       for (String annType : annTypes) {
     // 解析和获取注解信息
           AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
           if (candidate == null) {
               continue;
           }
           Object mode = candidate.get("mode");
           Object proxyTargetClass = candidate.get("proxyTargetClass");
           if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&
                   Boolean.class == proxyTargetClass.getClass()) {
       // 校验是否设置开启代理，如果配置则查看是否为JDK代理
               candidateFound = true;
               if (mode == AdviceMode.PROXY) {
         // 核心代码，如果有必要就创建一个自动代理创建器
                   AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
                   if ((Boolean) proxyTargetClass) {
           // 强制将自动代理创建器绑定到用户代理
                       AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
                       return;
                   }
               }
           }
       }
       //......
   }

复制代码 隐藏代码@Nullable
   private static BeanDefinition registerOrEscalateApcAsRequired(
           Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
       // 断言是否存在Bean，BeanDefinitionRegistry就是Spring容器中Bean的实际存在形式
       Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
       // 注册器先判断是否有注入org.springframework.aop.config.internalAutoProxyCreator
       if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
           BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
           if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
       // 这里根据优先级获取，第一次进来的时候是肯定没有注入的
               int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
               int requiredPriority = findPriorityForClass(cls);
               if (currentPriority < requiredPriority) {
                   apcDefinition.setBeanClassName(cls.getName());
               }
           }
           return null;
       }
       // 可以看作是将InfrastructureAdvisorAutoProxyCreator包装成RootBeanDefinition
       RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
       beanDefinition.setSource(source);
       beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
       beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
   // 核心部分：注入bean到ioc到容器当中，名字就是 org.springframework.aop.config.internalAutoProxyCreator
       registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
       return beanDefinition;
   }

复制代码 隐藏代码@Override
   public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
       if (bean != null) {
           Object cacheKey = getCacheKey(bean.getClass(), beanName);
           if (this.earlyProxyReferences.remove(cacheKey) != bean) {
       // 是否必要进行增强包装处理
               return wrapIfNecessary(bean, beanName, cacheKey);
           }
       }
       return bean;
   }

 复制代码 隐藏代码case PROXY:
return new String[] {AutoProxyRegistrar.class.getName(),
                     ProxyTransactionManagementConfiguration.class.getName()};

 复制代码 隐藏代码@Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor(
  TransactionAttributeSource transactionAttributeSource, TransactionInterceptor transactionInterceptor) {

  BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
  // 向切面中注入注解解析器,专门来解析事务注解的
  advisor.setTransactionAttributeSource(transactionAttributeSource);
  // 向切面中注入事务的拦截器,专门来拦截方法,包括事务的提交以及回滚操作
  advisor.setAdvice(transactionInterceptor);
  if (this.enableTx != null) {
    advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
  }
  return advisor;
}

 复制代码 隐藏代码public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
        this.publicMethodsOnly = publicMethodsOnly;
        if (jta12Present || ejb3Present) {
            this.annotationParsers = new LinkedHashSet<>(4);
      // spring注解解析器
            this.annotationParsers.add(new SpringTransactionAnnotationParser());
            if (jta12Present) {
        // jta解析起
                this.annotationParsers.add(new JtaTransactionAnnotationParser());
            }
            if (ejb3Present) {
        // ejb3的解析器
                this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
            }
        }
        else {
      // 使用spring注解解析器
            this.annotationParsers = Collections.singleton(new SpringTransactionAnnotationParser());
        }
    }

//调用org.springframework.transaction.annotation.SpringTransactionAnnotationParser#parseTransactionAnnotation方法，内部部分代码如下：
public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable {
  protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
        RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();

        Propagation propagation = attributes.getEnum("propagation");
        rbta.setPropagationBehavior(propagation.value());
        Isolation isolation = attributes.getEnum("isolation");
        rbta.setIsolationLevel(isolation.value());
        rbta.setTimeout(attributes.getNumber("timeout").intValue());
        rbta.setReadOnly(attributes.getBoolean("readOnly"));
        rbta.setQualifier(attributes.getString("value"));

        List<RollbackRuleAttribute> rollbackRules = new ArrayList<>();
        for (Class<?> rbRule : attributes.getClassArray("rollbackFor")) {
            rollbackRules.add(new RollbackRuleAttribute(rbRule));
        }
        for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
            rollbackRules.add(new RollbackRuleAttribute(rbRule));
        }
        for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
            rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
        }
        rbta.setRollbackRules(rollbackRules);

        return rbta;
    }
}

 复制代码 隐藏代码@Override
@Nullable
public Object invoke(MethodInvocation invocation) throws Throwable {
   // 计算出目标类：可能是{@code null}。 TransactionAttributeSource 应该传递目标类以及方法，这可能来自接口。
   Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

   // 适配方法执行
   return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
}

复制代码 隐藏代码@Nullable
   protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
           final InvocationCallback invocation) throws Throwable {

       // 如果事务属性为空，则该方法是非事务性的（就是非事务方式执行）
       TransactionAttributeSource tas = getTransactionAttributeSource();
       final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
       final TransactionManager tm = determineTransactionManager(txAttr);
       // 如果当前的注册器是响应式的，则按照响应式的方式处理
       if (this.reactiveAdapterRegistry != null && tm instanceof ReactiveTransactionManager) {
           // .......
       }

       PlatformTransactionManager ptm = asPlatformTransactionManager(tm);
       final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

       if (txAttr == null || !(ptm instanceof CallbackPreferringPlatformTransactionManager)) {
           // 使用 getTransaction 和 commit/rollback 调用进行事务划分。
           TransactionInfo txInfo = createTransactionIfNecessary(ptm, txAttr, joinpointIdentification);

           Object retVal;
           try {
               // 这是环绕通知，调用拦截链中的下一个拦截器。 实际会调用目标对象。
               retVal = invocation.proceedWithInvocation();
           }
           catch (Throwable ex) {
               // 目标方法调用失败
               completeTransactionAfterThrowing(txInfo, ex);
               throw ex;
           }
           finally {
       // 事务的后续清理操作
               cleanupTransactionInfo(txInfo);
           }
           // 
           if (retVal != null && vavrPresent && VavrDelegate.isVavrTry(retVal)) {
               // 如果符合回滚规则则进行回滚
               TransactionStatus status = txInfo.getTransactionStatus();
               if (status != null && txAttr != null) {
                   retVal = VavrDelegate.evaluateTryFailure(retVal, txAttr, status);
               }
           }
           // 未出现异常,也获取事务管理器则进行事务的提交
           commitTransactionAfterReturning(txInfo);
           return retVal;
       }
   // .......

复制代码 隐藏代码// 随机异常触发flag
   private static final boolean EXCEPTIN_FLAG = true;

   @Autowired
   private JdbcTemplate jdbcTemplate;

   /**
    * 事务失效的第一种情况：非事务方法调用事务方法
    */
       // 放开下面的注解即正常
       // @Transactional(rollbackFor = Exception.class)
   public void nonTransactionUseTrasaction(){
       System.out.println("发起转账");
       jdbcTemplate.update("update t_trans_test set amount=amount-100 where name='用户A'");
       innerMethod();
   }

   @Transactional(rollbackFor = Exception.class)
   public void innerMethod(){
       System.out.println("接受转账");
       if(EXCEPTIN_FLAG){
           throw new RuntimeException("转账失败");
       }
       jdbcTemplate.update("update t_trans_test set amount=amount+100 where name='用户B'");
   }/*运行结果：
   =========== 运行前数据准备重置数据 ========
   发起转账
   接受转账
   ====== 运行后查询操作结果 ======
   {id=1, name=用户A, amount=900}
   {id=2, name=用户B, amount=500}
   */

 复制代码 隐藏代码
//    @Transactional(rollbackFor = Exception.class)
    public void nonTransactionUseTrasaction(){
        System.out.println("发起转账");
//        jdbcTemplate.update("update t_trans_test set amount=amount-100 where name='用户A'");
        // 常见方式：注入自己
//        transactionTestService.innerMethod();
        // 使用代理对象方式1 ：AopContext.currentProxy()
//        TransactionTestService transactionTestService = (TransactionTestService) AopContext.currentProxy();
//        transactionTestService.innerMethod();
        // 第三种方法，注入 ApplicationContext
//        TransactionTestService transactionTestService = (TransactionTestService) applicationContext.getBean("transactionTestService");
//        transactionTestService.innerMethod();
        // 补充 - 获取Class: AopUtils.getTargetClass(yourObjectInstance);
//       AopUtils.getTargetClass(yourServiceClass);

    }

    @Transactional(rollbackFor = Exception.class)
    protected void innerMethod(){
        jdbcTemplate.update("update t_trans_test set amount=amount-100 where name='用户A'");
        System.out.println("接受转账");
        if(EXCEPTIN_FLAG){
            throw new RuntimeException("转账失败");
        }
        jdbcTemplate.update("update t_trans_test set amount=amount+100 where name='用户B'");
    }

复制代码 隐藏代码/**
    * 抛出不被处理的异常
    * @throws SQLException
    */
   @Transactional(rollbackFor = RuntimeException.class)
   public void throwErrorException() throws SQLException {
       jdbcTemplate.update("update t_trans_test set amount=amount-100 where name='用户A'");
       System.out.println("接受转账");
       if(EXCEPTIN_FLAG){
           throw new SQLException("转账失败");
       }
       jdbcTemplate.update("update t_trans_test set amount=amount+100 where name='用户B'");
   }/*运行结果：
   ========== 运行前数据准备重置数据 ========
   没有抛出支持回滚的异常测试
   接受转账
   ====== 运行后查询操作结果 ======
   {id=1, name=用户A, amount=900}
   {id=2, name=用户B, amount=500}

   */

复制代码 隐藏代码/**
    * 不抛出异常，导致不回滚
    */
   @Transactional(rollbackFor = Exception.class)
   public void nonThrowException(){
       System.out.println("发起转账");
       jdbcTemplate.update("update t_trans_test set amount=amount-1100 where name='用户A'");
       List<Map<String, Object>> maps = jdbcTemplate.queryForList("select * from t_trans_test where name='用户A'");
       Map<String, Object> stringObjectMap = maps.get(0);
       BigDecimal amount = new BigDecimal(stringObjectMap.get("amount").toString());
       if(amount.compareTo(BigDecimal.ZERO) < 0){
           log.error("余额不支持扣款");
       }
   }/*运行结果：
   =========== 运行前数据准备重置数据 ========
   没有抛出异常测试
   发起转账
   : 余额不支持扣款
   ====== 运行后查询操作结果 ======
   {id=1, name=用户A, amount=-100}
   {id=2, name=用户B, amount=500}
   */

 复制代码 隐藏代码 /**
     * 1。 TransactionDefinition.PROPAGATION_REQUIRED 测试
     * 不同隔离级别调用
     */
    //TransactionDefinition.PROPAGATION_REQUIRED
    @Transactional(rollbackFor = Exception.class, propagation = Propagation.REQUIRED)
    public void required(){
        jdbcTemplate.update("update t_trans_test set amount=amount-100 where name='用户A'");
        transactionTestService.requiredInner();
        if(EXCEPTIN_FLAG){
            throw new  RuntimeException("回滚事务");
        }
    }/*运行结果：
    =========== 运行前数据准备重置数据 ========
    ====== 运行后查询操作结果 ======
    {id=1, name=用户A, amount=1000}
    {id=2, name=用户B, amount=500}
    java.lang.RuntimeException: 回滚事务
    */
        // 注意这样使用会抛出异常
//    @Transactional(rollbackFor = RuntimeException.class, propagation = Propagation.NEVER)
    public void requiredInner(){
        jdbcTemplate.update("update t_trans_test set amount=amount+100 where name='用户B'");
    }

 复制代码 隐藏代码/**
     * 
     * Propagation.SUPPORTS 测试
     * 
     */
@Transactional(rollbackFor = Exception.class, propagation = Propagation.SUPPORTS)
public void required(){
  jdbcTemplate.update("update t_trans_test set amount=amount-100 where name='用户A'");
  transactionTestService.requiredInner();
  if(EXCEPTIN_FLAG){
    throw new  RuntimeException("回滚事务");
  }
}/*运行结果：
    =========== 运行前数据准备重置数据 ========
    ====== 运行后查询操作结果 ======
    {id=1, name=用户A, amount=900}
    {id=2, name=用户B, amount=600}

    java.lang.RuntimeException: 回滚事务
    */
public void requiredInner(){
  jdbcTemplate.update("update t_trans_test set amount=amount+100 where name='用户B'");
}

复制代码 隐藏代码/**

    * 2。 Propagation.SUPPORTS 测试
    * 3。
    */
   @Transactional(rollbackFor = Exception.class)
   public void required(){
       jdbcTemplate.update("update t_trans_test set amount=amount-100 where name='用户A'");
       transactionTestService.requiredInner();
       if(EXCEPTIN_FLAG){
           throw new  RuntimeException("回滚事务");
       }
   }/*运行结果：
   修复之后：
   =========== 运行前数据准备重置数据 ========
   ====== 运行后查询操作结果 ======
   {id=1, name=用户A, amount=1000}
   {id=2, name=用户B, amount=500}
   java.lang.RuntimeException: 回滚事务

   */
   @Transactional(rollbackFor = Exception.class, propagation = Propagation.SUPPORTS)
   public void requiredInner(){
       jdbcTemplate.update("update t_trans_test set amount=amount+100 where name='用户B'");
   }

 复制代码 隐藏代码/**

     * Propagation.SUPPORTS 测试
     */
// @Transactional(rollbackFor = Exception.class)
public void required(){
  jdbcTemplate.update("update t_trans_test set amount=amount-100 where name='用户A'");
  transactionTestService.requiredInner();
  if(EXCEPTIN_FLAG){
    throw new  RuntimeException("回滚事务");
  }
}/*运行结果：
    org.springframework.transaction.IllegalTransactionStateException: No existing transaction found for transaction marked with propagation 'mandatory'

    */
@Transactional(rollbackFor = Exception.class, propagation = Propagation.MANDATORY)
public void requiredInner(){
  jdbcTemplate.update("update t_trans_test set amount=amount+100 where name='用户B'");
}

复制代码 隐藏代码/**
    PROPAGATION_NOT_SUPPORTED 测试
    */
   @Transactional(rollbackFor = Exception.class)
   public void required(){
       jdbcTemplate.update("update t_trans_test set amount=amount-100 where name='用户A'");
       transactionTestService.requiredInner();
       if(EXCEPTIN_FLAG){
           throw new  RuntimeException("回滚事务");
       }
   }/*运行结果：
 ====== 运行后查询操作结果 ======
 {id=1, name=用户A, amount=1000}
 {id=2, name=用户B, amount=500}

   org.springframework.dao.CannotAcquireLockException: StatementCallback; SQL [update t_trans_test set amount=amount+100 where name='用户B']; Lock wait timeout exceeded; try restarting transaction; nested exception is com.mysql.cj.jdbc.exceptions.MySQLTransactionRollbackException: Lock wait timeout exceeded; try restarting transaction
   */
   @Transactional(rollbackFor = Exception.class, propagation = Propagation.NOT_SUPPORTED)
   public void requiredInner(){
       jdbcTemplate.update("update t_trans_test set amount=amount+100 where name='用户B'");
       if(EXCEPTIN_FLAG){
           throw new  RuntimeException("回滚事务");
       }
   }

 复制代码 隐藏代码@Transactional(rollbackFor = Exception.class)
public void required(){
  transactionTestService.requiredInner();
  jdbcTemplate.update("update t_trans_test set amount=amount-100 where name='用户A'");
  if(EXCEPTIN_FLAG){
    throw new  RuntimeException("回滚事务");
  }
}/*运行结果：
    =========== 运行前数据准备重置数据 ========
    ====== 运行后查询操作结果 =====  =
    {id=1, name=用户A, amount=1000}
    {id=2, name=用户B, amount=600}

    java.lang.RuntimeException: 回滚事务

    */

@Transactional(rollbackFor = Exception.class, propagation = Propagation.NOT_SUPPORTED)
public void requiredInner(){
  jdbcTemplate.update("update t_trans_test set amount=amount+100 where name='用户B'");
  if(EXCEPTIN_FLAG){
    throw new  RuntimeException("回滚事务");
  }
}