登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 业界 ›Spring Cloud分布式事务（基于Seata AT模式，集成Nacos ...

Spring Cloud分布式事务（基于Seata AT模式，集成Nacos）--学习版

米嘉怡 2025-11-27 12:10:00
程序园永久vip申请，500美金$，无限下载程序园所有程序/软件/数据/等
Spring Cloud分布式事务快速上手（基于Seata AT模式，集成Nacos）--学习版

前言

  对于从未接触过Seata的同学来说，想要快速上手Seata还是需要花费比较长的时间，因为本身微服务开发中环境的搭建、以及各种配置都已经很繁琐了，然后再集成Seata，Seata又有许多配置，对于每个微服务来说，针对Seata又有一些配置，要搞清楚各种配置之间的关系，对于像我这样的小白来说，着实不是一件容易的事。但Seata作为分布式事务的关键解决方案，在微服务架构中起着至关重要的作用。接下来，我将结合自身小白学习踩坑的过程，为大家介绍Seata的实操步骤，帮助大家少走弯路。
依赖的相关环境及组件

  为了方便像我这样的小白快速上手，我只能踩着巨人的肩膀前进，本文中相关demo基本参考ruoyi-cloud官方文档中的示例（能参考别人的代码千万别自己动手写），只做了部分改造，方便验证；同时，微服务环境框架也是直接用的ruoyi-cloud，感谢每一位开源前辈无私无畏的奉献。
组件版本    ruoyi-cloud        v3.6.6        Seata        1.4.0        Nacos        2.5.0    部署Seata-server（集成Nacos）

下载Seata-server

  可以从GitHub仓库https://github.com/apache/incubator-seata/releases下载各版本的Seata-server（直达链接：Seata-server各Releases版本）。Windows下载解压后（.zip），直接点击bin/seata-server.bat就可以启动。
配置Seata-server，集成Nacos

  使用Nacos作为注册中心及配置中心，需要修改Seata目录下conf/registry.con中的相关配置。由于使用Nacos作为注册中心，所以conf目录下的file.conf无需理会。主要修改两个地方，一个是registry.type改为nacos(默认是file)，另一个是config.type改为nacos（默认是file）；当然，registry.nacos，和config.nacos中需要修改成自己的环境，例如Nacos地址：127.0.0.1:8848，以及username和password，修改完成后，Seata-server就会使用Nacos作为注册中心和配置中心。
  1. registry {
  2.   # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
  3.   type = "nacos"
  4.   loadBalance = "RandomLoadBalance"
  5.   loadBalanceVirtualNodes = 10
  7.   nacos {
  8.     application = "seata-server"
  9.     serverAddr = "127.0.0.1:8848"
  10.     group = "SEATA_GROUP"
  11.     namespace = ""
  12.     cluster = "default"
  13.     username = ""
  14.     password = ""
  15.   }
  16.   eureka {
  17.     serviceUrl = "http://localhost:8761/eureka"
  18.     application = "default"
  19.     weight = "1"
  20.   }
  21.   redis {
  22.     serverAddr = "localhost:6379"
  23.     db = 0
  24.     password = ""
  25.     cluster = "default"
  26.     timeout = 0
  27.   }
  28.   zk {
  29.     cluster = "default"
  30.     serverAddr = "127.0.0.1:2181"
  31.     sessionTimeout = 6000
  32.     connectTimeout = 2000
  33.     username = ""
  34.     password = ""
  35.   }
  36.   consul {
  37.     cluster = "default"
  38.     serverAddr = "127.0.0.1:8500"
  39.   }
  40.   etcd3 {
  41.     cluster = "default"
  42.     serverAddr = "http://localhost:2379"
  43.   }
  44.   sofa {
  45.     serverAddr = "127.0.0.1:9603"
  46.     application = "default"
  47.     region = "DEFAULT_ZONE"
  48.     datacenter = "DefaultDataCenter"
  49.     cluster = "default"
  50.     group = "SEATA_GROUP"
  51.     addressWaitTime = "3000"
  52.   }
  53.   file {
  54.     name = "file.conf"
  55.   }
  56. }
  58. config {
  59.   # file、nacos 、apollo、zk、consul、etcd3
  60.   type = "nacos"
  62.   nacos {
  63.     serverAddr = "127.0.0.1:8848"
  64.     namespace = ""
  65.     group = "SEATA_GROUP"
  66.     username = ""
  67.     password = ""
  68.   }
  69.   consul {
  70.     serverAddr = "127.0.0.1:8500"
  71.   }
  72.   apollo {
  73.     appId = "seata-server"
  74.     apolloMeta = "http://192.168.1.204:8801"
  75.     namespace = "application"
  76.     apolloAccesskeySecret = ""
  77.   }
  78.   zk {
  79.     serverAddr = "127.0.0.1:2181"
  80.     sessionTimeout = 6000
  81.     connectTimeout = 2000
  82.     username = ""
  83.     password = ""
  84.   }
  85.   etcd3 {
  86.     serverAddr = "http://localhost:2379"
  87.   }
  88.   file {
  89.     name = "file.conf"
  90.   }
  91. }
