手记

回到首页 个人中心 反馈问题 注册登录
下载APP
首页 课程 实战 体系课 手记 专栏 慕课教程
继续浏览精彩内容
慕课网APP
程序员的梦工厂
打开
继续
感谢您的支持，我会继续努力的
赞赏金额会直接到老师账户
将二维码发送给自己后长按识别
微信支付
支付宝支付

Seata四种模式资料详解

一只甜甜圈 2025-01-02 17:27:45 浏览 22
一只甜甜圈
关注TA
已关注
手记 243
粉丝 55
获赞 117
概述

本文详细介绍了Seata的四种分布式事务模式，包括AT、TSO、XA和Saga模式，每种模式都有其特定的工作原理和应用场景。Seata通过这些模式为微服务架构下的分布式系统提供高性能且易用的事务解决方案。文章深入探讨了每种模式的配置和使用方法，提供了详细的代码示例和步骤说明。seata四种模式资料在文中得到了全面的展示和讲解。

Seata简介
Seata的作用和特点

Seata是阿里巴巴开源的一款分布式事务解决方案，旨在为微服务架构下的分布式系统提供高性能且易用的分布式事务功能。Seata的设计目标是支持多种主流的微服务框架，如Spring Cloud、Dubbo等，能够无缝地集成到现有的微服务架构中。Seata不仅支持传统的XA两阶段提交协议，还提供了一种更加灵活的事务补偿机制（Saga模式）等，满足了不同应用场景下的需求。

Seata的主要作用包括：

  1. 保证分布式系统的一致性：在分布式环境中，事务的ACID特性（原子性、一致性、隔离性、持久性）难以保持。Seata通过两阶段提交、补偿机制等手段保证分布式事务的最终一致性。

  2. 简化分布式事务的开发与维护：Seata提供了一套标准的API接口和配置方式，使得开发者可以快速地将分布式事务功能集成到应用中，显著降低了开发成本和维护难度。

  3. 性能优化：通过优化SQL解析算法、减少网络通信开销等技术手段，Seata在保证事务一致性的同时尽可能地提升了系统性能。
Seata的使用场景

Seata适用于微服务架构下的多种分布式事务场景，常见的应用场景包括：

  1. 多数据库操作：在一个微服务架构中，可能存在多个数据库。当一个业务逻辑涉及多个数据库操作时，使用传统的XA事务可能会因网络延迟等问题导致事务失败，这时可以采用Seata提供的分布式事务解决方案，以保证事务的最终一致性。

  2. 多服务操作：在微服务架构中，一个业务逻辑可能涉及多个服务的调用。例如，用户下单时，需要调用库存服务、订单服务等多个服务。在这种情况下，如果任何一个服务调用失败，整个业务逻辑都将失效。Seata可以帮助确保跨服务调用的一致性。

  3. 异步处理场景：在某些场景下，业务逻辑需要异步执行，比如发送邮件通知用户。使用两阶段提交机制可能会导致性能瓶颈，而Seata的Saga模式则更适合这种场景，它通过事务补偿机制保证了系统的最终一致性。
Seata的四种模式
AT模式

AT模式是Seata中最常用的一种分布式事务模式。它通过数据库代理层对SQL语句进行解析和拦截，实现了自动的事务补偿逻辑。

AT模式的工作原理

AT模式的工作原理可以分为以下几个步骤：

  1. 开始事务：客户端发起一个分布式事务请求，Seata Server端收到请求后，会生成一个全局事务ID（Global Transaction ID，简称XID），该XID将作为整个分布式事务的唯一标识。

  2. 数据库操作：客户端执行数据库操作。Seata Agent代理数据库连接，对SQL语句进行解析和拦截，记录当前操作的SQL。

  3. 提交事务：客户端请求提交分布式事务，Seata Server收到提交请求后，会根据事务的执行情况来决定下一步操作。如果所有分支事务都成功执行，Seata Server将通知客户端提交事务；反之，Seata Server将执行回滚操作。

  4. 补偿操作：如果某个分支事务执行失败，Seata Server会根据预设的补偿逻辑进行回滚操作，保证整个分布式事务的最终一致性。

AT模式的配置和使用

使用AT模式，首先需要引入Seata的相关依赖。在pom.xml文件中，添加如下依赖：

<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-spring-boot-starter</artifactId>
    <version>1.4.2</version>
</dependency>
<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-transaction-retry</artifactId>
    <version>1.4.2</version>
</dependency>

然后，在Spring Boot项目的application.yml文件中配置Seata的相关设置：

