Spring中的事物源码解析

前言

在Spring中，使用事物的方式基本上都是通过声明@Transactional来完成的。

xml方式

在xml的IOC容器中<tx:annotation-driven/>开启Spring的声明式事物支持。

Spring事物xml标签的解析由TxNamespaceHandler来处理。

<tx:annotation-driven/>该标签的解析由AnnotationDrivenBeanDefinitionParser来解析处理。

Spring声明式事物涉及三个核心类：

• BeanFactoryTransactionAttributeSourceAdvisor：
  在bean的初始化中，有一步populateBean，为该bean设置属性对象。
  属性是从哪里赋值的呢？
  在AnnotationDrivenBeanDefinitionParser解析该xml标签的时候，通过代码添加的。

  /**
  	 * Parses the {@code <tx:annotation-driven/>} tag. Will
  	 * {@link AopNamespaceUtils#registerAutoProxyCreatorIfNecessary register an AutoProxyCreator}
  	 * with the container as necessary.
  	 */
  	@Override
  	public BeanDefinition parse(Element element, ParserContext parserContext) {
  		registerTransactionalEventListenerFactory(parserContext);
  		String mode = element.getAttribute("mode");
  		if ("aspectj".equals(mode)) {
  			// mode="aspectj"
  			registerTransactionAspect(element, parserContext);
  		}
  		else {
  			// mode="proxy"
  			// 默认走这里，为该beanDefinition添加属性值，以便创建该bean的时候
  			// 其field域的属性能被赋值。
  			AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);
  		}
  		return null;
  	}
  	
  

  在populateBean()的该对象的属性值的时候，触发AnnotationTransactionAttributeSource对象和TransactionInterceptor的创建。即transactionAttributeSource属性和adviceBeanName属性。

• AnnotationTransactionAttributeSource：
  AnnotationTransactionAttributeSource(true)决定了@Transactional只能应用在public方法中。
  值为true，代表@Transanctional只能应用在public方法中，且是基于AOP代理的
  值为false，代表@Transactional可以应用在protected or private方法中，且是基于AspectJ代理的

• TransactionInterceptor：

• DataSourceTransactionManager：

注解的方式

通过@EnableTransactionManagement来开启Spring事物的声明式管理，这个注解引入TransactionManagementConfigurationSelector。

	/**
	 * 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[] {
				// 引入SpringAOP处理，即AnnotationAwareAspectJAutoProxyCreator
				AutoProxyRegistrar.class.getName(),
				// 事物配置类，即开启声明式事物所需的三个核心对象
				ProxyTransactionManagementConfiguration.class.getName()};
			case ASPECTJ:
				return new String[] {determineTransactionAspectClass()};
			default:
				return null;
		}
	}

该注解的解析是由ConfigurationClassPostProcessor来处理成可供IOC容器生成bean的BeanDefinition。【processImports阶段来处理该ImportSelector】

由AnnotationAwareAspectJAutoProxyCreator这个BeanPostProcessor通过postProcessBeforeInstantiation来触发Spring声明式事物的三个核心类的Bean对象创建（findAdvisorBeans()）。在这个过程中，触发对配置类ProxyTransactionManagementConfiguration的创建。

通过ProxyTransactionManagementConfiguration的创建来看ImportAware的作用？

在initializationBean阶段中交由ConfigurationClassPostProcessor$ImportAwareBeanPostProcessor处理ImportAware接口。有什么作用呢？获取该bean的注解元数据。

	// ImportAwareBeanPostProcessor 获取一个bean的注解元数据
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) {
		if (bean instanceof ImportAware) {
			ImportRegistry ir = this.beanFactory.getBean(IMPORT_REGISTRY_BEAN_NAME, ImportRegistry.class);
			AnnotationMetadata importingClass = ir.getImportingClassFor(ClassUtils.getUserClass(bean).getName());
			if (importingClass != null) {
				 // 设置注解元数据
				((ImportAware) bean).setImportMetadata(importingClass);
			}
		}
		return bean;
	}
	
	// 为ProxyTransactionManagementConfiguration设置注解元数据
	@Override
	public void setImportMetadata(AnnotationMetadata importMetadata) {
		this.enableTx = AnnotationAttributes.fromMap(
				importMetadata.getAnnotationAttributes(EnableTransactionManagement.class.getName(), false));
		if (this.enableTx == null) {
			throw new IllegalArgumentException(
					"@EnableTransactionManagement is not present on importing class " + importMetadata.getClassName());
		}
	}

代理对象

代理对象的生成是在bean初始化的initializationBean阶段，即advisedBeans缓存，防止重复代理bean对象（用@Aspect注解的类不会被代理）。

    // 在doCreateBean之前,接口代理处理，会给advisedBeans赋值
	try {
		// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
		// 这里，在AbstractAutoProxyCreator中，以下情况不能代理
		// 情况一：该类角色是基础设施类或者用切面注解，isInfrastructureClass(beanClass)
		// 情况二：shouldSkip，是否应该跳过代理
		// 是这两种情况，不能AOP代理，用advisedBeans存放判断结果
		// this.advisedBeans.put(cacheKey, Boolean.FALSE); return null;
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	}

生成的代理对象只有一个，对于自定义AOP跟@Transactional同切一个方法，也只对该方法所在类生成一个代理对象，所不同的是自定义的AOP切面对应的是InstantiationModelAwarePointcutAdvisor和BeanFactoryTransactionAttributeSourceAdvisor这两个Advisor进行针对性切面匹配处理。

用@Aspect进行自定义切面的，防止对方法的重复切逻辑匹配判断处理， 用shadowMatchCache进行缓存。
用@Transactional进行事物切面的，防止对方法的重复切逻辑匹配判断处理， 用attributeCache进行缓存。【因为，匹配的过程，有关类下的所有方法进行匹配，且当执行该事物方法时，会重新再通过attributeCache获取TransactionAttribute。】

为什么要有这两个缓存？
因为，只要开启Aop和事物，那么在IOC容器初始化的bean的创建中，总会有Bean后置处理器AnnotationAwareAspectJAutoProxyCreator对该bean进行处理。那么，如果该bean需要代理，就会每次都走该处理器的父类AbstractAutoProxyCreator的wrapIfNecessary()方法。

	/**
	 * Wrap the given bean if necessary, i.e. if it is eligible for being proxied.
	 * @param bean the raw bean instance
	 * @param beanName the name of the bean
	 * @param cacheKey the cache key for metadata access
	 * @return a proxy wrapping the bean, or the raw bean instance as-is
	 */
	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		// 通过缓存的advisedBean先判断是否代理
		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
			return bean;
		}
		// 基础设施类或者Aop类以及shouldSkip不代理
		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}

		// Create proxy if we have advice.
		// 是否有针对该bean代理处理的Advisor
		// 这个获取，就是防止重复处理，用缓存进行
		// 如果是AOP，用shadowCache；如果是Transaction，用attributeCache缓存
		// 该方法对应的TransactionAttribute
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		if (specificInterceptors != DO_NOT_PROXY) {
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
			Object proxy = createProxy(
					bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}

		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}

