springcloud(十七)--SpringCloud Alibaba Seata处理分布式事务

一、分布式事务问题

分布式之前
单机单库这个没有问题

分布式之后
单体应用被拆分成微服务应用，原来的三个模板被拆分三个独立的应用，分别使用三个独立的数据源，业务操作需要调用三个服务来完成。此时每个服务内的数据一致性由本地事务来保证，但是全局的数据一致问题没法保证。

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

二、Seata简介

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

一个典型是分布式事务过程：
分布式事务处理过程的一个 ID + 三组件模型

• Transaction ID XID (全局唯一的事务ID)
• 三组件概念
  • Transaction Coordinator(TC)(事务协调者: 维护全局和分支事务的状态，负责协调并驱动全局事务提交或回滚)
  • Transaction Manager(TM)(事务管理器: 控制全局事务的边界，负责开启一个全局事务，并最终发起全局提交和全局回滚的决议)
  • Resource Manager(RM)(资源管理器: 控制分支事务，负责分支注册、状态汇报，并接收事务协调器的指令，驱动分支/本地 事务的提交和回滚)

处理过程：

1、TM 向 TC 申请开启一个全局事务，全局事务创建成功并生成一个全局唯一的 XID；
2、XID 在微服务调用链的上下文传播；
3、RM 向 TC 注册分支事务，将其纳入 XID 对应全局事务的管辖；
4、TM 向 TC 发起针对 XID 的全局提交或回滚决议；
5、TC 调度 XID 下管辖的全部分支事务完成提交或回滚请求；

发布说明

本地注解 @Transactional
全局注解 @GlobalTransactional

SEATA的分布式交易解决方案

我们只需要使用一个注解 @GlobalTransactional 注解在业务方法上；

三、Seata-Server安装

下载地址
下载到指定目录并解压文件
修改conf目录下的file.conf配置文件
先备份file.conf文件

主要修改：自定义事务组名称 + 事务日记存储模式为db + 数据库连接信息
file.conf文件改两个地方：service模块、store模块

在本地的数据库创建一个名为seata的数据库

然后再seata的数据库建表，sql脚本在conf目录下的
db_store.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`)
);

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;

修改conf目录下的registry.conf 配置连接到nacos注册中心

先启动nacos端口号8848，启动完成后
在bin目录执行seata-server.bat文件

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

以下演示都需要先启动Nacos后启动Seata，保证两个都OK（Seata没启动报错no available server to connect）

分布式事务业务说明
业务说明：
这里我们会创建三个服务，一个订单服务，一个库存服务，一个账户服务。
当用户下单时，会在订单服务中创建一个订单，然后通过运程调用库存服务来扣减下单商品的库存，
再通过运程调用账户服务扣减用户账户里面的余额，
最后在订单服务修改订单状态为已完成。

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

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

1、创建业务数据库

seata_order: 存储订单的数据库
seata_storage: 存储库存的数据库
seata_account: 存储用户信息的数据库

建库SQL:

CREATE DATABASE seata_order;
CREATE DATABASE seata_storage;
CREATE DATABASE seata_account;

2、按业务数据库创建表

seata_order库创建 t_order表

drop table if exists `seata_order`.`t_order`;
CREATE TABLE `seata_order`.`t_order` (
	`id` BIGINT(11) NOT NULL AUTO_INCREMENT COMMENT '自增ID',
	`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 已完成',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = INNODB AUTO_INCREMENT = 0 DEFAULT CHARSET = utf8 COMMENT = '订单表';

seata_storage库创建 t_storage 表

