系统定制开发废话不多说丨分布式事务之seata使用，一文带你全盘掌握

系统定制开发今天给大家带来一个技系统定制开发术点的使用分享，系统定制开发就是事务之seata使用。系统定制开发分布式事务的解决方案，系统定制开发是大家在面试中不可避系统定制开发免会被问到的，系统定制开发而且分布式事务的解决系统定制开发方案也非常多。

系统定制开发今天威哥就以为例，把seata系统定制开发的使用在这里做了一个总结，系统定制开发希望能够帮助到大家。系统定制开发本案例在实施过程中，系统定制开发威哥力求简单明了，系统定制开发希望大家在学习过程中系统定制开发能够掌握其中的每个细节。好了，系统定制开发废话不多说，如果我们要学习seata，首先需要具备如下技术储备：

  • 数据库事务的基本知识；

  • 工具的使用；

  • 熟悉SpringCloudAlibaba；

  • 掌握SpringDataJPA简单使用；

一. Seata基本概念

1.seata是什么

Seata是阿里巴巴中间件团队发起了开源项目，其愿景是让分布式事务的使用像本地事务的使用一样，简单和高效，并逐步解决开发者们遇到的分布式事务方面的所有难题，后来更名为 Seata。

Seata的设计目标是对业务无侵入，因此从业务无侵入的2PC方案着手，在传统2PC的基础上演进。它把一个分布式事务理解成一个包含了若干分支事务的全局事务。

全局事务的职责是协调其下管辖的分支事务达成一致，要么一起成功提交，要么一起失败回滚。此外，通常分支事务本身就是一个关系数据库的本地事务。

2.seata基本架构

听到这里，是不是觉得很晦涩？那么威哥通过一幅图来帮助你们进一步理解seata的架构：

通过这幅图，我们看到了seata的三个重要的组件，分别是TC TM RM。那么他们到底是什么东西呢？

  • TC：Transaction Coordinator事务协调器，管理全局的分支事务的状态，用于全局性事务的提交和回滚。

  • TM：Transaction Manager 事务管理器，用于开启、提交或者回滚全局事务。

  • RM：Resource Manager资源管理器，用于分支事务上的资源管理，向TC注册分支事务，上报分支事务的状态，接受TC的命令来提交或者回滚分支事务。

3.seata执行流程

搞清楚了这几个组件的含义之后，那么seata的整个执行流程我们就可以梳理清楚了：

  • A服务的TM向TC申请开启一个全局事务，TC就会创建一个全局事务并返回一个唯一的XID。

  • 服务的RM向TC注册分支事务，并及其纳入XID对应全局事务的管辖。

  • A服务执行分支事务，向数据库做操作。

  • A服务开始远程调用B服务，此时XID会在微服务的调用链上传播。

  • B服务的RM向TC注册分支事务，并将其纳入XID对应的全局事务的管辖。

  • B服务执行分支事务，向数据库做操作。

  • 全局事务调用链处理完毕，TM根据有无异常向TC发起全局事务的提交或者回滚。

  • TC协调其管辖之下的所有分支事务，决定是否回滚。

二. 案例环境搭建

我们搞清楚Seata的相关概念之后，现在威哥带领大家实现一个需求：通过订单微服务实现下订单的操作，然后通知库存微服务进行库存的扣减。

1. 前期准备

我们需要先准备订单和商品实体类。

  1. //商品
  2. @Entity(name = "shop_product")
  3. @Data
  4. public class Product {
  5.     @Id
  6.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  7.     private Integer pid;//主键
  8.     private String pname;//商品名称
  9.     private Double pprice;//商品价格
  10.     private Integer stock;//库存
  11. }
  12.  
  13.  
  14. //订单
  15. @Entity(name = "shop_order")
  16. @Data
  17. public class Order {
  18.     @Id
  19.     @GeneratedValue(strategy = GenerationType.IDENTITY)
  20.     private Long oid;//订单id
  21.     private Integer uid;//用户id
  22.     private String username;//用户名
  23.     private Integer pid;//商品id
  24.     private String pname;//商品名称
  25.     private Double pprice;//商品单价
  26.     private Integer number;//购买数量
  27. }

我们还需要准备项目必备的pom依赖：

