接口的幂等性-CSDN博客

本文链接：https://blog.csdn.net/qq_51447496/article/details/137467425

接口的幂等性

什么是接口的幂等性？

接口的幂等性是指无论调用多少次，接口的执行结果都是一致的。简而言之，对于同一个请求，无论执行一次还是多次，都不会产生不同的结果。这对于系统的可靠性和稳定性至关重要。

案例分析：银行转账接口

考虑一个简单的银行转账接口，具有以下特征：

URL：POST /transfer
请求参数：
- from_account: 转出账户
- to_account: 转入账户
- amount: 转账金额

该接口的幂等性要求在重复调用时不会导致重复的转账操作。

1. 使用唯一标识符（ID）

在接口设计中，我们可以使用唯一标识符来标识每个请求，以确保请求的唯一性。我们可以使用UUID类来生成唯一的请求ID。

import java.util.UUID;

public class TransferService {
    // 模拟转账服务
    public String transfer(String fromAccount, String toAccount, double amount) {
        // 生成唯一请求ID
        String requestId = UUID.randomUUID().toString();
        
        // 模拟转账逻辑，使用 requestId 标识请求
        System.out.println("发起转账请求，请求ID：" + requestId);
        System.out.println("从账户 " + fromAccount + " 转账到账户 " + toAccount + "，金额：" + amount);
        
        // 实际转账逻辑...
        
        System.out.println("转账成功！");
        return requestId;
    }
    
    // 测试转账服务
    public static void main(String[] args) {
        TransferService transferService = new TransferService();
        String requestId1 = transferService.transfer("123456789", "987654321", 1000.0);
        String requestId2 = transferService.transfer("123456789", "987654321", 1000.0);
        
        System.out.println("第一次转账请求ID：" + requestId1);
        System.out.println("第二次转账请求ID：" + requestId2);
    }
}

在上述代码中，我们创建了一个名为 TransferService 的类，其中的 transfer 方法模拟了转账服务。在每次调用 transfer 方法时，我们使用 UUID.randomUUID().toString() 来生成唯一的请求ID，并将其作为转账请求的标识。通过打印出请求ID，我们可以看到每次转账请求的唯一性。

2. 使用幂等操作

使用幂等操作可以确保接口的执行结果与操作次数无关。在数据库更新操作中，我们可以使用乐观锁来避免并发更新问题。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class AccountService {
    private Lock lock = new ReentrantLock();

    // 模拟账户服务
    public void transfer(String fromAccount, String toAccount, double amount) {
        lock.lock();
        try {
            // 模拟转账逻辑，使用乐观锁更新账户余额
            System.out.println("发起转账，从账户 " + fromAccount + " 转出金额：" + amount);
            System.out.println("正在执行转账操作...");
            
            // 模拟更新账户余额
            // updateAccountBalance(fromAccount, toAccount, amount);
            
            System.out.println("转账成功！");
        } finally {
            lock.unlock();
        }
    }
    
    // 测试转账服务
    public static void main(String[] args) {
        AccountService accountService = new AccountService();
        
        // 模拟两个线程同时调用转账服务
        new Thread(() -> {
            accountService.transfer("123456789", "987654321", 1000.0);
        }).start();
        
        new Thread(() -> {
            accountService.transfer("123456789", "987654321", 1000.0);
        }).start();
    }
}

在上述代码中，创建了一个名为 AccountService 的类，其中的 transfer 方法模拟了账户转账服务。在转账过程中，我们使用了 ReentrantLock 锁来确保转账操作的原子性。虽然这里的转账逻辑是模拟的，但实际应用中，我们可以在更新账户余额时使用乐观锁等方式来确保幂等性。

3. 检测重复请求

在接口层面检测重复请求，可以使用数据库或缓存记录请求的唯一标识符或者请求参数，并判断是否为重复请求。如果是重复请求，可以拒绝重复处理或者返回相同的响应结果。

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

public class RequestValidator {
    private static ConcurrentMap<String, Boolean> processedRequests = new ConcurrentHashMap<>();

    public static boolean isValidRequest(String requestId) {
        if (processedRequests.putIfAbsent(requestId, true) != null) {
            return false; // 重复请求
        } else {
            return true;
        }
    }
}

在上述代码中，使用了 ConcurrentHashMap 来存储已处理的请求，以保证线程安全。当收到新的请求时，我们先检查是否已经处理过该请求，如果是重复请求则返回false，否则将该请求标记为已处理并返回true。这样就可以确保相同的请求不会被处理多次。

4. 使用版本控制

使用版本控制
在接口设计中使用版本控制，确保接口的变化不会影响幂等性。当接口升级或者修改时，需要保证新版本的接口依然具有相同的幂等性。

Copy code
// 版本控制示例
@Path("/v1/transfer")
public class TransferResourceV1 {
    // 接口实现...
}

@Path("/v2/transfer")
public class TransferResourceV2 {
    // 接口实现...
}
在上述示例中，使用了版本控制来管理不同版本的接口。如果需要对接口进行升级或者修改，可以在新版本的接口中实现新的功能，而保留旧版本接口的幂等性。这样可以确保在系统升级过程中不会破坏现有的接口幂等性。


### 5. 提供状态查询接口

如果接口是有状态的，可以提供状态查询接口来获取当前状态，以便客户端在重试时能够知道上一次操作的结果，并采取相应的处理措施。

```java
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@Path("/transferStatus")
public class TransferStatusResource {
    // 模拟保存请求状态的数据库或缓存
    private static final Map<String, String> requestStatusMap = new ConcurrentHashMap<>();

    @GET
    public String getTransferStatus(@QueryParam("requestId") String requestId) {
        // 查询请求状态并返回
        String status = requestStatusMap.get(requestId);
        if (status != null) {
            return status;
        } else {
            return "Request ID not found";
        }
    }

    // 模拟更新请求状态的方法
    public static void updateRequestStatus(String requestId, String status) {
        requestStatusMap.put(requestId, status);
    }

    // 测试状态查询接口
    public static void main(String[] args) {
        // 假设某个请求已经处理完成，状态为 "SUCCESS"
        String requestId = "123456789";
        String status = "SUCCESS";
        updateRequestStatus(requestId, status);

        // 查询请求状态
        TransferStatusResource resource = new TransferStatusResource();
        System.out.println("Request ID: " + requestId + ", Status: " + resource.getTransferStatus(requestId));
    }
}

在上述代码中，提供了一个名为 TransferStatusResource 的类，该类模拟了一个查询请求状态的接口。当客户端在重试时，可以通过查询接口获取上一次操作的结果。我们使用 ConcurrentHashMap 来模拟保存请求状态的数据库或缓存，并提供了一个 updateRequestStatus 方法来更新请求状态。