注解调用 计数器限流算法 令牌桶限流算法 漏桶限流算法 通过注解调用限流算法

已于 2023-08-04 10:41:03 修改
阅读量68 收藏
点赞数
文章标签： java 开发语言
于 2023-08-03 16:45:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Moonhwa/article/details/132086457
版权

测试类：

//package com.xxx.fxserver.service.utils.limiters;
//
//import com.xxx.fxserver.vo.LimiterEnum;
//
//import java.text.SimpleDateFormat;
//import java.util.Date;
//import java.util.concurrent.CountDownLatch;
//import java.util.concurrent.ExecutorService;
//import java.util.concurrent.Executors;
//import java.util.concurrent.atomic.AtomicInteger;
//
///**
// * @author jangwenhua
// * @description: 测试计数器限流算法
// * @date 2023-07-14 15:10
// */
//public class BaseLimitTest {
//
//    private MbLimiter limiter;
//    private int maxQPS;//填充速率
//
//    public BaseLimitTest(LimiterEnum type, int qps) {
//        this.limiter = MbLimiterFactory.getCountLimiter(type, qps);
//        this.maxQPS = qps;
//    }
//
//    public void test(boolean showLog) throws Exception {
//
//        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
//
//        final CountDownLatch countDownLatch1 = new CountDownLatch(100);
//        final CountDownLatch countDownLatch2 = new CountDownLatch(100);
//        final CountDownLatch countDownLatch3 = new CountDownLatch(100);
//
//        // 用于统计成功请求个数
//        AtomicInteger count1 = new AtomicInteger(0);
//        AtomicInteger count2 = new AtomicInteger(0);
//        AtomicInteger count3 = new AtomicInteger(0);
//
//        // 固定大小线程池
//        ExecutorService executorService = Executors.newFixedThreadPool(100);
//
//        System.out.println("====== Test 1 100 并发 ======");
//
//        // 获取开始时间
//        long startTime = System.currentTimeMillis();
//
//        // 前 1s 平均 50 次，随后不到 1s 内发起 50 次请求
//        for (int i = 0; i < 100; i++) {
//            executorService.execute(() -> {
//                if (limiter.tryAcquire()) {
//                    if (showLog)
//                        System.out.println("success " + sf.format(new Date()));
//                    count1.incrementAndGet();
//                } else {
//                    if (showLog)
//                        System.out.println("failed " + sf.format(new Date()));
//                }
//                countDownLatch1.countDown();
//            });
//            // 计数器算法最多请求20次，出现突刺现象
//            if (i < 50 || i > 80) {
//                Thread.sleep(20);
//            }
//        }
//
//        countDownLatch1.await();
//        System.out.println("Time Used: " + (System.currentTimeMillis() - startTime) / 1000.0 + " success: " + count1);
//
//        Thread.sleep(1000);
//        System.out.println("====== Test 2 每秒钟请求 10 次  ======");
//
//        startTime = System.currentTimeMillis();
//
//        // 功能性测试，每秒平均 10 次请求
//        for (int i = 0; i < 100; i++) {
//            executorService.execute(() -> {
//                if (limiter.tryAcquire()) {
//                    if (showLog)
//                        System.out.println("success " + sf.format(new Date()));
//                    count2.incrementAndGet();
//                } else {
//                    if (showLog)
//                        System.out.println("failed " + sf.format(new Date()));
//                }
//                countDownLatch2.countDown();
//            });
//            // 每 10 次请求延时 1 秒
            if ((i + 1) % 10 == 0) {
                Thread.sleep(1000);
            }
//            Thread.sleep(100);
//        }
//
//        countDownLatch2.await();
//        System.out.println("Time Used: " + (System.currentTimeMillis() - startTime) / 1000.0 + " success: " + count2);
//
//        Thread.sleep(1000);
//        System.out.println("====== Test 3 每秒钟请求 20 次  ======");
//
//        startTime = System.currentTimeMillis();
//
//        // 前 4.5s 平均每秒 20 次请求，4.5s 后并发请求 10 次
//        for (int i = 0; i < 100; i++) {
//            executorService.execute(() -> {
//                if (limiter.tryAcquire()) {
//                    if (showLog)
//                        System.out.println("success " + sf.format(new Date()));
//                    count3.incrementAndGet();
//                } else {
//                    if (showLog)
//                        System.out.println("failed " + sf.format(new Date()));
//                }
//                countDownLatch3.countDown();
//            });
            // 每 10 次请求延时 1 秒
            if ((i + 1) % 20 == 0) {
                Thread.sleep(1000);
            }
