devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot自定义接口限流注解(拦截器实现，AOP实现)_springboot aop限流器如何放行部分接口

作者：不正经 | 2024-04-08 01:48:32

赞

踩

springboot aop限流器如何放行部分接口

  1. 拦截器版

实现思路
1.通过拦截器，读取方法上的注解
2.累计请求数量，进行限流
1.1 定义注解RequestLimit
  1. package com.zhf.model.annotation;
  2.  
  3. import java.lang.annotation.*;
  4. import java.util.concurrent.TimeUnit;
  5.  
  6. @Documented
  7. @Inherited
  8. @Target({ElementType.METHOD,ElementType.TYPE})
  9. @Retention(RetentionPolicy.RUNTIME)
  10. public @interface RequestLimit {
  11.  
  12.     /**
  13.      * 限流的时间单位
  14.      */
  15.     TimeUnit timeUnit() default TimeUnit.SECONDS;
  16.  
  17.     /**
  18.      * 限流的时长
  19.      */
  20.     int limit() default 1;
  21.  
  22.     /**
  23.      * 最大限流量
  24.      * @return
  25.      */
  26.     int maxCount() default 1;
  27. }
1.2 定义拦截器RequestLimitInterceptor
  1. package com.zhf.model.interceptor;
  2.  
  3. import com.alibaba.fastjson.JSONObject;
  4. import com.zhf.model.annotation.RequestLimit;
  5. import org.springframework.stereotype.Component;
  6. import org.springframework.web.method.HandlerMethod;
  7. import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
  8. import javax.servlet.http.HttpServletRequest;
  9. import javax.servlet.http.HttpServletResponse;
  10. import java.io.IOException;
  11. import java.io.PrintWriter;
  12. import java.lang.annotation.Annotation;
  13. import java.lang.reflect.Method;
  14. import java.util.HashMap;
  15. import java.util.Map;
  16. import java.util.Timer;
  17. import java.util.TimerTask;
  18. import java.util.concurrent.TimeUnit;
  19.  
  20. @Component
  21. public class RequestLimitInterceptor extends HandlerInterceptorAdapter {
  22.  
  23.     /**
  24.      * 限流Map,懒得搭建Redis，暂时放在Map里面，然后通过定时任务实现限流
  25.      * 实际业务中可以放在Redis，利用过期时间限流
  26.      */
  27.     private final Map<String,Integer> map = new HashMap<>();
  28.  
  29.     /**
  30.      * 拦截请求执行的方法
  31.      * @param request
  32.      * @param response
  33.      * @param handler
  34.      * @return
  35.      * @throws Exception
  36.      */
  37.     @Override
  38.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  39.         System.out.println("限流的拦截器！");
  40.         //判断处理类是否为HandlerMethod
  41.         if(handler.getClass().isAssignableFrom(HandlerMethod.class)){
  42.             //进行强制转换
  43.             HandlerMethod handlerMethod = (HandlerMethod)handler;
  44.             //获取拦截的方法
  45.             Method method = handlerMethod.getMethod();
  46.             //获取方法上的注解对象，看是否被RequestLimit修饰
  47.             RequestLimit limiter = getTagAnnotation(method, RequestLimit.class);
  48.             //判断是否限流
  49.             if(null != limiter){
  50.                 if(isLimit(request,limiter)){
  51.                     responseOut(response,limiter.maxCount());
  52.                     return false;
  53.                 }
  54.             }
  55.         }
  56.         return super.preHandle(request, response, handler);
  57.     }
  58.  
  59.     /**
  60.      * 封装返回结果
  61.      */
  62.     private void responseOut(HttpServletResponse response,Integer limit) throws IOException {
  63.         response.setCharacterEncoding("UTF-8");
  64.         response.setContentType("application/json; charset=utf-8");
  65.         PrintWriter writer = response.getWriter();
  66.         Map<String,String> resultMap = new HashMap<>();
  67.         resultMap.put("status","502");
  68.         resultMap.put("msg","接口超出最大请求数:" + limit);
  69.         String s = JSONObject.toJSON(resultMap).toString();
  70.         writer.append(s);
  71.     }
  72.  
  73.     //获取处理类上的注解
  74.     public <T extends Annotation> T getTagAnnotation(Method method, Class<T> annotationClass){
  75.         //获取方法中是否有相关注解
  76.         T methodAnnotation = method.getAnnotation(annotationClass);
  77.         //获取类上是否有相关注解
  78.         T classAnnotation = method.getDeclaringClass().getAnnotation(annotationClass);
  79.         //判断是否存在相关注解
  80.         if(null != methodAnnotation){
  81.             return methodAnnotation;
  82.         }else return classAnnotation;
  83.     }
  84.  
  85.     /**
  86.      * 判断接口是否限流,通过请求的SessionId进行限流
  87.      */
  88.     public boolean isLimit(HttpServletRequest request,RequestLimit limiter){
  89.         //获取请求的SessionID
  90.         String id = request.getSession().getId();
  91.         //查看是否在限流map里面
  92.         Integer num = map.get(id);
  93.         System.out.println("SessionId:" + id + "\n" + "num:" + num + "\n" + "limiterCount:" + limiter.maxCount() + "\n" + "limit:" + limiter.limit());
  94.         //没有则初始化限流map，并创建定时任务(解除限流)
  95.         if(null == num){
  96.             //初始化计数器
  97.             map.put(id,1);
  98.             //创建定时器任务，删除限流器
  99.             Timer timer = new Timer();
  100.             //获取限流的时间毫秒数
  101.             long delay = getDelay(limiter.timeUnit(), limiter.limit());
  102.             timer.schedule(new TimerTask() {
  103.                 @Override
  104.                 public void run() {
  105.                     System.out.println("删除任务执行");
  106.                     map.remove(id);
  107.                 }
  108.             },delay);
  109.         }else{
  110.             //累加请求
  111.             ++num;
  112.             //判断是否超出最大限流次数
  113.             if(num > limiter.maxCount()){
  114.                 return true;
  115.             }
  116.             //更新计数器
  117.             map.put(id,num);
  118.         }
  119.         return false;
  120.     }
  121.  
  122.     /**
  123.      * 获取限流时间,总共限流的毫秒数
  124.      * @param timeUnit
  125.      * @param limit
  126.      * @return
  127.      */
  128.     public long getDelay(TimeUnit timeUnit,Integer limit){
  129.         if(null == timeUnit || limit == 0){
  130.             return 0;
  131.         }
  132.         switch (timeUnit){
  133.             case MILLISECONDS:
  134.                 return limit;
  135.             case MINUTES:
  136.                 return limit*60*1000;
  137.             case HOURS:
  138.                 return limit*60*60*1000;
  139.             default:
  140.                 return limit*1000;
  141.         }
  142.     }
  143.  
  144. }