这是父工程的pom.xml文件：

  1. <dependencyManagement>
  2.     <dependencies>
  3.         <dependency>
  4.             <groupId>org.springframework.cloud</groupId>
  5.             <artifactId>spring-cloud-dependencies</artifactId>
  6.             <version>${spring-cloud.version}</version>
  7.             <type>pom</type>
  8.             <scope>import</scope>
  9.         </dependency>
  10.         <dependency>
  11.             <groupId>com.alibaba.cloud</groupId>
  12.             <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  13.             <version>${spring-cloud-alibaba.version}</version>
  14.             <type>pom</type>
  15.             <scope>import</scope>
  16.         </dependency>
  17.     </dependencies>
  18. </dependencyManagement>

2. 搭建对应的微服务

现在我们分别搭建商品微服务和订单微服务

2.1 创建公共通用模块

我们创建shop-common模块，专门存放一些公共的实体类和工具类，便于其他模块进行共享。

2.1.1 在公共模块添加相关的依赖

  1. <dependencyManagement>
  2.     <dependencies>
  3.         <dependency>
  4.             <groupId>org.springframework.cloud</groupId>
  5.             <artifactId>spring-cloud-dependencies</artifactId>
  6.             <version>${spring-cloud.version}</version>
  7.             <type>pom</type>
  8.             <scope>import</scope>
  9.         </dependency>
  10.         <dependency>
  11.             <groupId>com.alibaba.cloud</groupId>
  12.             <artifactId>spring-cloud-alibaba-dependencies</artifactId>
  13.             <version>${spring-cloud-alibaba.version}</version>
  14.             <type>pom</type>
  15.             <scope>import</scope>
  16.         </dependency>
  17.     </dependencies>
  18. </dependencyManagement>

然后把之前准备的实体类都拷贝到这个shop-common中来。

2.2 搭建订单微服务模块

2.2.1 添加必要依赖

取名shop-order，在这个模块里面添加相关的依赖。

  1. <dependencies>
  2.     
  3.     <dependency>
  4.         <groupId>com.alibaba.cloud</groupId>
  5.         <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  6.     </dependency>
  7.  
  8.     
  9.     <dependency>
  10.         <groupId>org.springframework.cloud</groupId>
  11.         <artifactId>spring-cloud-starter-openfeign</artifactId>
  12.     </dependency>
  13.     
  14.     <dependency>
  15.         <groupId>org.springframework.boot</groupId>
  16.         <artifactId>spring-boot-starter-web</artifactId>
  17.     </dependency>
  18.  
  19.     <dependency>
  20.         <groupId>com.qf.common</groupId>
  21.         <artifactId>springcloudAlibaba-common</artifactId>
  22.         <version>1.0-SNAPSHOT</version>
  23.     </dependency>
  24.  
  25.     <dependency>
  26.         <groupId>com.qf.feign</groupId>
  27.         <artifactId>springcloudAlibaba-order-product-feign</artifactId>
  28.         <version>1.0-SNAPSHOT</version>
  29.     </dependency>
  30.     
  31.     
  32.     <dependency>
  33.         <groupId>org.springframework.boot</groupId>
  34.         <artifactId>spring-boot-starter-test</artifactId>
  35.     </dependency>
  36.     <dependency>
  37.         <groupId>junit</groupId>
  38.         <artifactId>junit</artifactId>
  39.     </dependency>
  40.  
  41.     
  42.     <dependency>
  43.         <groupId>com.alibaba.cloud</groupId>
  44.         <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
  45.     </dependency>
  46.  
  47.     
  48.     <dependency>
  49.         <groupId>com.alibaba.cloud</groupId>
  50.         <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
  51.     </dependency>
  52. </dependencies>

2.2.2 编写controller

在这里，我们编写一个下单操作的服务接口。

  1. @RestController
  2. @RequestMapping("order")
  3. @Slf4j
  4. public class OrderController {
  5.  
  6.     @Autowired
  7.     OrderService5 orderService5;
  8.  
  9.     @RequestMapping("prod/{pid}")
  10.     public Order order(@PathVariable("pid") Integer pid){
  11.         return orderService5.createOrder(pid);
  12.     }
  13. }

2.2.3 编写service

  1. public interface OrderService {
  2.  
  3.     Order createOrder(Integer pid);
  4. }
  1. @Service
  2. @Slf4j
  3. public class OrderServiceImpl implements OrderService {
  4.  
  5.     @Autowired
  6.     OrderFeign orderFeign;
  7.  
  8.     @Autowired
  9.     OrderDao orderDao;
  10.     @Override
  11.     public Order createOrder(Integer pid) {
  12.         //查询指定的商品信息
  13.         Product product = orderFeign.findProductByPid(pid);
  14.         log.info("查询到的商品信息是：{}", JSON.toJSONString(product));
  15.         //执行下单的操作
  16.         Order order = new Order();
  17.         order.setUid(1003);
  18.         order.setUsername("测试Seata案例");
  19.         order.setPid(pid);
  20.         order.setPname(product.getPname());
  21.         order.setPprice(product.getPprice());
  22.         //设置订单中的商品数量
  23.         order.setNumber(1);
  24.         orderDao.save(order);
  25.         log.info("订单创建成功，订单信息是:{}",JSON.toJSONString(order));
  26.         //执行扣减库存的操作
  27.         orderFeign.reduceStock(pid,order.getNumber());
  28.         return order;
  29.     }
  30. }

