java 分布式事务的实现方式之TCC方案

待我称王封你为后i 2024-03-16 18:05 10阅读 0赞

TCC 是一种补偿性的事务模式，它通过在事务执行之前定义 Try、Confirm 和 Cancel 三个阶段来实现事务的一致性。

*  Try 阶段：

在 Try 阶段，业务逻辑会尝试预留所需的资源和执行必要的检查，但不会真正进行数据修改。它会预留相关资源，并执行一些预检查，以确保后续的 Confirm 阶段可以成功执行。  
如果 Try 阶段执行成功，则事务可以进入 Confirm 阶段。如果 Try 阶段失败，则事务进入 Cancel 阶段。

*  Confirm 阶段：

在 Confirm 阶段，业务逻辑会真正执行事务操作，对数据进行修改，释放预留的资源，并确认事务的最终结果。  
Confirm 阶段应该是幂等的，即多次执行 Confirm 操作的结果应该是一致的。

*  Cancel 阶段：

在 Cancel 阶段，业务逻辑会回滚 Try 阶段所预留的资源和对数据的修改，将系统恢复到事务执行前的状态。  
Cancel 阶段也应该是幂等的，即多次执行 Cancel 操作的结果应该是一致的。  
TCC 方案相比于三阶段提交具有更细粒度的控制和灵活性，它允许应用根据实际业务需求来定义 Try、Confirm 和 Cancel 阶段的逻辑，并提供了补偿机制来处理异常情况。TCC 方案相对来说更加适用于复杂的业务场景，但也需要应用开发者自行实现和管理补偿逻辑。而三阶段提交是一个标准的分布式事务协议，需要基于该协议来实现协调者和参与者的逻辑，以保证事务的一致性。

##### 以下是使用 Spring Boot 框架实现 TCC 方案的示例代码： #####

首先，添加所需的依赖项到 pom.xml 文件中：

<dependencies>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
        </dependency>
    </dependencies>

接下来，创建一个数据库实体类 Order，表示订单信息：

import javax.persistence.Entity;
    import javax.persistence.Id;
    import javax.persistence.Table;
    import java.math.BigDecimal;
    
    @Entity
    @Table(name = "orders")
    public class Order {
        @Id
        private String id;
        private BigDecimal amount;
        private String status;
    
        // 构造函数、Getter 和 Setter 省略...
    }

然后，创建一个订单的数据库访问接口 OrderRepository，使用 Spring Data JPA：

import org.springframework.data.jpa.repository.JpaRepository;
    
    public interface OrderRepository extends JpaRepository<Order, String> {
    }

接下来，创建一个 TCC 服务接口 PaymentService，定义 Try、Confirm 和 Cancel 阶段的方法：

public interface PaymentService {
        boolean tryPayment(String orderId, BigDecimal amount);
        boolean confirmPayment(String orderId);
        boolean cancelPayment(String orderId);
    }

然后，实现 PaymentService 接口的具体逻辑，创建一个名为 PaymentServiceImpl 的类：

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    @Service
    public class PaymentServiceImpl implements PaymentService {
        @Autowired
        private OrderRepository orderRepository;
    
        @Override
        public boolean tryPayment(String orderId, BigDecimal amount) {
            Order order = orderRepository.findById(orderId).orElse(null);
            if (order != null && "PENDING".equals(order.getStatus())) {
                // 执行 Try 阶段的逻辑，预留资源和执行预检查
                // 返回 true 表示 Try 阶段成功
                return true;
            }
            return false; // Try 阶段失败
        }
    
        @Override
        @Transactional
        public boolean confirmPayment(String orderId) {
            Order order = orderRepository.findById(orderId).orElse(null);
            if (order != null && "PENDING".equals(order.getStatus())) {
                // 执行 Confirm 阶段的逻辑，实际支付操作和修改订单状态
                order.setStatus("PAID");
                orderRepository.save(order);
                return true; // Confirm 阶段成功
            }
            return false; // Confirm 阶段失败
        }
    
        @Override
        @Transactional
        public boolean cancelPayment(String orderId) {
            Order order = orderRepository.findById(orderId).orElse(null);
            if (order != null && "PENDING".equals(order.getStatus())) {
                // 执行 Cancel 阶段的逻辑，回滚 Try 阶段的操作，不修改订单状态
                return true; // Cancel 阶段成功
            }
            return false; // Cancel 阶段失败
        }
    }

最后，创建一个示例的业务逻辑类 OrderService，在其中使用 TCC 方案处理订单的下单流程：

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    @Service
    public class OrderService {
        @Autowired
        private PaymentService paymentService;
    
        @Transactional
        public void placeOrder(String orderId, BigDecimal amount) {
            boolean tryResult = paymentService.tryPayment(orderId, amount);
            if (tryResult) {
                try {
                    // 执行业务逻辑，创建订单等操作
    
                    boolean confirmResult = paymentService.confirmPayment(orderId);
                    if (confirmResult) {
                        // 提交事务
                    } else {
                        // 事务回滚，执行 Cancel 阶段的逻辑
                        paymentService.cancelPayment(orderId);
                        throw new RuntimeException("Confirm payment failed");
                    }
                } catch (Exception e) {
                    // 异常处理，执行 Cancel 阶段的逻辑
                    paymentService.cancelPayment(orderId);
                    throw e;
                }
            } else {
                throw new RuntimeException("Try payment failed");
            }
        }
    }

这是一个简单的示例，演示了如何使用 Java 和 Spring Boot 实现 TCC 方案。在实际应用中，你可能需要根据具体业务需求进行适当的调整和扩展，例如添加日志记录、错误处理等。  
如果是在真实的分布式环境中，建议采用kafka来进行分布式消息的传递。