java基于Guava的单机限流实现

随着互联网应用的发展，再高并发场景下要保证服务应用的稳定运行，需要对高频调用接口进行限流处理，为什么限流和限流的几种算法，前边的文章已经说过了，这次来说谷歌的Guava框架，此框架能很好实现限流效果， Guava提供了限流工具类RateLimiter，该类基于令牌桶算法实现流量限制，使用十分方便，而且十分高效，下边来说明如何使用guava框架进行限流。
首先在项目中引入使用的jar包：

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>30.0-jre</version> <!-- 使用最新版本 -->
</dependency>

代码示例：

//每秒产生2个令牌
private static final RateLimiter rateLimiter = RateLimiter.create(2.0);
@RequestMapping(value = "/post",method = RequestMethod.POST)
public String post(String name,String age){
    //尝试获取令牌，如果没有拿到令牌，则返回false
    boolean b = rateLimiter.tryAcquire();
    if (b){
        logger.info("拿到令牌，开始处理业务逻辑");
        return "拿到令牌，开始处理业务逻辑";
    }else {
        logger.info("没有拿到令牌，拒绝处理业务逻辑");
        return "拒绝处理业务逻辑";
    }
}

使用postman快速点击请求，看日志如下：通过执行结果看一看出来限流执行成功。

以上代码使用方式只是一个简单示例，在项目中肯定不能这么使用，太low,下边演示正确且大众的使用方式，通过切面来实现限流：
首先创建一个注解类

package com.example.mytest.aop;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.TimeUnit;

/**
* @version JDK 8
* @interfaceName Limit (此处以class为例)
* @date 2024/12/19
* @description 注解类
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Limit {
    /*
     * key接口限流的key,标识唯一接口使用
     */
   String key() default "";
   /*
   * 最多访问次数限制
   */
   double limit() default 5;

    /*
     * 获取令牌最大等待时间
     */
    long timeout() ;
    /**
     * 获取令牌最大等待时间单位（默认毫秒）
     */
    TimeUnit timeunit() default TimeUnit.MILLISECONDS;
    /**
     * 无法获取令牌的提示语
     */
    String errMsg() default "当前请求次数过多，请稍后再试";
}

定义一个AOP类，来解析这个注解

package com.example.mytest.aop;

import com.google.common.collect.Maps;
import com.google.common.util.concurrent.RateLimiter;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.Map;

/**
* @version JDK 8
* @className GuavaLimit (此处以class为例)
* @date 2024/12/19
*/
@Slf4j
@Component
@Aspect
public class GuavaLimit {
    /**
     * 存储不同接口不同限流策略的map
     */
    private final Map<String, RateLimiter> limitMap = Maps.newConcurrentMap();

    @Before(value = "@annotation(com.example.mytest.aop.Limit)")
    public void checkLimit(JoinPoint point){
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();
        Limit limit = method.getAnnotation(Limit.class);
        if (limit != null) {
            //不同的接口，不同的流量控制key
            String key = limit.key();
            RateLimiter rateLimiter = null;
            //验证缓存是否有命中key
            if (!limitMap.containsKey(key)) {
                // 创建令牌桶
                rateLimiter = RateLimiter.create(limit.limit());
                limitMap.put(key, rateLimiter);
                log.info("新建了令牌桶={}，容量={}", key, limit.limit());
            }
            rateLimiter = limitMap.get(key);
            // 拿令牌
            boolean acquire = rateLimiter.tryAcquire(limit.timeout(), limit.timeunit());
            log.info("令牌桶={}，获取令牌结果={}", key, acquire);
            // 拿不到命令，直接返回异常提示
            if (!acquire) {
                log.info("令牌桶={}，获取令牌失败", key);
                //如果没有拿到令牌就直接抛异常
                throw new RuntimeException(limit.errMsg());
            }
        }
    }
}

controller接口入口处使用注解进行限流，为了效果明显，我们令牌桶容量定义为1。

@RequestMapping(value = "/limit",method = RequestMethod.POST)
@Limit(key = "limitKey",limit =1,timeout = 500,
        timeunit = TimeUnit.MILLISECONDS, errMsg = "当前排队人数过多，请稍后再试")
public String limit(String name){
   return "接口调用成功！";
}

postman多次调用接口，结果如下：

看日志发现第二次调用的时候，令牌获取失败了，限流成功。下次展示分布式限流使用方法。

关注公众号“弱弱的程序媛”每天学习一个小知识点。