tcc分布式事务实现原理解析(同步调用)

本文讨论同步调用保证结果一致性的的情景（tcc）,当然即可采用顺序回滚的方式

=============

如 a方法 -> bcd方法  其中->代表远程调用

 

==============

tcc 代表三个英文单词 try commit cancel。

try阶段：

事务预提交。例如电商系统里的 积分、仓储、钱的计算，这些结果要最终保持结果一致性。那么就需要实现同时都成功或者同时都失败，那么这个过程就可以作为预提交数据，如积分可以预先加到预留字段或者通过先插入一条log日志作为预提交

commit：

当所有的try都success后,来提交上一步中所有的try预提交结果。即比如吧预留字段的积分加到最终的积分表上或者吧log日志中的数据加到最终积分表上。

cancel:

应当是当执行上面bcd的过程中 有一个远程调用失败了，那么就需要rollback当前已经执行的所有try

===========

如何实现一个分布式事务的框架？下面是伪代码实现

/拦截A的方法
doRound(MethodInvocation invocation){
    //获得一个tid;插入一个总事物对象 初始状态为try
    Long tId = insert(new TransactionClassInfo(tid, tryProcess, try));
    context.setTId(tId);
    //把包含tid的基本信息放到dubbo上下文中，方便告知被调用的远程方法 
    RpcContext.getContext().setAttachments(context);
    //原方法执行a继续执行 用来调用bcd
    boolean isSuccess = invocation.proceed();
     //插入一条代表所有
      //当invocation.proceed是执行成功的时候，需要发消息给各个远程调用的方法进行commit或者cancel
      if(isSuccess){
      //更新总事物对象 状态变为success
      update(transactionClassInfo(tid, tryProcess, commit));
      List<TransactionSubClassInfo> transactionSubClassInfos = queryTransactionSubClassInfosBysTid(params.geTId());
        transactionSubClassInfos.forEach(transactionSubClassInfo -> {
            type = transactionSubClassInfo.getType;
                rocketMq.send(topic, transactionSubCode,success, transactionSubClassInfo);//发消息来调用commit方法
        });
      update(transactionClassInfo(tid, sucess, commit));
      }else{
          update(transactionClassInfo(tid, tryProcess, cancel));
          //根据tid查询当前tid下的所有的事物
          List<TransactionSubClassInfo> transactionSubClassInfos = queryTransactionSubClassInfosBysTid(context.geTId());
        transactionSubClassInfos.forEach(transactionSubClassInfo -> {
            type = transactionSubClassInfo.getType;
                rocketMq.send(topic, transactionSubCode,fail, transactionSubClassInfo);//发消息来调用cancel方法
        });
        update(transactionClassInfo(tid, sucess, cancel));
      }

}   

//拦截远程调用的方法BCD
doRound(MethodInvocation invocation){
    Long tid = RpcContext.getContext().getMessage().getTid();
    String methodTypeName = invocation.getMethodName();
    if("try".equals(methodTypeName)){
         uniCode = getTransactionSubUniCode();
         //执行原try方法
         invocation.proceed();
          //methodTypeName = status 即哪个阶段
         insert(new TransactionSubClassInfo(tid, unicode, try, tryExcuteSuccess));
    }

    if("commit".equals(methodTypeName)){
         //执行原commit方法
         invocation.proceed();
         update(transactionSubClassInfo(tid, unicode, commit, tryExcuteSuccess));
    }

    if("cancel".equals(methodTypeName)){
     //执行原cancel方法
         invocation.proceed();
          update(transactionSubClassInfo(tid, unicode, cancel, tryExcuteSuccess))
    }
} 


/*算法方法:每个服务器都去数据取一段顺序数字组放到缓存中， 本地直接用，每次服务器取到数据组就更新下一起点*/
private getTransactionSubUniCode(){
    String date = "年月日";
    //从0开始
    Long start =getSequenceId();
    //插入下次开始的
    insertNextStartSequenceId(start + defalutSize);
    //static CodeCache; offSet = 0;codeCache.set(start, offset);
    return date.concat(codeCache.get(offset));

}

@TransactionInvoke
A {
    //dubbo服务BCD;
    B();

    C();

    D();

}


@TransactionSub(transactionSubCode = "uniCode", transactionType = "tcc")
B(){
    

    @TransactionSub(TransactionSubCode ="uniCode", ...)
    doTry{}


    @TransactionSub(TransactionSubCode ="uniCode", ...)
    doCommit(){

    }

    @TransactionSub(TransactionSubCode ="uniCode", ...)
    doCancel(){

    }
    
}



@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD })
public @interface TransactionInvoke {
　　...
}

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD })
public @interface TransactionSub {
    String transactionSubCode();

    String transactionType();
　　　　....
}


init(){
        //获得当前服务器下面所有的有分布式事物注释的类方法的元数据
        Map<transactionSubCode,TransactionSubClass> metaClassMap = AnnotationScanner.getClazzAndAnnotation(scanPackages)
        //static  subClassContext = ...;
        subClassContext.put(class);
        //扫描所有的包 获得这些
        List<String> transactionSubCodes = AnnotationScanner.getAllTransactionSubCodes(scanPackages);
        cosumer.setUnderTake(new ConsumerProcessClass());
        //吧扫描包里所有的包含
        cosumer.suscribe(topic, transactionSubCodes, ...);
        cosumer.listen();
        ...
    
}

class ConsumerProcessClass{
    process(TransactionSubClassInfo){
    transactionSubCode = TransactionSubClassInfo.getTransactionSubCode();
    TransactionSubClass  transactionSubClass= metaClassMap.get(transactionSubCode);
        if(TransactionSubClassInfo.isExcuteTrySuccess()){
            //利用反射调用commit方法或者cancel方法
            Reflect.doMethod(TransactionSubClass.getCommitMethod);
            update(transactionSubClassInfo(commit,sucess);
        }else{
        //利用反射调用commit方法或者cancel方法
            Reflect.invoke(TransactionSubClass.getCancelMethod);
            update(transactionSubClassInfo(cancel,sucess);
        }
    }
}

class TransactionSubClass{
    Method try;

    Method cancel;

    Method commit;

    ....
}

========================================
note:
//所有的上下文都放在三中类型的变量中
1static Filed;

2static ThreadLocal<>;


//可以设置在dubbo过滤器中 方便进行分布式事务的上下文传递
3Rpc.getContext().set();



========================================

note:如果发mq的过程中失败
或者在执行commit或者cancel阶段失败

那么怎么办？1 rocket重发2 定时任务扫描所有的transactionSubClassInfos 然后一个个根据tid查询transactionClassInfo判断是否执行成功 然后再次更新所有的定时任务扫描所有的transactionSubClassInfos 调用所有的commit或者cancel

========================================

note:如果在执行bcd是异步的呢？