SpringBoot處理接口冪等性的兩種方法詳解

更新時間：2022年06月21日 08:32:04 作者：_江南一點雨

接口冪等性處理算是一個非常常見的需求了，我們在很多項目中其實都會遇到。本文為大家總結了兩個處理接口冪等性的兩種常見方案，需要的可以參考一下

1. 接口冪等性實現方案梳理

其實接口冪等性的實現方案還是蠻多的，我這里和小伙伴們分享兩種比較常見的方案。

1.1 基于 Token

基于 Token 這種方案的實現思路很簡單，整個流程分兩步：

客戶端發(fā)送請求，從服務端獲取一個 Token 令牌，每次請求獲取到的都是一個全新的令牌。
客戶端發(fā)送請求的時候，攜帶上第一步的令牌，處理請求之前，先校驗令牌是否存在，當請求處理成功，就把令牌刪除掉。

大致的思路就是上面這樣，當然具體的實現則會復雜很多，有很多細節(jié)需要注意

1.2 基于請求參數校驗

最近在 TienChin 項目中使用的是另外一種方案，這種方案是基于請求參數來判斷的，如果在短時間內，同一個接口接收到的請求參數相同，那么就認為這是重復的請求，拒絕處理，大致上就是這么個思路。

相比于第一種方案，第二種方案相對來說省事一些，因為只有一次請求，不需要專門去服務端拿令牌。在高并發(fā)環(huán)境下這種方案優(yōu)勢比較明顯。

所以今天我就來和大家聊聊第二種方案的實現，后面在 TienChin 項目視頻中也會和大家細講。

2. 基于請求參數的校驗

首先我們新建一個 Spring Boot 項目，引入 Web 和 Redis 依賴，新建完成后，先來配置一下 Redis 的基本信息，如下：

spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=123

為了后續(xù) Redis 操作方便，我們再來對 Redis 進行一個簡單封裝，如下：

@Component
public class RedisCache {
    @Autowired
    public RedisTemplate redisTemplate;
    public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }
    public <T> T getCacheObject(final String key) {
        ValueOperations<String, T> operation = redisTemplate.opsForValue();
        return operation.get(key);
    }
}

這個比較簡單，一個存數據，一個讀數據。

接下來我們自定義一個注解，在需要進行冪等性處理的接口上，添加該注解即可，將來這個接口就會自動的進行冪等性處理。

@Inherited
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RepeatSubmit {
    /**
     * 間隔時間(ms)，小于此時間視為重復提交
     */
    public int interval() default 5000;

    /**
     * 提示消息
     */
    public String message() default "不允許重復提交，請稍候再試";
}

這個注解我們通過攔截器來進行解析，解析代碼如下：

public abstract class RepeatSubmitInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            Method method = handlerMethod.getMethod();
            RepeatSubmit annotation = method.getAnnotation(RepeatSubmit.class);
            if (annotation != null) {
                if (this.isRepeatSubmit(request, annotation)) {
                    Map<String, Object> map = new HashMap<>();
                    map.put("status", 500);
                    map.put("msg", annotation.message());
                    response.setContentType("application/json;charset=utf-8");
                    response.getWriter().write(new ObjectMapper().writeValueAsString(map));
                    return false;
                }
            }
            return true;
        } else {
            return true;
        }
    }

    /**
     * 驗證是否重復提交由子類實現具體的防重復提交的規(guī)則
     *
     * @param request
     * @return
     * @throws Exception
     */
    public abstract boolean isRepeatSubmit(HttpServletRequest request, RepeatSubmit annotation);
}

這個攔截器是一個抽象類，將接口方法攔截下來，然后找到接口上的 @RepeatSubmit 注解，調用 isRepeatSubmit 方法去判斷是否是重復提交的數據，該方法在這里是一個抽象方法，我們需要再定義一個類繼承自這個抽象類，在新的子類中，可以有不同的冪等性判斷邏輯，這里我們就是根據 URL 地址+參數來判斷冪等性條件是否滿足：

@Component
public class SameUrlDataInterceptor extends RepeatSubmitInterceptor {
    public final String REPEAT_PARAMS = "repeatParams";

    public final String REPEAT_TIME = "repeatTime";
    public final static String REPEAT_SUBMIT_KEY = "REPEAT_SUBMIT_KEY";

    private String header = "Authorization";

    @Autowired
    private RedisCache redisCache;

