微服务SpringCloud开弓之SpringCloud Alibaba Seata处理分布式事务「十五」

SpringCloud Alibaba Seata处理分布式事务

1、分布式事务问题

• 分布式前

  单机单库没这个问题

  从1：1 -> 1:N -> N: N

• 分布式之后

• 一句话

  一次业务操作需要跨多个数据源或需要跨多个系统进行远程调用，就会产生分布式事务问题

2、Seata简介

官网地址

• 是什么、

  Seata是一款开源的分布式事务解决方案，致力于在微服务架构下提供高性能和简单易用的分布式事务服务

• 能干嘛

  一个典型的分布式事务过程

  1、分布式事务处理过程的-ID+三组件模型

  ​ Transaction ID XID 全局唯一的事务ID

  ​ 3组件概念

  • Transaction Coordinator(TC) ：

    事务协调器，维护全局事务的运行状态，负责协调并驱动全局事务的提交或回滚;

  • Transaction Manager™

    控制全局事务的边界，负责开启一个全局事务，并最终发起全局提交或全局回滚的决议;

  • Resource Manager(RM)

    控制分支事务，负责分支注册，状态汇报，并接收事务协调器的指令，驱动分支（本地）事务的提交和回滚；

处理过程

- 下载地址

• 怎么玩

  Spring 本地@Transactional

  全局@GlobalTransactional

2、Seata-Server安装

• 官网地址

• 下载版本1.1.0

• seata-server-1.1.0.zip解压到指定目录并修改conf目录下的file.conf配置文件

  先备份原始file.conf文件

  主要修改：自定义事务组名称+事务日志存储模式为db+数据库连接信息

  file.conf

  service模块

  vgroup_mapping.my_test_tx_group = “fsp_tx_group”

  store模块

  mode = "db"
    url = "jdbc:mysql://127.0.0.1:3306/seata"
    user = "root"
    password = "你自己的密码"
  

• mysql5.7数据库新建库seata

• 在seata库里建表

  建表db_store.sql在\seata-server-1.1.0\seata\conf目录里面 db_store.sql

  SQL

  -- the table to store GlobalSession data
  drop table if exists `global_table`;
  create table `global_table` (
    `xid` varchar(128)  not null,
    `transaction_id` bigint,
    `status` tinyint not null,
    `application_id` varchar(32),
    `transaction_service_group` varchar(32),
    `transaction_name` varchar(128),
    `timeout` int,
    `begin_time` bigint,
    `application_data` varchar(2000),
    `gmt_create` datetime,
    `gmt_modified` datetime,
    primary key (`xid`),
    key `idx_gmt_modified_status` (`gmt_modified`, `status`),
    key `idx_transaction_id` (`transaction_id`)
  );
   
  -- the table to store BranchSession data
  drop table if exists `branch_table`;
  create table `branch_table` (
    `branch_id` bigint not null,
    `xid` varchar(128) not null,
    `transaction_id` bigint ,
    `resource_group_id` varchar(32),
    `resource_id` varchar(256) ,
    `lock_key` varchar(128) ,
    `branch_type` varchar(8) ,
    `status` tinyint,
    `client_id` varchar(64),
    `application_data` varchar(2000),
    `gmt_create` datetime,
    `gmt_modified` datetime,
    primary key (`branch_id`),
    key `idx_xid` (`xid`)
  );
   
  -- the table to store lock data
  drop table if exists `lock_table`;
  create table `lock_table` (
    `row_key` varchar(128) not null,
    `xid` varchar(96),
    `transaction_id` long ,
    `branch_id` long,
    `resource_id` varchar(256) ,
    `table_name` varchar(32) ,
    `pk` varchar(36) ,
    `gmt_create` datetime ,
    `gmt_modified` datetime,
    primary key(`row_key`)
  );
  
  

• 修改seata-server-1.0.0\seata\conf目录下的registry.conf配置文件

