分布式事务--手写TCC

最新推荐文章于 2023-03-25 13:54:26 发布
最新推荐文章于 2023-03-25 13:54:26 发布
阅读量781 收藏 5
点赞数 2
分类专栏： RPC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a294634473/article/details/117081743
版权

前言

基于之前的RPC服务手写一个简易的分布式事务TCC
实现细节有很多种做法 可以提出来一起讨论

实现思路

  1. 创建全局唯一ID能够让RPC中各个服务感知是同一个TCC
  2. 通过注册事务同步器在事务提交成功之后 先将confirm和cancel方法注册至zk服务
  3. 当所有的try方法都提交成功之后 获取zk中所有的confirm方法名称等信息 通过PRC调用各自写好的confirm方法（最终都是在主方法中执行）
  4. 当有try方法执行失败的时候 获取zk中所有的cancel方法名称等信息 通过PRC调用各自写好的cancel方法（最终都是在主方法中执行 所以调用RPC接口时需要返回该方法是否回滚 然后再主方法中抛出）
  5. 如果有confirm和cancel方法失败则需要存储到各个本地数据库中（后续的操作还没想好）

TCC注解

按照本地事务提交成功之后再注册confirm和cancel 方法的话 需要确定是谁开启TCC为了所有try方法执行完之后执行confirm方法

@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.TYPE })
public @interface TccTry {
    //对应的消费接口
    Class<?> interfaceClass();
    //对应的提交方法
    String confirmableKey() default "";
    //对应的取消方法
    String cancellableKey() default "";
    //是否为主方法
    boolean isMain() default false;
}

AOP注册事务同步器

@Aspect
@Component
public class TccTryAspect {

    @Pointcut("execution(* com.ljl.server.service.Impl.*.*(..))")
    public void pointcutName(){}

    @Autowired
    private ZkTccHander zkTccHander;

    @Before("pointcutName())")
    public void permissionCheck(JoinPoint point) {
        String className = point.getSignature().getDeclaringTypeName();
        String uuid = point.getArgs()[0].toString();
        try {
            TccTry tccTry = Class.forName(className).getAnnotation(TccTry.class);
            String comfirm = tccTry.confirmableKey();
            String cancel = tccTry.confirmableKey();
            MethodSignature signature = (MethodSignature) point.getSignature();
            Method method = signature.getMethod();
            if(method.getName().equals(comfirm)|| method.getName().equals(cancel)){
                //如果是comfirm或者cancel提交有成功或者失败则需要进行处理 这里先不考虑
            }else{
                // 注册事务同步器，在事务提交后进行回调 当所有的try都执行成功
                TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
                    //在事务提交/回滚后调用
                    @Override
                    public void afterCompletion(int status) {
                        switch (status) {
                            case 0:
                                //transaction status is commit
                                zkTccHander.invokeForPRC(uuid, className,"0");
                                //twoPhaseProcess(TransactionStatusEnum.STATUS_COMMITTED.getCode());
                                break;
                            case 1:
                                //transaction status is rollback
                                zkTccHander.invokeForPRC(uuid,className,"1");
                                break;
                            default:
                                //logger.error("tcc transaction status is unknown");
                                throw new RuntimeException("tcc transaction status is unknown");
                        }
                    }
                });
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

}

ZkTccHander

处理try-confirm-cancel 执行成功或者失败的逻辑

@Component
public class ZkTccHander {

    @Autowired
    public ZookeeperTcc zk;
    @Autowired
    private static ApplicationContextProviderForTcc applicationContex;


