分布式事务（一）Mysql本地事务和事务隔离级别分布式事务（二）分布式事务方案
分布式事务（三）Seata分布式事务框架-AT模式介绍
从分布式事务(四)开始:
订单业务案例
1 创建 Empty Project：seata-at
先新建文件夹 seata-samples，后面测试的 Seata AT 和 Seata TCC 模式都放在该目录下。
接着创建 seata-at 项目：
选择 Empty Project：
2 数据库初始化工具
订单案例涉及四个数据库：
为了后续测试方便我们编写一个工具，用来重置所有数据库表，可以方便地把数据重置到初始状态。
2.1 新建Module：db-init
第一步: 新建spring工程名为:db-init ,添加JDBC API ,MYSQL Driver依赖
第二步:修改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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.2.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>cn.tedu</groupId>
<artifactId>db-init</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>db-init</name>
<description>db-init</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>第三步:修改application.yml配置文件
项目的 application.properties 文件改名成 application.yml，然后添加 mysql 连接配置：
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost/?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
username: root
password: root注意： 在连接地址中没有指定库名，是因为我们要先后连接四个数据库，后面执行的 sql 脚本文件中会执行 use 来进行数据库切换。
2.2 resource包下新建sql包,用于添加 sql 脚本文件
案例中的 sql 脚本来自不同的项目：
- seata 库
seata 库是 Seata Server （TC，全局事务协调器）使用的数据库，建表语句来自这里：https://github.com/seata/seata/tree/develop/script/server/db
- order、storage和account库中的 undo_log 表
undo_log 表是各分支事务用来记录回滚日志的表，建表语句来自这里：https://github.com/seata/seata/tree/develop/script/client/at/db
- order、storage和account表
这个案例项目是 Seata 官方案例，我少做了一些改动。案例用的建表语句来自这里：https://github.com/seata/seata-samples/tree/master/springcloud-eureka-feign-mybatis-seata，在各项目的 resources 目录中的 sql 文件。
- order库中的 segment 表
EasyIdGenerator 是一个非常简单易用的全局唯一id发号器，他支持数据库自增id方式和雪花算法，由于雪花算法需要用到zookeeper服务器，为了简便起见，我们使用数据库自增id的方式。segment 表就来自这个开源项目，项目地址：https://github.com/lookingatstarts/easyIdGenerator
也可参考下面的sql语句进行复制粘贴
seata-server.sql
drop database if exists `seata`;
CREATE DATABASE `seata` CHARSET utf8;
use `seata`;
-- -------------------------------- The script used when storeMode is 'db' --------------------------------
-- the table to store GlobalSession data
CREATE TABLE IF NOT EXISTS `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`)
) ENGINE = InnoDB
DEFAULT CHARSET = utf8;
-- the table to store BranchSession data
CREATE TABLE IF NOT EXISTS `branch_table`
(
`branch_id` BIGINT NOT NULL,
`xid` VARCHAR(128) NOT NULL,
`transaction_id` BIGINT,
`resource_group_id` VARCHAR(32),
`resource_id` VARCHAR(256),
`branch_type` VARCHAR(8),
`status` TINYINT,
`client_id` VARCHAR(64),
`application_data` VARCHAR(2000),
`gmt_create` DATETIME(6),
`gmt_modified` DATETIME(6),
PRIMARY KEY (`branch_id`),
KEY `idx_xid` (`xid`)
) ENGINE = InnoDB
DEFAULT CHARSET = utf8;
-- the table to store lock data
CREATE TABLE IF NOT EXISTS `lock_table`
(
`row_key` VARCHAR(128) NOT NULL,
`xid` VARCHAR(96),
`transaction_id` BIGINT,
`branch_id` BIGINT NOT NULL,
`resource_id` VARCHAR(256),
`table_name` VARCHAR(32),
`pk` VARCHAR(36),
`gmt_create` DATETIME,
`gmt_modified` DATETIME,
PRIMARY KEY (`row_key`),
KEY `idx_branch_id` (`branch_id`)
) ENGINE = InnoDB
DEFAULT CHARSET = utf8;order.sql
drop database if exists `seata_order`;
CREATE DATABASE `seata_order` charset utf8;
use `seata_order`;
CREATE TABLE `order` (
`id` bigint(11) NOT NULL,
`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 '金额',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
ALTER TABLE `order` ADD COLUMN `status` int(1) DEFAULT NULL COMMENT '订单状态：0：创建中；1：已完结' AFTER `money` ;
-- for AT mode you must to init this sql for you business database. the seata server not need it.
CREATE TABLE IF NOT EXISTS `undo_log`
(
`branch_id` BIGINT(20) NOT NULL COMMENT 'branch transaction id',
`xid` VARCHAR(100) NOT NULL COMMENT 'global transaction id',
`context` VARCHAR(128) NOT NULL COMMENT 'undo_log context,such as serialization',
`rollback_info` LONGBLOB NOT NULL COMMENT 'rollback info',
`log_status` INT(11) NOT NULL COMMENT '0:normal status,1:defense status',
`log_created` DATETIME(6) NOT NULL COMMENT 'create datetime',
`log_modified` DATETIME(6) NOT NULL COMMENT 'modify datetime',
UNIQUE KEY `ux_undo_log` (`xid`, `branch_id`)
) ENGINE = InnoDB
AUTO_INCREMENT = 1
DEFAULT CHARSET = utf8 COMMENT ='AT transaction mode undo table';
CREATE TABLE IF NOT EXISTS segment
(
id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY COMMENT '自增主键',
VERSION BIGINT DEFAULT 0 NOT NULL COMMENT '版本号',
business_type VARCHAR(63) DEFAULT '' NOT NULL COMMENT '业务类型，唯一',
max_id BIGINT DEFAULT 0 NOT NULL COMMENT '当前最大id',
step INT DEFAULT 0 NULL COMMENT '步长',
increment INT DEFAULT 1 NOT NULL COMMENT '每次id增量',
remainder INT DEFAULT 0 NOT NULL COMMENT '余数',
created_at BIGINT UNSIGNED NOT NULL COMMENT '创建时间',
updated_at BIGINT UNSIGNED NOT NULL COMMENT '更新时间',
CONSTRAINT uniq_business_type UNIQUE (business_type)
) CHARSET = utf8mb4
ENGINE INNODB COMMENT '号段表';
INSERT INTO segment
(VERSION, business_type, max_id, step, increment, remainder, created_at, updated_at)
VALUES (1, 'order_business', 1000, 1000, 1, 0, NOW(), NOW());storage.sql
drop database if exists `seata_storage`;
CREATE DATABASE `seata_storage` charset utf8;
use `seata_storage`;
CREATE TABLE `storage` (
`id` bigint(11) NOT NULL AUTO_INCREMENT,
`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 '剩余库存',
`frozen` int(11) DEFAULT '0' COMMENT 'TCC事务锁定的库存',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
INSERT INTO `seata_storage`.`storage` (`id`, `product_id`, `total`, `used`, `residue`) VALUES ('1', '1', '100', '0', '100');
-- for AT mode you must to init this sql for you business database. the seata server not need it.
CREATE TABLE IF NOT EXISTS `undo_log`
(
`branch_id` BIGINT(20) NOT NULL COMMENT 'branch transaction id',
`xid` VARCHAR(100) NOT NULL COMMENT 'global transaction id',
`context` VARCHAR(128) NOT NULL COMMENT 'undo_log context,such as serialization',
`rollback_info` LONGBLOB NOT NULL COMMENT 'rollback info',
`log_status` INT(11) NOT NULL COMMENT '0:normal status,1:defense status',
`log_created` DATETIME(6) NOT NULL COMMENT 'create datetime',
`log_modified` DATETIME(6) NOT NULL COMMENT 'modify datetime',
UNIQUE KEY `ux_undo_log` (`xid`, `branch_id`)
) ENGINE = InnoDB
AUTO_INCREMENT = 1
DEFAULT CHARSET = utf8 COMMENT ='AT transaction mode undo table';account.sql
drop database if exists `seata_account`;
CREATE DATABASE `seata_account` charset utf8;
use `seata_account`;
CREATE TABLE `account` (
`id` bigint(11) NOT NULL AUTO_INCREMENT COMMENT 'id',
`user_id` bigint(11) UNIQUE 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 '剩余可用额度',
`frozen` decimal(10,0) DEFAULT '0' COMMENT 'TCC事务锁定的金额',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
INSERT INTO `seata_account`.`account` (`id`, `user_id`, `total`, `used`, `residue`) VALUES ('1', '1', '1000', '0', '1000');
-- for AT mode you must to init this sql for you business database. the seata server not need it.
CREATE TABLE IF NOT EXISTS `undo_log`
(
`branch_id` BIGINT(20) NOT NULL COMMENT 'branch transaction id',
`xid` VARCHAR(100) NOT NULL COMMENT 'global transaction id',
`context` VARCHAR(128) NOT NULL COMMENT 'undo_log context,such as serialization',
`rollback_info` LONGBLOB NOT NULL COMMENT 'rollback info',
`log_status` INT(11) NOT NULL COMMENT '0:normal status,1:defense status',
`log_created` DATETIME(6) NOT NULL COMMENT 'create datetime',
`log_modified` DATETIME(6) NOT NULL COMMENT 'modify datetime',
UNIQUE KEY `ux_undo_log` (`xid`, `branch_id`)
) ENGINE = InnoDB
AUTO_INCREMENT = 1
DEFAULT CHARSET = utf8 COMMENT ='AT transaction mode undo table';2.3 主程序中添加代码，执行sql脚本,创建四个数据库
Spring 中提供了一个 jdbc 脚本执行器，使用这个工具可以非常方便的运行一个 sql 脚本文件，下面是这个方法：
ScriptUtils.executeSqlScript()
只需要传入它需要的参数即可。
下面代码运行 sql 目录中的四个脚本程序，每次运行都会删除四个数据库再重新创建，并初始化数据。
package cn.tedu.dbinit;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.support.EncodedResource;
import org.springframework.jdbc.datasource.init.ScriptUtils;
import javax.annotation.PostConstruct;
import javax.sql.DataSource;
import java.sql.SQLException;
@SpringBootApplication
public class DbInitApplication {
@Autowired
private DataSource dataSource;
public static void main(String[] args) {
SpringApplication.run(DbInitApplication.class, args);
}
@PostConstruct
public void init() throws SQLException {
exec( "sql/account.sql");
exec( "sql/storage.sql");
exec( "sql/order.sql");
exec( "sql/seata-server.sql");
}
private void exec( String sql) throws SQLException {
ClassPathResource cpr = new ClassPathResource(
sql, DbInitApplication.class.getClassLoader());
EncodedResource resource = new EncodedResource(cpr, "utf-8");
ScriptUtils.executeSqlScript(dataSource.getConnection(), resource);
}
}- 启动后,会创建四个数据库:
3 eureka 注册中心
3.1 新建 Module：eureka-server
- 设置项目名 eureka，存放路径放在 seata-at 目录下,添加 eureka server 依赖：
- 修改pom.xml文件中spring boot 版本为2.3.2.RELEASE,Spring Cloud版本为Hoxton.SR8
3.2 修改application.yml 配置
spring:
application:
name: eureka-server
server:
port: 8761
eureka:
server:
enable-self-preservation: false
instance:
hostname: eureka1
client:
register-with-eureka: false
fetch-registry: false3.3 主程序添加 @EnableEurekaServer 注解
package cn.tedu.eurekaserver;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;
@EnableEurekaServer
@SpringBootApplication
public class EurekaServerApplication {
public static void main(String[] args) {
SpringApplication.run(EurekaServerApplication.class, args);
}
}4 父项目
为了对 order、storage和account微服务项目依赖进行统一管理，这里创建一个 pom 类型的 maven 项目，作为父项目.
4.1 新建 Maven 项目：order-parent1
4.2 修改pom.xml文件
看到 seata 依赖部分被注释掉了，后面添加 seata 事务时再启用。
<?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">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.2.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>cn.tedu</groupId>
<artifactId>order-parent1</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<name>order-parent1</name>
<properties>
<mybatis-plus.version>3.3.2</mybatis-plus.version>
<druid-spring-boot-starter.version>1.1.23</druid-spring-boot-starter.version>
<seata.version>1.3.0</seata.version>
<spring-cloud-alibaba-seata.version>2.0.0.RELEASE</spring-cloud-alibaba-seata.version>
<spring-cloud.version>Hoxton.SR8</spring-cloud.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>${mybatis-plus.version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>${druid-spring-boot-starter.version}</version>
</dependency>
<!--seata分布式事务依赖-->
<!--<dependency>-->
<!-- <groupId>com.alibaba.cloud</groupId>-->
<!-- <artifactId>spring-cloud-alibaba-seata</artifactId>-->
<!-- <version>${spring-cloud-alibaba-seata.version}</version>-->
<!-- <exclusions>-->
<!-- <exclusion>-->
<!-- <artifactId>seata-all</artifactId>-->
<!-- <groupId>io.seata</groupId>-->
<!-- </exclusion>-->
<!-- </exclusions>-->
<!--</dependency>-->
<!--<dependency>-->
<!-- <groupId>io.seata</groupId>-->
<!-- <artifactId>seata-all</artifactId>-->
<!-- <version>${seata.version}</version>-->
<!--</dependency>-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>${spring-cloud.version}</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>删除order-parent工程的src包
5 account账户项目
在这个微服务项目中实现扣减账户金额的功能。
第一步:在order-parent工程下创建spring Initializr子工程account
第二步:删除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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<artifactId>account</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>acounnt</name>
</project>
最后的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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<!--继承父类order-parent工程的pom文件依赖-->
<parent>
<artifactId>order-parent1</artifactId>
<groupId>cn.tedu</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>account</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>acounnt</name>
</project>第三步:编辑配置文件application.yml
spring:
application:
name: acount
datasource: #数据库连接
url: jdbc:mysql:///seata_account?useUnicode=true&characterEncoding=UTF-8&&serverTimezone=GMT%2B8
driver-class-name: com.mysql.cj.jdbc.Driver
# 8081 8082 8083 三个业务模块的端口
server:
port: 8081
eureka:
client:
service-url:
defaultZone: http://localhost:8761/eureka
instance: #注册ip地址,而不是主机名,免得解析,eureka控制台显示的'instance-id'有可能还是主机名,但其实就是ip
prefer-ip-address: true
#mp配置
mybatis-plus:
mapper-locations: classpath:mapper/*.xml
type-aliases-package: cn.tedu.account.entity #实体类包
configuration:
map-underscore-to-camel-case: true #驼峰命名格式
#日志 打开sql语句日志
logging:
level:
cn.tedu.account.mapper: debug #定义的mapper接口全部放在这个包下
第四步:新建bootstrap.yml配置文件,配置ip
#bootstrap.yml
spring:
cloud:
inetutils:
preferred-networks: # 以太网ip .+代表1到多个任意字符,其中.点需要转译所以加\
- 176\.8\.6\..+
第五步:创建entity包并创建实体类,相当于pojo包,封装MVC的model层
package cn.tedu.acounnt.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
//不添加 mybatis-plus 的注解: table,id,filed...
//而是在 xml 中自己写 sql 语句
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Account {
private Long id;
private Long userId;
private BigDecimal total; //总金额
private BigDecimal used; //已使用
private BigDecimal residue; //可用金额
private BigDecimal frozen; //冻结金额
}第六步:创建mapper包,创建AccountMapper接口继承BaseMapper,类型是Account
package cn.tedu.account.mapper;
import cn.tedu.account.entity.Account;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import java.math.BigDecimal;
public interface AccountMapper extends BaseMapper<Account> {
void decrease(Long userId, 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="cn.tedu.account.mapper.AccountMapper" >
<resultMap id="BaseResultMap" type="cn.tedu.account.entity.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"/>
<result column="frozen" property="frozen" jdbcType="DECIMAL"/>
</resultMap>
<update id="decrease">
UPDATE account SET residue = residue - #{money},used = used + #{money} where user_id = #{userId};
</update>
</mapper>第八步:启动类创建扫描mapper包注解
第九步:service包下创建服务层接口及实现类
package cn.tedu.account.service;
import java.math.BigDecimal;
public interface AccountService {
void decrease(Long useId, BigDecimal money);
}package cn.tedu.account.service;
import cn.tedu.account.mapper.AccountMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
@Service
public class AccountServiceImpl implements AccountService{
@Autowired
private AccountMapper accountMapper;
@Override
public void decrease(Long useId, BigDecimal money) {
accountMapper.decrease(userId,money);
}
}第十步:controller包下创建控制层,进行前端的请求与响应
package cn.tedu.account.controller;
import cn.tedu.account.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import java.math.BigDecimal;
@RestController
public class AccountController {
@Autowired
private AccountService accountService;
@GetMapping("/decrease") // ?useId=1&money=100
public String decrease(Long userId, BigDecimal money){
accountService.decrease(userId,money);
return "账户扣减成功";
}
}第十一步:启动eureka工程服务,再启动 account 工程,进行测试
- 查看 eureka 注册信息
- 访问 http://localhost:8761/ 查看账户服务在 eureka 中的注册信息：
- 访问账户服务执行账户扣减金额
- 访问 http://localhost:8081/decrease?userId=1&money=100
- 查看控制台 Mybatis 执行的 sql 日志
- 查看数据库表，确认金额已经被减掉
6 storage库存项目
storage 库存微服务项目，用来实现减少库存的功能
第一步:order-parent创建子工程storage
第二步:编辑pom文件,继承order-parent父工程的依赖
<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>order-parent1</artifactId>
<groupId>cn.tedu</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>storage</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>storage</name>
</project>第三步:resource包下编辑application.yml配置文件,并创建bootstrap.yml配置ip
spring:
application:
name: storage
datasource:
url: jdbc:mysql://localhost/seata_storage?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
driver-class-name: com.mysql.cj.jdbc.Driver
username: root
password: root
server:
port: 8082
eureka:
client:
service-url:
defaultZone: http://localhost:8761/eureka
instance:
prefer-ip-address: true
instance-id: ${spring.cloud.client.ip-address}:${spring.application.name}:${server.port}
mybatis-plus:
configuration:
map-underscore-to-camel-case: true
mapper-locations: classpath:mapper/*.xml
type-aliases-package: cn.tedu.storage.entity
logging:
level:
cn.tedu.storage.mapper: debug#bootstrap.yml
spring:
cloud:
inetutils:
preferred-networks: # 以太网ip .+代表1到多个任意字符,其中.点需要转译所以加\
- 176\.8\.6\..+第四步:entity包下创建Storage的实体类
package cn.tedu.storage.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Storage {
private Long id;
private Long productId;
private Integer total;
private Integer used;
private Integer residue;
private Integer frozen;
}第五步:mapper包下创建StorageMapper接口
package cn.tedu.storage.mapper;
import cn.tedu.storage.entity.Storage;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
public interface StorageMapper extends BaseMapper<Storage> {
void decrease(Long productId,Integer count);
}第六步:resource包下创建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="cn.tedu.storage.mapper.StorageMapper" >
<resultMap id="BaseResultMap" type="cn.tedu.storage.entity.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 storage SET used = used + #{count},residue = residue - #{count} WHERE product_id = #{productId}
</update>
</mapper>第七步:启动类添加扫描包注解
第八步:service包下创建StorageService接口及实现类
package cn.tedu.storage.service;
public interface StorageService { //Alt + enter 键创建接口实现类
void decrease(Long productId,Integer count);
}package cn.tedu.storage.service;
public class StorageServiceImpl implements StorageService {
@Autowired
private StorageMapper storageMapper;
@Override
public void decrease(Long productId, Integer count) {
}
}第九步:controller包下创建StorageController类,进行访问的请求与响应
package cn.tedu.storage.controller;
import cn.tedu.storage.service.StorageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class StorageController {
@Autowired
private StorageService storageService;
@GetMapping("/decrease") //?productId&count=10
public String decrease(Long productId, Integer count){
storageService.decrease(productId,count);
return "减少库存成功";
}
}第十步:启动eureka工程启动类,再启动Storage启动类进行测试
- 查看 eureka 注册信息
- 访问 http://localhost:8761/ 查看库存服务在 eureka 中的注册信息：
- 访问库存服务，执行减少库存操作
- 访问 http://localhost:8082/decrease?productId=1&count=1
- 查看控制台 Mybatis 执行的 sql 日志
- 查看数据库表，确认金额已经被减掉
7 order订单项目
order 订单项目保存订单，并调用 storage 和 account 减少库存和扣减金额。
第一步:新建order子工程
第二步:继承order-parent1父工程的依赖
<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>order-parent1</artifactId>
<groupId>cn.tedu</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>order</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>order</name>
</project>第三步:修改appilication.yml文件,创建bootstrap.yml文件配置ip
spring:
application:
name: order
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost/seata_order?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
username: root
password: root
server:
port: 8083
eureka:
client:
service-url:
defaultZone: http://localhost:8761/eureka
instance:
prefer-ip-address: true
instance-id: ${spring.cloud.client.ip-address}:${spring.application.name}:${server.port}
mybatis-plus:
type-aliases-package: cn.tedu.order.entity
mapper-locations:
- classpath:/mapper/*Mapper.xml
configuration:
map-underscore-to-camel-case: true
logging:
level:
cn.tedu.order.mapper: DEBUG#bootstrap.yml
spring:
cloud:
inetutils:
preferred-networks: # 以太网ip .+代表1到多个任意字符,其中.点需要转译所以加\
- 176\.8\.6\..+第四步:entity包下创建Order的实体类
package cn.tedu.order.entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.math.BigDecimal;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Order {
private Long id;
private Long userId;
private Long productId;
private Integer count;
private BigDecimal money;
private Integer status;
}第五步:mapper包下创建OrderMapper接口
package cn.tedu.order.mapper;
import cn.tedu.order.entity.Order;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
public interface OrderMapper extends BaseMapper<Order> {
void create(Order order);
}第六步:resource包下创建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="cn.tedu.order.mapper.OrderMapper" >
<resultMap id="BaseResultMap" type="cn.tedu.order.entity.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"> #order加引号是因为order属于SQL语句的关键词,加引号就指定它是表
INSERT INTO `order` (`id`,`user_id`,`product_id`,`count`,`money`,`status`)
VALUES(#{id}, #{userId}, #{productId}, #{count}, #{money},1);
</insert>
</mapper>第七步:启动类添加扫描包注解
第八步:service包下创建OrderService接口及实现类
package cn.tedu.order.service;
import cn.tedu.order.entity.Order;
public interface OrderService {
void create(Order order);
}package cn.tedu.order.service;
import cn.tedu.order.entity.Order;
import cn.tedu.order.mapper.OrderMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Random;
@Service
public class OrderServiceImpl implements OrderService {
@Autowired
private OrderMapper orderMapper;
@Override
public void create(Order order) {
//TODO: 远程调用发号器,获取订单id
// TODO: 从全局唯一id发号器获得id，这里暂时随机产生一个 orderId,有发号器后在删除这一行
//Long orderId = Long.valueOf(new Random().nextInt(Integer.MAX_VALUE));
long orderId = Math.abs(new Random().nextLong());
order.setId(orderId);
orderMapper.create(order);
// TODO: 调用storage，修改库存
// TODO: 调用account，修改账户余额
}
}第九步:controller包下创建OrderController类,进行访问的请求与响应
package cn.tedu.order.controller;
import cn.tedu.order.entity.Order;
import cn.tedu.order.service.OrderService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@Slf4j
public class OrderController {
@Autowired
OrderService orderService;
/*
用户用这个路径进行访问：
http://localhost:8083/create?userId=1&productId=1&count=10&money=100
*/
@GetMapping("/create")
public String create(Order order) {
log.info("创建订单");
orderService.create(order);
return "创建订单成功";
}
}第十步:启动eureka工程启动类,再启动Order启动类进行测试
- 查看 eureka 注册信息
- 访问 http://localhost:8761/ 查看订单服务在 eureka 中的注册信：
- 访问订单服务，执行订单保存
- 访问 http://localhost:8083/create?userId=1&productId=1&count=10&money=100
- 查看控制台 Mybatis 执行的 sql 日志
- 查看数据库表，确认订单保存成功
8 全局唯一id发号器
分布式系统中，产生唯一流水号的服务系统俗称发号器。
有很多发号器开源项目，这里使用 EasyIdGenerator，具体项目信息请访问：https://github.com/lookingatstarts/easyIdGenerator
项目使用非常简单，将项目下载下来稍作配置即可。
8.1 下载项目
访问 GitHub - lookingatstarts/easyIdGenerator: 生成全局唯一ID ，下载发号器项目。
8.2 解压到 seata-at 工程目录下
解压，和前面的项目放到同一个工程目录。
把目录改名为 easy-id-generator ：
8.3 导入 Module
在Maven工具窗口中点击添加按钮，选择发号器项目的 pom.xml 文件导入该项目：
注意： 如果右侧没有Maven工具标签，请按两下shift键，然后查找 “add maven projects” 就可以找到这个工具。
8.4 配置
第一步: 发号器向 eureka 进行注册，以便其它服务发现它。在pom.xml 中添加 Spring Cloud Eureka Client 依赖：
添加eureka-client依赖
<dependencies>
.....
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-dependencies</artifactId>
<version>Hoxton.SR8</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>第二步:application.yml编辑
- 配置使用数据库来生成自增id
- 向eureka进行注册
server:
port: 9090
easy-id-generator:
snowflake:
enable: false
zk:
connection-string: 127.0.0.1:2181,127.0.0.1:2182,127.0.0.1:2183
load-worker-id-from-file-when-zk-down: true # 当zk不可访问时，从本地文件中读取之前备份的workerId
segment:
enable: true
db-list: "seata_order"
fetch-segment-retry-times: 3 # 从数据库获取号段失败重试次数
eureka:
client:
service-url:
defaultZone: http://localhost:8761/eureka
instance:
prefer-ip-address: true
spring:
application:
name: easy-id- 创建一个bootstrap.yml
#bootstrap.yml
spring:
cloud:
inetutils:
preferred-networks: # 以太网ip .+代表1到多个任意字符,其中.点需要转译所以加\
- 176\.8\.6\..+8.5 seata_order.properties 数据库配置
在 resources 目录下新建配置文件 seata_order.properties，配置 seata_order 数据库的连接信息。
jdbcUrl=jdbc:mysql://localhost:3306/seata_order?serverTimezone=GMT%2B8&autoReconnect=true&useUnicode=true&characterEncoding=UTF-8
driverClassName=com.mysql.cj.jdbc.Driver
dataSource.user=root
dataSource.password=root
dataSource.cachePrepStmts=true
dataSource.prepStmtCacheSize=250
dataSource.prepStmtCacheSqlLimit=20488.6 数据表
在 db-init 项目的 order.sql 中已经创建了数据表，并插入了一个名为 order_business 的自增id条目。
项目的 schema.sql 中为示例数据表。
8.7 启动eureka服务和此项目启动类,测试
- 查看 eureka 中的注册信息
2.访问测试
根据 SegmentEasyIdController 类的设置，访问下面地址获取自增id：
http://localhost:9090/segment/ids/next_id?businessType=order_business
9 order订单添加Feign，调用库存和账户服务
- 调用发号器获得全局唯一id
- 调用库存服务减少商品库存
- 调用账户服务扣减用户金额
9.1 application.yml
ribbon 默认超时时间是1秒，为了方便分布式事务测试，把超时时长改为 10 秒：
spring:
application:
name: order
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost/seata_order?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
username: root
password: root
server:
port: 8083
eureka:
client:
service-url:
defaultZone: http://localhost:8761/eureka
instance:
prefer-ip-address: true
mybatis-plus:
type-aliases-package: cn.tedu.order.entity
mapper-locations:
- classpath:/mapper/*Mapper.xml
configuration:
map-underscore-to-camel-case: true
logging:
level:
cn.tedu.order.mapper: DEBUG
ribbon:
ReadTimeout: 100009.2 主程序添加注解启用 Feign
Order订单服务启动类添加 @EnableFeignClients 注解：
package cn.tedu.order;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
@EnableFeignClients
@MapperScan("cn.tedu.order.mapper")
@SpringBootApplication
public class OrderApplication {
public static void main(String[] args) {
SpringApplication.run(OrderApplication.class, args);
}
}9.3 添加Feign声明式客户端接口
发号器的客户端接口：
package cn.tedu.order.feign;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
@FeignClient(name = "EASY-ID")
public interface EasyIdClient {
@GetMapping("/segment/ids/next_id")
String nextId(@RequestParam String businessType);
}库存服务的客户端接口：
package cn.tedu.order.feign;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
@FeignClient(name = "storage")
public interface StorageClient {
@GetMapping("/decrease")
String decrease(@RequestParam Long productId, @RequestParam Integer count);
}账户服务的客户端接口：
package cn.tedu.order.feign;
import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import java.math.BigDecimal;
@FeignClient(name = "account")
public interface AccountClient {
@GetMapping("/decrease")
String decrease(@RequestParam Long userId, @RequestParam BigDecimal money);
}9.4 在业务代码中通过Feign客户端调用远程服务
package cn.tedu.order.service;
import cn.tedu.order.entity.Order;
import cn.tedu.order.feign.AccountClient;
import cn.tedu.order.feign.EasyIdGeneratorClient;
import cn.tedu.order.feign.StorageClient;
import cn.tedu.order.mapper.OrderMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Random;
@Service
public class OrderServiceImpl implements OrderService {
@Autowired
private OrderMapper orderMapper;
@Autowired
private EasyIdClient easyIdClient;
@Autowired
private AccountClient accountClient;
@Autowired
private StorageClient storageClient;
@Override
public void create(Order order) {
// 从全局唯一id发号器获得id
String s = easyIdClient.nextId("order_business");
Long orderId = Long.valueOf(s);
order.setId(orderId);
orderMapper.create(order);
// 修改库存
storageClient.decrease(order.getProductId(), order.getCount());
// 修改账户余额
accountClient.decrease(order.getUserId(), order.getMoney());
}
}9.5 启动项目，访问测试
访问订单项目进行测试：
http://localhost:8083/create?userId=1&productId=1&count=10&money=100
- 查看 order、storage和account的控制台查看日志
- 查看三个数据库中的数据变化
10 将项目托管到 git 仓库
10.1 seata-samples 设置成本地 git 仓库
目前项目的目录结构：
seata-samples
|- seata-at
|- ...seata-at 工程对 AT 事务进行测试。后面我们还要测试 TCC 事务，会创建 seata-tcc 工程：
seata-samples
|- seata-at
|- ...
|- seata-tcc
|- ...我们可以把 seata 测试的这两个项目一起托管到同一个 git 仓库，便于管理，所以直接把 seata-samples 目录设置为本地仓库。
选择创建本地仓库:
选择 seata-samples 文件夹创建为本地库：
按 ctrl + k 提交，选择提交全部文件，填写提交说明后进行提交：
10.2 推送到远程 git 仓库
接下来先在 github 或 gitee 创建一个远程仓库，例如可以命名为 seata-samples。
再按 ctrl+shift+k 先设置远程仓库路径：
点击 push 向远程仓库推送：
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
