14-Spring事务原理

2021-02-28 18:32:00 阅读：240 来源： 互联网

标签：事务 14 Spring targetClass invocation interceptor null public

@EnableTransactionManagement 利用TransactionManagementConfigurationSelector 往容器中注入了两个类
AutoProxyRegistrar、ProxyTransactionManagementConfiguration
AutoProxyRegistrar 往容器中注入了 InfrastructureAdvisorAutoProxyCreator
InfrastructureAdvisorAutoProxyCreator 也是利用后置处理器机制，在对象创建后，然后包装对象返回一个代理对象
查看它的父类，发现跟实现AOP的方式是类似的，都是根据一些规则找到对应的增强器，然后封装成MethodInterceptor，当对象调用目标方法时，动态代理机制就会链式调用这些拦截器。
```
 InfrastructureAdvisorAutoProxyCreator
 extends AbstractAdvisorAutoProxyCreator
     extends AbstractAutoProxyCreator
         extends ProxyProcessorSupport implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware
```
ProxyTransactionManagementConfiguration类信息如下

@Configuration
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
    public ProxyTransactionManagementConfiguration() {
    }

    @Bean(
        name = {"org.springframework.transaction.config.internalTransactionAdvisor"}
    )
  	// 给容器中增加了事务增强器
    @Role(2)
    public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
        BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
        advisor.setTransactionAttributeSource(this.transactionAttributeSource());
        advisor.setAdvice(this.transactionInterceptor());
        if (this.enableTx != null) {
            advisor.setOrder((Integer)this.enableTx.getNumber("order"));
        }

        return advisor;
    }

    // 事务注解解析器
    @Bean
    @Role(2)
    public TransactionAttributeSource transactionAttributeSource() {
        return new AnnotationTransactionAttributeSource();
    }

    // 事务拦截器, 它继承了 MethodInterceptor
  	// 因此在收集增强器的时候，这个也会被收集进去
    @Bean
    @Role(2)
    public TransactionInterceptor transactionInterceptor() {
        TransactionInterceptor interceptor = new TransactionInterceptor();
        interceptor.setTransactionAttributeSource(this.transactionAttributeSource());
        if (this.txManager != null) {
            interceptor.setTransactionManager(this.txManager);
        }

        return interceptor;
    }
}

下面主要查看TransactionInterceptor#invoke方法

public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor, Serializable {
    @Override
    @Nullable
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // 获取目标类
        Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
        // Adapt to TransactionAspectSupport's invokeWithinTransaction...
        return invokeWithinTransaction(invocation.getMethod(), targetClass, invocation::proceed);
    }
}

public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean {
    @Nullable
    protected Object invokeWithinTransaction(Method method, @Nullable Class<?> targetClass,
                                             final InvocationCallback invocation) throws Throwable {

        // 1. 获取事务注解解析器
        TransactionAttributeSource tas = getTransactionAttributeSource();
        // 2. 获取事务相关属性
        final TransactionAttribute txAttr = (tas != null ? tas.getTransactionAttribute(method, targetClass) : null);
        // 3. 获取 PlatformTransactionManager
        final PlatformTransactionManager tm = determineTransactionManager(txAttr);
        final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

        if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
            // Standard transaction demarcation with getTransaction and commit/rollback calls.
            // 创建一个事务信息对象
            TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
            Object retVal = null;
            try {
                // This is an around advice: Invoke the next interceptor in the chain.
                // This will normally result in a target object being invoked.
                // 4. 这里开始执行目标方法
                retVal = invocation.proceedWithInvocation();
            }
            catch (Throwable ex) {
                // target invocation exception
                // 5. 如果目标方法抛出异常，获取事务管理器，利用事务管理器进行回滚
                completeTransactionAfterThrowing(txInfo, ex);
                throw ex;
            }
            finally {
                cleanupTransactionInfo(txInfo);
            }
            // 6. 如果执行正常，则拿到事务管理器，提交事务
            commitTransactionAfterReturning(txInfo);
            return retVal;
        } else {
            // 省略......
        }
    }
}

标签：事务,14,Spring,targetClass,invocation,interceptor,null,public
来源： https://blog.csdn.net/lizc_lizc/article/details/114234444

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

14-Spring事务原理