Springboot分布式限流實踐
阿新 • • 發佈：2018-08-07
star rip num 一次 text package 最大 key值 rec
高並發訪問時，緩存、限流、降級往往是系統的利劍，在互聯網蓬勃發展的時期，經常會面臨因用戶暴漲導致的請求不可用的情況，甚至引發連鎖反映導致整個系統崩潰。這個時候常見的解決方案之一就是限流了，當請求達到一定的並發數或速率，就進行等待、排隊、降級、拒絕服務等...
限流算法介紹
a、令牌桶算法
令牌桶算法的原理是系統會以一個恒定的速度往桶裏放入令牌，而如果請求需要被處理，則需要先從桶裏獲取一個令牌，當桶裏沒有令牌可取時，則拒絕服務。 當桶滿時，新添加的令牌被丟棄或拒絕。
b、漏桶算法
其主要目的是控制數據註入到網絡的速率，平滑網絡上的突發流量，數據可以以任意速度流入到漏桶中。 漏桶算法提供了一種機制，通過它，突發流量可以被整形以便為網絡提供一個穩定的流量。 漏桶可以看作是一個帶有常量服務時間的單服務器隊列，如果漏桶為空，則不需要流出水滴，如果漏桶（包緩存）溢出，那麽水滴會被溢出丟棄
c、計算器限流
計數器限流算法是比較常用一種的限流方案也是最為粗暴直接的，主要用來限制總並發數，比如數據庫連接池大小、線程池大小、接口訪問並發數等都是使用計數器算法
如：使用 AomicInteger 來進行統計當前正在並發執行的次數，如果超過域值就直接拒絕請求，提示系統繁忙
限流具體代碼實踐
a、導入依賴
<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>21.0</version> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> </dependency> </dependencies>
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 但是滿足不了其它類型的轉換，所以還是得自己去定義其它類型的模板
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer; import org.springframework.data.redis.serializer.StringRedisSerializer; import java.io.Serializable; /** * redis配置 */ @Configuration public class RedisConfig { @Bean public RedisTemplate<String, Serializable> limitRedisTemplate(LettuceConnectionFactory redisConnectionFactory) { RedisTemplate<String, Serializable> template = new RedisTemplate<>(); template.setKeySerializer(new StringRedisSerializer()); template.setValueSerializer(new GenericJackson2JsonRedisSerializer()); template.setConnectionFactory(redisConnectionFactory); return template; } }
d、Limit 註解
具體代碼如下
1 import com.carry.enums.LimitType; 2 3 import java.lang.annotation.Documented; 4 import java.lang.annotation.ElementType; 5 import java.lang.annotation.Inherited; 6 import java.lang.annotation.Retention; 7 import java.lang.annotation.RetentionPolicy; 8 import java.lang.annotation.Target; 9 10 /** 11 * 限流 12 */ 13 @Target({ElementType.METHOD, ElementType.TYPE}) 14 @Retention(RetentionPolicy.RUNTIME) 15 @Inherited 16 @Documented 17 public @interface Limit { 18 19 /** 20 * 資源的名字 21 * 22 * @return String 23 */ 24 String name() default ""; 25 26 /** 27 * 資源的key 28 * 29 * @return String 30 */ 31 String key() default ""; 32 33 /** 34 * Key的prefix 35 * 36 * @return String 37 */ 38 String prefix() default ""; 39 40 /** 41 * 給定的時間段 42 * 單位秒 43 * 44 * @return int 45 */ 46 int period(); 47 48 /** 49 * 最多的訪問限制次數 50 * 51 * @return int 52 */ 53 int count(); 54 55 /** 56 * 類型 57 * 58 * @return LimitType 59 */ 60 LimitType limitType() default LimitType.CUSTOMER; 61 }
1 package com.carry.enums; 2 3 public enum LimitType { 4 /** 5 * 自定義key 6 */ 7 CUSTOMER, 8 /** 9 * 根據請求者IP 10 */ 11 IP; 12 }
e、Limit 攔截器（AOP）
我們可以通過編寫 Lua 腳本實現自己的API，核心就是調用 execute 方法傳入我們的 Lua 腳本內容，然後通過返回值判斷是否超出我們預期的範圍，超出則給出錯誤提示。
1 import com.carry.annotation.Limit; 2 import com.carry.enums.LimitType; 3 import com.google.common.collect.ImmutableList; 4 import org.apache.commons.lang3.StringUtils; 5 import org.aspectj.lang.ProceedingJoinPoint; 6 import org.aspectj.lang.annotation.Around; 7 import org.aspectj.lang.annotation.Aspect; 8 import org.aspectj.lang.reflect.MethodSignature; 9 import org.slf4j.Logger; 10 import org.slf4j.LoggerFactory; 11 import org.springframework.beans.factory.annotation.Autowired; 12 import org.springframework.context.annotation.Configuration; 13 import org.springframework.data.redis.core.RedisTemplate; 14 import org.springframework.data.redis.core.script.DefaultRedisScript; 15 import org.springframework.data.redis.core.script.RedisScript; 16 import org.springframework.web.context.request.RequestContextHolder; 17 import org.springframework.web.context.request.ServletRequestAttributes; 18 19 import javax.servlet.http.HttpServletRequest; 20 import java.io.Serializable; 21 import java.lang.reflect.Method; 22 23 24 @Aspect 25 @Configuration 26 public class LimitInterceptor { 27 28 private static final Logger logger = LoggerFactory.getLogger(LimitInterceptor.class); 29 30 private final RedisTemplate<String, Serializable> limitRedisTemplate; 31 32 @Autowired 33 public LimitInterceptor(RedisTemplate<String, Serializable> limitRedisTemplate) { 34 this.limitRedisTemplate = limitRedisTemplate; 35 } 36 37 38 @Around("execution(public * *(..)) && @annotation(com.carry.annotation.Limit)") 39 public Object 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 case IP: 50 key = getIpAddress(); 51 break; 52 case CUSTOMER: 53 key = limitAnnotation.key(); 54 break; 55 default: 56 key = StringUtils.upperCase(method.getName()); 57 } 58 ImmutableList<String> keys = ImmutableList.of(StringUtils.join(limitAnnotation.prefix(), key)); 59 try { 60 String luaScript = buildLuaScript(); 61 RedisScript<Number> 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 return pjp.proceed(); 66 } else { 67 throw new RuntimeException("You have been dragged into the blacklist"); 68 } 69 } catch (Throwable e) { 70 if (e instanceof RuntimeException) { 71 throw new RuntimeException(e.getLocalizedMessage()); 72 } 73 throw new RuntimeException("server exception"); 74 } 75 } 76 77 /** 78 * 限流 腳本 79 * 80 * @return lua腳本 81 */ 82 public String buildLuaScript() { 83 StringBuilder lua = new StringBuilder(); 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 return lua.toString(); 98 } 99 100 private static final String UNKNOWN = "unknown"; 101 102 /** 103 * 獲取IP地址 104 * @return 105 */ 106 public String 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 return ip; 119 } 120 }
f、控制層
在接口上添加 @Limit() 註解，如下代碼會在 Redis 中生成過期時間為 100s 的 key = test 的記錄，特意定義了一個 AtomicInteger 用作測試
1 import com.carry.annotation.Limit; 2 import org.springframework.web.bind.annotation.GetMapping; 3 import org.springframework.web.bind.annotation.RestController; 4 5 import java.util.concurrent.atomic.AtomicInteger; 6 7 8 @RestController 9 public class LimiterController { 10 11 private static final AtomicInteger ATOMIC_INTEGER = new AtomicInteger(); 12 13 @Limit(key = "test", period = 100, count = 10, name="resource", prefix = "limit") 14 @GetMapping("/test") 15 public int testLimiter() { 16 // 意味著100S內最多可以訪問10次 17 return ATOMIC_INTEGER.incrementAndGet(); 18 } 19 }
註意：上面例子保存在redis中的key值應該為“limittest”，即@Limit中prefix的值+key的值
測試
我們在postman中快速訪問localhost:8080/test，當訪問數超過10時出現以下結果
Springboot分布式限流實踐