深入探讨接口限流：优化你的应用性能的关键步骤

最新推荐文章于 2024-04-18 12:15:29 发布

九月生

最新推荐文章于 2024-04-18 12:15:29 发布

阅读量489

点赞数 10

文章标签： java springboot redis

本文链接：https://blog.csdn.net/qq_43711451/article/details/136713076

版权

深入探讨接口限流：优化你的应用性能的关键步骤

为什么要进行限流

接口限流的目的是确保系统的稳定性和可靠性，防止因为突发的高流量而导致系统崩溃或性能下降。通过限制接口的访问频率或并发连接数，可以有效地控制系统的负载，避免过载情况的发生。这样可以保障系统对正常请求的处理，并提高系统的整体可用性和性能。

当我们想象一条繁忙的高速公路时，接口限流就好像是交通警察控制车流一样。假设这条高速公路是一个接口，车辆是请求。如果没有交通警察限制车辆的数量和速度，可能会发生拥堵，导致交通瘫痪。但通过限制车辆的流量和速度，交通可以更顺畅地流动，避免发生交通事故，保持道路的正常运行。这就是接口限流的作用，通过控制请求的数量和速度，确保系统的稳定性和可靠性。

什么是限流？有哪些限流方法

限流是一种控制系统资源利用率的技术，它通过限制请求的数量或速率，以保护系统免受过载的影响。限流可以应用于各种系统中，包括网络服务、数据库、消息队列等。

以下是一些常见的限流算法：

固定窗口算法（Fixed Window）：在固定的时间窗口内计数请求，如果超过了限定的阈值，则拒绝后续请求。例如，限定每秒钟最多处理100个请求。
滑动窗口算法（Sliding Window）：与固定窗口算法类似，但窗口会根据时间动态滑动，以平滑请求速率的突发。这种算法可以更精确地控制请求速率。

假设单位时间还是1s，滑动窗口算法把它划分为5个小周期，也就是滑动窗口（单位时间）被划分为5个小格子。每格表示0.2s。每过0.2s，时间窗口就会往右滑动一格。然后呢，每个小周期，都有自己独立的计数器，如果请求是0.83s到达的，0.8~1.0s对应的计数器就会加1。
令牌桶算法（Token Bucket）：系统会维护一个令牌桶，其中包含一定数量的令牌，每个令牌代表一个可处理的请求。当请求到达时，系统会尝试获取一个令牌，如果桶中有足够的令牌，则请求被处理，否则请求被拒绝。令牌以固定的速率被填充到桶中，因此可以平滑处理突发的请求。
漏桶算法（Leaky Bucket）：类似于令牌桶算法，但处理方式相反。在漏桶算法中，请求被放入一个漏桶中，然后以固定的速率被处理。如果请求到达时漏桶已满，则请求被拒绝。

这些算法各有特点，可以根据具体的系统需求和性能要求选择合适的算法进行限流。

Java代码实现

这里我们主要讲解令牌桶算法，项目地址->代码仓库

基于Guava工具类实现限流

Google开源工具包Guava提供了限流工具类RateLimiter，该类基于令牌桶算法实现流量限制，使用十分方便，而且十分高效，实现步骤如下：

第一步：引入guava依赖包

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

第二步：接口添加上限流逻辑

package com.libsept24.limit.controller;

import com.google.common.util.concurrent.RateLimiter;
import com.libsept24.limit.entity.User;
import com.libsept24.limit.res.ResultResponse;
import com.libsept24.limit.res.StatusEnum;
import com.libsept24.limit.service.IUserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Slf4j
@RestController
public class UserController {

    /**
     * 限流策略：令牌桶算法
     * 1s中生成2个令牌
     */
    private final RateLimiter limiter = RateLimiter.create(1.0);

    @Resource
    private IUserService userService;

    @PostMapping("/queryUserInfos")
    public ResultResponse<List<User>> queryUserInfos(){
        boolean b = limiter.tryAcquire(0, TimeUnit.MILLISECONDS);
        if (!b){
            log.warn("进入服务降级，时间{}", LocalDateTime.now());
            return ResultResponse.error(StatusEnum.SERVICE_ERROR, "当前排队人数较多，请稍后再试！");
        }
        List<User> users = userService.queryUserInfos();
        return ResultResponse.success(users);
    }

}