复制代码
上传配置至Nacos配置中心

  在Nacos中新建配置，dataId为seataServer.properties，group为SEATA_GROUP（与Seata-server中config.nacos.group一致），配置内容参考https://github.com/apache/incubator-seata/tree/develop/script/config-center的config.txt并按需修改保存（直达链接：配置中心内容）。若不想手动复制，也可使用该链接目录下/nacos/nacos-config.sh或/nacos/nacos-config.py脚本导入到Nacos，这里主要修改两个地方，同时，由于后边将会搭建三个测试微服，这里需增加事务分组的配置（事务分组的具体解释请参考Seata官网https://seata.apache.org/zh-cn/docs/v1.4/user/txgroup/transaction-group）：
  如下修改为db,分布式事务的核心数据存储至数据库
  store.mode=db
  store.lock.mode=db
  store.session.mode=db
  以及配置数据库连接信息
  store.db.driverClassName
  store.db.url
  store.db.user       
  store.db.password
  增加事务分组配置，每个服务一个，一般都采用将key 值设置为服务端的服务名，有多少个微服务就添加多少行。
  #后边会搭建账户、商品、订单三个测试微服务，这配置每个微服务的事务分组
  service.vgroupMapping.ruoyi-account-group=default
  service.vgroupMapping.ruoyi-order-group=default
  service.vgroupMapping.ruoyi-product-group=default
  1. #事务分组配置
  2. service.vgroupMapping.ruoyi-account-group=default
  3. service.vgroupMapping.ruoyi-order-group=default
  4. service.vgroupMapping.ruoyi-product-group=default
  6. #For details about configuration items, see https://seata.io/zh-cn/docs/user/configurations.html
  7. #Transport configuration, for client and server
  8. transport.type=TCP
  9. transport.server=NIO
  10. transport.heartbeat=true
  11. transport.enableTmClientBatchSendRequest=false
  12. transport.enableRmClientBatchSendRequest=true
  13. transport.enableTcServerBatchSendResponse=false
  14. transport.rpcRmRequestTimeout=30000
  15. transport.rpcTmRequestTimeout=30000
  16. transport.rpcTcRequestTimeout=30000
  17. transport.threadFactory.bossThreadPrefix=NettyBoss
  18. transport.threadFactory.workerThreadPrefix=NettyServerNIOWorker
  19. transport.threadFactory.serverExecutorThreadPrefix=NettyServerBizHandler
  20. transport.threadFactory.shareBossWorker=false
  21. transport.threadFactory.clientSelectorThreadPrefix=NettyClientSelector
  22. transport.threadFactory.clientSelectorThreadSize=1
  23. transport.threadFactory.clientWorkerThreadPrefix=NettyClientWorkerThread
  24. transport.threadFactory.bossThreadSize=1
  25. transport.threadFactory.workerThreadSize=default
  26. transport.shutdown.wait=3
  27. transport.serialization=seata
  28. transport.compressor=none
  30. #Transaction routing rules configuration, only for the client
  31. service.vgroupMapping.default_tx_group=default
  32. #If you use a registry, you can ignore it
  33. service.default.grouplist=127.0.0.1:8091
  34. service.enableDegrade=false
  35. service.disableGlobalTransaction=false
  37. #Transaction rule configuration, only for the client
  38. client.rm.asyncCommitBufferLimit=10000
  39. client.rm.lock.retryInterval=10
  40. client.rm.lock.retryTimes=30
  41. client.rm.lock.retryPolicyBranchRollbackOnConflict=true
  42. client.rm.reportRetryCount=5
  43. client.rm.tableMetaCheckEnable=true
  44. client.rm.tableMetaCheckerInterval=60000
  45. client.rm.sqlParserType=druid
  46. client.rm.reportSuccessEnable=false
  47. client.rm.sagaBranchRegisterEnable=false
  48. client.rm.sagaJsonParser=fastjson
  49. client.rm.tccActionInterceptorOrder=-2147482648
  50. client.tm.commitRetryCount=5
  51. client.tm.rollbackRetryCount=5
  52. client.tm.defaultGlobalTransactionTimeout=60000
  53. client.tm.degradeCheck=false
  54. client.tm.degradeCheckAllowTimes=10
  55. client.tm.degradeCheckPeriod=2000
  56. client.tm.interceptorOrder=-2147482648
  57. client.undo.dataValidation=true
  58. client.undo.logSerialization=jackson
  59. client.undo.onlyCareUpdateColumns=true
  60. server.undo.logSaveDays=7
  61. server.undo.logDeletePeriod=86400000
  62. client.undo.logTable=undo_log
  63. client.undo.compress.enable=true
  64. client.undo.compress.type=zip
  65. client.undo.compress.threshold=64k
  66. #For TCC transaction mode
  67. tcc.fence.logTableName=tcc_fence_log
  68. tcc.fence.cleanPeriod=1h
  70. #Log rule configuration, for client and server
  71. log.exceptionRate=100
  73. #Transaction storage configuration, only for the server. The file, db, and redis configuration values are optional.
  74. # 修改为db,分布式事务的核心数据存储至数据库
  75. store.mode=db
  76. store.lock.mode=db
  77. store.session.mode=db
  78. #Used for password encryption
  79. store.publicKey=
  81. #If `store.mode,store.lock.mode,store.session.mode` are not equal to `file`, you can remove the configuration block.
  82. store.file.dir=file_store/data
  83. store.file.maxBranchSessionSize=16384
  84. store.file.maxGlobalSessionSize=512
  85. store.file.fileWriteBufferCacheSize=16384
  86. store.file.flushDiskMode=async
  87. store.file.sessionReloadReadSize=100
  89. #These configurations are required if the `store mode` is `db`. If `store.mode,store.lock.mode,store.session.mode` are not equal to `db`, you can remove the configuration block.
  90. store.db.datasource=druid
  91. store.db.dbType=mysql
  92. store.db.driverClassName=com.mysql.jdbc.Driver
  93. # 配置数据库连接信息
  94. store.db.url=jdbc:mysql://127.0.0.1:3306/seata?useUnicode=true&rewriteBatchedStatements=true
  95. store.db.user=username
  96. store.db.password=password
  97. store.db.minConn=5
  98. store.db.maxConn=30
  99. store.db.globalTable=global_table
  100. store.db.branchTable=branch_table
  101. store.db.distributedLockTable=distributed_lock
  102. store.db.queryLimit=100
  103. store.db.lockTable=lock_table
  104. store.db.maxWait=5000
  106. #These configurations are required if the `store mode` is `redis`. If `store.mode,store.lock.mode,store.session.mode` are not equal to `redis`, you can remove the configuration block.
  107. store.redis.mode=single
  108. store.redis.single.host=127.0.0.1
  109. store.redis.single.port=6379
  110. store.redis.sentinel.masterName=
  111. store.redis.sentinel.sentinelHosts=
  112. store.redis.sentinel.sentinelPassword=
  113. store.redis.maxConn=10
  114. store.redis.minConn=1
  115. store.redis.maxTotal=100
  116. store.redis.database=0
  117. store.redis.password=
  118. store.redis.queryLimit=100
  120. #Transaction rule configuration, only for the server
  121. server.recovery.committingRetryPeriod=1000
  122. server.recovery.asynCommittingRetryPeriod=1000
  123. server.recovery.rollbackingRetryPeriod=1000
  124. server.recovery.timeoutRetryPeriod=1000
  125. server.maxCommitRetryTimeout=-1
  126. server.maxRollbackRetryTimeout=-1
  127. server.rollbackFailedUnlockEnable=false
  128. server.distributedLockExpireTime=10000
  129. server.xaerNotaRetryTimeout=60000
  130. server.session.branchAsyncQueueSize=5000
  131. server.session.enableBranchAsyncRemove=false
  132. server.enableParallelRequestHandle=false
  134. #Metrics configuration, only for the server
  135. metrics.enabled=false
  136. metrics.registryType=compact
  137. metrics.exporterList=prometheus
  138. metrics.exporterPrometheusPort=9898
复制代码
导入Seata-server所需SQL

  前面我们已经配置了Seata使用mysql作为db高可用数据库(store.mode=db)，故需要在mysql创建一个seata库(store.db.url中配置的库名)，并导入数据库脚本。可以从GitHub仓库https://github.com/apache/incubator-seata/blob/develop/script/server/db下载不同数据库的SQL脚本（直达链接：mysql数据库脚本），下载后将SQL导入数据库中。
  1. -- -------------------------------- The script used when storeMode is 'db' --------------------------------
  2. -- the table to store GlobalSession data
  3. CREATE TABLE IF NOT EXISTS `global_table`
  4. (
  5.     `xid`                       VARCHAR(128) NOT NULL,
  6.     `transaction_id`            BIGINT,
  7.     `status`                    TINYINT      NOT NULL,
  8.     `application_id`            VARCHAR(32),
  9.     `transaction_service_group` VARCHAR(32),
  10.     `transaction_name`          VARCHAR(128),
  11.     `timeout`                   INT,
  12.     `begin_time`                BIGINT,
  13.     `application_data`          VARCHAR(2000),
  14.     `gmt_create`                DATETIME,
  15.     `gmt_modified`              DATETIME,
  16.     PRIMARY KEY (`xid`),
  17.     KEY `idx_status_gmt_modified` (`status` , `gmt_modified`),
  18.     KEY `idx_transaction_id` (`transaction_id`)
  19. ) ENGINE = InnoDB
  20.   DEFAULT CHARSET = utf8mb4;
  22. -- the table to store BranchSession data
  23. CREATE TABLE IF NOT EXISTS `branch_table`
  24. (
  25.     `branch_id`         BIGINT       NOT NULL,
  26.     `xid`               VARCHAR(128) NOT NULL,
  27.     `transaction_id`    BIGINT,
  28.     `resource_group_id` VARCHAR(32),
  29.     `resource_id`       VARCHAR(256),
  30.     `branch_type`       VARCHAR(8),
  31.     `status`            TINYINT,
  32.     `client_id`         VARCHAR(64),
  33.     `application_data`  VARCHAR(2000),
  34.     `gmt_create`        DATETIME(6),
  35.     `gmt_modified`      DATETIME(6),
  36.     PRIMARY KEY (`branch_id`),
  37.     KEY `idx_xid` (`xid`)
  38. ) ENGINE = InnoDB
  39.   DEFAULT CHARSET = utf8mb4;
  41. -- the table to store lock data
  42. CREATE TABLE IF NOT EXISTS `lock_table`
  43. (
  44.     `row_key`        VARCHAR(128) NOT NULL,
  45.     `xid`            VARCHAR(128),
  46.     `transaction_id` BIGINT,
  47.     `branch_id`      BIGINT       NOT NULL,
  48.     `resource_id`    VARCHAR(256),
  49.     `table_name`     VARCHAR(32),
  50.     `pk`             VARCHAR(36),
  51.     `status`         TINYINT      NOT NULL DEFAULT '0' COMMENT '0:locked ,1:rollbacking',
  52.     `gmt_create`     DATETIME,
  53.     `gmt_modified`   DATETIME,
  54.     PRIMARY KEY (`row_key`),
  55.     KEY `idx_status` (`status`),
  56.     KEY `idx_branch_id` (`branch_id`),
  57.     KEY `idx_xid` (`xid`)
  58. ) ENGINE = InnoDB
  59.   DEFAULT CHARSET = utf8mb4;
  61. CREATE TABLE IF NOT EXISTS `distributed_lock`
  62. (
  63.     `lock_key`       CHAR(20) NOT NULL,
  64.     `lock_value`     VARCHAR(20) NOT NULL,
  65.     `expire`         BIGINT,
  66.     primary key (`lock_key`)
  67. ) ENGINE = InnoDB
  68.   DEFAULT CHARSET = utf8mb4;
  70. INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('AsyncCommitting', ' ', 0);
  71. INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('RetryCommitting', ' ', 0);
  72. INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('RetryRollbacking', ' ', 0);
  73. INSERT INTO `distributed_lock` (lock_key, lock_value, expire) VALUES ('TxTimeoutCheck', ' ', 0);
复制代码
  至此，Seata-server已经配置完成并且集成了Nacos,事务数据也存储在DB中。可以点击Seata目录下bin/seata-server.bat脚本启动Seata-server。
1.png

搭建测试微服务

