RateLimiter+AOP自定义注解限流

最新推荐文章于 2024-03-21 10:37:47 发布
最新推荐文章于 2024-03-21 10:37:47 发布
阅读量448 收藏 3
点赞数
分类专栏： 限流 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_14946371/article/details/130148383
版权

RateLimiter简介

springboot集成RateLimiter

pom.xml引入guava依赖

<dependency>  
    <groupId>com.google.guava</groupId>  
    <artifactId>guava</artifactId>  
    <version>31.1-jre</version>  
</dependency>

RateLimiter常用api

RateLimiter.create(double permitsPerSecond)

  • 指定速率，每秒产生permitsPerSecond个令牌

rateLimiter.acquire(int permits);

  • 返回获取permits个令牌所需的时间

rateLimiter.tryAcquire(1);

  • 获取1个令牌，返回false获取失败，true获取成功

rateLimiter.tryAcquire(1, 2, TimeUnit.SECONDS)

  • 获取1个令牌，最多等待两秒。返回false获取失败，true获取成功
package com.fandf.test.ratelimter;  
  
import com.google.common.util.concurrent.RateLimiter;  
  
import java.util.concurrent.TimeUnit;  
  
/**  
* @author fandongfeng  
* @date 2023/4/9 19:55  
*/  
public class RateLimiterTest {  
  
    public static void main(String[] args) {  
        //指定速率，每秒产生一个令牌  
        RateLimiter rateLimiter = RateLimiter.create(1);  
        System.out.println(rateLimiter.getRate()); 
        //修改为每秒产生2个令牌
        rateLimiter.setRate(2);  
        System.out.println(rateLimiter.getRate());  
  
        //while (true) {  
            //获取2个令牌所需要的时间  
            double acquire = rateLimiter.acquire(2);  
            //输出结果， 第一次0秒，后面每次等待接近0.5秒的时间  
            //0.0  
            //0.995198  
            //0.9897  
            //0.999413  
            //0.998272  
            //0.99202  
            //0.993757  
            //0.996198  
            //0.99523  
            //0.99532  
            //0.992674  
            System.out.println(acquire);  
       // }  
            //获取1个令牌  
            boolean result = rateLimiter.tryAcquire(1);  
            System.out.println(result);  
            //获取1个令牌,最多等待两秒  
            boolean result2 = rateLimiter.tryAcquire(1, 2, TimeUnit.SECONDS);  
            System.out.println(result2);
 
    }  
  
}

RateLimiter+AOP实现自定义注解限流

自定义注解Limiter


package com.fandf.test.ratelimter;  
  
import java.util.concurrent.TimeUnit;  
  
/**  
* 限流注解  
*  
* @author fandongfeng  
* @date 2023/4/9 20:17  
*/  
@Target(ElementType.METHOD)  
@Retention(RetentionPolicy.RUNTIME)  
@Documented
public @interface Limiter {  
    /**
    * 不进行限流
    */
    int NOT_LIMITED = 0;  

    /**  
    * qps (每秒并发量)  
    */  
    double qps() default NOT_LIMITED;  

    /**  
    * 超时时长,默认不等待  
    */  
    int timeout() default 0;  

    /**  
    * 超时时间单位,默认毫秒  
    */  
    TimeUnit timeUnit() default TimeUnit.MILLISECONDS;  

    /**  
    * 返回错误信息  
    */  
    String msg() default "系统忙，请稍后再试";  
}

新增限流切面

pom引入aop依赖

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

package com.fandf.test.ratelimter;  
  
import com.google.common.util.concurrent.RateLimiter;  
import lombok.extern.slf4j.Slf4j;  
import org.aspectj.lang.ProceedingJoinPoint;  
import org.aspectj.lang.annotation.Around;  
import org.aspectj.lang.annotation.Aspect;  
import org.aspectj.lang.reflect.MethodSignature;  
import org.springframework.stereotype.Component;  
  
import java.lang.reflect.Method;  
import java.util.concurrent.ConcurrentHashMap;  
import java.util.concurrent.ConcurrentMap;  
  