//            // 测试下令牌桶算法瞬时处理一定量的请求
//            if (i < 90) {
//                Thread.sleep(50);
//            }
//        }
//
//        countDownLatch3.await();
//        System.out.println("Time Used: " + (System.currentTimeMillis() - startTime) / 1000.0 + " success: " + count3);
//        executorService.shutdown();
//
//    }
//}

枚举算法类型：

package com.xxx.fxserver.vo;

public enum LimiterEnum {
     COUNT_LIMITER,//计数器限流算法
     LEAKY_BUCKET_LIMITER,//可重入锁 漏桶限流算法
     TOKEN_BUCKET_LIMITER//令牌桶限流算法
}

计数器： 

package com.xxx.fxserver.service.utils.limiters;


/**
 * @author jangwenhua
 * @description: 计数器限流算法
 * @date 2023-07-14 15:10
 */
public class CountLimiter extends MbLimiter {

    private int count;                          // 计数器
    private long lastTime;                      // 时间戳

    public CountLimiter(int qps) {
        super(qps);
        count = 0;
        lastTime = 0;
    }

    @Override
    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        if (now - lastTime > 1000) {
            lastTime = now>>3<<3;               // 保证时间戳后三位都是0, 更精确
            count = 1;
            return true;
        } else if (count < qps) {
            count++;
            return true;
        } else {
            return false;
        }
    }
}

 漏桶算法：

package com.xxx.fxserver.service.utils.limiters;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author jangwenhua
 * @description: 漏桶限流算法
 * @date 2023-07-14 15:10
 */
public class LeakyBucketLimiter extends MbLimiter {

    private final long capacity;                                            // 水桶容量, 一秒流光
    private double remainWater;                                             // 目前水桶剩下的水量
    private long lastTime;                                                  // 时间戳
    private ReentrantLock lock = new ReentrantLock();                       // 可重入锁

    LeakyBucketLimiter(int qps) {
        super(qps);
        capacity = qps;
        remainWater = capacity;
        lastTime = 0;
    }

    @Override
    public boolean tryAcquire() {
        lock.lock();
        try {
            long now = System.currentTimeMillis();
            double outWater = ((now - lastTime)/1000.0) * capacity;         // 计算这段时间匀速流出的水
            lastTime = now;
            remainWater = Math.max(0, remainWater - outWater);
            if (remainWater + 1 <= capacity) {
                remainWater += 1;
                long waitingMs = (long)((remainWater / capacity) * 1000);   // 计算刚加入的水滴完全滴出漏桶需要的时间（毫秒）
                lock.unlock();
                try {
                    Thread.sleep(waitingMs);                                // 为实现匀速处理请求，需要阻塞一段时间后再return
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return true;
            } else return false;
        } finally {
            if (lock.isLocked()) lock.unlock();
        }
    }


    //    @Override
//    public synchronized boolean tryAcquire() {
//        long now = System.currentTimeMillis();
//        double outWater = ((now - lastTime)/1000.0)*capacity;           // 计算这段时间匀速流出的水
//        lastTime = now;
//        if (outWater > remainWater) {
//            // 请求已全部处理完毕
//            remainWater = 1;
//            return true;
//        } else {
//            // 还有未处理的请求
//            remainWater -= outWater;
//            if (remainWater + 1 <= capacity) {
//                remainWater += 1;
//                return true;
//            } else return false;
//        }
//    }
//}
}

 令牌桶算法：

package com.xxx.fxserver.service.utils.limiters;

/**
 * @author jangwenhua
 * @description: 令牌桶限流算法
 * @date 2023-07-14 15:10
 */
public class TokenBucketLimiter extends MbLimiter {