创建测试库及表
  1. # 订单数据库信息 seata_order
  2. DROP DATABASE IF EXISTS seata_order;
  3. CREATE DATABASE seata_order;
  5. DROP TABLE IF EXISTS seata_order.p_order;
  6. CREATE TABLE seata_order.p_order
  7. (
  8.     id               INT(11) NOT NULL AUTO_INCREMENT,
  9.     user_id          INT(11) DEFAULT NULL,
  10.     product_id       INT(11) DEFAULT NULL,
  11.     amount           INT(11) DEFAULT NULL,
  12.     total_price      DOUBLE       DEFAULT NULL,
  13.     status           VARCHAR(100) DEFAULT NULL,
  14.     add_time         DATETIME     DEFAULT CURRENT_TIMESTAMP,
  15.     last_update_time DATETIME     DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  16.     PRIMARY KEY (id)
  17. ) ENGINE = InnoDB
  18.   AUTO_INCREMENT = 1
  19.   DEFAULT CHARSET = utf8mb4;
  21. DROP TABLE IF EXISTS seata_order.undo_log;
  22. CREATE TABLE seata_order.undo_log
  23. (
  24.     id            BIGINT(20) NOT NULL AUTO_INCREMENT,
  25.     branch_id     BIGINT(20) NOT NULL,
  26.     xid           VARCHAR(100) NOT NULL,
  27.     context       VARCHAR(128) NOT NULL,
  28.     rollback_info LONGBLOB     NOT NULL,
  29.     log_status    INT(11) NOT NULL,
  30.     log_created   DATETIME     NOT NULL,
  31.     log_modified  DATETIME     NOT NULL,
  32.     PRIMARY KEY (id),
  33.     UNIQUE KEY ux_undo_log (xid, branch_id)
  34. ) ENGINE = InnoDB
  35.   AUTO_INCREMENT = 1
  36.   DEFAULT CHARSET = utf8mb4;
  37.   
  38. # 产品数据库信息 seata_product
  39. DROP DATABASE IF EXISTS seata_product;
  40. CREATE DATABASE seata_product;
  42. DROP TABLE IF EXISTS seata_product.product;
  43. CREATE TABLE seata_product.product
  44. (
  45.     id               INT(11) NOT NULL AUTO_INCREMENT,
  46.     price            DOUBLE   DEFAULT NULL,
  47.     stock            INT(11) DEFAULT NULL,
  48.     last_update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  49.     PRIMARY KEY (id)
  50. ) ENGINE = InnoDB
  51.   AUTO_INCREMENT = 1
  52.   DEFAULT CHARSET = utf8mb4;
  54. DROP TABLE IF EXISTS seata_product.undo_log;
  55. CREATE TABLE seata_product.undo_log
  56. (
  57.     id            BIGINT(20) NOT NULL AUTO_INCREMENT,
  58.     branch_id     BIGINT(20) NOT NULL,
  59.     xid           VARCHAR(100) NOT NULL,
  60.     context       VARCHAR(128) NOT NULL,
  61.     rollback_info LONGBLOB     NOT NULL,
  62.     log_status    INT(11) NOT NULL,
  63.     log_created   DATETIME     NOT NULL,
  64.     log_modified  DATETIME     NOT NULL,
  65.     PRIMARY KEY (id),
  66.     UNIQUE KEY ux_undo_log (xid, branch_id)
  67. ) ENGINE = InnoDB
  68.   AUTO_INCREMENT = 1
  69.   DEFAULT CHARSET = utf8mb4;
  71. INSERT INTO seata_product.product (id, price, stock)
  72. VALUES (1, 10, 20);
  75. # 账户数据库信息 seata_account
  76. DROP DATABASE IF EXISTS seata_account;
  77. CREATE DATABASE seata_account;
  79. DROP TABLE IF EXISTS seata_account.account;
  80. CREATE TABLE seata_account.account
  81. (
  82.     id               INT(11) NOT NULL AUTO_INCREMENT,
  83.     balance          DOUBLE   DEFAULT NULL,
  84.     last_update_time DATETIME DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  85.     PRIMARY KEY (id)
  86. ) ENGINE = InnoDB
  87.   AUTO_INCREMENT = 1
  88.   DEFAULT CHARSET = utf8mb4;
  90. DROP TABLE IF EXISTS seata_account.undo_log;
  91. CREATE TABLE seata_account.undo_log
  92. (
  93.     id            BIGINT(20) NOT NULL AUTO_INCREMENT,
  94.     branch_id     BIGINT(20) NOT NULL,
  95.     xid           VARCHAR(100) NOT NULL,
  96.     context       VARCHAR(128) NOT NULL,
  97.     rollback_info LONGBLOB     NOT NULL,
  98.     log_status    INT(11) NOT NULL,
  99.     log_created   DATETIME     NOT NULL,
  100.     log_modified  DATETIME     NOT NULL,
  101.     PRIMARY KEY (id),
  102.     UNIQUE KEY ux_undo_log (xid, branch_id)
  103. ) ENGINE = InnoDB
  104.   AUTO_INCREMENT = 1
  105.   DEFAULT CHARSET = utf8mb4;
  106. INSERT INTO seata_account.account (id, balance)
  107. VALUES (1, 50);
复制代码
  其中，每个库中的undo_log表，是Seata AT模式必须创建的表，主要用于分支事务的回滚，undo_log表可以从GitHub仓库https://github.com/apache/incubator-seata/tree/develop/script/client/at/db下载不同数据库的SQL脚本（直达链接：mysql数据库脚本）。另外，考虑到测试方便，我们插入了一条id = 1的account记录，和一条id = 1的product记录。
搭建测试服务

搭建账户服务

  在ruoyi-modules新建一个Module：ruoyi-account，为了搭建方便，以及减少Maven依赖，pom依赖直接拷贝ruoyi-system中的依赖，然后新增Seata的依赖就可以了。
  ruoyi-account的pom.xml:
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.     <modelVersion>4.0.0</modelVersion>
  4.     <parent>
  5.         <groupId>com.ruoyi</groupId>
  6.         ruoyi-modules</artifactId>
  7.         <version>3.6.6</version>
  8.     </parent>
  10.     ruoyi-account</artifactId>
  11.     <packaging>jar</packaging>
  13.     <name>ruoyi-account</name>
  14.     <url>http://maven.apache.org</url>
  16.     <properties>
  17.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  18.     </properties>
  20.     <dependencies>
  21.         
  22.         <dependency>
  23.             <groupId>com.alibaba.cloud</groupId>
  24.             spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  25.         </dependency>
  27.         
  28.         <dependency>
  29.             <groupId>com.alibaba.cloud</groupId>
  30.             spring-cloud-starter-alibaba-nacos-config</artifactId>
  31.         </dependency>
  33.         
  34.         <dependency>
  35.             <groupId>com.alibaba.cloud</groupId>
  36.             spring-cloud-starter-alibaba-sentinel</artifactId>
  37.         </dependency>
  39.         
  40.         <dependency>
  41.             <groupId>org.springframework.boot</groupId>
  42.             spring-boot-starter-actuator</artifactId>
  43.         </dependency>
  45.         
  46.         <dependency>
  47.             <groupId>com.mysql</groupId>
  48.             mysql-connector-j</artifactId>
  49.         </dependency>
  51.         
  52.         <dependency>
  53.             <groupId>com.ruoyi</groupId>
  54.             ruoyi-common-datasource</artifactId>
  55.         </dependency>
  57.         
  58.         <dependency>
  59.             <groupId>com.ruoyi</groupId>
  60.             ruoyi-common-datascope</artifactId>
  61.         </dependency>
  63.         
  64.         <dependency>
  65.             <groupId>com.ruoyi</groupId>
  66.             ruoyi-common-log</artifactId>
  67.         </dependency>
  69.         
  70.         <dependency>
  71.             <groupId>com.ruoyi</groupId>
  72.             ruoyi-common-swagger</artifactId>
  73.         </dependency>
  75.         
  76.         <dependency>
  77.             <groupId>com.alibaba.cloud</groupId>
  78.             spring-cloud-starter-alibaba-seata</artifactId>
  79.         </dependency>
  81.         <dependency>
  82.             <groupId>org.projectlombok</groupId>
  83.             lombok</artifactId>
  84.         </dependency>
  87.     </dependencies>
  89.     <build>
  90.         <finalName>${project.artifactId}</finalName>
  91.         <plugins>
  92.             <plugin>
  93.                 <groupId>org.springframework.boot</groupId>
  94.                 spring-boot-maven-plugin</artifactId>
  95.                 <executions>
  96.                     <execution>
  97.                         <goals>
  98.                             <goal>repackage</goal>
  99.                         </goals>
  100.                     </execution>
  101.                 </executions>
  102.             </plugin>
  103.         </plugins>
  104.     </build>
  105. </project>
