【SpringBoot框架篇】10.API接口限流实战

已于 2024-01-10 19:57:14 修改
阅读量1w 收藏 74
点赞数 19
分类专栏： SpringBoot 文章标签： spring boot java
于 2020-05-21 23:59:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ming19951224/article/details/106227451
版权

文章目录

1.简介

对接口限流的目的是通过对并发访问/请求进行限速，或者对一个时间窗口内的请求进行限速来保护系统，一旦达到限制速率则可以拒绝服务、排队或等待、降级等处理

2.限流算法

常用的限流算法由：漏桶算法和令牌桶算法。

2.1.漏桶算法

漏桶(Leaky Bucket)算法思路很简单,水(请求)先进入到漏桶里,漏桶以一定的速度出水(接口有响应速率),当水流入速度过大会直接溢出(访问频率超过接口响应速率),然后就拒绝请求,可以看出漏桶算法能强行限制数据的传输速率.示意图如下:
在这里插入图片描述

2.2.令牌桶算法

令牌桶算法的原理是系统会以一个恒定的速度往桶里放入令牌，而如果请求需要被处理，则需要先从桶里获取一个令牌，当桶里没有令牌可取时，则拒绝服务，令牌桶算法通过发放令牌，根据令牌的rate频率做请求频率限制，容量限制等

在这里插入图片描述

3.基于guava的RateLimiter实现

RateLimiter控制的是访问速率,RateLimiter是令牌桶算法的一种实现方式

3.1.常用方法

方法描述
create(int permits)创建每秒发放permits个令牌的桶
acquire()不带参数表示获取一个令牌.如果没有令牌则一直等待,返回等待的时间(单位为秒),没有被限流则直接返回0.0
acquire(int permits )获取permits 个令牌,.如果没有获取完令牌则一直等待,返回等待的时间(单位为秒),没有被限流则直接返回0.0
tryAcquire()尝试获取一个令牌,立即返回(非阻塞)
tryAcquire(int permits)尝试获取permits 个令牌,立即返回(非阻塞)
tryAcquire(long timeout, TimeUnit unit)尝试获取1个令牌,带超时时间
tryAcquire(int permits, long timeout, TimeUnit unit)尝试获取permits个令牌,带超时时间

获取令牌方法源码如下

   @CanIgnoreReturnValue
    public double acquire() {
        return this.acquire(1);
    }

    @CanIgnoreReturnValue
    public double acquire(int permits) {
        long microsToWait = this.reserve(permits);
        this.stopwatch.sleepMicrosUninterruptibly(microsToWait);//会进行线程休眠
        return 1.0D * (double)microsToWait / (double)TimeUnit.SECONDS.toMicros(1L);
    }
    
    public boolean tryAcquire() {
        return this.tryAcquire(1, 0L, TimeUnit.MICROSECONDS);
    }

    public boolean tryAcquire(int permits, long timeout, TimeUnit unit) {
        long timeoutMicros = Math.max(unit.toMicros(timeout), 0L);
        checkPermits(permits);
        long microsToWait;
        synchronized(this.mutex()) {
            long nowMicros = this.stopwatch.readMicros();
            //无参的tryAcquire方法默认的超时时间设置是0,如果在这里没有立即获取到令牌,会直接返回获取令牌失败
            if (!this.canAcquire(nowMicros, timeoutMicros)) {
                return false;
            }

            microsToWait = this.reserveAndGetWaitLength(permits, nowMicros);
        }

        this.stopwatch.sleepMicrosUninterruptibly(microsToWait);
        return true;
    }

3.2.main函数版本

    public static void main(String[] args) {
        SimpleDateFormat sdf=new SimpleDateFormat("HH:mm:ss");
        long begin = System.currentTimeMillis();
        // 每秒允许发放1个令牌
        double permits=1.0;
        RateLimiter limiter = RateLimiter.create(permits);
        for (int i = 1; i <= 10; i++) {
            // 获取i个令牌, 当i超过permits会被阻塞
            double waitTime = limiter.acquire(i);
            System.out.println("curTime=" + sdf.format(new Date()) + " call index:" + i + " waitTime:" + waitTime);
        }
        long end =  System.currentTimeMillis();
        System.out.println("begin time:" + sdf.format(new Date(begin))+",end time:"+sdf.format(new Date(end))+",Total task time："+(end-begin));
    }

