springboot+aop实现限流方式浅析

最新推荐文章于 2024-05-31 16:18:36 发布
最新推荐文章于 2024-05-31 16:18:36 发布
阅读量1.8k 收藏 14
点赞数 3
分类专栏： springboot 文章标签： spring boot 限流
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leijie0322/article/details/126206282
版权

限流，就是在某个时间窗口对资源访问做次数限制，如设定每秒最多100个访问请求。限流具有两个维度，如下

  • 时间：基于某段时间范围或某个时间点，即时间窗口，如对每分钟、每秒钟的时间窗口做限制；
  • 资源：基于可用资源的限制，如设定最大 访问次数或最高可用连接数；

在实际开发中，不止设置一种限流规则，而是设置多个限流规则共同作用，常见限流规则如下

  • QPS和连接数限制：对于QPS和连接数限流，可设定IP维度的限流，也可设定单个服务的限流。如设定一个IP每秒访问次数小于10，连接数小于5，单个服务QPS小于100，连接数小于200等；
  • 传输速率：如下载速度100k/s、100m/s；
  • 黑白名单：黑名单是限制其访问，白名单是自由访问；

限流常见方法如下

  • 令牌桶算法：获取令牌的请求才会被处理，其他请求要么排队要么直接被丢弃，桶存放指定的令牌数；
  • 漏桶算法：漏桶是将请求放到桶里，若是桶满了，其他请求将被丢弃，桶里的请求以恒定的速率从桶内流出；
  • 滑动窗口：当时间窗口的跨度越长，限流效果越平滑；

在springboot工程中，通过aop的方式实现限流，应用场景有采用guava的速率限流、采用redis的指定时间指定次数限制、socket请求限制、http请求限制。
实例1：guava速率限流

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

    //默认每秒桶中漏掉的token
    int limit() default 10;
}

@Aspect
@Component
public class RateLimitAspect {

    /**
     * 用来存放不同接口的RateLimiter(key为接口名称，value为RateLimiter)
     */
    private ConcurrentHashMap<String, RateLimiter> map = new ConcurrentHashMap<>();

    private RateLimiter rateLimiter;

    @Pointcut("@annotation(com..annotation.RateLimit)")
    public void limitPointCut() {
    }

    @Around("limitPointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        RateLimit annotation = methodSignature.getMethod().getAnnotation(RateLimit.class);
        int limit = annotation.limit();
        // 注解所在方法名区分不同的限流策略
        String key = methodSignature.getName();
        //获取rateLimiter
        if (!map.containsKey(key)) {
            map.put(key, RateLimiter.create(limit-1));
        }
        rateLimiter = map.get(key);
        if (rateLimiter.tryAcquire()) {
            //执行方法
            return joinPoint.proceed();
        } else {
            System.out.println("在1秒内已经超过" + limit + "次请求,不再向下发起请求.");
            return null;
        }
    }
}

	@RateLimit(limit = 3)
    @GetMapping(value = "/hello2", produces = "application/json;charset=UTF-8")
    public ResponseEntity<String> hello2() {
        String result = testService.hello();
        return ResponseEntity.ok("每秒内只接受3个请求:" + System.currentTimeMillis() + result);
    }

在这里插入图片描述
实例2：redis指定时间指定次数限制

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

    int limit() default 10;

    int time() default 10;

}

@Aspect
@Component
public class RequestLimitAspect {

    private final HttpServletRequest request;
    private final RedisService redisService;

    @Autowired
    public RequestLimitAspect(HttpServletRequest request, RedisService redisService) {
        this.request = request;
        this.redisService = redisService;
    }

    @Pointcut("@annotation(com..annotation.RequestLimit)")
    public void limitPointCut() {
    }

    @Around("limitPointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        RequestLimit requestLimit = methodSignature.getMethod().getAnnotation(RequestLimit.class);
        if (requestLimit != null) {
            String key = IPUtil.getIpAddress(request) + ":" + methodSignature.getName();
            int limit = requestLimit.limit();
            int time = requestLimit.time();
            if (redisService.hasKey(key)) {
                String count = redisService.get(key).toString();
                int countRequest = Integer.parseInt(count);
                if (countRequest >= limit) {
                    System.out.println("在" + time + "秒内已经超过" + limit + "次请求,不再向下发起请求.");
                    return null;
                } else {
                    redisService.incr(key, 1);
                    //return joinPoint.proceed();
                }
            } else {
                redisService.set(key, 1, time);
                //return joinPoint.proceed();
            }
        }
        return joinPoint.proceed();
    }

}

	@RequestLimit(time = 60, limit = 3)
    @GetMapping(value = "/hello", produces = "application/json;charset=UTF-8")
    public ResponseEntity<String> hello() {
        String result = testService.hello();
        return ResponseEntity.ok("60s内只接受3个请求:" + System.currentTimeMillis() + result);
    }

