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

古城微笑少年丶 2023-10-13 18:48 14阅读 0赞

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

### 一、什么是接口幂等性？ ###

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

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

### 二、出现幂等的场景 ###

#### 1、前端重复提交 ####

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

#### 2、接口超时重试 ####

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

#### 3、消息重复消费 ####

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

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

## 三、解决方案 ##

### 1、token机制实现 ###

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

> **具体流程步骤：**
> 
> 1.  客户端会先发送一个请求去获取 token，服务端会生成一个全局唯一的 ID 作为 token 保存在 redis 中，同时把这个 ID 返回给客户端
> 2.  客户端第二次调用业务请求的时候必须携带这个 token
> 3.  服务端会校验这个 token，如果校验成功，则执行业务，并删除 redis 中的 token
> 4.  如果校验失败，说明 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;
        }
    }

1.  配置全局异常处理

*  自定义异常

@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;
        }
    }

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

*  接口

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

*  实现类具体代码1

@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);
        }
    }

*  优化：上面这样写虽然可以，但因为是分开的，在多线程情况下，无法保证原子性，可能会出现执行完查看后，锁就被别的线程抢掉了。所以就需要引用redis的lua脚本来进行保证执行的原子性。

> **脚本：**
> 
>  *  `"if(redis.call('get', KEYS[1]) == ARGV[1]) then return redis.call('del', KEYS[1]) else return 0 end"`

@Override
        public void checkToken(HttpServletRequest request) {
        
            String token = request.getHeader("token");
            if (StringUtils.isEmpty(token)){
        
                //如果请求头token为空就从参数中获取
                token=request.getParameter("token");
                //如果都为空抛出参数异常的错误
                if (StringUtils.isEmpty(token)){
        
                    throw new ServiceException(ResultCodeEnum.ILLEGAL_ARGUMENT.getMessage(),ResultCodeEnum.ILLEGAL_ARGUMENT.getCode());
                }
            }
    
    //          这段lua脚本的意思就是：先查看redis是否有这个值，如果没有直接返回false，如果有则删除这个值，然后返回true。并且是在保证原子性的情况下进行
            String script = "if(redis.call('get', KEYS[1]) == ARGV[1]) then return redis.call('del', KEYS[1]) else return 0 end";
       //            用于检索lua脚本的，以及定义返回类型
            DefaultRedisScript<Boolean> redisScript = new DefaultRedisScript<>(script, Boolean.class);
    //        放入lua脚本以及kay，value（value需要建立设置为唯一值）
            Boolean flag =  redisTemplate.execute(redisScript, Arrays.asList("token:" + token), token);
            //如果redis中不包含该token，说明token已经被删除了，抛出请求重复异常
            if (!flag){
        
                throw new ServiceException(ResultCodeEnum.REPETITIVE_OPERATION.getMessage(),ResultCodeEnum.REPETITIVE_OPERATION.getCode());
            }
    
    //        返回true，代表第一次提交，则执行后续业务操作------
            System.out.println("校验通过！");
        }

**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();
        }
    }

1.  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  
![在这里插入图片描述][d09cc6c9729a449a9d8bdb246e8fe7bd.png]

*  测试接口，把获取到的token放入请求头中  
    ![在这里插入图片描述][532c8473d1954208aa674d15c5cfc249.png]

### 2、基于mysql实现 ###

这种实现方式是利用 mysql 唯一索引的特性。  
**示意图如下：**  
![在这里插入图片描述][612ac3752b354829853b6cbfd30179b7.png]

> **具体流程步骤**：
> 
> 1.  建立一张去重表，其中某个字段需要建立唯一索引
> 2.  客户端去请求服务端，服务端会将这次请求的一些信息插入这张去重表中
> 3.  因为表中某个字段带有唯一索引，如果插入成功，证明表中没有这次请求的信息，则执行后续的业务逻辑
> 4.  如果插入失败，则代表已经执行过当前请求，直接返回

### 3、基于redis实现 ###

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

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

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

**示意图如下**  
![在这里插入图片描述][3713329af80b4c1f82f44dd4f07cfd34.png]

> **具体流程步骤：**
> 
> 1.  客户端先请求服务端，会拿到一个能代表这次请求业务的唯一字段
> 2.  将该字段以 SETNX 的方式存入 redis 中，并根据业务设置相应的超时时间
> 3.  如果设置成功，证明这是第一次请求，则执行后续的业务逻辑
> 4.  如果设置失败，则代表已经执行过当前请求，直接返回

使用该方式，相当于lua脚本的方式，原子性上可能会差一些，因为虽然setnx是原子性操作，但在设置超时时间时没法保证原子操作。

#### 3.1、具体代码 ####

1.  controller层

@RestController
    @RequestMapping("/order")
    @Slf4j
    public class OrderInfoController {
        
        @Resource
        private VerifyService verifyService;
    
    
        @PostMapping("/submitOrder")
        public Result submitOrder(@RequestBody OrderInfo orderInfo){
        
            verifyService.verification(orderInfo.getOrderNo());
    
    
            log.info("订单生成成功:{}",orderInfo);
            return Result.ok("订单生成成功！");
    
        }
    }

1.  验证的service层的方法

@Override
        public Boolean verification(@NonNull String code) {
        
    
    //        使用redis的原生操作SETNX命令来实现，这个方法会发送一条命令到Redis服务器，
    //              如果键不存在，则设置键值对，并设置过期时间，返回true；如果键已经存在，则不做任何操作，并返回false。
    //              使用Redis原生操作实现虽然简单，但在高并发情况下可能存在竞争条件的问题，因为尽管setIfAbsent方法本身是原子的，但在设置过期时间时不是同一个操作，
    //              可能存在一定的延迟，具体根据自己情况来，如果对原子性操作比较高可以使用lua脚本的方式实现
            Boolean aBoolean = redisTemplate.opsForValue().setIfAbsent("NX:" + code, code, 30, TimeUnit.MINUTES);
    
            if (aBoolean) {
        
    //            设置过期时间
                redisTemplate.expire("NX:" + code,30,TimeUnit.MINUTES);
            }else {
        
                throw new ServiceException(ResultCodeEnum.REPETITIVE_OPERATION.getMessage(),ResultCodeEnum.REPETITIVE_OPERATION.getCode());
            }
            return aBoolean;
        }

## 总结 ##

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

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

[230fbbf58d6d448a852d1d3f050d5233.png]: https://img-blog.csdnimg.cn/230fbbf58d6d448a852d1d3f050d5233.png
[d09cc6c9729a449a9d8bdb246e8fe7bd.png]: https://img-blog.csdnimg.cn/d09cc6c9729a449a9d8bdb246e8fe7bd.png
[532c8473d1954208aa674d15c5cfc249.png]: https://img-blog.csdnimg.cn/532c8473d1954208aa674d15c5cfc249.png
[612ac3752b354829853b6cbfd30179b7.png]: https://img-blog.csdnimg.cn/612ac3752b354829853b6cbfd30179b7.png
[3713329af80b4c1f82f44dd4f07cfd34.png]: https://img-blog.csdnimg.cn/3713329af80b4c1f82f44dd4f07cfd34.png