测试结果如下
当i等于1的时候,直接获取到了令牌,当i大于1的时候会随着i的增长,获取令牌的等待时间也在增长
在这里插入图片描述

3.3.API接口限流实战

通关aop实现对接口的限流

3.3.1.引入依赖

		 <!-- guava 限流 -->
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>25.1-jre</version>
        </dependency>
        <!--aop切面-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>

3.3.2.自定义注解

该注解主要用于AOP功能的切入,不需要属性

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

    String limitKey() default ""; //限流的方法名

    double value()  default 0d;  //发放的许可证数量
}

3.3.3.自定义切面类

通过limiter.acquire()来获取令牌，当然也可以通过tryAcquire(int permits, long timeout, TimeUnit unit)来设置等待超时时间的方式获取令牌，如果超timeout为0或则调用无参的tryAcquire()，则代表非阻塞，获取不到立即返回，支持阻塞或可超时的令牌消费。

@Component
@Scope
@Aspect
public class RateLimitAspect {

    /**
     * 存储限流量和方法必须是static且线程安全
     */
    public static Map<String, RateLimiter> rateLimitMap = new ConcurrentHashMap<>();

    /**
     * 业务层切点
     */
    @Pointcut("@annotation(com.ljm.boot.apilimit.limit.RateLimit)")
    public void ServiceAspect() {
    }

    @Around("ServiceAspect()")
    public Object around(ProceedingJoinPoint joinPoint) {
        Object obj = null;
        try {
            //获取目标对象
            Class<?> clz = joinPoint.getTarget().getClass();
            //tryAcquire()是非阻塞, rateLimiter.acquire()是阻塞的
            Signature signature = joinPoint.getSignature();
            String name = signature.getName();
            String limitKey = getLimitKey(clz, name);
            RateLimiter rateLimiter = rateLimitMap.get(limitKey);
            if (rateLimiter.tryAcquire()) {
                obj = joinPoint.proceed();
            } else {
                //拒绝了请求（服务降级）
                obj = "The system is busy, please visit after a while";
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return obj;
    }

    private String getLimitKey(Class<?> clz, String methodName) {
        for (Method method : clz.getDeclaredMethods()) {
            //找出目标方法
            if (method.getName().equals(methodName)) {
                //判断是否是限流方法
                if (method.isAnnotationPresent(RateLimit.class)) {
                    String key= method.getAnnotation(RateLimit.class).limitKey();
                    if(key.equals("")){
                        key=method.getName();
                    }
                    return key;
                }
            }
        }
        return null;
    }
}

3.3.4.初始化限流的许可证数量

/**
 * @author Dominick Li
 * @CreateTime 2020/5/2 12:35
 * @description 初始化需要SemaphoreLimit限流的许可证数量
 **/
@Component
public class InitRateLimit implements ApplicationContextAware {

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, Object> beanMap = applicationContext.getBeansWithAnnotation(RestController.class);
        beanMap.forEach((k, v) -> {
            Class<?> controllerClass = v.getClass();
            System.out.println(controllerClass.toString());
            System.out.println(controllerClass.getSuperclass().toString());
            //获取所有声明的方法
            Method[] allMethods = controllerClass.getSuperclass().getDeclaredMethods();
            for (Method method : allMethods) {
                //判断方法是否使用了限流注解
                if (method.isAnnotationPresent(RateLimit.class)) {
                    //获取配置的限流量,实际值可以动态获取,配置key,根据key从配置文件获取
                    double value = method.getAnnotation(RateLimit.class).value();
                    String key = method.getAnnotation(RateLimit.class).limitKey();
                    if(key.equals("")){
                        key=method.getName();
                    }
                    System.out.println("RatelimitKey:" +key+",许可证数是"+value);
                    //key作为key.value为具体限流量,传递到切面的map中
                    RateLimitAspect.rateLimitMap.put(key, RateLimiter.create(value));
                }
            }
        });
    }
}

3.3.5.web接口

@RestController
public class LimitTestController {