registry {
  # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
  type = "nacos"
 
  nacos {
    serverAddr = "localhost:8848"
    namespace = ""
    cluster = "default"
  }

目的是：指明注册中心为nacos，及修改nacos连接信息

• 先启动Nacos端口号8848
• 再启动seata-server

3、订单/库存/账户业务数据库准备

• 以下演示都需要先启动Nacos后启动Seata，保证两个都OK

  Seata没启动报错no available server to connect

• 分布式事务业务说明

  业务说明

下订单–>扣库存–>减账户（余额）

• 创建业务数据库

  seata_order: 存储订单的数据库

  seata_storage:存储库存的数据库

  seata_account: 存储账户信息的数据库

• 建表SQL

  CREATE DATABASE seata_order；
   
  CREATE DATABASE seata_storage；
   
  CREATE DATABASE seata_account；
  

• 按照上述3库分别建对应业务表

  seata_order库下建t_order表

  CREATE TABLE t_order(
      `id` BIGINT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
      `user_id` BIGINT(11) DEFAULT NULL COMMENT '用户id',
      `product_id` BIGINT(11) DEFAULT NULL COMMENT '产品id',
      `count` INT(11) DEFAULT NULL COMMENT '数量',
      `money` DECIMAL(11,0) DEFAULT NULL COMMENT '金额',
      `status` INT(1) DEFAULT NULL COMMENT '订单状态：0：创建中; 1：已完结'
  ) ENGINE=INNODB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
   
  SELECT * FROM t_order;
  

  seata_storage库下建t_storage表

  CREATE TABLE t_storage(
      `id` BIGINT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY,
      `product_id` BIGINT(11) DEFAULT NULL COMMENT '产品id',
     `total` INT(11) DEFAULT NULL COMMENT '总库存',
      `used` INT(11) DEFAULT NULL COMMENT '已用库存',
      `residue` INT(11) DEFAULT NULL COMMENT '剩余库存'
  ) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
   
  INSERT INTO seata_storage.t_storage(`id`,`product_id`,`total`,`used`,`residue`)
  VALUES('1','1','100','0','100');
   
   
  SELECT * FROM t_storage;
  

  seata_account库下建t_account表

  CREATE TABLE t_account(
      `id` BIGINT(11) NOT NULL AUTO_INCREMENT PRIMARY KEY COMMENT 'id',
      `user_id` BIGINT(11) DEFAULT NULL COMMENT '用户id',
      `total` DECIMAL(10,0) DEFAULT NULL COMMENT '总额度',
      `used` DECIMAL(10,0) DEFAULT NULL COMMENT '已用余额',
      `residue` DECIMAL(10,0) DEFAULT '0' COMMENT '剩余可用额度'
  ) ENGINE=INNODB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
   
  INSERT INTO seata_account.t_account(`id`,`user_id`,`total`,`used`,`residue`) VALUES('1','1','1000','0','1000')
   
   
   
  SELECT * FROM t_account;
  

• 按照上述3库分别建对应的回滚日志表

  订单-库存-账户3个库下都需要建各自的回滚日志表

  \seata-server-1.1.0\seata\conf目录下的db_undo_log.sql

  SQL

  drop table `undo_log`;
  CREATE TABLE `undo_log` (
    `id` bigint(20) NOT NULL AUTO_INCREMENT,
    `branch_id` bigint(20) NOT NULL,
    `xid` varchar(100) NOT NULL,
    `context` varchar(128) NOT NULL,
    `rollback_info` longblob NOT NULL,
    `log_status` int(11) NOT NULL,
    `log_created` datetime NOT NULL,
    `log_modified` datetime NOT NULL,
    `ext` varchar(100) DEFAULT NULL,
    PRIMARY KEY (`id`),
    UNIQUE KEY `ux_undo_log` (`xid`,`branch_id`)
  ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
  

• 最终效果

4、订单/库存/账户业务微服务准备

• 新建库新建订单Order-Module

  1.seata-order-service2001

  2.POM

   <dependencies>
          <!--nacos-->
          <dependency>
              <groupId>com.alibaba.cloud</groupId>
              <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
          </dependency>
          <!--seata-->
          <dependency>
              <groupId>com.alibaba.cloud</groupId>
              <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
              <exclusions>
                  <exclusion>
                      <artifactId>seata-all</artifactId>
                      <groupId>io.seata</groupId>
                  </exclusion>
              </exclusions>
          </dependency>
          <dependency>
              <groupId>io.seata</groupId>
              <artifactId>seata-all</artifactId>
              <version>1.0.0</version>
          </dependency>
          <!--feign-->
          <dependency>
              <groupId>org.springframework.cloud</groupId>
              <artifactId>spring-cloud-starter-openfeign</artifactId>
          </dependency>
          <!--web-actuator-->
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-web</artifactId>
          </dependency>
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-actuator</artifactId>
          </dependency>
          <!--mysql-druid-->
          <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>8.0.11</version>
          </dependency>
          <dependency>
              <groupId>com.alibaba</groupId>
              <artifactId>druid-spring-boot-starter</artifactId>
          </dependency>
          <dependency>
              <groupId>org.mybatis.spring.boot</groupId>
              <artifactId>mybatis-spring-boot-starter</artifactId>
          </dependency>
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-test</artifactId>
              <scope>test</scope>
          </dependency>
          <dependency>
              <groupId>org.projectlombok</groupId>
              <artifactId>lombok</artifactId>
              <optional>true</optional>
          </dependency>
      </dependencies>
  

  3.YML

  server:
    port: 2001
  
  spring:
    application:
      name: seata-order-service
    cloud:
      alibaba:
        seata:
          #自定义事务组名称需要与seata-server中的对应
          tx-service-group: fsp_tx_group
      nacos:
        discovery:
          server-addr: localhost:8848
    datasource:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://192.168.149.102:3306/seata_order
      username: root
      password: 123
  
  feign:
    hystrix:
      enabled: false
  
  logging:
    level:
      io:
        seata: info
  
  mybatis:
    mapperLocations: classpath:mapper/*.xml
  

  4.file.conf(seata配置)

  service {
    #transaction service group mapping
    vgroup_mapping.fsp_tx_group = "default"
    #only support when registry.type=file, please don't set multiple addresses
    default.grouplist = "127.0.0.1:8091"
    #disable seata
    disableGlobalTransaction = false
  }
  
  ## transaction log store, only used in seata-server
  store {
    ## store mode: file、db
    mode = "db"
  
    ## file store property
    file {
      ## store location dir
      dir = "sessionStore"
    }
  
    ## database store property
    db {
      ## the implement of javax.sql.DataSource, such as DruidDataSource(druid)/BasicDataSource(dbcp) etc.
      datasource = "dbcp"
      ## mysql/oracle/h2/oceanbase etc.
      db-type = "mysql"
      driver-class-name = "com.mysql.jdbc.Driver"
      url = "jdbc:mysql://192.168.149.102:3306/seata"
      user = "root"
      password = "123"
    }
  }
  

  5.registry.conf

  registry {
    # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
    type = "nacos"
  
    nacos {
      serverAddr = "localhost:8848"
      namespace = ""
      cluster = "default"
    }
    eureka {
      serviceUrl = "http://localhost:8761/eureka"
      application = "default"
      weight = "1"
    }
    redis {
      serverAddr = "localhost:6379"
      db = "0"
    }
    zk {
      cluster = "default"
      serverAddr = "127.0.0.1:2181"
      session.timeout = 6000
      connect.timeout = 2000
    }
    consul {
      cluster = "default"
      serverAddr = "127.0.0.1:8500"
    }
    etcd3 {
      cluster = "default"
      serverAddr = "http://localhost:2379"
    }
    sofa {
      serverAddr = "127.0.0.1:9603"
      application = "default"
      region = "DEFAULT_ZONE"
      datacenter = "DefaultDataCenter"
      cluster = "default"
      group = "SEATA_GROUP"
      addressWaitTime = "3000"
    }
    file {
      name = "file.conf"
    }
  }
  
  config {
    # file、nacos 、apollo、zk、consul、etcd3
    type = "file"
  
    nacos {
      serverAddr = "localhost"
      namespace = ""
    }
    consul {
      serverAddr = "127.0.0.1:8500"
    }
    apollo {
      app.id = "seata-server"
      apollo.meta = "http://192.168.1.204:8801"
    }
    zk {
      serverAddr = "127.0.0.1:2181"
      session.timeout = 6000
      connect.timeout = 2000
    }
    etcd3 {
      serverAddr = "http://localhost:2379"
    }
    file {
      name = "file.conf"
    }
  }
  

  6.domain

  • CommonResult

  @Data
  @AllArgsConstructor
  @NoArgsConstructor
  public class CommonResult<T>
  {
      private Integer code;
      private String  message;
      private T       data;
   
      public CommonResult(Integer code, String message)
      {
          this(code,message,null);
      }
  }
  

  • Order

  import java.math.BigDecimal;
   
  @Data
  @AllArgsConstructor
  @NoArgsConstructor
  public class Order
  {
      private Long id;
   
      private Long userId;
   
      private Long productId;
   
      private Integer count;
   
      private BigDecimal money;
   
      private Integer status; //订单状态：0：创建中；1：已完结
  }
  

  7.Dao接口及实现

  • OrderDao

  @Mapper
  public interface OrderDao {
  
      //创建订单
      void create(Order order);
  
      //修改订单状态
      void update(@Param("userId") Long userId, @Param("status") Integer status);
  }
  
  

  • resources文件夹下新建mapper文件夹后添加OrderMapper.xml

  <?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  <mapper namespace="com.atguigu.springcloud.alibaba.dao.OrderDao">
  
      <resultMap id="order" type="com.atguigu.springcloud.alibaba.domain.Order">
          <result property="id" column="id" jdbcType="BIGINT"/>
          <result property="user_id" column="userId" jdbcType="BIGINT"/>
          <result property="product_id" column="productId" jdbcType="BIGINT"/>
          <result property="count" column="count" jdbcType="INTEGER"/>
          <result property="money" column="money" jdbcType="BIGINT"/>
          <result property="status" column="status" jdbcType="INTEGER"/>
      </resultMap>
  
  
      <insert id="create">
          insert into t_order(user_id,product_id,count,money,status)
          value (#{userId},#{productId},#{count},#{money},0)
      </insert>
  
      <update id="update">
          update t_order set status = 1
          where user_id = #{userId} and status = #{status}
      </update>
  </mapper>
  

  8.Service接口及实现

  • OrderService

    public interface OrderService {
    
        void create(Order order);
    }
    

    • OrderServiceImpl

      @Service
      @Slf4j
      public class OrderServiceImpl implements OrderService {
      
          @Resource
          private OrderDao orderDao;
          @Resource
          private StorageService storageService;
          @Resource
          private AccountService accountService;
      //
      //    @GlobalTransactional(name = "fsp-create-order",rollbackFor = Exception.class)
          @Override
          public void create(Order order) {
              log.info("-------->开始创建新订单");
              orderDao.create(order);
      
      
              log.info("--------订单微服务开始调用库存,做扣减");
              storageService.decrease(order.getProductId(),order.getCount());
              log.info("-------订单微服务开始调用库存，做扣减end");
      
              log.info("-------订单微服务开始调用账户，做扣减");
              accountService.decrease(order.getUserId(),order.getMoney());
              log.info("-------订单微服务开始调用账户，做扣减end");
      
      
              log.info("-------修改订单状态");
              orderDao.update(order.getUserId(),0);
              log.info("-------修改订单状态结束");
      
      
              log.info("--------下订单结束了，哈哈哈哈");
          }
      }
      

  • StorageService

    @FeignClient(value = "seata-storage-service")
    public interface StorageService{
        @PostMapping(value = "/storage/decrease")
        CommonResult decrease(@RequestParam("productId") Long productId, @RequestParam("count") Integer count);
    }
    

  • AccountService

    @FeignClient(value = "seata-account-service")
    public interface AccountService{
        @PostMapping(value = "/account/decrease")
        CommonResult decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money);
    }
    

  9.Controller

  @RestController
  public class OrderController{
      @Resource
      private OrderService orderService;
   
   
      @GetMapping("/order/create")
      public CommonResult create(Order order)
      {
          orderService.create(order);
          return new CommonResult(200,"订单创建成功");
      }
  }
  

  10.Config配置

  • MyBatisConfig

    @Configuration
    @MapperScan({"com.atguigu.springcloud.alibaba.dao"})
    public class MybatisConfig {
    }
    

  • DataSourceProxyConfig

    @Configuration
    public class DataSourceProxyConfig {
    
    //    @Value("${mybatis.mapperLocations}")
    //    private String mapperLocations;
    
        @Bean
        @ConfigurationProperties(prefix = "spring.datasource")
        public DataSource druidDataSource() {
            return new DruidDataSource();
        }
    
        @Bean
        public DataSourceProxy dataSourceProxy(DataSource dataSource) {
            return new DataSourceProxy(dataSource);
        }
    
        @Bean
        public SqlSessionFactory sqlSessionFactoryBean(DataSourceProxy dataSourceProxy) throws Exception {
            SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
            sqlSessionFactoryBean.setDataSource(dataSourceProxy);
            sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mapper/*.xml"));
    //        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources(mapperLocations));
            sqlSessionFactoryBean.setTransactionFactory(new SpringManagedTransactionFactory());
            return sqlSessionFactoryBean.getObject();
        }
    }
    

  11.主启动

  @SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
  @EnableFeignClients
  @EnableDiscoveryClient
  public class SeataOrderMainApp2001 {
      public static void main(String[] args) {
          SpringApplication.run(SeataOrderMainApp2001.class,args);
      }
  }
  

• 新建库存Storage-Module

  1.seata-order-service2002

  2.POM

      <dependencies>
          <!--nacos-->
          <dependency>
              <groupId>com.alibaba.cloud</groupId>
              <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
          </dependency>
          <!--seata-->
          <dependency>
              <groupId>com.alibaba.cloud</groupId>
              <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
              <exclusions>
                  <exclusion>
                      <artifactId>seata-all</artifactId>
                      <groupId>io.seata</groupId>
                  </exclusion>
              </exclusions>
          </dependency>
          <dependency>
              <groupId>io.seata</groupId>
              <artifactId>seata-all</artifactId>
              <version>1.0.0</version>
          </dependency>
          <!--feign-->
          <dependency>
              <groupId>org.springframework.cloud</groupId>
              <artifactId>spring-cloud-starter-openfeign</artifactId>
          </dependency>
          <!--web-actuator-->
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-web</artifactId>
          </dependency>
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-actuator</artifactId>
          </dependency>
          <!--mysql-druid-->
          <dependency>
              <groupId>mysql</groupId>
              <artifactId>mysql-connector-java</artifactId>
              <version>8.0.11</version>
          </dependency>
          <dependency>
              <groupId>com.alibaba</groupId>
              <artifactId>druid-spring-boot-starter</artifactId>
          </dependency>
          <dependency>
              <groupId>org.mybatis.spring.boot</groupId>
              <artifactId>mybatis-spring-boot-starter</artifactId>
          </dependency>
          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-test</artifactId>
              <scope>test</scope>
          </dependency>
          <dependency>
              <groupId>org.projectlombok</groupId>
              <artifactId>lombok</artifactId>
              <optional>true</optional>
          </dependency>
      </dependencies>
  

  3.YML

  server:
    port: 2002
  
  spring:
    application:
      name: seata-storage-service
    cloud:
      alibaba:
        seata:
          #自定义事务组名称需要与seata-server中的对应
          tx-service-group: fsp_tx_group
      nacos:
        discovery:
          server-addr: localhost:8848
    datasource:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://192.168.149.102:3306/seata_storage
      username: root
      password: 123
  
  feign:
    hystrix:
      enabled: false
  
  logging:
    level:
      io:
        seata: info
  
  mybatis:
    mapperLocations: classpath:mapper/*.xml
  

  4.file.conf

  service {
    #transaction service group mapping
    vgroup_mapping.fsp_tx_group = "default"
    #only support when registry.type=file, please don't set multiple addresses
    default.grouplist = "127.0.0.1:8091"
    #disable seata
    disableGlobalTransaction = false
  }
  
  ## transaction log store, only used in seata-server
  store {
    ## store mode: file、db
    mode = "db"
  
    ## file store property
    file {
      ## store location dir
      dir = "sessionStore"
    }
  
    ## database store property
    db {
      ## the implement of javax.sql.DataSource, such as DruidDataSource(druid)/BasicDataSource(dbcp) etc.
      datasource = "dbcp"
      ## mysql/oracle/h2/oceanbase etc.
      db-type = "mysql"
      driver-class-name = "com.mysql.jdbc.Driver"
      url = "jdbc:mysql://192.168.149.102:3306/seata"
      user = "root"
      password = "123"
    }
  }
  

  5.registry.conf

  registry {
    # file 、nacos 、eureka、redis、zk、consul、etcd3、sofa
    type = "nacos"
  
    nacos {
      serverAddr = "localhost:8848"
      namespace = ""
      cluster = "default"
    }
    eureka {
      serviceUrl = "http://localhost:8761/eureka"
      application = "default"
      weight = "1"
    }
    redis {
      serverAddr = "localhost:6379"
      db = "0"
    }
    zk {
      cluster = "default"
      serverAddr = "127.0.0.1:2181"
      session.timeout = 6000
      connect.timeout = 2000
    }
    consul {
      cluster = "default"
      serverAddr = "127.0.0.1:8500"
    }
    etcd3 {
      cluster = "default"
      serverAddr = "http://localhost:2379"
    }
    sofa {
      serverAddr = "127.0.0.1:9603"
      application = "default"
      region = "DEFAULT_ZONE"
      datacenter = "DefaultDataCenter"
      cluster = "default"
      group = "SEATA_GROUP"
      addressWaitTime = "3000"
    }
    file {
      name = "file.conf"
    }
  }
  
  config {
    # file、nacos 、apollo、zk、consul、etcd3
    type = "file"
  
    nacos {
      serverAddr = "localhost"
      namespace = ""
    }
    consul {
      serverAddr = "127.0.0.1:8500"
    }
    apollo {
      app.id = "seata-server"
      apollo.meta = "http://192.168.1.204:8801"
    }
    zk {
      serverAddr = "127.0.0.1:2181"
      session.timeout = 6000
      connect.timeout = 2000
    }
    etcd3 {
      serverAddr = "http://localhost:2379"
    }
    file {
      name = "file.conf"
    }
  }
  
  

  6.domain

  • CommonResult

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class CommonResult<T>
    {
        private Integer code;
        private String  message;
        private T       data;
    
        public CommonResult(Integer code, String message)
        {
            this(code,message,null);
        }
    }
    

  • Storage

    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Storage {
    
        private Long id;
    
        // 产品id
        private Long productId;
    
        //总库存
        private Integer total;
    
    
        //已用库存
        private Integer used;
    
    
        //剩余库存
        private Integer residue;
    }
    

  7.Dao接口及实现

  • StorageDao

     
    @Mapper
    public interface StorageDao {
    
     
        //扣减库存信息
        void decrease(@Param("productId") Long productId, @Param("count") Integer count);
    }
    

  • resources文件夹下新建mapper文件夹后添加StorageMapper.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
     
     
    <mapper namespace="com.atguigu.springcloud.alibaba.dao.StorageDao">
     
        <resultMap id="BaseResultMap" type="com.atguigu.springcloud.alibaba.domain.Storage">
            <id column="id" property="id" jdbcType="BIGINT"/>
            <result column="product_id" property="productId" jdbcType="BIGINT"/>
            <result column="total" property="total" jdbcType="INTEGER"/>
            <result column="used" property="used" jdbcType="INTEGER"/>
            <result column="residue" property="residue" jdbcType="INTEGER"/>
        </resultMap>
     
        <update id="decrease">
            UPDATE
                t_storage
            SET
                used = used + #{count},residue = residue - #{count}
            WHERE
                product_id = #{productId}
        </update>
     
    </mapper>
    
    

  8.Service接口及实现

  • StorageService

    public interface StorageService {
        
         // 扣减库存
        void decrease(Long productId, Integer count);
    }
    

    • StorageServiceImpl

      @Service
      public class StorageServiceImpl implements StorageService {
       
          private static final Logger LOGGER = LoggerFactory.getLogger(StorageServiceImpl.class);
       
          @Resource
          private StorageDao storageDao;
       
           // 扣减库存
          @Override
          public void decrease(Long productId, Integer count) {
              LOGGER.info("------->storage-service中扣减库存开始");
              storageDao.decrease(productId,count);
              LOGGER.info("------->storage-service中扣减库存结束");
          }
      }
      

  9.Controller

  @RestController
  public class StorageController {
   
      @Autowired
      private StorageService storageService;
   
   
      //扣减库存
      @RequestMapping("/storage/decrease")
      public CommonResult decrease(Long productId, Integer count) {
          storageService.decrease(productId, count);
          return new CommonResult(200,"扣减库存成功！");
      }
  }
  

  10.Config配置 同订单Order-Module

  11.主启动

  @SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
  @EnableDiscoveryClient
  @EnableFeignClients
  public class SeataStorageServiceApplication2002
  {
      public static void main(String[] args)
      {
          SpringApplication.run(SeataStorageServiceApplication2002.class, args);
      }
  }
  

• 新建账户Account-Module

  1.seata-order-service2003

  2.POM 同上模块

  3.YML

  server:
    port: 2003
  
  spring:
    application:
      name: seata-account-service
    cloud:
      alibaba:
        seata:
          #自定义事务组名称需要与seata-server中的对应
          tx-service-group: fsp_tx_group
      nacos:
        discovery:
          server-addr: localhost:8848
    datasource:
      driver-class-name: com.mysql.jdbc.Driver
      url: jdbc:mysql://192.168.149.102:3306/seata_account
      username: root
      password: 123
  
  feign:
    hystrix:
      enabled: false
  
  logging:
    level:
      io:
        seata: info
  
  mybatis:
    mapperLocations: classpath:mapper/*.xml
  

  4.file.conf 同上

  5.registry.conf 同上

  6.domain

  • CommonResult

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class CommonResult<T>
    {
        private Integer code;
        private String  message;
        private T       data;
     
        public CommonResult(Integer code, String message)
        {
            this(code,message,null);
        }
    }
    

  • Account

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Account {
     
        private Long id;
     
        /**
         * 用户id
         */
        private Long userId;
     
        /**
         * 总额度
         */
        private BigDecimal total;
     
        /**
         * 已用额度
         */
        private BigDecimal used;
     
        /**
         * 剩余额度
         */
        private BigDecimal residue;
    }
    

  7.Dao接口及实现

  • AccountDao

    @Mapper
    public interface AccountDao {
     
        /**
         * 扣减账户余额
         */
        void decrease(@Param("userId") Long userId, @Param("money") BigDecimal money);
    }
    

  • resources文件夹下新建mapper文件夹后添加AccountMapper.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
     
    <mapper namespace="com.atguigu.springcloud.alibaba.dao.AccountDao">
     
        <resultMap id="BaseResultMap" type="com.atguigu.springcloud.alibaba.domain.Account">
            <id column="id" property="id" jdbcType="BIGINT"/>
            <result column="user_id" property="userId" jdbcType="BIGINT"/>
            <result column="total" property="total" jdbcType="DECIMAL"/>
            <result column="used" property="used" jdbcType="DECIMAL"/>
            <result column="residue" property="residue" jdbcType="DECIMAL"/>
        </resultMap>
     
        <update id="decrease">
            UPDATE t_account
            SET
              residue = residue - #{money},used = used + #{money}
            WHERE
              user_id = #{userId};
        </update>
     
    </mapper>
    

  8.Service接口及实现

  • AccountService

     
    public interface AccountService {
     
        /**
         * 扣减账户余额
         */
        void decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money);
    }
    

  • AccountServiceImpl

    @Service
    public class AccountServiceImpl implements AccountService {
     
        private static final Logger LOGGER = LoggerFactory.getLogger(AccountServiceImpl.class);
     
     
        @Resource
        AccountDao accountDao;
     
        /**
         * 扣减账户余额
         */
        @Override
        public void decrease(Long userId, BigDecimal money) {
            
             LOGGER.info("------->account-service中扣减账户余额开始");
            try { TimeUnit.SECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); }
            accountDao.decrease(userId,money);
            LOGGER.info("------->account-service中扣减账户余额结束");
        }
    }
    

  9.Controller

  @RestController
  public class AccountController {
   
      @Resource
      AccountService accountService;
   
      /**
       * 扣减账户余额
       */
      @RequestMapping("/account/decrease")
      public CommonResult decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money){
          accountService.decrease(userId,money);
          return new CommonResult(200,"扣减账户余额成功！");
      }
  }
  

  10.Config配置 同其他模块

  11.主启动

   
  @SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
  @EnableDiscoveryClient
  @EnableFeignClients
  public class SeataAccountMainApp2003
  {
      public static void main(String[] args)
      {
          SpringApplication.run(SeataAccountMainApp2003.class, args);
      }
  }
  

