本地缓存 + Interceptor 实现访问限流

实现逻辑

1、首先，我们需要敲定哪些功能来实现上述操作。

2、本地缓存可以使用储存键值对的集合来存储，二维数组也可以，不过很考验耐心；

3、正如标题所说，Interceptor 拦截器，实现限流的不二人选，当然还得配上自定义的注解来自定义限流的时间和访问请求（在xx时间内最大的请求为xx）

4、（额外添加，可要可不要）正如自定义注解来定义限流时间与请求数量，那么是不是也可以搞一个功能来实现账号隔离呢？Token 表示，我站起来了，没错，我们可以争对不同的用户实现非同步的限流😀

实现步骤

1、话不多说，直接上依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.5.4</version>
</dependency>

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
    <groupId>com.auth0</groupId>
    <artifactId>java-jwt</artifactId>
    <version>3.8.1</version>
</dependency>

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

2、自定义注解 * 2

2.1、自定义验证 Token 注解

// 表示该注解可以标志的地方
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface TokenIsHave {

    // 默认需要携带 token
    boolean isHave() default true;

}

2.2、自定义限流注解

@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RequestLimit {

    /**
     * 在一段时间内的最大请求数
     * @return
     */
    int maxRequest() default 10;

    /**
     * 设置时间段，默认单位（分钟）
     * @return
     */
    int maxSecond() default 1;

}

3、 注解写好了，当然是要标志在需要限流的方法上面（Controller）

@RestController
public class LimitController {

    @GetMapping("/testLimit")
    // 自定义请求的时间段和最大请求数
    @RequestLimit(maxRequest = 2,maxSecond = 1)
    // 结合后续拦截器判断该请求需要token且token格式必须正确
    @TokenIsHave
    public String limit(){
        return "访问成功";
    }
    
    // 此处不标记 @TokenIsHave 注解是为了获取Token，不然程序都没有Token，一个方法都访问不到了
    @GetMapping("/getToken")
    public String getToken(@RequestParam("username") String username){
        // TokenUtils  自定义Token工具包
        return TokenUtil.getToken(username);
    }

}

4、那么问题来了，TokenUtil该如何定义呢？

public class TokenUtil {

    // 设置Token过期时间 3600分钟
    private static final long EXPIRE_TIME = 3600 * 60 * 1000;

    // 设置Token加密的钥匙
    private static final String TOKEN_KEY = "token_key";

    /**
     * 生成token
     * @param username
     * @return
     */
    public static String getToken(String username){
        // 先将时间格式化
        Date time = new Date(System.currentTimeMillis() + EXPIRE_TIME);
        // 使用 Algorithm.HMAC256 对 Token 进行加密
        Algorithm hmac384 = Algorithm.HMAC256(TOKEN_KEY);

        return JWT.create()
                // 在token内添加参数
                .withAudience(username)
                // 设置过期时间
                .withExpiresAt(time)
                // 加密
                .sign(hmac384);
    }


    /**
     * 获取封装在token内的username
     * @return
     */
    public static String getUserName(String token){
        try {
            // 因为我们封装参数是通过 withAudience 方法，所以我们可以直接获取
            // List<String> audience = JWT.decode(token).getAudience();
            // 因为我们得到的是一个 List 集合，且我们只封装了一个参数，当然封装多个按照封装的顺序进行获取
            String username = JWT.decode(token).getAudience().get(0);
            return username;
        }catch (Exception e){
            return null;
        }
    }


    /**
     * 验证token是否正确
     * @param token
     * @return
     */
    public static boolean requireToken(String token){
        try {
            // 国际惯例，锁要配套才可以解开，所以加载密钥
            Algorithm hmac384 = Algorithm.HMAC256(TOKEN_KEY);
            JWTVerifier verifier = JWT.require(hmac384).build();
            verifier.verify(token);
            return true;
        }catch (Exception e){
            return false;
        }
    }


}

5、模拟本地缓存

因为我们是使用本地缓存Map模拟Redis进行数据的存储及过期时间，于是本地缓存工具类出来了

public class SimulationRedis {

    // 模拟访问数（我们第一次访问时添加参数并默认为1）
    private static Integer requestCount = 1;

    // 模拟内存
    private static Map map = new HashMap<>();


    /**
     * 模拟内存，内部使用 map 集合存储数据
     * true、false 表示是否添加成功
     * @param key
     * @return
     */
    public static boolean setRequestCount(String key, Integer maxSecond){

        /**
         * 如果不存在该值，默认添加
         */
        if (map.get(key) == null) {
            map.put(key,requestCount);
            map.put(key+"_time",System.currentTimeMillis() + maxSecond*60000);
            return true;
        }

        return false;
    }

    /**
     * 判断请求是否可以继续访问
     * @param key
     * @return
     */
    public static boolean isContinue(
        String key, 
        Integer maxRequest, 
        Integer maxSecond){

        if (map.isEmpty()){
            return false;
        }

        if (isTimeOut(key, maxSecond)){
            // 判断请求数是否超过定义的最大请求数
            if (!(++requestCount > maxRequest)){
                map.put(key,requestCount);
                return true;
            }
            return false;
        }

        return true;
    }

