声明式事务的注册入口

1

http\://www.springframework.org/schema/tx=org.springframework.transaction.config.TxNamespaceHandler

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

public class TxNamespaceHandler extends NamespaceHandlerSupport {
    public void init() {
		// advice通知方法有关的，<tx:advice /> <tx:attributes /> <tx:method /> 标签支持在这里。
		registerBeanDefinitionParser("advice", new TxAdviceBeanDefinitionParser());
		// <tx:annotation-driven /> 解析支持
		registerBeanDefinitionParser("annotation-driven", new AnnotationDrivenBeanDefinitionParser());
		// 可以不看。
		registerBeanDefinitionParser("jta-transaction-manager", new JtaTransactionManagerBeanDefinitionParser());
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParser {
   public BeanDefinition parse(Element element, ParserContext parserContext) {
   		// 当前方法注册了InfrastructureAdvisorAutoProxyCreator  Infrastructure-->基础设施，优先级最低。
   		// 注意：区分@Aspect以及<aop:aspectj-autoproxy/>：两者注册的是AnnotationAwareAspectJAutoProxyCreator，最终按照优先级来确定使用哪个的。
   		
   		// 注册事务事件监听器，@TransactionalEventListener注解的支持。可以不看。
   		registerTransactionalEventListenerFactory(parserContext);
   		String mode = element.getAttribute("mode");
   		// 根据mode的值，来确定注册哪种类型的事务支持。这个不常用，可以不看。着重看else里面的内容。
   		if ("aspectj".equals(mode)) {
   			// mode="aspectj"
   			registerTransactionAspect(element, parserContext);
   			if (ClassUtils.isPresent("javax.transaction.Transactional", getClass().getClassLoader())) {
   				registerJtaTransactionAspect(element, parserContext);
   			}
   		}
   		else {
   			// TODO 默认值是proxy，主要看这个。
   			// mode="proxy"
   			AopAutoProxyConfigurer.configureAutoProxyCreator(element, parserContext);
   		}
   		return null;
   	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

private static class AopAutoProxyConfigurer {

		public static void configureAutoProxyCreator(Element element, ParserContext parserContext) {
			// TODO 注册Advisor
			AopNamespaceUtils.registerAutoProxyCreatorIfNecessary(parserContext, element);
			// 这里是一个常量，事务Advisor，等后面实例化时，如果匹配到方法，Advisor会封装到代理对象的执行链里面。
			String txAdvisorBeanName = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME;
			if (!parserContext.getRegistry().containsBeanDefinition(txAdvisorBeanName)) {
				Object eleSource = parserContext.extractSource(element);

				// 创建AnnotationTransactionAttributeSource的BeanDefinition，这是一个策略接口的实现。用于获取事务注解的属性值。
				// Create the TransactionAttributeSource definition.
				RootBeanDefinition sourceDef = new RootBeanDefinition(
						"org.springframework.transaction.annotation.AnnotationTransactionAttributeSource");
				sourceDef.setSource(eleSource);
				sourceDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
				String sourceName = parserContext.getReaderContext().registerWithGeneratedName(sourceDef);

				// 创建对应的MethodInterceptor，这是事务的方法拦截器，最终在生成代理的时候，会缓存到AdvisedSupport中，第一次调用执行生成执行链的时候，
				// 如果匹配对应的方法，就会将方法名-MethodInterceptor的映射关系存储到执行链。同样是缓存到AdvisedSupport中。
				// Create the TransactionInterceptor definition.
				RootBeanDefinition interceptorDef = new RootBeanDefinition(TransactionInterceptor.class);
				interceptorDef.setSource(eleSource);
				interceptorDef.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
				// 注意，这里只注入了一个名字，PlatformTransactionManager需要我们手动注入到容器，在创建TransactionInterceptor时，会通过getBean()来获取
				registerTransactionManager(element, interceptorDef);
				interceptorDef.getPropertyValues().add("transactionAttributeSource", new RuntimeBeanReference(sourceName));
				String interceptorName = parserContext.getReaderContext().registerWithGeneratedName(interceptorDef);

				// 创建BeanFactoryTransactionAttributeSourceAdvisor的BeanDefinition，并注册到registry中。当bean在实例化，
				// 查找容器中所有的增强方法时，会对所有的@Aspect封装成Advisor并实例化，以及直接注入进来的Advisor提前实例化，缓存到AdvisedSupport中。
				// 从接口层面说，这里创建一个Advisor。
				// Create the TransactionAttributeSourceAdvisor definition.
				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);
                // 剩余源码省略 ...
			}
		}
	}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {
   @Override
   	public void afterPropertiesSet() {
   		// 开启事务支持，那么PlatformTransactionManager和TransactionAttributeSource这两个实例是必须有的，否则启动就会抛出异常。
   		if (getTransactionManager() == null && this.beanFactory == null) {
   			throw new IllegalStateException(
   					"Set the 'transactionManager' property or make sure to run within a BeanFactory " +
   					"containing a PlatformTransactionManager bean!");
   		}
   		if (getTransactionAttributeSource() == null) {
   			throw new IllegalStateException(
   					"Either 'transactionAttributeSource' or 'transactionAttributes' is required: " +
   					"If there are no transactional methods, then don't use a transaction aspect.");
   		}
   	}
}

1
2
3
4
5
6

class AnnotationDrivenBeanDefinitionParser implements BeanDefinitionParser {
    private static void registerTransactionManager(Element element, BeanDefinition def) {
		def.getPropertyValues().add("transactionManagerBeanName",
				TxNamespaceHandler.getTransactionManagerName(element));
	}
}

1
2
3
4
5
6
7
8

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
// TODO 重点：事务注册入口类
@Import(TransactionManagementConfigurationSelector.class)
public @interface EnableTransactionManagement {
// 省略...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {
	@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;
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

@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() {
		// TODO 事务属性解析类
		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
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public class AnnotationTransactionAttributeSource extends AbstractFallbackTransactionAttributeSource
		implements Serializable {
	// 步骤一
	public AnnotationTransactionAttributeSource() {
		this(true);
	}

	// 步骤二
	public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
		// 这里注入了注解解析类。 SpringTransactionAnnotationParser，解析时就用到的这个类中的方法
		this.publicMethodsOnly = publicMethodsOnly;
		if (jta12Present || ejb3Present) {
			this.annotationParsers = new LinkedHashSet<>(4);
            // TODO 重点看这里
			this.annotationParsers.add(new SpringTransactionAnnotationParser());
			if (jta12Present) {
				this.annotationParsers.add(new JtaTransactionAnnotationParser());
			}
			if (ejb3Present) {
				this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
			}
		}
		else {
			this.annotationParsers = Collections.singleton(new SpringTransactionAnnotationParser());
		}
	}
}