spring cloud seata 使用说明

---

spring cloud seata 使用说明

 

*****************************

自动配置类

 

SeataAutoConfiguration

@ComponentScan(basePackages = {"io.seata.spring.boot.autoconfigure.properties"})
@ConditionalOnProperty(
    prefix = "seata",
    name = {"enabled"},
    havingValue = "true",
    matchIfMissing = true
)
@Configuration
@EnableConfigurationProperties({SeataProperties.class})
public class SeataAutoConfiguration {
    private static final Logger LOGGER = LoggerFactory.getLogger(SeataAutoConfiguration.class);
    @Autowired
    private SeataProperties seataProperties;

    public SeataAutoConfiguration() {
    }

    @Bean
    public SpringUtils springUtils() {
        return new SpringUtils();
    }

    @Bean
    @DependsOn({"springUtils"})
    @ConditionalOnMissingBean({GlobalTransactionScanner.class})
    public GlobalTransactionScanner globalTransactionScanner() {
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Automatically configure Seata");
        }

        return new GlobalTransactionScanner(this.seataProperties.getApplicationId(), this.seataProperties.getTxServiceGroup());
    }
}

 

SeataProperties：seata配置属性

@Component
@ConfigurationProperties(prefix = "seata")
@EnableConfigurationProperties({SpringCloudAlibabaConfiguration.class})
public class SeataProperties {
    private boolean enabled = true;
    private String applicationId;
    private String txServiceGroup;
    @Autowired
    private SpringCloudAlibabaConfiguration springCloudAlibabaConfiguration;

    public SeataProperties() {
    }

    public boolean isEnabled() {
        return this.enabled;
    }

    public SeataProperties setEnabled(boolean enabled) {
        this.enabled = enabled;
        return this;
    }

    public String getApplicationId() {
        if (null == this.applicationId) {
            this.applicationId = this.springCloudAlibabaConfiguration.getApplicationId();
        }//如果没有设置，默认去springCloudAlibanaConfiguration中的applicationId值

        return this.applicationId;
    }

    public SeataProperties setApplicationId(String applicationId) {
        this.applicationId = applicationId;
        return this;
    }

    public String getTxServiceGroup() {
        if (null == this.txServiceGroup) {
            this.txServiceGroup = this.springCloudAlibabaConfiguration.getTxServiceGroup();
        }//如果没有设置，默认去springCloudAlibanaConfiguration中的txServiceGroup值

        return this.txServiceGroup;
    }

    public SeataProperties setTxServiceGroup(String txServiceGroup) {
        this.txServiceGroup = txServiceGroup;
        return this;
    }
}

 

SpringCloudAlibabaConfiguration：配置applicationId、txServiceGroup属性

@ConfigurationProperties(prefix = "spring.cloud.alibaba.seata")
public class SpringCloudAlibabaConfiguration implements ApplicationContextAware {
    private static final Logger LOGGER = LoggerFactory.getLogger(SpringCloudAlibabaConfiguration.class);
    private static final String SPRING_APPLICATION_NAME_KEY = "spring.application.name";
    private static final String DEFAULT_SPRING_CLOUD_SERVICE_GROUP_POSTFIX = "-seata-service-group";
    private String applicationId;
    private String txServiceGroup;
    private ApplicationContext applicationContext;

    public SpringCloudAlibabaConfiguration() {
    }

    public String getApplicationId() {
        if (null == this.applicationId) {
            this.applicationId = this.applicationContext.getEnvironment().getProperty("spring.application.name");
        }//如果没有设置，默认为spring.application.name的值

        return this.applicationId;
    }

    public String getTxServiceGroup() {
        if (null == this.txServiceGroup) {
            String applicationId = this.getApplicationId();
            if (null == applicationId) {
                LOGGER.warn("{} is null, please set its value", "spring.application.name");
            }

            this.txServiceGroup = applicationId + "-seata-service-group";
        }//如果没有设置，默认为spring.application.name的值+"-seata=service-group"

        return this.txServiceGroup;
    }