复制代码
  ruoyi-account的bootstrap.yml:
  1. # Tomcat
  2. server:
  3.   port: 10300
  5. # Spring
  6. spring:
  7.   application:
  8.     # 应用名称
  9.     name: ruoyi-account
  10.   profiles:
  11.     # 环境配置
  12.     active: dev
  13.   cloud:
  14.     nacos:
  15.       discovery:
  16.         # 服务注册地址
  17.         server-addr: 127.0.0.1:8848
  18.       config:
  19.         # 配置中心地址
  20.         server-addr: 127.0.0.1:8848
  21.         # 配置文件格式
  22.         file-extension: yml
  23.         # 共享配置
  24.         shared-configs:
  25.           - application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
  26. seata:
  27.   enabled: true
  28.   # Seata 应用编号，默认为 ${spring.application.name}
  29.   application-id: ${spring.application.name}
  30.   # Seata 事务组编号，用于 TC 集群名
  31.   tx-service-group: ${spring.application.name}-group
  32.   # 关闭自动代理
  33.   enable-auto-data-source-proxy: false
  34.   # 服务配置项
  35.   service:
  36.     # 虚拟组和分组的映射
  37.     vgroup-mapping:
  38.       ruoyi-account-group: default
  39.   config:
  40.     type: nacos
  41.     nacos:
  42.       serverAddr: 127.0.0.1:8848
  43.       group: SEATA_GROUP
  44.       namespace:
  45.       dataId: seataServer.properties
  46.   registry:
  47.     type: nacos
  48.     nacos:
  49.       application: seata-server
  50.       server-addr: 127.0.0.1:8848
  51.       namespace:
复制代码
  ruoyi-account的bootstrap.yml也是直接拷贝ruoyi-system中的bootstrap.yml，然后修改服务端口，服务名；为了演示方便，关于Seata的配置也直接写在了bootstrap.yml。
  ruoyi-account的ruoyi-account-dev.yml:
  1. # spring配置
  2. spring:
  3.   redis:
  4.     host: localhost
  5.     port: 6379
  6.     password:
  7.   datasource:
  8.     druid:
  9.       stat-view-servlet:
  10.         enabled: true
  11.         loginUsername: ruoyi
  12.         loginPassword: 123456
  13.     dynamic:
  14.       druid:
  15.         initial-size: 5
  16.         min-idle: 5
  17.         maxActive: 20
  18.         maxWait: 60000
  19.         connectTimeout: 30000
  20.         socketTimeout: 60000
  21.         timeBetweenEvictionRunsMillis: 60000
  22.         minEvictableIdleTimeMillis: 300000
  23.         validationQuery: SELECT 1 FROM DUAL
  24.         testWhileIdle: true
  25.         testOnBorrow: false
  26.         testOnReturn: false
  27.         poolPreparedStatements: true
  28.         maxPoolPreparedStatementPerConnectionSize: 20
  29.         filters: stat,slf4j
  30.         connectionProperties: druid.stat.mergeSql\=true;druid.stat.slowSqlMillis\=5000
  31.       datasource:
  32.           # 主库数据源
  33.           master:
  34.             driver-class-name: com.mysql.cj.jdbc.Driver
  35.             url: jdbc:mysql://localhost:3306/seata_account?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
  36.             username: root
  37.             password: root123
  38.           # 从库数据源
  39.           # slave:
  40.             # username:
  41.             # password:
  42.             # url:
  43.             # driver-class-name:
  44.       seata: true #开启seata代理，开启后默认每个数据源都代理，如果某个不需要代理可单独关闭
  46. # mybatis配置
  47. mybatis:
  48.     # 搜索指定包别名
  49.     typeAliasesPackage: com.ruoyi.account
  50.     # 配置mapper的扫描，找到所有的mapper.xml映射文件
  51.     mapperLocations: classpath:mapper/**/*.xml
  53. # springdoc配置
  54. springdoc:
  55.   gatewayUrl: http://localhost:8080/${spring.application.name}
  56.   api-docs:
  57.     # 是否开启接口文档
  58.     enabled: false
复制代码
  ruoyi-account的ruoyi-account-dev.yml也是直接拷贝ruoyi-system中的ruoyi-system-dev.yml，仅修改数据库连接信息，MyBatis扫描的包等，唯一比较重要的一点是动态数据源这里配置了seata:true，开启Seata代理。
  ruoyi-account示例代码:
  Account.java
  1. package com.ruoyi.account.domain;
  3. import lombok.Getter;
  4. import lombok.Setter;
  6. import java.util.Date;
  8. @Getter
  9. @Setter
  10. public class Account {
  12.     private Long id;
  14.     /**
  15.      * 余额
  16.      */
  17.     private Double balance;
  19.     private Date lastUpdateTime;
  21. }
复制代码
  AccountMapper.java
  1. package com.ruoyi.account.mapper;
  3. import com.ruoyi.account.domain.Account;
  5. public interface AccountMapper {
  6.     public Account selectById(Long userId);
  8.     public void updateById(Account account);
  9. }
复制代码
  AccountMapper.xml
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.ruoyi.account.mapper.AccountMapper">
  7.     <resultMap type="com.ruoyi.account.domain.Account" id="AccountResult">
  8.         <id     property="id"              column="id"                />
  9.         <result property="balance"         column="balance"           />
  10.         <result property="lastUpdateTime"  column="last_update_time"  />
  11.     </resultMap>
  13.     <select id="selectById" parameterType="com.ruoyi.account.domain.Account" resultMap="AccountResult">
  14.         select id, balance, last_update_time
  15.         from account where id = #{userId}
  16.     </select>
  18.     <update id="updateById" parameterType="com.ruoyi.account.domain.Account">
  19.         update account set balance = #{balance}, last_update_time = sysdate() where id = #{id}
  20.     </update>
  22. </mapper>
复制代码
  AccountService.java
  1. package com.ruoyi.account.service;
  3. public interface AccountService {
  4.     /**
  5.      * 账户扣减
  6.      * @param userId 用户 ID
  7.      * @param price 扣减金额
  8.      */
  9.     void reduceBalance(Long userId, Double price);
  10. }
复制代码
  AccountServiceImpl.java
  1. package com.ruoyi.account.service.impl;
  3. import javax.annotation.Resource;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.stereotype.Service;
  7. import org.springframework.transaction.annotation.Propagation;
  8. import org.springframework.transaction.annotation.Transactional;
  9. import com.baomidou.dynamic.datasource.annotation.DS;
  10. import com.ruoyi.account.domain.Account;
  11. import com.ruoyi.account.mapper.AccountMapper;
  12. import com.ruoyi.account.service.AccountService;
  13. import io.seata.core.context.RootContext;
  15. @Service
  16. public class AccountServiceImpl implements AccountService
  17. {
  18.     private static final Logger log = LoggerFactory.getLogger(AccountServiceImpl.class);
  19.    
  20.     @Resource
  21.     private AccountMapper accountMapper;
  23.     /**
  24.      * 事务传播特性设置为 REQUIRES_NEW 开启新的事务 重要！！！！一定要使用REQUIRES_NEW
  25.      * 在若依的示例中，事务的传播特性必须设置REQUIRES_NEW，但经本人测试，多服务调用事务
  26.      * 设置成默认的REQUIRED也能回滚成功
  27.      */
  28.     @Override
  29.     @Transactional
  30.     public void reduceBalance(Long userId, Double price)
  31.     {
  32.         log.info("=============ACCOUNT START=================");
  33.         log.info("当前 XID: {}", RootContext.getXID());
  35.         Account account = accountMapper.selectById(userId);
  36.         Double balance = account.getBalance();
  37.         log.info("下单用户{}余额为 {},商品总价为{}", userId, balance, price);
  39.         if (balance < price)
  40.         {
  41.             log.warn("用户 {} 余额不足，当前余额:{}", userId, balance);
  42.             throw new RuntimeException("余额不足");
  43.         }
  44.         log.info("开始扣减用户 {} 余额", userId);
  45.         double currentBalance = account.getBalance() - price;
  46.         account.setBalance(currentBalance);
  47.         accountMapper.updateById(account);
  48.         log.info("扣减用户 {} 余额成功,扣减后用户账户余额为{}", userId, currentBalance);
  49.         log.info("=============ACCOUNT END=================");
  50.     }
  52. }
复制代码
  AccountController.java
  1. package com.ruoyi.account.controller;
  3. import com.ruoyi.account.dto.ReduceBalanceRequest;
  4. import com.ruoyi.account.service.AccountService;
  5. import com.ruoyi.common.core.domain.R;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.validation.annotation.Validated;
  8. import org.springframework.web.bind.annotation.PostMapping;
  9. import org.springframework.web.bind.annotation.RequestBody;
  10. import org.springframework.web.bind.annotation.RequestMapping;
  11. import org.springframework.web.bind.annotation.RestController;
  13. @RestController
  14. @RequestMapping("/account")
  15. public class AccountController {
  17.     @Autowired
  18.     private AccountService accountService;
  20.     @PostMapping("/reduceBalance")
  21.     public R reduceBalance(@Validated @RequestBody ReduceBalanceRequest request) {
  22.         accountService.reduceBalance(request.getUserId(), request.getPrice());
  23.         return R.ok("下单成功");
  24.     }
  25. }
复制代码
  ReduceBalanceRequest.java
  1. package com.ruoyi.account.dto;
  4. import lombok.AllArgsConstructor;
  5. import lombok.Getter;
  6. import lombok.NoArgsConstructor;
  7. import lombok.Setter;
  9. @Getter
  10. @Setter
  11. @NoArgsConstructor
  12. @AllArgsConstructor
  13. public class ReduceBalanceRequest {
  14.     private Long userId;
  16.     private Double price;
  17. }
