基础版

  1. import org.springframework.web.bind.annotation.RequestMapping;
  2. import org.springframework.web.bind.annotation.RestController;
  4. import java.util.HashMap;
  5. import java.util.Map;
  7. /**
  8.  * 普通 Map 版本
  9.  */
  10. @RequestMapping("/user")
  11. @RestController
  12. public class UserController3 {
  14.     // 缓存 ID 集合
  15.     private Map<String, Integer> reqCache = new HashMap<>();
  17.     @RequestMapping("/add")
  18.     public String addUser(String id) {
  19.         // 非空判断(忽略)...
  20.         synchronized (this.getClass()) {
  21.             // 重复请求判断
  22.             if (reqCache.containsKey(id)) {
  23.                 // 重复请求
  24.                 System.out.println("请勿重复提交！！！" + id);
  25.                 return "执行失败";
  26.             }
  27.             // 存储请求 ID
  28.             reqCache.put(id, 1);
  29.         }
  30.         // 业务代码...
  31.         System.out.println("添加用户ID:" + id);
  32.         return "执行成功！";
  33.     }
  34. }

存在的问题：此实现方式有一个致命的问题，因为 HashMap 是无限增长的，因此它会占用越来越多的内存，并且随着 HashMap 数量的增加查找的速度也会降低，所以我们需要实现一个可以自动“清除”过期数据的实现方案。

优化版——固定大小的数组

此版本解决了 HashMap 无限增长的问题，它使用数组加下标计数器（reqCacheCounter）的方式，实现了固定数组的循环存储。
当数组存储到最后一位时，将数组的存储下标设置 0，再从头开始存储数据，实现代码如下：

  1. import org.springframework.web.bind.annotation.RequestMapping;
  2. import org.springframework.web.bind.annotation.RestController;
  4. import java.util.Arrays;
  6. @RequestMapping("/user")
  7. @RestController
  8. public class UserController {
  10.     private static String[] reqCache = new String[100]; // 请求 ID 存储集合
  11.     private static Integer reqCacheCounter = 0; // 请求计数器（指示 ID 存储的位置）
  13.     @RequestMapping("/add")
  14.     public String addUser(String id) {
  15.         // 非空判断(忽略)...
  16.         synchronized (this.getClass()) {
  17.             // 重复请求判断
  18.             if (Arrays.asList(reqCache).contains(id)) {
  19.                 // 重复请求
  20.                 System.out.println("请勿重复提交！！！" + id);
  21.                 return "执行失败";
  22.             }
  23.             // 记录请求 ID
  24.             if (reqCacheCounter >= reqCache.length) reqCacheCounter = 0; // 重置计数器
  25.             reqCache[reqCacheCounter] = id; // 将 ID 保存到缓存
  26.             reqCacheCounter++; // 下标往后移一位
  27.         }
  28.         // 业务代码...
  29.         System.out.println("添加用户ID:" + id);
  30.         return "执行成功！";
  31.     }
  32. }

扩展版——双重检测锁(DCL)

上一种实现方法将判断和添加业务，都放入 synchronized 中进行加锁操作，这样显然性能不是很高，于是我们可以使用单例中著名的 DCL（Double Checked Locking，双重检测锁）来优化代码的执行效率，实现代码如下：

  1. import org.springframework.web.bind.annotation.RequestMapping;
  2. import org.springframework.web.bind.annotation.RestController;
  4. import java.util.Arrays;
  6. @RequestMapping("/user")
  7. @RestController
  8. public class UserController {
  10.     private static String[] reqCache = new String[100]; // 请求 ID 存储集合
  11.     private static Integer reqCacheCounter = 0; // 请求计数器（指示 ID 存储的位置）
  13.     @RequestMapping("/add")
  14.     public String addUser(String id) {
  15.         // 非空判断(忽略)...
  16.         // 重复请求判断
  17.         if (Arrays.asList(reqCache).contains(id)) {
  18.             // 重复请求
  19.             System.out.println("请勿重复提交！！！" + id);
  20.             return "执行失败";
  21.         }
  22.         synchronized (this.getClass()) {
  23.             // 双重检查锁（DCL,double checked locking）提高程序的执行效率
  24.             if (Arrays.asList(reqCache).contains(id)) {
  25.                 // 重复请求
  26.                 System.out.println("请勿重复提交！！！" + id);
  27.                 return "执行失败";
  28.             }
  29.             // 记录请求 ID
  30.             if (reqCacheCounter >= reqCache.length) reqCacheCounter = 0; // 重置计数器
  31.             reqCache[reqCacheCounter] = id; // 将 ID 保存到缓存
  32.             reqCacheCounter++; // 下标往后移一位
  33.         }
  34.         // 业务代码...
  35.         System.out.println("添加用户ID:" + id);
  36.         return "执行成功！";
  37.     }
  38. }

