Spring Cloud（二十六）：SpringCloud Alibaba Seata处理分布式事务

秒速五厘米 2022-10-22 07:49 238阅读 0赞

## 1. 分布式事务问题 ##

### 1.1 分布式前 ###

单机单库没这个问题

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

### 1.2 分布式之后 ###

单体应用被拆分微服务应用，原来的三个模块被拆分成三个独立的应用，分别使用三个独立的数据源，业务操作需要调用三个服务来完成，此时每个服务内部的数据一致性由本地事务来保证，但是全局的数据一致性问题没法保证：  
用户购买商品的业务逻辑，整个业务逻辑由三个微服务提供支持：  
仓储服务：对卖的商品扣除仓储数量  
订单服务：根据采购需求创建订单  
账户服务：从用户账户中扣除余额

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

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

*  Transaction ID XID  
    全局唯一的事务ID
 *  Transaction Coordinator(TC)：事务协调器，维护全局事务的运行状态，负责协调并驱动全局事务的提交或回滚；
 *  Transaction Manager™：控制全局事务的边界，负责开启一个全局事务，并最终发起全局提交或全局回滚的决议;
 *  Resource Manager(RM)：控制分支事务，负责分支注册，状态汇报，并接收事务协调器的指令，驱动分支（本地）事务的提交和回滚；

**处理过程**

*  TM向TC申请开启一个全局事务，全局事务创建成功并生成一个全局唯一的XID
 *  XID在微服务调用链路的上下文中传播
 *  RM向TC注册分支事务，将其纳入XID对应全局事务的管辖
 *  TM向TC发起针对XID的全局提交或回滚决议
 *  TC调度XID下管辖的全部分支事务完成提交或回滚请求  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70]

**下载**  
发布说明:https://github.com/seata/seata/releases

**使用**

*  Spring 本地@Transactional
 *  全局@GlobalTransactional  
    SEATA的分布式交易解决方案  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70 1]

## 2. Seata-Server安装 ##

**官网地址**  
http://seata.io/zh-cn/

**下载版本**  
![在这里插入图片描述][20210405155258901.png]

**解压到指定目录并修改conf目录下的file.conf配置文件**  
主要修改：自定义事务组名称+事务日志存储模式为db+数据库连接信息

*  service模块（file.conf）  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70 2]
 *  store模块（file.conf）  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70 3]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70 4]  
    **数据库新建库seata**  
    建表db\_store.sql在\\seata-server-0.9.0\\seata\\conf目录里面

**修改seata\\conf目录下的registry.conf配置文件**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70 5]

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

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

### 3.1 分布式事务业务说明 ###

创建三个服务，一个订单服务，一个库存服务，一个账户服务

当用户下单时，会在订单服务中创建一个订单，然后通过远程调用库存服务来扣减下单商品的库存，在通过远程调用账户服务来扣减用户账户里面的余额，最后在订单服务中修改订单状态为已完成。

该操作跨越三个数据库，有两次远程调用，很明显会有分布式事务问题

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

### 3.2 创建业务数据库 ###

*  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 t_account(`id`,`user_id`,`total`,`used`,`residue`) VALUES('1','1','1000','0','1000');
    SELECT * FROM t_account;

**按照上述3库分别建对应的回滚日志表**  
订单-库存-账户3个库下都需要建各自的回滚日志表

seata\\conf目录下的db\_undo\_log.sql

-- the table to store seata xid data
    -- 0.7.0+ add context
    -- you must to init this sql for you business databese. the seata server not need it.
    -- 此脚本必须初始化在你当前的业务数据库中，用于AT 模式XID记录。与server端无关（注：业务数据库）
    -- 注意此处0.3.0+ 增加唯一索引 ux_undo_log
    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;

**最终效果**  
![在这里插入图片描述][20210405165920419.png]  
![在这里插入图片描述][2021040516593275.png]  
![在这里插入图片描述][20210405165941678.png]  
![在这里插入图片描述][2021040516595251.png]

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

**业务需求**  
下订单->减库存->扣余额->改（订单）状态

### 4.1 订单 ###

**新建订单Order-Module**  
seata-order-service2001

**pom**

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>spring-cloud-demo</artifactId>
            <groupId>com.lele.springcloud</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>seata-order-service2001</artifactId>
    
        <dependencies>
            
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
            
            <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>0.9.0</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>
            
            <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>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>1.1.10</version>
            </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>
    </project>

