• SpringCloud - Spring Cloud Alibaba 之 Seata分布式事务服务；TCC事务模式机制（二十三）

    阅读本文前可先参考：

    SpringCloud - Spring Cloud Alibaba 之 Seata分布式事务服务详解；部署（十八）_MinggeQingchun的博客-CSDN博客

    SpringCloud - Spring Cloud Alibaba 之 Seata分布式事务服务；AT事务模式（二十）_MinggeQingchun的博客-CSDN博客

    Seata TCC 事务模式

    AT模式基本上能满足我们使用分布式事务大部分需求，但涉及非关系型数据库与中间件的操作、跨公司服务的调用、跨语言的应用调用就需要结合TCC模式

    http://seata.io/zh-cn/docs/dev/mode/tcc-mode.html

    一个分布式的全局事务，整体是两阶段提交（Try - [Comfirm/Cancel]）的模型

    根据两阶段行为模式的不同，我们将分支事务划分为 Automatic (Branch) Transaction Mode 和 TCC (Branch) Transaction Mode

    AT 模式（参考链接 TBD）基于 支持本地 ACID 事务 的 关系型数据库：

    • 一阶段 prepare 行为：在本地事务中，一并提交业务数据更新和相应回滚日志记录
    • 二阶段 commit 行为：马上成功结束，自动 异步批量清理回滚日志
    • 二阶段 rollback 行为：通过回滚日志，自动 生成补偿操作，完成数据回滚

    TCC 模式，不依赖于底层数据资源的事务支持（需要程序员编写代码实现提交和回滚）：

    • 一阶段 prepare 行为：调用 自定义 的 prepare 逻辑
    • 二阶段 commit 行为：调用 自定义 的 commit 逻辑
    • 二阶段 rollback 行为：调用 自定义 的 rollback 逻辑

    TCC 模式，是指支持把 自定义 的分支事务纳入到全局事务的管理中

    通俗来说，Seata的TCC模式就是手工版本的AT模式，它允许你自定义两阶段的处理逻辑而不需要依赖AT模式的undo_log回滚表

    1、创建数据库、表、插入数据等

    （1）accountdb账户库、account账户表

    1. SET NAMES utf8mb4;
    2. SET FOREIGN_KEY_CHECKS = 0;
    3.  
    4. -- ----------------------------
    5. -- Table structure for account
    6. -- ----------------------------
    7. DROP TABLE IF EXISTS `account`;
    8. CREATE TABLE `account`  (
    9.   `id` int(20) NOT NULL AUTO_INCREMENT,
    10.   `user_id` int(20) NULL DEFAULT NULL,
    11.   `balance` decimal(20, 0) NULL DEFAULT NULL,
    12.   `update_time` datetime(6) NULL DEFAULT NULL,
    13.   PRIMARY KEY (`id`) USING BTREE
    14. ) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
    15.  
    16. SET FOREIGN_KEY_CHECKS = 1;

    （2）productdb产品库、product产品表

    1. SET NAMES utf8mb4;
    2. SET FOREIGN_KEY_CHECKS = 0;
    3.  
    4. -- ----------------------------
    5. -- Table structure for product
    6. -- ----------------------------
    7. DROP TABLE IF EXISTS `product`;
    8. CREATE TABLE `product`  (
    9.   `id` int(20) NOT NULL AUTO_INCREMENT,
    10.   `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
    11.   `price` decimal(10, 2) NULL DEFAULT NULL,
    12.   `stock` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
    13.   `add_time` datetime(6) NULL DEFAULT NULL,
    14.   `update_time` datetime(6) NULL DEFAULT NULL,
    15.   PRIMARY KEY (`id`) USING BTREE
    16. ) ENGINE = InnoDB AUTO_INCREMENT = 2 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
    17.  
    18. SET FOREIGN_KEY_CHECKS = 1;

    （3）orderdb订单库、orders 订单表

    1. SET NAMES utf8mb4;
    2. SET FOREIGN_KEY_CHECKS = 0;
    3.  
    4. -- ----------------------------
    5. -- Table structure for orders
    6. -- ----------------------------
    7. DROP TABLE IF EXISTS `orders`;
    8. CREATE TABLE `orders`  (
    9.   `id` int(20) NOT NULL AUTO_INCREMENT,
    10.   `user_id` int(20) NULL DEFAULT NULL,
    11.   `product_id` int(20) NULL DEFAULT NULL,
    12.   `pay_amount` decimal(20, 0) NULL DEFAULT NULL,
    13.   `add_time` datetime(6) NULL DEFAULT NULL,
    14.   `update_time` datetime(6) NULL DEFAULT NULL,
    15.   PRIMARY KEY (`id`) USING BTREE
    16. ) ENGINE = InnoDB AUTO_INCREMENT = 6 CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
    17.  
    18. SET FOREIGN_KEY_CHECKS = 1;

    （4）undo_log表  

    Seata AT 模式

    1. -- 注意此处0.7.0+ 增加字段 context
    2. CREATE TABLE `undo_log` (
    3.   `id` bigint(20) NOT NULL AUTO_INCREMENT,
    4.   `branch_id` bigint(20) NOT NULL,
    5.   `xid` varchar(100) NOT NULL,
    6.   `context` varchar(128) NOT NULL,
    7.   `rollback_info` longblob NOT NULL,
    8.   `log_status` int(11) NOT NULL,
    9.   `log_created` datetime NOT NULL,
    10.   `log_modified` datetime NOT NULL,
    11.   PRIMARY KEY (`id`),
    12.   UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
    13. ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

    注：

    每个库必须创建 undo_log 表，是 Seata AT模式必须创建的表，主要用于分支事务的回滚

    Seata AT 模式

     

    一、SpringBoot单体应用多数据源TCC事务

    在Spring Boot单体项目中，使用了多数据源，就要保证多个数据源的数据一致性，即产生了分布式事务的问题，采用Seata的AT事务模式来解决该分布式事务问题

    以下图购物下单为例

    分布式事务的N种实现
    pdf 0星 超过10%的资源 787KB
    下载

    1、创建一个 springboot应用，命名 springcloud-alibaba-3-seata-tcc-transaction 

    2、添加依赖

    1. <groupId>com.companygroupId>
    2.     <artifactId>springcloud-alibaba-3-seata-tcc-transactionartifactId>
    3.     <version>1.0.0version>
    4.  
    5.     <name>springcloud-alibaba-3-seata-tcc-transactionname>
    6.     <description>Demo project for Spring Bootdescription>
    7.  
    8.     <properties>
    9.         <java.version>1.8java.version>
    10.         <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    11.         <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
    12.         <spring-boot.version>2.3.12.RELEASEspring-boot.version>
    13.         <spring-cloud-alibaba.version>2.2.7.RELEASEspring-cloud-alibaba.version>
    14.     properties>
    15.  
    16.     <dependencies>
    17.         <dependency>
    18.             <groupId>org.springframework.bootgroupId>
    19.             <artifactId>spring-boot-starter-webartifactId>
    20.         dependency>
    21.  
    22.         <dependency>
    23.             <groupId>org.springframework.bootgroupId>
    24.             <artifactId>spring-boot-starter-actuatorartifactId>
    25.         dependency>
    26.  
    27.         <dependency>
    28.             <groupId>org.springframework.bootgroupId>
    29.             <artifactId>spring-boot-starter-testartifactId>
    30.             <scope>testscope>
    31.             <exclusions>
    32.                 <exclusion>
    33.                     <groupId>org.junit.vintagegroupId>
    34.                     <artifactId>junit-vintage-engineartifactId>
    35.                 exclusion>
    36.             exclusions>
    37.         dependency>
    38.  
    39.         <dependency>
    40.             <groupId>org.projectlombokgroupId>
    41.             <artifactId>lombokartifactId>
    42.         dependency>
    43.  
    44.         
    45.         <dependency>
    46.             <groupId>mysqlgroupId>
    47.             <artifactId>mysql-connector-javaartifactId>
    48.             
    49.         dependency>
    50.  
    51.         
    52.         <dependency>
    53.             <groupId>org.mybatis.spring.bootgroupId>
    54.             <artifactId>mybatis-spring-boot-starterartifactId>
    55.             <version>2.1.3version>
    56.         dependency>
    57.  
    58.         
    59.         <dependency>
    60.             <groupId>io.seatagroupId>
    61.             <artifactId>seata-spring-boot-starterartifactId>
    62.             <version>1.4.2version>
    63.         dependency>
    64.  
    65.         
    66.         <dependency>
    67.             <groupId>com.baomidougroupId>
    68.             <artifactId>dynamic-datasource-spring-boot-starterartifactId>
    69.             <version>3.2.0version>
    70.         dependency>
    71.  
    72.         
    73.         <dependency>
    74.             <groupId>com.alibaba.nacosgroupId>
    75.             <artifactId>nacos-clientartifactId>
    76.             <version>2.1.0version>
    77.         dependency>
    78.     dependencies>
    79.  
    80.     
    81.     <dependencyManagement>
    82.         <dependencies>
    83.             <dependency>
    84.                 <groupId>com.alibaba.cloudgroupId>
    85.                 <artifactId>spring-cloud-alibaba-dependenciesartifactId>
    86.                 <version>${spring-cloud-alibaba.version}version>
    87.                 <type>pomtype>
    88.                 <scope>importscope>
    89.             dependency>
    90.             
    91.             <dependency>
    92.                 <groupId>org.springframework.cloudgroupId>
    93.                 <artifactId>spring-cloud-dependenciesartifactId>
    94.                 <version>Hoxton.SR12version>
    95.                 <type>pomtype>
    96.                 <scope>importscope>
    97.             dependency>
    98.             <dependency>
    99.                 <groupId>org.springframework.bootgroupId>
    100.                 <artifactId>spring-boot-dependenciesartifactId>
    101.                 <version>${spring-boot.version}version>
    102.                 <type>pomtype>
    103.                 <scope>importscope>
    104.             dependency>
    105.         dependencies>
    106.     dependencyManagement>
    107.  
    108.     <build>
    109.         <plugins>
    110.             <plugin>
    111.                 <groupId>org.apache.maven.pluginsgroupId>
    112.                 <artifactId>maven-compiler-pluginartifactId>
    113.                 <configuration>
    114.                     <source>1.8source>
    115.                     <target>1.8target>
    116.                     <encoding>UTF-8encoding>
    117.                 configuration>
    118.             plugin>
    119.             <plugin>
    120.                 <groupId>org.springframework.bootgroupId>
    121.                 <artifactId>spring-boot-maven-pluginartifactId>
    122.             plugin>
    123.             
    124.             <plugin>
    125.                 <groupId>org.mybatis.generatorgroupId>
    126.                 <artifactId>mybatis-generator-maven-pluginartifactId>
    127.                 <version>1.4.0version>
    128.                 <configuration>
    129.                     
    130.                     <configurationFile>src/main/resources/generatorConfig.xmlconfigurationFile>
    131.                     
    132.                     <verbose>trueverbose>
    133.                     
    134.                     <overwrite>trueoverwrite>
    135.                 configuration>
    136.             plugin>
    137.         plugins>
    138.  
    139.         <resources>
    140.             <resource>
    141.                 <directory>src/main/javadirectory>
    142.                 <includes>
    143.                     <include>**/*.xmlinclude>
    144.                 includes>
    145.             resource>
    146.             <resource>
    147.                 <directory>src/main/resourcesdirectory>
    148.                 <includes>
    149.                     <include>**/*.*include>
    150.                 includes>
    151.             resource>
    152.             
    153.             <resource>
    154.                 <directory>src/main/webappdirectory>
    155.                 <targetPath>META-INF/servicestargetPath>
    156.                 <includes>
    157.                     <include>**/*.*include>
    158.                 includes>
    159.             resource>
    160.         resources>
    161.     build>

    3、 application.properties配置文件

    1. #内嵌服务器端口
    2. server.port=8081
    3.  
    4. #应用服务名称
    5. spring.application.name=springcloud-alibaba-3-seata-tcc-transaction
    6.  
    7. # 设置默认的数据源或者数据源组，默认值即为master
    8. spring.datasource.dynamic.primary=order-ds
    9.  
    10. # 订单order数据源配置
    11. spring.datasource.dynamic.datasource.order-ds.url=jdbc:mysql://192.168.133.129:3306/orderdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&rewriteBatchedStatements=true&useSSL=false
    12. spring.datasource.dynamic.datasource.order-ds.driver-class-name=com.mysql.cj.jdbc.Driver
    13. spring.datasource.dynamic.datasource.order-ds.username=root
    14. spring.datasource.dynamic.datasource.order-ds.password=123456
    15.  
    16. # 商品product数据源配置
    17. spring.datasource.dynamic.datasource.product-ds.url=jdbc:mysql://192.168.133.129:3306/productdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&rewriteBatchedStatements=true&useSSL=false
    18. spring.datasource.dynamic.datasource.product-ds.driver-class-name=com.mysql.cj.jdbc.Driver
    19. spring.datasource.dynamic.datasource.product-ds.username=root
    20. spring.datasource.dynamic.datasource.product-ds.password=123456
    21.  
    22. # 账户account数据源配置
    23. spring.datasource.dynamic.datasource.account-ds.url=jdbc:mysql://192.168.133.129:3306/accountdb?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf8&rewriteBatchedStatements=true&useSSL=false
    24. spring.datasource.dynamic.datasource.account-ds.driver-class-name=com.mysql.cj.jdbc.Driver
    25. spring.datasource.dynamic.datasource.account-ds.username=root
    26. spring.datasource.dynamic.datasource.account-ds.password=123456
    27.  
    28. # 是否启动对Seata的集成
    29. spring.datasource.dynamic.seata=true
    30.  
    31.  
    32. #-----------------------------------------------------------
    33. #单机版 tc server 配置
    34. # Seata应用编号，默认为 ${spring.application.name}
    35. seata.application-id=springboot-tcc-seata
    36. # Seata事务组编号，用于TC集群名，一般格式为：${spring.application.name}-group
    37. seata.tx-service-group=springboot-tcc-seata-group
    38. # 虚拟组和分组的映射 seata.service.vgroup-mapping.${seata.tx-service-group}=default
    39. seata.service.vgroup-mapping.springboot-tcc-seata-group=default
    40. # 分组和Seata服务的映射，此处default指上面 seata.service.vgroup-mapping.springboot-seata-group 的值 default
    41. seata.service.grouplist.default=192.168.133.129:8091
    42. # 存储模式 默认 file模式
    43. seata.config.type=file
    44. # 默认为 file
    45. seata.registry.type=file
    46. #------------------------------------------------------------
    47.  
    48.  
    49. #------------------------------------------------------------
    50. ##集群版 tc server 配置
    51. ## Seata应用编号，默认为 ${spring.application.name}
    52. #seata.application-id=springboot-tcc-seata
    53. ## Seata事务组编号，用于TC集群名，一般格式为：${spring.application.name}-group
    54. #seata.tx-service-group=springboot-tcc-seata-group
    55. ## 虚拟组和分组的映射 seata.service.vgroup-mapping.${seata.tx-service-group}=default
    56. #seata.service.vgroup-mapping.springboot-tcc-seata-group=default
    57. #------------------------------------------------------------
    58.  
    59. #设置使用注册中心
    60. #seata.registry.type=nacos
    61. #seata.registry.nacos.cluster=default
    62. #seata.registry.nacos.application=seata-server
    63. #seata.registry.nacos.group=SEATA_GROUP
    64. #seata.registry.nacos.server-addr=192.168.133.129:8848
    65. #
    66. #seata.enable-auto-data-source-proxy=false
    67. #seata.client.rm.lock.retry-policy-branch-rollback-on-conflict=false
    68.  
    69.  
    70. #配置 undo_log 的解析方式
    71. seata.client.undo.log-serialization=myJackson

    4、编写相应的 controller、model、mapper、service类，这里只给出调用顺序相关的类

     controller测试类

    1. @Slf4j //lombok
    2. @RestController
    3. public class OrderController {
    4.  
    5.     @Autowired
    6.     private OrderService orderService;
    7.  
    8.     @RequestMapping("/order")
    9.     public Integer createOrder(@RequestParam("userId") Integer userId,
    10.                                @RequestParam("productId") Integer productId) throws Exception {
    11.  
    12.         log.info("请求下单, 用户:{}, 商品:{}", userId, productId);
    13.  
    14.         return orderService.createOrder(userId, productId);
    15.     }
    16. }
    17.  
    18.  
    19.  
    20. @Slf4j
    21. @Service
    22. public class OrderServiceImpl implements OrderService {
    23.  
    24.     @Autowired
    25.     private OrdersMapper ordersMapper;
    26.  
    27.     @Autowired
    28.     private AccountService accountService;
    29.  
    30.     @Autowired
    31.     private ProductService productService;
    32.  
    33.     @Override
    34.     @DS(value = "order-ds")
    35.     @GlobalTransactional //seata全局事务注解， TM 事务发起方
    36.     public Integer createOrder(Integer userId, Integer productId) throws Exception {
    37.         Integer amount = 1; // 购买数量暂时设置为 1
    38.  
    39.         log.info("当前 XID: {}", RootContext.getXID());
    40.  
    41.         // 减库存
    42.         Product product = productService.reduceStock(productId, amount);
    43.  
    44.         // 减余额
    45.         accountService.reduceBalance(userId, product.getPrice());
    46.  
    47.         // 下订单
    48.         Orders order = new Orders();
    49.         order.setUserId(userId);
    50.         order.setProductId(productId);
    51.         order.setPayAmount(product.getPrice().multiply(new BigDecimal(amount)));
    52.  
    53.         ordersMapper.insertSelective(order);
    54.  
    55.         log.info("下订单: {}", order.getId());
    56.  
    57.         int a = 10 / 0;
    58.  
    59.         // 返回订单编号
    60.         return order.getId();
    61.     }
    62. }

    AccountService

    1. @LocalTCC
    2. public interface AccountService {
    3.  
    4.     /**
    5.      * 扣除余额
    6.      * 定义两阶段提交
    7.      * name = reduceStock为一阶段try方法
    8.      * commitMethod = commitTcc 为二阶段确认方法
    9.      * rollbackMethod = cancel 为二阶段取消方法
    10.      * BusinessActionContextParameter注解 可传递参数到二阶段方法
    11.      *
    12.      * @param userId 用户ID
    13.      * @param money  扣减金额
    14.      * @throws Exception 失败时抛出异常
    15.      */
    16.     @TwoPhaseBusinessAction(name = "reduceBalance", commitMethod = "commitTcc", rollbackMethod = "cancelTcc")
    17.     void reduceBalance(@BusinessActionContextParameter(paramName = "userId") Integer userId,
    18.                        @BusinessActionContextParameter(paramName = "money") BigDecimal money);
    19.  
    20.     /**
    21.      * 确认方法、可以另命名，但要保证与commitMethod一致
    22.      * context可以传递try方法的参数
    23.      *
    24.      * @param context 上下文
    25.      * @return boolean
    26.      */
    27.     boolean commitTcc(BusinessActionContext context);
    28.  
    29.     /**
    30.      * 二阶段取消方法
    31.      *
    32.      * @param context 上下文
    33.      * @return boolean
    34.      */
    35.     boolean cancelTcc(BusinessActionContext context);
    36.  
    37. }
    38.  
    39.  
    40.  
    41. @Slf4j
    42. @Service
    43. public class AccountServiceImpl implements AccountService {
    44.  
    45.     @Autowired
    46.     private AccountMapper accountMapper;
    47.  
    48.     @DS(value = "account-ds")
    49.     @Override
    50.     public void reduceBalance(Integer userId, BigDecimal money) {
    51.         log.info("当前 XID: {}", RootContext.getXID());
    52.  
    53.         // 检查余额
    54.         Account account = accountMapper.selectAccountByUserId(userId);
    55.         if (account.getBalance().doubleValue() < money.doubleValue()) {
    56.             throw new RuntimeException("余额不足");
    57.         }
    58.  
    59.         // 扣除余额
    60.         int updateCount = accountMapper.reduceBalance(userId, money);
    61.         // 扣除成功
    62.         if (updateCount == 0) {
    63.             throw new RuntimeException("余额不足");
    64.         }
    65.         log.info("扣除用户 {} 余额成功", userId);
    66.  
    67.         //int a = 10 / 0;
    68.     }
    69.  
    70.     /**
    71.      * tcc服务（confirm）方法
    72.      * 可以空确认
    73.      *
    74.      * @param context 上下文
    75.      * @return boolean
    76.      */
    77.     @DS(value = "account-ds")
    78.     @Override
    79.     public boolean commitTcc(BusinessActionContext context) {
    80.         log.info("Confirm阶段，AccountServiceImpl, commitTcc --> xid = {}", context.getXid() + ", commitTcc提交成功");
    81.         return true;
    82.     }
    83.  
    84.     /**
    85.      * tcc服务（cancel）方法
    86.      * 实现中间件、非关系型数据库的回滚操作
    87.      * @param context 上下文
    88.      * @return boolean
    89.      */
    90.     @DS(value = "account-ds")
    91.     @Override
    92.     public boolean cancelTcc(BusinessActionContext context) {
    93.         log.info("Cancel阶段，AccountServiceImpl, cancelTcc --> xid = " + context.getXid() + ", cancelTcc提交失败");
    94.         //可以实现中间件、非关系型数据库的回滚操作
    95.         log.info("Cancel阶段，AccountServiceImpl, cancelTcc this data: userId= {}, money = {}", context.getActionContext("userId"), context.getActionContext("money"));
    96.  
    97.         //进行数据库回滚处理
    98.         Integer userId = (Integer)context.getActionContext("userId");
    99.         BigDecimal money = (BigDecimal)context.getActionContext("money");
    100.  
    101.         //把余额再加回去
    102.         accountMapper.increaseBalance(userId, money);
    103.  
    104.         return true;
    105.     }
    106. }

    ProductService 

    1. @LocalTCC
    2. public interface ProductService {
    3.  
    4.     /**
    5.      * 减库存
    6.      *
    7.      * 定义两阶段提交
    8.      * name = reduceStock为一阶段try方法
    9.      * commitMethod = commitTcc 为二阶段确认方法
    10.      * rollbackMethod = cancel 为二阶段取消方法
    11.      * BusinessActionContextParameter注解 可传递参数到二阶段方法
    12.      *
    13.      * @param productId 商品ID
    14.      * @param amount    扣减数量
    15.      * @throws Exception 扣减失败时抛出异常
    16.      */
    17.     @TwoPhaseBusinessAction(name = "reduceStock", commitMethod = "commitTcc", rollbackMethod = "cancelTcc")
    18.     Product reduceStock(@BusinessActionContextParameter(paramName = "productId") Integer productId,
    19.                         @BusinessActionContextParameter(paramName = "amount") Integer amount);
    20.  
    21.     /**
    22.      * 二阶段提交方法
    23.      *
    24.      * 确认方法、可以另命名，但要保证与commitMethod一致
    25.      * context可以传递try方法的参数
    26.      *
    27.      * @param context 上下文
    28.      * @return boolean
    29.      */
    30.     boolean commitTcc(BusinessActionContext context);
    31.  
    32.     /**
    33.      * 二阶段回滚方法
    34.      *
    35.      * @param context 上下文
    36.      * @return boolean
    37.      */
    38.     boolean cancelTcc(BusinessActionContext context);
    39.  
    40. }
    41.  
    42.  
    43.  
    44. @Slf4j
    45. @Service
    46. public class ProductServiceImpl implements ProductService {
    47.  
    48.     @Autowired
    49.     private AccountService accountService;
    50.  
    51.     @Autowired
    52.     private ProductMapper productMapper;
    53.  
    54.     @DS(value = "product-ds")
    55.     @Override
    56.     public Product reduceStock(Integer productId, Integer amount) {
    57.         log.info("当前 XID: {}", RootContext.getXID());
    58.  
    59.         // 检查库存
    60.         Product product = productMapper.selectByPrimaryKey(productId);
    61.         if (product.getStock() < amount) {
    62.             throw new RuntimeException("库存不足");
    63.         }
    64.  
    65.         // 扣减库存
    66.         int updateCount = productMapper.reduceStock(productId, amount);
    67.         // 扣除成功
    68.         if (updateCount == 0) {
    69.             throw new RuntimeException("库存不足");
    70.         }
    71.  
    72.         // 扣除成功
    73.         log.info("扣除 {} 库存成功", productId);
    74.  
    75.         return product;
    76.     }
    77.  
    78.     /**
    79.      * tcc服务（confirm）方法
    80.      * 可以空确认
    81.      *
    82.      * @param context 上下文
    83.      * @return boolean
    84.      */
    85.     @DS(value = "product-ds")
    86.     @Override
    87.     public boolean commitTcc(BusinessActionContext context) {
    88.         log.info("Confirm阶段，ProductServiceImpl, commitTcc --> xid = " + context.getXid() + ", commitTcc提交成功");
    89.         return true;
    90.     }
    91.  
    92.     /**
    93.      * tcc服务（cancel）方法
    94.      *
    95.      * @param context 上下文
    96.      * @return boolean
    97.      */
    98.     @DS(value = "product-ds")
    99.     @Override
    100.     public boolean cancelTcc(BusinessActionContext context) {
    101.         log.info("Cancel阶段，ProductServiceImpl, cancelTcc --> xid = " + context.getXid() + ", cancelTcc提交失败");
    102.  
    103.         //实现中间件、非关系型数据库的回滚操作
    104.         log.info("Cancel阶段，ProductServiceImpl, cancelTcc this data: {}, {}", context.getActionContext("productId"), context.getActionContext("amount"));
    105.  
    106.         //进行数据库回滚处理
    107.         Integer productId = (Integer)context.getActionContext("productId");
    108.         Integer amount = (Integer)context.getActionContext("amount");
    109.         //把库存再加回去 (避免数据出问题，加个锁，分布式环境下就需要分布式锁)
    110.         productMapper.increaseStock(productId, amount);
    111.  
    112.         return true;
    113.     }
    114. }

    @LocalTCC注解

    标识此TCC为本地模式，即该事务是本地调用，非RPC调用

    @LocalTCC一定需要注解在接口上，此接口可以是寻常的业务接口，只要实现了TCC的两阶段提交对应方法即可

    @TwoPhaseBusinessAction注解

    标识为TCC模式，注解try方法，其中name为当前tcc方法的bean名称，写方法名便可（全局唯一），commitMethod指提交方法，rollbackMethod指事务回滚方法，指定好三个方法之后，Seata会根据事务的成功或失败，通过动态代理去帮我们自动调用提交或者回滚

    @BusinessActionContextParameter 注解

    将参数传递到二阶段（commitMethod/rollbackMethod）的方法

    seata-server-1.1.0.zip
    zip 0星 超过10%的资源 33.28MB
    下载

    BusinessActionContext

    指TCC事务上下文，携带了业务方法的参数

    二、Spring Cloud Alibaba的TCC分布式事务

    测试应用

    1、创建 4 个SpringBoot 模块

    （1）springcloud-alibaba-3-seata-tcc-commons

    1. <groupId>com.companygroupId>
    2.     <artifactId>springcloud-alibaba-3-seata-tcc-commonsartifactId>
    3.     <version>1.0.0version>
    4.  
    5.     <dependencies>
    6.         
    7.         <dependency>
    8.             <groupId>org.projectlombokgroupId>
    9.             <artifactId>lombokartifactId>
    10.             <version>1.18.16version>
    11.         dependency>
    12.  
    13.         
    14.         <dependency>
    15.             <groupId>org.springframework.cloudgroupId>
    16.             <artifactId>spring-cloud-starter-openfeignartifactId>
    17.             <version>3.0.0version>
    18.         dependency>
    19.  
    20.     dependencies>
    1. @FeignClient(name = "springcloud-alibaba-3-seata-tcc-account")
    2. public interface FeignAccountService {
    3.  
    4.     /**
    5.      * 扣除余额
    6.      *
    7.      * @param userId 用户ID
    8.      * @param money  扣减金额
    9.      * @throws Exception 失败时抛出异常
    10.      */
    11.     @PostMapping("/account/reduceBalance")
    12.     void reduceBalance(@RequestParam("userId") Integer userId, @RequestParam("money") BigDecimal money);
    13.  
    14. }
    15.  
    16.  
    17. @FeignClient(name = "springcloud-alibaba-3-seata-tcc-order")
    18. public interface FeignOrderService {
    19.  
    20.     /**
    21.      * 创建订单
    22.      *
    23.      * @param userId 用户ID
    24.      * @param productId 产品ID
    25.      * @return 订单编号
    26.      * @throws Exception 创建订单失败，抛出异常
    27.      */
    28.     Integer createOrder(Integer userId, Integer productId) throws Exception;
    29.  
    30. }
    31.  
    32. @FeignClient(name = "springcloud-alibaba-3-seata-tcc-product")
    33. public interface FeignProductService {
    34.  
    35.     /**
    36.      * 减库存
    37.      *
    38.      * @param productId 商品ID
    39.      * @param amount    扣减数量
    40.      * @throws Exception 扣减失败时抛出异常
    41.      */
    42.     @PostMapping("/product/reduceStock")
    43.     Product reduceStock(@RequestParam("productId") Integer productId, @RequestParam("amount") Integer amount);
    44. }

    （2）springcloud-alibaba-3-seata-tcc-order

    1. <groupId>com.companygroupId>
    2.     <artifactId>springcloud-alibaba-3-seata-tcc-orderartifactId>
    3.     <version>1.0.0version>
    4.  
    5.     <name>springcloud-alibaba-3-seata-tcc-ordername>
    6.     <description>Demo project for Spring Bootdescription>
    7.  
    8.     <properties>
    9.         <java.version>1.8java.version>
    10.         <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    11.         <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
    12.         <spring-boot.version>2.3.12.RELEASEspring-boot.version>
    13.         <spring-cloud-alibaba.version>2.2.7.RELEASEspring-cloud-alibaba.version>
    14.     properties>
    15.  
    16.     <dependencies>
    17.         <dependency>
    18.             <groupId>org.springframework.bootgroupId>
    19.             <artifactId>spring-boot-starter-webartifactId>
    20.         dependency>
    21.  
    22.         
    23.         <dependency>
    24.             <groupId>com.alibaba.cloudgroupId>
    25.             <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
    26.         dependency>
    27.  
    28.         <dependency>
    29.             <groupId>org.springframework.bootgroupId>
    30.             <artifactId>spring-boot-starter-testartifactId>
    31.             <scope>testscope>
    32.             <exclusions>
    33.                 <exclusion>
    34.                     <groupId>org.junit.vintagegroupId>
    35.                     <artifactId>junit-vintage-engineartifactId>
    36.                 exclusion>
    37.             exclusions>
    38.         dependency>
    39.  
    40.         <dependency>
    41.             <groupId>org.projectlombokgroupId>
    42.             <artifactId>lombokartifactId>
    43.         dependency>
    44.  
    45.         
    46.         <dependency>
    47.             <groupId>mysqlgroupId>
    48.             <artifactId>mysql-connector-javaartifactId>
    49.         dependency>
    50.  
    51.         
    52.         <dependency>
    53.             <groupId>org.mybatis.spring.bootgroupId>
    54.             <artifactId>mybatis-spring-boot-starterartifactId>
    55.             <version>2.1.3version>
    56.         dependency>
    57.  
    58.         
    59.         <dependency>
    60.             <groupId>com.alibaba.cloudgroupId>
    61.             <artifactId>spring-cloud-starter-alibaba-seataartifactId>
    62.             <exclusions>
    63.                 <exclusion>
    64.                     <groupId>io.seatagroupId>
    65.                     <artifactId>seata-spring-boot-starterartifactId>
    66.                 exclusion>
    67.             exclusions>
    68.         dependency>
    69.  
    70.         
    71.         <dependency>
    72.             <groupId>io.seatagroupId>
    73.             <artifactId>seata-spring-boot-starterartifactId>
    74.             <version>1.4.2version>
    75.         dependency>
    76.  
    77.         
    78.         <dependency>
    79.             <groupId>com.companygroupId>
    80.             <artifactId>springcloud-alibaba-3-seata-tcc-commonsartifactId>
    81.             <version>1.0.0version>
    82.         dependency>
    83.  
    84.     dependencies>
    85.  
    86.     
    87.     <dependencyManagement>
    88.         <dependencies>
    89.             <dependency>
    90.                 <groupId>com.alibaba.cloudgroupId>
    91.                 <artifactId>spring-cloud-alibaba-dependenciesartifactId>
    92.                 <version>${spring-cloud-alibaba.version}version>
    93.                 <type>pomtype>
    94.                 <scope>importscope>
    95.             dependency>
    96.             
    97.             <dependency>
    98.                 <groupId>org.springframework.cloudgroupId>
    99.                 <artifactId>spring-cloud-dependenciesartifactId>
    100.                 <version>Hoxton.SR12version>
    101.                 <type>pomtype>
    102.                 <scope>importscope>
    103.             dependency>
    104.             <dependency>
    105.                 <groupId>org.springframework.bootgroupId>
    106.                 <artifactId>spring-boot-dependenciesartifactId>
    107.                 <version>${spring-boot.version}version>
    108.                 <type>pomtype>
    109.                 <scope>importscope>
    110.             dependency>
    111.         dependencies>
    112.     dependencyManagement>
    113.  
    114.     <build>
    115.         <plugins>
    116.             <plugin>
    117.                 <groupId>org.apache.maven.pluginsgroupId>
    118.                 <artifactId>maven-compiler-pluginartifactId>
    119.                 <version>3.8.1version>
    120.                 <configuration>
    121.                     <source>1.8source>
    122.                     <target>1.8target>
    123.                     <encoding>UTF-8encoding>
    124.                 configuration>
    125.             plugin>
    126.             <plugin>
    127.                 <groupId>org.springframework.bootgroupId>
    128.                 <artifactId>spring-boot-maven-pluginartifactId>
    129.             plugin>
    130.         plugins>
    131.  
    132.         <resources>
    133.             <resource>
    134.                 <directory>src/main/javadirectory>
    135.                 <includes>
    136.                     <include>**/*.xmlinclude>
    137.                 includes>
    138.             resource>
    139.             <resource>
    140.                 <directory>src/main/resourcesdirectory>
    141.                 <includes>
    142.                     <include>**/*.*include>
    143.                 includes>
    144.             resource>
    145.         resources>
    146.     build>
    1. @Slf4j
    2. @RestController
    3. public class OrderController {
    4.  
    5.     @Autowired
    6.     private OrderService orderService;
    7.  
    8.     /**
    9.      * 下单操作，发起分布式事务
    10.      *
    11.      * @param userId
    12.      * @param productId
    13.      * @return
    14.      * @throws Exception
    15.      */
    16.     @RequestMapping("/order")
    17.     public Integer createOrder(@RequestParam("userId") Integer userId,
    18.                                @RequestParam("productId") Integer productId) throws Exception {
    19.  
    20.         log.info("[createOrder] 请求下单, 用户:{}, 商品:{}", userId, productId);
    21.  
    22.         return orderService.createOrder(userId, productId);
    23.     }
    24. }
    25.  
    26.  
    27. @Slf4j
    28. @Service
    29. public class OrderServiceImpl implements OrderService {
    30.  
    31.     @Autowired
    32.     private OrdersMapper ordersMapper;
    33.  
    34.     @Autowired
    35.     private FeignProductService feignProductService;
    36.  
    37.     @Autowired
    38.     private FeignAccountService feignAccountService;
    39.  
    40.     @Override
    41.     @GlobalTransactional //seata全局事务注解， TM 分布式全局事务发起者
    42.     public Integer createOrder(Integer userId, Integer productId) {
    43.         Integer amount = 1; // 购买数量，暂时设为 1
    44.  
    45.         log.info("[createOrder] 当前 XID: {}", RootContext.getXID());
    46.  
    47.         // 减库存 （feign的调用） http远程调用
    48.         Product product = feignProductService.reduceStock(productId, amount);
    49.  
    50.         // 减余额
    51.         feignAccountService.reduceBalance(userId, product.getPrice());
    52.  
    53.         // 下订单
    54.         Orders order = new Orders();
    55.         order.setUserId(userId);
    56.         order.setProductId(productId);
    57.         order.setPayAmount(product.getPrice().multiply(new BigDecimal(amount)));
    58.  
    59.         ordersMapper.insertSelective(order);
    60.  
    61.         log.info("[createOrder] 下订单: {}", order.getId());
    62.  
    63.         int a = 10 / 0;
    64.  
    65.         // 返回订单编号
    66.         return order.getId();
    67.     }
    68. }

    （3）springcloud-alibaba-3-seata-tcc-product

    1. @LocalTCC
    2. public interface ProductService {
    3.  
    4.     /**
    5.      * 减库存
    6.      *
    7.      * 定义两阶段提交
    8.      * name = reduceStock为一阶段try方法
    9.      * commitMethod = commitTcc 为二阶段确认方法
    10.      * rollbackMethod = cancel 为二阶段取消方法
    11.      * BusinessActionContextParameter注解 可传递参数到二阶段方法
    12.      *
    13.      * @param productId 商品ID
    14.      * @param amount    扣减数量
    15.      * @throws Exception 扣减失败时抛出异常
    16.      */
    17.     @TwoPhaseBusinessAction(name = "reduceStock", commitMethod = "commitTcc", rollbackMethod = "cancelTcc")
    18.     Product reduceStock(@BusinessActionContextParameter(paramName = "productId") Integer productId,
    19.                         @BusinessActionContextParameter(paramName = "amount") Integer amount);
    20.  
    21.     /**
    22.      * 确认方法、可以另命名，但要保证与commitMethod一致
    23.      * context可以传递try方法的参数
    24.      *
    25.      * @param context 上下文
    26.      * @return boolean
    27.      */
    28.     boolean commitTcc(BusinessActionContext context);
    29.  
    30.     /**
    31.      * 二阶段取消方法
    32.      *
    33.      * @param context 上下文
    34.      * @return boolean
    35.      */
    36.     boolean cancelTcc(BusinessActionContext context);
    37.  
    38. }
    39.  
    40.  
    41. @Slf4j
    42. @Service
    43. public class ProductServiceImpl implements ProductService {
    44.  
    45.     @Autowired
    46.     private ProductMapper productMapper;
    47.  
    48.     /**
    49.      * tcc服务（try）方法
    50.      * 也是实际业务方法
    51.      *
    52.      * @param productId 商品ID
    53.      * @param amount    扣减数量
    54.      * @return
    55.      */
    56.     @Override
    57.     public Product reduceStock(Integer productId, Integer amount) {
    58.         log.info("[reduceStock] 当前 XID: {}", RootContext.getXID());
    59.  
    60.         // 检查库存
    61.         Product product = productMapper.selectByPrimaryKey(productId);
    62.         if (product.getStock() < amount) {
    63.             throw new RuntimeException("库存不足");
    64.         }
    65.  
    66.         // 减库存
    67.         int updateCount = productMapper.reduceStock(productId, amount);
    68.         // 减库存失败
    69.         if (updateCount == 0) {
    70.             throw new RuntimeException("库存不足");
    71.         }
    72.  
    73.         // 减库存成功
    74.         log.info("减库存 {} 库存成功", productId);
    75.  
    76.         return product;
    77.     }
    78.  
    79.     /**
    80.      * tcc服务（confirm）方法
    81.      * 可以空确认
    82.      *
    83.      * @param context 上下文
    84.      * @return boolean
    85.      */
    86.     @Override
    87.     public boolean commitTcc(BusinessActionContext context) {
    88.         log.info("Confirm阶段，ProductServiceImpl, commitTcc --> xid = " + context.getXid() + ", commitTcc提交成功");
    89.         return true;
    90.     }
    91.  
    92.     /**
    93.      * tcc服务（cancel）方法
    94.      *
    95.      * @param context 上下文
    96.      * @return boolean
    97.      */
    98.     @Override
    99.     public boolean cancelTcc(BusinessActionContext context) {
    100.         log.info("Cancel阶段，ProductServiceImpl, cancelTcc --> xid = " + context.getXid() + ", cancelTcc提交失败");
    101.         //TODO 这里可以实现中间件、非关系型数据库的回滚操作
    102.         log.info("Cancel阶段，ProductServiceImpl, cancelTcc this data: {}, {}", context.getActionContext("productId"), context.getActionContext("amount"));
    103.  
    104.         //进行数据库回滚处理
    105.         Integer productId = (Integer)context.getActionContext("productId");
    106.         Integer amount = (Integer)context.getActionContext("amount");
    107.  
    108.         //把库存再加回去
    109.         productMapper.increaseStock(productId, amount);
    110.  
    111.         return true;
    112.     }
    113. }

    （4）springcloud-alibaba-3-seata-tcc-account

    1. @LocalTCC
    2. public interface AccountService {
    3.  
    4.     /**
    5.      * 扣除余额
    6.      * 定义两阶段提交
    7.      * name = reduceStock为一阶段try方法
    8.      * commitMethod = commitTcc 为二阶段确认方法
    9.      * rollbackMethod = cancel 为二阶段取消方法
    10.      * BusinessActionContextParameter注解 可传递参数到二阶段方法
    11.      *
    12.      * @param userId 用户ID
    13.      * @param money  扣减金额
    14.      * @throws Exception 失败时抛出异常
    15.      */
    16.     @TwoPhaseBusinessAction(name = "reduceBalance", commitMethod = "commitTcc", rollbackMethod = "cancelTcc")
    17.     void reduceBalance(@BusinessActionContextParameter(paramName = "userId") Integer userId,
    18.                        @BusinessActionContextParameter(paramName = "money") BigDecimal money);
    19.  
    20.     /**
    21.      * 确认方法、可以另命名，但要保证与commitMethod一致
    22.      * context可以传递try方法的参数
    23.      *
    24.      * @param context 上下文
    25.      * @return boolean
    26.      */
    27.     boolean commitTcc(BusinessActionContext context);
    28.  
    29.     /**
    30.      * 二阶段取消方法
    31.      *
    32.      * @param context 上下文
    33.      * @return boolean
    34.      */
    35.     boolean cancelTcc(BusinessActionContext context);
    36. }
    37.  
    38.  
    39. @Slf4j
    40. @Service
    41. public class AccountServiceImpl implements AccountService {
    42.  
    43.     @Autowired
    44.     private AccountMapper accountMapper;
    45.  
    46.     @Override
    47.     public void reduceBalance(Integer userId, BigDecimal money) {
    48.         log.info("[reduceBalance] 当前 XID: {}", RootContext.getXID());
    49.  
    50.         // 检查余额
    51.         Account account = accountMapper.selectAccountByUserId(userId);
    52.         if (account.getBalance().doubleValue() < money.doubleValue()) {
    53.             throw new RuntimeException("余额不足");
    54.         }
    55.  
    56.         // 扣除余额
    57.         int updateCount = accountMapper.reduceBalance(userId, money);
    58.         // 扣除成功
    59.         if (updateCount == 0) {
    60.             throw new RuntimeException("余额不足");
    61.         }
    62.         log.info("[reduceBalance] 扣除用户 {} 余额成功", userId);
    63.     }
    64.  
    65.     /**
    66.      * tcc服务（confirm）方法
    67.      * 可以空确认
    68.      *
    69.      * @param context 上下文
    70.      * @return boolean
    71.      */
    72.     @Override
    73.     public boolean commitTcc(BusinessActionContext context) {
    74.         log.info("Confirm阶段，AccountServiceImpl, commitTcc --> xid = {}", context.getXid() + ", commitTcc提交成功");
    75.         return true;
    76.     }
    77.  
    78.     /**
    79.      * tcc服务（cancel）方法
    80.      *
    81.      * @param context 上下文
    82.      * @return boolean
    83.      */
    84.     @Override
    85.     public boolean cancelTcc(BusinessActionContext context) {
    86.         log.info("Cancel阶段，AccountServiceImpl, cancelTcc --> xid = " + context.getXid() + ", cancelTcc提交失败");
    87.         //TODO 这里可以实现中间件、非关系型数据库的回滚操作
    88.         log.info("Cancel阶段，AccountServiceImpl, cancelTcc this data: userId= {}, money = {}", context.getActionContext("userId"), context.getActionContext("money"));
    89.  
    90.         //进行数据库回滚处理
    91.         Integer userId = (Integer)context.getActionContext("userId");
    92.         BigDecimal money = (BigDecimal)context.getActionContext("money");
    93.  
    94.         //幂等性问题
    95.  
    96.         //把余额再加回去
    97.         accountMapper.increaseBalance(userId, money);
    98.  
    99.         return true;
    100.     }
    101. }
  • 相关阅读:
    PY32F002A系列单片机：高性价比、低功耗，满足多样化应用需求
    【Linux-Windows】简述IPv4子网掩码网关和DNS
    Super easy to understand decision trees (part one）
    FILE类与IO流
    SpringBoot笔记：SpringBoot集成MyBatisPlus、Sqlite实战
    CSP-S初赛基础知识整理
    uni-app：js实现数组中的相关处理
    【Hadoop】学习笔记（四）
    代码随想录算法训练营第46天| 单词拆分，背包问题总结
    【若依(ruoyi)】ztree初始化
  • 原文地址：https://blog.csdn.net/MinggeQingchun/article/details/126240085