以上用到了RateLimiter的2个核心方法：create()、tryAcquire()，以下为详细说明

acquire() 获取一个令牌, 改方法会阻塞直到获取到这一个令牌, 返回值为获取到这个令牌花费的时间
acquire(int permits) 获取指定数量的令牌, 该方法也会阻塞, 返回值为获取到这 N 个令牌花费的时间
tryAcquire() 判断时候能获取到令牌, 如果不能获取立即返回 false
tryAcquire(int permits) 获取指定数量的令牌, 如果不能获取立即返回 false
tryAcquire(long timeout, TimeUnit unit) 判断能否在指定时间内获取到令牌, 如果不能获取立即返回 false
tryAcquire(int permits, long timeout, TimeUnit unit) 同上

利用AOP实现guava令牌桶

第一步：引入AOP依赖

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

第二步：定义注解

package com.libsept24.limit.handler.annotations;

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;

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

    /**
     * 资源的key,唯一
     * 作用：不同的接口，不同的流量控制
     */
    String key() default "";

    /**
     * 最多的访问限制次数
     */
    double permitsPerSecond () ;

    /**
     * 获取令牌最大等待时间
     */
    long timeout();

    /**
     * 获取令牌最大等待时间,单位(例:分钟/秒/毫秒) 默认:毫秒
     */
    TimeUnit timeunit() default TimeUnit.MILLISECONDS;

    /**
     * 得不到令牌的提示语
     */
    String msg() default "系统繁忙,请稍后再试.";
}

第三步：实现切面

package com.libsept24.limit.aspt.limit;

import com.google.common.collect.Maps;
import com.google.common.util.concurrent.RateLimiter;
import com.libsept24.limit.handler.annotations.LocalLimit;
import com.libsept24.limit.res.ResultResponse;
import com.libsept24.limit.res.StatusEnum;
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 org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
import java.util.Map;

@Slf4j
@Aspect
@Component
public class LocalLimitAop {

    /**
     * 不同的接口，不同的流量控制
     * map的key为 Limiter.key
     */
    private final Map<String, RateLimiter> limitMap = Maps.newConcurrentMap();

    @Around("@annotation(com.libsept24.limit.handler.annotations.LocalLimit)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        //拿limit的注解
        LocalLimit limit = method.getAnnotation(LocalLimit.class);
        if (limit != null) {
            //key作用：不同的接口，不同的流量控制
            String key = limit.key();
            RateLimiter rateLimiter = null;
            //验证缓存是否有命中key
            if (!limitMap.containsKey(key)) {
                // 创建令牌桶
                rateLimiter = RateLimiter.create(limit.permitsPerSecond());
                limitMap.put(key, rateLimiter);
                log.info("新建了令牌桶={}，容量={}", key, limit.permitsPerSecond());
            }
            rateLimiter = limitMap.get(key);
            // 拿令牌
            boolean acquire = rateLimiter.tryAcquire(limit.timeout(), limit.timeunit());
            // 拿不到命令，直接返回异常提示
            if (!acquire) {
                log.debug("令牌桶={}，获取令牌失败", key);
                return ResultResponse.error(StatusEnum.SERVICE_ERROR, limit.msg());
            }
        }
        return joinPoint.proceed();
    }
}

第四步：给接口添加注解

package com.libsept24.limit.controller;

import com.google.common.util.concurrent.RateLimiter;
import com.libsept24.limit.entity.User;
import com.libsept24.limit.handler.annotations.LocalLimit;
import com.libsept24.limit.res.ResultResponse;
import com.libsept24.limit.res.StatusEnum;
import com.libsept24.limit.service.IUserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Slf4j
@RestController
public class UserController {
  
    @Resource
    private IUserService userService;

    @LocalLimit(key = "queryUserInfos2", permitsPerSecond = 1.0, timeout = 0, msg = "当前排队人数较多，请稍后再试！")
    @PostMapping("/queryUserInfos2")
    public ResultResponse<List<User>> queryUserInfos2(){
        List<User> users = userService.queryUserInfos();
        return ResultResponse.success(users);
    }

}

以上的方式只能针对于单体项目进行限流，如果遇到了微服务架构的时候就不支持

分布式系统架构中的限流方式

这边使用redisson

第一步：引入依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
  <groupId>org.redisson</groupId>
  <artifactId>redisson-spring-boot-starter</artifactId>
  <version>3.17.7</version>