在这里插入图片描述
或切面环绕无返回，请求返回为空

@Aspect
@Component
public class RequestLimitAspect2 {

    private final HttpServletRequest request;
    private final RedisService redisService;

    @Autowired
    public RequestLimitAspect2(HttpServletRequest request, RedisService redisService) {
        this.request = request;
        this.redisService = redisService;
    }

    @Pointcut("@annotation(com.ldc.springboot_ratelimiter.annotation.RequestLimit2)")
    public void limitPointCut() {
    }

    @Around("limitPointCut()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        RequestLimit2 requestLimit2 = methodSignature.getMethod().getAnnotation(RequestLimit2.class);
        if (requestLimit2 != null) {
            String key = IPUtil.getIpAddress(request) + ":" + methodSignature.getName();
            int limit = requestLimit2.limit();
            int time = requestLimit2.time();
            if (redisService.hasKey(key)) {
                String count = redisService.get(key).toString();
                int countRequest = Integer.parseInt(count);
                if (countRequest >= limit) {
                    System.out.println("在" + time + "秒内已经超过" + limit + "次请求,不再向下发起请求.");
                    return;
                } else {
                    redisService.incr(key, 1);
                    joinPoint.proceed();
                }
            } else {
                redisService.set(key, 1, time);
                joinPoint.proceed();
            }
        }
    }

}

实例3：socket请求限流

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

    String event() default "";

    int limit() default 10;

    int time() default 10;

}

@Aspect
@Component
public class SocketRequestLimitAspect {

    private static final Logger logger = LoggerFactory.getLogger(SocketRequestLimitAspect.class);

    private final RedisService redisService;

    @Autowired
    public SocketRequestLimitAspect(RedisService redisService) {
        this.redisService = redisService;
    }

    @Pointcut("@annotation(com..annotation.SocketRequestLimit)")
    public void pointcut(){}

    @Around("pointcut()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = joinPoint.getTarget().getClass().getMethod(methodSignature.getName(), methodSignature.getMethod().getParameterTypes());
        SocketRequestLimit annotation = method.getAnnotation(SocketRequestLimit.class);
        String event = annotation.event();
        SocketIOClient socketIOClient = null;
        Object[] args = joinPoint.getArgs();
        for (Object arg : args) {
            if(arg instanceof SocketIOClient) {
                socketIOClient = (SocketIOClient) arg;
            }
        }
        if (annotation != null) {
            String ip = socketIOClient.getRemoteAddress().toString();
            String key = ip.substring(0, ip.lastIndexOf(":")) + ":" + event;
            int limit = annotation.limit();
            int time = annotation.time();
            if (redisService.hasKey(key)) {
                String count = redisService.get(key).toString();
                int countRequest = Integer.parseInt(count);
                if (countRequest >= limit) {
                    System.out.println("在" + time + "秒内已经超过" + limit + "次请求,不再向下发起请求.");
                    return;
                } else {
                    redisService.incr(key, 1);
                    joinPoint.proceed();
                }
            } else {
                redisService.set(key, 1, time);
                joinPoint.proceed();
            }
        }
    }

}

@SocketRequestLimit(event = "EVENT",limit = 3,time = 60)
    @OnEvent(value = "EVENT")
    public void EVENT(SocketIOClient client) {
        String result = testService.hello2();
        client.sendEvent("EVENT", JSON.toJSONString(result));
    }

页面1秒发起1个请求，在10秒内共发起了10个请求，在60秒内允许向下请求3个，丢弃了7个请求，下游服务10秒响应1个，页面最终共收到3个响应结果。

实例4：多个切面组件，指定增强顺序
通过@Order注解即可指定执行的先后顺序

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

    String event() default "";

    int limit() default 10;

    int time() default 10;

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

    long timeout() default 3;

    String event() default "";
}

@Order(1)
@Aspect
@Component
public class SocketRequestLimitAspect {

    private static final Logger logger = LoggerFactory.getLogger(SocketRequestLimitAspect.class);

    private final RedisService redisService;