/**  
* 限流切面  
* @author fandongfeng  
* @date 2023/4/9 20:19  
*/  
@Slf4j  
@Aspect  
@Component  
public class RateLimiterAspect {  
    /**  
    * key: 类全路径+方法名  
    */  
    private static final ConcurrentMap<String, RateLimiter> RATE_LIMITER_CACHE = new ConcurrentHashMap<>();  
  
  
    @Around("@within(limiter) || @annotation(limiter)")  
    public Object pointcut(ProceedingJoinPoint point, Limiter limiter) throws Throwable {  
        MethodSignature signature = (MethodSignature) point.getSignature();  
        Method method = signature.getMethod();  
        if (limiter != null && limiter.qps() > Limiter.NOT_LIMITED) {  
            double qps = limiter.qps();  
            //这个key可以根据具体需求配置,例如根据ip限制,或用户  
            String key = method.getDeclaringClass().getName() + method.getName();  
            if (RATE_LIMITER_CACHE.get(key) == null) {  
                // 初始化 QPS  
                RATE_LIMITER_CACHE.put(key, RateLimiter.create(qps));  
            }  
            // 尝试获取令牌  
            if (RATE_LIMITER_CACHE.get(key) != null && !RATE_LIMITER_CACHE.get(key).tryAcquire(limiter.timeout(), limiter.timeUnit())) {  
                log.error("触发限流操作{}", key);  
                throw new RuntimeException(limiter.msg());  
            }  
        }  
        return point.proceed();  
    }  
}

测试限流

新建controller

package com.fandf.test.ratelimter;  
  
import lombok.extern.slf4j.Slf4j;  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RestController;  
  
/**  
* @author fandongfeng  
* @date 2023/4/9 20:25  
*/  
@RestController  
@RequestMapping("limiter")  
@Slf4j  
public class UserController {  
  
    @GetMapping  
    @Limiter(qps = 1, msg = "您已被限流！")  
        public String getUserName() {  
        String userName = "zhangsan";  
        log.info("userName = {}", userName);  
        return userName;  
    }  
  
}

打印结果

20:51:40.867 logback [http-nio-8080-exec-5] INFO  c.f.test.ratelimter.UserController - userName = zhangsan
20:51:41.700 logback [http-nio-8080-exec-6] INFO  c.f.test.ratelimter.UserController - userName = zhangsan
20:51:42.375 logback [http-nio-8080-exec-7] INFO  c.f.test.ratelimter.UserController - userName = zhangsan
20:51:43.029 logback [http-nio-8080-exec-8] INFO  c.f.test.ratelimter.UserController - userName = zhangsan
20:51:43.647 logback [http-nio-8080-exec-9] ERROR c.f.t.ratelimter.RateLimiterAspect - 触发限流操作com.fandf.test.ratelimter.UserControllergetUserName
20:51:43.648 logback [http-nio-8080-exec-9] ERROR o.a.c.c.C.[.[.[.[dispatcherServlet] - Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception [Request processing failed; nested exception is java.lang.RuntimeException: 您已被限流！] with root cause
java.lang.RuntimeException: 您已被限流！
	at com.fandf.test.ratelimter.RateLimiterAspect.pointcut(RateLimiterAspect.java:45)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethodWithGivenArgs(AbstractAspectJAdvice.java:634)
	at org.springframework.aop.aspectj.AbstractAspectJAdvice.invokeAdviceMethod(AbstractAspectJAdvice.java:624)
	at org.springframework.aop.aspectj.AspectJAroundAdvice.invoke(AspectJAroundAdvice.java:72)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:175)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:753)
	at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:97)
	at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
	at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.proceed(CglibAopProxy.java:753)
	at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:698)
	at com.fandf.test.ratelimter.UserController$$EnhancerBySpringCGLIB$$ee09d79c.getUserName(<generated>)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.springframework.web.method.support.InvocableHandlerMethod.doInvoke(InvocableHandlerMethod.java:205)
	at org.springframework.web.method.support.InvocableHandlerMethod.invokeForRequest(InvocableHandlerMethod.java:150)
	at org.springframework.web.servlet.mvc.method.annotation.ServletInvocableHandlerMethod.invokeAndHandle(ServletInvocableHandlerMethod.java:117)
	at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.invokeHandlerMethod(RequestMappingHandlerAdapter.java:895)
	at org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter.handleInternal(RequestMappingHandlerAdapter.java:808)
	at org.springframework.web.servlet.mvc.method.AbstractHandlerMethodAdapter.handle(AbstractHandlerMethodAdapter.java:87)
	at org.springframework.web.servlet.DispatcherServlet.doDispatch(DispatcherServlet.java:1067)
	at org.springframework.web.servlet.DispatcherServlet.doService(DispatcherServlet.java:963)
	at org.springframework.web.servlet.FrameworkServlet.processRequest(FrameworkServlet.java:1006)
	at org.springframework.web.servlet.FrameworkServlet.doGet(FrameworkServlet.java:898)
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:655)
	at org.springframework.web.servlet.FrameworkServlet.service(FrameworkServlet.java:883)
	at javax.servlet.http.HttpServlet.service(HttpServlet.java:764)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:227)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:162)
	at org.apache.tomcat.websocket.server.WsFilter.doFilter(WsFilter.java:53)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:189)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:162)
	at org.springframework.web.filter.RequestContextFilter.doFilterInternal(RequestContextFilter.java:100)
	at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:117)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:189)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:162)
	at org.springframework.web.filter.FormContentFilter.doFilterInternal(FormContentFilter.java:93)
	at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:117)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:189)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:162)
	at org.springframework.web.filter.CharacterEncodingFilter.doFilterInternal(CharacterEncodingFilter.java:201)
	at org.springframework.web.filter.OncePerRequestFilter.doFilter(OncePerRequestFilter.java:117)
	at org.apache.catalina.core.ApplicationFilterChain.internalDoFilter(ApplicationFilterChain.java:189)
	at org.apache.catalina.core.ApplicationFilterChain.doFilter(ApplicationFilterChain.java:162)
	at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:197)
	at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:97)
	at org.apache.catalina.authenticator.AuthenticatorBase.invoke(AuthenticatorBase.java:540)
	at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:135)
	at org.apache.catalina.valves.ErrorReportValve.invoke(ErrorReportValve.java:92)
	at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:78)
	at org.apache.catalina.connector.CoyoteAdapter.service(CoyoteAdapter.java:357)
	at org.apache.coyote.http11.Http11Processor.service(Http11Processor.java:382)
	at org.apache.coyote.AbstractProcessorLight.process(AbstractProcessorLight.java:65)
	at org.apache.coyote.AbstractProtocol$ConnectionHandler.process(AbstractProtocol.java:895)
	at org.apache.tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1732)
	at org.apache.tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:49)
	at org.apache.tomcat.util.threads.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1191)
	at org.apache.tomcat.util.threads.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:659)
	at org.apache.tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
	at java.lang.Thread.run(Thread.java:748)
