spring中 方法上@Transation实现原理

Spring中@Transactional注解方法实现原理

Spring的@Transactional注解在方法级别实现事务管理的原理主要基于动态代理和拦截器机制，以下是其核心实现流程：

1. 代理创建阶段

当Spring容器启动时，会为带有@Transactional注解的类创建代理对象：

1. Bean后处理器介入：

   • InfrastructureAdvisorAutoProxyCreator识别需要事务管理的Bean

   • 对目标Bean创建AOP代理（JDK动态代理或CGLIB代理）

2. 代理对象生成：

   // 原始Bean
   public class UserServiceImpl implements UserService {
       @Transactional
       public void createUser(User user) {
           // 业务逻辑
       }
   }
   
   // 生成的代理对象（伪代码）
   public class UserServiceProxy extends UserServiceImpl {
       private TransactionInterceptor txInterceptor;
       
       public void createUser(User user) {
           // 代理逻辑
           txInterceptor.invoke(new MethodInvocation() {
               // 包装原始方法调用
           });
       }
   }

2. 方法调用阶段

当调用代理对象的方法时，事务拦截器开始工作：

1. 拦截器调用链：

   客户端调用
   ↓
   Proxy.invoke()
   ↓
   TransactionInterceptor.invoke()
   ↓
   TransactionAspectSupport.invokeWithinTransaction()

2. 事务准备流程：

   protected Object invokeWithinTransaction(Method method, Class<?> targetClass, 
         final InvocationCallback invocation) throws Throwable {
       
       // 1. 获取事务属性（解析@Transactional注解）
       TransactionAttribute txAttr = getTransactionAttributeSource()
           .getTransactionAttribute(method, targetClass);
       
       // 2. 获取事务管理器
       PlatformTransactionManager tm = determineTransactionManager(txAttr);
       
       // 3. 根据传播行为决定事务操作
       TransactionStatus status = tm.getTransaction(txAttr);
       
       try {
           // 4. 执行原始方法
           Object result = invocation.proceedWithInvocation();
           
           // 5. 提交事务
           tm.commit(status);
           return result;
       } catch (Throwable ex) {
           // 6. 异常处理（决定是否回滚）
           completeTransactionAfterThrowing(txAttr, status, ex);
           throw ex;
       }
   }

3. 关键组件协作

4. 特殊场景处理

1. 自调用问题：

   public class OrderService {
       public void process() {
           this.updateOrder(); // 自调用不会经过代理，事务失效
       }
       
       @Transactional
       public void updateOrder() {...}
   }

   解决方案：注入自身代理或拆分到不同类

2. 异常回滚规则：

   • 默认只对RuntimeException和Error回滚

   • 可通过rollbackFor/noRollbackFor自定义

3. 事务传播行为：

   @Transactional(propagation = Propagation.REQUIRES_NEW)
   public void methodA() {
       // 总是启动新事务
   }

5. 实现原理总结

1. 代理机制：通过AOP创建代理对象包裹原始Bean

2. 拦截处理：方法调用被TransactionInterceptor拦截

3. 事务管理：根据注解属性执行事务开始/提交/回滚

4. 线程绑定：使用ThreadLocal保持事务上下文一致性

5. 资源协调：统一管理Connection等资源

这种设计实现了业务逻辑与事务管理的解耦，开发者只需通过注解声明事务需求，无需编写模板化的事务管理代码。

请再说下代理对象 事物拦截器，事物管理器之前关系及执行流程