</dependency>

第二步：定义注解

package com.libsept24.limit.handler.annotations;

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;

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

    /**
     * 资源的key,唯一
     * 作用：不同的接口，不同的流量控制
     */
    String key() default "";

    /**
     * 最多的访问限制次数
     */
    long permitsPerSecond () ;

    /**
     * 获取令牌最大等待时间
     */
    long timeout();

    /**
     * 获取令牌最大等待时间,单位(例:分钟/秒/毫秒) 默认:毫秒
     */
    TimeUnit timeunit() default TimeUnit.MILLISECONDS;

    /**
     * 得不到令牌的提示语
     */
    String msg() default "系统繁忙,请稍后再试.";
}

第二步：实现切面

package com.libsept24.limit.aspt.limit;

import com.google.common.collect.Maps;
import com.google.common.util.concurrent.RateLimiter;
import com.libsept24.limit.handler.annotations.LocalLimit;
import com.libsept24.limit.handler.annotations.RedisLimit;
import com.libsept24.limit.res.ResultResponse;
import com.libsept24.limit.res.StatusEnum;
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.redisson.api.RRateLimiter;
import org.redisson.api.RateIntervalUnit;
import org.redisson.api.RateType;
import org.redisson.api.RedissonClient;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.lang.reflect.Method;
import java.util.Map;

@Slf4j
@Aspect
@Component
public class RedisLimitAop {

    @Resource
    private RedissonClient redissonClient;

    /**
     * 不同的接口，不同的流量控制
     * map的key为 Limiter.key
     */
    private final Map<String, RateLimiter> limitMap = Maps.newConcurrentMap();

    @Around("@annotation(com.libsept24.limit.handler.annotations.RedisLimit)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        //拿limit的注解
        RedisLimit limit = method.getAnnotation(RedisLimit.class);
        if (limit != null) {
            //key作用：不同的接口，不同的流量控制
            String key = limit.key();
            RRateLimiter rateLimiter = redissonClient.getRateLimiter(key);
            // rateInterval RateIntervalUnit 中生成limit.permitsPerSecond()个
            rateLimiter.trySetRate(RateType.OVERALL, limit.permitsPerSecond(), 1, RateIntervalUnit.SECONDS);
            boolean acquire = rateLimiter.tryAcquire(limit.timeout(), limit.timeunit());
            // 拿不到命令，直接返回异常提示
            if (!acquire) {
                log.debug("令牌桶={}，获取令牌失败", key);
                return ResultResponse.error(StatusEnum.SERVICE_ERROR, limit.msg());
            }
        }
        return joinPoint.proceed();
    }
}

第四步：给接口添加注解

package com.libsept24.limit.controller;

import com.google.common.util.concurrent.RateLimiter;
import com.libsept24.limit.entity.User;
import com.libsept24.limit.handler.annotations.LocalLimit;
import com.libsept24.limit.handler.annotations.RedisLimit;
import com.libsept24.limit.res.ResultResponse;
import com.libsept24.limit.res.StatusEnum;
import com.libsept24.limit.service.IUserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Slf4j
@RestController
public class UserController {

    @Resource
    private IUserService userService;

    @RedisLimit(key = "queryUserInfos2", permitsPerSecond = 1, timeout = 0, msg = "当前排队人数较多，请稍后再试！")
    @PostMapping("/queryUserInfos2")
    public ResultResponse<List<User>> queryUserInfos2(){
        List<User> users = userService.queryUserInfos();
        return ResultResponse.success(users);
    }

}

九月生

关注

10
点赞
踩
4

收藏

觉得还不错? 一键收藏
1
评论
深入探讨接口限流：优化你的应用性能的关键步骤

限流是一种控制系统资源利用率的技术，它通过限制请求的数量或速率，以保护系统免受过载的影响。限流可以应用于各种系统中，包括网络服务、数据库、消息队列等。固定窗口算法（Fixed Window）：在固定的时间窗口内计数请求，如果超过了限定的阈值，则拒绝后续请求。例如，限定每秒钟最多处理100个请求。滑动窗口算法（Sliding Window）：与固定窗口算法类似，但窗口会根据时间动态滑动，以平滑请求速率的突发。这种算法可以更精确地控制请求速率。
复制链接

扫一扫