分布式事务—— TCC 代码示例

TCC（Try-Confirm-Cancel）是一种分布式事务解决方案，它通常用于在微服务架构中处理跨多个服务的事务。TCC 将长事务拆分成多个短事务，并通过应用层的两阶段提交来确保数据一致性。在 TCC 模型中，每个服务都负责维护自己的事务状态，并在全局事务的协调下执行 Try、Confirm 或 Cancel 操作。

下面是一个简化的 Java 示例，展示了如何实现 TCC 模型。这个示例将包括三个角色：事务协调者（Transaction Coordinator）、参与者（Transaction Participant，即服务）以及全局事务的上下文（Transaction Context）。

---

1. 定义全局事务上下文

public class GlobalTransactionContext {  
    private String xid; // 全局事务ID  
    private boolean isCommitted = false; // 标记事务是否已提交  
  
    // 构造函数、getter和setter省略  
  
    public synchronized void commit() {  
        isCommitted = true;  
    }  
  
    public synchronized boolean isCommitted() {  
        return isCommitted;  
    }  
}

2. 定义参与者接口

public interface TransactionParticipant {  
    // Try 阶段：尝试执行操作，预留资源  
    void tryExecute(GlobalTransactionContext context);  
  
    // Confirm 阶段：确认执行，真正提交资源  
    void confirm(GlobalTransactionContext context);  
  
    // Cancel 阶段：取消执行，释放资源  
    void cancel(GlobalTransactionContext context);  
}

3. 实现参与者

public class SimpleParticipant implements TransactionParticipant {  
    private String resourceName;  
  
    public SimpleParticipant(String resourceName) {  
        this.resourceName = resourceName;  
    }  
  
    @Override  
    public void tryExecute(GlobalTransactionContext context) {  
        System.out.println(resourceName + " TryExecute 成功.");  
        // 在这里执行 Try 阶段的逻辑，比如预留资源  
    }  
  
    @Override  
    public void confirm(GlobalTransactionContext context) {  
        if (context.isCommitted()) {  
            System.out.println(resourceName + " Confirm 成功.");  
            // 在这里执行 Confirm 阶段的逻辑，比如提交资源  
        }  
    }  
  
    @Override  
    public void cancel(GlobalTransactionContext context) {  
        if (!context.isCommitted()) {  
            System.out.println(resourceName + " Cancel 成功.");  
            // 在这里执行 Cancel 阶段的逻辑，比如释放资源  
        }  
    }  
}

4. 事务协调者

import java.util.List;  
  
public class TransactionCoordinator {  
    private List<TransactionParticipant> participants;  
    private GlobalTransactionContext context;  
  
    public TransactionCoordinator(List<TransactionParticipant> participants, GlobalTransactionContext context) {  
        this.participants = participants;  
        this.context = context;  
    }  
  
    public void executeTransaction() {  
        // Try 阶段  
        for (TransactionParticipant participant : participants) {  
            participant.tryExecute(context);  
        }  
  
        // 假设这里有一些业务逻辑来决定是否提交  
        // ...  
  
        // 根据业务逻辑决定提交或回滚  
        context.commit(); // 假设决定提交  
  
        // Confirm 或 Cancel 阶段  
        for (TransactionParticipant participant : participants) {  
            if (context.isCommitted()) {  
                participant.confirm(context);  
            } else {  
                participant.cancel(context);  
            }  
        }  
    }  
}

5. 使用示例

public class TCCDemo {  
    public static void main(String[] args) {  
        GlobalTransactionContext context = new GlobalTransactionContext();  
        context.setXid("tx12345");  
  
        List<TransactionParticipant> participants = List.of(  
            new SimpleParticipant("ResourceA"),  
            new SimpleParticipant("ResourceB")  
        );  
  
        TransactionCoordinator coordinator = new TransactionCoordinator(participants, context);  
        coordinator.executeTransaction();  
    }  
}

---

请注意，这个示例是高度简化的，并没有处理网络故障、服务宕机等分布式系统常见的复杂情况。在实际应用中，TCC 的实现需要更复杂的逻辑来确保事务的原子性、一致性、隔离性和持久性（ACID 属性）。此外，TCC 通常与注册中心、服务发现、配置中心等组件结合使用，以便在分布式环境中有效地协调和管理事务。