    @RateLimit(value =3)
    @RequestMapping("/ratelimit")
    public String ratelimit() throws Exception{
     	//假设业务处理了1秒
        TimeUnit.SECONDS.sleep(1);
        return "success";
    }
}

3.3.6.压测

    public static void main(String[] args) throws Exception {
        ///设置线程池最大执行20个线程并发执行任务
        int threadSize = 20;
        //AtomicInteger通过CAS操作能保证统计数量的原子性
        AtomicInteger successCount = new AtomicInteger(0);
        CountDownLatch downLatch = new CountDownLatch(20);
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(threadSize);
        for (int i = 0; i < threadSize; i++) {
            fixedThreadPool.submit(() -> {
                RestTemplate restTemplate = new RestTemplate();
                String str = restTemplate.getForObject("http://localhost:8010/ratelimit", String.class);
                if ("success".equals(str)) {
                    successCount.incrementAndGet();
                }
                System.out.println(str);
                downLatch.countDown();
            });
        }
        //等待所有线程都执行完任务
        downLatch.await();
        fixedThreadPool.shutdown();
        System.out.println("总共有" + successCount.get() + "个线程获得到了令牌!");
    }

可以看到大部分请求直接被拒绝了，只有4个线程获取到了令牌
在这里插入图片描述

4.基于Semaphore控制并发数

Semaphore(信号量)，是用来控制同时访问特定资源的线程数量，它通过计数来协调各个线程，以保证合理的使用公共资源。我的理解是：信号量控制着一个线程池中并发线程的数量。就好像我们去一家饭店吃饭，这家饭店最多可以同时供应50人，如果饭店中已经坐满50人，这时新来的客人就必须等待，直到有客人离开他们才可以进入，并且总的数量不可以超过50人。这里饭店就好比线程池，饭店里的服务人员和厨师就好比共享的资源，每个客人都相当于一个线程, semaphore就记录着里面的人数，要根据semaphore的数量来决定是否让新的客人进入。为了得到一个资源，每个线程都要先获取permit，以确保当前可以访问。

4.1.常用方法

方法描述
acquire()从许可集中请求获取一个许可，此时当前线程开始阻塞，直到获得一个可用许可，或者当前线程被中断。
acquire(int permits)从许可集中请求获取指定个数(permits)的许可，此时当前线程开始阻塞，直到获得指定数据(permits)可用许可，或者当前线程被中断。
release()释放一个许可，将其返回给许可集。
release(int permits)释放指定个数(permits)许可，将其返回给许可集。
tryAcquire()尝试获取一个可用许可，如果此时有一个可用的许可，则立即返回true，同时许可集中许可个数减一；如果此时许可集中无可用许可，则立即返回false。
tryAcquire(int permits)尝试获取指定个数(permits)可用许可，如果此时有指定个数(permits)可用的许可，则立即返回true，同时许可集中许可个数减指定个数(permits)；如果此时许可集中许可个数不足指定个数(permits)，则立即返回false。
tryAcquire(long timeout, TimeUnit unit)在给定的等待时间内，尝试获取一个可用许可，如果此时有一个可用的许可，则立即返回true，同时许可集中许可个数减一；如果此时许可集中无可用许可，当前线程阻塞，直至其它某些线程调用此Semaphore的release()方法并且当前线程是下一个被分配许可的线程，或者其它某些线程中断当前线程或者已超出指定的等待时间
tryAcquire(int permits, long timeout, TimeUnit unit)在给定的等待时间内，尝试获取指定个数(permits)可用许可，如果此时有指定个数(permits)可用的许可，则立即返回true，同时许可集中许可个数减指定个数(permits)；如果此时许可集中许可个数不足指定个数(permits)，当前线程阻塞，直至其它某些线程调用此Semaphore的release()方法并且当前线程是下一个被分配许可的线程并且许可个数满足指定个数，或者其它某些线程中断当前线程，或者已超出指定的等待时间。

4.2.main函数版本

下面代码设置了20个线程并发执行任务,但是通过Semaphore 设置只允许5个并发的执行

public class SemaphoreTest {