    public void setTxServiceGroup(String txServiceGroup) {
        this.txServiceGroup = txServiceGroup;
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

 

GlobalTransactionScanner：全局事务扫描

public class GlobalTransactionScanner extends AbstractAutoProxyCreator implements InitializingBean, ApplicationContextAware, DisposableBean {
    private static final long serialVersionUID = 1L;
    private static final Logger LOGGER = LoggerFactory.getLogger(GlobalTransactionScanner.class);
    private static final int AT_MODE = 1;
    private static final int MT_MODE = 2;
    private static final int ORDER_NUM = 1024;
    private static final int DEFAULT_MODE = 3;
    private static final Set PROXYED_SET = new HashSet();
    private static final FailureHandler DEFAULT_FAIL_HANDLER = new DefaultFailureHandlerImpl();
    private MethodInterceptor interceptor;
    private final String applicationId;
    private final String txServiceGroup;
    private final int mode;
    private final boolean disableGlobalTransaction;
    private final FailureHandler failureHandlerHook;
    private ApplicationContext applicationContext;

    public GlobalTransactionScanner(String txServiceGroup) {
        this(txServiceGroup, txServiceGroup, 3);
    }

    public GlobalTransactionScanner(String txServiceGroup, int mode) {
        this(txServiceGroup, txServiceGroup, mode);
    }

    public GlobalTransactionScanner(String applicationId, String txServiceGroup) {
        this(applicationId, txServiceGroup, 3);
    }

    public GlobalTransactionScanner(String applicationId, String txServiceGroup, int mode) {
        this(applicationId, txServiceGroup, mode, DEFAULT_FAIL_HANDLER);
    }

    public GlobalTransactionScanner(String applicationId, String txServiceGroup, FailureHandler failureHandlerHook) {
        this(applicationId, txServiceGroup, 3, failureHandlerHook);
    }

    public GlobalTransactionScanner(String applicationId, String txServiceGroup, int mode, FailureHandler failureHandlerHook) {
        this.disableGlobalTransaction = ConfigurationFactory.getInstance().getBoolean("service.disableGlobalTransaction", false);
        this.setOrder(1024);
        this.setProxyTargetClass(true);
        this.applicationId = applicationId;
        this.txServiceGroup = txServiceGroup;
        this.mode = mode;
        this.failureHandlerHook = failureHandlerHook;
    }

    public void destroy() {
        ShutdownHook.getInstance().destroyAll();
    }

    private void initClient() {
        if (LOGGER.isInfoEnabled()) {
            LOGGER.info("Initializing Global Transaction Clients ... ");
        }

        if (!StringUtils.isNullOrEmpty(this.applicationId) && !StringUtils.isNullOrEmpty(this.txServiceGroup)) {
            TMClient.init(this.applicationId, this.txServiceGroup); 
                     //初始化事务管理器transaction manager

            if (LOGGER.isInfoEnabled()) {
                LOGGER.info("Transaction Manager Client is initialized. applicationId[" + this.applicationId + "] txServiceGroup[" + this.txServiceGroup + "]");
            }

            RMClient.init(this.applicationId, this.txServiceGroup); 
                     //初始化资源管理器resource manager

            if (LOGGER.isInfoEnabled()) {
                LOGGER.info("Resource Manager is initialized. applicationId[" + this.applicationId + "] txServiceGroup[" + this.txServiceGroup + "]");
            }

            if (LOGGER.isInfoEnabled()) {
                LOGGER.info("Global Transaction Clients are initialized. ");
            }

            this.registerSpringShutdownHook(); //注册shutDownHook，关机前释放相关资源
        } else {
            throw new IllegalArgumentException("applicationId: " + this.applicationId + ", txServiceGroup: " + this.txServiceGroup);
        }
    }

    private void registerSpringShutdownHook() { 
        if (this.applicationContext instanceof ConfigurableApplicationContext) {
            ((ConfigurableApplicationContext)this.applicationContext).registerShutdownHook();
            ShutdownHook.removeRuntimeShutdownHook();
        }

        ShutdownHook.getInstance().addDisposable(TmRpcClient.getInstance(this.applicationId, this.txServiceGroup));
                                   //关机前释放事务管理器transaction manager
        ShutdownHook.getInstance().addDisposable(RmRpcClient.getInstance(this.applicationId, this.txServiceGroup));
                                   //关机前释放资源管理器resource manager
    }

    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
                                    //创建代理对象

        if (this.disableGlobalTransaction) { 
            return bean;              //如果禁止全局事务，直接返回bean
        } else {
            try {
                synchronized(PROXYED_SET) {
                    if (PROXYED_SET.contains(beanName)) {
                        return bean;  //如果已经创建beanName的代理对象，直接返回bean
                    } else {
                        this.interceptor = null;
                        if (TCCBeanParserUtils.isTccAutoProxy(bean, beanName, this.applicationContext)) {
                            this.interceptor = new TccActionInterceptor(TCCBeanParserUtils.getRemotingDesc(beanName));
                                      //tcc模式，拦截器为TccActionInterceptor
                        } else {
                            Class serviceInterface = SpringProxyUtils.findTargetClass(bean);
                            Class[] interfacesIfJdk = SpringProxyUtils.findInterfaces(bean);
                            if (!this.existsAnnotation(new Class[]{serviceInterface}) && !this.existsAnnotation(interfacesIfJdk)) {
                                return bean;
                            }

                            if (this.interceptor == null) {
                                this.interceptor = new GlobalTransactionalInterceptor(this.failureHandlerHook);
                                     //at模式，拦截器为GlobalTransactionalInterceptor
                                ConfigurationFactory.getInstance().addConfigListener("service.disableGlobalTransaction", (ConfigurationChangeListener)this.interceptor);
                            }
                        }

                        LOGGER.info("Bean[" + bean.getClass().getName() + "] with name [" + beanName + "] would use interceptor [" + this.interceptor.getClass().getName() + "]");
                        if (!AopUtils.isAopProxy(bean)) {
                            bean = super.wrapIfNecessary(bean, beanName, cacheKey);
                        } else {
                            AdvisedSupport advised = SpringProxyUtils.getAdvisedSupport(bean);
                            Advisor[] advisor = this.buildAdvisors(beanName, this.getAdvicesAndAdvisorsForBean((Class)null, (String)null, (TargetSource)null));
                            Advisor[] var7 = advisor;
                            int var8 = advisor.length;

                            for(int var9 = 0; var9 < var8; ++var9) {
                                Advisor avr = var7[var9];
                                advised.addAdvisor(0, avr);
                            }
                        }

                        PROXYED_SET.add(beanName);
                        return bean;
                    }
                }
            } catch (Exception var13) {
                throw new RuntimeException(var13);
            }
        }
    }

    private boolean existsAnnotation(Class[] classes) {//判断是否含有注解
        if (classes != null && classes.length > 0) {
            Class[] var2 = classes;
            int var3 = classes.length;

            for(int var4 = 0; var4 < var3; ++var4) {
                Class clazz = var2[var4];
                if (clazz != null) {
                    Method[] methods = clazz.getMethods();
                    Method[] var7 = methods;
                    int var8 = methods.length;

                    for(int var9 = 0; var9 < var8; ++var9) {
                        Method method = var7[var9];
                        GlobalTransactional trxAnno = (GlobalTransactional)method.getAnnotation(GlobalTransactional.class);
                        if (trxAnno != null) {
                            return true;
                        }//如果方法上标注注解@GlobalTransactional，返回true

                        GlobalLock lockAnno = (GlobalLock)method.getAnnotation(GlobalLock.class);
                        if (lockAnno != null) {
                            return true;
                        }//如果方法上标注注解@GlobalLock，返回true
                    }
                }
            }
        }

        return false;
    }//方法上没有注解@GlobalTransactional、@GlobalLock，返回false

    private MethodDesc makeMethodDesc(GlobalTransactional anno, Method method) {
        return new MethodDesc(anno, method);
    }

    protected Object[] getAdvicesAndAdvisorsForBean(Class beanClass, String beanName, TargetSource customTargetSource) throws BeansException {
        return new Object[]{this.interceptor};
    }

    public void afterPropertiesSet() {
        if (this.disableGlobalTransaction) {
            if (LOGGER.isInfoEnabled()) {
                LOGGER.info("Global transaction is disabled.");
            }

        } else {
            this.initClient();
        }
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
        this.setBeanFactory(applicationContext);
    }

    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        if (bean instanceof DataSourceProxy && ConfigurationFactory.getInstance().getBoolean("client.support.spring.datasource.autoproxy", false)) {
            throw new ShouldNeverHappenException("Auto proxy of DataSource can't be enabled as you've created a DataSourceProxy bean.Please consider removing DataSourceProxy bean or disabling auto proxy of DataSource.");
        } else {
            return super.postProcessBeforeInitialization(bean, beanName);
        }
    }