2.2.4 编写feign客户端

  1. @FeignClient(name = "service-product")
  2. public interface OrderFeign {
  3.  
  4.     @RequestMapping("product/{pid}")
  5.     public Product findProductByPid(@PathVariable("pid") Integer pid);
  6.  
  7.     @RequestMapping("product/reduceStock")
  8.     void reduceStock(@RequestParam("pid") Integer pid,@RequestParam("number") Integer number);
  9. }

2.2.5 编写dao

  1. public interface OrderDao extends JpaRepository<Order,Integer> {
  2. }

2.3 搭建商品微服务模块

2.3.1 添加必要依赖

取名shop-product,在这个模块里面添加相关的依赖。

  1. <dependencies>
  2.     
  3.     <dependency>
  4.         <groupId>com.alibaba.cloud</groupId>
  5.         <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  6.     </dependency>
  7.  
  8.     <dependency>
  9.         <groupId>org.springframework.boot</groupId>
  10.         <artifactId>spring-boot-starter-web</artifactId>
  11.     </dependency>
  12.  
  13.     <dependency>
  14.         <groupId>com.qf.common</groupId>
  15.         <artifactId>springcloudAlibaba-common</artifactId>
  16.         <version>1.0-SNAPSHOT</version>
  17.     </dependency>
  18.  
  19.     
  20.     <dependency>
  21.         <groupId>com.alibaba.cloud</groupId>
  22.         <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
  23.     </dependency>
  24.     
  25.     <dependency>
  26.         <groupId>com.alibaba.cloud</groupId>
  27.         <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
  28.     </dependency>
  29. </dependencies>

2.3.2 编写controller

  1. @RestController
  2. @Slf4j
  3. @RefreshScope //配置信息的即时刷新
  4. public class ProductController {
  5.  
  6.     @Autowired
  7.     ProductService productService;
  8.  
  9.     //根据id查询对应的商品信息
  10.     @RequestMapping("product/{pid}")
  11.     public Product findProductByPid(@PathVariable("pid") Integer pid){
  12.         Product product = productService.findProductByPid(pid);
  13.         //JSON.toJSONString  把指定数据转换成json串
  14.         log.info("查询到的对应的商品是:" + JSON.toJSONString(product));
  15.         return product;
  16.     }
  17.     
  18.       //扣减库存
  19.     @RequestMapping("product/reduceStock")
  20.     public void reduceStock(@RequestParam("pid") Integer pid,@RequestParam("number") Integer number){
  21.         productService.reduceStock(pid,number);
  22.     }
  23.  
  24. }

2.3.3 编写service

  1. public interface ProductService {
  2.  
  3.     Product findProductByPid(Integer pid);
  4.  
  5.     void reduceStock(Integer pid, Integer number);
  6. }
  1. @Service
  2. public class ProductServiceImpl implements ProductService {
  3.  
  4.     @Autowired
  5.     ProductDao productDao;
  6.  
  7.     @Override
  8.     public Product findProductByPid(Integer pid) {
  9.         Optional<Product> optional = productDao.findById(pid);
  10.         return optional.get();
  11.     }
  12.  
  13.     @Override
  14.     public void reduceStock(Integer pid, Integer number) {
  15.         Product product = productDao.findById(pid).get();
  16.         product.setStock(product.getStock() -  number);
  17.         productDao.save(product);
  18.     }
  19. }

2.3.4 编写dao

  1. public interface ProductDao extends JpaRepository<Product,Integer> {
  2. }

现在我们启动测试，目前代码是没有什么问题的。但是如果我手动模拟异常。具体操作如下：

此时我们再去测试，这个时候就出现了问题了。我们发现订单能够下单成功，但是库存没有扣减。这样就出现了数据不一致的事务问题。那么我们可以使用seata来帮我们解决问题。

三. 配置使用seata

1. 下载seata

同学们可以在如下资源链接上进行下载：

下载地址：https://github.com/seata/seata/releases/v0.9.0/

2. 配置Seata

