SpringBoot基于过滤器和内存如何实现重复请求拦截功能

这篇文章主要介绍了SpringBoot基于过滤器和内存如何实现重复请求拦截功能的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇springBoot基于过滤器和内存如何实现重复请求拦截功能文章都会有所收获，下面我们一起来看看吧。

对于一些请求服务器的接口，可能存在重复发起请求，如果是查询操作倒是并无大碍，但是如果涉及到写入操作，一旦重复，可能对业务逻辑造成很严重的后果，例如交易的接口如果重复请求可能会重复下单。

这里我们使用过滤器的方式对进入服务器的请求进行过滤操作，实现对相同客户端请求同一个接口的过滤。

 @Slf4j @Component public class IRequestFilter extends OncePerRequestFilter {     @Resource     private FastMap fastMap;      @Override     protected void doFilterInternal(httpservletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {         ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();         String address = attributes != null ? attributes.getRequest().getRemoteAddr() : UUID.randomUUID().toString();         if (Objects.equals(request.getMethod(), "GET")) {             StringBuilder str = new StringBuilder();             str.append(request.getRequestURI()).append("|")                     .append(request.getRemotePort()).append("|")                     .append(request.getLocalName()).append("|")                     .append(address);             String hex = DigestUtil.md5Hex(new String(str));             log.info("请求的MD5值为:{}", hex);             if (fastMap.containsKey(hex)) {                 throw new IllegalStateException("请求重复，请稍后重试!");             }             fastMap.put(hex, 10 * 1000L);             fastMap.expired(hex, 10 * 1000L, (key, val) -> System.out.println("map:" + fastMap + ",删除的key:" + key + ",线程名:" + Thread.currentThread().getName()));         }         log.info("请求的 address:{}", address);         chain.doFilter(request, response);     } }

通过继承Spring中的OncePerRequestFilter过滤器，确保在一次请求中只通过一次filter，而不需要重复的执行

通过获取请求体中的数据，计算出MD5值，存储在基于内存实现的FastMap中，FastMap的键为MD5值，value表示多久以内不能重复请求，这里配置的是10s内不能重复请求。通过调用FastMap的expired()方法，设置该请求的过期时间和过期时的回调函数

 @Component public class FastMap {          private final TreeMap<Long, List<String>> expireKeysMap = new TreeMap<>();          private final Map<String, Long> keyExpireMap = new ConcurrentHashMap<>();          private final HashMap<String, ExpireCallback<String, Long>> keyExpireCallbackMap = new HashMap<>();     private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();          private final Lock dataWriteLock = readWriteLock.writeLock();          private final Lock dataReadLock = readWriteLock.readLock();     private final ReentrantReadWriteLock expireKeysReadWriteLock = new ReentrantReadWriteLock();          private final Lock expireKeysWriteLock = expireKeysReadWriteLock.writeLock();          private final Lock expireKeysReadLock = expireKeysReadWriteLock.readLock();          private volatile ScheduledExecutorService scheduledExecutorService;          private static final int ONE_MILLION = 100_0000;          public FastMap() {         this.init();     }          private void init() {         // 双重校验构造一个单例的scheduledExecutorService         if (scheduledExecutorService == null) {             synchronized (FastMap.class) {                 if (scheduledExecutorService == null) {                     // 启用定时器，定时删除过期key,1秒后启动，定时1秒, 因为时间间隔计算基于nanoTime,比timer.schedule更靠谱                     scheduledExecutorService = new ScheduledThreadPoolExecutor(1, runnable -> {                         Thread thread = new Thread(runnable, "expireTask-" + UUID.randomUUID());                         thread.setDaemon(true);                         return thread;                     });                 }             }         }     }     public boolean containsKey(Object key) {         dataReadLock.lock();         try {             return this.keyExpireMap.containsKey(key);         } finally {             dataReadLock.unlock();         }     }     public Long put(String key, Long value) {         dataWriteLock.lock();         try {             return this.keyExpireMap.put(key, value);         } finally {             dataWriteLock.unlock();         }     }     public Long remove(Object key) {         dataWriteLock.lock();         try {             return this.keyExpireMap.remove(key);         } finally {             dataWriteLock.unlock();         }     }     public Long expired(String key, Long ms, ExpireCallback<String, Long> callback) {         // 对过期数据写上锁         expireKeysWriteLock.lock();         try {             // 使用nanoTime消除系统时间的影响，转成毫秒存储降低timeKey数量,过期时间精确到毫秒级别             Long expireTime = (System.nanoTime() / ONE_MILLION + ms);             this.keyExpireMap.put(key, expireTime);             List<String> keys = this.expireKeysMap.get(expireTime);             if (keys == null) {                 keys = new ArrayList<>();                 keys.add(key);                 this.expireKeysMap.put(expireTime, keys);             } else {                 keys.add(key);             }             if (callback != null) {                 // 设置的过期回调函数                 this.keyExpireCallbackMap.put(key, callback);             }             // 使用延时服务调用清理key的函数，可以及时调用过期回调函数             // 同key重复调用，会产生多个延时任务，就是多次调用清理函数，但是不会产生多次回调，因为回调取决于过期时间和回调函数）             scheduledExecutorService.schedule(this::clearExpireData, ms, TimeUnit.MILLISECONDS);              //假定系统时间不修改前提下的过期时间             return System.currentTimeMillis() + ms;         } finally {             expireKeysWriteLock.unlock();         }     }          private void clearExpireData() {         // 查找过期key         Long curTimestamp = System.nanoTime() / ONE_MILLION;         Map<Long, List<String>> expiredKeysMap = new LinkedHashMap<>();         expireKeysReadLock.lock();         try {             // 过期时间在【从前至此刻】区间内的都为过期的key             // headMap():获取从头到 curTimestamp 元素的集合：不包含 curTimestamp             SortedMap<Long, List<String>> sortedMap = this.expireKeysMap.headMap(curTimestamp, true);             expiredKeysMap.putAll(sortedMap);         } finally {             expireKeysReadLock.unlock();         }          for (Map.Entry<Long, List<String>> entry : expiredKeysMap.entrySet()) {             for (String key : entry.getValue()) {                 // 删除数据                 Long val = this.remove(key);                 // 首次调用删除（val!=null，前提：val存储值都不为null）                 if (val != null) {                     // 如果存在过期回调函数，则执行回调                     ExpireCallback<String, Long> callback;                     expireKeysReadLock.lock();                     try {                         callback = this.keyExpireCallbackMap.get(key);                     } finally {                         expireKeysReadLock.unlock();                     }                     if (callback != null) {                         // 回调函数创建新线程调用，防止因为耗时太久影响线程池的清理工作                         // 这里为什么不用线程池调用，因为ScheduledThreadPoolExecutor线程池仅支持核心线程数设置，不支持非核心线程的添加                         // 核心线程数用一个就可以完成清理工作，添加额外的核心线程数浪费了                         new Thread(() -> callback.onExpire(key, val), "callback-thread-" + UUID.randomUUID()).start();                     }                 }                 this.keyExpireCallbackMap.remove(key);             }             this.expireKeysMap.remove(entry.geTKEy());         }     } }

FastMap通过ScheduledExecutorService接口实现定时线程任务的方式对请求处于过期时间的自动删除。

关于“SpringBoot基于过滤器和内存如何实现重复请求拦截功能”这篇文章的内容就介绍到这里，感谢各位的阅读！相信大家对“SpringBoot基于过滤器和内存如何实现重复请求拦截功能”知识都有一定的了解，大家如果还想学习更多知识，欢迎关注编程网精选频道。