    private final static Semaphore permit = new Semaphore(5);

    public static void main(String[] args) {
        //设置线程池最大执行20个线程并发执行任务
        int threadSize = 20;
        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(threadSize);
        for (int i = 0; i < threadSize; i++) {
            fixedThreadPool.submit(() -> {
                try {
                    //获取令牌
                    permit.acquire();
                    Thread.sleep(1L);
                    //业务逻辑处理
                    System.out.println("处理任务的线程是" + Thread.currentThread().getId() + ",当前时间是" + System.currentTimeMillis());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    //释放令牌
                    permit.release();
                }
            });
        }
    }
}

执行结果
通过下图可以看到,每毫秒只有5个线程在执行任务
在这里插入图片描述

4.3.API接口限流实战

4.3.1.引入依赖

     <!--aop切面-->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>

4.3.2.自定义注解

@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface SemaphoreLimit {

    String limitKey() default ""; //限流的方法名

    int value()  default 0;  //发放的许可证数量

}

4.3.3.自定义切面类

@Component
@Scope
@Aspect
public class SemaphoreLimitAspect {
    
    /**
     * 存储限流量和方法必须是static且线程安全
     */
    public static Map<String, Semaphore> semaphoreMap = new ConcurrentHashMap<>();

    /**
     * 业务层切点
     */
    @Pointcut("@annotation(com.ljm.boot.ratelimit.limit.SemaphoreLimit)")
    public void ServiceAspect() {

    }

    @Around("ServiceAspect()")
    public Object around(ProceedingJoinPoint joinPoint) {
        //获取目标对象
        Class<?> clz = joinPoint.getTarget().getClass();
        //获取增强方法信息
        Signature signature = joinPoint.getSignature();
        String name = signature.getName();
        String limitKey = getLimitKey(clz, name);
        Semaphore semaphore = semaphoreMap.get(limitKey);
        //立即获取许可证,非阻塞
        boolean flag = semaphore.tryAcquire();
        Object obj = null;
        try {
            //拿到许可证则执行任务
            if (flag) {
                obj = joinPoint.proceed();
            } else {
                //拒绝了请求（服务降级）
                obj = "limitKey:"+limitKey+", The system is busy, please visit after a while";
            }
        } catch (Throwable e) {
            e.printStackTrace();
        } finally {
            if (flag) semaphore.release(); //拿到许可证后释放通行证
        }
        return obj;
    }

    /**
     * 获取拦截方法配置的限流key,没有返回null
     */
    private String getLimitKey(Class<?> clz, String methodName) {
        for (Method method : clz.getDeclaredMethods()) {
            //找出目标方法
            if (method.getName().equals(methodName)) {
                //判断是否是限流方法
                if (method.isAnnotationPresent(SemaphoreLimit.class)) {
                    String key= method.getAnnotation(SemaphoreLimit.class).limitKey();
                    if(key.equals("")){
                        key=method.getName();
                    }
                    return key;
                }
            }
        }
        return null;
    }
}

4.3.4.初始化限流的许可证数量

@Component
public class InitSemaphoreLimit implements ApplicationContextAware {

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, Object> beanMap = applicationContext.getBeansWithAnnotation(RestController.class);
        beanMap.forEach((k, v) -> {
            Class<?> controllerClass = v.getClass();
            System.out.println(controllerClass.toString());
            System.out.println(controllerClass.getSuperclass().toString());
            //获取所有声明的方法
            Method[] allMethods = controllerClass.getSuperclass().getDeclaredMethods();
            for (Method method : allMethods) {
                System.out.println(method.getName());
                //判断方法是否使用了限流注解
                if (method.isAnnotationPresent(SemaphoreLimit.class)) {
                    //获取配置的限流量,实际值可以动态获取,配置key,根据key从配置文件获取
                    int value = method.getAnnotation(SemaphoreLimit.class).value();
                    String key = method.getAnnotation(SemaphoreLimit.class).limitKey();
                    if(key.equals("")){
                        key=method.getName();
                    }
                    System.out.println("SemaphoreLimitKey:" +key+",许可证数是"+value);
                    //key作为key.value为具体限流量,传递到切面的map中
                    SemaphoreLimitAspect.semaphoreMap.put(key, new Semaphore(value));
                }
            }
        });
    }
}

