【源码讲解】Spring事务是如何应用到你的业务场景中的？

初衷

日常开发中经常用到@Transaction注解，那你知道它是怎么应用到你的业务代码中的吗？本篇文章将从以下两个方面阐述Spring事务实现原理：

1. 解析并加载事务配置：本质上是解析xml文件将标签加载成 BeanDefinition 对象；
2. 生成事务代理对象并运行：本质上是Spring AOP在事务这块的应用，将业务Bean替换成事务代理对象（JdkDynamicAopProxy：JDK代理，CglibAopProxy：CGLIB代理）；

本文使用的源码版本是Spring 4.3.18.RELEASE，使用的是XML开启事务。

关键类

这里列出几个核心类，提前留个印象，后面会讲解什么时候调用

1. XmlBeanDefinitionReader 加载XML定义的Bean入口
2. TxNamespaceHandler 解析XML中的事务标签： advice、annotation-driven等；
3. InfrastructureAdvisorAutoProxyCreator 该类实现了 BeanPostProcessor 接口（可以在Bean初始化后进行替换），是生成事务代理类并替换的关键类；
4. AnnotationTransactionAttributeSource 用来解析业务方法使用注解 @Transaction 上的配置，提供给 TransactionInterceptor 使用；
5. TransactionInterceptor 事务拦截类：真正处理事务的类，开启、回滚事务，可以理解成切面中的通知：做什么；
6. BeanFactoryTransactionAttributeSourceAdvisor 实现了Advisor接口，可以理解为切面：切点(TransactionAttributeSourcePointcut) + 通知(TransactionInterceptor)。

示例代码：

	public class TransactionService {
	
	    @Transactional(rollbackFor = Throwable.class)
	    public void testTransaction(){
	        System.out.println("方法逻辑");
	    }
	}

     ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("config.xml");
     TransactionService transactionService = context.getBean(TransactionService.class);
     transactionService.testTransaction();

1. 解析并加载事务配置

加载的入口(同时也是Spring容器加载的核心代码)：

synchronized (this.startupShutdownMonitor) {
			// Prepare this context for refreshing.
			prepareRefresh();

			// 重点，这里是Spring初始化默认的容器，在这一步会通过解析配置文件将定义的bean转换为 BeanDefinition，
			// 保存在 beanDefinitionMap 中
			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

			// Prepare the bean factory for use in this context.
			prepareBeanFactory(beanFactory);

			try {
				// Allows post-processing of the bean factory in context subclasses.
				postProcessBeanFactory(beanFactory);

				// Invoke factory processors registered as beans in the context.
				invokeBeanFactoryPostProcessors(beanFactory);

				// Register bean processors that intercept bean creation.
				registerBeanPostProcessors(beanFactory);

				// Initialize message source for this context.
				initMessageSource();

				// Initialize event multicaster for this context.
				initApplicationEventMulticaster();

				// Initialize other special beans in specific context subclasses.
				onRefresh();

				// Check for listener beans and register them.
				registerListeners();

				// 重点，初始化所有非懒加载bean的方法，也可以理解为根据特定规则将 BeanDefinition 转成 Bean对象的方法
				finishBeanFactoryInitialization(beanFactory);

				// Last step: publish corresponding event.
				finishRefresh();
			}

			catch (BeansException ex) {
				if (logger.isWarnEnabled()) {
					logger.warn("Exception encountered during context initialization - " +
							"cancelling refresh attempt: " + ex);
				}

				// Destroy already created singletons to avoid dangling resources.
				destroyBeans();

				// Reset 'active' flag.
				cancelRefresh(ex);

				// Propagate exception to caller.
				throw ex;
			}

			finally {
				// Reset common introspection caches in Spring's core, since we
				// might not ever need metadata for singleton beans anymore...
				resetCommonCaches();
			}
		}

事务配置的解析在上面的obtainFreshBeanFactory，由于我们使用的是ClassPathXmlApplicationContext 作为容器，它的解析类为：XmlBeanDefinitionReader；核心方法：

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
		Assert.notNull(encodedResource, "EncodedResource must not be null");
		if (logger.isInfoEnabled()) {
			logger.info("Loading XML bean definitions from " + encodedResource.getResource());
		}

		Set currentResources = this.resourcesCurrentlyBeingLoaded.get();
		if (currentResources == null) {
			currentResources = new HashSet(4);
			this.resourcesCurrentlyBeingLoaded.set(currentResources);
		}
		if (!currentResources.add(encodedResource)) {
			throw new BeanDefinitionStoreException(
					"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
		}
		try {
			// 读取 config.xml 文件
			InputStream inputStream = encodedResource.getResource().getInputStream();
			try {
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
				// 开始加载 config.xml 文件中定义的bean，这里只是加载成BeanDefinition，初始化在另外的方法
				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
			}
			finally {
				inputStream.close();
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"IOException parsing XML document from " + encodedResource.getResource(), ex);
		}
		finally {
			currentResources.remove(encodedResource);
			if (currentResources.isEmpty()) {
				this.resourcesCurrentlyBeingLoaded.remove();
			}
		}
	}
	

