为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 Seata初识教程：轻松入门微服务分布式事务

Seata初识教程：轻松入门微服务分布式事务

标签：
Spring Cloud 微服务
概述

Seata是一款开源的分布式事务解决方案，旨在提供高性能和简单易用的事务管理服务。本文将详细介绍Seata的基本概念、安装步骤以及如何在实际应用中使用Seata，帮助读者快速掌握Seata初识教程。

Seata简介
Seata是什么

Seata（Software Transaction Access Layer）是一个开源的分布式事务解决方案，致力于提供高性能和简单易用的事务管理服务。它可以在微服务架构中确保跨多个服务的事务一致性，解决了微服务架构下分布式事务所带来的挑战。

Seata通过提供一套标准的分布式事务API，使得开发者可以轻松地在不同的服务之间实现事务的一致性管理。Seata的核心理念是通过Transaction Manager（TM）、Resource Manager（RM）、和Transaction Coordinator（TC）这三个组件来实现分布式事务的管理和协调。

Seata的作用和优势

Seata的主要作用是在微服务架构下保证跨服务的数据一致性，具体来说，Seata能够：

  1. 保证数据一致性：在分布式系统中，Seata确保所有参与的服务都能保持数据的一致性，即使在网络故障或服务异常的情况下。
  2. 简化分布式事务管理：Seata为开发者提供了一套易于使用的API，使得事务管理变得简单高效。
  3. 提高系统可用性：Seata通过事务补偿机制，增强了系统的容错能力和可用性。

Seata的主要优势包括：

  • 高性能：Seata采用轻量级的设计，能够在保证事务一致性的同时，提供高效的性能。
  • 易于集成：Seata与多种主流框架和数据库兼容，可以轻松地集成到现有的微服务架构中。
  • 社区活跃：Seata拥有活跃的社区支持，不断更新与改进，为用户提供及时的技术支持。
Seata的安装与环境准备

在开始使用Seata之前，需要先完成环境准备和安装过程。以下是详细的步骤：

1. 安装Java环境

Seata需要运行在Java环境中，确保你的系统中已经安装了Java开发工具包（JDK）。

java -version

如果未安装，可以从Oracle官网或OpenJDK下载对应版本的JDK。

2. 下载Seata

访问Seata的GitHub仓库，下载最新版本的Seata。

git clone https://github.com/seata/seata.git
cd seata
git checkout tags/<latest_version>

替换<latest_version>为实际版本号，例如1.5.0。

3. 配置环境变量

将Seata的bin目录添加到系统的PATH环境变量中，以方便后续操作。

export PATH=$PATH:/path/to/seata/bin

4. 启动Seata

启动Seata的Transaction Coordinator（TC）服务。

./bin/seata-server.sh -m nio -p 8091 -h 127.0.0.1 -c conf/seata-server.properties

命令解释：

  • -m nio：使用NIO模式启动Seata服务器。
  • -p 8091：监听端口8091。
  • -h 127.0.0.1：监听本地主机。
  • -c conf/seata-server.properties：指定配置文件路径。

5. 配置数据库

Seata需要一个数据库来存储事务相关信息，可以使用MySQL、Oracle等数据库。以下是使用MySQL配置的示例：

  1. 安装MySQL，并创建一个名为seata的数据库。
CREATE DATABASE seata;
  1. 将Seata的数据库表脚本文件conf/db/rds-seata-server.sql导入到MySQL中。
mysql -u root -p seata < /path/to/seata/conf/db/rds-seata-server.sql

完成以上步骤后，Seata的安装和环境准备就完成了。

Seata核心概念
资源管理器（RM）

资源管理器（Resource Manager，简称RM）是Seata中负责管理本地资源的组件。通常与本地数据库进行交互，能够自动识别并注册事务上下文，确保事务的本地资源能够参与到分布式事务中。

功能与职责

  • 识别本地资源：RM能够识别并注册本地资源，如数据库连接和JDBC连接。
  • 管理本地事务：管理本地事务的开始、提交和回滚。
  • 事务上下文管理：管理事务上下文，确保本地资源能够参与到分布式事务中。
  • 提交与回滚：根据事务协调器（TC）的指令，提交或回滚本地事务。

实现示例

在Spring Boot应用中，可以通过在配置文件中添加Seata的RM配置，将数据库连接转换为Seata的资源管理器。

