在我们项目开发过程中常常都会涉及到接口幂等性，最常见于支付和商城等系统；当然在面试过程中也会出现经常被面试官提问到。

一、什么是接口幂等性？

什么是幂等（百度百科）
幂等（idempotent、idempotence）是一个数学与计算机学概念，常见于抽象代数中。
在编程中一个幂等操作的特点是其任意多次执行所产生的影响均与一次执行的影响相同。幂等函数，或幂等方法，是指可以使用相同参数重复执行，并能获得相同结果的函数。这些函数不会影响系统状态，也不用担心重复执行会对系统造成改变。例如，“setTrue()”函数就是一个幂等函数,无论多次执行，其结果都是一样的.更复杂的操作幂等保证是利用唯一交易号(流水号)实现。

幂等性：多次调用方法或者接口不会改变业务状态，可以保证重复调用的结果和单次调用的结果一致。

二、出现幂等的场景

1、前端重复提交

用户注册，用户创建商品等操作，前端都会提交一些数据给后台服务，后台需要根据用户提交的数据在数据库中创建记录。如果用户不小心多点了几次，后端收到了好几次提交，这时就会在数据库中重复创建了多条记录。这就是接口没有幂等性带来的 bug。

2、接口超时重试

对于给第三方调用的接口，有可能会因为网络原因而调用失败，这时，一般在设计的时候会对接口调用加上失败重试的机制。如果第一次调用已经执行了一半时，发生了网络异常。这时再次调用时就会因为脏数据的存在而出现调用异常。

3、消息重复消费

在使用消息中间件来处理消息队列，且手动 ack 确认消息被正常消费时。如果消费者突然断开连接，那么已经执行了一半的消息会重新放回队列。

当消息被其他消费者重新消费时，如果没有幂等性，就会导致消息重复消费时结果异常，如数据库重复数据，数据库数据冲突，资源重复等。

三、解决方案

1、token机制实现

通过token 机制实现接口的幂等性,这是一种比较通用性的实现方法。
示意图如下：
在这里插入图片描述

具体流程步骤：

客户端会先发送一个请求去获取 token，服务端会生成一个全局唯一的 ID 作为 token 保存在 redis 中，同时把这个 ID 返回给客户端

客户端第二次调用业务请求的时候必须携带这个 token

服务端会校验这个 token，如果校验成功，则执行业务，并删除 redis 中的 token

如果校验失败，说明 redis 中已经没有对应的 token，则表示重复操作，直接返回指定的结果给客户端

代码实现

1. 添加依赖

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

2. 添加配置类

请求返回体

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Response {
    
    
        private int status;
        private String msg;
        private Object data;
}

返回code

public enum ResponseCode {
    
    
    // 通用模块 1xxxx
    ILLEGAL_ARGUMENT(10000, "参数不合法"),
    REPETITIVE_OPERATION(10001, "请勿重复操作"),
    ;
    ResponseCode(Integer code, String msg) {
    
    
        this.code = code;
        this.msg = msg;
    }
    private Integer code;
    private String msg;
    public Integer getCode() {
    
    
        return code;
    }
    public void setCode(Integer code) {
    
    
        this.code = code;
    }
    public String getMsg() {
    
    
        return msg;
    }
    public void setMsg(String msg) {
    
    
        this.msg = msg;
    }
}

配置全局异常处理

自定义异常

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ServiceException extends RuntimeException{
    
    
    private String code;
    private String msg;
}

全局异常捕获

@ControllerAdvice
public class MyControllerAdvice {
    
    
    @ResponseBody
    @ExceptionHandler(ServiceException.class)
    public Response serviceExceptionHandler(ServiceException exception){
    
    
        Response response=new Response(Integer.valueOf(exception.getCode()),exception.getMsg(),null);
        return response;
    }
}

编辑创建获取Token和验证Token的接口以及实现

接口

@Service
public interface TokenService {
    
    
    public Response createToken();
    public Response checkToken(HttpServletRequest request);
}

实现类具体代码

@Service
public class TokenServiceImpl implements TokenService {
    
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    @Override
    public Response createToken() {
    
    
//        生成uuid当作token,也可用雪花等其他算法
        String token = UUID.randomUUID().toString().replaceAll("-", "");
//        将生成的token存入redis中
        redisTemplate.opsForValue().set(token,token);
//        返回正确的结果信息
        Response response = new Response(0, token.toString(), null);
        return response;
    }

