@Override    @SuppressWarnings("unchecked")    public Mono<Response> isAllowed(String routeId, String id) {        // 初始化判断        if (!this.initialized.get()) {            throw new IllegalStateException("RedisRateLimiter is not initialized");        }
        // How many requests per second do you want a user to be allowed to do?        int replenishRate = 0;
        // How much bursting do you want to allow?        int burstCapacity = 0;
        // How many tokens are requested per request?        int requestedTokens = 1;
        final RedisLimitDefinition limitDefinition;
        if(LimitListRouteDefinitionLocator.ID_PREFIX.equals(routeId.split(ValidateRequestGlobalFilter.SPLIT)[0])){            limitDefinition = limitConfig.getLimitInfoMap().get(id);            if (ObjectUtils.isEmpty(limitDefinition) ){                throw new IllegalArgumentException("No Configuration found for uri " + id);            }            replenishRate = limitDefinition.getReplenishRate();
            // How much bursting do you want to allow?            burstCapacity = limitDefinition.getBurstCapacity();        } else{            // 自定义逻辑，分为分钟级限流和秒级限流            String[] routeIdArr = routeId.split(ValidateRequestGlobalFilter.SEPARATOR);            if(routeIdArr.length > 1){                replenishRate = Integer.parseInt(routeIdArr[0]);                burstCapacity = replenishRate * 60;                limitDefinition = new RedisLimitDefinition(replenishRate, replenishRate, null, null);                requestedTokens = 60;            } else{                replenishRate = Integer.parseInt(routeIdArr[0]);                burstCapacity = replenishRate;                limitDefinition = new RedisLimitDefinition(replenishRate, replenishRate, null, null);                requestedTokens = 1;            }        }

        try {            List<String> keys = getKeys(id);
            // The arguments to the LUA script. time() returns unixtime in seconds.            List<String> scriptArgs = Arrays.asList(replenishRate + "",                    burstCapacity + "", Instant.now().getEpochSecond() + "",                    requestedTokens + "");            // allowed, tokens_left = redis.eval(SCRIPT, keys, args)            // 调用lua脚本并返回结果            Flux<List<Long>> flux = this.reactiveStringRedisTemplate.execute(this.script, keys,                    scriptArgs);            return flux.onErrorResume(throwable -> {                if (log.isDebugEnabled()) {                    log.debug("Error calling rate limiter lua", throwable);                }                return Flux.just(Arrays.asList(1L, -1L));            }).reduce(new ArrayList<Long>(), (longs, l) -> {                longs.addAll(l);                return longs;            }).map(results -> {                boolean allowed = results.get(0) == 1L;                Long tokensLeft = results.get(1);
                Response response = new Response(allowed,                        getHeaders(limitDefinition, tokensLeft));
                if (log.isDebugEnabled()) {                    log.debug("response: " + response);                }                return response;            });        }        catch (Exception e) {            /*             * We don't want a hard dependency on Redis to allow traffic. Make sure to set             * an alert so you know if this is happening too much. Stripe's observed             * failure rate is 0.01%.             */            log.error("Error determining if user allowed from redis", e);        }        return Mono.just(new Response(true, getHeaders(limitDefinition, -1L)));    }

-- 基于唯一id生成的token key和timestamp keylocal tokens_key = KEYS[1]local timestamp_key = KEYS[2]--redis.log(redis.LOG_WARNING, "tokens_key " .. tokens_key)
-- 对应的脚本入参，分别为-- 往令牌桶放置的速率，每秒n个local rate = tonumber(ARGV[1])-- 令牌桶最大容量local capacity = tonumber(ARGV[2])-- 当前时间戳，秒级local now = tonumber(ARGV[3])-- 每次请求消耗的令牌数量local requested = tonumber(ARGV[4])
-- 放满令牌桶是的时长local fill_time = capacity/rate-- redis key过期时间local ttl = math.floor(fill_time*2)
--redis.log(redis.LOG_WARNING, "rate " .. ARGV[1])--redis.log(redis.LOG_WARNING, "capacity " .. ARGV[2])--redis.log(redis.LOG_WARNING, "now " .. ARGV[3])--redis.log(redis.LOG_WARNING, "requested " .. ARGV[4])--redis.log(redis.LOG_WARNING, "filltime " .. fill_time)--redis.log(redis.LOG_WARNING, "ttl " .. ttl)
-- 这里对于last_tokens和last_refreshed的操作既是赋值也有初始化的作用-- 获取令牌桶的数量，如果为空，将令牌桶容量赋值local last_tokens = tonumber(redis.call("get", tokens_key))if last_tokens == nil then  last_tokens = capacityend--redis.log(redis.LOG_WARNING, "last_tokens " .. last_tokens)-- 获取最后的更新时间戳，如果为空，设置为0local last_refreshed = tonumber(redis.call("get", timestamp_key))if last_refreshed == nil then  last_refreshed = 0end--redis.log(redis.LOG_WARNING, "last_refreshed " .. last_refreshed)
-- 计算出上次到这次统计的时间间隔local delta = math.max(0, now-last_refreshed)-- 上次剩余的令牌数量+新生成的令牌，这个值不会大于令牌桶容量local filled_tokens = math.min(capacity, last_tokens+(delta*rate))-- 总剩余令牌是否能满足一次请求消耗的令牌local allowed = filled_tokens >= requestedlocal new_tokens = filled_tokens-- 请求是否允许通过的标志位local allowed_num = 0-- 满足的话将总数减去单次消耗的令牌记为当前桶容量，并重新放置到redis key中if allowed then  new_tokens = filled_tokens - requested  allowed_num = 1end
--redis.log(redis.LOG_WARNING, "delta " .. delta)--redis.log(redis.LOG_WARNING, "filled_tokens " .. filled_tokens)--redis.log(redis.LOG_WARNING, "allowed_num " .. allowed_num)--redis.log(redis.LOG_WARNING, "new_tokens " .. new_tokens)
if ttl > 0 then  redis.call("setex", tokens_key, ttl, new_tokens)  redis.call("setex", timestamp_key, ttl, now)end
-- return { allowed_num, new_tokens, capacity, filled_tokens, requested, new_tokens }return { allowed_num, new_tokens }