    public Object postProcessAfterInitialization(final Object bean, String beanName) throws BeansException {
        if (bean instanceof DataSource && !(bean instanceof DataSourceProxy) && ConfigurationFactory.getInstance().getBoolean("client.support.spring.datasource.autoproxy", false)) {
            if (LOGGER.isInfoEnabled()) {
                LOGGER.info("Auto proxy of [{}]", beanName);
            }

            final DataSourceProxy dataSourceProxy = DataSourceProxyHolder.get().putDataSource((DataSource)bean);
            Class[] interfaces = SpringProxyUtils.getAllInterfaces(bean);
            return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), interfaces, new InvocationHandler() {
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    Method m = BeanUtils.findDeclaredMethod(DataSourceProxy.class, method.getName(), method.getParameterTypes());
                    if (null != m) {
                        return m.invoke(dataSourceProxy, args);
                    } else {
                        boolean oldAccessible = method.isAccessible();

                        Object var6;
                        try {
                            method.setAccessible(true);
                            var6 = method.invoke(bean, args);
                        } finally {
                            method.setAccessible(oldAccessible);
                        }

                        return var6;
                    }
                }
            });
        } else {
            return super.postProcessAfterInitialization(bean, beanName);
        }
    }
}

 

TccActionInterceptor：tcc模式拦截器