完善版——LRUMap

上面的代码基本已经实现了重复数据的拦截，但显然不够简洁和优雅，比如下标计数器的声明和业务处理等，但值得庆幸的是 Apache 为我们提供了一个 commons-collections 的框架，里面有一个非常好用的数据结构 LRUMap 可以保存指定数量的固定的数据，并且它会按照 LRU 算法，帮你清除最不常用的数据。

小贴士：LRU 是 Least Recently Used 的缩写，即最近最少使用，是一种常用的数据淘汰算法，选择最近最久未使用的数据予以淘汰。

首先，我们先来添加 Apache commons collections 的引用：

  1.  <!-- 集合工具类 apache commons collections -->
  2. <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
  3. <dependency>
  4.   <groupId>org.apache.commons</groupId>
  5.   <artifactId>commons-collections4</artifactId>
  6.   <version>4.4</version>
  7. </dependency>
  1. import org.apache.commons.collections4.map.LRUMap;
  2. import org.springframework.web.bind.annotation.RequestMapping;
  3. import org.springframework.web.bind.annotation.RestController;
  5. @RequestMapping("/user")
  6. @RestController
  7. public class UserController {
  9.     // 最大容量 100 个，根据 LRU 算法淘汰数据的 Map 集合
  10.     private LRUMap<String, Integer> reqCache = new LRUMap<>(100);
  12.     @RequestMapping("/add")
  13.     public String addUser(String id) {
  14.         // 非空判断(忽略)...
  15.         synchronized (this.getClass()) {
  16.             // 重复请求判断
  17.             if (reqCache.containsKey(id)) {
  18.                 // 重复请求
  19.                 System.out.println("请勿重复提交！！！" + id);
  20.                 return "执行失败";
  21.             }
  22.             // 存储请求 ID
  23.             reqCache.put(id, 1);
  24.         }
  25.         // 业务代码...
  26.         System.out.println("添加用户ID:" + id);
  27.         return "执行成功！";
  28.     }
  29. }

最终版——封装

以上都是方法级别的实现方案，然而在实际的业务中，我们可能有很多的方法都需要防重，那么接下来我们就来封装一个公共的方法，以供所有类使用：

  1. import org.apache.commons.collections4.map.LRUMap;
  3. /**
  4.  * 幂等性判断
  5.  */
  6. public class IdempotentUtils {
  8.     // 根据 LRU(Least Recently Used，最近最少使用)算法淘汰数据的 Map 集合，最大容量 100 个
  9.     private static LRUMap<String, Integer> reqCache = new LRUMap<>(100);
  11.     /**
  12.      * 幂等性判断
  13.      * @return
  14.      */
  15.     public static boolean judge(String id, Object lockClass) {
  16.         synchronized (lockClass) {
  17.             // 重复请求判断
  18.             if (reqCache.containsKey(id)) {
  19.                 // 重复请求
  20.                 System.out.println("请勿重复提交！！！" + id);
  21.                 return false;
  22.             }
  23.             // 非重复请求，存储请求 ID
  24.             reqCache.put(id, 1);
  25.         }
  26.         return true;
  27.     }
  28. }
  1. import com.example.idempote.util.IdempotentUtils;
  2. import org.springframework.web.bind.annotation.RequestMapping;
  3. import org.springframework.web.bind.annotation.RestController;
  5. @RequestMapping("/user")
  6. @RestController
  7. public class UserController4 {
  8.     @RequestMapping("/add")
  9.     public String addUser(String id) {
  10.         // 非空判断(忽略)...
  11.         // -------------- 幂等性调用（开始） --------------
  12.         if (!IdempotentUtils.judge(id, this.getClass())) {
  13.             return "执行失败";
  14.         }
  15.         // -------------- 幂等性调用（结束） --------------
  16.         // 业务代码...
  17.         System.out.println("添加用户ID:" + id);
  18.         return "执行成功！";
  19.     }
  20. }

参考文章
https://juejin.im/post/6850418120985837575#heading-3