复制代码
  至此，账户服务就搭建好了，这里主要提供一个扣减账户余额的接口。
搭建商品服务

  同样，在ruoyi-modules新建一个Module：ruoyi-product。
  ruoyi-product的pom.xml:
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.     <modelVersion>4.0.0</modelVersion>
  4.     <parent>
  5.         <groupId>com.ruoyi</groupId>
  6.         ruoyi-modules</artifactId>
  7.         <version>3.6.6</version>
  8.     </parent>
  10.     ruoyi-product</artifactId>
  11.     <packaging>jar</packaging>
  13.     <name>ruoyi-product</name>
  14.     <url>http://maven.apache.org</url>
  16.     <properties>
  17.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  18.     </properties>
  20.     <dependencies>
  21.         
  22.         <dependency>
  23.             <groupId>com.alibaba.cloud</groupId>
  24.             spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  25.         </dependency>
  27.         
  28.         <dependency>
  29.             <groupId>com.alibaba.cloud</groupId>
  30.             spring-cloud-starter-alibaba-nacos-config</artifactId>
  31.         </dependency>
  33.         
  34.         <dependency>
  35.             <groupId>com.alibaba.cloud</groupId>
  36.             spring-cloud-starter-alibaba-sentinel</artifactId>
  37.         </dependency>
  39.         
  40.         <dependency>
  41.             <groupId>org.springframework.boot</groupId>
  42.             spring-boot-starter-actuator</artifactId>
  43.         </dependency>
  45.         
  46.         <dependency>
  47.             <groupId>com.mysql</groupId>
  48.             mysql-connector-j</artifactId>
  49.         </dependency>
  51.         
  52.         <dependency>
  53.             <groupId>com.ruoyi</groupId>
  54.             ruoyi-common-datasource</artifactId>
  55.         </dependency>
  57.         
  58.         <dependency>
  59.             <groupId>com.ruoyi</groupId>
  60.             ruoyi-common-datascope</artifactId>
  61.         </dependency>
  63.         
  64.         <dependency>
  65.             <groupId>com.ruoyi</groupId>
  66.             ruoyi-common-log</artifactId>
  67.         </dependency>
  69.         
  70.         <dependency>
  71.             <groupId>com.ruoyi</groupId>
  72.             ruoyi-common-swagger</artifactId>
  73.         </dependency>
  75.         
  76.         <dependency>
  77.             <groupId>com.alibaba.cloud</groupId>
  78.             spring-cloud-starter-alibaba-seata</artifactId>
  79.         </dependency>
  81.         <dependency>
  82.             <groupId>org.projectlombok</groupId>
  83.             lombok</artifactId>
  84.         </dependency>
  85.     </dependencies>
  87.     <build>
  88.         <finalName>${project.artifactId}</finalName>
  89.         <plugins>
  90.             <plugin>
  91.                 <groupId>org.springframework.boot</groupId>
  92.                 spring-boot-maven-plugin</artifactId>
  93.                 <executions>
  94.                     <execution>
  95.                         <goals>
  96.                             <goal>repackage</goal>
  97.                         </goals>
  98.                     </execution>
  99.                 </executions>
  100.             </plugin>
  101.         </plugins>
  102.     </build>
  103. </project>
复制代码
  ruoyi-product的bootstrap.yml:
  1. # Tomcat
  2. server:
  3.   port: 10302
  5. # Spring
  6. spring:
  7.   application:
  8.     # 应用名称
  9.     name: ruoyi-product
  10.   profiles:
  11.     # 环境配置
  12.     active: dev
  13.   cloud:
  14.     nacos:
  15.       discovery:
  16.         # 服务注册地址
  17.         server-addr: 127.0.0.1:8848
  18.       config:
  19.         # 配置中心地址
  20.         server-addr: 127.0.0.1:8848
  21.         # 配置文件格式
  22.         file-extension: yml
  23.         # 共享配置
  24.         shared-configs:
  25.           - application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
  26. seata:
  27.   enabled: true
  28.   # Seata 应用编号，默认为 ${spring.application.name}
  29.   application-id: ${spring.application.name}
  30.   # Seata 事务组编号，用于 TC 集群名
  31.   tx-service-group: ${spring.application.name}-group
  32.   # 关闭自动代理
  33.   enable-auto-data-source-proxy: false
  34.   # 服务配置项
  35.   service:
  36.     # 虚拟组和分组的映射
  37.     vgroup-mapping:
  38.       ruoyi-product-group: default
  39.   config:
  40.     type: nacos
  41.     nacos:
  42.       serverAddr: 127.0.0.1:8848
  43.       group: SEATA_GROUP
  44.       namespace:
  45.       dataId: seataServer.properties
  46.   registry:
  47.     type: nacos
  48.     nacos:
  49.       application: seata-server
  50.       server-addr: 127.0.0.1:8848
  51.       namespace:
复制代码
  ruoyi-product的ruoyi-product-dev.yml:
  1. # spring配置
  2. spring:
  3.   redis:
  4.     host: localhost
  5.     port: 6379
  6.     password:
  7.   datasource:
  8.     druid:
  9.       stat-view-servlet:
  10.         enabled: true
  11.         loginUsername: ruoyi
  12.         loginPassword: 123456
  13.     dynamic:
  14.       druid:
  15.         initial-size: 5
  16.         min-idle: 5
  17.         maxActive: 20
  18.         maxWait: 60000
  19.         connectTimeout: 30000
  20.         socketTimeout: 60000
  21.         timeBetweenEvictionRunsMillis: 60000
  22.         minEvictableIdleTimeMillis: 300000
  23.         validationQuery: SELECT 1 FROM DUAL
  24.         testWhileIdle: true
  25.         testOnBorrow: false
  26.         testOnReturn: false
  27.         poolPreparedStatements: true
  28.         maxPoolPreparedStatementPerConnectionSize: 20
  29.         filters: stat,slf4j
  30.         connectionProperties: druid.stat.mergeSql\=true;druid.stat.slowSqlMillis\=5000
  31.       datasource:
  32.           # 主库数据源
  33.           master:
  34.             driver-class-name: com.mysql.cj.jdbc.Driver
  35.             url: jdbc:mysql://localhost:3306/seata_product?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
  36.             username: root
  37.             password: root123
  38.           # 从库数据源
  39.           # slave:
  40.             # username:
  41.             # password:
  42.             # url:
  43.             # driver-class-name:
  44.       seata: true
  46. # mybatis配置
  47. mybatis:
  48.     # 搜索指定包别名
  49.     typeAliasesPackage: com.ruoyi.product
  50.     # 配置mapper的扫描，找到所有的mapper.xml映射文件
  51.     mapperLocations: classpath:mapper/**/*.xml
  53. # springdoc配置
  54. springdoc:
  55.   gatewayUrl: http://localhost:8080/${spring.application.name}
  56.   api-docs:
  57.     # 是否开启接口文档
  58.     enabled: false
复制代码
  ruoyi-product示例代码:
  Product.java
  1. package com.ruoyi.product.domain;
  3. import lombok.Getter;
  4. import lombok.Setter;
  6. import java.util.Date;
  8. @Getter
  9. @Setter
  10. public class Product {
  12.     private Integer id;
  13.     /**
  14.      * 价格
  15.      */
  16.     private Double price;
  17.     /**
  18.      * 库存
  19.      */
  20.     private Integer stock;
  22.     private Date lastUpdateTime;
  24. }
复制代码
  ProductMapper.java
  1. package com.ruoyi.product.mapper;
  3. import com.ruoyi.product.domain.Product;
  5. public interface ProductMapper {
  6.     public Product selectById(Long productId);
  8.     public void updateById(Product product);
  9. }
复制代码
  ProductMapper.xml
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.ruoyi.product.mapper.ProductMapper">
  7.     <resultMap type="com.ruoyi.product.domain.Product" id="ProductResult">
  8.         <id     property="id"              column="id"                />
  9.         <result property="price"           column="price"             />
  10.         <result property="stock"           column="stock"             />
  11.         <result property="lastUpdateTime"  column="last_update_time"  />
  12.     </resultMap>
  14.     <select id="selectById" parameterType="com.ruoyi.product.domain.Product" resultMap="ProductResult">
  15.         select id, price, stock, last_update_time
  16.         from product where id = #{productId}
  17.     </select>
  19.     <update id="updateById" parameterType="com.ruoyi.product.domain.Product">
  20.         update product set price = #{price}, stock = #{stock}, last_update_time = sysdate() where id = #{id}
  21.     </update>
  23. </mapper>
复制代码
  ProductService.java
  1. package com.ruoyi.product.service;
  3. public interface ProductService {
  4.     /**
  5.      * 扣减库存
  6.      *
  7.      * @param productId 商品 ID
  8.      * @param amount 扣减数量
  9.      * @return 商品总价
  10.      */
  11.     Double reduceStock(Long productId, Integer amount);
  12. }