4.3.5.web接口

@RestController
public class LimitTestController {
	
	 /**
     * 设置limitKey=SemaphoreKey,并且许可证只有3个
     */
    @SemaphoreLimit(limitKey ="semaphoreKey", value =3)
    @RequestMapping("/semaphoreLimit")
    public String semaphoreLimit() throws Exception{
        //假设业务处理了1秒
        TimeUnit.SECONDS.sleep(1);
        return "success";
    }
}

4.3.6.压测

和标题3.3.6一样,把接口名称改成semaphoreLimit即可。
测试结果如下图
因为我们在调用web接口时候线程休眠了1秒,所以20个线程并发处理任务的时候,只有3个获取到个许可证,
和我们预期的结果一致.
在这里插入图片描述

5.基于redission的RateLimiter实现分布式限流

  • Redission是Redis官方推荐的客户端,其中RateLimiter实现和guava的RateLimiter类似都是是要令牌桶算法实现限流，
  • guava基于内存只能实现单节点的限流,Redission基于redis缓存数据库可以实现分布式限流。

下面示例设置的是限流的接口名称为rate_limiter，限流模式为所有实例共享,时间窗口2秒内流出10个令牌。

  • 根据key创建限流对象: client.getRateLimiter(key);
  • 设置限流参数: rRateLimiter.trySetRate(RateType.PER_CLIENT, 10，2, RateIntervalUnit.SECONDS);第一个参数表示限流模式，第二个参数表示令牌数，第三个是时间，第四个是时间单位。
  • 限流模式包括: RateType.PER_CLIENT(单实例共享),RateType.OVERALL=所有实例共享。
  • Redission的RRateLimiter和guava的RateLimiter接口函数大部分类似,就不过多再描述了。
    在这里插入图片描述

5.1.main函数版本

