【SpringBoot】基于自定义注解实现接口幂等性方法_接口幂等性通过注解实现

近期需要对接口进行幂等性的改造，特此记录下。

一、背景

在微服务架构中，幂等是一致性方面的一个重要概念。

一个幂等操作的特点是指其多次执行所产生的影响均与一次执行的影响相同。在业务中也就是指的，多次调用方法或者接口不会改变业务状态，可以保证重复调用的结果和单次调用的结果一致。

二、常见场景

1.用户重复操作

在产品订购下单过程中，由于网络延迟或者用户误操作等原因，导致多次提交。这时就会在后台执行多条重复请求，导致脏数据或执行错误等。

2.分布式消息重复消费

消息队列中由于某种原因消息二次发送或者被二次消费的时候，导致程序多次执行，从而导致数据重复，资源冲突等。

3.接口超时重试

由于网络波动，引起的重复请求，导致数据的重复等。

三、常见解决方案

1.token机制实现

由客户端发送请求获取Token，服务端生成全局唯一的ID作为token，并保存在redis中，同时返回ID给客户端。

客户端调用业务端的请求的时候需要携带token，由服务端进行校验，校验成功，则允许执行业务，不成功则表示重复操作，直接返回给客户端。

2.mysql去重

建立一个去重表，当客户端请求的时候，将请求信息存入去重表进行判断。由于去重表带有唯一索引，如果插入成功则表示可以执行。如果失败则表示已经执行过当前请求，直接返回。

3.基于redis锁机制

在redis中，SETNX表示 SET IF NOT EXIST的缩写，表示只有不存在的时候才可以进行设置，可以利用它实现锁的效果。

客户端请求服务端时，通过计算拿到代表这次业务请求的唯一字段，将该值存入redis，如果设置成功表示可以执行。失败则表示已经执行过当前请求，直接返回。

四、实现方法

基于种种考虑，本文将基于方法3实现幂等性方法。其中有两个需要注意的地方：

1.如何实现唯一请求编号进行去重？

本文将采用用户ID:接口名:请求参数进行请求参数的MD5摘要，同时考虑到请求时间参数的干扰性（同一个请求，除了请求参数都相同可以认为为同一次请求），排除请求时间参数进行摘要，可以在短时间内保证唯一的请求编号。

2.如何保证最小的代码侵入性？

本文将采用自定义注解，同时采用切面AOP的方式，最大化的减少代码的侵入，同时保证了方法的易用性。

五、代码实现 

1.自定义注解

实现自定义注解，同时设置超时时间作为重复间隔时间。在需要使用幂等性校验的方法上面加上注解即可实现幂等性。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * @create 2021-01-18 16:40
 * 实现接口幂等性注解
 **/
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface AutoIdempotent {
 
    long expireTime() default 10000;
 
}

2.MD5摘要辅助类

通过传入的参数进行MD5摘要，同时去除需要排除的干扰参数生成唯一的请求ID。

import com.google.gson.Gson;
import com.hhu.consumerdemo.model.User;
import lombok.extern.slf4j.Slf4j;
 
import javax.xml.bind.DatatypeConverter;
import java.security.MessageDigest;
import java.util.*;
 
/**
 * @create 2021-01-14 10:12
 **/
@Slf4j
public class ReqDedupHelper {
 
 
    private Gson gson = new Gson();
    /**
     *
     * @param reqJSON 请求的参数，这里通常是JSON
     * @param excludeKeys 请求参数里面要去除哪些字段再求摘要
     * @return 去除参数的MD5摘要
     */
    public String dedupParamMD5(final String reqJSON, String... excludeKeys) {
        String decreptParam = reqJSON;
 
        TreeMap paramTreeMap = gson.fromJson(decreptParam, TreeMap.class);
        if (excludeKeys!=null) {
            List<String> dedupExcludeKeys = Arrays.asList(excludeKeys);
            if (!dedupExcludeKeys.isEmpty()) {
                for (String dedupExcludeKey : dedupExcludeKeys) {
                    paramTreeMap.remove(dedupExcludeKey);
                }
            }
        }
 
        String paramTreeMapJSON = gson.toJson(paramTreeMap);
        String md5deDupParam = jdkMD5(paramTreeMapJSON);
        log.debug("md5deDupParam = {}, excludeKeys = {} {}", md5deDupParam, Arrays.deepToString(excludeKeys), paramTreeMapJSON);
        return md5deDupParam;
    }
 
    private static String jdkMD5(String src) {
        String res = null;
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            byte[] mdBytes = messageDigest.digest(src.getBytes());
            res = DatatypeConverter.printHexBinary(mdBytes);
        } catch (Exception e) {
            log.error("",e);
        }
        return res;
    }
 
    //测试方法
    public static void main(String[] args) {
        Gson gson = new Gson();
        User user1 = new User("1","2",18);
        Object[] objects = new Object[]{"sss",11,user1};
 
        Map<String, Object> maps = new HashMap<>();
        maps.put("参数1",objects[0]);
        maps.put("参数2",objects[1]);
        maps.put("参数3",objects[2]);
        String json1 = gson.toJson(maps);
        System.out.println(json1);
        TreeMap paramTreeMap = gson.fromJson(json1, TreeMap.class);
        System.out.println(gson.toJson(paramTreeMap));
 
    }
 
}

3.redis辅助Service

生成唯一的请求ID作为token存入redis，同时设置好超时时间，在超时时间内的请求参数将作为重复请求返回，而校验成功插入redis的请求Token将作为首次请求，进行放通。