    @SuppressWarnings("unchecked")
    @Override
    public boolean isRepeatSubmit(HttpServletRequest request, RepeatSubmit annotation) {
        String nowParams = "";
        if (request instanceof RepeatedlyRequestWrapper) {
            RepeatedlyRequestWrapper repeatedlyRequest = (RepeatedlyRequestWrapper) request;
            try {
                nowParams = repeatedlyRequest.getReader().readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        // body參數為空，獲取Parameter的數據
        if (StringUtils.isEmpty(nowParams)) {
            try {
                nowParams = new ObjectMapper().writeValueAsString(request.getParameterMap());
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        }
        Map<String, Object> nowDataMap = new HashMap<String, Object>();
        nowDataMap.put(REPEAT_PARAMS, nowParams);
        nowDataMap.put(REPEAT_TIME, System.currentTimeMillis());

        // 請求地址（作為存放cache的key值）
        String url = request.getRequestURI();

        // 唯一值（沒有消息頭則使用請求地址）
        String submitKey = request.getHeader(header);

        // 唯一標識（指定key + url + 消息頭）
        String cacheRepeatKey = REPEAT_SUBMIT_KEY + url + submitKey;

        Object sessionObj = redisCache.getCacheObject(cacheRepeatKey);
        if (sessionObj != null) {
            Map<String, Object> sessionMap = (Map<String, Object>) sessionObj;
            if (compareParams(nowDataMap, sessionMap) && compareTime(nowDataMap, sessionMap, annotation.interval())) {
                return true;
            }
        }
        redisCache.setCacheObject(cacheRepeatKey, nowDataMap, annotation.interval(), TimeUnit.MILLISECONDS);
        return false;
    }

    /**
     * 判斷參數是否相同
     */
    private boolean compareParams(Map<String, Object> nowMap, Map<String, Object> preMap) {
        String nowParams = (String) nowMap.get(REPEAT_PARAMS);
        String preParams = (String) preMap.get(REPEAT_PARAMS);
        return nowParams.equals(preParams);
    }

    /**
     * 判斷兩次間隔時間
     */
    private boolean compareTime(Map<String, Object> nowMap, Map<String, Object> preMap, int interval) {
        long time1 = (Long) nowMap.get(REPEAT_TIME);
        long time2 = (Long) preMap.get(REPEAT_TIME);
        if ((time1 - time2) < interval) {
            return true;
        }
        return false;
    }
}

我們來看下具體的實現邏輯：

首先判斷當前的請求對象是不是 RepeatedlyRequestWrapper，如果是，說明當前的請求參數是 JSON，那么就通過 IO 流將參數讀取出來，這塊小伙伴們要結合上篇文章共同來理解，否則可能會覺得云里霧里的，傳送門JSON 數據讀一次就沒了，怎么辦？。
如果在第一步中，并沒有拿到參數，那么說明參數可能并不是 JSON 格式，而是 key-value 格式，那么就以 key-value 的方式讀取出來參數，并將之轉為一個 JSON 字符串。
接下來構造一個 Map，將前面讀取到的參數和當前時間存入到 Map 中。
接下來構造存到 Redis 中的數據的 key，這個 key 由固定前綴 + 請求 URL 地址 + 請求頭的認證令牌組成，這塊請求頭的令牌還是非常重要需要有的，只有這樣才能區(qū)分出來當前用戶提交的數據（如果是 RESTful 風格的接口，那么為了區(qū)分，也可以將接口的請求方法作為參數拼接到 key 中）。
接下來就去 Redis 中獲取數據，獲取到之后，分別去比較參數是否相同以及時間是否過期。
如果判斷都沒問題，返回 true，表示這個請求重復了。
否則返回說明這是用戶對這個接口第一次提交數據或者是已經過了時間窗口了，那么就把參數字符串重新緩存到 Redis 中，并返回 false，表示請求沒問題。

好啦，做完這一切，最后我們再來配置一下攔截器即可：

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    RepeatSubmitInterceptor repeatSubmitInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(repeatSubmitInterceptor)
                .addPathPatterns("/**");
    }
}

如此，我們的接口冪等性就處理好啦～在需要的時候，就可以直接在接口上使用啦：

@RestController
public class HelloController {

    @PostMapping("/hello")
    @RepeatSubmit(interval = 100000)
    public String hello(@RequestBody String msg) {
        System.out.println("msg = " + msg);
        return "hello";
    }
}

到此這篇關于SpringBoot處理接口冪等性的兩種方法詳解的文章就介紹到這了,更多相關SpringBoot處理接口冪等性內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: