Spring学习(二十五)-Spring事务源码分析

Spring事务源码分析：

@EnableTransactionManagement 开启基于注解的事务管理功能；

给方法上标注 @Transactional 表示当前方法是一个事务方法；

@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;

}

TransactionManagementConfigurationSelector：

public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {

	@Override
	protected String[] selectImports(AdviceMode adviceMode) {
		switch (adviceMode) {
		    //代理 给容器中AutoProxyRegistrar和ProxyTransactionManagementConfiguration组件
			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;
		}
	}

}

AutoProxyRegistrar：

public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

	private final Log logger = LogFactory.getLog(getClass());

	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		boolean candidateFound = false;
		Set<String> annoTypes = importingClassMetadata.getAnnotationTypes();
		for (String annoType : annoTypes) {
			AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annoType);
			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()) {
				candidateFound = true;
				//如果是AdviceMode.PROXY
				if (mode == AdviceMode.PROXY) {
				    //当需要的时候注册自动代理创建器
					AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
					if ((Boolean) proxyTargetClass) {
						AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
						return;
					}
				}
			}
		}
		if (!candidateFound) {
			String name = getClass().getSimpleName();
			logger.warn(String.format("%s was imported but no annotations were found " +
					"having both 'mode' and 'proxyTargetClass' attributes of type " +
					"AdviceMode and boolean respectively. This means that auto proxy " +
					"creator registration and configuration may not have occurred as " +
					"intended, and components may not be proxied as expected. Check to " +
					"ensure that %s has been @Import'ed on the same class where these " +
					"annotations are declared; otherwise remove the import of %s " +
					"altogether.", name, name, name));
		}
	}

}
//注册自动代理创建器
public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
		return registerAutoProxyCreatorIfNecessary(registry, null);
	}
//给容器中注册一个 InfrastructureAdvisorAutoProxyCreator 组件
public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
		return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
}
//InfrastructureAdvisorAutoProxyCreator 组件 它也是一个后置处理器
public class InfrastructureAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator {

	private ConfigurableListableBeanFactory beanFactory;

     //初始化工厂
	@Override
	protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		super.initBeanFactory(beanFactory);
		this.beanFactory = beanFactory;
	}

	@Override
	protected boolean isEligibleAdvisorBean(String beanName) {
		return (this.beanFactory.containsBeanDefinition(beanName) &&
				this.beanFactory.getBeanDefinition(beanName).getRole() == BeanDefinition.ROLE_INFRASTRUCTURE);
	}

}
InfrastructureAdvisorAutoProxyCreator作用：关系图

作用：利用后置处理器机制在对象创建以后，包装对象，返回一个代理对象（增强器），代理对象执行方法利用拦截器链进行调用


//注册自动代理创建器定义信息
private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		//public static final String AUTO_PROXY_CREATOR_BEAN_NAME ="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;
		}
		//构建RootBeanDefinition 对象
		RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
		beanDefinition.setSource(source);
		beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
		beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
		//往容器中注册该bean的定义信息
		registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
		return beanDefinition;
}
@Override
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException {

 。。。。。。。。。。。。。。。。。。。
 BeanDefinition oldBeanDefinition;

 oldBeanDefinition = this.beanDefinitionMap.get(beanName);
 if (oldBeanDefinition != null) {
	 。。。。。。。。。。。。。。。。。。。
	 //使用map保存到容器中
	 this.beanDefinitionMap.put(beanName, beanDefinition);
 }
	 。。。。。。。。。。。。。。。。。。。。。
 if (oldBeanDefinition != null || containsSingleton(beanName)) {
	 resetBeanDefinition(beanName);
	}
}

ProxyTransactionManagementConfiguration：

//配置类 
@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());
		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());
		// this.txManager PlatformTransactionManager 事务管理者
		if (this.txManager != null) {
		    //设置了事务管理信息
			interceptor.setTransactionManager(this.txManager);
		}
		return interceptor;
	}

}
//注册各种事务解析器，解析器解析各种标签如new SpringTransactionAnnotationParser()
public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
	this.publicMethodsOnly = publicMethodsOnly;
	this.annotationParsers = new LinkedHashSet<TransactionAnnotationParser>(2);
	this.annotationParsers.add(new SpringTransactionAnnotationParser());
	。。。。。。。。。。。。。。。。。。。。
}
	
//SpringTransactionAnnotationParser
@Override
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
	AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ae, Transactional.class);
	if (attributes != null) {
		return parseTransactionAnnotation(attributes);
	}
	else {
		return null;
	}
}

public TransactionAttribute parseTransactionAnnotation(Transactional ann) {
	return parseTransactionAnnotation(AnnotationUtils.getAnnotationAttributes(ann, false, false));
}
//@Transactional内各种属性信息
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"));//属性值
	。。。。。。。。。。。。。。。。。。。。。
	。。。。。。。。。。。。。。。。。。。
	rbta.getRollbackRules().addAll(rollBackRules);
	return rbta;
}	

TransactionInterceptor：关系图
作用：1.先获取事务相关的属性2.再获取PlatformTransactionManager，如果事先没有添加指定任何transactionmanger最终会从容器中按照类型获取一个PlatformTransactionManager；
3.执行目标方法如果异常，获取到事务管理器，利用事务管理回滚操作；如果正常，利用事务管理器，提交事务

public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {
     。。。。。
	@Override
	public Object invoke(final MethodInvocation invocation) throws Throwable {
	
		Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

		// 在目标方法执行的时候；执行拦截器链；
		//TransactionInterceptor：事务拦截器：
		return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
			@Override
			public Object proceedWithInvocation() throws Throwable {
				return invocation.proceed();
			}
		});
	}
      。。。。。

	//---------------------------------------------------------------------
	// 支持序列化
	//---------------------------------------------------------------------
    。。。。。。。。。
}

protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final InvocationCallback invocation)
			throws Throwable {

		//先获取事务相关的属性
		final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
		final PlatformTransactionManager tm = determineTransactionManager(txAttr);
		final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
		//如果是一个事务
		if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
			//如果事先没有添加指定任何transactionmanger最终会从容器中按照类型获取一个PlatformTransactionManager
			TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
			Object retVal = null;
			try {
				//执行目标方法 如果正常，
				retVal = invocation.proceedWithInvocation();
			}
			catch (Throwable ex) {
				//如果异常，获取到事务管理器，利用事务管理回滚操作；
				completeTransactionAfterThrowing(txInfo, ex);
				throw ex;
			}
			finally {
				cleanupTransactionInfo(txInfo);
			}
			//利用事务管理器，提交事务
			commitTransactionAfterReturning(txInfo);
			return retVal;
		}
		。。。。。。。。。。。。。
}

具体流程可以在项目中根据上面注册的两个组件点击debug查看，这里详述太麻烦，我比较懒。