seata:
  server:
    port: 8091 # Seata服务端端口
    application-id: seata-demo # Seata服务端应用ID
    tx-service-group: default_tx_group # 事务服务组
    enable-auto-data-source-proxy: true # 启用自动数据库代理
    service:
      vgroup-mapping:
        default_tx_group: default_group # 配置事务服务组映射
      default:
        store:
          mode: file # Seata服务端存储模式，可以选择file或db
          file:
            dir: ./logs/seata # Seata服务端日志文件路径
            lock:
              dir: ./logs/seata/lock # Seata服务端锁文件路径
            undo:
              data-dir: ./logs/seata/undo # Seata服务端undo日志文件路径
            log:
              interval: 3600000 # Seata服务端日志清理周期

接下来，配置数据源代理。在application.yml文件中添加以下配置：

seata:
  datasource:
    ds:
      platform: mysql # 数据库类型
      rules:
        table:
          - table_id=@{0}\\.[0-9a-zA-Z_]{0,19} # 自定义规则匹配表名

最后，在Spring Boot项目的配置类中，注入DataSourceProxy：

import io.seata.integration.spring.SeataSpringBootConfiguration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.Primary;

import javax.sql.DataSource;

@Configuration
@Import(SeataSpringBootConfiguration.class)
public class DataSourceConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    @Primary
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
}

以上配置完成后，就可以在服务中使用AT模式的分布式事务了。例如：

import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @GlobalTransactional
    public void createOrder(int userId, int productId, int quantity) {
        jdbcTemplate.update("INSERT INTO orders (user_id, product_id, quantity) VALUES (?, ?, ?)", userId, productId, quantity);
        jdbcTemplate.update("UPDATE products SET quantity = quantity - ? WHERE id = ?", quantity, productId);
    }

    @GlobalTransactional
    public void rollbackOrder(int orderId, int productId, int quantity) {
        jdbcTemplate.update("DELETE FROM orders WHERE id = ?", orderId);
        jdbcTemplate.update("UPDATE products SET quantity = quantity + ? WHERE id = ?", quantity, productId);
    }
}

在上述示例中，createOrder方法是事务的主分支，负责执行创建订单和减少库存的操作。如果createOrder方法执行失败，Seata会调用rollbackOrder方法回滚订单和库存的变更。

TSO模式

TSO模式（Tidb Snapshot Mode）是Seata为TiDB数据库设计的一种分布式事务模式。它基于TiDB的多版本并发控制（MVCC）机制，实现了分布式事务的一致性。

TSO模式的工作原理

TSO模式的工作原理如下：

  1. 创建事务：客户端发起一个分布式事务请求，Seata Server端收到请求后，生成一个全局事务ID（XID），并将其发送给TiDB。

  2. 读取数据：TiDB根据XID读取数据，生成一个时间戳，该时间戳表示事务读取数据的时间点。

  3. 写入数据：TiDB根据时间戳写入数据，并生成一个新的时间戳，该时间戳表示事务写入数据的时间点。

  4. 提交事务：客户端请求提交分布式事务，Seata Server收到提交请求后，根据事务的执行情况决定下一步操作。如果所有分支事务都成功执行，Seata Server将通知客户端提交事务；反之，Seata Server将执行回滚操作。

  5. 回滚操作：如果某个分支事务执行失败，Seata Server将根据预设的补偿逻辑执行回滚操作，保证整个分布式事务的最终一致性。

TSO模式的配置和使用

使用TSO模式，首先需要引入Seata的相关依赖。在pom.xml文件中，添加如下依赖：

<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-spring-boot-starter</artifactId>
    <version>1.4.2</version>
</dependency>
<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-transaction-retry</artifactId>
    <version>1.4.2</version>
</dependency>

然后，在Spring Boot项目的application.yml文件中配置Seata的相关设置：

seata:
  server:
    port: 8091 # Seata服务端端口
    application-id: seata-demo # Seata服务端应用ID
    tx-service-group: default_tx_group # 事务服务组
    enable-auto-data-source-proxy: false # 关闭自动数据库代理
    service:
      vgroup-mapping:
        default_tx_group: default_group # 配置事务服务组映射
      default:
        store:
          mode: file # Seata服务端存储模式，可以选择file或db
          file:
            dir: ./logs/seata # Seata服务端日志文件路径
            lock:
              dir: ./logs/seata/lock # Seata服务端锁文件路径
            undo:
              data-dir: ./logs/seata/undo # Seata服务端undo日志文件路径
            log:
              interval: 3600000 # Seata服务端日志清理周期

接下来，配置TiDB数据源。在application.yml文件中添加以下配置：

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:4000/db # TiDB数据库URL
    username: root # 用户名
    password: root # 密码
    driver-class-name: com.mysql.jdbc.Driver # JDBC驱动类名

最后，在Spring Boot项目的配置类中，注入DataSource：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
}