spring:
  seata:
  transaction:
   service:
     group-id: ${GROUP_ID}
     tx-service-group: ${TX_SERVICE_GROUP}
     enabled: true
     rm:
       async-commit-buffer-limit: -1
       lock:
         retry-interval: 1000
         retry-times: 30
       report-success-async: true
       report-stdout: false
       execute-order: forward
       undo:
         log-serializer: jackson
         data-type:
           - type: insert
             undo-item:
               - column: id
                 type: primary
       transaction:
         isolation: read_committed
         retry-policy:
           retry-amount: 1
           break-amount: 1
           retry-throwable: false

通过这些配置，Seata的RM组件会接管数据库连接，并管理本地资源的事务状态。

资源代理（AT）

资源代理（Autocommit Transaction，简称AT）是Seata的核心技术之一，它能够在不修改现有应用程序代码的情况下，将普通的本地事务转换为分布式事务。AT通过在数据库操作时插入额外的日志，记录了每个操作的原始状态，以便在必要时进行回滚。

功能与职责

  • 自动管理事务：自动管理本地事务的提交与回滚。
  • 生成回滚日志：在事务执行时，插入额外的日志，记录操作的原始状态。
  • 回滚操作：根据需要，自动执行回滚操作，将数据恢复到事务开始前的状态。

实现示例

当使用AT模式时，开发者不需要对现有代码进行任何修改，只需要配置Seata的RM和AT相关参数即可。

spring:
 seata:
   transaction:
     service:
       group-id: ${GROUP_ID}
       tx-service-group: ${TX_SERVICE_GROUP}
       enabled: true
       rm:
         undo:
           log-serializer: jackson
           data-type:
             - type: insert
               undo-item:
                 - column: id
                   type: primary
         transaction:
           isolation: read_committed
           undo:
             log-serializer: jackson
             data-type:
               - type: insert
                 undo-item:
                   - column: id
                     type: primary
         execute-order: forward
       tm:
         commit-sync: false
         rollback-sync: false
       client:
         transaction:
           retry-policy:
             retry-amount: 1
             break-amount: 1
             retry-throwable: false

通过以上配置，在数据库操作过程中，AT会自动记录每个操作的状态，从而可以在必要时实现回滚。

事务管理器（TM）

事务管理器（Transaction Manager，简称TM）是Seata中负责发起和管理分布式事务的组件。它能够发起全局事务，并通过与资源管理器（RM）和事务协调器（TC）的通信，确保所有参与的本地事务能够正确地提交或回滚。

功能与职责

  • 发起事务：发起全局事务，生成全局事务ID。
  • 管理事务生命周期：管理全局事务的生命周期，包括开始、提交和回滚。
  • 协调事务：协调各个参与的本地事务，确保它们能够正确地执行。
  • 事务补偿：在事务失败时，进行必要的补偿操作。

实现示例

在Spring Boot应用中，可以通过注解方式使用TM来发起全局事务。

import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @GlobalTransactional
    public void registerUser(String userId) {
        // 执行数据库操作
        saveUserToDatabase(userId);
        // 其他业务逻辑
    }

    private void saveUserToDatabase(String userId) {
        // 模拟数据库操作
        System.out.println("Saving user " + userId + " to database.");
    }
}

通过@GlobalTransactional注解，TM会自动管理事务的生命周期，确保事务的正确提交或回滚。

事务协调器（TC）

事务协调器（Transaction Coordinator，简称TC）是Seata的核心组件之一，负责协调全局事务的执行。它通过维护全局事务的状态，确保所有参与的本地事务能够正确地提交或回滚。

功能与职责

  • 维护全局事务状态：维护全局事务的状态，包括事务的开始、提交和回滚。
  • 协调事务执行：协调各个参与的本地事务，确保它们能够正确地执行。
  • 事务补偿：在事务失败时，进行必要的补偿操作。

实现示例

在Seata的配置文件中，可以通过配置TC的相关参数，来指定TC的行为和策略。

seata:
  transaction:
  service:
    group-id: ${GROUP_ID}
    tx-service-group: ${TX_SERVICE_GROUP}
    enabled: true
    tm:
      commit-sync: false
      rollback-sync: false
    rm:
      async-commit-buffer-limit: -1
      lock:
        retry-interval: 1000
        retry-times: 30
      report-success-async: true
      report-stdout: false
      execute-order: forward
      undo:
        log-serializer: jackson
        data-type:
          - type: insert
            undo-item:
              - column: id
                type: primary
      transaction:
        isolation: read_committed
        undo:
          log-serializer: jackson
          data-type:
            - type: insert
              undo-item:
                - column: id
                  type: primary
        retry-policy:
          retry-amount: 1
          break-amount: 1
          retry-throwable: false