doLoadBeanDefinitions 具体解析的方法是在org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions 中进行，该方法如下

		protected void doRegisterBeanDefinitions(Element root) {
		// Any nested  elements will cause recursion in this method. In
		// order to propagate and preserve  default-* attributes correctly,
		// keep track of the current (parent) delegate, which may be null. Create
		// the new (child) delegate with a reference to the parent for fallback purposes,
		// then ultimately reset this.delegate back to its original (parent) reference.
		// this behavior emulates a stack of delegates without actually necessitating one.
		BeanDefinitionParserDelegate parent = this.delegate;
		this.delegate = createDelegate(getReaderContext(), root, parent);

		if (this.delegate.isDefaultNamespace(root)) {
			String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
			if (StringUtils.hasText(profileSpec)) {
				String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
						profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
				if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
					if (logger.isInfoEnabled()) {
						logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
								"] not matching: " + getReaderContext().getResource());
					}
					return;
				}
			}
		}

		preProcessXml(root);
		// 真正解析config.xml文件
		parseBeanDefinitions(root, this.delegate);
		postProcessXml(root);

		this.delegate = parent;
	}
	
	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
	    // 判断根节点是不是默认的节点，实际通过判断根节点的 namespaceURI 属性是不是 http://www.springframework.org/schema/beans ，
	    // 我们这里的配置文件声明的正好是这个属性，所以返回的是true，注意bean标签也是默认标签
		if (delegate.isDefaultNamespace(root)) {
			// 获取子节点
			NodeList nl = root.getChildNodes();
			for (int i = 0; i < nl.getLength(); i++) {
				Node node = nl.item(i);
				// 判断子节点是不是标签
				if (node instanceof Element) {
					Element ele = (Element) node;
					// bean标签的解析
					if (delegate.isDefaultNamespace(ele)) {
						parseDefaultElement(ele, delegate);
					}
					// 重点：tx标签在这里进行
					else {
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			delegate.parseCustomElement(root);
		}
	}
	// 解析非bean的标签
	public BeanDefinition parseCustomElement(Element ele) {
		return parseCustomElement(ele, null);
	}
	// 解析非默认标签方法
	public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
		String namespaceUri = getNamespaceURI(ele);
		// 这里是Spring使用了策略模式解析配置，通过namespaceUri匹配对应的处理类，也就是上面的关键类 TxNamespaceHandler，
		// 这里的resolve运用了懒加载，在获取映射关系handlerMappings属性为null时会从META-INF/spring.handlers 下面获取映射关系，
		// 由于IDEA debug的时候默认会调用getHandlerMappings方法，所以使用debug的时候会发现一开始就有值
		NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
		if (handler == null) {
			error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
			return null;
		}
		// 获取到处理类后，让处理类开始解析配置
		return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
	}

TxNamespaceHandler 最终交给类 AnnotationDrivenBeanDefinitionParser 进行解析事务配置；

public BeanDefinition parse(Element element, ParserContext parserContext) {
		// 注册一个事务工厂事件，允许我们自定义监听事务的提交等操作
		registerTransactionalEventListenerFactory(parserContext);
		String mode = element.getAttribute("mode");
		// 如果使用的是 aspectj 方式，走这个方法
		if ("aspectj".equals(mode)) {
			// mode="aspectj"
			registerTransactionAspect(element, parserContext);
		}
		else {
			// 默认使用的是代理模式 
			// mode="proxy"
			AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);
		}
		return null;
	}
	
	/**
	 * Inner class to just introduce an AOP framework dependency when actually in proxy mode.
	 */
	private static class AopAutoProxyConfigurer {

		public static void configureAutoProxyCreator(Element element, ParserContext parserContext) {
			// 重点，注册 InfrastructureAdvisorAutoProxyCreator 的 BeanDefinition，这个是个关键类，代理业务bean的操作都靠它了
			AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);

			String txAdvisorBeanName = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME;
			if (!parserContext.getRegistry().containsBeanDefinition(txAdvisorBeanName)) {
				Object eleSource = parserContext.extractSource(element);

				// 重点，注册一个全局的 TransactionAttributeSource 的BeanDefinition ,用于解析 @Transaction 定义的元数据
				RootBeanDefinition sourceDef = new RootBeanDefinition(
						"org.springframework.transaction.annotation.AnnotationTransactionAttributeSource");
				sourceDef.setSource(eleSource);
				sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
				String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);

				// 重点，注册 TransactionInterceptor 的BeanDefinition，这个就是事务真正执行的类，可以理解为是事务切面上的通知
				RootBeanDefinition interceptorDef = new RootBeanDefinition(TransactionInterceptor.class);
				interceptorDef.setSource(eleSource);
				interceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
				registerTransactionManager(element, interceptorDef);
				interceptorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
				String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);

				// 重点，注册 BeanFactoryTransactionAttributeSourceAdvisor 的BeanDefinition，可以理解为事务的切面，
				// 包含了切点(TransactionAttributeSourcePointcut) + 通知(TransactionInterceptor)，保存在 ProxyFactory 中，用于生成代理对象
				RootBeanDefinition advisorDef = new RootBeanDefinition(BeanFactoryTransactionAttributeSourceAdvisor.class);
				advisorDef.setSource(eleSource);
				advisorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
				advisorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
				advisorDef.getPropertyValues().add("adviceBeanName", interceptorName);
				if (element.hasAttribute("order")) {
					advisorDef.getPropertyValues().add("order", element.getAttribute("order"));
				}
				parserContext.getRegistry().registerBeanDefinition(txAdvisorBeanName, advisorDef);

				CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), eleSource);
				compositeDef.addNestedComponent(new BeanComponentDefinition(sourceDef, sourceName));
				compositeDef.addNestedComponent(new BeanComponentDefinition(interceptorDef, interceptorName));
				compositeDef.addNestedComponent(new BeanComponentDefinition(advisorDef, txAdvisorBeanName));
				parserContext.registerComponent(compositeDef);
			}
		}
	}