• Test

  下订单->减库存->扣余额->改（订单）状态

数据库初始情况

正常下单

访问http://localhost:2001/order/create?userId=1&productId=1&count=10&money=100

数据库情况

超时异常，没加@GlobalTransactional

AccountServiceImpl添加超时

   @Override
    public void decrease(Long userId, BigDecimal money) {
        log.info("账户扣除余额开始---");
        try {
            TimeUnit.SECONDS.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(userId);
        accountDao.decrease(userId, money);
        log.info("账户扣除余额结束---");
    }
}

结果

1、当库存和账户余额扣减后，订单状态并没有设置为已经完成，没有从零改为1

2、而且由于feign的重试机制，账户余额还有可能被多次扣减

超时异常，添加@GlobalTransactional

• AccountServiceImpl添加超时

• OrderServiceImpl@GlobalTransactiona

• 下单后数据库数据并没有任何改变

• 记录都添加不进数据库

5、Seata之原理简介再次回顾

1、再看TC/TM/RM三大组件

分布式事务的执行流程

• TM开启分布式事务(TM向TC注册全局事务记录)
• 换业务场景，编排数据库，服务等事务内资源（RM向TC汇报资源准备状态）
• TM结束分布式事务，事务一阶段结束（TM通知TC提交/回滚分布式事务）
• TC汇总事务信息，决定分布式事务是提交还是回滚
• TC通知所有RM提交/回滚资源，事务二阶段结束。

2、AT模式如何做到对业务的无侵入

是什么

一阶段加载


二阶段提交

二阶段回滚

补充