使用AOP+ExpiringMap+ConcurrentHashMap实现对接口访问次数的限制

什么是ExpiringMap

ExpiringMap 是一个Java库中的数据结构，主要用于实现具有自动过期功能的Map（键值对集合）。在常规的java.util.Map基础上，ExpiringMap 提供了额外的功能，即它可以为存储在其中的键值对设置生命周期（TTL，Time to Live），一旦超过设定的生存时间，相应的键值对会自动从Map中移除。

ExpiringMap的主要特点包括：

1. 过期策略：允许为Map中的条目设置固定或可变的有效期。
2. 线程安全：确保在多线程环境下也能正确地进行读写操作。
3. 高性能与低开销：设计用于高效处理大量并发访问及条目的过期清理。
4. 零依赖：通常不需要外部依赖库即可运行。
5. 最大尺寸限制：可以设置Map的最大容量，当达到上限时可以通过某种策略（如LRU）删除最早过期或者最先插入的条目。
6. 过期监听器：提供过期事件监听机制，当某个条目过期时可以执行特定的回调函数。
7. 延迟输入加载：某些实现可能支持在访问时才计算或加载即将过期的数据。
8. 过期自省：允许查询Map中已经过期但尚未被清理的条目。

通过ExpiringMap，开发者可以在应用程序中方便地创建一个本地缓存，用于存储需要在一段时间后失效的数据，从而避免频繁的数据库访问或者其他昂贵资源的操作。这个数据结构在Web服务限流、缓存管理、临时授权令牌存储等方面尤其有用。

过期策略:

• ExpirationPolicy.CREATED：在每次更新元素时，过期时间同时清零。
• ExpirationPolicy.ACCESSED：在每次访问元素时，过期时间同时清零。

什么是ConcurrentHashMap

ConcurrentHashMap 是 Java 中提供的线程安全的哈希表实现类。它继承自 AbstractMap 类，实现了 ConcurrentMap 接口，是 HashMap 的线程安全版本。

与 HashMap 不同的是，ConcurrentHashMap 在处理并发操作时采用了一种不同的策略来保证线程安全性。它使用了分段锁（Segment）的机制，将整个哈希表分为多个段（Segment），每个段都可以独立地加锁，不同的线程可以同时访问不同的段，从而提高了并发访问的效率。

ConcurrentHashMap 主要提供了以下特点和方法：

1. 线程安全：ConcurrentHashMap 在多线程环境下提供了线程安全的操作。
2. 分段锁：它使用了分段锁的机制，不同的线程可以同时访问不同的段，提高了并发访问的效率。
3. 高性能：相较于传统的线程安全的哈希表实现（如 Hashtable），ConcurrentHashMap 在并发访问下具有更好的性能。
4. 支持高并发读写：ConcurrentHashMap 在读操作上没有锁的限制，多个线程可以同时读取数据，从而提高了并发读取的效率。
5. 支持扩容：ConcurrentHashMap 在容量不足时，可以自动进行扩容操作，以保证哈希表的性能。

以下是 ConcurrentHashMap 的一些常用方法：

• put(key, value)：将指定的键值对添加到哈希表中。
• get(key)：根据指定的键获取对应的值。
• remove(key)：根据指定的键删除对应的键值对。
• containsKey(key)：判断哈希表中是否包含指定的键。
• size()：返回哈希表中键值对的数量。

需要注意的是，虽然 ConcurrentHashMap 提供了线程安全的操作，但在一些特殊情况下，仍然需要额外的同步措施来保证数据的一致性。

实现接口访问次数限制

添加依赖

<!-- AOP依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
    <version>2.1.5.RELEASE</version>
</dependency>
<!-- Map依赖 -->
<dependency>
    <groupId>net.jodah</groupId>
    <artifactId>expiringmap</artifactId>
    <version>0.5.8</version>
</dependency>

自定义注解

package com.sitech.salemng.common.aop;

import java.lang.annotation.*;

/**
 * @author sxh
 * @date 2024/3/14
 */
@Documented
@Target(ElementType.METHOD) // 说明该注解只能放在方法上面
@Retention(RetentionPolicy.RUNTIME)
public @interface LimitRequest {
    long time() default 60*60*1000; // 限制时间 单位：毫秒
    int count() default 5; // 允许请求的次数
}

自定义切面AOP

package com.sitech.salemng.common.aop;

import com.sitech.ijcf.boot.core.error.exception.BusiException;
import net.jodah.expiringmap.ExpirationPolicy;
import net.jodah.expiringmap.ExpiringMap;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

/**
 * @author sxh
 * @date 2024/3/14
 */
@Aspect
@Component
public class LimitRequestAspect {

    private static ConcurrentHashMap<String, ExpiringMap<String, Integer>> book = new ConcurrentHashMap<>();

    // 定义切点
    // 让所有有@LimitRequest注解的方法都执行切面方法
    @Pointcut("@annotation(limitRequest)")
    public void excudeService(LimitRequest limitRequest) {
    }

    @Around("excudeService(limitRequest)")
    public Object doAround(ProceedingJoinPoint pjp, LimitRequest limitRequest) throws Throwable {

        // 获得request对象
        RequestAttributes ra = RequestContextHolder.getRequestAttributes();
        ServletRequestAttributes sra = (ServletRequestAttributes) ra;
        HttpServletRequest request = sra.getRequest();

        // 获取Map对象， 如果没有则返回默认值
        // 第一个参数是key， 第二个参数是默认值
        ExpiringMap<String, Integer> uc = book.getOrDefault(request.getRequestURI(), ExpiringMap.builder().variableExpiration().build());
        Integer uCount = uc.getOrDefault(request.getRemoteAddr(), 0);
        System.out.println("uCount = " + uCount);
        System.out.println("请求IP：" + request.getRemoteAddr());


        if (uCount >= limitRequest.count()) { // 超过次数，不执行目标方法
            System.out.println("请求接口超过次数!!!");
            throw new BusiException("请求接口超过次数！！！");
        } else if (uCount == 0) { // 第一次请求时，设置有效时间
            uc.put(request.getRemoteAddr(), uCount + 1, ExpirationPolicy.CREATED, limitRequest.time(), TimeUnit.MILLISECONDS);
        } else { // 未超过次数， 记录加一
            uc.put(request.getRemoteAddr(), uCount + 1);
        }
        book.put(request.getRequestURI(), uc);
        System.out.println("book" + book);


        // result的值就是被拦截方法的返回值
        Object result = pjp.proceed();

        return result;
    }


}

最后，需要限制哪个接口的访问次数，就在该方法上添加@LimitRequest注解。