到这里，事务配置的加载就结束了，上面的步骤只是将事务的关键类变成 BeanDefinition，实际上还没有生成Bean对象的，下面我们看下BeanDefinition 是如何变成Bean的（这一个步骤不是Spring事务独有的，是所有BeanDefinition 的共同逻辑），然后是如何生成业务bean代理对象并替换业务bean的。

2. 生成事务代理对象

入口在 1.解析并加载事务配置 列举的finishBeanFactoryInitialization(beanFactory) 方法中：

	/**
	 * Finish the initialization of this context's bean factory,
	 * initializing all remaining singleton beans.
	 */
	protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// Initialize conversion service for this context.
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		// Register a default embedded value resolver if no bean post-processor
		// (such as a PropertyPlaceholderConfigurer bean) registered any before:
		// at this point, primarily for resolution in annotation attribute values.
		if (!beanFactory.hasEmbeddedValueResolver()) {
			beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
				@Override
				public String resolveStringValue(String strVal) {
					return getEnvironment().resolvePlaceholders(strVal);
				}
			});
		}

		// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// Stop using the temporary ClassLoader for type matching.
		beanFactory.setTempClassLoader(null);

		// Allow for caching all bean definition metadata, not expecting further changes.
		beanFactory.freezeConfiguration();

		// 重点，开始初始化所有非懒加载的bean
		beanFactory.preInstantiateSingletons();
	}

beanFactory.preInstantiateSingletons() 具体方法如下：

public void preInstantiateSingletons() throws BeansException {
		if (this.logger.isDebugEnabled()) {
			this.logger.debug("Pre-instantiating singletons in " + this);
		}

		// Iterate over a copy to allow for init methods which in turn register new bean definitions.
		// While this may not be part of the regular factory bootstrap, it does otherwise work fine.将所有注册的BeanDefinition 名称保存到起来
		List beanNames = new ArrayList(this.beanDefinitionNames);

		// Trigger initialization of all non-lazy singleton beans...
		for (String beanName : beanNames) {
			// 获取 BeanDefinition
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			// bean定义不是抽象、懒加载而且是单例bean
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				// 工厂bean特有逻辑，这不是我们的关注点，我们关注点是else的 getBean(beanName);
				if (isFactoryBean(beanName)) {
					final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged(new PrivilegedAction() {
							@Override
							public Boolean run() {
								return ((SmartFactoryBean) factory).isEagerInit();
							}
						}, getAccessControlContext());
					}
					else {
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean) factory).isEagerInit());
					}
					if (isEagerInit) {
						getBean(beanName);
					}
				}
				else {
					// 重点，将 BeanDefinition 创建成bean的核心方法，同时也是执行 BeanPostProcessor 的入口
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged(new PrivilegedAction