spring 事务机制的个人总结

回滚事务到保存点。

--删除表bonus_2017。
DROP TABLE IF EXISTS bonus_2017;
--创建表bonus_2017。
CREATE TABLE bonus_2017(staff_id INT NOT NULL, staff_name CHAR(50), job VARCHAR(30), bonus NUMBER);
--向表bonus_2017中insert记录1。
INSERT INTO bonus_2017(staff_id, staff_name, job, bonus) VALUES(23,'limingwang','developer',5000);
--提交事务。
COMMIT;
--设置保存点s1。
SAVEPOINT s1;
--向表bonus_2017中insert记录2。
INSERT INTO bonus_2017(staff_id, staff_name, job, bonus) VALUES(24,'liyuyu','tester',7000);
--设置保存点s2。
SAVEPOINT s2;
--查询表bonus_2017的数据。
SELECT * FROM bonus_2017;

STAFF_ID     STAFF_NAME                                         JOB                            BONUS           
------------ -------------------------------------------------- ------------------------------ ----------------------------------------
23           limingwang                                          developer                         5000                 
24           liyuyu                                              tester                        7000                 

2 rows fetched.
--回滚到保存点s1。
ROLLBACK TO SAVEPOINT s1;
--查询表bouns_2017的数据。
SELECT * FROM bonus_2017;

STAFF_ID     STAFF_NAME                                         JOB                            BONUS           
------------ -------------------------------------------------- ------------------------------ ----------------------------------------
23           limingwang                                          developer                         5000                 

1 rows fetched.

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

<!-- 配置c3po连接池 -->
 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
  <!-- 注入属性值 -->
  <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
  <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/xxxxx"></property>
  <property name="user" value="xxx"></property>
  <property name="password" value="xxxxx"></property>
 </bean>
 <!-- 编程式事务管理 -->
 <!-- 配置事务管理器，必须是 PlatformTransactionManager 所支持的实现类 -->
 <bean id="dataSourceTransactionManager"
  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <!-- 注入dataSource -->
  <property name="dataSource" ref="dataSource"></property>
 </bean>

 <!-- 配置事务管理器模板 -->
 <bean id="transactionTemplate"
  class="org.springframework.transaction.support.TransactionTemplate">
  <!-- 注入真正进行事务管理的事务管理器,name必须为 transactionManager否则无法注入 -->
  <property name="transactionManager" ref="dataSourceTransactionManager"></property>
 </bean>

<!-- MYSQL -->
  <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
  </dependency>
  <!-- Spring Boot JDBC -->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
  </dependency>

CREATE TABLE `admin` (
  `id` int NOT NULL AUTO_INCREMENT,
  `username` varchar(50) DEFAULT NULL,
  `password` varchar(50) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb3;

// 单元测试
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(@Nullable 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;

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/jee
        https://www.springframework.org/schema/jee/spring-jee.xsd">

    <jee:jndi-lookup id="dataSource" jndi-name="jdbc/jpetstore"/>

    <bean id="txManager" class="org.springframework.transaction.jta.JtaTransactionManager" />

    <!-- other <bean/> definitions here -->

</beans>

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();
    }
}

 <!-- 事务管理器 -->
 <bean id="transactionManager"
  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <!-- 数据源 -->
  <property name="dataSource" ref="dataSource" />
 </bean>
  <tx:annotation-driven transaction-manager="transactionManager" />
 <!-- 通知 -->
 <tx:advice id="txAdvice" transaction-manager="transactionManager">
  <tx:attributes>
   <!-- 传播行为 -->
   <tx:method name="save*" propagation="REQUIRED" />
   <tx:method name="insert*" propagation="REQUIRED" />
   <tx:method name="delete*" propagation="REQUIRED" />
   <tx:method name="update*" propagation="REQUIRED" />
   <tx:method name="find*" propagation="SUPPORTS" read-only="true" />
   <tx:method name="get*" propagation="SUPPORTS" read-only="true" />
  </tx:attributes>
 </tx:advice>
 
 <!-- 切面 -->
 <aop:config>
  <aop:advisor advice-ref="txAdvice"
   pointcut="execution(* service.*.*(..))" />
 </aop:config>

  .....
      
    <!-- 事务管理器 -->  
    <bean id="myTracnsactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
        <property name="dataSource" ref="dataSource"></property>  
    </bean>  
      
    <!-- 事务代理工厂 -->  
    <!-- 生成事务代理对象 -->  
    <bean id="serviceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">  
        <property name="transactionManager" ref="myTracnsactionManager"></property>  
        <property name="target" ref="buyStockService"></property>  
        <property name="transactionAttributes">  
            <props>  
                <!-- 主要 key 是方法     
                    ISOLATION_DEFAULT  事务的隔离级别  
                    PROPAGATION_REQUIRED  传播行为  
                -->  
                <prop key="add*">ISOLATION_DEFAULT,PROPAGATION_REQUIRED</prop>  
                <!-- -Exception 表示发生指定异常回滚，+Exception 表示发生指定异常提交 -->  
                <prop key="buyStock">ISOLATION_DEFAULT,PROPAGATION_REQUIRED,-BuyStockException</prop>  
            </props>  
        </property>  
          
    </bean> 
.....

@Transactional(isolation=Isolation.DEFAULT,propagation=Propagation.REQUIRED,rollbackFor=BuyStockException.class) 

if (isValidateExistingTransaction()) {
   if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
    I
   }
   // 如果设置了只读但是当前事务没有只读，则抛出异常
   if (!definition.isReadOnly()) {
    if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
     throw new IllegalTransactionStateException("Participating transaction with definition [" +
       definition + "] is not marked as read-only but existing transaction is");
    }
   }
}
// 没有则同步构建一个空事务

@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;
  }
 // .......

CREATE TABLE `t_trans_test` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `amount` decimal(16,0) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3;

INSERT INTO `transaction_tb`.`t_trans_test` (`id`, `name`, `amount`) VALUES (1, '用户A', 1000);
INSERT INTO `transaction_tb`.`t_trans_test` (`id`, `name`, `amount`) VALUES (2, '用户B', 500);

// 随机异常触发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}
    */

alter table t_trans_test ENGINE=MyISAM;

Methods annotated with '@Transactional' must be overridable 

 /**
     * 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("回滚事务");
  }
}