drop table if exists `seata_storage`.`t_storage`;
CREATE TABLE `seata_storage`.`t_storage` (
	`id` BIGINT(11) NOT NULL AUTO_INCREMENT COMMENT '自增ID',
	`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 '剩余库存',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = INNODB AUTO_INCREMENT = 0 DEFAULT CHARSET = utf8 COMMENT = '库存表';

-- 初始化一条数据 --
INSERT INTO `seata_storage`.`t_storage`(`id`,`product_id`,`total`,`used`,`residue`) VALUES (1,1,100,0,100);

seata_account库创建t_account 表

drop table if exists `seata_account`.`t_account`;
CREATE TABLE `seata_account`.`t_account` (
	`id` BIGINT(11) NOT NULL AUTO_INCREMENT COMMENT '自增ID',
	`user_id` BIGINT(11) DEFAULT NULL COMMENT '用户id',
	`total` DECIMAL(11,0) DEFAULT NULL COMMENT '总额度',
	`used` DECIMAL(11,0) DEFAULT NULL COMMENT '已用额度',
	`residue` DECIMAL(11,0) DEFAULT NULL	COMMENT '剩余额度',
PRIMARY KEY (`id`) USING BTREE
) ENGINE = INNODB AUTO_INCREMENT = 0 DEFAULT CHARSET = utf8 COMMENT = '账户表';

-- 初始化一条数据 --
INSERT INTO `seata_account`.`t_account`(`id`,`user_id`,`total`,`used`,`residue`) VALUES (1,1,1000,0,1000);

3、按业务数据库创建对应的回滚日记表

订单-库存-账户3个库下都需要建各自的回滚日记表
在seata\conf目录下的db_undo_log.sql文件

最终效果：

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

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

1、订单业务微服务Module

新建Module订单：seata-order-service-2001微服务
pom文件：

 <dependencies>
        <!--SpringCloud ailibaba nacos -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--SpringCloud ailibaba seata -->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
            <!-- 去除自带seata的版本 -->
            <exclusions>
                <exclusion>
                    <artifactId>seata-all</artifactId>
                    <groupId>io.seata</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- 引入0.9版本的seata 以本地的seata版本对应 -->
        <dependency>
            <groupId>io.seata</groupId>
            <artifactId>seata-all</artifactId>
            <version>0.9.0</version>
        </dependency>

        <!--openfeign-->
        <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>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>

        <!--mysql-connector-java-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

application.yml配置文件：

server:
  port: 2001

spring:
  application:
    name: seata-order-service # 微服务名称
  cloud:
    alibaba:
      seata:
        # 自定义事务组名称需要与seata/conf目录下的file.conf的service模块vgroup_mapping.my_test_tx_group对应
        tx-service-group: zzp_tx_group
    nacos:
      discovery:
        # 配置Nacos 注册中心
        server-addr: 127.0.0.1:8848
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource            # 当前数据源操作类型
    driver-class-name: org.gjt.mm.mysql.Driver              # mysql驱动包
    url: jdbc:mysql://localhost:3306/seata_order?serverTimezone=GMT%2B8&useUnicode=true&characterEncoding=utf-8&useSSL=false
    username: "root"
    password: "123456"

feign:
  hystrix:
    enabled: false

logging:
  level:
    io:
      seata: info

mybatis:
  mapperLocations: classpath:mapper/*.xml

在resources文件夹在需要添加file.conf、registry.conf（seata\conf目录下）支持seata分布式事务支持配置

再修改resources下的file.conf的事务组配置：如下图

domain类（实体类）:
CommonResult响应类

package com.zzp.springcloud.domain;


import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @author zzp
 *
 */
@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.zzp.springcloud.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.math.BigDecimal;

/**
 * @author zzp
 *
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Order {

    /**
     * 自增ID
     */
    private Long id;

    /**
     * 用户id
     */
    private Long userId;

    /**
     * 产品id
     */
    private Long productId;

    /**
     * 数量
     */
    private Integer count;

    /**
     * 金额
     */
    private BigDecimal money;

    /**
     * 订单状态；0 创建中 1 已完成
     */
    private Integer status;

}

dao类：

package com.zzp.springcloud.dao;

import com.zzp.springcloud.domain.Order;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

/**
 * @author zzp
 *
 */
@Mapper
public interface OrderDao {

    // 1 创建订单
    void create(Order order);

    // 2 修改订单状态
    void update(@Param("userId") Long userId,@Param("status") Integer status);
}

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.zzp.springcloud.dao.OrderDao">

    <!-- 映射实体类字段 -->
    <resultMap id="BaseResultMap" type="com.zzp.springcloud.domain.Order">
        <id column="id" property="id" jdbcType="BIGINT"/>
        <id column="user_id" property="userId" jdbcType="BIGINT"/>
        <id column="product_id" property="productId" jdbcType="BIGINT"/>
        <id column="count" property="count" jdbcType="INTEGER"/>
        <id column="money" property="money" jdbcType="DECIMAL"/>
        <id 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>

服务类：

package com.zzp.springcloud.service;

import com.zzp.springcloud.domain.Order;

/**
 * @author zzp
 *
 */
public interface OrderService {

    // 1 创建订单
    void create(Order order);

}

实现类：

package com.zzp.springcloud.service.impl;

import com.zzp.springcloud.dao.OrderDao;
import com.zzp.springcloud.domain.Order;
import com.zzp.springcloud.feign.AccountFeign;
import com.zzp.springcloud.feign.StorageFeign;
import com.zzp.springcloud.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * @author zzp
 *
 */
@Service
@Slf4j
public class OrderServiceImpl implements OrderService {

    @Resource
    private OrderDao orderDao;
    @Resource
    private AccountFeign accountFeign;
    @Resource
    private StorageFeign storageFeign;

    /**
     * 创建订单-》调用库存服务扣减库存-》调用账户扣减账户余额-》修改订单状态
     * @param order
     */
    @Override
    public void create(Order order) {

        log.info("----->开始新建订单");
        // 1 新建订单
        orderDao.create(order);

        log.info("----->订单服务调用库存服务，做扣减 --- start");
        // 2 扣减库存
        storageFeign.decrease(order.getProductId(),order.getCount());
        log.info("----->订单服务调用库存服务，做扣减 --- end");

        log.info("----->订单服务调用账户服务，做扣减 --- start");
        // 3 扣减账户
        accountFeign.decrease(order.getUserId(),order.getMoney());
        log.info("----->订单服务调用账户服务，做扣减 --- end");

        // 4 修改订单的状态 订单状态；0 创建中 1 已完成
        log.info("----->修改订单状态 --- start");
        orderDao.update(order.getUserId(),0);
        log.info("----->修改订单状态 --- end");


        log.info("----->下订单结束了，-----> end");

    }
}

feign调用类：
AccountFeign类

package com.zzp.springcloud.feign;

import com.zzp.springcloud.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 zzp
 *
 */
@FeignClient(value = "seata-account-service")
public interface AccountFeign {

    @PostMapping(value = "/account/decrease")
    CommonResult decrease(@RequestParam("userId") Long userId, @RequestParam("money") BigDecimal money);

}

StorageFeign类

package com.zzp.springcloud.feign;

import com.zzp.springcloud.domain.CommonResult;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

/**
 * @author zzp
 *
 */
@FeignClient(value = "seata-storage-service")
public interface StorageFeign {

    @PostMapping(value = "/storage/decrease")
    CommonResult decrease(@RequestParam("productId") Long productId, @RequestParam("count") Integer count);
}

控制类：

package com.zzp.springcloud.controller;

import com.zzp.springcloud.domain.CommonResult;
import com.zzp.springcloud.domain.Order;
import com.zzp.springcloud.service.OrderService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * @author zzp
 */
@RestController
public class OrderController {

    @Resource
    private OrderService orderService;

    @GetMapping(value = "/order/create")
    public CommonResult create(Order order){
        orderService.create(order);
        return new CommonResult(200,"订单创建成功");
    }

}

MyBatis配置类：

package com.zzp.springcloud.config;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;

/**
 * @author zzp
 *
 */
@Configuration
@MapperScan({"com.zzp.springcloud.dao"})
public class MyBatisConfig {
}

设置seata数据源代理

package com.zzp.springcloud.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;


/**
 * 使用Seata对数据源进行代理
 * @author zzp
 */
@Configuration
public class DataSourceRroxyConfig {

    @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(mapperLocations));
        sqlSessionFactoryBean.setTransactionFactory(new SpringManagedTransactionFactory());
        return sqlSessionFactoryBean.getObject();
    }


}

启动类：

package com.zzp.springcloud;

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 zzp
 *
 */
@EnableDiscoveryClient
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)//取消数据源的自动创建
@EnableFeignClients
public class SeataOrderMainApp2001 {

    public static void main(String[] args) {
        SpringApplication.run(SeataOrderMainApp2001.class,args);
    }
}

最终效果图：

2、库存业务微服务Module

新建Module库存：seata-storage-service-2002微服务
创建步骤和2001服务差不多，
这里粘贴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.zzp.springcloud.dao.StorageDao">

    <!-- 映射实体类字段 -->
    <resultMap id="BaseResultMap" type="com.zzp.springcloud.domain.Storage">
        <id column="id" property="id" jdbcType="BIGINT"/>
        <id column="product_id" property="productId" jdbcType="BIGINT"/>
        <id column="total" property="total" jdbcType="INTEGER"/>
        <id column="used" property="used" jdbcType="INTEGER"/>
        <id 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>

最终效果图：

3、账户业务微服务Module

新建Module账户：seata-account-service-2003微服务
查看2001和2002微服务
最终效果图：

测试

先启动Nacos 后启动 seata
启动2001、2002、2003微服务

查看三个数据库的初始数据：
seata_order数据库：

seata_storage数据库：

seata_account数据库：

访问订单微服务接口：http://localhost:2001/order/create?userId=1&productId=1&count=50&money=100

访问成功！
后台日记：

再查看三个数据库的数据：

seata_order数据库：新增一条订单

seata_storage数据库：减了库存

seata_account数据库：减了金额

超时异常，没加 @GlobalTransactional 注解
在AccountServiceImpl添加超时

 @Override
    public void decrease(Long userId, BigDecimal money) {
        LOGGER.info("----->account-service中扣减余额--start");
        // 暂停几秒设置
        try
        {
            TimeUnit.SECONDS.sleep(20);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        accountDao.decrease(userId,money);
        LOGGER.info("----->account-service中扣减余额--end");
    }

重启2003微服务

再次调用：
http://localhost:2001/order/create?userId=1&productId=1&count=10&money=100

访问失败！

再次查看三个数据库的数据：

seata_order数据库：新增一条订单 状态 创建中

seata_storage数据库：减了库存

seata_account数据库：减了金额

故障情况：
当库存和账户金额扣减后，订单状态并没有设置为已完成，没有从零改为1，而且由于feign的重试机制，账户余额可能被多次扣减

超时异常，添加 @GlobalTransactional 注解
在AccountServiceImpl添加超时（上一步操作）
在OrderServiceImpl添加@GlobalTransactional注解

 /**
     * 创建订单-》调用库存服务扣减库存-》调用账户扣减账户余额-》修改订单状态
     * @param order
     */
    @Override
     @GlobalTransactional(name = "zzp-creata-order",rollbackFor = Exception.class)
    public void create(Order order) {....}

@GlobalTransactional 注解 name属性： 唯一名称 rollbackFor 属性：异常类

重启2001微服务

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

访问出错了

再看看数据库：

未操作数据库，说明在订单服务操作的时候出现了超时错误，@GlobalTransactional 进行了事务回滚，

一部分补充：

Seata

• 2019年1月份蚂蚁金服和阿里巴巴共同开源的分布式事务解决方案
• Simple Extensible Autonomous Transaction Architecture，简单可扩展自治事务框架

工作开发或者使用集群的时候 请使用Seata1.0以后的版本

TC/TM/RM三大组件

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

Seata 是什么?
Seata 是一款开源的分布式事务解决方案，致力于提供高性能和简单易用的分布式事务服务。Seata 将为用户提供了 AT、TCC、SAGA 和 XA 事务模式，为用户打造一站式的分布式解决方案。

这里使用的是默认 AT 模式
AT 模式：提供无侵入自动补偿的事务模式，目前已支持 MySQL、 Oracle 、PostgreSQL和 TiDB的AT模式，H2 开发中

两阶段提交协议的演变：

• 一阶段：业务数据和回滚日志记录在同一个本地事务中提交，释放本地锁和连接资源。
• 二阶段：
  • 提交异步化，非常快速地完成。
  • 回滚通过一阶段的回滚日志进行反向补偿。

一阶段加载
在一阶段，Seata 会拦截 “业务SQL”,
1 解析 SQL 语义，找到 “业务SQL” 要更新的业务数据，在业务数据被更新前，将其保存成 “before image” ，
2 执行 “业务SQL” 更新业务数据，在业务数据更新之后，
3 其保存成 “after image” ，最后生成行锁。
以上操作全部在一个数据库实物内完成，这样保证了一阶段操作的原子性。

二阶段提交
二段如是顺利提交的话，
因为 “业务SQL” 在一阶段已经提交至数据库，所以Seata框架只需将一阶段保存的快照数据和行锁删掉，完成数据清理即可。

二阶段回滚：
二阶段如果是回滚的话。Seata 就需要回滚一阶段已经执行的 “业务SQL” ，还原业务数据。
回滚方式是用 “before image” 还原业务数据；但在还原前要首先效验脏写，对比 “数据库当前业务数据” 和 “after image” ，
如果两份数据完全一致就说明没有脏写，可以还原业务数据，如果不一致说明有脏写，出现脏写就需要人工处理。

debug测试
debug模式启动2001、2002、2003微服务
在OrderServiceImpl打断点：

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

查看seata数据库

管理三个资源数据库

订单数据：第7条记录

查看undo_log记录

查看rollback_info内容：

global_table表：

跑完后，seata数据库的表数据被清空了

图：