复制代码
  ProductServiceImpl.java
  1. package com.ruoyi.product.service.impl;
  3. import javax.annotation.Resource;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.stereotype.Service;
  7. import org.springframework.transaction.annotation.Propagation;
  8. import org.springframework.transaction.annotation.Transactional;
  9. import com.baomidou.dynamic.datasource.annotation.DS;
  10. import com.ruoyi.product.domain.Product;
  11. import com.ruoyi.product.mapper.ProductMapper;
  12. import com.ruoyi.product.service.ProductService;
  13. import io.seata.core.context.RootContext;
  15. @Service
  16. public class ProductServiceImpl implements ProductService {
  17.     private static final Logger log = LoggerFactory.getLogger(ProductServiceImpl.class);
  19.     @Resource
  20.     private ProductMapper productMapper;
  22.     /**
  23.      * 事务传播特性设置为 REQUIRES_NEW 开启新的事务 重要！！！！一定要使用REQUIRES_NEW
  24.      * 在若依的示例中，事务的传播特性必须设置REQUIRES_NEW，但经本人测试，多服务调用事务
  25.      * 设置成默认的REQUIRED也能回滚成功
  26.      */
  27.     @Transactional
  28.     @Override
  29.     public Double reduceStock(Long productId, Integer amount)
  30.     {
  31.         log.info("=============PRODUCT START=================");
  32.         log.info("当前 XID: {}", RootContext.getXID());
  34.         // 检查库存
  35.         Product product = productMapper.selectById(productId);
  36.         Integer stock = product.getStock();
  37.         log.info("商品编号为 {} 的库存为{},订单商品数量为{}", productId, stock, amount);
  39.         if (stock < amount)
  40.         {
  41.             log.warn("商品编号为{} 库存不足，当前库存:{}", productId, stock);
  42.             throw new RuntimeException("库存不足");
  43.         }
  44.         log.info("开始扣减商品编号为 {} 库存,单价商品价格为{}", productId, product.getPrice());
  45.         // 扣减库存
  46.         int currentStock = stock - amount;
  47.         product.setStock(currentStock);
  48.         productMapper.updateById(product);
  49.         double totalPrice = product.getPrice() * amount;
  50.         log.info("扣减商品编号为 {} 库存成功,扣减后库存为{}, {} 件商品总价为 {} ", productId, currentStock, amount, totalPrice);
  51.         log.info("=============PRODUCT END=================");
  52.         return totalPrice;
  53.     }
  55. }
复制代码
  ProductController.java
  1. package com.ruoyi.product.controller;
  3. import com.ruoyi.common.core.domain.R;
  4. import com.ruoyi.product.dto.ReduceStockRequest;
  5. import com.ruoyi.product.service.ProductService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.validation.annotation.Validated;
  8. import org.springframework.web.bind.annotation.PostMapping;
  9. import org.springframework.web.bind.annotation.RequestBody;
  10. import org.springframework.web.bind.annotation.RequestMapping;
  11. import org.springframework.web.bind.annotation.RestController;
  13. @RestController
  14. @RequestMapping("/product")
  15. public class ProductController {
  17.     @Autowired
  18.     private ProductService productService;
  20.     @PostMapping("/reduceStock")
  21.     public R<Double> reduceStock(@Validated @RequestBody ReduceStockRequest request) {
  22.         Double d = productService.reduceStock(request.getProductId(), request.getAmount());
  23.         return R.ok(d);
  24.     }
  25. }
复制代码
  ReduceStockRequest.java
  1. package com.ruoyi.product.dto;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Getter;
  5. import lombok.NoArgsConstructor;
  6. import lombok.Setter;
  8. @Getter
  9. @Setter
  10. @NoArgsConstructor
  11. @AllArgsConstructor
  12. public class ReduceStockRequest {
  13.     private Long productId;
  15.     private Integer amount;
  17. }
复制代码
  至此，商品服务就搭建好了，这里主要提供一个扣减商品库存的接口。
创建服务调用模块

  在ruoyi-modules新建一个Module：ruoyi-call（当你也可以不新建Module，直接把Feign接口写在具调用的服务中，这里新建Module主是为了更好的体现模块之间的低耦合），该模块主要的作用是提供Feign接口，用于订单服务调用商品及账户服务，为了搭建方便，以及减少Maven依赖，pom依赖直接拷贝ruoyi-api-system中的依赖。
  ruoyi-call的pom.xml:
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.     <modelVersion>4.0.0</modelVersion>
  4.     <parent>
  5.         <groupId>com.ruoyi</groupId>
  6.         ruoyi-modules</artifactId>
  7.         <version>3.6.6</version>
  8.     </parent>
  10.     ruoyi-call</artifactId>
  11.     <packaging>jar</packaging>
  13.     <name>ruoyi-call</name>
  14.     <url>http://maven.apache.org</url>
  16.     <properties>
  17.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  18.     </properties>
  20.     <dependencies>
  21.         <dependency>
  22.             <groupId>com.ruoyi</groupId>
  23.             ruoyi-common-core</artifactId>
  24.         </dependency>
  26.         <dependency>
  27.             <groupId>org.projectlombok</groupId>
  28.             lombok</artifactId>
  29.         </dependency>
  30.     </dependencies>
  31. </project>
复制代码
  ruoyi-call示例代码:
  AccountFeignService.java
  1. package com.ruoyi.call.feign;
  3. import com.ruoyi.call.dto.ReduceBalanceRequest;
  4. import com.ruoyi.common.core.domain.R;
  5. import org.springframework.cloud.openfeign.FeignClient;
  6. import org.springframework.web.bind.annotation.PostMapping;
  7. import org.springframework.web.bind.annotation.RequestBody;
  9. @FeignClient(name = "ruoyi-account")
  10. public interface AccountFeignService {
  12.     @PostMapping("/account/reduceBalance")
  13.     R reduceBalance(@RequestBody ReduceBalanceRequest request);
  14. }
复制代码
  ProductFeignService.java
  1. package com.ruoyi.call.feign;
  3. import com.ruoyi.call.dto.ReduceStockRequest;
  4. import com.ruoyi.common.core.domain.R;
  5. import org.springframework.cloud.openfeign.FeignClient;
  6. import org.springframework.web.bind.annotation.PostMapping;
  7. import org.springframework.web.bind.annotation.RequestBody;
  9. @FeignClient(name = "ruoyi-product")
  10. public interface ProductFeignService {
  12.     @PostMapping("/product/reduceStock")
  13.     R<Double> reduceStock(@RequestBody ReduceStockRequest request);
  14. }
复制代码
  ReduceBalanceRequest.java
  1. package com.ruoyi.call.dto;
  4. import lombok.AllArgsConstructor;
  5. import lombok.Getter;
  6. import lombok.NoArgsConstructor;
  7. import lombok.Setter;
  9. @Getter
  10. @Setter
  11. @NoArgsConstructor
  12. @AllArgsConstructor
  13. public class ReduceBalanceRequest {
  14.     private Long userId;
  16.     private Double price;
  17. }
复制代码
  ReduceStockRequest.java
  1. package com.ruoyi.call.dto;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Getter;
  5. import lombok.NoArgsConstructor;
  6. import lombok.Setter;
  8. @Getter
  9. @Setter
  10. @NoArgsConstructor
  11. @AllArgsConstructor
  12. public class ReduceStockRequest {
  13.     private Long productId;
  15.     private Integer amount;
  17. }
复制代码
  至此，服务调用模块就创建好了，这里主要提供Feign接口，供订单服务调用。
