Spring 事务源码分析
1.分析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，如下表格，所以通过ImportSelector接口的selectImports()方法返回要注册到容器中的的组件。
| public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {} public abstract class AdviceModeImportSelector<A extends Annotation> implements ImportSelector {}
|
那么它注册了哪些组件那：
| protected String[] selectImports(AdviceMode adviceMode) { switch (adviceMode) { 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; } } |
我们从EnableTransactionManagement的AdviceMode mode() default AdviceMode.PROXY;中看出，注册两个组件AutoProxyRegistrar，ProxyTransactionManagementConfiguration。
①AutoProxyRegistrar，
向容器中注册了AutoProxyCreator即InfrastructureAdvisorAutoProxyCreator(增强自动代理创建器)这个组件。InfrastructureAdvisorAutoProxyCreator利用后置处理器机制，在对象创建以后，包装对象，返回代理对象。通过拦截器链对代理对象执行方法进行调用。
| public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar { public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { //只给出关键代码 Object proxyTargetClass = candidate.get("proxyTargetClass"); if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() && Boolean.class == proxyTargetClass.getClass()) { candidateFound = true; if (mode == AdviceMode.PROXY) {//默认值就是PROXY AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry); if ((Boolean) proxyTargetClass) {//默认值是false 看EnableTransactionManagement注解 AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry); return; } } } } } @Nullable public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) { return registerAutoProxyCreatorIfNecessary(registry, null); }
@Nullable public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable Object source) {
return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source); } |
②ProxyTransactionManagementConfiguration
给容器中注册事务增强器。在注册的时候需要事务属性
advisor.setTransactionAttributeSource(transactionAttributeSource());
同时也加入了事务拦截器advisor.setAdvice(transactionInterceptor());
| @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() { return new AnnotationTransactionAttributeSource(); } |
注册Spring注解解析器，jta事务注解解析器，Ejb事务注解解析器
| public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) { this.publicMethodsOnly = publicMethodsOnly; this.annotationParsers = new LinkedHashSet<>(2); this.annotationParsers.add(new SpringTransactionAnnotationParser()); if (jta12Present) { this.annotationParsers.add(new JtaTransactionAnnotationParser()); } if (ejb3Present) { this.annotationParsers.add(new Ejb3TransactionAnnotationParser()); } } |
spring事务注解解析器，会解析我们@Transactional中定义的属性
| public class SpringTransactionAnnotationParser implements TransactionAnnotationParser, Serializable { //只给出关键代码 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<>(); 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; } } |
另一方面添加了事务拦截器：创建了一个TransactionInterceptor，它保存了事务属性信息，事务管理器。
| @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; } |
它是一个方法拦截器，我们在容器中存放着代理对象，代理对象要执行方法法了，那么拦截器就会拦截进行工作。
| public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable { public Object invoke(final MethodInvocation invocation) throws Throwable { Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null); return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed); } } |
拦截到执行的方法，首先获得事务属性，然后获得事务处理器，根据事务配置判断是否创建事务，执行目标方法，若执行过程中出现异常，那么调用事务管理器回滚，否则调用事务管理器提交事务
| protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass, final InvocationCallback invocation) throws Throwable { //先获得事务属性 TransactionAttributeSource tas = getTransactionAttributeSource(); final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null); //然后获得事务管理器，默认从容器中获取bean类型为PlatformTransactionManager的事务管理器，若制定了事务管理器，那么就返回制定的事务管理器 final PlatformTransactionManager tm = determineTransactionManager(txAttr); final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);
if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) { //若有必要那么创建事务 TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification); Object retVal = null; //先执行目标方法 try { retVal = invocation.proceedWithInvocation(); } //若事务出现异常，那么txInfo.getTransactionManager().rollback(txInfo.getTransactionStatus());事务回滚 catch (Throwable ex) { completeTransactionAfterThrowing(txInfo, ex); throw ex; } finally { cleanupTransactionInfo(txInfo); } //若正常应用事务管理器提交事务 commitTransactionAfterReturning(txInfo); return retVal; //省略。。。。。。 } } |