我们下载下来之后，会是一个压缩包。我们把这个压缩包打开之后进行相关配置。

2.1 修改registry.conf，指定seata使用nacos注册中心

  1. registry {
  2.   # 支持的注册中心有：file 、nacos 、eureka、redis、zk、consul、etcd3、sofa  我们使用自己的注册中心即可  所以删除其他注册中心相关的配置
  3.   type = "nacos"
  4.  
  5.   nacos {
  6.     serverAddr = "localhost"
  7.     namespace = ""
  8.     cluster = "default"
  9.   }
  10.  
  11. }
  12.  
  13. config {
  14.   # file、nacos 、apollo、zk、consul、etcd3
  15.   type = "nacos"
  16.  
  17.   nacos {
  18.     serverAddr = "localhost"
  19.     namespace = ""
  20.   }
  21.  
  22. }

2.2 修改nacos-config.txt，指定我们的服务名称

2.3 初始化seata在nacos中的配置

我们需要把seata相关的配置信息在nacos配置中心进行注册。

  1. # 初始化seata 的nacos配置 # 注意: 这里要保证nacos是已经正常运行的 
  2. cd conf 
  3. nacos-config.sh 127.0.0.1

执行成功后可以打开Naco的控制台，在配置列表中，可以看到初始化了很多Group为SEATA_GROUP的配置。

2.4 启动seata服务

切换到bin目录执行以下命令：

  1. cd bin
  2. seata-server.bat -p 9000 -m file

启动后在 Nacos 的服务列表下面可以看到一个名为 serverAddr的服务。如果入下图所示，小伙伴们，seata服务启动成功！！！！！

3. 使用seata进行事务控制

3.1 初始化一张数据表，用来seata进行日志记录

  1. CREATE TABLE `undo_log`
  2. (
  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. `ext` VARCHAR(100) DEFAULT NULL,
  12. PRIMARY KEY (`id`),
  13. UNIQUE KEY `ux_undo_log` (`xid`, `branch_id`)
  14. ) ENGINE = INNODB
  15. AUTO_INCREMENT = 1
  16. DEFAULT CHARSET = utf8;

3.2 在微服务中添加seata相关的依赖

  1. <dependency>
  2.      <groupId>com.alibaba.cloud</groupId>
  3.      <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
  4.  </dependency>
  5.  
  6.  <dependency>
  7.      <groupId>com.alibaba.cloud</groupId>
  8.      <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
  9.  </dependency>

3.3 配置DataSourceProxyConfig代理数据源

Seata 是通过代理数据源实现事务分支的，所以需要配置 io.seata.rm.datasource.DataSourceProxy 的 Bean，且是 @Primary默认的数据源，否则事务不会回滚，无法实现分布式事务.

在shop-product和shop-order里面都添加如下配置类：

  1. @Configuration
  2.  public class DataSourceProxyConfig {
  3.      @Bean
  4.      @ConfigurationProperties(prefix = "spring.datasource")
  5.      public DruidDataSource druidDataSource() {
  6.          return new DruidDataSource();
  7.      }
  8.  
  9.      @Primary
  10.      @Bean
  11.      public DataSourceProxy dataSource(DruidDataSource druidDataSource) {
  12.          return new DataSourceProxy(druidDataSource);
  13.      }
  14.  }

  • 在shop-product和shop-order的resources目录添加registry.conf(直接将seata里面的配置复制过来即可)。

  • 在shop-product和shop-order的resources目录添加bootstrap.yml里面,然后添加配置。

3.4 在shop-order微服务中开启全局事务

4. 结果测试

我们发生请求：http://localhost:8091/order5/prod/1

此时查看数据库，我们发现事务问题得到了控制。就是当发生异常的时候，下单的记录被回滚了，而且库存也没有出现扣减。

到现在，我们的分布式事务就得到了控制，小伙伴们，你们有没有学会呢？可以留言或者java学习+资料获取 加q群：691533824  扫码学习啦！

网站建设定制开发 软件系统开发定制 定制软件开发 软件开发定制 定制app开发 app开发定制 app开发定制公司 电商商城定制开发 定制小程序开发 定制开发小程序 客户管理系统开发定制 定制网站 定制开发 crm开发定制 开发公司 小程序开发定制 定制软件 收款定制开发 企业网站定制开发 定制化开发 android系统定制开发 定制小程序开发费用 定制设计 专注app软件定制开发 软件开发定制定制 知名网站建设定制 软件定制开发供应商 应用系统定制开发 软件系统定制开发 企业管理系统定制开发 系统定制开发