**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://localhost:3306/seata_order
        username: root
        password: root
    
    feign:
      hystrix:
        enabled: false
    
    logging:
      level:
        io:
          seata: info
    
    mybatis:
      mapper-locations: classpath:mapper/*.xml

**file.conf**

transport {
      # tcp udt unix-domain-socket
      type = "TCP"
      #NIO NATIVE
      server = "NIO"
      #enable heartbeat
      heartbeat = true
      #thread factory for netty
      thread-factory {
        boss-thread-prefix = "NettyBoss"
        worker-thread-prefix = "NettyServerNIOWorker"
        server-executor-thread-prefix = "NettyServerBizHandler"
        share-boss-worker = false
        client-selector-thread-prefix = "NettyClientSelector"
        client-selector-thread-size = 1
        client-worker-thread-prefix = "NettyClientWorkerThread"
        # netty boss thread size,will not be used for UDT
        boss-thread-size = 1
        #auto default pin or 8
        worker-thread-size = 8
      }
      shutdown {
        # when destroy server, wait seconds
        wait = 3
      }
      serialization = "seata"
      compressor = "none"
    }
    service {
      #vgroup->rgroup
      vgroup_mapping.fsp_tx_group = "default"  #修改自定义事务组名称
      default.grouplist = "127.0.0.1:8091"
      #degrade current not support
      enableDegrade = false
      #disable
      disable = false
      #unit ms,s,m,h,d represents milliseconds, seconds, minutes, hours, days, default permanent
      max.commit.retry.timeout = "-1"
      max.rollback.retry.timeout = "-1"
    }
    
    client {
      async.commit.buffer.limit = 10000
      lock {
        retry.internal = 10
        retry.times = 30
      }
      report.retry.count = 5
      tm.commit.retry.count = 1
      tm.rollback.retry.count = 1
    }
    
    ## transaction log store
    store {
      ## store mode: file、db
      mode = "db"
    
      ## file store
      file {
        dir = "sessionStore"
    
        # branch session size , if exceeded first try compress lockkey, still exceeded throws exceptions
        max-branch-session-size = 16384
        # globe session size , if exceeded throws exceptions
        max-global-session-size = 512
        # file buffer size , if exceeded allocate new buffer
        file-write-buffer-cache-size = 16384
        # when recover batch read size
        session.reload.read_size = 100
        # async, sync
        flush-disk-mode = async
      }
    
      ## database store
      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://127.0.0.1:3306/seata"
        user = "root"
        password = "root"
        min-conn = 1
        max-conn = 3
        global.table = "global_table"
        branch.table = "branch_table"
        lock-table = "lock_table"
        query-limit = 100
      }
    }
    lock {
      ## the lock store mode: local、remote
      mode = "remote"
    
      local {
        ## store locks in user's database
      }
    
      remote {
        ## store locks in the seata's server
      }
    }
    recovery {
      #schedule committing retry period in milliseconds
      committing-retry-period = 1000
      #schedule asyn committing retry period in milliseconds
      asyn-committing-retry-period = 1000
      #schedule rollbacking retry period in milliseconds
      rollbacking-retry-period = 1000
      #schedule timeout retry period in milliseconds
      timeout-retry-period = 1000
    }
    
    transaction {
      undo.data.validation = true
      undo.log.serialization = "jackson"
      undo.log.save.days = 7
      #schedule delete expired undo_log in milliseconds
      undo.log.delete.period = 86400000
      undo.log.table = "undo_log"
    }
    
    ## metrics settings
    metrics {
      enabled = false
      registry-type = "compact"
      # multi exporters use comma divided
      exporter-list = "prometheus"
      exporter-prometheus-port = 9898
    }
    
    support {
      ## spring
      spring {
        # auto proxy the DataSource bean
        datasource.autoproxy = false
      }
    }

**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"
      }
    }

**domain**  
CommonResult

package com.lele.springcloud.alibaba.domain;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * @author: lele
     * @date: 2021/4/5 18:43
     * @description:
     */
    @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

package com.lele.springcloud.alibaba.domain;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    import java.math.BigDecimal;
    
    /**
     * @author: lele
     * @date: 2021/4/5 18:44
     * @description:
     */
    @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：已完结
    }

**Dao接口及实现**

