AT 模式#

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepo;

    @Autowired
    private InventoryFeignClient inventoryClient;

    @Autowired
    private AccountFeignClient accountClient;

    /**
     * 创建订单 - AT 模式
     *
     * 只需要加上 @GlobalTransactional 注解
     * 所有在这个方法中的数据库操作都会被 Seata 管理
     */
    @GlobalTransactional(rollbackFor = Exception.class)
    public Order createOrder(Long userId, Long skuId, Integer quantity,
                             BigDecimal amount) {
        // 1. 创建订单（本地数据库操作）
        Order order = new Order();
        order.setUserId(userId);
        order.setSkuId(skuId);
        order.setQuantity(quantity);
        order.setAmount(amount);
        order.setStatus(OrderStatus.PENDING);
        order = orderRepo.save(order);

        // 2. 扣减库存（远程服务，实际上也是数据库操作）
        inventoryClient.decreaseStock(skuId, quantity);

        // 3. 扣减余额（远程服务）
        accountClient.deductBalance(userId, amount);

        // 4. 更新订单状态
        order.setStatus(OrderStatus.SUCCESS);
        order = orderRepo.save(order);

        return order;
    }
}

@FeignClient(name = "inventory-service")
public interface InventoryFeignClient {

    /**
     * 扣减库存
     * 这个接口在 inventory-service 中的实现
     * 会被 Seata 自动代理，支持分布式事务
     */
    @PostMapping("/inventory/decrease")
    void decreaseStock(@RequestParam Long skuId, @RequestParam Integer quantity);
}

@RestController
@RequestMapping("/inventory")
public class InventoryController {

    @Autowired
    private InventoryRepository inventoryRepo;

    @PostMapping("/decrease")
    public void decreaseStock(@RequestParam Long skuId, @RequestParam Integer quantity) {
        // AT 模式：直接写业务 SQL，Seata 自动管理回滚
        // INSERT/UPDATE/DELETE 都支持
        inventoryRepo.decreaseStock(skuId, quantity);
    }
}

@GlobalTransactional(timeoutMills = 30000, rollbackFor = Exception.class)
public void someOperation() {
    // 全局事务超时时间，默认 60 秒
    // 超时后会自动回滚
}

// 支持 Spring 的事务传播行为
@GlobalTransactional(propagation = Propagation.REQUIRED)
public void outerOperation() {
    innerOperation(); // 嵌套的事务会加入当前全局事务
}

@GlobalTransactional(propagation = Propagation.REQUIRES_NEW)
public void innerOperation() {
    // 开启新的全局事务（独立于父事务）
}

@GlobalTransactional(rollbackFor = Exception.class)
public void someOperation() {
    try {
        // 业务逻辑
    } catch (BusinessException e) {
        // 业务异常：Seata 会自动回滚
        throw e;
    }
}

@GlobalTransactional(noRollbackFor = BusinessException.class)
public void someOperation() {
    // BusinessException 不会触发回滚
}

// AT 模式的回滚逻辑（简化版）
public void rollback() {
    // 1. 读取 undo log
    UndoLog undoLog = undoLogRepository.findByBranchIdAndXid(branchId, xid);

    // 2. 解析 rollback_info
    Map<String, Object> rollbackInfo = JSON.parse(undoLog.getRollbackInfo());

    // 3. 遍历每个数据项
    for (UndoItem item : rollbackInfo.getUndoItems()) {
        TableRecords beforeImage = item.getBeforeImage();
        TableRecords afterImage = item.getAfterImage();

        // 4. 根据操作类型生成反向 SQL
        if (isUpdate(item)) {
            // UPDATE: 用 beforeImage 覆盖 afterImage
            String sql = buildUpdateSql(beforeImage);
            jdbcTemplate.execute(sql);
        } else if (isInsert(item)) {
            // INSERT: 生成 DELETE
            String sql = buildDeleteSql(afterImage);
            jdbcTemplate.execute(sql);
        } else if (isDelete(item)) {
            // DELETE: 用 beforeImage 重新插入
            String sql = buildInsertSql(beforeImage);
            jdbcTemplate.execute(sql);
        }
    }

    // 5. 删除 undo log
    undoLogRepository.delete(undoLog);
}

// 错误示例：表没有主键
@Entity
@Table(name = "inventory")
public class Inventory {

    @Column(name = "sku_id")
    private Long skuId;

    @Column(name = "stock")
    private Integer stock;

    // 没有 @Id 注解！
}

// Seata 无法确定唯一行，回滚会失败

// 正确示例
@Entity
@Table(name = "inventory")
public class Inventory {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "sku_id")
    private Long skuId;

    @Column(name = "stock")
    private Integer stock;
}

// 谨慎使用：批量更新不同行
@GlobalTransactional
public void batchUpdate(List<Long> skuIds) {
    for (Long skuId : skuIds) {
        inventoryRepo.decreaseStock(skuId, 1);
    }
}