这一过程发生在findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName)阶段中。

@Aspect和@Transactional都是被AnnotationAwareAspectJAutoProxyCreator来处理的。而@Async是被AsyncAnnotationBeanPostProcessor所来处理的。
完整分析可以参考IOC容器初始化之AOP内部机制

事物执行

在执行事物方法（被切方法）时，防止重复进入创建方法执行器并处理，用methodCache方法缓存，缓存该方法的拦截器或者Advise链（是List<Object>），因为该方法会被不同切面处理，比如这个场景：自定义的AOP切这个方法和用 @Transactional切这个方法。同时，这个场景需要注意，自定义的切面如果跟声明式事物同切一个方法时，一定要注意，自定义切面的通知方法，显示抛出异常，否则，异常被吃掉，导致声明式事物不起作用。

会进入CglibAopProxy的intercept方法【方法拦截】。

获取到该方法的所有的拦截器Interceptor及Advice。

	// 1. 获取AOP中所有的Advisor
	// 2. 从所有的Advisor中，筛选出它们的匹配器能匹配到该方法的MethodInterceptor
	// 在这个matches的过程中会用到TransactionAttribute，因此是从缓存中获取的。
	List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

创建CglibMethodInvocation方法执行器进行proceed()处理。

进入TransactionInterceptor的invoke处理，即在事物的情形下执行：
return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);。

1.获取事务属性源TransactionAttributeSource
	怎么来的？即是TransactionInterceptor中的属性值。
	在创建TransactionInterceptor对象的时候赋值。
		=> ProxyTransactionManagementConfiguration
		
2.从TransactionAttributeSource中获取事务属性TransactionAttribute。
	这里是从缓存中获取的，第一次创建是在创建事物方法所在的类的代理对象的初始化bean阶段，
	用AnnotationAwareAspectJAutoProxyCreator创建代理对象的时候，将@Transactional
	转换成TransactionAttribute。
	