public class TccActionInterceptor implements MethodInterceptor {
    private static final Logger LOGGER = LoggerFactory.getLogger(TccActionInterceptor.class);
    private ActionInterceptorHandler actionInterceptorHandler = new ActionInterceptorHandler();
    protected RemotingDesc remotingDesc;

    public TccActionInterceptor() {
    }

    public TccActionInterceptor(RemotingDesc remotingDesc) {
        this.remotingDesc = remotingDesc;
    }

    public Object invoke(MethodInvocation invocation) throws Throwable {
        if (!RootContext.inGlobalTransaction()) {
            return invocation.proceed();  //如果没有开启全局事务，不做处理继续执行
        } else {
            Method method = this.getActionInterfaceMethod(invocation);
                                          //获取原始方法
            TwoPhaseBusinessAction businessAction = (TwoPhaseBusinessAction)method.getAnnotation(TwoPhaseBusinessAction.class);
                                          //获取标注了注解TwoPhaseBusinessAction的两阶段操作
            if (businessAction != null) {
                String xid = RootContext.getXID();
                RootContext.unbind();
                RootContext.bindInterceptorType(xid, BranchType.TCC);

                Object var7;
                try {
                    Object[] methodArgs = invocation.getArguments();
                    ActionInterceptorHandler var10000 = this.actionInterceptorHandler;
                    invocation.getClass();
                    Map ret = var10000.proceed(method, methodArgs, xid, businessAction, invocation::proceed);
                                         //执行相关操作，actionInterceptorHandler的proceed()方法

                    var7 = ret.get("result");
                } finally {
                    RootContext.unbindInterceptorType();
                    RootContext.bind(xid);
                }

                return var7;
            } else {
                return invocation.proceed();
            }
        }
    }

    protected Method getActionInterfaceMethod(MethodInvocation invocation) {
    protected Class getProxyInterface(Object proxyBean) throws Exception {

 

GlobalTransactionalInterceptor：at模式拦截器

public class GlobalTransactionalInterceptor implements ConfigurationChangeListener, MethodInterceptor {
    private static final Logger LOGGER = LoggerFactory.getLogger(GlobalTransactionalInterceptor.class);
    private static final FailureHandler DEFAULT_FAIL_HANDLER = new DefaultFailureHandlerImpl();
    private final TransactionalTemplate transactionalTemplate = new TransactionalTemplate();
    private final GlobalLockTemplate