1.3 将自定义拦截器加入到Spring的拦截器
  1. package com.zhf.model.config;
  2. import com.zhf.model.interceptor.RequestLimitInterceptor;
  3. import org.springframework.stereotype.Component;
  4. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  5. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  6.  
  7. import javax.annotation.Resource;
  8.  
  9. @Component
  10. public class WebMVCConfig implements WebMvcConfigurer {
  11.  
  12.     @Resource
  13.     RequestLimitInterceptor limiter;
  14.  
  15.     @Override
  16.     public void addInterceptors(InterceptorRegistry registry) {
  17.         registry.addInterceptor(limiter);
  18.         WebMvcConfigurer.super.addInterceptors(registry);
  19.     }
  20. }
1.4 创建MainController进行测试
为了方便测试，这里设置为1分钟5次 
  1. package com.zhf.model.controller;
  2.  
  3. import com.zhf.model.annotation.RequestLimit;
  4. import org.springframework.web.bind.annotation.RequestMapping;
  5. import org.springframework.web.bind.annotation.RestController;
  6. import java.util.concurrent.TimeUnit;
  7.  
  8. @RestController
  9. @RequestMapping("/main")
  10. public class MainController {
  11.  
  12.     @RequestMapping("/lock")
  13.     @RequestLimit(maxCount = 5 , limit = 1 ,timeUnit = TimeUnit.MINUTES)
  14.     public String testLock(){
  15.         return "ok";
  16.     }
  17.  
  18. }

  • 16:19点击5次，接口限流

  • 16:20再次点击，限流解除

  1. AOP实现

  • 没依赖先添加依赖

  1. <dependency>
  2.     <groupId>org.springframework</groupId>
  3.     <artifactId>spring-aspects</artifactId>
  4.     <version>4.3.7.RELEASE</version>
  5. </dependency>
  6.  
  7. <dependency>
  8.     <groupId>org.springframework</groupId>
  9.     <artifactId>spring-aop</artifactId>
  10.     <version>4.3.7.RELEASE</version>
  11. </dependency>