    public void invokeForPRC(String uuid,String className,String code){
        if(code.equals("0")){
            //同时插入本地数据库 失败之后继续调用
            //将tcc中的comfirm 和 cancel 存储到zk中用于后续的本地事务服务
            try {
                TccTry tccTry = Class.forName(className).getAnnotation(TccTry.class);
                String comfirm = tccTry.confirmableKey();
                String cancel = tccTry.cancellableKey();
                //通过唯一id进行创建 存在就不创建 并存储comfirm和cancel  如果方法有参数应该还要存储参数
                zk.createNodeNoWatch("/TCC/"+uuid,uuid);
                zk.createNodeNoWatch("/TCC/"+uuid+"/comfirm","comfirm");
                zk.createNodeNoWatch("/TCC/"+uuid+"/comfirm/"+comfirm,tccTry.interfaceClass().getName());
                zk.createNodeNoWatch("/TCC/"+uuid+"/cancel","cancel");
                zk.createNodeNoWatch("/TCC/"+uuid+"/cancel/"+cancel,tccTry.interfaceClass().getName());
                //通过uuid获取存储在zk上面的信息之后再通过反射调用@RPCClient
                //当所有方法try成功之后调用comfirm
                if(tccTry.isMain()){
                    List<String> childrens = zk.getChildsNoWatch("/TCC/"+uuid+"/comfirm");
                    System.out.println(childrens);
                    if(childrens.size() !=0){
                        for (String child : childrens) {
                            String data = zk.getData("/TCC/"+uuid+"/comfirm/"+child);
                            System.out.println(data);
                            Class tcc = Class.forName(data);
                            Object implObj= applicationContex.getBean(StringUtil.toLowerCaseFirstOne(tcc.getSimpleName()));
                            Method method = tcc.getDeclaredMethod(child,String.class);
                            method.invoke(implObj,uuid);
                        }
                    }
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (KeeperException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }else{
            //当tcc中的comfirm 和 cancel中有出现失败的时候需要记录下来 并进行重试
            try {
                TccTry tccTry = Class.forName(className).getAnnotation(TccTry.class);
                //当有方法try失败之后在Main中调用cancel
                if(tccTry.isMain()){
                    List<String> childrens = zk.getChildsNoWatch("/TCC/"+uuid+"/cancel");
                    if(childrens.size() !=0){
                        for (String child : childrens) {
                            String data = zk.getData("/TCC/"+uuid+"/cancel/"+child);
                            Class tcc = Class.forName(data);
                            System.out.println(data);
                            System.out.println(child);
                            Object implObj= applicationContex.getBean(StringUtil.toLowerCaseFirstOne(tcc.getSimpleName()));
                            Method method = tcc.getDeclaredMethod(child,String.class);
                            method.invoke(implObj,uuid);
                        }
                    }
                }
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (KeeperException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }


    }
}

结果展示

原始状态

在这里插入图片描述

调用成功

在这里插入图片描述

调用失败

这里可以看到调用了cancel方法
在这里插入图片描述

示例下单为一个RPC项目

@Service
@TccTry(interfaceClass= TccTestClient.class,confirmableKey="placeAnOrderForComfirm",cancellableKey="placeAnOrderForCancel",isMain=true)
@RPCServer
public class TccTestServiceImpl extends ServiceImpl<BaseOrderMapper, BaseOrder>  implements TccTestService {

    @Autowired
    private BalanceManageClient balanceManageClient;

    @Autowired
    private CouponManageClient couponManageClient;
    @Autowired
    private BaseOrderMapper baseOrderMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void placeAnOrderForTry(String uuid) throws Exception {
        //开始分布式事务  示例就调用下单、库存、积分

        //step1.锁定下单 将订单修改成中间状态
        BaseOrder baseOrder = new BaseOrder();
        baseOrder.setId(1);
        baseOrder.setStatus("锁定状态");
        baseOrderMapper.updateById(baseOrder);
        //step2.现金扣减
        String bcode = balanceManageClient.balanceReduceForTry(uuid);
        //0代表RPC方法回滚了
        if("0".equals(bcode)){
            throw new Exception();

        }//step3.积分
        String ccode = couponManageClient.couponUseForTry(uuid);
        //0代表RPC方法回滚了
        if("0".equals(ccode)){
            throw new Exception();

        }

    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void placeAnOrderForComfirm(String uuid) {
        //step1.将订单修改成下单完成状态
        BaseOrder baseOrder = new BaseOrder();
        baseOrder.setId(1);
        baseOrder.setStatus("完成状态");
        baseOrderMapper.updateById(baseOrder);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void placeAnOrderForCancel(String uuid) {
        //step1.将订单修改成未支付状态
        BaseOrder baseOrder = new BaseOrder();
        baseOrder.setId(1);
        baseOrder.setStatus("支付异常");
        baseOrderMapper.updateById(baseOrder);
    }
}

示例积分和会员为第二个RPC项目

@Service
@TccTry(interfaceClass= BalanceManageClient.class,confirmableKey="balanceReduceForComfirm",cancellableKey="balanceReduceForCancel")
@RPCServer
public class BalanceManageServiceImpl extends ServiceImpl<BaseOrderMapper, BaseOrder>  implements BalanceManageService {

    @Autowired
    private BalanceManageService balanceManageService;


    @Autowired
    private BaseOrderMapper baseOrderMapper;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String balanceReduceForTry(String uuid)  {
        try {
            balanceManageService.balanceReduceForTry2(uuid);
            System.out.println("1");
            return "1";
        }catch (Exception e){
            System.out.println("失败");
            return "0";
        }
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String balanceReduceForTry2(String uuid) {
        BaseOrder baseOrder = new BaseOrder();
        baseOrder.setId(2);
        baseOrder.setStatus("库存100");
        baseOrderMapper.updateById(baseOrder);
        return "1";
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String balanceReduceForComfirm(String uuid) {
        //step1.将订单修改成下单完成状态
        BaseOrder baseOrder = new BaseOrder();
        baseOrder.setId(2);
        baseOrder.setStatus("库存99");
        baseOrderMapper.updateById(baseOrder);
        return "1";
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String balanceReduceForCancel(String uuid) {
        //step1.将订单修改成未支付状态
        BaseOrder baseOrder = new BaseOrder();
        baseOrder.setId(2);
        baseOrder.setStatus("库存100");
        baseOrderMapper.updateById(baseOrder);
        return "1";
    }
}


@Service
@TccTry(interfaceClass= CouponManageClient.class,confirmableKey="couponUseForComfirm",cancellableKey="couponUseForCancel")
@RPCServer
public class CouponManageServiceImpl extends ServiceImpl<BaseOrderMapper, BaseOrder>  implements CouponManageService {



    @Autowired
    private CouponManageService couponManageService;
    @Autowired
    private BaseOrderMapper baseOrderMapper;

    @Override
    public String couponUseForTry(String uuid) {
        try {
            couponManageService.couponUseForTry2(uuid);
            System.out.println("1");
            return "1";
        }catch (Exception e){
            return "0";
        }


    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String couponUseForTry2(String uuid) {

        BaseOrder baseOrder = new BaseOrder();
        baseOrder.setId(3);
        baseOrder.setStatus("会员积分100");
        baseOrderMapper.updateById(baseOrder);
        //int i = 1/0;
        return "1";
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String couponUseForComfirm(String uuid) {
        //step1.将订单修改成下单完成状态
        BaseOrder baseOrder = new BaseOrder();
        baseOrder.setId(3);
        baseOrder.setStatus("会员积分120");
        baseOrderMapper.updateById(baseOrder);
        return "1";
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public String couponUseForCancel(String uuid) {
        //step1.将订单修改成未支付状态
        BaseOrder baseOrder = new BaseOrder();
        baseOrder.setId(3);
        baseOrder.setStatus("会员积分100");
        baseOrderMapper.updateById(baseOrder);
        return "1";
    }
}
纸上得来终觉浅，绝知此事要躬行
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于Hyperf的TCC分布式事务-tcc-transaction.zip
11-06
基于Hyperf的TCC分布式事务-tcc-transaction
分布式事务-hm.pdf
09-10
解决分布式事务的方法多样，如两阶段提交（2PC）、三阶段提交（3PC）、补偿事务（TCC）、 Saga模式、分布式事务协调器（如X/Open XA、Seata等）以及NoSQL数据库提供的特定事务模型。每种方案都有其优缺点，需根据...
分布式事务解决方案「手写代码」
12-08
<img src="https://img-bss.csdn.net/201912090245244367.png" alt="" />
手写基于Spring Cloud的TCC分布式事务框架
银湖冰河
10-19 1346
手动实现Spring Cloud分布式事务框架TCC如何简单、有效的实现小型分布式事务框架TCCTCC原理简介框架设计 如何简单、有效的实现小型分布式事务框架TCC 最近听到很多其他公司的小伙伴问分布式事务的问题，各种业务场景都有，可能就是这两年很多公司都在往微服务发展，现在各个子系统都拆分、建设的差不多了，实现了模块化开发，但是也遇到了很多分布式事务等问题，大多都用消息重试来保证外部系统的最终一致，或者把外部参与者限制为一个，其他操作全部本地实现、再结合业务场景的方式来解决。 如果业务要求严格一致性、执行
分布式事务框架哪个好_超万字长文，精讲如何手写分布式事务框架！
weixin_39834788的博客
11-29 846
分享架构师全套视频，50G资料，涵盖所有框架知识点，最牛逼技术栈！(关注“白码啸西风”，回复“0104”获得：网盘密码)分布式事务在当下分布式开发领域已经成为必须考虑的因素，随着微服务、SOA架构思想日益被开发者所熟知，分布式事务的解决思路也不断被提出并被开源社区实现。在互联网开发中，我们常常会采用一揽子“柔性事务”解决方案来保证系统内模块之间数据的 最终一致性。业界知名的分布式事务解决...
手写分布式事务之四定义分布式事务注解
Nuan_Feng的博客
02-23 976
自定义注解 案例代码 /** * @author wangchao * @date 2020-11-27 13:07:21 */ @Service public class TTestServiceImpl extends ServiceImpl<TTestMapper, TTest> implements TTestService { @Autowired TTestFeignClient feignClient; @Autowired TTe.
腾讯T9纯手写基于Mycat中间件的分布式数据库架构笔记
the shy
03-25 128
般来讲，一个Zone都有- -组主备Mycat负载均衡器LB，LB与同一中心内的Mycat Cluster组成一对多关系， 即一个LB可以服务-一个中心内的所有Cluster的负载均衡请求，也可以是多个LB,每个负担不同的Mycat Cluster的流量。随着计算机和信息技术的迅猛发展和普及，行业应用系统的规模迅速扩大，行业应用所产生的数据量呈爆炸式增长，动辄达到数百TB甚至数百PB的规模，已远远超出现有的传统计算技术和信息系统的处理能力，而集中式数据库面对大规模数据处理逐渐表现出其局限性。
Java-24-通用设计-分布式事务-TCC.rar
最新发布
09-18
Java-24_通用设计_分布式事务_TCC.rar
rest-tcc分布式事务
09-22
tcc 分布式事务 解决方案 基于rest的分布式事务解决方案
TCC-Transaction分布式事务DEMO
05-22
TCC-Transaction分布式事务DEMO,基于Mysql数据库的事务，包括分布式提交和回滚，例子完成，可以正常跑，基于Maven构建的项目
支付宝TCC示例
03-13
支付宝TCC示例
分布式事务解决方案「手写代码」.txt
12-31
课程介绍： 从理论基础知识，从简入深进行讲解，在理论的基础上，通过手写代码进行分布式事务的实践。 没有事务知识的小白，在这个课程也可以得到收获
从0到1手写分布式对象存储系统-02分布式架构初建
余衫马的博客
10-21 665
从0到1手写分布式对象存储系统
【自建分布式数据库详细指南】（三）扩展：利用POSTGRESQL流复制创建读写分离
wter26的专栏
11-09 1259
留档
如何编写一个分布式数据库
热门推荐
stark_summer的专栏
10-02 2万+
讲师: 刘奇(goroutine) 个人简介： PingCAP创始人兼CEO。分布式系统专家，擅长分布式数据库，分布式缓存。目前从事NewSQL方向的创业，通过开源方式重建google内部的F1和spanner。目前项目已经开源，https://github.com/pingcap/tidb大家好, 我是开源项目 分布式 NewSQL 数据库 TiDB 和 分布式缓存 Codis 的 创始人 刘
分布式事务之：TCC (Try-Confirm-Cancel) 模式
weixin_33743703的博客
02-29 3422
在当前如火如荼的互联网浪潮下，如何应对海量数据、高并发成为大家面临的普遍难题。广大IT公司从以往的集中式网站架构，纷纷转向分布式的网站架构，随之而来的就是进行数据库拆分和应用拆分，如何在跨数据库、跨应用保证数据操作和业务操作的一致性、原子性，又成为需要解决的新的问题。从分布式事务的需求来源来看：1、跨数据库 数据库拆分(水平、垂直)带来的分布式事务-&gt;保证跨库操作的原子性 基于单个J...
TCC分布式事务的实现原理（补偿机制）
weixin_46217160的博客
11-09 3390
核心思想是：针对每个操作，都要注册一个与其对应的确认和补偿（撤销）操作。分为三个阶段： Try 阶段:主要是对业务系统做检测（一致性）及资源预留（准隔离性） Confirm 阶段:主要是对业务系统做确认提交，Try阶段执行成功并开始执行 Confirm阶段时，默认Confirm阶段是不会出错的。即：只要Try成功，Confirm一定成功。(Confirm 操作满足幂等性。要求具备幂等设计，Confirm 失败后需要进行重试。 ) Cancel 阶段主要是在业务执行错误，需要回滚的状态下执行的业务取.
手写window
chenggil10的专栏
06-25 95
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions { // Override point for customization after application launch. // self.window = ...
分布式事务管理组件seata 和 TCC-Transaction
04-25
两者有什么区别和优缺点？ Seata和TCC-Transaction都是分布式事务管理组件，都可以用来解决分布式事务问题，但是它们的实现方式有所不同。 Seata通过基于行级锁的分布式事务协调器来实现分布式事务管理，具有高可用性和高性能的特点。Seata可以使用XA或TCC等事务模型，可以精确控制每个分支事务的生命周期。 TCC-Transaction则是通过尝试、确认、取消三个阶段来实现分布式事务管理，具有技术栈无关性，并且能够灵活地处理嵌套事务和异常情况。 相较而言，Seata更加成熟和稳定，支持多种事务模型，在容错性和性能方面都有所优化。而TCC-Transaction则更加灵活，可以适应各种场景和技术栈。 总的来说，选择哪一种分布式事务管理组件需要根据具体的业务需求和场景进行综合评估和选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值