Feb 13 2023

微服务架构下的分布式事务最佳实践：Saga模式与TCC模式深度对比分析

作者： 绝缘体..   发布： 2023-02-13 17:28   分类： go, ios, MySQL, spring, tomcat, 后端框架, 开发工具, 数据库, 移动开发, 编程语言   阅读：   抢沙发  
 
更多

微服务架构下的分布式事务最佳实践：Saga模式与TCC模式深度对比分析

引言

在微服务架构日益普及的今天，分布式事务成为了一个不可回避的技术难题。传统的单体应用中，事务管理相对简单，可以借助数据库的ACID特性来保证数据的一致性。然而，当业务被拆分成多个独立的微服务时，跨服务的数据操作就涉及到了分布式事务的处理。

分布式事务的核心挑战在于如何在多个独立的服务之间保证数据的一致性，同时还要兼顾系统的性能和可用性。为了解决这一问题，业界提出了多种分布式事务解决方案，其中Saga模式和TCC模式是两种最为常用且有效的方案。

本文将深入分析Saga模式和TCC模式的实现原理，通过实际代码示例展示两种模式的应用场景，并结合Spring Cloud和Seata框架提供完整的实现方案和生产环境部署建议。

分布式事务基础概念

什么是分布式事务

分布式事务是指事务的参与者、支持事务的服务器、资源服务器以及事务管理器分别位于不同的分布式系统的不同节点之上。简单来说，就是一次大的操作由多个服务参与完成，这些服务可能部署在不同的服务器上，使用不同的数据库。

分布式事务的挑战

  1. 网络延迟和故障：服务间通信可能因为网络问题而失败
  2. 数据一致性：需要保证所有参与服务的数据状态保持一致
  3. 性能问题：分布式事务通常比本地事务慢得多
  4. 复杂性增加：系统架构和业务逻辑变得更加复杂

CAP理论与BASE理论

在分布式系统中，CAP理论指出一个分布式系统最多只能同时满足一致性(Consistency)、可用性(Availability)和分区容错性(Partition tolerance)这三项中的两项。

BASE理论是对CAP中一致性和可用性权衡的结果，它来源于对大规模互联网系统分布式实践的总结，通过牺牲强一致性来获得可用性，并允许数据在一段时间内不一致，但最终达到一致状态。

Saga模式详解

Saga模式基本概念

Saga模式是一种分布式事务解决方案，它将一个长事务拆分成多个短事务，每个短事务都对应一个补偿事务。当某个短事务执行失败时，系统会按照相反的顺序执行之前成功的短事务的补偿操作，从而保证数据的最终一致性。

Saga模式的工作原理

Saga模式的核心思想是将一个大的分布式事务分解为多个本地事务，每个本地事务都有对应的补偿事务：

  1. 正向执行：按照业务流程顺序执行各个服务的本地事务
  2. 补偿机制：当某个步骤失败时，按照相反顺序执行已成功步骤的补偿事务
  3. 最终一致性：通过补偿机制保证数据最终达到一致状态

Saga模式的两种实现方式

1. 事件驱动Saga

事件驱动Saga通过事件编排来协调各个服务的执行：

// 订单服务 - 创建订单Saga
@Component
public class OrderSaga {
    
    @Autowired
    private OrderService orderService;
    
    @Autowired
    private InventoryService inventoryService;
    
    @Autowired
    private PaymentService paymentService;
    
    // Saga启动方法
    public void createOrderSaga(OrderRequest request) {
        try {
            // 步骤1: 创建订单
            Order order = orderService.createOrder(request);
            
            // 步骤2: 扣减库存
            inventoryService.deductInventory(order.getProductId(), order.getQuantity());
            
            // 步骤3: 执行支付
            paymentService.processPayment(order.getId(), order.getAmount());
            
            // 步骤4: 完成订单
            orderService.completeOrder(order.getId());
            
        } catch (Exception e) {
            // 启动补偿流程
            compensateOrderCreation(request);
            throw new RuntimeException("订单创建失败", e);
        }
    }
    
