Transaction注解原理

• 开启事务注解EnableTransactionManagement，该注解往容器中导入了导入TransactionManagementConfigurationSelector组件。该组件有个方法，在容器刷新的时候会被调用。(此处不讲解为什么会被调用，重点讲解Transaction注解)

protected String[] selectImports(AdviceMode adviceMode) {
		switch (adviceMode) {
			case PROXY:
				return new String[] {AutoProxyRegistrar.class.getName(),
						ProxyTransactionManagementConfiguration.class.getName()};
			case ASPECTJ:
				return new String[] {
						TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME};
			default:
				return null;
		}
	}

• EnableTransactionManagement默认是**AdviceMode mode() default AdviceMode.PROXY;**所以
  AutoProxyRegistrar和ProxyTransactionManagementConfiguration会被加载到容器中。

  • AutoProxyRegistrar功能是往容器中注册了InfrastructureAdvisorAutoProxyCreator是个BeanPostProcessor后置处理器。
  • ProxyTransactionManagementConfiguration利用@Bean注解往容器中添加多个bean。(BeanFactoryTransactionAttributeSourceAdvisor是个Advisor和前面Aop中@Before一样都是通知方法，但是此处的是手动导入的，Aop是自己自动生成的)。

• 在bean生成完成以后会调用后置处理器初始化。会去查找bean有没有合适的通知方法。所以重点是在找通知方法，找到了合适的就会生成代理对象。

//简单的分析一下流程
AbstractAutowireCapableBeanFactory#initializeBean() -> 
AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization() ->
AbstractAutoProxyCreator#postProcessAfterInitialization() ->
AbstractAutoProxyCreator#wrapIfNecessary()->
AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean()

/**
	 * 寻找可用的通知方法
	 */
	protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
		//寻找所有的Advisors,会去容器遍历所有类型为Advisor的bean，
		//BeanFactoryTransactionAttributeSourceAdvisor就是我们手动导入的Advisor           
		List<Advisor> candidateAdvisors = findCandidateAdvisors();
		//在所有的Advisors,看是否有beanClass匹配的
		List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
		extendAdvisors(eligibleAdvisors);
		if (!eligibleAdvisors.isEmpty()) {
			eligibleAdvisors = sortAdvisors(eligibleAdvisors);
		}
		return eligibleAdvisors;
	}

//找到所有的Advisors,剩下就是是否有匹配的findAdvisorsThatCanApply()方法
//最终走到TransactionAttributeSourcePointcut#matches
//->AbstractFallbackTransactionAttributeSource#computeTransactionAttribute

```java
protected TransactionAttribute computeTransactionAttribute(Method method, Class<?> targetClass) {
		//判断方法修饰符是不是Public，allowPublicMethodsOnly()默认是true的
		if (allowPublicMethodsOnly() && !Modifier.isPublic(method.getModifiers())) {
			return null;
		}
	
		// 这里面就是判断方法上有没有Transactional注解，有进行解析操作并返回。
		TransactionAttribute txAttr = findTransactionAttribute(specificMethod);
		if (txAttr != null) {
			return txAttr;
		}
		//代码每贴全，为了少点没用的东西。。。。

• 那要是找了合适的通知方法，就生成代理对象，并设置回调函数。设置回调函数是CglibAopProxy.DynamicAdvisedInterceptor的intercept方法，该方法有个getInterceptorsAndDynamicInterceptionAdvice获取合适的拦截器。(事务的拦截器是TransactionInterceptor)

public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                //获取目标对象，不是代理对象
                target = getTarget();
				if (target != null) {
					targetClass = target.getClass();
				}
				//获取方法合适的拦截器
				List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
				Object retVal;
				//没有合适的拦截器并且方法的修饰符是Public
				if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
					Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
					//会调用目标方法
					retVal = methodProxy.invoke(target, argsToUse);
				}
				else {
					/*
					* 1.有合适的拦截器:会去执行拦截器TransactionInterceptor#invoke()，
                    *   事务的提交，回滚等一系列操作都在里面。具体是调去了
                    *    TransactionAspectSupport#invokeWithinTransaction()方法   
					*  2.没有合适的拦截器并且方法的修饰符不是Public:这里面也会去调目标方法
					*     (这里简单可以走进去看一下)
					*/
					retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
				}
				retVal = processReturnType(proxy, target, method, retVal);
				return retVal;
			}

总结事务失效的几种情况:

1. 事务方法不是public方法，computeTransactionAttribute方法()会返回一个null出去，告诉容器没有可用的通知方法，不需要生成代理对象，没有代理对象肯定不会去回到函数，所以事务失效。
2. 本类中没有事务的方法调用有事务的方法事务会失效。(注意是本类)
3. 本类中有事务的方法调用没有事务的方法事务，没有事务的方法会被加上事务。

@Component
public class Animal {
    @Transactional
    public void test(){
        System.out.println("cece");
    }
    public void test2(){
       //相当于 this.test()
        test();
    }
}

//因为target = getTarget();invoke(target, argsToUse);
//调用的是目标对象的，所以到时候this就相当于目标对象不是代理对象，
//所以就不会走回调方法，直接调用目标方法。要是把this改成容器中代理对象还是会走回调方法。

如有疑问可以留言解答，涉及东西太多了不可能全部写完，不然太长都没法看了。