    @Override
    public Response checkToken(HttpServletRequest request) {
    
    
        String token = request.getHeader("token");
        if (StringUtils.isBlank(token)){
    
    
            //如果请求头token为空就从参数中获取
            token=request.getParameter("token");
            //如果都为空抛出参数异常的错误
            if (StringUtils.isBlank(token)){
    
    
                throw new ServiceException(ResponseCode.ILLEGAL_ARGUMENT.getCode().toString(),ResponseCode.ILLEGAL_ARGUMENT.getMsg());
            }
        }
        //如果redis中不包含该token，说明token已经被删除了，抛出请求重复异常
        if (!redisTemplate.hasKey(token)){
    
    
            throw new ServiceException(ResponseCode.REPETITIVE_OPERATION.getCode().toString(),ResponseCode.REPETITIVE_OPERATION.getMsg());
        }
        //删除token
        Boolean del=redisTemplate.delete(token);
        //如果删除不成功（已经被其他请求删除），抛出请求重复异常
        if (!del){
    
    
            throw new ServiceException(ResponseCode.REPETITIVE_OPERATION.getCode().toString(),ResponseCode.REPETITIVE_OPERATION.getMsg());
        }
        return new Response(0,"校验成功",null);
    }
}

5.配置自定义注解
只需要在需要实现接口幂等性的接口上添加此注解，就可以实现token验证。需要先请求获取token在验证

自定义注解

@Target({
    
    ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ApiIdempotent {
    
    
}

接口拦截器，通过拦截接口上有ApiIdempotent注解的接口实现验证

public class ApiIdempotentInterceptor implements HandlerInterceptor {
    
    
    @Autowired
    private TokenService tokenService;

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
    
        if (!(handler instanceof HandlerMethod)) {
    
    
            return true;
        }
        HandlerMethod handlerMethod= (HandlerMethod) handler;
        Method method=handlerMethod.getMethod();
//        拦截有 ApiIdempotent 注解的接口
        ApiIdempotent methodAnnotation=method.getAnnotation(ApiIdempotent.class);
        if (methodAnnotation != null){
    
    
            // 校验通过放行，校验不通过全局异常捕获后输出返回结果
            tokenService.checkToken(request);
        }
        return true;
    }
}

注入bean容器

@Configuration
public class WebConfig implements WebMvcConfigurer {
    
    
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
    
    
        registry.addInterceptor(apiIdempotentInterceptor());
    }

    @Bean
    public ApiIdempotentInterceptor apiIdempotentInterceptor() {
    
    
        return new ApiIdempotentInterceptor();
    }
}

controller接口验证

@RestController
@RequestMapping("/token")
public class TokenController {
    
    
    @Autowired
    private TokenService tokenService;
	//获取token
    @GetMapping("getToken")
    public Response getToken(){
    
    
        return tokenService.createToken();
    }
	//核验
    @PostMapping("checkToken")
    public Response checkToken(HttpServletRequest request){
    
    
        return tokenService.checkToken(request);
    }
}

具体实现使用

@Controller
public class BasicController {
    
    

    // http://127.0.0.1:8080/hello?name=lisi
    @RequestMapping("/hello")
    @ResponseBody
    @ApiIdempotent
    public String hello(@RequestParam(name = "name", defaultValue = "unknown user") String name) {
    
    
        return "Hello " + name;
    }

    // http://127.0.0.1:8080/user
    @RequestMapping("/user")
    @ResponseBody
    @ApiIdempotent
    public User user() {
    
    
        User user = new User();
        user.setName("theonefx");
        user.setAge(666);
        return user;
    }

结果验证

首先通过token接口创建一个token出来，此时redis中也存在了改token
在这里插入图片描述

测试接口，把获取到的token放入请求头中

2、基于mysql实现

这种实现方式是利用 mysql 唯一索引的特性。
示意图如下：
在这里插入图片描述

具体流程步骤：

建立一张去重表，其中某个字段需要建立唯一索引

客户端去请求服务端，服务端会将这次请求的一些信息插入这张去重表中

因为表中某个字段带有唯一索引，如果插入成功，证明表中没有这次请求的信息，则执行后续的业务逻辑

如果插入失败，则代表已经执行过当前请求，直接返回

3、基于redis实现

这种实现方式是基于 setNx 命令实现的，分布式锁一般也就是采用这种方式。

setNx key value：将 key 的值设为 value ，当且仅当 key 不存在。若给定的 key 已经存在，则 SETNX 不做任何动作。

该命令在设置成功时返回 1，设置失败时返回 0。

示意图如下
在这里插入图片描述

具体流程步骤：

客户端先请求服务端，会拿到一个能代表这次请求业务的唯一字段

将该字段以 SETNX 的方式存入 redis 中，并根据业务设置相应的超时时间

如果设置成功，证明这是第一次请求，则执行后续的业务逻辑

如果设置失败，则代表已经执行过当前请求，直接返回

总结

这几种实现幂等的方式其实都是大同小异的，类似的还有使用状态机、悲观锁、乐观锁的方式来实现，其实都是采用的一个锁的方式实现，都是比较简单的。

总之，当你去设计一个接口的时候，幂等都是首要考虑的问题，特别是当你负责设计转账、支付这种涉及到 money 的接口

【2023】项目开发过程中接口幂等性解决方案实现，及代码示例