    // 补偿方法
    private void compensateOrderCreation(OrderRequest request) {
        try {
            // 撤销支付
            paymentService.cancelPayment(request.getOrderId());
        } catch (Exception e) {
            log.error("撤销支付失败", e);
        }
        
        try {
            // 恢复库存
            inventoryService.restoreInventory(request.getProductId(), request.getQuantity());
        } catch (Exception e) {
            log.error("恢复库存失败", e);
        }
        
        try {
            // 取消订单
            orderService.cancelOrder(request.getOrderId());
        } catch (Exception e) {
            log.error("取消订单失败", e);
        }
    }
}

2. 命令协调Saga

命令协调Saga通过中央协调器来管理整个Saga的执行流程：

// Saga协调器
@Component
public class SagaCoordinator {
    
    @Autowired
    private List<SagaStep> sagaSteps;
    
    public void executeSaga(List<SagaCommand> commands) {
        List<SagaCommand> executedCommands = new ArrayList<>();
        
        try {
            // 顺序执行所有命令
            for (SagaCommand command : commands) {
                command.execute();
                executedCommands.add(command);
            }
        } catch (Exception e) {
            // 执行补偿
            compensate(executedCommands);
            throw new RuntimeException("Saga执行失败", e);
        }
    }
    
    private void compensate(List<SagaCommand> executedCommands) {
        // 反向执行补偿命令
        for (int i = executedCommands.size() - 1; i >= 0; i--) {
            try {
                executedCommands.get(i).compensate();
            } catch (Exception e) {
                log.error("补偿执行失败", e);
            }
        }
    }
}

// Saga命令接口
public interface SagaCommand {
    void execute() throws Exception;
    void compensate() throws Exception;
}

// 具体命令实现
public class CreateOrderCommand implements SagaCommand {
    private OrderService orderService;
    private OrderRequest orderRequest;
    private Order order;
    
    @Override
    public void execute() throws Exception {
        order = orderService.createOrder(orderRequest);
    }
    
    @Override
    public void compensate() throws Exception {
        if (order != null) {
            orderService.cancelOrder(order.getId());
        }
    }
}

基于Seata的Saga实现

Seata是阿里巴巴开源的分布式事务解决方案，它提供了完整的Saga模式实现：