package com.lele.springcloud.alibaba.dao;
    
    import com.lele.springcloud.alibaba.domain.Order;
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Param;
    
    /**
     * @author: lele
     * @date: 2021/4/5 18:48
     * @description:
     */
    @Mapper
    public interface OrderDao {
        
        //新建订单
        void create(Order order);
    
        //修改订单状态，从零改为1
        void update(@Param("userId") Long userId, @Param("status") Integer status);
    }

resources文件夹下新建mapper文件夹后添加：

<?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.lele.springcloud.alibaba.dao.OrderDao">
        <resultMap id="BaseResultMap" type="com.lele.springcloud.alibaba.domain.Order">
            <id column="id" property="id" jdbcType="BIGINT"/>
            <result column="user_id" property="userId" jdbcType="BIGINT"/>
            <result column="product_id" property="productId" jdbcType="BIGINT"/>
            <result column="count" property="count" jdbcType="INTEGER"/>
            <result column="money" property="money" jdbcType="DECIMAL"/>
            <result column="status" property="status" jdbcType="INTEGER"/>
        </resultMap>
    
        <insert id="create">
            insert into t_order (id,user_id,product_id,count,money,status)
            values (null,#{userId},#{productId},#{count},#{money},0);
        </insert>
        
        <update id="update">
            update t_order set status = 1
            where user_id=#{userId} and status = #{status};
        </update>
    </mapper>

**Service接口及实现**

package com.lele.springcloud.alibaba.service;
    
    import com.lele.springcloud.alibaba.domain.Order;
    
    /**
     * @author: lele
     * @date: 2021/4/5 18:57
     * @description:
     */
    public interface OrderService {
        
        void create(Order order);
    }

package com.lele.springcloud.alibaba.service.impl;
    
    import com.lele.springcloud.alibaba.dao.OrderDao;
    import com.lele.springcloud.alibaba.domain.Order;
    import com.lele.springcloud.alibaba.service.OrderService;
    import io.seata.spring.annotation.GlobalTransactional;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    
    /**
     * @author: lele
     * @date: 2021/4/5 18:57
     * @description:
     */
    @Service
    @Slf4j
    public class OrderServiceImpl implements OrderService {
        
        @Resource
        private OrderDao orderDao;
        @Resource
        private StorageService storageService;
        @Resource
        private AccountService accountService;
    
        /**
         * 创建订单->调用库存服务扣减库存->调用账户服务扣减账户余额->修改订单状态
         */
    
        @Override
        @GlobalTransactional(name = "fsp-create-order",rollbackFor = Exception.class)
        public void create(Order order){
        
            log.info("----->开始新建订单");
            //新建订单
            orderDao.create(order);
    
            //扣减库存
            log.info("----->订单微服务开始调用库存，做扣减Count");
            storageService.decrease(order.getProductId(),order.getCount());
            log.info("----->订单微服务开始调用库存，做扣减end");
    
            //扣减账户
            log.info("----->订单微服务开始调用账户，做扣减Money");
            accountService.decrease(order.getUserId(),order.getMoney());
            log.info("----->订单微服务开始调用账户，做扣减end");
    
    
            //修改订单状态，从零到1代表已经完成
            log.info("----->修改订单状态开始");
            orderDao.update(order.getUserId(),0);
            log.info("----->修改订单状态结束");
    
            log.info("----->下订单结束了");
    
        }
    
    }

package com.lele.springcloud.alibaba.service;
    
    import com.lele.springcloud.alibaba.domain.CommonResult;
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    
    /**
     * @author: lele
     * @date: 2021/4/5 19:01
     * @description:
     */
    @FeignClient(value = "seata-storage-service")
    public interface StorageService {
        
        @PostMapping(value = "/storage/decrease")
        CommonResult decrease(@RequestParam("productId") Long productId, @RequestParam("count") Integer count);
    }

package com.lele.springcloud.alibaba.service;
    
    import com.lele.springcloud.alibaba.domain.CommonResult;
    import org.springframework.cloud.openfeign.FeignClient;
    import org.springframework.web.bind.annotation.PostMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    
    import java.math.BigDecimal;
    
    /**
     * @author: lele
     * @date: 2021/4/5 19:03
     * @description:
     */
    @FeignClient(value = "seata-account-service")
    public interface AccountService {
        
        @PostMapping(value = "/account/decrease")
        CommonResult decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money);
    }

**controller**