以上配置完成后，就可以在服务中使用TSO模式的分布式事务了。例如：

import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @GlobalTransactional
    public void createOrder(int userId, int productId, int quantity) {
        jdbcTemplate.update("INSERT INTO orders (user_id, product_id, quantity) VALUES (?, ?, ?)", userId, productId, quantity);
        jdbcTemplate.update("UPDATE products SET quantity = quantity - ? WHERE id = ?", quantity, productId);
    }

    @GlobalTransactional
    public void rollbackOrder(int orderId, int productId, int quantity) {
        jdbcTemplate.update("DELETE FROM orders WHERE id = ?", orderId);
        jdbcTemplate.update("UPDATE products SET quantity = quantity + ? WHERE id = ?", quantity, productId);
    }
}

在上述示例中，createOrder方法是事务的主分支，负责执行创建订单和减少库存的操作。如果createOrder方法执行失败，Seata会调用rollbackOrder方法回滚订单和库存的变更。

XA模式

XA模式是一种传统的分布式事务协议，它通过两阶段提交（2PC）机制实现分布式事务的一致性。Seata支持XA模式，可以与现有的数据库管理系统（如MySQL、Oracle等）无缝集成。

XA模式的工作原理

XA模式的工作原理如下：

  1. 启动事务：客户端发起一个分布式事务请求，Seata Server端收到请求后，生成一个全局事务ID（XID），并将其发送给各个分支事务。

  2. 准备阶段：每个分支事务执行SQL操作，并将操作结果发送给Seata Server。Seata Server根据分支事务的结果决定下一步操作。如果所有分支事务都成功执行，Seata Server进入提交阶段；反之，Seata Server进入回滚阶段。

  3. 提交阶段：Seata Server通知所有分支事务提交事务。分支事务收到提交请求后，执行提交操作，并将提交结果发送给Seata Server。如果所有分支事务都成功提交，Seata Server认为整个分布式事务成功执行；反之，Seata Server进入回滚阶段。

  4. 回滚阶段：Seata Server通知所有分支事务回滚事务。分支事务收到回滚请求后，执行回滚操作，并将回滚结果发送给Seata Server。如果所有分支事务都成功回滚，Seata Server认为整个分布式事务回滚成功；反之，Seata Server再次进入回滚阶段。

XA模式的配置和使用

使用XA模式，首先需要引入Seata的相关依赖。在pom.xml文件中，添加如下依赖：

<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-spring-boot-starter</artifactId>
    <version>1.4.2</version>
</dependency>
<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-transaction-retry</artifactId>
    <version>1.4.2</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.28</version>
</dependency>
<dependency>
    <groupId>com.atomikos</groupId>
    <artifactId>transactions-jdbc</artifactId>
    <version>4.0.6</version>
</dependency>

然后，在Spring Boot项目的application.yml文件中配置Seata的相关设置：

seata:
  server:
    port: 8091 # Seata服务端端口
    application-id: seata-demo # Seata服务端应用ID
    tx-service-group: default_tx_group # 事务服务组
    enable-auto-data-source-proxy: false # 关闭自动数据库代理
    service:
      vgroup-mapping:
        default_tx_group: default_group # 配置事务服务组映射
      default:
        store:
          mode: file # Seata服务端存储模式，可以选择file或db
          file:
            dir: ./logs/seata # Seata服务端日志文件路径
            lock:
              dir: ./logs/seata/lock # Seata服务端锁文件路径
            undo:
              data-dir: ./logs/seata/undo # Seata服务端undo日志文件路径
            log:
              interval: 3600000 # Seata服务端日志清理周期

接下来，配置XA数据源。在application.yml文件中添加以下配置：

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/db # MySQL数据库URL
    username: root # 用户名
    password: root # 密码
    driver-class-name: com.mysql.cj.jdbc.Driver # JDBC驱动类名
    xa:
      enabled: true # 启用XA事务
      xa-data-source-class-name: com.mysql.jdbc.jdbc2.optional.MysqlXADataSource # XA数据源类名

最后，在Spring Boot项目的配置类中，注入DataSource：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.XADataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource dataSource() {
        return XADataSourceBuilder.create().build();
    }
}

以上配置完成后，就可以在服务中使用XA模式的分布式事务了。例如：

import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @GlobalTransactional
    public void createOrder(int userId, int productId, int quantity) {
        jdbcTemplate.update("INSERT INTO orders (user_id, product_id, quantity) VALUES (?, ?, ?)", userId, productId, quantity);
        jdbcTemplate.update("UPDATE products SET quantity = quantity - ? WHERE id = ?", quantity, productId);
    }

    @GlobalTransactional
    public void rollbackOrder(int orderId, int productId, int quantity) {
        jdbcTemplate.update("DELETE FROM orders WHERE id = ?", orderId);
        jdbcTemplate.update("UPDATE products SET quantity = quantity + ? WHERE id = ?", quantity, productId);
    }
}

