回炉Spring-AOP及事务源码解读
一、AOP
AOP，面向切面编程
即拓展功能不通过修改源代码来实现。
采用横向抽取机制，取代了传统的纵向继承体系的重复性代码。在运行期间通过代理方式向目标类中织入增强代码。
实现一个AOP的步骤：
1、将需要增强的目标类和切面类都注入到Spring容器中，标注使Spring知道哪个是切面类，@Aspect（曾犯错，在切面类上没有标注@Component注解）
2、在切面类上的通知方法上标注通知注解（如@Around，@Before等），并在注解中指明切入点表达式
3、开启基于注解的aop模式，在配置类上加上注解@EnableAspectJAutoProxy
注：（SpringBoot默认开启了基于注解的AOP模式，不用再启动类上再加@EnableAspectJAutoProxy）
@AfterReturning注解的returning可将增强方法的返回值映射到参数上
@AfterReturning(value = "pointCut()", returning = "result") public void afterReturning(Object result) throws Throwable {}
@AfterThrowing(value="pointCut()",throwing="exception")的throwing将增强方法的异常信息映射到参数上
获取切入点方法名：joinPoint.getSignature().getName()
获取方法入参：joinPoint.getArgs()
@Before("pointCut()")
// 方法若有多个参数，JoinPoint一定要放在第一位
public void before(JoinPoint joinPoint) {
String name = joinPoint.getSignature().getName();
Object[] args = joinPoint.getArgs();
}
AOP原理：
@EnableAspectJAutoProxy注解做了什么？
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Import(AspectJAutoProxyRegistrar.class) public @interface EnableAspectJAutoProxy {...}
@EnableAspectJAutoProxy往容器中导入了AspectJAutoProxyRegistrar，利用AspectJAutoProxyRegistrar自定义往容器中注册了name为org.springframework.aop.config.internalAutoProxyCreator，class为AnnotationAwareAspectJAutoProxyCreator的bean。
也就是说，@EnableAspectJAutoProxy往Spring容器中注册了AnnotationAwareAspectJAutoProxyCreator这个bean。
技巧：如果看到了Enable开头的注解，就看这个注解有没有往容器中注册一些组件，如果注册组件了，这些组件的功能是什么，如果具体功能搞明白了，那么这个注解的原理就清楚了。
那么既然@EnableAspectJAutoProxy往Spring容器中注册了AnnotationAwareAspectJAutoProxyCreator这个bean（从名字看是：注解装配切面代理创造器），那就看一下这个bean的功能是什么，源码走起：
AnnotationAwareAspectJAutoProxyCreator 的继承关系如下：
看到其祖先类实现了InstantiationAwareBeanPostProcessor 接口，而此接口又实现了BeanPostProcessor接口，而这个接口我们知道叫做后置处理器，后置处理器的功能就是在bean初始化的前后做一些工作。
抽象父类AbstractAutoProxyCreator 又实现了BeanFactoryAware，可以往代码中注入BeanFactory。
那么先重点看与setBeanFactory以及与后置处理器相关的逻辑，通过源码发现AbstractAutoProxyCreator有setBeanFactory()以及后置处理器相关的逻辑。而在AbstractAutoProxyCreator的子抽象类AbstractAdvisorAutoProxyCreator又重写了setBeanFactory()方法
public void setBeanFactory(BeanFactory beanFactory) { super.setBeanFactory(beanFactory); if (!(beanFactory instanceof ConfigurableListableBeanFactory)) { throw new IllegalArgumentException("AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory); } else { this.initBeanFactory((ConfigurableListableBeanFactory)beanFactory); } }
由于其子类AnnotationAwareAspectJAutoProxyCreator 重写了initBeanFactory方法，所以最终调用的是AnnotationAwareAspectJAutoProxyCreator 中的initBeanFactory方法中的逻辑：
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) { super.initBeanFactory(beanFactory); if (this.aspectJAdvisorFactory == null) { this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory); } this.aspectJAdvisorsBuilder = new AnnotationAwareAspectJAutoProxyCreator.BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory); }
断点看AOP的整个执行流程：
1、new AnnotationConfigApplicationContext(AopConfig.class); 创建Spring容器，接下来看其构造器逻辑
2、先注册配置类，然后调用refresh()方法刷新容器，接下来看refresh()的逻辑
3、invokeBeanFactoryPostProcessors(beanFactory);实例化并调用所有注册的BeanFactoryPostProcessor
4、registerBeanPostProcessors(beanFactory); 注册bean的后置处理器来拦截bean的创建
1）：先获取ioc容器中已经定义了的所有实现BeanPostProcessor接口的后置处理器的name. String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
2）：给容器中添加了额外的BeanPostProcessor beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
3）：遍历所有的BeanPostProcessor，按照实现了PriorityOrdered接口的，和实现了Ordered接口的进行分组，分别保存在不同的List集合中
①：若实现了PriorityOrdered，则先创建其对象，当成普通bean注册到Spring容器中，然后将其放进priorityOrderedPostProcessors集合，若其又实现了MergedBeanDefinitionPostProcessor，将其再放进internalPostProcessors集合；
②：若其实现了Ordered接口，将其bean name放入orderedPostProcessorNames集合；
③：若两个接口都没实现，则将其bean name放进nonOrderedPostProcessorNames集合；
4）：优先注册实现了PriorityOrdered接口的BeanPostProcessor作为bean的后置处理器到Spring容器中，再注册实现了Ordered接口的BeanPostProcessor，最后注册其他的BeanPostProcessor.
注册的BeanPostProcessor保存在AbstractBeanFactory的 private final List<BeanPostProcessor> beanPostProcessors = new BeanPostProcessorCacheAwareList();集合属性中
5）：注册其实就是步骤3）中的根据其name获取BeanPostProcessor对象｛BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);｝，实际上就是创建BeanPostProcessor对象然后将其保存在Spring容器中。
以创建name为internalAutoProxyCreator的BeanPostProcessor【AnnotationAwareAspectJAutoProxyCreator】为例，看一下创建过程：
（1）：创建bean的实例，getBean()——doGetBean()——getSingleton()——getObject()——createBean()——doCreateBean()
（2）：populateBean：给bean的各种属性赋值
（3）：initializeBean：初始化bean
①：invokeAwareMethods()判断bean是不是实现了xxxAware接口，如果实现了就调用相关的setXxx方法给bean的属性赋值
②：Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);应用bean的后置处理器的初始化前置方法，获取所有的后置处理器（之前注册保存在AbstractBeanFactory的List<BeanPostProcessor>属性中），遍历调用它们的postProcessBeforeInitialization()方法
③：invokeInitMethods(beanName, wrappedBean, mbd); 执行初始化方法，先@PostConstruct() 注解方法，然后如果实现了InitializingBean，执行afterPropertiesSet，再执行自定义的初始化方法（如果在@Bean注解指定了initMethod的话）
④：Object wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);应用bean的后置处理器的初始化后置方法，获取所有的后置处理器，遍历调用其postProcessAfterInitialization()方法
6）：由于AnnotationAwareAspectJAutoProxyCreator实现了 BeanFactoryAware接口，所以在invokeAwareMethods()方法中，回到了上面说的调用其抽象父类AbstractAdvisorAutoProxyCreator重写的setBeanFactory()方法。然后走到了AnnotationAwareAspectJAutoProxyCreator 的initBeanFactory()方法，至此，BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)创建成功
7）：最后将所有的BeanPostProcessor注册到BeanFactory中
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
-->beanFactory.addBeanPostProcessor(postProcessor);）
注册的BeanPostProcessor保存在AbstractBeanFactory的 private final List<BeanPostProcessor> beanPostProcessors = new BeanPostProcessorCacheAwareList();集合属性中
以上就是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程。
接下来看其作为一个BeanPostProcessor如何影响bean的创建过程的：
5、finishBeanFactoryInitialization(beanFactory);完成BeanFactory初始化工作，创建剩下的单实例bean，为什么说是剩下的呢？因为BeanPostProcessors类型的bean在步骤4已经创建
完成了
1）：preInstantiateSingletons()-->遍历获取容器中所有的beanDefinitionNames，遍历依此创建对象getBean(beanName); 在DefaultListableBeanFactory类中
2）：getBean(beanName)-->doGetBean()-->getSingleton(beanName) ，在创建bean之前先尝试获取单实例Bean的实例，为什么呢？因为只要创建好的bean就会被缓存起来
①：先去JVM缓存 private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); /** Cache of singleton objects: bean name to bean instance. */ 中去获取缓存的创建好了的单实例bean对象
②：若创建完成的单实例bean缓存中没有，再去当前创建bean池中去尝试获取。
当前创建bean池：private final Set<String> singletonsCurrentlyInCreation =Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16)); // 池中保存中的是 bean name
因为在创建单实例bean的时候会存在依赖注入的情况，为了避免循环依赖，Spring在创建bean的过程中，若发现有依赖bean，则尝试去创建依赖的bean，因此Spring将每一个正在创建的bean的beanName放在一个“当前创建bean池”中，bean在创建过程中，BeanName将一直存在这个池中。
③：如果当前线程创建bean池有，则尝试从提前创建单例bean缓存中加载bean：private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16); /** Cache of early singleton objects: bean name --> bean instance */
④：如果earlySingletonObjects 缓存中加载不成功，则再次尝试从singletonFactories中获取提前曝光的ObjectFactory，private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); /** Cache of singleton factories: bean name --> ObjectFactory */
如果根据beanName找到了ObjectFactory，则从ObjectFactory中获取bean实例，然后将其放在earlySingletonObjects 缓存中，再将其ObjectFactory从singletonFactories中移除。
因为Spring为了避免循环依赖，在Spring中创建bean的原则是不等bean创建完就会将创建bean的ObjectFactory提早曝光加入到缓存中，一旦下一个bean创建时候需要依赖上一个bean则直接使用ObjectFactory去获取依赖bean的实例。
3）：createBean() 创建bean实例
①：Object bean=resolveBeforeInstantiation(beanName, mbdToUse); 参数：RootBeanDefinition mbdToUse，bean的定义信息。
方法的作用是：给BeanPostProcessor一个机会返回一个代理对象就不用创建其对象了。如果可以，直接返回代理对象，如果不能，则继续执行doCreateBean(beanName, mbdToUse, args);，其实现为：
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName); if (bean != null) { bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); }
这个方法的逻辑是：先拿到所有的后置处理器然后遍历，如果其中一个后置处理器实现了InstantiationAwareBeanPostProcessor接口，则执行这个后置处理器的postProcessBeforeInstantiation方法，如果返回了bean对象，则执行applyBeanPostProcessorsAfterInitialization并返回bean实例，结束bean的创建，不走下面的doCreateBean。
注意：InstantiationAwareBeanPostProcessor虽继承了BeanPostProcessor，但其定义了postProcessBeforeInstantiation和postProcessAfterInstantiation方法，与BeanPostProcessor的postProcessBeforeInitialization和postProcessAfterInitialization方法不同，BeanPostProcessor的两个方法是在bean实例创建完成之后的初始化前后调用的，而InstantiationAwareBeanPostProcessor的两个方法是在创建bean实例之前尝试返回代理对象的。
这也是AnnotationAwareAspectJAutoProxyCreator的功能，在所有的bean创建之前会有一个拦截，尝试返回其代理对象
②：doCreateBean，真正的创建bean的实例，即上面4.5的流程
AnnotationAwareAspectJAutoProxyCreator做了什么事情？
一下逻辑都在create()方法中
1、每一个bean创建之前，都会调用postProcessBeforeInstantiation(); 代码在AbstractAutoProxyCreator#postProcessBeforeInstantiation
其处理逻辑是：
1）：判断当前bean是否在advisedBean（保存了所有增强过的bean的缓存）中，private final Map<Object, Boolean> advisedBeans = new ConcurrentHashMap<>(256);
2）：isInfrastructureClass(beanClass)：判断当前bean是否是 基础类型的Advice、Pointcut、Advisor、AopInfrastructureBean或者是否是切面（是否有@Aspect注解）
3）：或者shouldSkip(beanClass, beanName)：是否需要跳过
①：获取候选的增强器（切面里面的增强方法）List<Advisor> candidateAdvisors = findCandidateAdvisors();
②：遍历然后判断每一个增强器是否是AspectJPointcutAdvisor类型的，如果是，返回true，否则返回flase
③：而我们的增强器类型是：InstantiationModelAwarePointcutAdvisor，因此，shouldSkip方法永远返回false
2、执行doCreateBean方法，创建bean，并初始化
3、postProcessAfterInstantiation和postProcessBeforeInitialization一个返回true，一个返回bean对象本身，什么都没做
4、postProcessAfterInitialization方法：创建完对象并初始化后，调用它。代码在AbstractAutoProxyCreator#postProcessAfterInitialization 其逻辑是：
判断当前bean是否已经代理过，若没有则执行：return wrapIfNecessary(bean, beanName, cacheKey); 这个方法的作用是，封装bean如果必要的话，也就是在这里创建目标类的代理对象
1）：Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);找到所有能应用到当前bean的增强方法
（1）：获取配置的所有的切面增强方法
（2）：找到所有的增强方法中能应用到当前bean方法中的
（3）：获取到能在当前bean使用的增强方法的集合，并按照一定规则排序
（4）：如果能在当前bean使用的增强方法的集合不为空，则转为数组返回，否则返回null
2）：如果返回的数组不为空，则需要代理
（1）：将bean的name作为key，值为true，放在advisedBeans（所有增强过的bean的ConcurrentHashMap）中
（2）：创建代理对象，Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
①：如果能在当前bean使用的增强方法
②：遍历将其添加到proxyFactory中
③： DefaultAopProxyFactory中创建代理对象，如果目标类实现了接口，则使用JDK动态代理；否则使用CGlib动态代理
JdkDynamicAopProxy(AdvisedSupport config)
ObjenesisCglibAopProxy(AdvisedSupport config)
（3）：将bean作为key，代理对象的class对象作为value，保存到private final Map<Object, Class<?>> proxyTypes = new ConcurrentHashMap<Object, Class<?>>(16);中
（4）：返回代理对象（代理对象中包含了增强器和目标对象等）
（5）：以后在容器中获取到的就是这个组件的代理对象，执行目标方法的时候，代理对象就会执行增强方法的流程
3）否则不需要代理，将bean的name作为key，值为false，放在advisedBeans中，表示不需要增强
总结：AnnotationAwareAspectJAutoProxyCreator在初始化后置方法postProcessAfterInitialization中，判断是否有增强方法能应用到当前bean中，若有，则为当前bean创建代理对象，并保存到Spring容器中，以后从Spring容器中获取到的就是代理对象。
从容器中获取的对象是代理对象，即容器中保存了组件的代理对象（cglib增强后的对象），这个对象里面保存了详细的信息（比如要应用的切面中的增强方法，也叫增强器，目标对象等）
执行目标对象Target中的切入点方法，即执行被增强的方法的流程：
F7进入切点方法：
1、CglibAopProxy.intercept(); 拦截目标方法的执行
2、获取目标对象
Object target = null; // 目标对象
TargetSource targetSource = this.advised.getTargetSource();
target = targetSource.getTarget();
3、根据ProxyFactory对象获取将要执行的目标方法拦截器链
List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
DefaultAdvisorChainFactory#getInterceptorsAndDynamicInterceptionAdvice // 实际逻辑代码
1）：List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
保存所有的拦截器，包括一个默认的 ExposeInvocationInterceptor.ADVISOR 和 其他所有切点方法的增强器
2）：遍历所有的增强器，将其转为MethodInterceptor 【MethodInterceptor[] interceptors = registry.getInterceptors(advisor);】
如果增强器是MethodInterceptor，直接放入List<MethodInterceptor>集合中
如果不是，使用AdvisorAdapter将增强器转为MethodInterceptor，然后再放入List<MethodInterceptor>集合中
最后将集合转为数组返回
4、如果没有拦截器链，则直接执行目标方法（拦截器链，每一个通知方法又被包装为方法拦截器，利用MethodInterceptor机制）
5、如果有拦截器链，把需要执行的目标对象，目标方法，拦截器等信息作为参数创建一个CglibMethodInvocation对象并调用其proceed（）方法
retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
CglibMethodInvocation对象：
拦截器列表：
6、拦截器的触发过程
1）：如果没有拦截器执行目标方法，或者拦截器的索引和拦截器数组-1大小一样（即执行到了最后一个拦截器），则执行目标方法
2）：链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回后再去执行（类似于递归调用），
如上面拦截器的调用顺序是 Expose-->AfterReturning-->Around-->Before，然后前面的等待后面的返回再执行，最后实际执行顺序是Before-->Around-->AfterReturning-->Expose
拦截器链的机制，保证通知方法与目标方法的执行顺序。
AOP总结
1、@EnableAspectJAutoProxy 开启AOP功能
2、@EnableAspectJAutoProxy 会给容器中注册一个组件 AnnotationAwareApectJAutoProxyCreator
3、AnnotationAwareApectJAutoProxyCreator是一个后置处理器
4、容器的创建流程
1）：registerBeanPostProcessors(beanFactory); 注册后置处理器，创建AnnotationAwareApectJAutoProxyCreator对象
2）：finishBeanFactoryInitialization(beanFactory); 初始化剩下的单实例bean
（1）：创建业务逻辑组件和切面组件
（2）：AnnotationAwareApectJAutoProxyCreator 拦截组件的创建过程
（3）： 组件创建完成之后，作为后置处理器的AnnotationAwareApectJAutoProxyCreator在postProcessAfterInitialization方法中判断组件是否需要增强，如果需要则 将需要应用到目标对象的切面中的通知方法，包装成增强器Advisor，然后给业务逻辑组件创建一个代理对象。
5、执行目标方法
1）：代理对象来执行目标方法
2）：CglibAopProxy.intercept(); 拦截目标方法的执行
（1）：得到目标方法执行的拦截器链
（2）：利用拦截器的链式机制，依次进入每一个拦截器进行执行
（3）：实际执行顺序：
正常执行：前置通知-->目标方法-->后置通知-->返回通知
出现异常：前置通知-->目标方法-->后置通知-->异常通知
二、事务
声明式事务
jdbc和tx依赖：
<!--jdbc & tx-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
数据源和mysql连接依赖：
<!--dbcp datasource-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-dbcp2</artifactId>
<version>2.7.0</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
配置文件信息：
/** * @EnableTransactionManagement 开启基于注解的事务管理功能 * 1、配置数据源 * 2、配置事务管理器来管理事务 * 3、给方法上标注 @Transactional 表示当前方法是一个事务方法，@Transaction默认回滚Error和RuntimeException，但是不包括和RuntimeException * 一样同属于Exception子类的如IOException、SQLException和自定义异常等，对于这些异常如果也要回滚要在rollbackFor中指定 */ @EnableTransactionManagement @Configuration @ComponentScan(value = {"com.yang.service"}) public class TransactionConfig { @Bean public DataSource myDataSource() { BasicDataSource dataSource = new BasicDataSource(); dataSource.setUsername("yang"); dataSource.setPassword("yang"); dataSource.setDriverClassName("com.mysql.jdbc.Driver"); dataSource.setUrl("jdbc:mysql://localhost:3306/test"); return dataSource; } /** * 如果bean之间有依赖，直接放进参数中即可，参数值会从Spring容器中取，然后赋值 * 参数从Spring容器中取 * * @param myDataSource * @return */ @Bean public JdbcTemplate jdbcTemplate(DataSource myDataSource) { JdbcTemplate jdbcTemplate = new JdbcTemplate(myDataSource); // 也可以直接调用,Spring对@Configuration类会特殊处理；给容器中加组件的方法，多次调用都只是从容器中找组件 // JdbcTemplate jdbcTemplate = new JdbcTemplate(myDataSource()); return jdbcTemplate; } /** * 注册事务管理器在容器中 * * @return * @throws Exception */ @Bean public PlatformTransactionManager transactionManager() { return new DataSourceTransactionManager(myDataSource()); } }
@EnableTransactionManagement 做了什么？
@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; }
1、导入了TransactionManagementConfigurationSelector，TransactionManagementConfigurationSelector往容器中导入了两个组件
AutoProxyRegistrar 、ProxyTransactionManagementConfiguration
/** * Returns {@link ProxyTransactionManagementConfiguration} or * {@code AspectJ(Jta)TransactionManagementConfiguration} for {@code PROXY} * and {@code ASPECTJ} values of {@link EnableTransactionManagement#mode()}, * respectively. */ @Override protected String[] selectImports(AdviceMode adviceMode) { switch (adviceMode) { case PROXY: return new String[] {AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()}; case ASPECTJ: return new String[] {determineTransactionAspectClass()}; default: return null; } } private String determineTransactionAspectClass() { return (ClassUtils.isPresent("javax.transaction.Transactional", getClass().getClassLoader()) ? TransactionManagementConfigUtils.JTA_TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME : TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME); } // public static final String JTA_TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME = "org.springframework.transaction.aspectj.AspectJJtaTransactionManagementConfiguration"; // public static final String TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME = "org.springframework.transaction.aspectj.AspectJTransactionManagementConfiguration";
（1）、AutoProxyRegistrar
给容器中注册了一个beanNameorg.springframework.aop.config.internalAutoProxyCreator，类型为InfrastructureAdvisorAutoProxyCreator的组件（bean），其是一个后置处理器，和AOP中的AnnotationAwareAspectJAutoProxyCreator类似，它们beanName相同。都是在对象创建完成之后利用后置处理器的初始化后置方法，包装对象，然后返回一个包含增强器的代理对象，代理对象执行方法利用拦截器链进行调用。
（2）、ProxyTransactionManagementConfiguration是一个配置文件类
/** * {@code @Configuration} class that registers the Spring infrastructure beans * necessary to enable proxy-based annotation-driven transaction management. * * @author Chris Beams * @since 3.1 * @see EnableTransactionManagement * @see TransactionManagementConfigurationSelector */ @Configuration public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration { @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME) @Role(BeanDefinition.ROLE_INFRASTRUCTURE) public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() { // 事务增强器 BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor(); advisor.setTransactionAttributeSource(transactionAttributeSource()); advisor.setAdvice(transactionInterceptor()); if (this.enableTx != null) { advisor.setOrder(this.enableTx.<Integer>getNumber("order")); } return advisor; } @Bean @Role(BeanDefinition.ROLE_INFRASTRUCTURE) public TransactionAttributeSource transactionAttributeSource() { return new AnnotationTransactionAttributeSource(); } @Bean @Role(BeanDefinition.ROLE_INFRASTRUCTURE) public TransactionInterceptor transactionInterceptor() { // 事务拦截器 TransactionInterceptor interceptor = new TransactionInterceptor(); interceptor.setTransactionAttributeSource(transactionAttributeSource()); if (this.txManager != null) { interceptor.setTransactionManager(this.txManager); } return interceptor; } }
1、往容器中注册事务增强器transactionAdvisor，其中事务增强器中又依赖了：
1）：事务增强器要用事务注解的参数信息，TransactionAttributeSource，AnnotationTransactionAttributeSource来解析事务注解
2）：事务拦截器：TransactionInterceptor，保存了事务属性信息，事务管理器。其实现了MethodInterceptor接口。在目标方法执行的时候：执行拦截器链，然后执行事务拦截器：
（1）：先获取事务相关的属性
（2）：再获取PlatformTransactionManager事务管理器，如果在@Transactional注解中没有指定transactionManager，则最终会从容器中按照类型获取一个PlatformTransactionManager
（3）：执行目标方法
如果异常，获取到事务管理器，利用事务管理回滚操作
【transactionInfo.getTransactionManager().rollback(txInfo.getTransactionStatus())】
如果正常，利用事务管理器，提交事务【transactionInfo.getTransactionManager().commit(txInfo.getTransactionStatus());】
TransactionInterceptor#invoke
@Override @Nullable public Object invoke(MethodInvocation invocation) throws Throwable { // Work out the target class: may be {@code null}. // The TransactionAttributeSource should be passed the target class // as well as the method, which may be from an interface. Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null); // Adapt to TransactionAspectSupport's invokeWithinTransaction... return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed); }
@Transactional注解处理器的核心代码，TransactionAspectSupport#invokeWithinTransaction:278，从TransactionInterceptor#invoke进入：
/** * General delegate for around-advice-based subclasses, delegating to several other template * methods on this class. Able to handle {@link CallbackPreferringPlatformTransactionManager} * as well as regular {@link PlatformTransactionManager} implementations. * @param method the Method being invoked * @param targetClass the target class that we're invoking the method on * @param invocation the callback to use for proceeding with the target invocation * @return the return value of the method, if any * @throws Throwable propagated from the target invocation */ @Nullable protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass, final InvocationCallback invocation) throws Throwable { // If the transaction attribute is null, the method is non-transactional. TransactionAttributeSource tas = getTransactionAttributeSource(); final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null); final PlatformTransactionManager tm = determineTransactionManager(txAttr); // 确定要用于给定交易的特定交易管理器 final String joinpointIdentification = methodIdentification(method, targetClass, txAttr); if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) { // Standard transaction demarcation with getTransaction and commit/rollback calls. TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification); // 开启事务 Object retVal = null; try { // This is an around advice: Invoke the next interceptor in the chain. // This will normally result in a target object being invoked. retVal = invocation.proceedWithInvocation(); // 执行业务方法 } catch (Throwable ex) { // target invocation exception completeTransactionAfterThrowing(txInfo, ex); // 回滚事务 throw ex; // 仍往上抛出异常，供上层捕获 } finally { cleanupTransactionInfo(txInfo); // Reset the TransactionInfo ThreadLocal. } commitTransactionAfterReturning(txInfo); // 提交事务 return retVal; } else { ... } }
回滚事务：
/** * Handle a throwable, completing the transaction. * We may commit or roll back, depending on the configuration. * @param txInfo information about the current transaction * @param ex throwable encountered */ protected void completeTransactionAfterThrowing(@Nullable TransactionInfo txInfo, Throwable ex) { if (txInfo != null && txInfo.getTransactionStatus() != null) { if (logger.isTraceEnabled()) { logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "] after exception: " + ex); } if (txInfo.transactionAttribute != null && txInfo.transactionAttribute.rollbackOn(ex)) { try { txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus()); } catch (TransactionSystemException ex2) { logger.error("Application exception overridden by rollback exception", ex); ex2.initApplicationException(ex); throw ex2; } catch (RuntimeException | Error ex2) { logger.error("Application exception overridden by rollback exception", ex); throw ex2; } } else { // We don't roll back on this exception. // Will still roll back if TransactionStatus.isRollbackOnly() is true. // 默认回滚(ex instanceof RuntimeException || ex instanceof Error) 异常，其他异常不会回滚，仍提交事务 try { txInfo.getTransactionManager().commit(txInfo.getTransactionStatus()); } catch (TransactionSystemException ex2) { logger.error("Application exception overridden by commit exception", ex); ex2.initApplicationException(ex); throw ex2; } catch (RuntimeException | Error ex2) { logger.error("Application exception overridden by commit exception", ex); throw ex2; } } } }
最终回滚代码为：DataSourceTransactionManager#doRollback
DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction(); Connection con = txObject.getConnectionHolder().getConnection(); con.rollback();
提交事务：
/** * Execute after successful completion of call, but not after an exception was handled. * Do nothing if we didn't create a transaction. * @param txInfo information about the current transaction */ protected void commitTransactionAfterReturning(@Nullable TransactionInfo txInfo) { if (txInfo != null && txInfo.getTransactionStatus() != null) { if (logger.isTraceEnabled()) { logger.trace("Completing transaction for [" + txInfo.getJoinpointIdentification() + "]"); } txInfo.getTransactionManager().commit(txInfo.getTransactionStatus()); // 提交事务 } }
最终提交代码为：
DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction(); Connection con = txObject.getConnectionHolder().getConnection(); con.commit();
END.