    private final int capacity;                             // 桶内能装多少令牌
    private double curTokenNum;                             // 现在桶内令牌数量(用double存)
    private long lastTime;                                  // 时间戳

    TokenBucketLimiter(int qps) {
        super(qps);
        capacity = qps;
        curTokenNum = 0;
        lastTime = 0;
    }

    @Override
    public synchronized boolean tryAcquire() {
        long now = System.currentTimeMillis();
        double intoToken = (now - lastTime)/1000.0 * capacity;
        lastTime = now;
        if (intoToken + curTokenNum > capacity) {
            // 令牌已放满
            curTokenNum = capacity - 1;
            return true;
        } else if (intoToken + curTokenNum >= 1) {
            // 还有令牌
            curTokenNum += intoToken - 1;
            return true;
        } else {
            curTokenNum += intoToken;
            return false;
        }
    }
}

限流器抽象父类： 

package com.xxx.fxserver.service.utils.limiters;


/**
 * @author jangwenhua
 * @description: 限流器抽象父类
 * @date 2023-07-14 15:10
 */
public abstract class MbLimiter {

    final int qps;//填充速率

    MbLimiter(int qps) {
        this.qps = qps;
    }

    // 获取继续执行的资格（非阻塞）立刻返回成功或失败
    public abstract boolean tryAcquire();

}

 限流器工厂类：

package com.xxx.fxserver.service.utils.limiters;

import com.xxx.fxserver.vo.LimiterEnum;

/**
 * @author jangwenhua
 * @description: 限流器工厂类
 * @date 2023-07-14 15:10
 */
public class MbLimiterFactory {

    public static MbLimiter getCountLimiter(LimiterEnum limiterEnum, int qps) {
        switch (limiterEnum) {
            case COUNT_LIMITER:
                return new CountLimiter(qps);
            case LEAKY_BUCKET_LIMITER:
                return new LeakyBucketLimiter(qps);
            case TOKEN_BUCKET_LIMITER:
                return new TokenBucketLimiter(qps);
            default:
                return null;
        }
    }

}

 定义注解调用参数：

package com.xxx.fxserver.service.utils.limiters;

import com.xxx.fxserver.vo.LimiterEnum;

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)//注解会在class中存在，运行时可通过反射获取
@Target(ElementType.METHOD)//目标是方法
@Documented//文档生成时，该注解将被包含在javadoc中，可去掉
public @interface MbLimiters {
    /**
     * 类型
     */
    LimiterEnum type() default LimiterEnum.COUNT_LIMITER;
    /**
     * 一秒流数
     */
    int qps() default 10;

}

 注解切面核心代码：

package com.xxx.fxserver.service.utils.limiters;

import com.xxx.fxserver.common.exception.BusinessException;
import com.xxx.fxserver.vo.LimiterEnum;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;

@Aspect
@Component
@Slf4j
public class MbLimitersAspect {

    @Pointcut("@annotation(com.xxx.fxserver.service.utils.limiters.MbLimiters)")
    public void controllerAspect() { }

    @Around("controllerAspect()")
    public Object aroundMethod(ProceedingJoinPoint jp) throws Throwable {
        boolean showLog =true;
        MbLimiter limiter = giveController(jp);
        //执行方法
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
            if (limiter.tryAcquire()) {
                if (showLog)
                    log.info("success " + sf.format(new Date()));
            } else {
                if (showLog)
                    log.info("failed " + sf.format(new Date()));
                throw new BusinessException("请重新尝试!");
            }
        return jp.proceed();
    }

    private MbLimiter giveController(ProceedingJoinPoint joinPoint) throws Exception {
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        if (method != null) {
            MbLimiters limiters = method.getAnnotation(MbLimiters.class);
            MbLimiter limiter = this.getCountLimiter(limiters.type(),limiters.qps());
            return limiter;
        }
        return null;
    }

