二TCC-transaction分布式事务关键组件--1Participant参与者、TransactionManager事务管理器

二 TCC-transaction分布式事务关键组件--1Participant参与者、TransactionManager事务管理器

二 TCC-transaction关键组件类及原理

2.1 框架原理

2.1.1 基本使用

在一个模块配置Tcc-transaction并使用，需要执行如下操作：

1.1 生效tcc-transaction

在spring项目中可以使用xml配置或者注解来生效tcc-transaction。

a. XML配置

    <tcc:annotation-driven transaction-repository="transactionRepository"/>

b. 注解配置

    @EnableTccTransaction

1.2 配置transaction repository

transaction repository用来保存事务日志，框架提供多种Transaction Repository：

 在tcc-transaction-dubbo-sample中使用MemoryStoreTransactionRepository(没有持久化能力，仅可用于测试）：
 
    <bean id="transactionRepository" class="org.mengyun.tcctransaction.repository.MemoryStoreTransactionRepository">
        <property name="domain" value="TCC:DUBBO:CAPITAL:"/>
    </bean>

1.3 声明tcc接口

在接口方法上加上@EnableTcc(1.7.x新增注解，1.6.x是@Compensable）将提供的接口标记为tcc接口:

     public interface CapitalTradeOrderService {
        @EnableTcc
        public String record(CapitalTradeOrderDto tradeOrderDto);
 
    }

1.4 配置TCC事务的Try、Confirm、Cancel方法：

在tcc接口实现上方法上添加@Compensable注解，设置confirmMethod和cancelMethod方法，分别为tcc的confirm和cancel方法。

    @Override
    @Compensable(confirmMethod = "confirmRecord", cancelMethod = "cancelRecord", transactionContextEditor = DubboTransactionContextEditor.class)
    @Transactional
    public String record(CapitalTradeOrderDto tradeOrderDto) {
        ...
    }

在 TCC 里，一个业务活动可以有多个事务，每个业务操作归属于不同的事务，即一个事务可以包含多个业务操作。TCC-Transaction 将每个业务操作抽象成事务参与者，每个事务可以包含多个参与者。

参与者需要声明 try / confirm / cancel 三个类型的方法，和 TCC 的操作一一对应。在程序里，通过 @Compensable 注解标记在 try 方法上，并填写对应的 confirm / cancel 方法，示例代码如下：

// try
@Compensable(confirmMethod = "confirmRecord", cancelMethod = "cancelRecord", transactionContextEditor = MethodTransactionContextEditor.class)
public String record(TransactionContext transactionContext, CapitalTradeOrderDto tradeOrderDto) {}
 
// confirm
public void confirmRecord(TransactionContext transactionContext, CapitalTradeOrderDto tradeOrderDto) {}
 
// cancel
public void cancelRecord(TransactionContext transactionContext, CapitalTradeOrderDto tradeOrderDto) {}

try阶段是由业务方发起调用，而confirm和cancel由事务管理器自动调用。在这里，事务管理器就是CompensableTransactionInterceptor(通过组合的方式，里面含有的TransactionManager才是真正的事务管理器，TransactionManager的方法会被调用），confirm和cancel方法由它自动调用。

主要通过spring-aop拦截器CompensableTransactionInterceptor、ResourceCoordinatorInterceptor
CompensableTransactionInterceptor : 用于tcc事务的流程执行begin（try)、commit(confirm)、rollback(cancel)
ResourceCoordinatorInterceptor : 用于记录tcc事务的Participant（参与方）

2.1.2 框架基本流程

2.2 核心组件类

针对TCC-Transaction框架中涉及的关键组件，按照如图所示的模块，首先对各个关键组件进行分析：

2.2.1 事务参与者Participant与事务Transaction

关系如图：

TCC将事务和事务参与者，抽象为两个类Transaction和Participant。

一个transaction可以有多个participant参与者
Transaction---{participant1;participant2;participant3......}
 
Transaction{
  List<Participant> participants //事务对象中，用list保存当前事务的参与者
    commit（）/rollback() ;//事务提供的方法，通过for循环，遍历list中每个participant.commit/rollback方法实现方法提交、回滚
}
 
Participant{
  transactionXid ;//当前事务的全局id
  confirm/cancelInvocationContext;//confirm或者cancel方法调用上下文（包含调用的所有信息）
  Terminator ;// commit/rollback通过Terminator对象，完成方法的调用
  TransactionContextEditorClass;//transactionContext事务上下文的编辑类，可以通过该类修改和获取事务上下文
  
  //事务的提交与回滚，通过Terminator调用
  commit/rollback{
    Terminator.invoke(new TransactionContext,new Invocation,transactionContextEditorClass);
  }
  
}

1 Transaction事务

关注核心的属性和方法

//事务对象需要持久存储，所以需要其实现序列化Serializable
public class Transaction implements Serializable {
 
    private List<Participant> participants = new ArrayList<>(); //事务的参与者participants列表
    private Map<String, Object> attachments = new ConcurrentHashMap<>(); //附加属性
    private Date createTime = new Date();
    private Xid xid; //事务编号，唯一地标识一个事务，UUID算法生成
    private Xid rootXid;
    private String rootDomain;
    private TransactionType transactionType; //事务类型（包含ROOT根事务、BRANCH分支事务），表示当前事务时发起者还是参与者
    private TransactionStatus status;//事务状态（包含trying、confirming、cancelling），表示当前事务在tcc执行的阶段
    private Date lastUpdateTime = new Date(); 
    private volatile int retriedCount = 0;//重试次数
    private long version = 0L; //版本号，用于乐观锁更新事务
 
    public Transaction() {
    }
 
  //该构造函数，创建trying阶段的分支branch事务
    public Transaction(TransactionContext transactionContext) {
        this.xid = transactionContext.getXid();
        this.rootXid = transactionContext.getRootXid();
        this.rootDomain = transactionContext.getRootDomain();
        this.status = TransactionStatus.TRYING;
        this.transactionType = TransactionType.BRANCH;
    }
 
  //该构造函数，创建trying阶段的root事务
    public Transaction(Object uniqueIdentity, String rootDomain) {
 
        this.xid = TransactionXid.withUniqueIdentity(uniqueIdentity);
        this.status = TransactionStatus.TRYING;
        this.transactionType = TransactionType.ROOT;
        this.rootXid = xid;
        this.rootDomain = rootDomain;
    }
  
  //commit使用fori循环，调用每个参与者participant.commit
      public void commit() {
        for (Participant participant : participants) {
            if (!participant.getStatus().equals(ParticipantStatus.CONFIRM_SUCCESS)) {
              
                participant.commit();
              //commit提交成功后，修改参与者的状态
                participant.setStatus(ParticipantStatus.CONFIRM_SUCCESS);
            }
        }
    }
 
    public void rollback() {
        for (Participant participant : participants) {
            if (!participant.getStatus().equals(ParticipantStatus.CANCEL_SUCCESS)) {
                participant.rollback();
                participant.setStatus(ParticipantStatus.CANCEL_SUCCESS);
            }
        }
    }
  
  //添加事务参与者
    public void enlistParticipant(Participant participant) {
        participants.add(participant);
    }

(1)TransactionXid

其中，TransactionXid使用uuid算法生成全局唯一的事务id：

   public static TransactionXid withUniqueIdentity(Object uniqueIdentity) {
        int formatId = Xid.AUTO;
        String xid = null;
        if (uniqueIdentity == null) {
            xid = FactoryBuilder.factoryOf(UUIDGenerator.class).getInstance().generate();
        } else {
            xid = uniqueIdentity.toString();
            formatId = Xid.CUSTOMIZED;
        }
        return new TransactionXid(formatId, xid);
    }

(2)TransactionStatus

public enum TransactionStatus {
 
    TRYING(1), CONFIRMING(2), CANCELLING(3), TRY_SUCCESS(11), TRY_FAILED(12);
 

(3)TransactionType

public enum TransactionType {
 
    ROOT(1),
    BRANCH(2);

2 Participant事务参与者

public class Participant implements Serializable {
 
    Class<? extends TransactionContextEditor> transactionContextEditorClass; //事务上下文编辑器类
 
    private Xid rootXid;
    private String rootDomain;
 
    private Xid xid; //事务id
    private InvocationContext invocationContext;
    private ParticipantStatus status = ParticipantStatus.TRYING; //参与者状态
 
    public Participant() {
 
    }
 
    public void rollback() {
      //利用执行器调用对应的rollback方法
        Terminator.invoke(new TransactionContext(rootDomain, rootXid, xid, TransactionStatus.CANCELLING, status), new Invocation(invocationContext.getCancelMethodName(), invocationContext), transactionContextEditorClass);
    }
 
    public void commit() {
        Terminator.invoke(new TransactionContext(rootDomain, rootXid, xid, TransactionStatus.CONFIRMING, status), new Invocation(invocationContext.getConfirmMethodName(), invocationContext), transactionContextEditorClass);
    }

participant的xid事务id，通过该id关联上其所属的事务。同一个事务下的事务id相同，通过同id执行tcc的参与者的操作。

(1)ParticipantStatus

参与者的状态，标识当前事务参与者，在tcc执行过程中，所处于TCC阶段的状态

public enum ParticipantStatus {
    TRYING(1), CONFIRMING(2), CANCELLING(3), TRY_SUCCESS(11), TRY_FAILED(12), CONFIRM_SUCCESS(21), CANCEL_SUCCESS(31);
    private int id;

(2) TransactionContext事务上下文

public class TransactionContext implements Serializable {
 
    private static final long serialVersionUID = -8199390103169700387L;
    private Xid xid;
    private Xid rootXid;
    private String rootDomain;
 
    private TransactionStatus status = TransactionStatus.TRYING;
    private ParticipantStatus participantStatus = ParticipantStatus.TRYING;
    private Map<String, String> attachments = new ConcurrentHashMap<>();

(3) InvocationContext调用上下文

调用上下文，包含了当前调用的所有信息，包括目标类、参数类型、confirm和cancel方法名称

public class InvocationContext implements Serializable {
 
    private static final long serialVersionUID = -7969140711432461165L;
 
    private Class targetClass;
    private String confirmMethodName;
    private String cancelMethodName;
    private Class[] parameterTypes;
    private Object[] args;

(4)Invocation

调用，包括调用的方法名和InvocationContext

public class Invocation {
    private String methodName;
 
    private InvocationContext invocationContext;
 
    public Invocation(String methodName, InvocationContext invocationContext) {
        this.methodName = methodName;
        this.invocationContext = invocationContext;
    }

(5)Terminator执行器

public final class Terminator {
 
    public static Object invoke(TransactionContext transactionContext, Invocation invocation, Class<? extends TransactionContextEditor> transactionContextEditorClass) {
 
      //当invocation中方法名不为空，即有实际的调用方法时
        if (StringUtils.isNotEmpty(invocation.getMethodName())) {
 
          //参与者对象类
            Object target = FactoryBuilder.factoryOf(invocation.getTargetClass()).getInstance();
 
            Method method = null;
 
            try {
              //参与者需要执行的方法（try/confirm/cancel)
                method = target.getClass().getMethod(invocation.getMethodName(), invocation.getParameterTypes());
            } catch (NoSuchMethodException e) {
                throw new SystemException(e);
            }
 
          //设置事务上下文transactionContext到transactionContextEditorClass上
            FactoryBuilder.factoryOf(transactionContextEditorClass).getInstance().set(transactionContext, target, method, invocation.getArgs());
            try {
              //反射调用
                return method.invoke(target, invocation.getArgs());
            } catch (IllegalAccessException | InvocationTargetException e) {
                throw new SystemException(e);
            } finally {
                FactoryBuilder.factoryOf(transactionContextEditorClass).getInstance().clear(transactionContext, target, method, invocation.getArgs());
            }
        }
        return null;
    }

(6)TransactionContextEditor事务上下文编辑器

在TCC2.0版本以后，只有这个默认实现类，用threadLocal保存事务上下文对象。

public class ThreadLocalTransactionContextEditor implements TransactionContextEditor {
 
    @Override
    public TransactionContext get(Object target, Method method, Object[] args) {
        return TransactionContextHolder.getCurrentTransactionContext();
    }
 
    @Override
    public void set(TransactionContext transactionContext, Object target, Method method, Object[] args) {
        TransactionContextHolder.setCurrentTransactionContext(transactionContext);
    }
 
    public void clear(TransactionContext transactionContext, Object target, Method method, Object[] args) {
        TransactionContextHolder.clear();
    }
}

public class TransactionContextHolder {
		//创建当前线程变量ThreadLocal，保存事务上下文
    private static ThreadLocal<TransactionContext> transactionContextThreadLocal = new ThreadLocal<>();
 
    private TransactionContextHolder() {
    }
 
    public static TransactionContext getCurrentTransactionContext() {
        return transactionContextThreadLocal.get();
    }
 
    public static void setCurrentTransactionContext(TransactionContext transactionContext) {
        transactionContextThreadLocal.set(transactionContext);
    }
 
    public static void clear() {
        transactionContextThreadLocal.remove();
    }
}

可知，TransactionContextEditor是将事务上下文保存在本地线程对象ThreadLocal中。

2.2.2 事务管理器TransactionManager

事务管理器类，主要提供事务的begin、commit、rollback和获取事务、participant的新增管理

public class TransactionManager {
  
  private static final ThreadLocal<Deque<Transaction>> CURRENT = new ThreadLocal<>();
 
    private int threadPoolSize = Runtime.getRuntime().availableProcessors() * 2 + 1;
    private int threadQueueSize = 1024;
 
  //TCC提供的异步执行Terminator线程池
    private ExecutorService asyncTerminatorExecutorService = new ThreadPoolExecutor(threadPoolSize,
            threadPoolSize,
            0L,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(threadQueueSize), new ThreadPoolExecutor.AbortPolicy());
    private ExecutorService asyncSaveExecutorService = new ThreadPoolExecutor(threadPoolSize,
            threadPoolSize,
            0L,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(threadQueueSize * 2), new ThreadPoolExecutor.CallerRunsPolicy());
 
    private TransactionRepository transactionRepository;
  
  
		//事务的开启、commit、rollback
    public Transaction begin(Object uniqueIdentify) {
    public void commit(boolean asyncCommit) {
    public void rollback(boolean asyncRollback) {
 
      //
    public Transaction propagationNewBegin(TransactionContext transactionContext) 
    public Transaction propagationExistBegin(TransactionContext transactionContext) 
 
      //添加事务参与者Participant
    public void enlistParticipant(Participant participant) 
    
      //注册事务Transaction
    private void registerTransaction(Transaction transaction) 

然后，对于事务管理器提供的核心方法，进行分析：

(a)TransactionManager.begin开启事务

发起根事务TransactionType.ROOT---此时创建事务类型为ROOT的根事务，并存储、注册。

    public Transaction begin(Object uniqueIdentify) {
      //TAG1 创建根事务
        Transaction transaction = new Transaction(uniqueIdentify, this.transactionRepository.getDomain());
        //为了性能调优，在创建transaction阶段，不着急持久化存储
        if (transaction.getXid().getFormatId() == Xid.CUSTOMIZED) {
          //TAG2 对于自定义的xid，确保在TCC阶段之前只创建一次事务（所以对于自定义的xid，需要在tcc阶段开始前，先持久化存储）
            transactionRepository.create(transaction);
        }
      //TAG3 注册事务transaction
        registerTransaction(transaction);
        return transaction;
    }

TAG1:这里创建事务Transaction，使用如下构造函数：

   public Transaction(Object uniqueIdentity, String rootDomain) {
 
        this.xid = TransactionXid.withUniqueIdentity(uniqueIdentity);
        this.status = TransactionStatus.TRYING;
        this.transactionType = TransactionType.ROOT;
        this.rootXid = xid;
        this.rootDomain = rootDomain;
    }

Transaction有两个构造函数，当前构造函数只被begin()调用，只创建TransactionType.ROOT根事务、且 TransactionStatus.TRYING创建的是TCC阶段的try阶段。

TAG2:transactionRepository.create(transaction) 存储事务。详细见后续

TAG3 注册事务transaction

(b)TransactionManager.registerTransaction注册事务

   //事务管理器的本地线程变量，其内存储事务Transaction的队列
		private static final ThreadLocal<Deque<Transaction>> CURRENT = new ThreadLocal<>();
 
    private void registerTransaction(Transaction transaction) {
 
        if (CURRENT.get() == null) {
            CURRENT.set(new LinkedList<Transaction>());
        }
 
      //将事务添加入本地线程事务队列的头部
        CURRENT.get().push(transaction);
    }

注意：

在事务管理器TransactionManager.register注册事务，是将事务对象添加入本地线程事务队列的头部，后面获取事务时，也是从头部获取。（因为在TCC事务中，支持一个事务管理器管理多个事务transaction，而后创建的事务，要先提交，所以，入队和出队都要从头部）

©TransactionManager.propagationNewBegin传播并发起分支事务

注意调用时机：创建分支事务，在try阶段调用。

这里，首先创建分支事务，然后注册。

   public Transaction propagationNewBegin(TransactionContext transactionContext) {
			//注意：这里创建分支BRANCH事务
        Transaction transaction = new Transaction(transactionContext);
 
        //for performance tuning, at create stage do not persistent为了性能调优角度，在创建阶段，不持久化存储事务transaction
//        transactionRepository.create(transaction);
     //注册事务
        registerTransaction(transaction);
        return transaction;
    }

此处区分于beginTransaction，这里创建事务对象为TransactionType.BRANCH分支事务、TransactionStatus.TRYING事务状态为try阶段。分支事务和ROOT根事务有同一个事务id。

    public Transaction(TransactionContext transactionContext) {
        this.xid = transactionContext.getXid();
        this.rootXid = transactionContext.getRootXid();
        this.rootDomain = transactionContext.getRootDomain();
        this.status = TransactionStatus.TRYING;
        this.transactionType = TransactionType.BRANCH;
    }

(d)TransactionManager.propagationExistBegin传播并获取分支事务

注意区别：

TransactionManager.propagationExistBegin：这里是侧重获取分支事务（需要从事务存储器中查找并获取事务）；在confirm/cancle阶段调用

TransactionManager.propagationNewBegin是创建BRANCH事务，并存储，侧重于发起；在try阶段调用

    public Transaction propagationExistBegin(TransactionContext transactionContext) throws NoExistedTransactionException {
      //根据事务上下文transactionContext.getXid()，从事务存储器transactionRepository查询事务
        Transaction transaction = transactionRepository.findByXid(transactionContext.getXid());
 
        if (transaction != null) {
          //将获取的事务，重新注册入TransactionManager中
            registerTransaction(transaction);
            return transaction;
        } else {
            throw new NoExistedTransactionException();
        }
    }

(e)TransactionManager.commit提交事务

    public void commit(boolean asyncCommit) {
			//TAG1 获取当前事务队列的首个transaction
        final Transaction transaction = getCurrentTransaction();
			//修改当前事务状态为CONFIRMING
        transaction.setStatus(TransactionStatus.CONFIRMING);
			//更新
        transactionRepository.update(transaction);
 
        if (asyncCommit) {
            try {
                long statTime = System.currentTimeMillis();
 
                asyncTerminatorExecutorService.submit(() -> commitTransaction(transaction));
                logger.debug("async submit cost time:{}", System.currentTimeMillis() - statTime);
            } catch (Throwable commitException) {
                logger.warn("compensable transaction async submit confirm failed, recovery job will try to confirm later.", commitException.getCause());
                //throw new ConfirmingException(commitException);
            }
        } else {
            commitTransaction(transaction);
        }
    }
 
    private void commitTransaction(Transaction transaction) {
        try {
          //提交事务
            transaction.commit();
          //完成commit后，从持久化存储中删除事务
            transactionRepository.delete(transaction);
        } catch (Throwable commitException) {
 
            //如果commit提交失败，更新CONFIRMING状态的事务
            try {
                transactionRepository.update(transaction);
            } catch (Exception e) {
                //ignore any exception here
            }
 
            logger.warn("compensable transaction confirm failed, recovery job will try to confirm later.", commitException);
            throw new ConfirmingException(commitException);
        }
    }

综上，transactionManager.commit逻辑如下：

1 先从当前事务管理器transactionManager获取线程变量的事务队列的首个事务；
2 修改状态为confirming；
3 存储器中更新事务；
4 transaction.commit()；----如果commit失败，更新transaction（在提交的过程中，会更改transactionContext、参与者状态等信息，因此需要更新）
5 提交成功后，删除当前事务

TAG1 getCurrentTransaction 获取当前线程变量的事务队列的头部事务

   public Transaction getCurrentTransaction() {
        if (isTransactionActive()) {
            return CURRENT.get().peek();
        }
        return null;
    }
    
		//判断是否是活跃事务：只要当前线程变量的事务队列中有事务即可
       public boolean isTransactionActive() {
        Deque<Transaction> transactions = CURRENT.get();
        return transactions != null && !transactions.isEmpty();
    }

(e)TransactionManager.rollback

    public void rollback(boolean asyncRollback) {
 
        final Transaction transaction = getCurrentTransaction();
        transaction.setStatus(TransactionStatus.CANCELLING);
 
        transactionRepository.update(transaction);
 
        if (asyncRollback) {
 
            try {
                asyncTerminatorExecutorService.submit(() -> rollbackTransaction(transaction));
            } catch (Throwable rollbackException) {
                logger.warn("compensable transaction async rollback failed, recovery job will try to rollback later.", rollbackException);
                throw new CancellingException(rollbackException);
            }
        } else {
 
            rollbackTransaction(transaction);
        }
    }
    
        private void rollbackTransaction(Transaction transaction) {
        try {
            transaction.rollback();
            transactionRepository.delete(transaction);
        } catch (Throwable rollbackException) {
 
            //try save updated transaction
            try {
                transactionRepository.update(transaction);
            } catch (Exception e) {
                //ignore any exception here
            }
 
            logger.warn("compensable transaction rollback failed, recovery job will try to rollback later.", rollbackException);
            throw new CancellingException(rollbackException);
        }
    }

逻辑和commit相同

(e)TransactionManager.enlistParticipant添加参与者到transaction

该方法在try阶段被调用。

在添加参与者Participant时，先加入参与者队列；然后根据transaction.getVersion()是否为0，判断是否需要执行存储、或者进行更新

    public void enlistParticipant(Participant participant) {
        Transaction transaction = this.getCurrentTransaction();
        transaction.enlistParticipant(participant);
 
        if (transaction.getVersion() == 0L) {
            // transaction.getVersion()为0，表示之前从未持久化存储过，需要调用进行存储 
            transactionRepository.create(transaction);
        } else {
            transactionRepository.update(transaction);
        }
    }