通过以上配置，TC会维护全局事务的状态，并协调各个参与的本地事务的执行。

Seata快速入门
Seata的下载与配置

在安装Seata并完成环境准备后，可以开始配置Seata以适应具体的应用场景。以下是具体的配置步骤：

1. 下载Seata

访问Seata的GitHub仓库，下载最新版本的Seata。

git clone https://github.com/seata/seata.git
cd seata
git checkout tags/<latest_version>

替换<latest_version>为实际版本号，例如1.5.0。

2. 配置Seata

在Seata的配置文件conf/seata-server.conf中，配置服务器端的参数。

transport {
    type = "TCP"
    server = "NIO"
    port = 8091
    bind.port = 8091
    heartbeat = true
    heartbeat.key = "DYNAMIC_HEARTBEAT_KEY"
    heartbeat.timeout = 30000
}
service {
    group.enable = true
    group.id = "DEFAULT_GROUP"
    tx.service.group = "DEFAULT_GROUP"
    tx.recovery = true
    tx.recovery.retry.period = 3000
    tx.recovery.max.retry = 3
    tx.recovery.thread.pool.size = 5
    tx.recovery.thread.pool.core.size = 5
    tx.recovery.thread.pool.queue.size = 10000
    tx.recovery.thread.pool.keepalive = 60000
    tx.recovery.thread.pool.core.pool.size = 5
    tx.recovery.thread.pool.max.pool.size = 5
    tx.recovery.thread.pool.queue.capacity = 10000
    tx.recovery.thread.pool.allow.core.thread.execution = false
    tx.recovery.thread.pool.max.queue.capacity = 10000
    tx.recovery.thread.pool.queue.timeout = 10000
    tx.recovery.thread.pool.queue.timeout.unit = MILLISECONDS
    tx.recovery.thread.pool.core.pool.size = 5
    tx.recovery.thread.pool.max.pool.size = 5
    tx.recovery.thread.pool.queue.capacity = 10000
    tx.recovery.thread.pool.allow.core.thread.execution = false
    tx.recovery.thread.pool.max.queue.capacity = 10000
    tx.recovery.thread.pool.queue.timeout = 10000
    tx.recovery.thread.pool.queue.timeout.unit = MILLISECONDS
}

3. 启动Seata

启动Seata的Transaction Coordinator（TC）服务。

./bin/seata-server.sh -m nio -p 8091 -h 127.0.0.1 -c conf/seata-server.properties

命令解释：

  • -m nio：使用NIO模式启动Seata服务器。
  • -p 8091：监听端口8091。
  • -h 127.0.0.1：监听本地主机。
  • -c conf/seata-server.properties：指定配置文件路径。

4. 验证Seata服务器

通过访问Seata提供的HTTP接口，验证Seata服务器是否正常启动。

curl http://127.0.0.1:8091/v1/server/status

成功启动后，返回结果应包含当前Seata服务器的状态信息。

Seata的启动与验证

启动Seata

在完成安装与配置后，可以通过以下命令启动Seata的Transaction Coordinator（TC）服务。

./bin/seata-server.sh -m nio -p 8091 -h 127.0.0.1 -c conf/seata-server.properties

命令解释：

  • -m nio：使用NIO模式启动Seata服务器。
  • -p 8091：监听端口8091。
  • -h 127.0.0.1：监听本地主机。
  • -c conf/seata-server.properties：指定配置文件路径。

验证Seata服务器

启动Seata后，可以通过访问Seata提供的HTTP接口，验证Seata服务器是否正常启动。

curl http://127.0.0.1:8091/v1/server/status

成功启动后，返回结果应包含当前Seata服务器的状态信息，如下所示：

{
  "message": "SUCCESS",
  "code": "0",
  "success": true,
  "result": {
    "serverStatus": "UP"
  }
}
第一个Seata分布式事务示例

在完成Seata的安装与配置后，可以编写一个简单的分布式事务示例来验证其功能。

创建Spring Boot项目

使用Spring Initializr创建一个新的Spring Boot项目，并添加Seata依赖。

<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-spring-boot-starter</artifactId>
    <version>1.5.0</version>
</dependency>

配置Seata

在项目中添加Seata的配置文件application.yml。

