Seata TCC源码了解

2019独角兽企业重金招聘Python工程师标准>>>

Seata事务

Seata中的Tcc模式需要服务的参与方在接口上增加@TwoPhaseBusinessAction注解，tcc接口名称需要全局唯一，tcc接口的confirm和cancel方法的名称用于后续aop拦截及框架反射调用。

例子：

public interface TccAction {
    @TwoPhaseBusinessAction(name = "yourTccActionName", commitMethod = "confirm", rollbackMethod = "cancel")
    public boolean try(BusinessActionContext businessActionContext, int a, int b);
    public boolean confirm(BusinessActionContext businessActionContext);
    public boolean cancel(BusinessActionContext businessActionContext);
}

接着需要定义实现类Impl实现这个接口，为三个方法提供具体实现。

服务启动之后会将参与方服务进行发布，注册到远端，seata框架会调用参与方的confirm或cancel方法，形成TCC闭环事务。

发起方

参与方需要在业务方法上增加@GlobalTransactional注解，用于开启切面注册全局事务，业务方法中调用TCC参与方的若干try方法，一旦业务调用成功，seata框架会通知TC回调参与方的confirm或cancel方法。

相关源码：

• 模块：seata-spring 类：GlobalTransactionalInterceptor.class 功能：全局事务切面逻辑，包括注册全局事务，拿到 xid
• 模块：seata-spring 类：TccActionInterceptor.class 功能：TCC 参与方切面逻辑
• 模块：seata-tcc 类：TCCResourceManager.class 功能：解析 TCC Bean，保存 TCC Resources，便于后续回调
• 模块：seata-tcc 类：ActionInterceptorHandler.class 功能：TCC 分支事务注册实现
• 模块：seata-server 类：DefaultCoordinator.class、FileTransactionStoreManager.class 功能：主要是 TC 的实现、事务存储等实现

注册Resource

public class TCCResource implements Resource {

    private String resourceGroupId = "DEFAULT";

    private String appName;

    private String actionName; // TCC 接口名称 

    private Object targetBean; // TCC Bean

    private Method prepareMethod; // try 方法

    private String commitMethodName;

    private Method commitMethod; // confirm 方法

    private String rollbackMethodName;

    private Method rollbackMethod; // cancel 方法

    // …… 省略
}

Seata 解析到应用中存在 TCC Bean，则通过 parserRemotingServiceInfo 方法生成一个 TCCResource 对象，进而调用 TCCResourceManager 类的 registerResource 方法，将 TCCResource 对象保存到本地的 tccResourceCache 中，它是一个 ConcurrentHashMap 结构，同时通过 RmRpcClient 将该 TCCResource 的 resourceId、address 等信息注册到服务端，便于后续 TC 通过 RPC 回调到正确的地址。

// 解析 TCCResource 的部分代码
Class interfaceClass = remotingBeanDesc.getInterfaceClass();
Method[] methods = interfaceClass.getMethods();
if(isService(bean, beanName)){
    try {
        // 如果是 TCC service Bean，解析并注册该 resource
        Object targetBean = remotingBeanDesc.getTargetBean();
        for(Method m : methods){
            TwoPhaseBusinessAction twoPhaseBusinessAction = m.getAnnotation(TwoPhaseBusinessAction.class);
            if(twoPhaseBusinessAction != null){
                // 如果有 TCC 参与方注解，定义一个 TCCResource，
                TCCResource tccResource = new TCCResource();
                tccResource.setActionName(twoPhaseBusinessAction.name());
                // TCC Bean
                tccResource.setTargetBean(targetBean); 
                // try 方法
                tccResource.setPrepareMethod(m); 
                // confirm 方法名称
                tccResource.setCommitMethodName(twoPhaseBusinessAction.commitMethod());
                // confirm 方法对象
                tccResource.setCommitMethod(ReflectionUtil.getMethod(interfaceClass, twoPhaseBusinessAction.commitMethod(), new Class[]{BusinessActionContext.class}));
                // cancel 方法名称
                tccResource.setRollbackMethodName(twoPhaseBusinessAction.rollbackMethod());
                // cancel 方法对象
                tccResource.setRollbackMethod(ReflectionUtil.getMethod(interfaceClass, twoPhaseBusinessAction.rollbackMethod(), new Class[]{BusinessActionContext.class}));
                // 调用到 TCCResourceManager 的 registerResource 方法
                DefaultResourceManager.get().registerResource(tccResource);
            }
        }
    }catch (Throwable t){
        throw new FrameworkException(t, "parser remting service error");
    }
}

