boot分布式计算 spring_Springboot分布式限流实践

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

限流算法介绍

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时出现以下结果