在上述示例中，createOrder方法是事务的主分支，负责执行创建订单和减少库存的操作。如果createOrder方法执行失败，Seata会调用rollbackOrder方法回滚订单和库存的变更。

Saga模式

Saga模式是一种基于补偿机制的分布式事务模式。它通过在各个微服务之间执行预定义的补偿操作来保证分布式事务的一致性。Seata支持Saga模式，可以与现有的微服务框架（如Spring Cloud、Dubbo等）无缝集成。

Saga模式的工作原理

Saga模式的工作原理如下：

  1. 启动事务：客户端发起一个分布式事务请求，Seata Server端收到请求后，生成一个全局事务ID（XID），并将其发送给各个分支事务。

  2. 执行操作：每个分支事务执行SQL操作。如果操作成功，分支事务向Seata Server发送成功消息；如果操作失败，分支事务向Seata Server发送失败消息。

  3. 提交阶段：Seata Server收到所有分支事务的成功消息后，认为整个分布式事务成功执行；反之，Seata Server进入回滚阶段。

  4. 回滚阶段：Seata Server收到任何分支事务的失败消息后，会根据预设的补偿逻辑执行回滚操作。具体来说，Seata Server会通知各个分支事务执行补偿操作，以撤销之前的操作结果，保证整个分布式事务的最终一致性。

Saga模式的配置和使用

使用Saga模式，首先需要引入Seata的相关依赖。在pom.xml文件中，添加如下依赖：

<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-spring-boot-starter</artifactId>
    <version>1.4.2</version>
</dependency>
<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-transaction-retry</artifactId>
    <version>1.4.2</version>
</dependency>

然后，在Spring Boot项目的application.yml文件中配置Seata的相关设置：

seata:
  server:
    port: 8091 # Seata服务端端口
    application-id: seata-demo # Seata服务端应用ID
    tx-service-group: default_tx_group # 事务服务组
    enable-auto-data-source-proxy: false # 关闭自动数据库代理
    service:
      vgroup-mapping:
        default_tx_group: default_group # 配置事务服务组映射
      default:
        store:
          mode: file # Seata服务端存储模式，可以选择file或db
          file:
            dir: ./logs/seata # Seata服务端日志文件路径
            lock:
              dir: ./logs/seata/lock # Seata服务端锁文件路径
            undo:
              data-dir: ./logs/seata/undo # Seata服务端undo日志文件路径
            log:
              interval: 3600000 # Seata服务端日志清理周期

接下来，配置数据源。在application.yml文件中添加以下配置：

spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/db # MySQL数据库URL
    username: root # 用户名
    password: root # 密码
    driver-class-name: com.mysql.cj.jdbc.Driver # JDBC驱动类名

最后，在Spring Boot项目的配置类中，注入DataSource：

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class DataSourceConfig {

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
}

以上配置完成后，就可以在服务中使用Saga模式的分布式事务了。例如：

import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @GlobalTransactional
    public void createOrder(int userId, int productId, int quantity) {
        jdbcTemplate.update("INSERT INTO orders (user_id, product_id, quantity) VALUES (?, ?, ?)", userId, productId, quantity);
        jdbcTemplate.update("UPDATE products SET quantity = quantity - ? WHERE id = ?", quantity, productId);
    }

    @GlobalTransactional
    public void rollbackOrder(int orderId, int productId, int quantity) {
        jdbcTemplate.update("DELETE FROM orders WHERE id = ?", orderId);
        jdbcTemplate.update("UPDATE products SET quantity = quantity + ? WHERE id = ?", quantity, productId);
    }
}

在上述示例中，createOrder方法是事务的主分支，负责执行创建订单和减少库存的操作。如果createOrder方法执行失败，Seata会调用rollbackOrder方法回滚订单和库存的变更。

以上就是关于Seata四种模式的详细讲解。这些模式都各有特点，适用于不同的应用场景。希望这些信息能帮助你更好地理解和使用Seata。

打开App，阅读手记
相关标签
Spring Cloud
中间件
微服务
0人推荐
发表评论
随时随地看视频慕课网APP

相关课程

SpringCloud Finchley(M2+RELEASE+SR2)微服务实战

¥366 中级 5670

Spring Cloud Alibaba微服务从入门到进阶

¥399 中级 3065

Spring Cloud微服务架构 设计实现广告系统

¥299 中级 2131

Java 亿级项目架构设计与落地应用

¥4699 112