越走越远的风
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RateLimiter了解
zy1104560031的专栏
11-05 451
本文参考：https://blog.csdn.net/u014730658/article/details/79374356 本文参考：https://blog.csdn.net/manzhizhen/article/details/52606732 RateLimter实现了令牌桶的限流算法 假设我们希望每秒最多发送5个请求，那么相当于每0.2秒发送一个。 - 当第一个请求发送后，记为开始...
springboot注解+aop实现接口限流
09-07
springboot框架中使用自定义注解，配合切面实现接口...可以学会自定义注解使用、自定义响应码枚举及使用、自定义异常类及使用、aop的使用、自定义动态配置全局配置项及使用、ip解析工具、自定义redis缓存key枚举及使用
【Java核心能力】RateLimiter 限流底层原理解析
qq_45260619的博客
03-10 2035
为什么要学习 RateLimiter 原理呢，其实是因为我的项目中使用到了 RateLimiter 进行限流，之前有一次在唯品会面试的时候，面试官就问到了 RateLimiter 的底层限流算法以及原理，当时回答的并不是很好，所以这里整理一下！ 这篇文章并没有讲 RateLimiter 的源码，底层源码看起来比较复杂，主要来理解它的限流算法原理、存在的缺点、以及在真实项目中如何使用它！
限流算法之漏桶算法、令牌桶算法
weixin_34313182的博客
11-04 4113
1.限流 每个API接口都是有访问上限的,当访问频率或者并发量超过其承受范围时候,我们就必须考虑限流来保证接口的可用性或者降级可用性.即接口也需要安装上保险丝,以防止非预期的请求对系统压力过大而引起的系统瘫痪. 通常的策略就是拒绝多余的访问,或者让多余的访问排队等待服务,或者引流. 如果要准确的控制QPS,简单的做法是维护一个单位时间内的Counter,如判断单位时间已经过去,则将Count...
利用RateLimiter加上自定义Aop注解限制某个接口的访问频率
最新发布
lixiaobai_boke的博客
03-21 362
利用RateLimiter加上自定义Aop注解限制某个接口的访问频率
使用RateLimiter限流（AOP + 注解实现）
dh554112075的博客
06-25 2355
注意：这里不会对RateLimiter做介绍 引入依赖 <!-- guava --> <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> ...
接口限流注解 RateLimiter (现成直接用)
weixin_43652507的博客
08-20 362
接口限流注解 RateLimiter (现成直接用)
springBoot+aop+自定义注解+本地线程实现统一接口日志及接口响应时长
02-01
内容概要：springboot+拦截器+aop+自定义注解+本地线程实现统一接口日志记录，记录下接口所在模块、接口描述、接口请求参数、接口返回参数、接口请求时间以及接口耗时用于接口优化，接口记录参数以及操作人防止使用...
spring aop 自定义注解保存操作日志到mysql数据库 源码
11-25
2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑实现 （需要知道原理的请看spring aop源码，此处不做赘述） 3、可在现有源码上快速进行功能扩展 4、spring boot，mybatis，druid，spring aop的使用
Spring+SpringMvc+MybatisPlus+Aop（自定义注解）动态切换数据源
12-25
本项目“Spring+SpringMvc+MybatisPlus+Aop（自定义注解）动态切换数据源”正是针对这一需求提供的一种解决方案。下面将详细介绍这个项目中的关键技术点和实现原理。 首先，Spring框架是Java企业级应用开发的核心...
详解springboot+aop+Lua分布式限流的最佳实践
08-19
本文主要介绍了springboot+aop+Lua分布式限流的最佳实践，涵盖了限流的定义、限流的重要性、限流方案等多个方面。 一、什么是限流？为什么要限流？ 限流是指限制系统处理请求的速度，以避免系统崩溃和超载。限流是...
SpringBoot基于RateLimiter+AOP动态的为不同接口限流
爱飞的笨鸟的博客
07-16 1207
公司需要对接第三方接口,每个接口都有频率限制,只好做下精准的限流,精准到方法,如果是服务的话Hystrix应该可以的,废话不多说,看了一篇不错的文章,亲测可行,记录一下. 1.首先接口限流算法： 1.计数器方式（传统计数器缺点：临界问题 可能违背定义固定速率原则） 2.令牌桶方式 3.漏桶方式 4.应用层限流（Nginx） 2.限流实现： 2.1. RateLimiter是gua...
蚂蚁课堂：自定义注解方式封装RateLimiter 限流
weixin_30404405的博客
04-03 177
1先自定义注解 @Target(value = ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface ExtRateLimiter { double value(); long timeOut(); } ...
ratelimit+aop自定义注解实现应用限流
菜鸟逆袭记
07-24 3322
1、基于springboot项目pom.xml添加如下依赖： &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-aop&lt;/artifactId&gt; &lt;/dependency&gt; &lt...
RateLimiter
justsomebody126的专栏
11-03 446
参考： https://www.jianshu.com/p/5d4fe4b2a726 https://blog.csdn.net/charleslei/article/details/53152883 Guava 的 RateLimiter 采用令牌桶算法 令牌桶算法的原理是系统会以一个恒定的速度往桶里放入令牌，而如果请求需要被处理，则需要先从桶里获取一个令牌，当桶里没有令牌可取时，则拒...
ratelimter
a6203649的专栏
06-13 304
ratelimter实现细节 参考：https://www.jianshu.com/p/3dfae5c15eb9 每次acquire去更新令牌&获取令牌 step1：更新令牌桶 根据时间点去补充令牌桶中的令牌数目，比如设定令牌桶速率为10个/s，上次更新令牌桶距离当前0.5s，则补充5个，距离1s，则补充10个。注意令牌桶中令牌数量不得超过令牌数目，速率为10个/s，那么令牌数目最大为10...
互联网并发与安全系列教程（03） - RateLimiter使用AOP方式实现限流
阿甘兄
11-18 441
在上一节，我们学习了限流的方案： 限流算法（如：令牌桶、漏桶、计数器） 应用层解决 接入层解决（如Nginx） 我们知道RateLimiter是guava提供的基于令牌桶算法的实现类，可以非常简单的完成限流，并且根据系统的实际情况来调整生成token的速率。本文通过仿写RateLimiter来实现限流，下面直接实现代码（讲解主要的代码）： 1.Controller层： @RequestMapp...
RateLimiter：结合Spring Aop应用，以及SmoothBursty原理分析
琦彦
12-21 1428
RateLimiter RateLimiter使用的是一种叫令牌桶的流控算法，RateLimiter会按照一定的频率往桶里扔令牌，线程拿到令牌才能执行，比如你希望自己的应用程序QPS不要超过1000，那么RateLimiter设置1000的速率后，就会每秒往桶里扔1000个令牌。 令牌桶算法 令牌桶算法概念如下： 令牌以固定速率生成； 生成的令牌放入令牌桶中存放，如果令牌桶满了则多余...
SpringBoot+AOP自定义权限注解
07-25
- *1* [springboot+mybatis+aop+注解实现数据权限](https://blog.csdn.net/weixin_42935902/article/details/116758260)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值