搭建订单服务

  在ruoyi-modules新建一个Module：ruoyi-order，为了搭建方便，以及减少Maven依赖，pom依赖直接拷贝ruoyi-system中的依赖，然后新增Seata的依赖，再就是引入创刚建的服务调用模块。
  ruoyi-order的pom.xml:
  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.     <modelVersion>4.0.0</modelVersion>
  4.     <parent>
  5.         <groupId>com.ruoyi</groupId>
  6.         ruoyi-modules</artifactId>
  7.         <version>3.6.6</version>
  8.     </parent>
  10.     ruoyi-order</artifactId>
  11.     <packaging>jar</packaging>
  13.     <name>ruoyi-order</name>
  14.     <url>http://maven.apache.org</url>
  16.     <properties>
  17.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  18.     </properties>
  20.     <dependencies>
  21.         
  22.         <dependency>
  23.             <groupId>com.alibaba.cloud</groupId>
  24.             spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  25.         </dependency>
  27.         
  28.         <dependency>
  29.             <groupId>com.alibaba.cloud</groupId>
  30.             spring-cloud-starter-alibaba-nacos-config</artifactId>
  31.         </dependency>
  33.         
  34.         <dependency>
  35.             <groupId>com.alibaba.cloud</groupId>
  36.             spring-cloud-starter-alibaba-sentinel</artifactId>
  37.         </dependency>
  39.         
  40.         <dependency>
  41.             <groupId>org.springframework.boot</groupId>
  42.             spring-boot-starter-actuator</artifactId>
  43.         </dependency>
  45.         
  46.         <dependency>
  47.             <groupId>com.mysql</groupId>
  48.             mysql-connector-j</artifactId>
  49.         </dependency>
  51.         
  52.         <dependency>
  53.             <groupId>com.ruoyi</groupId>
  54.             ruoyi-common-datasource</artifactId>
  55.         </dependency>
  57.         
  58.         <dependency>
  59.             <groupId>com.ruoyi</groupId>
  60.             ruoyi-common-datascope</artifactId>
  61.         </dependency>
  63.         
  64.         <dependency>
  65.             <groupId>com.ruoyi</groupId>
  66.             ruoyi-common-log</artifactId>
  67.         </dependency>
  69.         
  70.         <dependency>
  71.             <groupId>com.ruoyi</groupId>
  72.             ruoyi-common-swagger</artifactId>
  73.         </dependency>
  75.         
  76.         <dependency>
  77.             <groupId>com.alibaba.cloud</groupId>
  78.             spring-cloud-starter-alibaba-seata</artifactId>
  79.         </dependency>
  81.         <dependency>
  82.             <groupId>com.ruoyi</groupId>
  83.             ruoyi-call</artifactId>
  84.             <version>3.6.6</version>
  85.         </dependency>
  86.     </dependencies>
  88.     <build>
  89.         <finalName>${project.artifactId}</finalName>
  90.         <plugins>
  91.             <plugin>
  92.                 <groupId>org.springframework.boot</groupId>
  93.                 spring-boot-maven-plugin</artifactId>
  94.                 <executions>
  95.                     <execution>
  96.                         <goals>
  97.                             <goal>repackage</goal>
  98.                         </goals>
  99.                     </execution>
  100.                 </executions>
  101.             </plugin>
  102.         </plugins>
  103.     </build>
  104. </project>
复制代码
  ruoyi-order的bootstrap.yml:
  1. # Tomcat
  2. server:
  3.   port: 10301
  5. # Spring
  6. spring:
  7.   application:
  8.     # 应用名称
  9.     name: ruoyi-order
  10.   profiles:
  11.     # 环境配置
  12.     active: dev
  13.   cloud:
  14.     nacos:
  15.       discovery:
  16.         # 服务注册地址
  17.         server-addr: 127.0.0.1:8848
  18.       config:
  19.         # 配置中心地址
  20.         server-addr: 127.0.0.1:8848
  21.         # 配置文件格式
  22.         file-extension: yml
  23.         # 共享配置
  24.         shared-configs:
  25.           - application-${spring.profiles.active}.${spring.cloud.nacos.config.file-extension}
  26. seata:
  27.   enabled: true
  28.   # Seata 应用编号，默认为 ${spring.application.name}
  29.   application-id: ${spring.application.name}
  30.   # Seata 事务组编号，用于 TC 集群名
  31.   tx-service-group: ${spring.application.name}-group
  32.   # 关闭自动代理
  33.   enable-auto-data-source-proxy: false
  34.   # 服务配置项
  35.   service:
  36.     # 虚拟组和分组的映射
  37.     vgroup-mapping:
  38.       ruoyi-order-group: default
  39.   config:
  40.     type: nacos
  41.     nacos:
  42.       serverAddr: 127.0.0.1:8848
  43.       group: SEATA_GROUP
  44.       namespace:
  45.       dataId: seataServer.properties
  46.   registry:
  47.     type: nacos
  48.     nacos:
  49.       application: seata-server
  50.       server-addr: 127.0.0.1:8848
  51.       namespace:
复制代码
  ruoyi-order的ruoyi-order-dev.yml:
  1. # spring配置
  2. spring:
  3.   redis:
  4.     host: localhost
  5.     port: 6379
  6.     password:
  7.   datasource:
  8.     druid:
  9.       stat-view-servlet:
  10.         enabled: true
  11.         loginUsername: ruoyi
  12.         loginPassword: 123456
  13.     dynamic:
  14.       druid:
  15.         initial-size: 5
  16.         min-idle: 5
  17.         maxActive: 20
  18.         maxWait: 60000
  19.         connectTimeout: 30000
  20.         socketTimeout: 60000
  21.         timeBetweenEvictionRunsMillis: 60000
  22.         minEvictableIdleTimeMillis: 300000
  23.         validationQuery: SELECT 1 FROM DUAL
  24.         testWhileIdle: true
  25.         testOnBorrow: false
  26.         testOnReturn: false
  27.         poolPreparedStatements: true
  28.         maxPoolPreparedStatementPerConnectionSize: 20
  29.         filters: stat,slf4j
  30.         connectionProperties: druid.stat.mergeSql\=true;druid.stat.slowSqlMillis\=5000
  31.       datasource:
  32.           # 主库数据源
  33.           master:
  34.             driver-class-name: com.mysql.cj.jdbc.Driver
  35.             url: jdbc:mysql://localhost:3306/seata_order?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
  36.             username: root
  37.             password: root123
  38.           # 从库数据源
  39.           # slave:
  40.             # username:
  41.             # password:
  42.             # url:
  43.             # driver-class-name:
  44.       seata: true
  46. # mybatis配置
  47. mybatis:
  48.     # 搜索指定包别名
  49.     typeAliasesPackage: com.ruoyi.order
  50.     # 配置mapper的扫描，找到所有的mapper.xml映射文件
  51.     mapperLocations: classpath:mapper/**/*.xml
  53. # springdoc配置
  54. springdoc:
  55.   gatewayUrl: http://localhost:8080/${spring.application.name}
  56.   api-docs:
  57.     # 是否开启接口文档
  58.     enabled: false
复制代码
  ruoyi-order示例代码:
  Order.java
  1. package com.ruoyi.order.domain;
  3. import lombok.Getter;
  4. import lombok.Setter;
  6. @Getter
  7. @Setter
  8. public class Order {
  10.     private Integer id;
  12.     /**
  13.      * 用户ID
  14.      */
  15.     private Long userId;
  17.     /**
  18.      * 商品ID
  19.      */
  20.     private Long productId;
  22.     /**
  23.      * 订单状态
  24.      */
  25.     private int status;
  27.     /**
  28.      * 数量
  29.      */
  30.     private Integer amount;
  32.     /**
  33.      * 总金额
  34.      */
  35.     private Double totalPrice;
  37.     public Order()
  38.     {
  39.     }
  41.     public Order(Long userId, Long productId, int status, Integer amount)
  42.     {
  43.         this.userId = userId;
  44.         this.productId = productId;
  45.         this.status = status;
  46.         this.amount = amount;
  47.     }
  48. }
复制代码
  OrderMapper.java
  1. package com.ruoyi.order.mapper;
  3. import com.ruoyi.order.domain.Order;
  5. public interface OrderMapper {
  6.     public void insert(Order order);
  8.     public void updateById(Order order);
  9. }
复制代码
  OrderMapper.xml
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.ruoyi.order.mapper.OrderMapper">
  7.     <resultMap type="com.ruoyi.order.domain.Order" id="OrderResult">
  8.         <id     property="id"              column="id"                />
  9.         <result property="userId"          column="user_id"           />
  10.         <result property="productId"       column="product_id"        />
  11.         <result property="amount"          column="amount"            />
  12.         <result property="totalPrice"      column="total_price"       />
  13.         <result property="status"          column="status"            />
  14.     </resultMap>
  16.     <insert id="insert" parameterType="com.ruoyi.order.domain.Order" useGeneratedKeys="true" keyProperty="id">
  17.         insert into p_order (
  18.         <if test="userId != null and userId != '' ">user_id,</if>
  19.         <if test="productId != null and productId != '' ">product_id,</if>
  20.         <if test="amount != null and amount != '' ">amount,</if>
  21.         <if test="totalPrice != null and totalPrice != '' ">total_price,</if>
  22.         <if test="status != null and status != ''">status,</if>
  23.         add_time
  24.         )values(
  25.         <if test="userId != null and userId != ''">#{userId},</if>
  26.         <if test="productId != null and productId != ''">#{productId},</if>
  27.         <if test="amount != null and amount != ''">#{amount},</if>
  28.         <if test="totalPrice != null and totalPrice != ''">#{totalPrice},</if>
  29.         <if test="status != null and status != ''">#{status},</if>
  30.         sysdate()
  31.         )
  32.     </insert>
  34.     <update id="updateById" parameterType="com.ruoyi.order.domain.Order">
  35.         update p_order
  36.         <set>
  37.             <if test="userId != null and userId != ''">user_id = #{userId},</if>
  38.             <if test="productId != null and productId != ''">product_id = #{productId},</if>
  39.             <if test="amount != null and amount != ''">amount = #{amount},</if>
  40.             <if test="totalPrice != null and totalPrice != ''">total_price = #{totalPrice},</if>
  41.             <if test="status != null and status != ''">status = #{status},</if>
  42.             last_update_time = sysdate()
  43.         </set>
  44.         where id = #{id}
  45.     </update>
  47. </mapper>
