Springboot（五十八）SpringBoot3使用Redisson实现接口的限流功能
这部分我记录一下我使用redission实现接口限流的全过程。
关于自定义注解，请移步《SpringBoot（二十六）SpringBoot自定义注解》
一：redission自定义限流注解主要流程
对接口实现限流，主要使用了Redisson提供的限流API方法；使用很简单：
第一步：声明一个限流器；
RRateLimiter rRateLimiter = redissonClient.getRateLimiter(rateLimiterKey);第二步：设置速率；举例：5秒中产生2个令牌
rRateLimiter.trySetRate(RateType.OVERALL, 2, 5, RateIntervalUnit.SECONDS);第三步：试图获取一个令牌，获取到，返回true；否则，返回false
rateLimiter.tryAcquire();二：自定义限流注解接口
MyRateLimiter.java
package com.modules.customannotations.myAnnotation;
import com.modules.customannotations.enums.LimitType;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyRateLimiter {
/**
* 限流key,支持使用Spring el表达式来动态获取方法上的参数值
*/
String rateKey() default "";
/**
* 限流时间,单位秒
*/
int time() default 60;
/**
* 限流次数
*/
int count() default 100;
/**
* 限流类型
*/
LimitType limitType() default LimitType.DEFAULT;
/**
* 提示消息
*/
String errMsg() default "接口请求过于频繁,请稍后再试!";
}三：实现限流注解接口
MyRateLimiterAspect.java
package com.modules.customannotations.annotationAspect;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.StrUtil;
import com.modules.customannotations.enums.LimitType;
import com.modules.customannotations.myAnnotation.MyRateLimiter;
import lombok.RequiredArgsConstructor;
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.redisson.api.RRateLimiter;
import org.redisson.api.RateIntervalUnit;
import org.redisson.api.RateType;
import org.redisson.api.RedissonClient;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.core.ParameterNameDiscoverer;
import org.springframework.expression.EvaluationContext;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.ParserContext;
import org.springframework.expression.common.TemplateParserContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
@Slf4j
@Aspect
@Component
@RequiredArgsConstructor
public class MyRateLimiterAspect {
private final RedissonClient redissonClient;
/**
* 定义spel表达式解析器
*/
private final ExpressionParser parser = new SpelExpressionParser();
/**
* 定义spel解析模版
*/
private final ParserContext parserContext = new TemplateParserContext();
/**
* 定义spel上下文对象进行解析
*/
private final EvaluationContext context = new StandardEvaluationContext();
/**
* 方法参数解析器
*/
private final ParameterNameDiscoverer pnd = new DefaultParameterNameDiscoverer();
@Before("@annotation(rateLimiter)")
public void doBefore(JoinPoint point, MyRateLimiter rateLimiter) {
int time = rateLimiter.time();
int count = rateLimiter.count();
String rateLimiterKey = getRateKey(rateLimiter, point);
log.error("rateLimiterKey == {}", rateLimiterKey);
try {
RateType rateType = RateType.OVERALL;
if (rateLimiter.limitType() == LimitType.CLUSTER)
{
rateType = RateType.PER_CLIENT;
}
long number = -1;
RRateLimiter rRateLimiter = redissonClient.getRateLimiter(rateLimiterKey);
rRateLimiter.trySetRate(rateType, count, time, RateIntervalUnit.SECONDS);
if (rRateLimiter.tryAcquire())
{
// 3.24
number = rRateLimiter.availablePermits();
}
if (number == -1) {
String message = rateLimiter.errMsg();
throw new RuntimeException(message);
}
log.info("限制令牌 => {}, 剩余令牌 => {}, 缓存key => '{}'", count, number, rateLimiterKey);
} catch (Exception ex) {
throw ex;
}
}
/**
* 解析El表达式获取lockKey
* @param rateLimiter
* @param joinPoint
* @return
*/
public String getRateKey(MyRateLimiter rateLimiter, JoinPoint joinPoint)
{
String key = rateLimiter.rateKey();
// 获取方法(通过方法签名来获取)
MethodSignature signature = (MethodSignature) joinPoint.getSignature();
Method method = signature.getMethod();
Class<?> targetClass = method.getDeclaringClass();
// 判断是否是spel格式
if (StrUtil.containsAny(key, "#"))
{
// 获取参数值
Object[] args = joinPoint.getArgs();
// 获取方法上参数的名称
String[] parameterNames = pnd.getParameterNames(method);
if (ArrayUtil.isEmpty(parameterNames))
{
throw new RuntimeException("限流key解析异常!请联系管理员!");
}
for (int i = 0; i < parameterNames.length; i++)
{
context.setVariable(parameterNames[i], args[i]);
}
// 解析返回给key
try
{
Expression expression;
if (StrUtil.startWith(key, parserContext.getExpressionPrefix()) && StrUtil.endWith(key, parserContext.getExpressionSuffix()))
{
expression = parser.parseExpression(key, parserContext);
}
else
{
expression = parser.parseExpression(key);
}
key = expression.getValue(context, String.class) + ":";
}
catch (Exception e)
{
throw new RuntimeException("限流key解析异常!请联系管理员!");
}
}
StringBuilder stringBuffer = new StringBuilder("xk-admin:rate_limit:");
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
stringBuffer.append(request.getRequestURI()).append(":");
if (rateLimiter.limitType() == LimitType.IP)
{
// 获取请求ip
stringBuffer.append(request.getRemoteAddr() + ":");
}
else if (rateLimiter.limitType() == LimitType.CLUSTER)
{
// 获取客户端实例id 3.24
stringBuffer.append(redissonClient.getId()).append(":");
}
return stringBuffer.append(key).toString();
}
}四：限流注解中使用的枚举类
LimitType.java
package com.modules.customannotations.enums;
public enum LimitType {
/**
* 默认限流策略，针对某一个接口进行限流
*/
DEFAULT,
CLUSTER,
/**
* 根据IP地址进行限流
*/
IP;
}五：测试一下
通过使用@RateLimiter 注解配置：count = 2, time = 10；即：每10秒钟产生2个令牌。
@GetMapping("index/rateTest")
@MyRateLimiter(rateKey = "'rateTest'+ #param1+#param2", count = 2, time = 10, limitType = LimitType.DEFAULT, errMsg = "访问超过限制,请稍后再试!")
public void rateTest(String param1, String param2) {
System.out.println("开始执行业务逻辑......");
ThreadUtil.sleep(15000);
System.out.println("结束执行业务逻辑......");
}浏览器访问：http://localhost:7001/java/index/rateTest
控制台输出：
使用redission实现自定义限流注解成功。
有好的建议，请在下方输入你的评论。