    /**
     * 模拟判断请求访问的时间段是否需要更新
     * @return
     */
    public static boolean isTimeOut(String key, Integer maxSecond){
        long nowTime = System.currentTimeMillis();
        // 如果访问请求时间已经超过我们定义的时间，对缓存内的时间与请求数进行更新
        // Long.valueOf(map.get(key+"_time").toString()) 避免向下转型造成的精度丢失
        if (nowTime >= Long.valueOf(map.get(key+"_time").toString())){
            resetMap(key, maxSecond);
        }
        
        return true;
    }


    /**
     * 重置时间与请求
     * @param key
     * @param maxSecond
     * @return
     */
    public static boolean resetMap(String key, Integer maxSecond){
        try {
            requestCount = 0;
            map.put(key, requestCount);
            map.put(key+"_time", System.currentTimeMillis() + maxSecond*60000);
            return true;
        }catch (Exception e){
            return false;
        }
    }
    
}

6、定义拦截器实现限流和Token验签

6.1 token 验签拦截器

// 实现HandlerInterceptor接口
public class TokenSignatureInterceptor implements HandlerInterceptor {

    /**
     * 请求进入 controller中方法 前执行
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(
        HttpServletRequest request, 
        HttpServletResponse response, 
        // handler 为访问的方法的全路径名
        Object handler) throws Exception {

        // 判断请求的方式是否为 options
        if ("OPTIONS".equals(request.getMethod().toLowerCase())){
            return true;
        }

        /**
         * 表示该请求不是映射到方法
         */
        if (!(handler instanceof HandlerMethod)){
            return true;
        }
        
        // HandlerMethod 封装了很多属性，类似于方法上方标注的 注解、、、
        HandlerMethod methodHandle = (HandlerMethod) handler;
        // 获取方法
        Method method = methodHandle.getMethod();
        // 从请求头获取 token （前端请求时默认将token参数加入）
        // 如果Controller层定义GetMapping("/login")
        // 访问时需要 localhost:自定义端口号/login?token=、、、
        String token = request.getParameter("token");
        
        // 获取方法上方标注的注解
        TokenIsHave tokenIsHave = method.isAnnotationPresent(TokenIsHave.class)；
        
        // 判断方法头是否标注了该注解
        if (tokenIsHava != null){
            
            // 获取 TokenIsHave 内的参数判断该方法是否需要 Token 认证
            if (!tokenIsHave.isHave()){
                return true;
            }

            // 如果前端传来的 Token 为空，则请求不可通过
            // StringUtils.hasText 验证 String 是否为空
            if (!StringUtils.hasText(token)){
                return false;
            }

            // 校检token，如果返回false，表示token错误，请求不可通过
            if (!TokenUtil.requireToken(token)){
                return false;
            }

            return true;
        }

        
        // 如果没有标注该注解，直接发行，表示不需要token验证
        return true;
    }


    /**
     * 页面跳转后执行
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    }

    /**
     * 执行完 Controller 未跳转至视图之前
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
    }


}

6.2 流量监控拦截器

public class RequestLimitInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(
        HttpServletRequest request, 
        HttpServletResponse response, 
        Object handler) throws Exception {

        if ("OPTIONS".equals(request.getMethod().toUpperCase())){
            return true;
        }

        if (!(handler instanceof HandlerMethod)){
            return true;
        }

        // 获取注解
        HandlerMethod methodHandle = (HandlerMethod) handler;
        RequestLimit requestLimit= 
            methodHandle.getMethod().getAnnotation(RequestLimit.class);
            
        if (requestLimit == null){
            return true;
        }

        // 获取token内储存的username
        String token = request.getParameter("token");
        
        // 获取存储在token内的userName将其作为缓存内的key值
        String userName = TokenUtil.getUserName(token);

        // 获取注解内容，时间和最大请求数
        // 最大请求数
        int maxRequest = requestLimit.maxRequest();
        // 最大时间段
        int maxSecond = requestLimit.maxSecond();
        
        // 通过模拟缓存判断该请求是否可以通过
        /**
         * 如果返回 false 表示之前已存在该key
         */
        if (SimulationRedis.setRequestCount(userName, maxSecond)){
            if (!SimulationRedis.isContinue(userName, maxRequest, maxSecond)){
                System.out.println("访问过于频繁，请稍后再试");
                return false;
            }
            return true;
        }

        // 如果存在该 key，可以直接进行判断
        if (!SimulationRedis.isContinue(userName, maxRequest, maxSecond)){
            return false;
        }

        return true;
    }
    
}

7、将拦截器放入SpringMVC中

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry
            // 添加拦截器
            .addInterceptor(new TokenSignatureInterceptor())
            // 添加拦截器的作用范围
            .addPathPatterns("/**");
        registry
            .addInterceptor(new RequestLimitInterceptor())
            .addPathPatterns("/**");
    }
}