本文采用的spring-redis版本为2.0以上，使用2.0以下版本的需要主要没有setIfAbsent方法，需要自己实现。

import com.xxx.xxx.utils.ReqDedupHelper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;
 
import java.util.concurrent.TimeUnit;
 
/**
 * @create 2021-01-18 17:44
 **/
@Service
@Slf4j
public class TokenService {
 
    private static final String TOKEN_NAME = "request_token";
 
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
 
 
    public boolean checkRequest(String userId, String methodName, long expireTime, String reqJsonParam, String... excludeKeys){
        final boolean isConsiderDup;
        String dedupMD5 = new ReqDedupHelper().dedupParamMD5(reqJsonParam, excludeKeys);
        String redisKey = "dedup:U="+userId+ "M="+methodName+"P="+dedupMD5;
        log.info("redisKey:{}", redisKey);
 
        long expireAt = System.currentTimeMillis() + expireTime;
        String val = "expireAt@" + expireAt;
 
        // NOTE:直接SETNX不支持带过期时间，所以设置+过期不是原子操作，极端情况下可能设置了就不过期了
        if (stringRedisTemplate.opsForValue().setIfAbsent(redisKey, val)) {
            if (stringRedisTemplate.expire(redisKey, expireTime, TimeUnit.MILLISECONDS)) {
                isConsiderDup =  false;
            } else {
                isConsiderDup =  true;
            }
        } else {
            log.info("加锁失败 failed！！key：{}，value:{}",redisKey,val);
            return true;
        }
        return isConsiderDup;
    }
 
}

4.AOP切面辅助类

aop切面，切住所有带有幂等注解的方法。进行幂等性的操作。

import com.google.gson.Gson;
import com.xxx.xxx.annotation.AutoIdempotent;
import com.xxx.xxx.service.TokenService;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
import java.util.HashMap;
import java.util.Map;
 
/**
 * @author: 
 * @date: 2020-04-28 14:20
 */
@Aspect
@Component
@Slf4j
public class AutoIdempontentHandler {
 
    private Gson gson = new Gson();
 
    private static final String excludeKey = "";
    private static final String methodName = "methodName";
 
    @Autowired
    private TokenService tokenService;
 
    @Pointcut("@annotation(com.xxx.xxx.annotation.AutoIdempotent)")
    public void autoIdempontentHandler() {
    }
 
    @Before("autoIdempontentHandler()")
    public void doBefore() throws Throwable {
        log.info("idempontentHandler..doBefore()");
    }
 
    @Around("autoIdempontentHandler()")
    public Object doAround(ProceedingJoinPoint joinpoint) throws Throwable {
 
        boolean checkres = this.handleRequest(joinpoint);
        if(checkres){
            //重复请求,提示重复 报错
            log.info("重复性请求..");
            throw new Exception();
        }
        return joinpoint.proceed();
    }
 
    private Boolean handleRequest(ProceedingJoinPoint joinpoint) {
        Boolean result = false;
        log.info("========判断是否是重复请求=======");
        MethodSignature methodSignature = (MethodSignature) joinpoint.getSignature();
        //获取自定义注解值
        AutoIdempotent autoIdempotent = methodSignature.getMethod().getDeclaredAnnotation(AutoIdempotent.class);
        long expireTime = autoIdempotent.expireTime();
        // 获取参数名称
        String methodsName = methodSignature.getMethod().getName();
        String[] params = methodSignature.getParameterNames();
        //获取参数值
        Object[] args = joinpoint.getArgs();
        Map<String, Object> reqMaps = new HashMap<>();
        for(int i=0; i<params.length; i++){
            reqMaps.put(params[i], args[i]);
        }
        String reqJSON = gson.toJson(reqMaps);
        result = tokenService.checkRequest("user1", methodsName, expireTime, reqJSON, excludeKey);
        return result;
    }
 
    @AfterReturning(returning = "retVal", pointcut = "autoIdempontentHandler()")
    public void doAfter(Object retVal) throws Throwable {
        log.debug("{}", retVal);
    }
}

5.注解的使用

在需要幂等性的方法上进行注解，同时设置参数保证各个接口的超时时间的不一致性。可以看到在5秒内是无法再次请求方法1的。

import com.xxx.xxx.annotation.AutoIdempotent;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
 
/**
 * @author 
 * @Date: 2020-01-03 14:16
 */
@RestController
public class ConsumerController {
 
 
    @AutoIdempotent(expireTime = 5000)
    @GetMapping("/start/{index}")
    public String setValue( @PathVariable("index")  String index){
        return index + "1";
    }
 
    @GetMapping("/start2/{index}")
    public String setValue2( @PathVariable("index")  String index){
        return index + "2";
    }
 
 
}

六、思考与不足

微服务架构中，幂等操作的特点是指任意多次执行所产生的影响均与一次执行的影响相同。但在实际设计的时候，却简单的进行所有请求进行重复。

然而，重试是降低微服务失败率的重要手段。因为网络波动、系统资源的分配不确定等因素会导致部分请求的失败。而这部分的请求中大部分实际上只需要进行简单的重试就可以保证成功。这才是幂等性真正需要实现的。暂时我并没有更好的解决方法，只能通过短时间的禁用，以及人为的决定何种方法进行幂等性校验来达到目的。欢迎有想法的和我一起探讨交流~

七、参考文献

https://mp.weixin.qq.com/s/xq2ks76hTU0Df-z2EzxyHQ

https://mp.weixin.qq.com/s/GNfIHIIDwncHLfw5TJiC0Q