# application.yml
seata:
  enabled: true
  application-id: ${spring.application.name}
  tx-service-group: my_tx_group
  service:
    vgroup-mapping:
      my_tx_group: default
    grouplist:
      default: 127.0.0.1:8091
  saga:
    enabled: true
    state-machine:
      resources:
        - classpath*:statelang/*.json

// 使用Seata Saga注解
@SagaState
public class OrderSagaService {
    
    @SagaAction(name = "createOrder")
    public void createOrder(OrderRequest request) {
        // 创建订单逻辑
    }
    
    @SagaAction(name = "deductInventory")
    public void deductInventory(InventoryRequest request) {
        // 扣减库存逻辑
    }
    
    @SagaAction(name = "processPayment")
    public void processPayment(PaymentRequest request) {
        // 处理支付逻辑
    }
    
    @SagaCompensation(name = "createOrder")
    public void compensateCreateOrder(OrderRequest request) {
        // 补偿创建订单
    }
    
    @SagaCompensation(name = "deductInventory")
    public void compensateDeductInventory(InventoryRequest request) {
        // 补偿扣减库存
    }
    
    @SagaCompensation(name = "processPayment")
    public void compensateProcessPayment(PaymentRequest request) {
        // 补偿支付处理
    }
}

TCC模式详解

TCC模式基本概念

TCC（Try-Confirm-Cancel）模式是一种分布式事务解决方案，它要求业务逻辑提供三个操作：

  1. Try：尝试执行业务，完成所有业务检查，预留必要业务资源
  2. Confirm：确认执行业务，真正执行业务，不作任何业务检查，只使用Try阶段预留的业务资源
  3. Cancel：取消执行业务，释放Try阶段预留的业务资源

TCC模式的工作原理

TCC模式通过三个阶段来保证分布式事务的一致性：

  1. Try阶段：各参与方尝试执行业务，进行业务检查并预留资源
  2. Confirm阶段：如果所有参与方的Try都成功，则执行Confirm操作
  3. Cancel阶段：如果任何一个参与方的Try失败，则执行Cancel操作回滚

TCC模式实现示例

// TCC接口定义
public interface AccountTccService {
    
    @TwoPhaseBusinessAction(name = "accountTccAction", commitMethod = "confirm", rollbackMethod = "cancel")
    public boolean prepare(@BusinessActionContextParameter(paramName = "accountId") String accountId,
                          @BusinessActionContextParameter(paramName = "amount") BigDecimal amount);
    
    public boolean confirm(BusinessActionContext businessActionContext);
    
    public boolean cancel(BusinessActionContext businessActionContext);
}

// 账户服务TCC实现
@Service
public class AccountTccServiceImpl implements AccountTccService {
    
    @Autowired
    private AccountRepository accountRepository;
    
    @Override
    public boolean prepare(String accountId, BigDecimal amount) {
        Account account = accountRepository.findById(accountId);
        if (account.getBalance().compareTo(amount) < 0) {
            throw new RuntimeException("余额不足");
        }
        
        // 预留资源：冻结金额
        account.setFrozenAmount(account.getFrozenAmount().add(amount));
        account.setBalance(account.getBalance().subtract(amount));
        accountRepository.save(account);
        
        return true;
    }
    
    @Override
    public boolean confirm(BusinessActionContext businessActionContext) {
        String accountId = businessActionContext.getActionContext("accountId", String.class);
        BigDecimal amount = businessActionContext.getActionContext("amount", BigDecimal.class);
        
        Account account = accountRepository.findById(accountId);
        // 确认冻结金额，实际扣款
        account.setFrozenAmount(account.getFrozenAmount().subtract(amount));
        accountRepository.save(account);
        
        return true;
    }
    
    @Override
    public boolean cancel(BusinessActionContext businessActionContext) {
        String accountId = businessActionContext.getActionContext("accountId", String.class);
        BigDecimal amount = businessActionContext.getActionContext("amount", BigDecimal.class);
        
        Account account = accountRepository.findById(accountId);
        // 释放冻结金额，恢复余额
        account.setFrozenAmount(account.getFrozenAmount().subtract(amount));
        account.setBalance(account.getBalance().add(amount));
        accountRepository.save(account);
        
        return true;
    }
}

// 转账服务使用TCC
@Service
public class TransferService {
    
    @Autowired
    private AccountTccService accountTccService;
    
    @GlobalTransactional
    public void transfer(String fromAccountId, String toAccountId, BigDecimal amount) {
        // Try阶段：准备转账
        accountTccService.prepare(fromAccountId, amount);
        accountTccService.prepare(toAccountId, amount.negate());
        
        // 如果Try都成功，Seata会自动调用Confirm
        // 如果Try失败，Seata会自动调用Cancel
    }
}

TCC模式的优缺点分析

优点：

  1. 高性能：Try阶段可以并行执行，提高系统吞吐量
  2. 强一致性：能够保证强一致性
  3. 灵活性：业务逻辑控制粒度细，可以精确控制资源预留

缺点：

  1. 实现复杂：需要业务方实现Try、Confirm、Cancel三个方法
  2. 侵入性强：对业务代码有较大侵入性
  3. 幂等性要求：Confirm和Cancel操作需要保证幂等性

Saga模式与TCC模式深度对比

1. 实现复杂度对比

维度 Saga模式 TCC模式
实现难度 中等 高
业务侵入性 低 高
开发成本 较低 较高
维护成本 中等 高

2. 性能对比

维度 Saga模式 TCC模式
执行效率 中等 高
并发性能 一般 优秀
资源占用 较多 较少

3. 一致性保证对比

维度 Saga模式 TCC模式
一致性级别 最终一致性 强一致性
回滚能力 完整回滚 精确回滚
数据一致性 可能存在中间状态 无中间状态

4. 适用场景对比

Saga模式适用场景：

  • 业务流程较长，涉及多个服务
  • 可以接受最终一致性
  • 业务逻辑复杂，难以精确控制资源
  • 对系统性能要求不是特别严格

TCC模式适用场景：

  • 对一致性要求极高
  • 业务流程相对较短
  • 能够精确控制资源预留
  • 对系统性能要求较高

Spring Cloud集成实现

基于Spring Cloud的Saga实现

// Saga编排服务
@RestController
@RequestMapping("/saga")
public class SagaOrchestratorController {
    
    @Autowired
    private OrderServiceClient orderServiceClient;
    
    @Autowired
    private InventoryServiceClient inventoryServiceClient;
    
    @Autowired
    private PaymentServiceClient paymentServiceClient;
    
    @PostMapping("/order")
    public ResponseEntity<String> createOrder(@RequestBody OrderRequest request) {
        SagaContext context = new SagaContext();
        context.setOrderRequest(request);
        
        try {
            // 步骤1: 创建订单
            OrderResponse orderResponse = orderServiceClient.createOrder(request);
            context.setOrderId(orderResponse.getOrderId());
            
            // 步骤2: 扣减库存
            inventoryServiceClient.deductInventory(
                new InventoryRequest(request.getProductId(), request.getQuantity()));
            
            // 步骤3: 执行支付
            paymentServiceClient.processPayment(
                new PaymentRequest(orderResponse.getOrderId(), request.getAmount()));
            
            // 步骤4: 完成订单
            orderServiceClient.completeOrder(orderResponse.getOrderId());
            
            return ResponseEntity.ok("订单创建成功");
            
        } catch (Exception e) {
            // 执行补偿
            compensate(context);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                               .body("订单创建失败: " + e.getMessage());
        }
    }
    
    private void compensate(SagaContext context) {
        try {
            if (context.getOrderId() != null) {
                // 撤销支付
                paymentServiceClient.cancelPayment(context.getOrderId());
            }
        } catch (Exception e) {
            log.error("撤销支付失败", e);
        }
        
        try {
            if (context.getOrderRequest() != null) {
                // 恢复库存
                inventoryServiceClient.restoreInventory(
                    new InventoryRequest(context.getOrderRequest().getProductId(), 
                                       context.getOrderRequest().getQuantity()));
            }
        } catch (Exception e) {
            log.error("恢复库存失败", e);
        }
        
        try {
            if (context.getOrderId() != null) {
                // 取消订单
                orderServiceClient.cancelOrder(context.getOrderId());
            }
        } catch (Exception e) {
            log.error("取消订单失败", e);
        }
    }
}

// Feign客户端定义
@FeignClient(name = "order-service")
public interface OrderServiceClient {
    @PostMapping("/orders")
    OrderResponse createOrder(@RequestBody OrderRequest request);
    
    @PutMapping("/orders/{orderId}/complete")
    void completeOrder(@PathVariable("orderId") String orderId);
    
    @DeleteMapping("/orders/{orderId}")
    void cancelOrder(@PathVariable("orderId") String orderId);
}

基于Seata的TCC实现

// 配置Seata
@Configuration
public class SeataConfig {
    
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource dataSource() {
        return new DruidDataSource();
    }
    
    @Bean
    public DataSourceProxy dataSourceProxy(DataSource dataSource) {
        return new DataSourceProxy(dataSource);
    }
    
    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSourceProxy dataSourceProxy) throws Exception {
        SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
        factoryBean.setDataSource(dataSourceProxy);
        return factoryBean.getObject();
    }
}

// TCC业务实现
@Service
public class AccountTccServiceImpl implements AccountTccService {
    
    @Autowired
    private AccountMapper accountMapper;
    
    @Override
    @GlobalTransactional
    public boolean prepare(@BusinessActionContextParameter(paramName = "accountId") String accountId,
                          @BusinessActionContextParameter(paramName = "amount") BigDecimal amount) {
        Account account = accountMapper.selectById(accountId);
        if (account == null || account.getBalance().compareTo(amount) < 0) {
            throw new RuntimeException("账户余额不足");
        }
        
        // Try阶段：冻结资金
        account.setFrozenAmount(account.getFrozenAmount().add(amount));
        account.setBalance(account.getBalance().subtract(amount));
        accountMapper.updateById(account);
        
        return true;
    }
    
    @Override
    public boolean confirm(BusinessActionContext businessActionContext) {
        String accountId = businessActionContext.getActionContext("accountId", String.class);
        BigDecimal amount = businessActionContext.getActionContext("Amount", BigDecimal.class);
        
        Account account = accountMapper.selectById(accountId);
        if (account != null) {
            // Confirm阶段：确认扣款
            account.setFrozenAmount(account.getFrozenAmount().subtract(amount));
            accountMapper.updateById(account);
        }
        
        return true;
    }
    
    @Override
    public boolean cancel(BusinessActionContext businessActionContext) {
        String accountId = businessActionContext.getActionContext("accountId", String.class);
        BigDecimal amount = businessActionContext.getActionContext("Amount", BigDecimal.class);
        
        Account account = accountMapper.selectById(accountId);
        if (account != null) {
            // Cancel阶段：释放冻结资金
            account.setFrozenAmount(account.getFrozenAmount().subtract(amount));
            account.setBalance(account.getBalance().add(amount));
            accountMapper.updateById(account);
        }
        
        return true;
    }
}

生产环境部署建议

1. 高可用部署架构

# Seata Server集群部署
version: '3.8'
services:
  seata-server-1:
    image: seataio/seata-server:1.5.2
    container_name: seata-server-1
    ports:
      - "8091:8091"
    environment:
      - SEATA_PORT=8091
      - STORE_MODE=db
    volumes:
      - ./seata-server/logs:/root/logs/seata
      - ./seata-server/file.conf:/seata-server/resources/file.conf
      - ./seata-server/registry.conf:/seata-server/resources/registry.conf

  seata-server-2:
    image: seataio/seata-server:1.5.2
    container_name: seata-server-2
    ports:
      - "8092:8091"
    environment:
      - SEATA_PORT=8092
      - STORE_MODE=db
    volumes:
      - ./seata-server/logs:/root/logs/seata
      - ./seata-server/file.conf:/seata-server/resources/file.conf
      - ./seata-server/registry.conf:/seata-server/resources/registry.conf

  seata-server-3:
    image: seataio/seata-server:1.5.2
    container_name: seata-server-3
    ports:
      - "8093:8091"
    environment:
      - SEATA_PORT=8093
      - STORE_MODE=db
    volumes:
      - ./seata-server/logs:/root/logs/seata
      - ./seata-server/file.conf:/seata-server/resources/file.conf
      - ./seata-server/registry.conf:/seata-server/resources/registry.conf

2. 数据库配置优化

# Seata数据库配置
spring.datasource.url=jdbc:mysql://localhost:3306/seata?useUnicode=true&characterEncoding=utf8&allowMultiQueries=true&useSSL=false
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# 连接池配置
spring.datasource.hikari.maximum-pool-size=20
spring.datasource.hikari.minimum-idle=5
spring.datasource.hikari.connection-timeout=30000
spring.datasource.hikari.idle-timeout=600000
spring.datasource.hikari.max-lifetime=1800000

3. 监控和告警配置

// 分布式事务监控
@Component
public class TransactionMonitor {
    
    private static final Logger log = LoggerFactory.getLogger(TransactionMonitor.class);
    
    @EventListener
    public void handleGlobalTransactionEvent(GlobalTransactionEvent event) {
        switch (event.getTransactionState()) {
            case Begin:
                log.info("全局事务开始: {}", event.getTransactionName());
                break;
            case Committed:
                log.info("全局事务提交成功: {}", event.getTransactionName());
                break;
            case Rollbacked:
                log.warn("全局事务回滚: {}", event.getTransactionName());
                // 发送告警
                sendAlert("事务回滚", event.getTransactionName());
                break;
            case TimeoutRollbacked:
                log.error("全局事务超时回滚: {}", event.getTransactionName());
                // 发送紧急告警
                sendAlert("事务超时回滚", event.getTransactionName());
                break;
        }
    }
    
    private void sendAlert(String type, String transactionName) {
        // 实现告警发送逻辑
        AlertService.sendAlert("分布式事务异常", 
                              String.format("事务类型: %s, 事务名称: %s", type, transactionName));
    }
}

4. 性能调优建议

JVM参数优化：

# JVM调优参数
-Xms2g -Xmx4g -XX:MetaspaceSize=256m -XX:MaxMetaspaceSize=512m
-XX:+UseG1GC -XX:MaxGCPauseMillis=200
-XX:+PrintGC -XX:+PrintGCDetails -XX:+PrintGCTimeStamps
-Xloggc:/logs/gc.log

应用参数优化：

# Spring Boot应用配置
server:
  tomcat:
    max-threads: 200
    min-spare-threads: 10
    accept-count: 100
    max-connections: 8192

spring:
  datasource:
    hikari:
      maximum-pool-size: 50
      minimum-idle: 10
      connection-timeout: 30000
      idle-timeout: 600000
      max-lifetime: 1800000
      leak-detection-threshold: 60000

最佳实践总结

1. 选择合适的模式

  • 选择Saga模式的情况：

    • 业务流程复杂，涉及多个服务
    • 可以接受最终一致性
    • 开发资源有限，希望降低实现复杂度

  • 选择TCC模式的情况：

    • 对数据一致性要求极高
    • 业务流程相对简单
    • 有足够的开发资源来实现复杂的补偿逻辑

2. 设计原则

  1. 幂等性设计：确保Confirm和Cancel操作的幂等性
  2. 超时控制：合理设置事务超时时间
  3. 异常处理：完善的异常处理和补偿机制
  4. 监控告警：建立完整的监控和告警体系
  5. 日志记录：详细的事务执行日志记录

3. 运维建议

  1. 定期清理：定期清理过期的事务数据
  2. 容量规划：根据业务量合理规划系统容量
  3. 备份策略：制定完善的数据库备份策略
  4. 故障演练：定期进行故障演练和恢复测试

4. 故障处理

// 故障处理示例
@Component
public class TransactionRecoveryService {
    
    @Autowired
    private TransactionLogRepository transactionLogRepository;
    
    @Scheduled(fixedDelay = 300000) // 每5分钟执行一次
    public void recoverPendingTransactions() {
        List<TransactionLog> pendingTransactions = 
            transactionLogRepository.findPendingTransactions();
        
        for (TransactionLog log : pendingTransactions) {
            try {
                // 根据事务状态执行相应的恢复操作
                if (log.getStatus() == TransactionStatus.PREPARED) {
                    executeConfirm(log);
                } else if (log.getStatus() == TransactionStatus.FAILED) {
                    executeCancel(log);
                }
            } catch (Exception e) {
                log.error("事务恢复失败: {}", log.getTransactionId(), e);
            }
        }
    }
    
    private void executeConfirm(TransactionLog log) {
        // 执行确认操作
    }
    
    private void executeCancel(TransactionLog log) {
        // 执行取消操作
    }
}

结论

Saga模式和TCC模式都是解决分布式事务问题的有效方案，各有其适用场景和优缺点。在实际项目中，需要根据具体的业务需求、性能要求和开发资源来选择合适的模式。

Saga模式实现相对简单，适合业务流程复杂、可以接受最终一致性的场景；TCC模式能够保证强一致性，但实现复杂度较高，适合对一致性要求极高的核心业务场景。

无论选择哪种模式，都需要考虑系统的高可用性、性能优化、监控告警等运维因素，确保分布式事务系统在生产环境中的稳定运行。通过合理的设计和完善的运维体系，可以有效解决微服务架构下的分布式事务难题，为业务的稳定发展提供有力保障。

本文来自极简博客，作者：梦境旅人，转载请注明原文链接：微服务架构下的分布式事务最佳实践：Saga模式与TCC模式深度对比分析

打赏

本文固定链接: https://www.cxy163.net/archives/6505 | 绝缘体-小明哥的技术博客

该日志由 绝缘体.. 于 2023年02月13日 发表在 go, ios, MySQL, spring, tomcat, 后端框架, 开发工具, 数据库, 移动开发, 编程语言 分类下， 你可以发表评论，并在保留原文地址及作者的情况下引用到你的网站或博客。
原创文章转载请注明: 微服务架构下的分布式事务最佳实践：Saga模式与TCC模式深度对比分析 | 绝缘体-小明哥的技术博客
关键字: , , , ,
【上一篇】
【下一篇】

您可能还会对这些文章感兴趣！

  1. golang内存对齐分析(转载)
  2. DOS攻击(一)
  3. docker进阶_dockerswarm
  4. docker基础_网络模式
  5. mysql中int(1)是长度为1的int型吗？
  6. CDN绕过
  7. python安全脚本
  8. php的password_hash方法详解
  9. python黑帽子(第二章)
  10. 使用php编程的一些经验总结
  11. sqlmap Tamper脚本编写
  12. mysql 配置ssl ，java应用连接
  13. (转载)Go channel 的妙用
  14. 蜜罐学习
  15. go语言编译过程概述
  16. golang并发扫描

微服务架构下的分布式事务最佳实践：Saga模式与TCC模式深度对比分析：等您坐沙发呢！

发表评论


快捷键：Ctrl+Enter