Main函数测试

    public static void main(String[] args) throws Exception {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        RedissonClient client = Redisson.create(config);
        RRateLimiter rateLimiter = client.getRateLimiter("rate_limiter");
        Integer threadSize=20;
        //访问模式    访问数 访问速率  访问时间
        //访问模式 RateType.PER_CLIENT=单实例共享     RateType.OVERALL=所有实例共享
        rateLimiter.trySetRate(RateType.OVERALL, 10, 2, RateIntervalUnit.SECONDS);
        ExecutorService executorService = Executors.newFixedThreadPool(threadSize);
        CountDownLatch downLatch = new CountDownLatch(threadSize);
        AtomicInteger successCount = new AtomicInteger(0);
        for (int i = 0; i < threadSize; i++) {
            executorService.submit(() -> {
                try {
                    if(rateLimiter.tryAcquire()){
                        successCount.incrementAndGet();
                        System.out.println("处理任务的线程是" + Thread.currentThread().getId() + ",当前时间是" + System.currentTimeMillis());
                    }
                    downLatch.countDown();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
        }
        downLatch.await();
        System.out.println(successCount.get());
    }

测试效果如下
在这里插入图片描述

5.2.API接口限流实战

5.2.1.引入依赖

       <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.17.6</version>
        </dependency>

5.2.2.自定义注解

@Target({ElementType.PARAMETER, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RedisRateLimit {

    String limitKey() default ""; //限流的方法名

    int time() default  1; //默认设置为1秒

    int value()  default 3;  //发放的许可证数量
}

5.2.3.自定义切面类

@Component
@Scope
@Aspect
public class RedisRateLimitAspect {

    /**
     * 存储限流量和方法必须是static且线程安全
     */
    public static Map<String, RRateLimiter> rateLimitMap = new ConcurrentHashMap<>();

    /**
     * 业务层切点
     */
    @Pointcut("@annotation(com.ljm.boot.apilimit.limit.RedisRateLimit)")
    public void ServiceAspect() {
    }

    @Around("ServiceAspect()")
    public Object around(ProceedingJoinPoint joinPoint) {
        Object obj = null;
        try {
            //获取目标对象
            Class<?> clz = joinPoint.getTarget().getClass();
            //tryAcquire()是非阻塞, rateLimiter.acquire()是阻塞的
            Signature signature = joinPoint.getSignature();
            String name = signature.getName();
            String limitKey = getLimitKey(clz, name);
            RRateLimiter rateLimiter = rateLimitMap.get(limitKey);
            if (rateLimiter.tryAcquire()) {
                obj = joinPoint.proceed();
            } else {
                //拒绝了请求（服务降级）
                obj = "The system is busy, please visit after a while";
            }
        } catch (Throwable e) {
            e.printStackTrace();
        }
        return obj;
    }

    private String getLimitKey(Class<?> clz, String methodName) {
        for (Method method : clz.getDeclaredMethods()) {
            //找出目标方法
            if (method.getName().equals(methodName)) {
                //判断是否是限流方法
                if (method.isAnnotationPresent(RedisRateLimit.class)) {
                    String key= method.getAnnotation(RedisRateLimit.class).limitKey();
                    if(key.equals("")){
                        key=method.getName();
                    }
                    return key;
                }
            }
        }
        return null;
    }
}

5.2.4.初始化限流的许可证数量

@Component
public class InitRedisRateLimit implements ApplicationContextAware {

    @Autowired
    private RedissonClient client;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, Object> beanMap = applicationContext.getBeansWithAnnotation(RestController.class);
        beanMap.forEach((k, v) -> {
            Class<?> controllerClass = v.getClass();
            System.out.println(controllerClass.toString());
            System.out.println(controllerClass.getSuperclass().toString());
            //获取所有声明的方法
            Method[] allMethods = controllerClass.getSuperclass().getDeclaredMethods();
            RedisRateLimit redisRateLimit;
            RRateLimiter rRateLimiter;
            for (Method method : allMethods) {
                //判断方法是否使用了限流注解
                if (method.isAnnotationPresent(RedisRateLimit.class)) {
                    //获取配置的限流量,实际值可以动态获取,配置key,根据key从配置文件获取
                    redisRateLimit = method.getAnnotation(RedisRateLimit.class);
                    String key = redisRateLimit.limitKey();
                    if (key.equals("")) {
                        key = method.getName();
                    }
                    System.out.println("RedisRatelimitKey:" + key + ",许可证数是" + redisRateLimit.value());
                    //key作为key.value为具体限流量,传递到切面的map中
                    rRateLimiter = client.getRateLimiter(key);
                    //访问模式    访问数 访问速率  访问时间
                    //访问模式分为 RateType.PER_CLIENT=单实例共享     RateType.OVERALL=所有实例共享
                    rRateLimiter.trySetRate(RateType.OVERALL, redisRateLimit.value(), redisRateLimit.time(), RateIntervalUnit.SECONDS);
                    RedisRateLimitAspect.rateLimitMap.put(key, rRateLimiter);
                }
            }
        });
    }
}

5.2.5.Web接口

    /**
     * 设置limitKey=redisRatelimit,并且每2秒许可证只有5个
     */
    @RedisRateLimit(limitKey = "redisRatelimit",value =5,time = 2)
    @RequestMapping("/redisRatelimit")
    public String redisRatelimit() throws Exception{
        //假设业务处理了1秒
        TimeUnit.SECONDS.sleep(1);
        return "success";
    }

压测和标题3.3.6代码一样,把接口名称改成redisRatelimit即可。

6.项目配套代码

gitee代码地址

创作不易,要是觉得我写的对你有点帮助的话,麻烦在gitee上帮我点下 Star

【SpringBoot框架篇】其它文章如下,后续会继续更新。

皓亮君
关注
专栏目录
Springboot实现令牌桶限流
moni_mm的博客
08-24 6168
在对一个秒杀系统进行限流，感觉计数法太过于简单粗暴，便实现一个简单的令牌桶限流 令牌桶 大小固定的令牌桶可自行以恒定的速率源源不断地产生令牌。如果令牌不被消耗，或者被消耗的速度小于产生的速度，令牌就会不断地增多，直到把桶填满。后面再产生的令牌就会从桶中溢出。最后桶中可以保存的最大令牌数永远不会超过桶的大小。 设计思路 实现令牌桶类 用HashMap&amp;amp;lt;&amp;amp;gt;存储多个桶，...
Springboot接口限流
chrishe751的博客
07-23 2029
最近监控到公司服务器内存持续高占比，造成应用卡顿，经过分析日志发现是恶意的频繁的请求造成的。 互联网公司工作，很难避免这种情况。参见：https://blog.csdn.net/ityouknow/article/details/104666810?utm_medium=distribute.pc_relevant_right.none-task-blog-BlogCommendFromMachineLearnPai2-14.nonecase&depth_1-utm_source=distribu.
springboot 限流方案
qq_41482600的博客
06-28 1636
在大多数的微服务架构在设计之初，比如在技术选型阶段，架构师会从一个全局的视角去规划技术栈的组合，比如结合当前产品的现状考虑是使用dubbo？还是springcloud？作为微服务治理的底层框架。甚至为了满足快速的上线、迭代和交付，直接以springboot为基座进行开发，后续再引入新的技术栈等...所以在谈论某个业务场景具体的技术解决方案时不可一概而论，而是需要结合产品和业务的现状综合评估，以限流来说，在下面的不同的技术架构下具体在选择的时候可能也不一样。
SpringBoot整合resilience4j实现接口限流
flash_love的博客
01-03 1205
最近在开发项目的时候，需要用到限流的功能，搜索资料发现，最近resilience4j这个框架还是挺火的，使用研究了一下简单实用。这篇博客主要是SpringBoot简单整合resilience4j框架实现接口限流功能。
16个SpringBoot 扩展接口，帮你写出更加漂亮的代码
最新发布
良月柒
09-06 187
阅读本文大概需要 4 分钟。来自：网络，侵删推荐一个程序员编程资料站：http://cxyroad.com2024年IDEA最新激活方法后台回复：激活码CSDN免登录复制代码插件下载：CSDN复制插件以下是正文。1、背景Spring的核心思想就是容器，当容器refresh的时候，外部看上去风平浪静，其实内部则是一片惊涛骇浪，汪洋一片。Springboot更是封装了Spring，遵循约定大于配置，加...
SpringBoot中如何实现限流，这种方式才叫优雅。
Java技术攻略的博客
03-20 702
现在，一个问题摆在我们面前：如何将这两种限流机制整合到同一个组件中，以便用户随时切换呢？显然，我们需要定义一个通用的限流组件，将其引入到业务中，并支持通过配置文件自由切换不同的限流机制。举例而言，当使用时，启用Redis分布式限流组件，当使用时，启用Guava限流组件。这种自由切换机制能够为用户提供更大的灵活性和可维护性。接下来，让我们开始动手实现吧！
SpringBoot 如何进行限流？老鸟们还可以这样玩
GitHub质检员
11-29 143
*** 资源的key,唯一* 作用：不同的接口，不同的流量控制*//*** 最多的访问限制次数*//*** 过期时间也可以理解为单位时间，单位秒，默认60*/​/*** 得不到令牌的提示语*/String msg() default "系统繁忙,请稍后再试.";
Springboot项目接口限流方案
m0_37978198的博客
01-25 1835
本文提供系统接口限流的基本方案，拿来可用，可以指定系统接口总并发数，也是指定某些接口的并发数，还可以根据IP指定该接口的并发数，有兴趣的小伙伴可以参考下。
Spring boot接口限流
big_title的博客
07-06 461
限流可以认为服务降级的一种，限流通过限制请求的流量以达到保护系统的目的。
Springboot 实现接口限流
qq_40266420的博客
05-16 538
springboot 实现接口限流
Spring Boot 接口如何做限流？面试官问起如何作答
doubututou的博客
02-05 320
阅读目录： 1. 前言 2. 算法介绍-计数器法 3. 算法介绍-滑动窗口 4. 算法介绍-漏桶算法 5. 算法介 绍-令牌桶算法 前言 在一个高并发系统中对流量的把控是非常重要的，当巨大的流量直接请求到我们的服务器上没多久就可能造成接口不可用，不处理的话甚至会造成整个应用不可用。 那么何为限流呢？顾名思义，限流就是限制流量，就像你宽带包了1个G的流量，用完了就没了。通过限流，我们可以很好地控制系统的qps，从而达到保护系统的目的。本篇文章将会介绍一下常用的限流算法以及他们各自的特点。 算法介绍 计数器
基于springboot定义接口网关.zip
04-08
标题中的“基于SpringBoot定义接口网关”表明这个项目是使用SpringBoot框架来构建一个接口网关服务。接口网关是微服务架构中常见的组件，它作为系统对外的统一入口，处理所有客户端请求，实现路由转发、认证授权、限...
基于 SpringBoot 的分布式秒杀系统.zip
02-01
【标题】"基于 SpringBoot 的分布式秒杀系统"是一个典型的 IT 实战项目，它涉及到的主要技术栈是 SpringBoot，这是目前非常流行的企业级应用开发框架，尤其在微服务架构中广泛应用。SpringBoot 提供了快速构建应用的...
springboot-uploadfile.zip
04-28
在本项目"springboot-uploadfile.zip"中，我们聚焦于使用Spring Boot 2.0来构建RESTful API，实现文件的上传与下载功能。这个实战课程的源码提供了清晰的指导，帮助开发者理解如何在实际应用中处理这些常见的Web操作...
基于SpringBoot的秒杀系统源码数据库.zip
03-09
【描述】这个压缩包包含了一个基于SpringBoot框架构建的秒杀系统完整的源代码和数据库资源。秒杀系统是电商领域常见的一种高并发处理机制，用于在短时间内处理大量用户的抢购请求。SpringBoot以其简洁的配置、快速的...
SpringBoot2.x使用Jsoup防范XSS攻击实战
SpringBoot 2.x作为流行的Java Web框架，提供了一种有效的方法来防御XSS攻击，那就是集成Jsoup库。 一、XSS攻击详解 XSS攻击是由于应用程序未能正确处理用户输入导致的。攻击者可以通过注入JavaScript、HTML或其他...
一起来学 SpringBoot 2.x | 第二十七篇：优雅解决分布式限流
Java_Jsp_Ssh的博客
11-06 2039
http://www.iocoder.cn/Spring-Boot/battcn/v2-cache-redislimter/    SpringBoot 是为了简化 Spring 应用的创建、运行、调试、部署等一系列问题而诞生的产物，自动装配的特性让我们可以更好的关注业务本身而不是外部的XML配置，我们只需遵循规范，引入相关的依赖就可以轻易的搭建出一个 WEB 工程 在前面的两篇文章中，...
一文搞定 Spring Boot 服务接口限流
m0_71777195的博客
07-05 1524
在开发高并发系统时有三把利器用来保护系统：缓存、降级和限流。限流可以认为服务降级的一种，限流通过限制请求的流量以达到保护系统的目的。一般来说，系统的吞吐量是可以计算出一个阈值的，为了保证系统的稳定运行，一旦达到这个阈值，就需要限制流量并采取一些措施以完成限制流量的目的。比如：延迟处理，拒绝处理，或者部分拒绝处理等等。否则，很容易导致服务器的宕机。
使用Spring Boot实现限流
聚娃科技开发者博客
08-03 314
在分布式系统中，限流是一种重要的手段，用于控制服务的并发访问量，防止系统因高并发而崩溃。Spring Boot作为目前流行的Java微服务框架，提供了多种限流实现方式，本文将探讨如何在Spring Boot项目中实现限流功能，保障系统的稳定性和可靠性。限流（Rate Limiting）是指在一定时间窗口内对请求进行限制，防止系统处理过多的请求，保证系统资源的有效利用和稳定运行。常见的限流策略包括固定窗口限流、滑动窗口限流、令牌桶算法和漏桶算法等。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

皓亮君

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值