package com.lele.springcloud.alibaba.controller;
    
    import com.lele.springcloud.alibaba.domain.CommonResult;
    import com.lele.springcloud.alibaba.domain.Order;
    import com.lele.springcloud.alibaba.service.OrderService;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.annotation.Resource;
    
    /**
     * @author: lele
     * @date: 2021/4/5 19:04
     * @description:
     */
    @RestController
    public class OrderController {
        
        @Resource
        private OrderService orderService;
    
    
        @GetMapping("/order/create")
        public CommonResult create(Order order)
        {
        
            orderService.create(order);
            return new CommonResult(200,"订单创建成功");
        }
    
    }

**Config配置**

package com.lele.springcloud.alibaba.config;
    
    import org.mybatis.spring.annotation.MapperScan;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * @author: lele
     * @date: 2021/4/5 19:09
     * @description:
     */
    @Configuration
    @MapperScan({
        "com.lele.springcloud.alibaba.dao"})
    public class MyBatisConfig {
        
    }

package com.lele.springcloud.alibaba.config;
    
    import com.alibaba.druid.pool.DruidDataSource;
    import io.seata.rm.datasource.DataSourceProxy;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.mybatis.spring.SqlSessionFactoryBean;
    import org.mybatis.spring.transaction.SpringManagedTransactionFactory;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
    
    import javax.sql.DataSource;
    
    /**
     * @author: lele
     * @date: 2021/4/5 19:11
     * @description:
     */
    @Configuration
    public class DataSourceProxyConfig {
        
    
        @Value("${mybatis.mapper-locations}")
        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(mapperLocations));
            sqlSessionFactoryBean.setTransactionFactory(new SpringManagedTransactionFactory());
            return sqlSessionFactoryBean.getObject();
        }
    
    }

**主启动**

package com.lele.springcloud.alibaba;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.openfeign.EnableFeignClients;
    
    /**
     * @author: lele
     * @date: 2021/4/5 18:49
     * @description:
     */
    @EnableDiscoveryClient
    @EnableFeignClients
    @SpringBootApplication(exclude = DataSourceAutoConfiguration.class)//取消数据源自动创建的配置
    public class SeataOrderMainApp2001 {
        
        public static void main(String[] args) {
        
            SpringApplication.run(SeataOrderMainApp2001.class, args);
        }
    }

### 4.2 库存 ###

**新建库存Storage-Module**  
新建seata-storage-service2002模块

**pom**

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <parent>
            <artifactId>spring-cloud-demo</artifactId>
            <groupId>com.lele.springcloud</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>seata-storage-service2002</artifactId>
    
        <dependencies>
            
            <dependency>
                <groupId>com.alibaba.cloud</groupId>
                <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
            </dependency>
            
            <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>0.9.0</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-openfeign</artifactId>
            </dependency>
            
            <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>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid-spring-boot-starter</artifactId>
                <version>1.1.10</version>
            </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>
    </project>

**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://localhost:3306/seata_storage
        username: root
        password: root
    
    feign:
      hystrix:
        enabled: false
    
    logging:
      level:
        io:
          seata: info
    
    mybatis:
      mapper-locations: classpath:mapper/*.xml

**file.conf、registry.conf 同 订单2001**  
**domain**  
CommonResult 同订单2001  
Storage

package com.lele.springcloud.alibaba.domain;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * @author: lele
     * @date: 2021/4/5 19:35
     * @description:
     */
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class Storage {
        
        private Long id;
        
        private Long productId;
        
        private Integer total;
        
        private Integer used;
        
        private Integer residue;
    }

**dao**

package com.lele.springcloud.alibaba.dao;
    
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Param;
    
    /**
     * @author: lele
     * @date: 2021/4/5 19:39
     * @description:
     */
    @Mapper
    public interface StorageDao {
        
        // 扣减库存
        void decrease(@Param("productId") Long productId, @Param("count") Integer count);
    }

<?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.lele.springcloud.alibaba.dao.StorageDao">
        <resultMap id="BaseResultMap" type="com.lele.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>

**service及其实现类**

package com.lele.springcloud.alibaba.service;
    
    /**
     * @author: lele
     * @date: 2021/4/5 19:50
     * @description:
     */
    public interface StorageService {
        
        void decrease(Long productId, Integer count);
    }