2.1 创建限流的注解类RateLimiter.java
  1. package com.zhf.model.annotation;
  2.  
  3. import java.lang.annotation.*;
  4. import java.util.concurrent.TimeUnit;
  5.  
  6. @Target(ElementType.METHOD)
  7. @Retention(RetentionPolicy.RUNTIME)
  8. @Documented
  9. public @interface RateLimiter {
  10.  
  11.     /**
  12.      * 限流的时间单位
  13.      */
  14.     TimeUnit timeUnit() default TimeUnit.SECONDS;
  15.  
  16.     /**
  17.      * 限流的时长
  18.      */
  19.     int limit() default 1;
  20.  
  21.     /**
  22.      * 最大限流量
  23.      * @return
  24.      */
  25.     int maxCount() default 1;
  26. }

2.2 创建切面RateLimiterAspect.java

这里直接使用Redis(String)的过期时间作为限流的计数器
直接使用String不方便管理，可以使用RedisScript进行管理 
  1. package com.zhf.model.aop;
  2.  
  3. import com.alibaba.fastjson.JSONObject;
  4. import com.zhf.model.annotation.RateLimiter;
  5. import com.zhf.model.exception.CommonException;
  6. import org.aspectj.lang.JoinPoint;
  7. import org.aspectj.lang.annotation.Aspect;
  8. import org.aspectj.lang.annotation.Before;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.data.redis.core.RedisTemplate;
  11. import org.springframework.stereotype.Component;
  12. import org.springframework.web.context.request.RequestContextHolder;
  13. import org.springframework.web.context.request.ServletRequestAttributes;
  14.  
  15. import javax.servlet.http.HttpServletResponse;
  16. import java.io.IOException;
  17. import java.io.PrintWriter;
  18. import java.util.HashMap;
  19. import java.util.Map;
  20.  
  21. /**
  22.  * 限流处理类
  23.  * @Aspect 声明该类为切面
  24.  */
  25. @Aspect
  26. @Component
  27. public class RateLimiterAspect
  28. {
  29.     @Autowired
  30.     private RedisTemplate redisTemplate;
  31.  
  32.  
  33.     /**
  34.      * 执行前置方法，"@annotation(rateLimiter)"在注解rateLimiter之前执行
  35.      * @param point
  36.      * @param rateLimiter
  37.      * @throws Throwable
  38.      */
  39.     @Before("@annotation(rateLimiter)")
  40.     public void doBefore(JoinPoint point, RateLimiter rateLimiter) throws Throwable
  41.     {
  42.         //获取请求
  43.         ServletRequestAttributes attributes = (ServletRequestAttributes)RequestContextHolder.getRequestAttributes();
  44.         //获取SessionID
  45.         String id = attributes.getRequest().getSession().getId();
  46.         //这里使用redis过期时间作限流
  47.         Integer count = (Integer)redisTemplate.opsForValue().get(id);
  48.         //如果第一次请求或上次限流已经解除
  49.         System.out.println("Count:" + count + ";TimeUnit:" + rateLimiter.timeUnit());
  50.         if(null == count){
  51.             //初始化限流器
  52.             redisTemplate.opsForValue().set(id,1,rateLimiter.limit(),rateLimiter.timeUnit());
  53.         }else{
  54.             //累加
  55.             ++count;
  56.             redisTemplate.opsForValue().set(id,count,0);
  57.             if(count > rateLimiter.maxCount()){
  58.                 //抛出自定义异常码，然后统一返回
  59.                 throw new CommonException(480);
  60.             }
  61.         }
  62.     }
  63. }