TCCResourceManager 的 registerResource 方法的实现：

// 内存中保存的 resourceId 和 TCCResource 的映射关系
private Map tccResourceCache = new ConcurrentHashMap();

@Override
public void registerResource(Resource resource) {
    TCCResource tccResource = (TCCResource) resource;
    tccResourceCache.put(tccResource.getResourceId(), tccResource);
    // 调用父类的方法通过 RPC 注册到远端
    super.registerResource(tccResource);
}

TCCResource 是如何注册到服务端的：

public void registerResource(Resource resource) {
    // 拿到 RmRpcClient 实例，调用其 registerResource 方法
    RmRpcClient.getInstance().registerResource(resource.getResourceGroupId(), resource.getResourceId());
}

public void registerResource(String resourceGroupId, String resourceId) {
    if (LOGGER.isInfoEnabled()) {
        LOGGER.info("register to RM resourceId:" + resourceId);
    }
    synchronized (channels) {
        for (Map.Entry entry : channels.entrySet()) {
            String serverAddress = entry.getKey();
            Channel rmChannel = entry.getValue();
            if (LOGGER.isInfoEnabled()) {
                LOGGER.info("register resource, resourceId:" + resourceId);
            }
            // 注册 resourceId，远端将其解析为一个 RpcContext 保存在内存中
            sendRegisterMessage(serverAddress, rmChannel, resourceId);
        }
    }
}

注册全局事务

GlobalTransaction 注解是全局事务的入口，其切面逻辑实现在 GlobalTransactionalInterceptor 类中。如果判断进入 @GlobalTransaction 修饰的方法，会调用 handleGlobalTransaction 方法进入切面逻辑，其中关键方法是 transactionalTemplate 的 execute 方法。

public Object execute(TransactionalExecutor business) throws Throwable {
    
    // 如果上游已经有 xid 传过来说明自己是下游，直接参与到这个全局事务中就可以，不必新开一个，角色是 Participant
    // 如果上游没有 xid 传递过来，说明自己是发起方，新开启一个全局事务，角色是 Launcher
    GlobalTransaction tx = GlobalTransactionContext.getCurrentOrCreate();

    // …… …… 省略 

    try {

        // 开启全局事务
        beginTransaction(txInfo, tx);

        Object rs = null;
        try {

            // 调用业务方法
            rs = business.execute();

        } catch (Throwable ex) {

            // 如果抛异常，通知 TC 回滚全局事务
            completeTransactionAfterThrowing(txInfo,tx,ex);
            throw ex;
        }

        // 如果不抛异常，通知 TC 提交全局事务
        commitTransaction(tx);

        return rs;
    } 

    // …… …… 省略
}

beginTransaction 方法调用了 transactionManager 的 begin 方法：

// 客户端
@Override
public String begin(String applicationId, String transactionServiceGroup, String name, int timeout)
    throws TransactionException {
    GlobalBeginRequest request = new GlobalBeginRequest();
    request.setTransactionName(name);
    request.setTimeout(timeout);
    // 发送 RPC，获取 TC 下发的 xid
    GlobalBeginResponse response = (GlobalBeginResponse)syncCall(request);
    return response.getXid();
}

// 服务端
@Override
public String begin(String applicationId, String transactionServiceGroup, String name, int timeout)
    throws TransactionException {
    // 全局事务用 GlobalSession 来表示
    GlobalSession session = GlobalSession.createGlobalSession(
        applicationId, transactionServiceGroup, name, timeout);
    session.addSessionLifecycleListener(SessionHolder.getRootSessionManager());
    // 将 GlobalSession 写入文件存储
    session.begin();
    // 返回 UUID 作为全局事务 ID
    return XID.generateXID(session.getTransactionId());
}

TwoPhaseBusinessAction 注册分支事务

全局事务调用业务方法时，会进入 TCC 参与方的切面逻辑，主要实现在 TccActionInterceptor 类中，关键方法是 actionInterceptorHandler 的 proceed方法。

public Map proceed(Method method, Object[] arguments, TwoPhaseBusinessAction businessAction, Callback