package com.lele.springcloud.alibaba.service.impl;
    
    import com.lele.springcloud.alibaba.dao.StorageDao;
    import com.lele.springcloud.alibaba.service.StorageService;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    
    /**
     * @author: lele
     * @date: 2021/4/5 19:52
     * @description:
     */
    @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中扣减库存结束");
        }
    }

**controller**

package com.lele.springcloud.alibaba.controller;
    
    import com.lele.springcloud.alibaba.domain.CommonResult;
    import com.lele.springcloud.alibaba.service.StorageService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    /**
     * @author: lele
     * @date: 2021/4/5 19:57
     * @description:
     */
    @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, "扣减库存成功！");
        }
    }

**Config配置 同订单2001**  
**主启动类**

package com.lele.springcloud.alibaba;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.openfeign.EnableFeignClients;
    
    /**
     * @author: lele
     * @date: 2021/4/5 20:02
     * @description:
     */
    @SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
    @EnableDiscoveryClient
    @EnableFeignClients
    public class SeataStorageServiceApplication2002 {
        
        public static void main(String[] args) {
        
            SpringApplication.run(SeataStorageServiceApplication2002.class, args);
        }
    }

### 4.3 账户 ###

**新建账户Account-Module**  
新建seata-account-service2003

**pom同订单2001**

**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://localhost:3306/seata_account
        username: root
        password: root
    
    feign:
      hystrix:
        enabled: false
    
    logging:
      level:
        io:
          seata: info
    
    mybatis:
      mapper-locations: classpath:mapper/*.xml

**file.conf、registry.conf 同 订单2001**

**domain**  
CommonResult 同订单2001

package com.lele.springcloud.alibaba.domain;
    
    import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    
    /**
     * @author: lele
     * @date: 2021/4/5 18:43
     * @description:
     */
    @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);
        }
    
    }

**Dao**

package com.lele.springcloud.alibaba.dao;
    
    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Param;
    
    import java.math.BigDecimal;
    
    /**
     * @author: lele
     * @date: 2021/4/5 20:54
     * @description:
     */
    @Mapper
    public interface AccountDao {
        
        void decrease(@Param("userId") Long userId, @Param("money") BigDecimal money);
    }

<?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.lele.springcloud.alibaba.dao.AccountDao">
        <resultMap id="BaseResultMap" type="com.lele.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>

**service**

package com.lele.springcloud.alibaba.service;
    
    import org.springframework.web.bind.annotation.RequestParam;
    
    import java.math.BigDecimal;
    
    /**
     * @author: lele
     * @date: 2021/4/5 21:01
     * @description:
     */
    public interface AccountService {
        
        
        void decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money);
    }

package com.lele.springcloud.alibaba.service.impl;
    
    import com.lele.springcloud.alibaba.dao.AccountDao;
    import com.lele.springcloud.alibaba.service.AccountService;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    import java.math.BigDecimal;
    
    /**
     * @author: lele
     * @date: 2021/4/5 21:03
     * @description:
     */
    @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中扣减账户余额开始");
            // 模拟超时异常，全局事务回滚
            accountDao.decrease(userId, money);
            LOGGER.info("------>account-service中扣减账户余额结束");
        }
    }

**controller**

package com.lele.springcloud.alibaba.controller;
    
    import com.lele.springcloud.alibaba.domain.CommonResult;
    import com.lele.springcloud.alibaba.service.AccountService;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.annotation.Resource;
    import java.math.BigDecimal;
    
    /**
     * @author: lele
     * @date: 2021/4/5 21:08
     * @description:
     */
    @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, "扣减账户余额成功！");
        }
    }

**Config配置 同订单2001**  
**主启动类**

package com.lele.springcloud.alibaba;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
    import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
    import org.springframework.cloud.openfeign.EnableFeignClients;
    
    /**
     * @author: lele
     * @date: 2021/4/5 21:15
     * @description:
     */
    @SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
    @EnableDiscoveryClient
    @EnableFeignClients
    public class SeataAccountMainApp2003 {
        
    
        public static void main(String[] args) {
        
            SpringApplication.run(SeataAccountMainApp2003.class, args);
        }
    }

## 5. 测试 ##

下订单->减库存->扣余额->改（订单）状态  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70 6]  
**数据库初始情况**  
![在这里插入图片描述][20210405212144712.png]  
![在这里插入图片描述][20210405212158822.png]  
![在这里插入图片描述][20210405212209808.png]