seata:
 transaction:
   service:
     group-id: ${GROUP_ID}
     tx-service-group: ${TX_SERVICE_GROUP}
     enabled: true
     rm:
       async-commit-buffer-limit: -1
       lock:
         retry-interval: 1000
         retry-times: 30
       report-success-async: true
       report-stdout: false
       execute-order: forward
       undo:
         log-serializer: jackson
         data-type:
           - type: insert
             undo-item:
               - column: id
                 type: primary
       transaction:
         isolation: read_committed
         undo:
           log-serializer: jackson
           data-type:
             - type: insert
               undo-item:
                 - column: id
                   type: primary
         retry-policy:
           retry-amount: 1
           break-amount: 1
           retry-throwable: false
     tm:
       commit-sync: false
       rollback-sync: false
     client:
       transaction:
         retry-policy:
           retry-amount: 1
           break-amount: 1
           retry-throwable: false

编写服务代码

创建一个简单的服务类，使用Seata的@GlobalTransactional注解发起全局事务。

import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @GlobalTransactional
    public void registerUser(String userId) {
        // 执行数据库操作
        saveUserToDatabase(userId);
        // 其他业务逻辑
    }

    private void saveUserToDatabase(String userId) {
        // 模拟数据库操作
        System.out.println("Saving user " + userId + " to database.");
    }
}

运行示例

启动Spring Boot应用，调用registerUser方法，验证Seata的分布式事务功能。

mvn spring-boot:run

在控制台中，可以看到输出的“Saving user ... to database”，表明Seata成功管理了分布式事务。

Seata实际应用案例
Seata在电商系统中的应用

Seata在电商系统中主要用于确保订单、库存和其他相关服务之间的数据一致性。通过在订单服务和库存服务之间发起分布式事务，确保订单创建和库存扣减操作同时成功，否则进行回滚。

场景描述

在电商系统中，当用户下单时，需要同时更新订单信息和扣减库存。如果其中任何一个操作失败，整个事务需要回滚，以确保数据的一致性。

实现步骤

  1. 配置Seata：在订单服务和库存服务中配置Seata。
seata:
 transaction:
   service:
     group-id: ${GROUP_ID}
     tx-service-group: ${TX_SERVICE_GROUP}
     enabled: true
     rm:
       async-commit-buffer-limit: -1
       lock:
         retry-interval: 1000
         retry-times: 30
       report-success-async: true
       report-stdout: false
       execute-order: forward
       undo:
         log-serializer: jackson
         data-type:
           - type: insert
             undo-item:
               - column: id
                 type: primary
       transaction:
         isolation: read_committed
         undo:
           log-serializer: jackson
           data-type:
             - type: insert
               undo-item:
                 - column: id
                   type: primary
         retry-policy:
           retry-amount: 1
           break-amount: 1
           retry-throwable: false
     tm:
       commit-sync: false
       rollback-sync: false
     client:
       transaction:
         retry-policy:
           retry-amount: 1
           break-amount: 1
           retry-throwable: false
  1. 编写服务代码：在订单服务中发起全局事务，并调用库存服务。
import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    private final UserService userService;

    public OrderService(UserService userService) {
        this.userService = userService;
    }

    @GlobalTransactional
    public void createOrder(int userId, int productCount) {
        // 调用库存服务
        userService.decreaseStock(userId, productCount);
        // 调用订单服务
        saveOrderToDatabase(userId, productCount);
    }

    private void saveOrderToDatabase(int userId, int productCount) {
        // 模拟数据库操作
        System.out.println("Saving order for user " + userId + " with product count " + productCount);
    }
}
  1. 调用服务：在应用入口处调用createOrder方法。
public class Application {

    public static void main(String[] args) {
        // 初始化Spring Boot应用
        SpringApplication.run(Application.class, args);
        // 创建订单
        OrderService orderService = new OrderService(new UserService());
        orderService.createOrder(1, 10);
    }
}

通过以上步骤，可以确保在电商系统中，订单创建和库存扣减操作能够同时成功，否则进行回滚。

Seata在金融系统中的应用

Seata在金融系统中主要用于确保转账、支付和其他相关服务之间的数据一致性。通过在转账服务和支付服务之间发起分布式事务，确保转账和支付操作同时成功，否则进行回滚。

场景描述

在金融系统中，当用户转账时，需要同时更新转账信息和支付信息。如果其中任何一个操作失败，整个事务需要回滚，以确保数据的一致性。

实现步骤

  1. 配置Seata：在转账服务和支付服务中配置Seata。
