Spring Cloud Gateway限流实现及存在问题

 1@Configuration
 2@AutoConfigureAfter(RedisReactiveAutoConfiguration.class)
 3@AutoConfigureBefore(GatewayAutoConfiguration.class)
 4@ConditionalOnBean(ReactiveRedisTemplate.class)
 5@ConditionalOnClass({RedisTemplate.class, DispatcherHandler.class})
 6class GatewayRedisAutoConfiguration {
 7
 8	@Bean
 9	@SuppressWarnings("unchecked")
10	public RedisScript redisRequestRateLimiterScript() {
11		DefaultRedisScript redisScript = new DefaultRedisScript<>();
12		redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("META-INF/scripts/request_rate_limiter.lua")));
13		redisScript.setResultType(List.class);
14		return redisScript;
15	}
16
17	@Bean
18	//TODO: replace with ReactiveStringRedisTemplate in future
19	public ReactiveRedisTemplate<String, String> stringReactiveRedisTemplate(
20			ReactiveRedisConnectionFactory reactiveRedisConnectionFactory) {
21		RedisSerializer<String> serializer = new StringRedisSerializer();
22		RedisSerializationContext<String , String> serializationContext = RedisSerializationContext
23				.<String, String>newSerializationContext()
24				.key(serializer)
25				.value(serializer)
26				.hashKey(serializer)
27				.hashValue(serializer)
28				.build();
29		return new ReactiveRedisTemplate<>(reactiveRedisConnectionFactory,
30				serializationContext);
31	}
32
33	@Bean
34	@ConditionalOnMissingBean
35	public RedisRateLimiter redisRateLimiter(ReactiveRedisTemplate<String, String> redisTemplate,
36											 @Qualifier(RedisRateLimiter.REDIS_SCRIPT_NAME) RedisScript<List<Long>> redisScript,
37											 Validator validator) {
38		return new RedisRateLimiter(redisTemplate, redisScript, validator);
39	}
40}

1@RateLimiter(base = RateLimiter.Base.IP, path=”/sms/send”, permits = 10, timeUnit = TimeUnit.MINUTES)

 1local tokens_key = KEYS[1]  -- token对应的key
 2local timestamp_key = KEYS[2]  -- token key对应的时间key，单位：秒
 3local rate = tonumber(ARGV[1]) -- 每秒填充的速率
 4local capacity = tonumber(ARGV[2]) -- 令牌桶的容量
 5local now = tonumber(ARGV[3]) -- 当前请求的时间，单位：秒
 6local requested = tonumber(ARGV[4])  -- 请求获取令牌数
 7local fill_time = capacity/rate  -- 填满令牌桶时需要的时间
 8local ttl = math.floor(fill_time*2)  -- 设置key对应的过期时间，及时回收内存
 9
10-- 获取当前剩余的令牌，如果token对应的key不存在则创建并填满
11local last_tokens = tonumber(redis.call("get", tokens_key))
12if last_tokens == nil then
13  last_tokens = capacity
14end
15
16-- 获取上次获取令牌的时间，单位：秒
17local last_refreshed = tonumber(redis.call("get", timestamp_key))
18if last_refreshed == nil then
19  last_refreshed = 0
20end
21
22-- 计算当前请求的时间距离上一次获取令牌的时间间隔
23local delta = math.max(0, now-last_refreshed)
24-- 根据时间间隔计算当次请求需要填充的令牌数
25local filled_tokens = math.min(capacity, last_tokens+(delta*rate))
26-- 若当前剩余令牌数大于或等于当前请求令牌，则返回1
27local allowed = filled_tokens >= requested
28local new_tokens = filled_tokens
29local allowed_num = 0
30-- 扣减剩余令牌数并设置allowed_num为1
31if allowed then
32  new_tokens = filled_tokens - requested
33  allowed_num = 1
34end
35-- 更新key的过期时间
36redis.call("setex", tokens_key, ttl, new_tokens)
37redis.call("setex", timestamp_key, ttl, now)
38-- 返回获取令牌结果及剩余令牌数
39return { allowed_num, new_tokens }

 1@ConfigurationProperties("spring.cloud.gateway.redis-rate-limiter")
 2public class RedisRateLimiter extends AbstractRateLimiter<RedisRateLimiter.Config> implements ApplicationContextAware {
 3    /**
 4     * This uses a basic token bucket algorithm and relies on the fact that Redis scripts
 5     * execute atomically. No other operations can run between fetching the count and
 6     * writing the new count.
 7     */
 8    @Override
 9    @SuppressWarnings("unchecked")
10    public Mono<Response> isAllowed(String routeId, String id) {
11        //...
12        // 每秒允许多少个用户允许通过，即令牌生成速率
13        int replenishRate = routeConfig.getReplenishRate();
14        // 令牌最大数量
15        int burstCapacity = routeConfig.getBurstCapacity();
16        try {
17            List<String> keys = getKeys(id);
18            // The arguments to the LUA script. time() returns unixtime in seconds.
19            List<String> scriptArgs = Arrays.asList(replenishRate + "", burstCapacity + "",
20                    Instant.now().getEpochSecond() + "", "1");
21            // allowed, tokens_left = redis.eval(SCRIPT, keys, args)
22            Flux<List<Long>> flux = this.redisTemplate.execute(this.script, keys, scriptArgs);
23            ...
24        }
25    }
26    static List<String> getKeys(String id) {
27        // use `{}` around keys to use Redis Key hash tags
28        // this allows for using redis cluster
29        // Make a unique key per user.
30        String prefix = "request_rate_limiter.{" + id;
31        // You need two Redis keys for Token Bucket.
32        String tokenKey = prefix + "}.tokens";
33        String timestampKey = prefix + "}.timestamp";
34        return Arrays.asList(tokenKey, timestampKey);
35    }
36}