正常下单:  
http://localhost:2001/order/create?userId=1&productId=1&count=10&money=100  
![在这里插入图片描述][20210405214010190.png]  
数据库情况:  
![在这里插入图片描述][20210405214101274.png]  
![在这里插入图片描述][20210405214114367.png]  
![在这里插入图片描述][20210405214132313.png]

**超时异常，没加@GlobalTransactional**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70 7]

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

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

**超时异常，添加@GlobalTransactional**  
下单后数据库数据并没有任何改变

## 6. Seata之原理简介 ##

![在这里插入图片描述][2021040521565679.png]  
**再看TC/TM/RM三大组件**

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

**AT模式如何做到对业务的无侵入**  
![在这里插入图片描述][20210405215822198.png]  
![在这里插入图片描述][20210405215839458.png]

**一阶段加载**  
![在这里插入图片描述][20210405215903901.png]  
![在这里插入图片描述][2021040521591561.png]

**二阶段提交**  
![在这里插入图片描述][2021040522000047.png]

**二阶段回滚**  
![在这里插入图片描述][2021040522003617.png]  
![在这里插入图片描述][20210405220047125.png]  
![在这里插入图片描述][20210405220103125.png]  
![在这里插入图片描述][20210405220118296.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70]: /images/20221022/5d41bba6dfb3496dadc3aa8725e31d72.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70 1]: /images/20221022/cbc7d9adf14e48fc9f6b6d035f6d15aa.png
[20210405155258901.png]: /images/20221022/eb4081657d6b427fa0035eb20cd5d97d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70 2]: /images/20221022/ba9249c280f7480dbcf49313145f9823.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70 3]: /images/20221022/481e9c829e68437ab4f36648d53ed902.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70 4]: /images/20221022/19080d3ff96b43feb7df774863c009ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70 5]: /images/20221022/540e62dcce1a470995940fc3fe31b432.png
[20210405165920419.png]: /images/20221022/80c74bf1a405409682f37bd1f142ce0d.png
[2021040516593275.png]: /images/20221022/ce6cecb5489b4d99a079cf2749293771.png
[20210405165941678.png]: /images/20221022/b87af7bb7bf143b8a5c79a369164072a.png
[2021040516595251.png]: /images/20221022/7a9d179c0c264d01973f1190434b47fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70 6]: /images/20221022/e07596710bb648e29fe48c584d3bd73c.png
[20210405212144712.png]: /images/20221022/e83613465c18439eacce98d8bdc75eb0.png
[20210405212158822.png]: /images/20221022/2a0c5eb1c1e246b1b52ea19888b601e8.png
[20210405212209808.png]: /images/20221022/5c4b1b66d7ad43de83e73429db6c4eb5.png
[20210405214010190.png]: /images/20221022/548ae018aab54c238b974324319f7817.png
[20210405214101274.png]: /images/20221022/8a57d66155944f4ea091bb34752d5208.png
[20210405214114367.png]: /images/20221022/cd7a3e05030e4293bc5029c7bf269219.png
[20210405214132313.png]: /images/20221022/0f637c0dccfb4b01802f805e975e54ce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvdXdhbmxl_size_16_color_FFFFFF_t_70 7]: /images/20221022/eb1453f087ee4146a5d4dc50a604972d.png
[2021040521565679.png]: /images/20221022/0bd73309983941028de9a74c708d4c5f.png
[20210405215822198.png]: /images/20221022/f85e3ea1b75c4c52917cbcd6c3c31bf2.png
[20210405215839458.png]: /images/20221022/a1e199373cd14e6585fd36244b7cf64e.png
[20210405215903901.png]: /images/20221022/bab15bcd3dd44cdf809239f239ed3b33.png
[2021040521591561.png]: /images/20221022/023475711ecb476e96b7670078fadfff.png
[2021040522000047.png]: /images/20221022/5a94b609c7cd4dd8a6ef5f17029dd501.png
[2021040522003617.png]: /images/20221022/2233f7cdfec041b0b8fc944c3e0d9931.png
[20210405220047125.png]: /images/20221022/a711a9a1e06c421ebea1afc18d22ea3f.png
[20210405220103125.png]: /images/20221022/b1b79770f0c54f93bdd6cdf8f13f1836.png
[20210405220118296.png]: /images/20221022/be889901e0964349b6f864c18592146c.png