高并发访问时，缓存、限流、降级往往是系统的利剑，在互联网蓬勃发展的时期，经常会面临因用户暴涨导致的请求不可用的情况，甚至引发连锁反映导致整个系统崩溃。这个时候常见的解决方案之一就是限流了，当请求达到一定的并发数或速率，就进行等待、排队、降级、拒绝服务等...

限流算法介绍

a、令牌桶算法

令牌桶算法的原理是系统会以一个恒定的速度往桶里放入令牌，而如果请求需要被处理，则需要先从桶里获取一个令牌，当桶里没有令牌可取时，则拒绝服务。 当桶满时，新添加的令牌被丢弃或拒绝。


b、漏桶算法

其主要目的是控制数据注入到网络的速率，平滑网络上的突发流量，数据可以以任意速度流入到漏桶中。 漏桶算法提供了一种机制，通过它，突发流量可以被整形以便为网络提供一个稳定的流量。 漏桶可以看作是一个带有常量服务时间的单服务器队列，如果漏桶为空，则不需要流出水滴，如果漏桶(包缓存)溢出，那么水滴会被溢出丢弃


c、计算器限流

计数器限流算法是比较常用一种的限流方案也是最为粗暴直接的，主要用来限制总并发数，比如数据库连接池大小、线程池大小、接口访问并发数等都是使用计数器算法

如：使用 AomicInteger 来进行统计当前正在并发执行的次数，如果超过域值就直接拒绝请求，提示系统繁忙

限流具体代码实践

