Seata Saga模式实战教程

cheniy2025/9/17大约 3 分钟

Seata Saga模式实战教程

前置知识

在学习本教程之前，请确保您已经：

了解Seata的基本概念
掌握Spring Boot和Spring Cloud开发
理解状态机的基本原理

Saga模式简介

Saga模式是一种长事务解决方案，将一个大事务拆分为多个本地事务，每个本地事务都有对应的补偿操作。其特点是：

长事务支持：适合处理长事务场景
异步补偿：通过补偿机制保证最终一致性
并发执行：支持服务编排和并发调用

工作原理

正向操作：按照状态机定义的流程执行各个服务
补偿机制：当某个服务失败时，执行之前服务的补偿操作
状态管理：通过状态机管理整个流程的执行

状态机配置

1. 状态机定义

{
    "name": "orderSaga",
    "comment": "订单流程",
    "version": "1.0.0",
    "states": {
        "Start": {
            "type": "Start",
            "next": "CreateOrder"
        },
        "CreateOrder": {
            "type": "ServiceTask",
            "serviceType": "spring",
            "serviceName": "orderService",
            "serviceMethod": "create",
            "compensation": "compensateOrder",
            "next": "ReduceStock"
        },
        "ReduceStock": {
            "type": "ServiceTask",
            "serviceType": "spring",
            "serviceName": "stockService",
            "serviceMethod": "reduce",
            "compensation": "compensateStock",
            "next": "End"
        },
        "End": {
            "type": "End"
        }
    }
}

2. 服务实现

@Service("orderService")
@Slf4j
public class OrderService {
    
    @Autowired
    private OrderMapper orderMapper;
    
    public boolean create(String businessKey, Map<String, Object> params) {
        Order order = new Order();
        order.setBusinessKey(businessKey);
        order.setUserId((String) params.get("userId"));
        order.setAmount((Integer) params.get("amount"));
        order.setStatus(OrderStatus.CREATED.getCode());
        
        return orderMapper.insert(order) > 0;
    }
    
    public boolean compensateOrder(String businessKey, Map<String, Object> params) {
        Order order = orderMapper.selectByBusinessKey(businessKey);
        order.setStatus(OrderStatus.CANCELED.getCode());
        
        return orderMapper.updateById(order) > 0;
    }
}

使用示例

1. 配置Saga状态机

@Configuration
public class SagaConfig {
    
    @Bean
    public StateMachineEngine stateMachineEngine(
            @Autowired ApplicationContext applicationContext) {
        StateMachineEngineImpl stateMachineEngine = new StateMachineEngineImpl();
        // 设置Spring容器
        SpringApplicationContextProvider contextProvider = new SpringApplicationContextProvider();
        contextProvider.setApplicationContext(applicationContext);
        stateMachineEngine.setApplicationContextProvider(contextProvider);
        
        // 设置状态机配置
        Resources[] resources = new Resources[] {
            new ClassPathResource("statelang/order_saga.json")
        };
        StateMachineRepository repository = new StateMachineRepository();
        repository.setResources(resources);
        repository.initRepository();
        stateMachineEngine.setStateMachineRepository(repository);
        
        return stateMachineEngine;
    }
}

2. 调用示例

@Service
@Slf4j
public class BusinessService {

    @Autowired
    private StateMachineEngine stateMachineEngine;
    
    @GlobalTransactional
    public boolean createOrder(String userId, Integer amount) {
        Map<String, Object> startParams = new HashMap<>();
        startParams.put("userId", userId);
        startParams.put("amount", amount);
        
        StateMachineInstance instance = stateMachineEngine.start(
            "orderSaga",
            null,
            startParams
        );
        
        return instance.getStatus().equals(ExecutionStatus.SU);
    }
}

最佳实践

设计建议

注意事项

补偿设计：每个服务都要设计幂等的补偿操作
状态记录：记录每个服务的执行状态
异常处理：合理处理补偿过程中的异常
超时控制：设置合适的服务超时时间

优化建议

并行执行：合理使用并行服务提升性能
状态持久化：持久化状态机执行记录
监控告警：对补偿操作进行监控

并行服务示例

{
    "name": "parallelSaga",
    "states": {
        "Choice": {
            "type": "Choice",
            "branches": [{
                "condition": "amount > 100",
                "next": "FirstService"
            }, {
                "next": "SecondService"
            }]
        },
        "FirstService": {
            "type": "ServiceTask",
            "next": "Join"
        },
        "SecondService": {
            "type": "ServiceTask",
            "next": "Join"
        },
        "Join": {
            "type": "Join",
            "next": "End"
        }
    }
}

常见问题

1. Saga模式如何保证数据一致性？

Saga通过以下机制保证最终一致性：

补偿操作的设计和实现
状态机的执行记录
幂等性设计
异常重试机制

2. 如何处理补偿失败的情况？

@Service
public class CompensationService {
    
    @Transactional(rollbackFor = Exception.class)
    public boolean compensate(String businessKey) {
        // 1. 记录补偿日志
        logCompensation(businessKey);
        
        try {
            // 2. 执行补偿
            doCompensate(businessKey);
            return true;
        } catch (Exception e) {
            // 3. 补偿失败处理
            handleCompensationFailure(businessKey, e);
            return false;
        }
    }
}

补偿失败的处理建议：

记录详细的失败信息
实现重试机制
提供人工干预接口

总结

本文详细介绍了Seata Saga模式的实现方法：

✅ 基本概念：Saga模式原理和特点
✅ 状态机配置：JSON配置和服务实现
✅ 使用示例：完整的业务流程实现
✅ 最佳实践：设计建议和优化方案
✅ 常见问题：一致性保证和补偿处理

下一步学习

了解Seata的其他模式
学习复杂业务场景的处理
探索性能优化方案