    public static MbLimiter getCountLimiter(LimiterEnum limiterEnum, int qps) {
        switch (limiterEnum) {
            case COUNT_LIMITER:
                return new CountLimiter(qps);
            case LEAKY_BUCKET_LIMITER:
                return new LeakyBucketLimiter(qps);
            case TOKEN_BUCKET_LIMITER:
                return new TokenBucketLimiter(qps);
            default:
                return null;
        }
    }

}

 接口调用注解方式:

    @PostMapping(value = "/getQrcode")
    @MbLimiters(type = LimiterEnum.TOKEN_BUCKET_LIMITER,qps = 80)
    public ResultVo getQrcode(@RequestBody Map<String, Object> params) throws IOException {
return null;
}

三斤老陈姜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
springboot注解+aop实现接口限流
09-07
springboot框架中使用自定义注解，配合切面实现接口限流，增加ip黑名单功能，可实现ip+账号+接口进黑名单，也可以实现账号+ip进黑名单及禁用账号； 可以学会自定义注解使用、自定义响应码枚举及使用、自定义异常类及...
基于令牌桶算法实现的SpringBoot无锁限流插件
08-07
开发者可以通过阅读源码了解其实现细节，例如如何创建和维护令牌桶，如何实现无锁的数据结构，以及如何与SpringBoot的AOP（面向切面编程）机制相结合，实现注解驱动的限流功能。 总结来说，基于令牌桶算法的...
Sentinel实现限流
11-03
你可以设置不同的限流策略，例如固定窗口限流、滑动窗口限流等，这些策略基于不同的算法实现，如计数器算法、令牌桶算法和漏桶算法。这些算法可以帮助Sentinel在达到设定阈值时，以平滑的方式限制或拒绝新的请求。 ...
Springboot使用redis进行api防刷限流过程详解
08-25
Spring Boot 结合 Redis 实现 API 防刷限流的过程主要涉及到两个核心概念：限流算法和缓存机制。在本文中，我们将深入探讨如何利用 Redis 的存储特性以及 Spring Boot 的强大框架支持来构建一个高效的 API 限流系统...
Spring Cloud Alibaba使用Sentinel实现接口限流
08-26
然后，在应用程序中使用 @SentinelResource 注解来标注需要限流的接口。Sentinel 会根据配置的规则来限流接口。 Sentinel 的规则配置可以通过 Sentinel Dashboard 来完成。Sentinel Dashboard 提供了可视化的界面来...
配置Java开发环境
Broken_x的博客
07-10 1431
Java开发环境配置
java集合工具类
最新发布
hejiefeng111的博客
07-12 227
【代码】java集合工具类。
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 288
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 412
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1400
在 Java 中，可以通过多种方法将一个Object转换为Integer。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 2202
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java占位符替换五种方式
weixin_61478518的博客
07-08 519
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
elk部署springboot
Chihirozy的博客
07-11 175
elk部署springboot。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 3255
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
springboot中抽离日志
qq_24223159的博客
07-08 388
【代码】springboot中抽离日志。
深入剖析 Java 中 Spring Bean 的生命周期
weixin_42545951的博客
07-12 513
在 Java 开发中，Spring 框架是广泛使用的企业级应用开发框架。理解 Spring Bean 的生命周期对于开发者来说至关重要，这也是面试中经常会被问到的重要知识点。
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
牛马程序员的博客
07-10 750
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
项目实战--XML文档解析工具
qq_40623672的博客
07-11 714
XML (eXtensible Markup Language)指可扩展标记语言，标准通用标记语言的子集，可以标记数据、定义数据类型，可以允许自定义标记语言进行数据承载，通常被用来传输和存储数据，定义也简单，遵循核心DTD（文档类型定义）语法约束。> < site > < name > CSDN博客网站 </ name > < url > https://blog.csdn.net/ </ url > < desc > 技术学习网站 </ desc > </ site >
学习mybatis
weixin_45621552的博客
07-08 681
【代码】学习mybatis。
springboot注解实现redis限流
04-20
SpringBoot注解实现Redis限流可以使用@RedisRateLimiter注解和自定义一个Aspect类实现。@RedisRateLimiter注解可以设置限流的时间单位、阈值以及针对哪个API进行限流。自定义的Aspect类则可以将注解解析出来，并使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值