Spring声明式事务注解之@EnableTransactionManagement
1. 说明
@EnableTransactionManagement声明在主配置类上，表示开启声明式事务，其原理是通过@Import导入TransactionManagementConfigurationSelector组件，然后又通过TransactionManagementConfigurationSelector导入组件AutoProxyRegistrar和ProxyTransactionManagementConfiguration；
2. 原理分析
@EnableTransactionManagement代码实现如下：
|
1
2
3
4
5
6
7
8
9
10
|
@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented// 通过@Import导入TransactionManagementConfigurationSelector组件@Import(TransactionManagementConfigurationSelector.class) public @interface EnableTransactionManagement { boolean proxyTargetClass() default false; AdviceMode mode() default AdviceMode.PROXY; int order() default Ordered.LOWEST_PRECEDENCE;} |
@EnableTransactionManagement通过@Import导入TransactionManagementConfigurationSelector；
TransactionManagementConfigurationSelector的实现如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> { /** * {@inheritDoc} * @return {@link ProxyTransactionManagementConfiguration} or * {@code AspectJTransactionManagementConfiguration} for {@code PROXY} and * {@code ASPECTJ} values of {@link EnableTransactionManagement#mode()}, respectively */ @Override protected String[] selectImports(AdviceMode adviceMode) { switch (adviceMode) { case PROXY: // 根据@EnableTransactionManagement的固定值PROXY，这里会导入AutoProxyRegistrar组件和ProxyTransactionManagementConfiguration组件 return new String[] {AutoProxyRegistrar.class.getName(), ProxyTransactionManagementConfiguration.class.getName()}; case ASPECTJ: return new String[] {TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME}; default: return null; } } } |
所以TransactionManagementConfigurationSelector又导入了组件AutoProxyRegistrar和ProxyTransactionManagementConfiguration；
3. AutoProxyRegistrar分析
3.1 AutoProxyRegistrar继承关系
|
1
2
3
4
5
6
7
8
|
InfrastructureAdvisorAutoProxyCreator --AbstractAdvisorAutoProxyCreator --AbstractAdvisorAutoProxyCreator --ProxyProcessorSupport --SmartInstantiationAwareBeanPostProcessor // 跟AOP是原理是一样的 --InstantiationAwareBeanPostProcessor --BeanPostProcessor --BeanFactoryAware |
3.2 AutoProxyRegistrar的所用
AutoProxyRegistrar的作用跟AOP中的AnnotationAwareAspectJAutoProxyCreator是一样的，利用后置处理器机制在对象创建以后，包装对象，返回一个代理对象（增强器），代理对象执行方法利用拦截器链进行调用；InfrastructureAdvisorAutoProxyCreator继承SmartInstantiationAwareBeanPostProcessor，跟AOP的原理是一样的，也是通过@Transactional作为方法拦截的标记，把有事务管理的类作为目标类，生成代理对象，然后增强@Transactional标记的方法，在使用目标方法的时候，从IOC容器中获取的其实是被增强的代理类，且事务方法会被代理，跟AOP原理一样的；
4. ProxyTransactionManagementConfiguration分析
ProxyTransactionManagementConfiguration是一个配置类，想IOC容器中导入事务增强器(BeanFactoryTransactionAttributeSourceAdvisor)，事务注解@Transactional的解析器(AnnotationTransactionAttributeSource)和事务方法拦截器(TransactionInterceptor)；
|
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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
|
package org.springframework.transaction.annotation; import org.springframework.beans.factory.config.BeanDefinition;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.context.annotation.Role;import org.springframework.transaction.config.TransactionManagementConfigUtils;import org.springframework.transaction.interceptor.BeanFactoryTransactionAttributeSourceAdvisor;import org.springframework.transaction.interceptor.TransactionAttributeSource;import org.springframework.transaction.interceptor.TransactionInterceptor; @Configurationpublic class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration { /** 事务增强器(Advisor)，在事务类创建的时候，被AutoProxyRegistrar导入的组件InfrastructureAdvisorAutoProxyCreator拦截， InfrastructureAdvisorAutoProxyCreator拦截的逻就是增强事务类的事务方法， 而BeanFactoryTransactionAttributeSourceAdvisor作为增强器， 与需要增强的方法(这里是指被@Transactional标记的方法)进行匹配，匹配成功的增强器，最后转成拦截器(MethodInterceptor, 就是下面的TransactionInterceptor)，然后与目标方法一起在拦截器链中被执行，达到方法增强的效果； BeanFactoryTransactionAttributeSourceAdvisor的继承关系如下： BeanFactoryTransactionAttributeSourceAdvisor --AbstractBeanFactoryPointcutAdvisor --AbstractPointcutAdvisor --PointcutAdvisor --Advisor AOP中AspectJPointcutAdvisor的继承关系如下，与AbstractPointcutAdvisor一样，都实现PointcutAdvisor --AspectJPointcutAdvisor --PointcutAdvisor --Advisor */ @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; } /** @Transactional注解的解析类；负责解析事务方法上@Transactional中的各个参数配置，解析的时机是在创建事务类之后被增强的时候， 匹配事务方法的时候一起被解析了 AnnotationTransactionAttributeSource的继承关系如下： AnnotationTransactionAttributeSource --AbstractFallbackTransactionAttributeSource --TransactionAttributeSource 通过方法org.springframework.transaction.interceptor.AbstractFallbackTransactionAttributeSource.getTransactionAttribute(Method, Class<?>) 解析出事务信息TransactionAttribute； AnnotationTransactionAttributeSource在方法findTransactionAttribute(Class<?>)中依赖于SpringTransactionAnnotationParser在解析事务类时， 绑定事务方法与增强器的时候进行@Transactional注解解析； */ @Bean @Role(BeanDefinition.ROLE_INFRASTRUCTURE) public TransactionAttributeSource transactionAttributeSource() { return new AnnotationTransactionAttributeSource(); } /** 被@Transactional标记的事务方法的拦截器，实际是一个MethodInterceptor 保存了事务属性信息，事务管理器； 在目标方法执行的时候；执行拦截器链； */ @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; }} |
在SpringTransactionAnnotationParser中parseTransactionAnnotation方法来解析@Transactional中的各个参数，其具体代码如下：
|
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
|
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")); ArrayList<RollbackRuleAttribute> rollBackRules = new ArrayList<RollbackRuleAttribute>(); Class<?>[] rbf = attributes.getClassArray("rollbackFor"); for (Class<?> rbRule : rbf) { RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule); rollBackRules.add(rule); } String[] rbfc = attributes.getStringArray("rollbackForClassName"); for (String rbRule : rbfc) { RollbackRuleAttribute rule = new RollbackRuleAttribute(rbRule); rollBackRules.add(rule); } Class<?>[] nrbf = attributes.getClassArray("noRollbackFor"); for (Class<?> rbRule : nrbf) { NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule); rollBackRules.add(rule); } String[] nrbfc = attributes.getStringArray("noRollbackForClassName"); for (String rbRule : nrbfc) { NoRollbackRuleAttribute rule = new NoRollbackRuleAttribute(rbRule); rollBackRules.add(rule); } rbta.getRollbackRules().addAll(rollBackRules); return rbta;} |
spring 事务 @EnableTransactionManagement原理
@EnableXXX原理：注解上有个XXXRegistrar，或通过XXXSelector引入XXXRegistrar，XXXRegistrar实现了ImportBeanDefinitionRegistrar的registerBeanDefinitions方法，给容器注册XXXCreator。
这个Creator实现了后置处理器，后置处理器在对象创建以后，包装对象，返回一个代理对象，代理对象执行方法利用拦截器链进行调用
1）、@EnableTransactionManagement
利用TransactionManagementConfigurationSelector给容器中会导入组件
导入两个组件
|
1
2
|
AutoProxyRegistrarProxyTransactionManagementConfiguration |
2）、AutoProxyRegistrar：
给容器中注册一个 InfrastructureAdvisorAutoProxyCreator 组件；
利用后置处理器机制在对象创建以后，包装对象，返回一个代理对象（增强器），代理对象执行方法利用拦截器链进行调用；
3）、ProxyTransactionManagementConfiguration是个@Configuration
1、给容器中注册事务增强器transactionAdvisor；
1）、事务增强器要用事务注解的信息，AnnotationTransactionAttributeSource解析事务注解
2）、事务拦截器transactionInterceptor：
TransactionInterceptor；保存了事务属性信息，事务管理器；
TransactionInterceptor是一个 MethodInterceptor；
在目标方法执行的时候；
执行拦截器链；
只有事务拦截器：
1）、先获取事务相关的属性
2）、再获取PlatformTransactionManager，如果事先没有添加指定任何transactionmanger 最终会从容器中按照类型获取一个PlatformTransactionManager；
3）、执行目标方法
如果异常，获取到事务管理器，利用事务管理回滚操作；
如果正常，利用事务管理器，提交事务
以上为个人经验，希望能给大家一个参考，也希望大家多多支持服务器之家。
原文链接：https://blog.csdn.net/luojinbai/article/details/87725112