a、导入依赖
org.springframework.boot
spring-boot-starter-aop
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-data-redis
com.google.guava
guava
21.0
org.apache.commons
commons-lang3
org.springframework.boot
spring-boot-starter-test
b、属性配置
在 application.properites 资源文件中添加 redis 相关的配置项
spring.redis.host=192.168.68.110
spring.redis.port=6379
spring.redis.password=123456
c、RedisTemplate
默认情况下 spring-boot-data-redis 为我们提供了StringRedisTemplate 但是满足不了其它类型的转换，所以还是得自己去定义其它类型的模板
importorg.springframework.context.annotation.Bean;importorg.springframework.context.annotation.Configuration;importorg.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;importorg.springframework.data.redis.core.RedisTemplate;importorg.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;importorg.springframework.data.redis.serializer.StringRedisSerializer;importjava.io.Serializable;/*** redis配置*/@Configurationpublic classRedisConfig {
@Beanpublic RedisTemplatelimitRedisTemplate(LettuceConnectionFactory redisConnectionFactory) {
RedisTemplate template = new RedisTemplate<>();
template.setKeySerializer(newStringRedisSerializer());
template.setValueSerializer(newGenericJackson2JsonRedisSerializer());
template.setConnectionFactory(redisConnectionFactory);returntemplate;
}
}
d、Limit 注解
具体代码如下
1 importcom.carry.enums.LimitType;2
3 importjava.lang.annotation.Documented;4 importjava.lang.annotation.ElementType;5 importjava.lang.annotation.Inherited;6 importjava.lang.annotation.Retention;7 importjava.lang.annotation.RetentionPolicy;8 importjava.lang.annotation.Target;9
10 /**
11 * 限流12 */
13 @Target({ElementType.METHOD, ElementType.TYPE})14 @Retention(RetentionPolicy.RUNTIME)15 @Inherited16 @Documented17 public @interfaceLimit {18
19 /**
20 * 资源的名字21 *22 *@returnString23 */
24 String name() default "";25
26 /**
27 * 资源的key28 *29 *@returnString30 */
31 String key() default "";32
33 /**
34 * Key的prefix35 *36 *@returnString37 */
38 String prefix() default "";39
40 /**
41 * 给定的时间段42 * 单位秒43 *44 *@returnint45 */
46 intperiod();47
48 /**
49 * 最多的访问限制次数50 *51 *@returnint52 */
53 intcount();54
55 /**
56 * 类型57 *58 *@returnLimitType59 */
60 LimitType limitType() defaultLimitType.CUSTOMER;61 }
1 packagecom.carry.enums;2
3 public enumLimitType {4 /**
5 * 自定义key6 */
7 CUSTOMER,8 /**
9 * 根据请求者IP10 */
11 IP;12 }
e、Limit 拦截器(AOP)
我们可以通过编写 Lua 脚本实现自己的API，核心就是调用 execute 方法传入我们的 Lua 脚本内容，然后通过返回值判断是否超出我们预期的范围，超出则给出错误提示。
1 importcom.carry.annotation.Limit;2 importcom.carry.enums.LimitType;3 importcom.google.common.collect.ImmutableList;4 importorg.apache.commons.lang3.StringUtils;5 importorg.aspectj.lang.ProceedingJoinPoint;6 importorg.aspectj.lang.annotation.Around;7 importorg.aspectj.lang.annotation.Aspect;8 importorg.aspectj.lang.reflect.MethodSignature;9 importorg.slf4j.Logger;10 importorg.slf4j.LoggerFactory;11 importorg.springframework.beans.factory.annotation.Autowired;12 importorg.springframework.context.annotation.Configuration;13 importorg.springframework.data.redis.core.RedisTemplate;14 importorg.springframework.data.redis.core.script.DefaultRedisScript;15 importorg.springframework.data.redis.core.script.RedisScript;16 importorg.springframework.web.context.request.RequestContextHolder;17 importorg.springframework.web.context.request.ServletRequestAttributes;18
19 importjavax.servlet.http.HttpServletRequest;20 importjava.io.Serializable;21 importjava.lang.reflect.Method;22
23
24 @Aspect25 @Configuration26 public classLimitInterceptor {27
28 private static final Logger logger = LoggerFactory.getLogger(LimitInterceptor.class);29
30 private final RedisTemplatelimitRedisTemplate;31
32 @Autowired33 public LimitInterceptor(RedisTemplatelimitRedisTemplate) {34 this.limitRedisTemplate =limitRedisTemplate;35 }36
37
38 @Around("execution(public * *(..)) && @annotation(com.carry.annotation.Limit)")39 publicObject interceptor(ProceedingJoinPoint pjp) {40 MethodSignature signature =(MethodSignature) pjp.getSignature();41 Method method =signature.getMethod();42 Limit limitAnnotation = method.getAnnotation(Limit.class);43 LimitType limitType =limitAnnotation.limitType();44 String name =limitAnnotation.name();45 String key;46 int limitPeriod =limitAnnotation.period();47 int limitCount =limitAnnotation.count();48 switch(limitType) {49 caseIP:50 key =getIpAddress();51 break;52 caseCUSTOMER:53 key =limitAnnotation.key();54 break;55 default:56 key =StringUtils.upperCase(method.getName());57 }58 ImmutableList keys =ImmutableList.of(StringUtils.join(limitAnnotation.prefix(), key));59 try{60 String luaScript =buildLuaScript();61 RedisScript redisScript = new DefaultRedisScript<>(luaScript, Number.class);62 Number count =limitRedisTemplate.execute(redisScript, keys, limitCount, limitPeriod);63 logger.info("Access try count is {} for name={} and key = {}", count, name, key);64 if (count != null && count.intValue() <=limitCount) {65 returnpjp.proceed();66 } else{67 throw new RuntimeException("You have been dragged into the blacklist");68 }69 } catch(Throwable e) {70 if (e instanceofRuntimeException) {71 throw newRuntimeException(e.getLocalizedMessage());72 }73 throw new RuntimeException("server exception");74 }75 }76
77 /**
78 * 限流 脚本79 *80 *@returnlua脚本81 */
82 publicString buildLuaScript() {83 StringBuilder lua = newStringBuilder();84 lua.append("local c");85 lua.append("\nc = redis.call('get',KEYS[1])");86 //调用不超过最大值，则直接返回
87 lua.append("\nif c and tonumber(c) > tonumber(ARGV[1]) then");88 lua.append("\nreturn c;");89 lua.append("\nend");90 //执行计算器自加
91 lua.append("\nc = redis.call('incr',KEYS[1])");92 lua.append("\nif tonumber(c) == 1 then");93 //从第一次调用开始限流，设置对应键值的过期
94 lua.append("\nredis.call('expire',KEYS[1],ARGV[2])");95 lua.append("\nend");96 lua.append("\nreturn c;");97 returnlua.toString();98 }99
100 private static final String UNKNOWN = "unknown";101
102 /**
103 * 获取IP地址104 *@return
105 */
106 publicString getIpAddress() {107 HttpServletRequest request =((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();108 String ip = request.getHeader("x-forwarded-for");109 if (ip == null || ip.length() == 0 ||UNKNOWN.equalsIgnoreCase(ip)) {110 ip = request.getHeader("Proxy-Client-IP");111 }112 if (ip == null || ip.length() == 0 ||UNKNOWN.equalsIgnoreCase(ip)) {113 ip = request.getHeader("WL-Proxy-Client-IP");114 }115 if (ip == null || ip.length() == 0 ||UNKNOWN.equalsIgnoreCase(ip)) {116 ip =request.getRemoteAddr();117 }118 returnip;119 }120 }
f、控制层
在接口上添加 @Limit() 注解，如下代码会在 Redis 中生成过期时间为 100s 的 key = test 的记录，特意定义了一个 AtomicInteger 用作测试
1 importcom.carry.annotation.Limit;2 importorg.springframework.web.bind.annotation.GetMapping;3 importorg.springframework.web.bind.annotation.RestController;4
5 importjava.util.concurrent.atomic.AtomicInteger;6
7
8 @RestController9 public classLimiterController {10
11 private static final AtomicInteger ATOMIC_INTEGER = newAtomicInteger();12
13 @Limit(key = "test", period = 100, count = 10, name="resource", prefix = "limit")14 @GetMapping("/test")15 public inttestLimiter() {16 //意味着100S内最多可以访问10次
17 returnATOMIC_INTEGER.incrementAndGet();18 }19 }

注意：上面例子保存在redis中的key值应该为“limittest”，即@Limit中prefix的值+key的值

测试

我们在postman中快速访问localhost:8080/test，当访问数超过10时出现以下结果