3.从IOC容器中获取事务管理器TransactionManager【DataSourceTransactionManager】。
4.将事物管理器对象强转及获取事物方法信息(methodJoinPointInfo，以此作为事物名【默认】)。
5.根据事物属性，事务管理器，事物方法信息创建事物【createTransactionIfNecessary】
	(这里，注意一下命名，获取的是事物信息TransactionInfo，但是方法命名却是Transaction，
	简化方法的命名，不是根据返回值命名，而是根据语义命名。)
	
	5.1 根据事物属性从事务管理器中获取事物【TransactionStatus】
	(这里的方法名同上，也是没有命名为getTransactionStatus，而是getTransaction)
		
		5.1.1 真正获取事物（方法命名，doGetTransaction，且这是一个模板方法，实际实现，
		交由具体的事务管理器实现，比如DataSourceTransactionManager）
			创建一个事物对象，DataSourceTransactionObject
			给对象设定相应属性值，比如，嵌套事物，Jdbc连接
			Jdbc连接是怎么获取的？
			从事物同步管理器中获取：
			TransactionSynchronizationManager.getResource(obtainDataSource())
			事物同步管理器，通过NameThreadLocal将线程与事物相关信息进行了绑定，通过
			ThreadLocal，我们也不难看出，Spring的事物是本地事物。

		5.1.2 已经存在事物【场景：嵌套事物】
			判断事物存在的方法：
				就是判断新建事物（事物对象）中是否含有Jdbc连接（Holder）或者Jdbc连接
				（Holder）中的事物活跃
				
			处理存在的事物：handleExistingTransaction，依照事物的传播机制分场景处理

		5.1.3 当前不存在事物，依照事物的传播机制分场景处理
			不支持这种传播机制：TransactionDefinition.PROPAGATION_MANDATORY
			
			该事物方法定义的传播行为是以下三种：
				TransactionDefinition.PROPAGATION_REQUIRED
				TransactionDefinition.PROPAGATION_REQUIRES_NEW
				TransactionDefinition.PROPAGATION_NESTED
			挂起事物：suspend(null)
			
			开始事务：startTransaction
				创建事物状态TransactionStatus
				实际开始事务：doBegin（方法命名，没有起名doBeginTransaction，
				因为语境已是开始事物阶段）
				
					事物对象中不存在连接Holder或者连接没有到事物同步阶段
						从数据源中获取连接对象，为事物对象设置连接对象
					为事物对象设置事物同步标志true，到事物同步阶段
					为事物对象设置隔离级别，只读标识
					Jdbc连接自动提交：
						设置为非自动提交（因此，Spring事物都是非自动提交方式）
					准备事物连接：prepareTransactionalConnection
						事物是否只读
					为事物对象的连接Holder设置事物活跃标志，true
					事物对象是新创建的，绑定连接到当前线程ThreadLocal：
						TransactionSynchronizationManager.bindResource(
							obtainDataSource(), 
							txObject.getConnectionHolder());
					在整个doBegin阶段中抛异常的话：
						事物对象是新创建的：
							释放Jdbc连接
							为该事物对象的connectionHolder置空
				准备同步事物，绑定到线程：prepareSynchronization
			开始事物这个阶段抛异常：
				恢复挂起的事物资源：
					resume(null, suspendedResources);
	
	5.2 准备事物信息：prepareTransactionInfo
			将事物信息绑定到当前线程：
			原理的事物信息，赋值给oldTransactionInfo
6. 继续处理，多个切点，切的是同一个方法：
	invocation.proceedWithInvocation()
	最终，会再次进入ReflectiveMethodInvocation的proceed方法
	判断，事物方法的拦截器链执行完，执行实际方法invokeJoinPoint（被声明式事物注解的方法）
7.  执行被声明式事物注解的方法
	执行jdbc的方法的时候都没去提交。
8. 当执行完清除事物信息的时候cleanupTransactionInfo，提交事物：
	commitTransactionAfterReturning(txInfo);	
	
	通过事务管理器提交事物状态：commit
	
	是否回滚
	处理提交：processCommit
		提交前的准备：prepareForCommit
		提交前触发回调：triggerBeforeCommit
		事物完成前触发回调：triggerBeforeCompletion
		根据事物状态属性执行不同动作：
			有保存点savePoint，释放
			事物状态是一个新事物的状态，实际提交事物状态：doCommit(status)
	    提交事物之后触发回调：triggerAfterCommit
	    事物完成后触发回调：triggerAfterCompletion
	    	清除事物同步器
	    事物完成后清除：cleanupAfterCompletion
	    	事物状态的完成属性置为true
	    	事物同步器清除：TransactionSynchronizationManager.clear();
	    	完成之后实际清除事物：doCleanupAfterCompletion
	    		将数据源与当前线程解绑：		
					TransactionSynchronizationManager.unbindResource(obtainDataSource());
				重置Jdbc连接为自动提交
				重置事物之后的连接：
					DataSourceUtils.resetConnectionAfterTransaction(
					con, txObject.getPreviousIsolationLevel(), 
					txObject.isReadOnly());
					释放连接
					清除事物对象中的连接Holder
9.一次事物方法的执行已经完成