复制代码
  OrderService.java
  1. package com.ruoyi.order.service;
  3. import com.ruoyi.order.dto.PlaceOrderRequest;
  5. public interface OrderService {
  6.     /**
  7.      * 下单
  8.      *
  9.      * @param placeOrderRequest 订单请求参数
  10.      */
  11.     void placeOrder(PlaceOrderRequest placeOrderRequest);
  12. }
复制代码
  OrderServiceImpl.java
  1. package com.ruoyi.order.service.impl;
  3. import javax.annotation.Resource;
  5. import com.ruoyi.call.dto.ReduceBalanceRequest;
  6. import com.ruoyi.call.dto.ReduceStockRequest;
  7. import com.ruoyi.call.feign.AccountFeignService;
  8. import com.ruoyi.call.feign.ProductFeignService;
  9. import com.ruoyi.common.core.domain.R;
  10. import org.slf4j.Logger;
  11. import org.slf4j.LoggerFactory;
  12. import org.springframework.beans.factory.annotation.Autowired;
  13. import org.springframework.stereotype.Service;
  14. import org.springframework.transaction.annotation.Transactional;
  15. import com.baomidou.dynamic.datasource.annotation.DS;
  16. import com.ruoyi.order.domain.Order;
  17. import com.ruoyi.order.dto.PlaceOrderRequest;
  18. import com.ruoyi.order.mapper.OrderMapper;
  19. import com.ruoyi.order.service.OrderService;
  20. import io.seata.core.context.RootContext;
  21. import io.seata.spring.annotation.GlobalTransactional;
  23. @Service
  24. public class OrderServiceImpl implements OrderService {
  25.     private static final Logger log = LoggerFactory.getLogger(OrderServiceImpl.class);
  27.     @Resource
  28.     private OrderMapper orderMapper;
  30.     @Autowired
  31.     private ProductFeignService productFeignService;
  33.     @Autowired
  34.     private AccountFeignService accountFeignService;
  36.     @Override
  37.     @Transactional
  38.     @GlobalTransactional // 重点 第一个开启事务的需要添加seata全局事务注解
  39.     public void placeOrder(PlaceOrderRequest request) {
  40.         log.info("=============ORDER START=================");
  41.         Long userId = request.getUserId();
  42.         Long productId = request.getProductId();
  43.         Integer amount = request.getAmount();
  44.         log.info("收到下单请求,用户:{}, 商品:{},数量:{}", userId, productId, amount);
  46.         log.info("当前 XID: {}", RootContext.getXID());
  48.         Order order = new Order(userId, productId, 0, amount);
  50.         orderMapper.insert(order);
  51.         log.info("订单一阶段生成，等待扣库存付款中");
  52.         // 扣减库存并计算总价
  53. //        Double totalPrice = productService.reduceStock(productId, amount);
  54. //        // 扣减余额
  55. //        accountService.reduceBalance(userId, totalPrice);
  57.         // 扣减库存并计算总价
  58.         R<Double> r = productFeignService.reduceStock(new ReduceStockRequest(productId, amount));
  59.         if (r.getCode() != 200) {
  60.            throw new RuntimeException("扣减库存失败");
  61.         }
  62.         Double totalPrice = r.getData();
  63.         // 扣减余额
  64.         R r1 = accountFeignService.reduceBalance(new ReduceBalanceRequest(userId, totalPrice));
  65.         if (r1.getCode() != 200) {
  66.             throw new RuntimeException("扣减余额失败");
  67.         }
  68.         order.setStatus(1);
  69.         order.setTotalPrice(totalPrice);
  70.         orderMapper.updateById(order);
  71.         log.info("订单已成功下单");
  72.         log.info("=============ORDER END=================");
  73.     }
  75. }
复制代码
  OrderController.java
  1. package com.ruoyi.order.controller;
  3. import com.ruoyi.common.core.domain.R;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.validation.annotation.Validated;
  6. import org.springframework.web.bind.annotation.PostMapping;
  7. import org.springframework.web.bind.annotation.RequestBody;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  10. import com.ruoyi.order.dto.PlaceOrderRequest;
  11. import com.ruoyi.order.service.OrderService;
  13. @RestController
  14. @RequestMapping("/order")
  15. public class OrderController {
  16.     @Autowired
  17.     private OrderService orderService;
  19.     @PostMapping("/placeOrder")
  20.     public R placeOrder(@Validated @RequestBody PlaceOrderRequest request) {
  21.         orderService.placeOrder(request);
  22.         return R.ok("下单成功");
  23.     }
  25.     @PostMapping("/test1")
  26.     public R test1() {
  27.         // 商品单价10元，库存20个,用户余额50元，模拟一次性购买22个。 期望异常回滚
  28.         orderService.placeOrder(new PlaceOrderRequest(1L, 1L, 22));
  29.         return R.ok("下单成功");
  30.     }
  32.     @PostMapping("/test2")
  33.     public R test2() {
  34.         // 商品单价10元，库存20个，用户余额50元，模拟一次性购买6个。 期望异常回滚
  35.         orderService.placeOrder(new PlaceOrderRequest(1L, 1L, 6));
  36.         return R.ok("下单成功");
  37.     }
  38. }
复制代码
  PlaceOrderRequest.java
  1. package com.ruoyi.order.dto;
  3. import lombok.Getter;
  4. import lombok.Setter;
  6. @Getter
  7. @Setter
  8. public class PlaceOrderRequest {
  10.     private Long userId;
  12.     private Long productId;
  14.     private Integer amount;
  16.     public PlaceOrderRequest() {
  17.     }
  19.     public PlaceOrderRequest(Long userId, Long productId, Integer amount) {
  20.         this.userId = userId;
  21.         this.productId = productId;
  22.         this.amount = amount;
  23.     }
  24. }
复制代码
  至此，订单服务就搭建好了。订单服务提供了下单接口，可以模拟正常下单，同时提供了验证库存不足及余额不足的接口，用于验证事务回滚。
测试验证

  使用接口测试工具Postman或Apifox测试接口，注意观察运行日志，以及数据库数据变化，至此分布式事务集成案例全流程完毕。
正常下单

  模拟正常下单，买一个商品 http://localhost:10301/order/placeOrder
  1. {
  2.     "userId": 1,
  3.     "productId": 1,
  4.     "amount": 1
  5. }
复制代码
库存不足

  模拟库存不足，事务回滚 http://localhost:9201/order/placeOrder
  1. {
  2.     "userId": 1,
  3.     "productId": 1,
  4.     "amount": 22
  5. }
复制代码
用户余额不足

模拟用户余额不足，事务回滚 http://localhost:9201/order/placeOrder
  1. {
  2.     "userId": 1,
  3.     "productId": 1,
  4.     "amount": 6
  5. }
复制代码
结语

  Seata AT模式是微服务场景下最常用的分布式事务解决方案之一，核心优势是对业务无侵入（仅需添加注解），底层基于「两阶段提交+自动补偿」实现数据一致性。AT模式的设计目标是：让开发者像使用本地事务一样使用分布式事务，无需手动编写回滚逻辑。其核心依赖「事务协调器（TC）、资源管理器（RM）、事务管理器（TM）」三大组件，以及「undo_log日志表、全局锁、本地锁」三大核心机制。在AT模式的两阶段提交中，第一阶段执行本地事务时，Seata会自动拦截业务SQL，生成包含数据旧值的undo_log并与业务数据一同提交至数据库；第二阶段若需回滚，框架则通过undo_log反向执行更新操作，完成数据恢复。
  具体使用时只需将@GlobalTransactional注解添加在分布式事务的发起方方法上，Seata便会自动完成全局事务ID的生成、分支事务的注册与协调。使用时具体的注意事项包括：必须使用Seata数据源代理、必须创建undo_log表、所有微服务的tx-service-group、service.vgroupMapping需与Seata Server配置一致等。
  技术探索之路漫漫，由于作者水平有限，文中难免有疏漏或不妥之处，若有不同见解或优化建议，欢迎留言交流指正。
参考资料

https://seata.apache.org/zh-cn/docs/user/quickstart
https://doc.ruoyi.vip/ruoyi-cloud/cloud/seata.html#基本介绍
https://xie.infoq.cn/article/37af299e60562cf625029c29e

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！
SpringCloud分布式事务基于

使用道具 举报

相关推荐
勺缓曜
2025-11-27 16:51:28

举报

程序园永久vip申请，500美金$，无限下载程序园所有程序/软件/数据/等
感谢分享，学习下。
空娅芬
6 天前

举报

猛犸象科技工作室:网站开发，备案域名，渗透，服务器出租，DDOS/CC攻击，TG加粉引流
热心回复！
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
米嘉怡
6 天前

0

粉丝关注

17

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