2.3 自定义异常类CommonException，同一异常返回

  • 自定义异常类

  1. package com.zhf.model.exception;
  2.  
  3. import lombok.Data;
  4.  
  5. @Data
  6. public class CommonException extends RuntimeException{
  7.  
  8.     private int code;
  9.  
  10.     private String msg;
  11.  
  12.     public CommonException() {
  13.     }
  14.  
  15.     public CommonException(int code) {
  16.         this.code = code;
  17.     }
  18.  
  19.     public CommonException(int code, String msg) {
  20.         this.code = code;
  21.         this.msg = msg;
  22.     }
  23. }
  1. package com.zhf.model.handler;
  2.  
  3. import com.zhf.model.exception.CommonException;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.springframework.http.HttpStatus;
  6. import org.springframework.web.bind.annotation.*;
  7.  
  8. import java.time.format.DateTimeParseException;
  9.  
  10. @RestControllerAdvice
  11. @Slf4j
  12. public class CommonExceptionHandler {
  13.  
  14.     @ExceptionHandler(NullPointerException.class)
  15.     @ResponseStatus(value= HttpStatus.INTERNAL_SERVER_ERROR)
  16.     public ReturnResult handleTypeMismatchException(NullPointerException ex){
  17.         log.debug(ex.getMessage());
  18.         return new ReturnResult(500,"空指针异常");
  19.     }
  20.  
  21.     @ExceptionHandler(ArithmeticException.class)
  22.     @ResponseStatus(value= HttpStatus.INTERNAL_SERVER_ERROR)
  23.     public ReturnResult handleArithmeticException(ArithmeticException ex){
  24.         ex.printStackTrace();
  25.         return new ReturnResult(500,"被除数不能为零");
  26.     }
  27.  
  28.     @ExceptionHandler(DateTimeParseException.class)
  29.     @ResponseStatus(value= HttpStatus.INTERNAL_SERVER_ERROR)
  30.     public ReturnResult handleDateTimeParseException(DateTimeParseException ex){
  31.         ex.printStackTrace();
  32.         return new ReturnResult(500,"时间转换格式错误");
  33.     }
  34.  
  35.     @ExceptionHandler(CommonException.class)
  36.     @ResponseStatus(value= HttpStatus.INTERNAL_SERVER_ERROR)
  37.     public ReturnResult handleCommonException(CommonException ex){
  38.         ex.printStackTrace();
  39.         if(ex.getCode() == 480){
  40.             return new ReturnResult(480,"接口限流");
  41.         }
  42.         if(ex.getCode() == 502){
  43.             return new ReturnResult(502,"自定义异常处理502");
  44.         }
  45.         return new ReturnResult(500,"时间转换格式错误");
  46.     }
  47. }
2.4创建测试类
方便测试，一分钟五次 
  1. package com.zhf.model.controller;
  2.  
  3. import com.zhf.model.annotation.RateLimiter;
  4. import com.zhf.model.annotation.RequestLimit;
  5. import org.springframework.web.bind.annotation.RequestMapping;
  6. import org.springframework.web.bind.annotation.RestController;
  7. import java.util.concurrent.TimeUnit;
  8.  
  9. @RestController
  10. @RequestMapping("/main")
  11. public class MainController {
  12.  
  13.     /**
  14.      * 测试限流
  15.      * @return
  16.      */
  17.     @RequestMapping("/lock")
  18.     @RequestLimit(maxCount = 5 , limit = 1 ,timeUnit = TimeUnit.MINUTES)
  19.     public String testLock(){
  20.         return "ok";
  21.     }
  22.  
  23.     @RequestMapping("/testAopLimit")
  24.     @RateLimiter(maxCount = 5 , limit = 1 ,timeUnit = TimeUnit.MINUTES)
  25.     public String testAopLimit(){
  26.         return "ok";
  27.     }
  28. }
18:00点击5次，接口限流
18:01再次请求，解除限流

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号