    @Autowired
    public SocketRequestLimitAspect(RedisService redisService) {
        this.redisService = redisService;
    }

    @Pointcut("@annotation(com..SocketRequestLimit)")
    public void pointcut(){}

    @Around("pointcut()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = joinPoint.getTarget().getClass().getMethod(methodSignature.getName(), methodSignature.getMethod().getParameterTypes());
        SocketRequestLimit annotation = method.getAnnotation(SocketRequestLimit.class);
        String event = annotation.event();
        SocketIOClient socketIOClient = null;
        Object[] args = joinPoint.getArgs();
        for (Object arg : args) {
            if(arg instanceof SocketIOClient) {
                socketIOClient = (SocketIOClient) arg;
            }
        }
        if (annotation != null) {
            String ip = socketIOClient.getRemoteAddress().toString();
            String key = ip.substring(0, ip.lastIndexOf(":")) + ":" + event;
            int limit = annotation.limit();
            int time = annotation.time();
            if (redisService.hasKey(key)) {
                String count = redisService.get(key).toString();
                int countRequest = Integer.parseInt(count);
                if (countRequest >= limit) {
                    System.out.println("在" + time + "秒内已经超过" + limit + "次请求,不再向下发起请求.");
                    return;
                } else {
                    redisService.incr(key, 1);
                    joinPoint.proceed();
                }
            } else {
                redisService.set(key, 1, time);
                joinPoint.proceed();
            }
        }
    }

}
@Order(2)
@Aspect
@Component
public class SocketRequestTimeOutAspect {

    private static final Logger logger = LoggerFactory.getLogger(SocketRequestTimeOutAspect.class);

    ArrayBlockingQueue<Runnable> blockingQueue = new ArrayBlockingQueue<Runnable>(2);
    ExecutorService executorService = new ThreadPoolExecutor(2,2,60, TimeUnit.MILLISECONDS,blockingQueue,new ThreadPoolExecutor.DiscardOldestPolicy());

    @Pointcut("@annotation(com..annotation.SocketRequestTimeOutAnnotation)")
    public void pointcut(){}

    @Around("pointcut()")
    public void around(ProceedingJoinPoint joinPoint) throws NoSuchMethodException {
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        Method method = joinPoint.getTarget().getClass().getMethod(methodSignature.getName(), methodSignature.getMethod().getParameterTypes());
        SocketRequestTimeOutAnnotation annotation = method.getAnnotation(SocketRequestTimeOutAnnotation.class);
        long timeout = annotation.timeout();
        String event = annotation.event();

        SocketIOClient socketIOClient = null;
        Object[] args = joinPoint.getArgs();
        for (Object arg : args) {
            if(arg instanceof SocketIOClient) {
                socketIOClient = (SocketIOClient) arg;
            }
        }
        Future<Object> future = executorService.submit(() -> {
            try {
                Object processResult = joinPoint.proceed();
                return processResult;
            } catch (Throwable throwable) {
                logger.error(String.format("请求异常"),throwable);
                throwable.printStackTrace();
                return null;
            }
        });
        try {
            future.get(timeout, TimeUnit.SECONDS);
        } catch (TimeoutException e) {
            logger.error("请求的地址URL {} 事件 {} 持久层请求超时", socketIOClient.getRemoteAddress(), event);
            socketIOSendException(socketIOClient, event, "持久层请求超时");
        } finally {
            //executorService.shutdown();
        }
    }

    private void socketIOSendException(SocketIOClient socketIOClient, String event, String content) {
        if(socketIOClient != null) {
            Map<String, Object> map = new HashMap<>();
            map.put("9999",content + ",请稍后再试.");
            socketIOClient.sendEvent(event, JSON.toJSONString(map));
        }
    }

}

请求次数限制先行增强，将请求只放行3个，然后进行3个请求超时增强，由于响应处理超时，页面收到3个超时响应，待3个请求响应完成，页面收到3个响应结果，进行了双重限流，第一层口子小，第二层没有充分利用线程池及其拒绝策略。
在这里插入图片描述
在这里插入图片描述
继续思考限流的应用场景，加油吧，少年。