seata:
 transaction:
   service:
     group-id: ${GROUP_ID}
     tx-service-group: ${TX_SERVICE_GROUP}
     enabled: true
     rm:
       async-commit-buffer-limit: -1
       lock:
         retry-interval: 1000
         retry-times: 30
       report-success-async: true
       report-stdout: false
       execute-order: forward
       undo:
         log-serializer: jackson
         data-type:
           - type: insert
             undo-item:
               - column: id
                 type: primary
       transaction:
         isolation: read_committed
         undo:
           log-serializer: jackson
           data-type:
             - type: insert
               undo-item:
                 - column: id
                   type: primary
         retry-policy:
           retry-amount: 1
           break-amount: 1
           retry-throwable: false
     tm:
       commit-sync: false
       rollback-sync: false
     client:
       transaction:
         retry-policy:
           retry-amount: 1
           break-amount: 1
           retry-throwable: false
  1. 编写服务代码：在转账服务中发起全局事务，并调用支付服务。
import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.stereotype.Service;

@Service
public class TransferService {

    private final PaymentService paymentService;

    public TransferService(PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    @GlobalTransactional
    public void transferMoney(int userId, int amount) {
        // 调用支付服务
        paymentService.pay(userId, amount);
        // 调用转账服务
        saveTransferToDatabase(userId, amount);
    }

    private void saveTransferToDatabase(int userId, int amount) {
        // 模拟数据库操作
        System.out.println("Transferring money for user " + userId + " with amount " + amount);
    }
}
  1. 调用服务：在应用入口处调用transferMoney方法。
public class Application {

    public static void main(String[] args) {
        // 初始化Spring Boot应用
        SpringApplication.run(Application.class, args);
        // 创建订单
        TransferService transferService = new TransferService(new PaymentService());
        transferService.transferMoney(1, 100);
    }
}

通过以上步骤，可以确保在金融系统中，转账和支付操作能够同时成功，否则进行回滚。

Seata在物流系统中的应用

Seata在物流系统中主要用于确保订单、配送和其他相关服务之间的数据一致性。通过在订单服务和配送服务之间发起分布式事务，确保订单创建和配送信息更新操作同时成功，否则进行回滚。

场景描述

在物流系统中，当用户下单时，需要同时更新订单信息和配送信息。如果其中任何一个操作失败，整个事务需要回滚，以确保数据的一致性。

实现步骤

  1. 配置Seata：在订单服务和配送服务中配置Seata。
seata:
 transaction:
   service:
     group-id: ${GROUP_ID}
     tx-service-group: ${TX_SERVICE_GROUP}
     enabled: true
     rm:
       async-commit-buffer-limit: -1
       lock:
         retry-interval: 1000
         retry-times: 30
       report-success-async: true
       report-stdout: false
       execute-order: forward
       undo:
         log-serializer: jackson
         data-type:
           - type: insert
             undo-item:
               - column: id
                 type: primary
       transaction:
         isolation: read_committed
         undo:
           log-serializer: jackson
           data-type:
             - type: insert
               undo-item:
                 - column: id
                   type: primary
         retry-policy:
           retry-amount: 1
           break-amount: 1
           retry-throwable: false
     tm:
       commit-sync: false
       rollback-sync: false
     client:
       transaction:
         retry-policy:
           retry-amount: 1
           break-amount: 1
           retry-throwable: false
  1. 编写服务代码：在订单服务中发起全局事务，并调用配送服务。
import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    private final DeliveryService deliveryService;

    public OrderService(DeliveryService deliveryService) {
        this.deliveryService = deliveryService;
    }

    @GlobalTransactional
    public void createOrder(int userId, int productCount) {
        // 调用配送服务
        deliveryService.updateDeliveryInfo(userId, productCount);
        // 调用订单服务
        saveOrderToDatabase(userId, productCount);
    }

    private void saveOrderToDatabase(int userId, int productCount) {
        // 模拟数据库操作
        System.out.println("Saving order for user " + userId + " with product count " + productCount);
    }
}
  1. 调用服务：在应用入口处调用createOrder方法。
public class Application {

    public static void main(String[] args) {
        // 初始化Spring Boot应用
        SpringApplication.run(Application.class, args);
        // 创建订单
        OrderService orderService = new OrderService(new DeliveryService());
        orderService.createOrder(1, 10);
    }
}

通过以上步骤，可以确保在物流系统中，订单创建和配送信息更新操作能够同时成功，否则进行回滚。

点击查看更多内容
发表于 2024.11.08 00:16， 共 102 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

HUX布斯

手记
篇
粉丝
84
获赞与收藏
378

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
微信客服

购课补贴
联系客服咨询优惠详情

 帮助反馈 APP下载

慕课网APP
您的移动学习伙伴

 公众号

扫描二维码
关注慕课网微信公众号

举报

0/150
提交
取消