ldcaws
关注
  • 3
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
详解springboot+aop+Lua分布式限流的最佳实践
08-19
详解springboot+aop+Lua分布式限流的最佳实践 本文主要介绍了springboot+aop+Lua分布式限流的最佳实践，涵盖了限流的定义、限流的重要性、限流方案等多个方面。 一、什么是限流？为什么要限流？ 限流是指限制系统...
SpringBoot+AOP+TraceID.pdf
01-04
SpringBoot+AOP+TraceID.pdf 本文档主要讲解了 SpringBoot 中 AOP（Aspect Oriented Programming）的应用和 TraceID 的实现。 AOP 基本概念 AOP 的 existence 目的是为了解耦，使得一组类可以共享相同的行为。在 ...
基于 AOP + Redis + 自定义注解 实现细粒度的接口IP访问限制 | 开源微服务项目
BASK2312的博客
01-10 262
一般向外暴露的接口，都需要加上一个访问限制，以防止有人恶意刷流量或者爆破，访问限制的做法有很多种，从控制粒度上来看可以分为：全局访问限制和接口访问限制，本文讲的是接口访问的限制。本章讲解的主要内容在项目中的位置：scblogs / common / common-web / src / main / java / cn / sticki / common / web / anno /我的写法是基于AOP + 自定义注解 + Redis，并且封装在一个单独的模块common-web。
SpringBoot如何使用AOP+Redis实现接口限流实现全过程（值得珍藏）
a342874650的专栏
01-21 595
在当今的微服务架构中，接口限流是一个常见的需求，用以防止系统过载和潜在的资源耗尽。Spring Boot 提供了一种方便的方式来实施接口限流，结合 AOP（面向切面编程）和 Redis 存储限流信息，可以有效地实现这一目标。
一个注解+AOP 实现接口限流、防重、防抖
最新发布
m0_61075687的博客
05-31 379
接口限流、防重复提交、接口防抖，是保证接口安全、稳定提供服务，以及防止错误数据活脏数据产生的重要手段。下面我讲用实际的代码例子来说明怎么用注解和AOP搞定限流、防重、防抖。
通过自定义注解+AOP实现限流
m0_57850369的博客
01-12 420
我通过 AOP 对这个注解进行拦截，当我拦截到这个注解所对应的方法后，我就获取到当前方法所对应这个注解 的 name 和 token，他们作为 当前执行方法的 限流名称和访问次数。当我自定义一个注解，参数为 name 访问令牌 ， token 一秒内访问次数 ，
AOP 切面编程实战（日志+限流）
HHH的博客
08-11 361
现在我有这么一个controller , 想要给他们都添加一个打印日志的功能，传统的方法就是都在每一个方法里写上一个打印的代码， 可是万一方法数量更多，并且有很多个这样的controller ,你还是一个个的处理吗？所以这里就要用到我们的AOP 切面编程了。顾名思义，切面就是统一的来对某些方法进行操作 AOP切面编程一共有两种写法，我这里就基于更加主流更加灵活的注解的写法进行演示。我们这里先创建一个注解，这个注解里只有一个属性 basenessName（基本名称）我们想要的效果就是将该注解放在对应的方法上
AOP+注解 解决重放攻击
weixin_40317062的博客
09-12 601
防止重放攻击，简单来说就是防止多次访问 方法： @ResponseBody @RequestMapping(value = "/saveOrUpdate", method = RequestMethod.POST) @RequestLimit public Object saveOrUpdate(MallStore store, HttpServletRequest request) { 注解：@RequestLimit @Target(ElementType..
Spring Boot项目怎么通过Redisson实现滑动窗口限流？
冥胖胖9的博客
02-01 777
为了防止这些接口被攻击者恶意频繁调用，消耗我们的系统资源，通常我们会对这些接口做限流保护，否则可能会导致我们的服务器的宕机。在redisson中已经为我们实现好了滑动窗口限流，通过redissonClient拿到限流器后，配置好时间窗口和限流速率就能直接使用了。实现原理和上面我们的伪代码是一样的，只是它将这一部分封装好了，我们拿到后开箱即用。从上图我们可以得知，有一个时间窗口随着时间轴在向右移动，我们可以记录这个时间窗口内的请求次数，当超过我们允许的阈值时，则进行限流不能继续进行请求。
【SpringBoot随笔】采用RateLimiter实现QPS限流
qq_44299928的博客
10-31 792
【代码】【SpringBoot随笔】采用RateLimiter实现QPS限流。
SpringBoot 如何进行限流？老鸟们还可以这样玩
GitHub质检员
11-29 112
*** 资源的key,唯一* 作用：不同的接口，不同的流量控制*//*** 最多的访问限制次数*//*** 过期时间也可以理解为单位时间，单位秒，默认60*/​/*** 得不到令牌的提示语*/String msg() default "系统繁忙,请稍后再试.";
springboot注解+aop实现接口限流
09-07
springboot框架中使用自定义注解，配合切面实现接口限流，增加ip黑名单功能，可实现ip+账号+接口进黑名单，也可以实现账号+ip进黑名单及禁用账号； 可以学会自定义注解使用、自定义响应码枚举及使用、自定义异常类及...
使用SpringBoot+AOP实现可插拔式日志的示例代码
08-25
本文主要介绍了使用 SpringBoot 与 AOP 实现可插拔式日志的示例代码，通过示例代码详细介绍了使用 AOP 实现可插拔式日志的步骤和实现方式。 首先，AOP（Aspect-Oriented Programming）是一种面向切面编程技术，通过...
基于springboot+mvc+freemarker+aop实现校友信息管理系统源码.zip
01-08
1、基于springboot+mvc+freemarker+aop实现校友信息管理系统源码.zip 2、该资源包括项目的全部源码，下载可以直接使用！ 3、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考...
【SpringBoot】秒杀业务：redis+拦截器+自定义注解+验证码简单实现限流
浩泽学编程的博客
03-05 1712
限流是秒杀业务最常用的手段。限流是从用户访问压力的角度来考虑如何应对系统故障。这里我是用限制访问接口次数（Redis+拦截器+自定义注解）和验证码的方式实现简单限流。含义：限制xx秒内最多请求xx次/*** @Author: Dragon_王* @Description: 通用接口限流，限制xx秒内最多请求次数//时间，单位秒 int second();//限制最大请求次数 int maxCount();//是否需要登录 boolean needLogin() default true;
限流（SpringBoot + AOP）
stubborn的博客
10-13 351
Google开源工具包Guava提供了限流工具类RateLimiter，该类基于令牌桶算法实现流量限制 第一步：引入guava依赖包 <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>30.1-jre</version> </dependency> 第二步：给接
AOP实现接口限流
liuerchong的博客
05-26 823
前言 限流方案 Java限流及常用解决方案 Guawa限流应用 @Slf4j @RestController @RequestMapping("/limit") public class LimitController { /** * 限流策略 ： 1秒钟2个请求 */ private final RateLimiter limiter = RateLimiter.create(2.0); private DateTimeFormatter dtf = Date
SpringBoot 如何进行限流
weixin_47221460的博客
07-28 6567
springboot限流
Aop限流实现解决方案
ડUN的博客
01-08 1091
Aop限流实现解决方案 01、限流 在业务场景中，为了限制某些业务的并发，造成接口的压力，需要增加限流功能。 02、限流的成熟解决方案 guava (漏斗算法 + 令牌算法) （单机限流） redis + lua + ip 限流（比较推荐）（分布式限流） nginx 限流 （源头限流） … 03、 限流的目的 保护服务的资源泄露 解决服务器的高可压，减少服务器并发 04、安装redis服务 安装redis wget http://download.redis.io/releases/redis-6.
springboot+aop实现pvuv统计
04-04
Spring Boot是一个用于构建独立的、生产级别的Java应用程序的框架，而AOP（面向切面编程）是一种编程范式，它允许在程序运行期间动态地将额外的行为织入到代码中。通过结合Spring Boot和AOP，我们可以实现PV（页面访问量）和UV（独立访客数）的统计。 下面是实现Spring Boot + AOP进行PVUV统计的步骤： 1. 创建一个Spring Boot项目，并添加所需的依赖。 2. 创建一个切面类，用于定义统计逻辑。可以使用@Aspect注解标记该类为切面类，并使用@Before、@After等注解定义切点和增强逻辑。 3. 在切面类中，可以使用@Pointcut注解定义切点表达式，用于匹配需要进行统计的方法。 4. 在切面类中，可以使用ThreadLocal或者缓存等方式来记录PV和UV的数据。 5. 在切面类中，可以使用HttpServletRequest获取请求信息，如请求路径、IP地址等。 6. 在切面类中，可以使用自定义的数据结构或者数据库等方式来存储和更新PV和UV的数据。 7. 在切面类中，可以使用定时任务或者其他方式来定期清理过期的PV和UV数据。 8. 在需要进行统计的方法上添加相应的注解，如@PVCount、@UVCount等，以便切面类能够匹配到这些方法。 9. 运行Spring Boot应用程序，切面类将会在匹配到的方法执行前后进行统计操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值