限流处理器

使用FireflySoft.RateLimit首先需要创建一个限流处理器RateLimitProcessor的实例，然后用它来过滤每一个请求。创建RateLimitProcessor的实例，至少需要提供两个信息：被限流的请求类型、限流算法和规则。其它还有限流计数持久化方式、限流错误信息，如果不提供会使用默认值。这里先不展开，后边会详细介绍它们。创建RateLimitProcessor需要采用构造器模式，如果你使用ASP.NET Core应该很熟悉，如果没什么印象打开Program.cs就可以看到了。为了提高效率，这个限流处理器一般会统一放在某个过滤器中，这个过滤器在ASP.NET中可以是一个消息处理器，在ASP.NET Core中一般就是一个中间件。为了方便集成，FireflySoft.RateLimit已经提供了一个基于ASP.NET的消息处理器和一个基于ASP.NET Core的中间件，通过Github和Nuget都可以很方便的找到他们，Github上还提供了演示程序.

被限流请求类型

被限流请求类型就是需要被限制的业务请求的类型，在ASP.NET中他可能是HttpRequestMessage，在ASP.NET Core中它可能是HttpContext，在其它业务中它可能是你自定义的一个类型XXXRequest。被限流请求类型很重要，因为不同的业务可能使用不同的请求类型，而限流处理程序需要从当前请求中提取或关联到限流目标，明确请求类型才能确定提取方法，否则对请求进行限制将无所适从

限流算法和规则

FireflySoft.RateLimit提供了四种常见的限流算法：固定窗口、滑动窗口、漏桶、令牌桶。固定窗口相对最简单，无论是算法的时间复杂度还是分布式环境实现难度都比较有优势，如果需求是在较短的时间内进行限制，比如每秒限制多少次，使用这种算法是最合适的。但是实际场景中请求在时间分布中可能不太均匀，时多时少，根据需求的不同，可能需要选择其它三种限流算法，这里不做说明了，网上已经有很多的场景选择说明。 初始化限流算法还需要提供对应的限流规则，因为不同的算法往往需要不同的参数，这里很难对不同的算法提供完全统一的限流规则，不过这些规则确实是有共同设置项的，比如限流锁定时间、目标提取方法、是否应用限流处理的判断方法等。 以上文【使用方法】中的限流代码为例，做一些介绍：

1. FixedWindowAlgorithm是此限流组件提供的固定窗口限流算法。

2. FixedWindowRateLimitRule是此限流组件提供的固定窗口限流规则类型；

3. HttpContext是业务中需要限制的请求类型，这里是Http请求上下文类型；

4. StatWindow是固定窗口的大小，是一个时间跨度；

5. LimitNumber是限流值，在StatWindow时间内请求数超过它就会触发限流；

6. LockSeconds是触发限流后的锁定时间，此时间内请求都会被阻止，不需要锁定时可以不设置；

7. ExtractTarget传递一个方法用于从请求中提取限流目标，这里是用户的每一个请求路径；

8. CheckRuleMatching传递一个方法用于检查当前请求是否需要限流检查，这里return true代表所有请求都要经过限流检查。

这里有两个比较有意思的设置：ExtractTarget和CheckRuleMatching，他们共同作用，让用户可以完全自由的定制自己限流的目标和条件，不固定是IP、ClientId或者Url。其它算法规则中每个设置项的含义可以通过其注释了解到。 如果这几个算法还不能满足要求，可以通过实现IRateLimitAlgorithm来定义一个新的算法。

计数持久化方式

FireflySoft.RateLimit中的限流计数目前支持保存在内存或者Redis中，也可以通过实现IRateLimitStorage来定义一个新的存储器。 对于只需要部署一份的程序，绝大部分情况下使用内存就够了；但是如果限流的时间窗口比较长，比如1小时限制300次，重启就会丢失计数，这可能是个风险，此时使用Redis会比较合适。 对于需要部署多份的程序，如果请求是基本均匀的，并且在每个部署之间的分配也是均匀的，那么使用内存存储器也未尝不可，将总的限流数平均分配在每一个部署中，只要有一个部署触发限流，其它部署很大几率上也会触发限流。但是对于需要部署多份的情况，采用更持久的Redis方式才是稳妥的。 相比内存访问，Redis访问需要网络交互，这会造成一定的性能损失，访问量很大时也会产生拥堵，不过也可以将请求分散到多个Redis的方式进行缓解；同时分布式环境下数据一致性的实现难度更大，即使使用Redis，比如限流处理中必然会涉及的各种时间，不同节点之间的时间不可能绝对一致，越短的时间窗口协调难度越大。因此使用滑动窗口、漏桶、令牌桶等分布式实现难度较大的算法时，需要注意时间单位的设置.

限流错误信息

限流错误信息是触发限流时限流检查结果中附带的信息，目前每个限流处理器允许设置一个统一的RateLimitError，方便业务侧进行统一处理。默认限流错误Code是429，Message为null。你也可以不使用这个定义的值，根据当前限流目标和限流规则构造自己的错误信息

限流锁定

限流锁定是触发限流时的惩罚性处理。FireflySoft.RateLimit通过设置限流规则中的LockSeconds，定义触发限流后的锁定时间，此时间内的请求都会被认定触发限流规则，而不被允许通过；如果不需要锁定忽略这个设置就可以了

如上图所示，时间单位是1秒，阈值是3。

• 第1秒3个请求，不会触发限流；

• 第2秒1个请求，不会触发限流；

• 第3秒4个请求，这一秒的前3个请求正常处理，第4个请求触发限流，会被拒绝处理。

• 后续第4秒、第5秒不会触发限流，所有请求正常处理。

Core、AspNet、Middleware 3种

Github 源码地址

GitHub - bosima/FireflySoft.RateLimit: It is a rate limiting library based on .Net standard.

ASP.NET Core 使用方法:

1、Install Nuget Package Package Manager: Install-Package FireflySoft.RateLimit.AspNetCore Or .NET CLI: dotnet add package FireflySoft.RateLimit.AspNetCore

Use Middleware 使用方法:

public void ConfigureServices(IServiceCollection services) { ...

services.AddRateLimit(new InProcessFixedWindowAlgorithm(
    new[] {
        new FixedWindowRule()
        {
            ExtractTarget = context =>
            {
                return (context as HttpContext).Request.Path.Value;
            },
            CheckRuleMatching = context =>
            {
                return true;
            },
            Name="default limit rule",
            LimitNumber=30,
            StatWindow=TimeSpan.FromSeconds(1)
        }
    })
);
​
...

}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { ...

app.UseRateLimit();
​
...

}

ASP.NET

1、Install Nuget Package:

Install-Package FireflySoft.RateLimit.AspNet

2、Register MessageHandler

Open Global.asax.cs, the following code adds the rate limit message handle:

protected void Application_Start() { ...

GlobalConfiguration.Configuration.MessageHandlers.Add(
    new RateLimitHandler(
        new Core.InProcessAlgorithm.InProcessFixedWindowAlgorithm(
            new[] {
                new FixedWindowRule()
                {
                    ExtractTarget = context =>
                    {
                        return (context as HttpRequestMessage).RequestUri.AbsolutePath;
                    },
                    CheckRuleMatching = context =>
                    {
                        return true;
                    },
                    Name="default limit rule",
                    LimitNumber=30,
                    StatWindow=TimeSpan.FromSeconds(1)
                }
            })
    ));
​
...

}

背景：为防止接口QPS太大而造成系统运行卡顿的现象，在这儿以ratelimit+redis+lua对系统接口做了个限流。当时也考虑过使用其他的限流方法，比如微服务生态中使用的sentinel中间件，但是这个如果要实现持久化要进行特殊的配置，比如使用nacos进行持久化，需要修改sntinel源码，相比较而言单纯为了限流儿集成两个中间件会显得比较臃肿，所以到最后还是使用了retelimit+redis+lua这个方案，本身redis系统中就会使用，存储token、部门信息等一些读取次数多的数据。

一、主要逻辑实现：

1. 首先确定的是要采用切面的方式，后期如果相对某一个接口进行限流可以直接采用注解的方式。
2. 其二在redis存储的key的名称要以方法名+ip的方式，这样可以更好的实现思路1指出的问题。
3. 使用lua脚本直接传到redis中操作，这样可以减少网络开销以及复用，并且可以保证是原子操作。
4. 第四点就是lua脚本的编写啦，redis 以有序队列进行存储，每一个key值都带有当前得分为当前时间戳的元素，每次新增的的时候都会将过时的元素进行清理，并进行判断是否达到限流条件。

二、代码实现：

代码结构：

限流注解接口类

package com.heyu.ratelimit.annotation;

import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.annotation.AliasFor;
import org.springframework.core.annotation.AnnotationUtils;

import java.lang.annotation.*;
import java.util.concurrent.TimeUnit;

/**
 * <p>
 * 限流注解，添加了 {@link AliasFor} 必须通过 {@link AnnotationUtils} 获取，才会生效
 * </p>
 *
 * @author: 程鹏
 * @date: 2021-02-24 14:45
 * @Description: 限流切面
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface RateLimiter {
    long DEFAULT_REQUEST = 5;


    /**
     * max 最大请求数
     */
    @AliasFor("max") long value() default DEFAULT_REQUEST;

    /**
     * max 最大请求数
     */
    @AliasFor("value") long max() default DEFAULT_REQUEST;

    /**
     * 限流key
     */
    String key() default "";

    /**
     * 超时时长，默认1分钟
     */
    long timeout() default 1;

    /**
     * 超时时间单位，默认 分钟
     */
    TimeUnit timeUnit() default TimeUnit.MINUTES;
}

切面操作类

package com.heyu.ratelimit.aspect;

import cn.hutool.core.util.StrUtil;
import com.heyu.ratelimit.annotation.RateLimiter;
import com.heyu.ratelimit.util.IpUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.time.Instant;
import java.util.Collections;
import java.util.concurrent.TimeUnit;

/**
 * @author: 程鹏
 * @date: 2021-02-24 14:13
 * @Description: 限流切面
 */
@Slf4j
@Aspect
@Component
@RequiredArgsConstructor(onConstructor_ = @Autowired)
public class RateLimiterAspect {
    private final static String SEPARATOR = ":";
    private final static String REDIS_LIMIT_KEY_PREFIX = "limit:";
    private final StringRedisTemplate stringRedisTemplate;
    private final RedisScript<Long> limitRedisScript;

    @Pointcut("@annotation(com.heyu.ratelimit.annotation.RateLimiter)")
    public void rateLimit() {

    }

    @Around("rateLimit()")
    public Object pointcut(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();

        Method method = signature.getMethod();
        // 通过 AnnotationUtils.findAnnotation 获取 RateLimiter 注解
        RateLimiter rateLimiter = AnnotationUtils.findAnnotation(method, RateLimiter.class);
        if (rateLimiter != null) {
            String key = rateLimiter.key();
            // 默认用类名+方法名做限流的 key 前缀
            if (StrUtil.isBlank(key)) {
                key = method.getDeclaringClass().getName() + StrUtil.DOT + method.getName();
            }
            // 最终限流的 key 为 前缀 + IP地址
            // TODO: 此时需要考虑局域网多用户访问的情况，因此 key 后续需要加上方法参数更加合理
            key = key + SEPARATOR + IpUtil.getIpAddr();

            long max = rateLimiter.max();
            long timeout = rateLimiter.timeout();
            TimeUnit timeUnit = rateLimiter.timeUnit();
            boolean limited = shouldLimited(key, max, timeout, timeUnit);
            if (limited) {
                throw new RuntimeException("手速太快了，慢点儿吧~");
            }
        }

        return point.proceed();
    }

    private boolean shouldLimited(String key, long max, long timeout, TimeUnit timeUnit) {
        // 最终的 key 格式为：
        // limit:自定义key:IP
        // limit:类名.方法名:IP
        key = REDIS_LIMIT_KEY_PREFIX + key;
        // 统一使用单位毫秒
        long ttl = timeUnit.toMillis(timeout);
        // 当前时间毫秒数
        long now = Instant.now().toEpochMilli();
        long expired = now - ttl;
        // 注意这里必须转为 String,否则会报错 java.lang.Long cannot be cast to java.lang.String
        Long executeTimes = stringRedisTemplate.execute(limitRedisScript, Collections.singletonList(key), now + "", ttl + "", expired + "", max + "");
        if (executeTimes != null) {
            if (executeTimes == 0) {
                log.error("【{}】在单位时间 {} 毫秒内已达到访问上限，当前接口上限 {}", key, ttl, max);
                return true;
            } else {
                log.info("【{}】在单位时间 {} 毫秒内访问 {} 次", key, ttl, executeTimes);
                return false;
            }
        }
        return false;
    }
}

redis配置类

package com.heyu.ratelimit.config;

import org.springframework.context.annotation.Bean;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.scripting.support.ResourceScriptSource;
import org.springframework.stereotype.Component;

/**
 * @author: 程鹏
 * @date: 2021-02-26 14:35
 * @Description:
 */
@Component
public class RedisConfig {
    @Bean
    @SuppressWarnings("unchecked")
    public RedisScript<Long> limitRedisScript() {
        DefaultRedisScript redisScript = new DefaultRedisScript<>();
        redisScript.setScriptSource(new ResourceScriptSource(new ClassPathResource("redis/limit.lua")));
        redisScript.setResultType(Long.class);
        return redisScript;
    }
}

Ip解析类

package com.heyu.ratelimit.util;

import cn.hutool.core.util.StrUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

/**
 * @author: 程鹏
 * @date: 2021-02-26 14:28
 * @Description:
 */
@Slf4j
public class IpUtil {
    private final static String UNKNOWN = "unknown";
    private final static int MAX_LENGTH = 15;

    /**
     * 获取IP地址
     * 使用Nginx等反向代理软件， 则不能通过request.getRemoteAddr()获取IP地址
     * 如果使用了多级反向代理的话，X-Forwarded-For的值并不止一个，而是一串IP地址，X-Forwarded-For中第一个非unknown的有效IP字符串，则为真实IP地址
     */
    public static String getIpAddr() {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        String ip = null;
        try {
            ip = request.getHeader("x-forwarded-for");
            if (StrUtil.isEmpty(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("Proxy-Client-IP");
            }
            if (StrUtil.isEmpty(ip) || ip.length() == 0 || UNKNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("WL-Proxy-Client-IP");
            }
            if (StrUtil.isEmpty(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_CLIENT_IP");
            }
            if (StrUtil.isEmpty(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
            }
            if (StrUtil.isEmpty(ip) || UNKNOWN.equalsIgnoreCase(ip)) {
                ip = request.getRemoteAddr();
            }
        } catch (Exception e) {
            log.error("IPUtils ERROR ", e);
        }
        // 使用代理，则获取第一个IP地址
        if (!StrUtil.isEmpty(ip) && ip.length() > MAX_LENGTH) {
            if (ip.indexOf(StrUtil.COMMA) > 0) {
                ip = ip.substring(0, ip.indexOf(StrUtil.COMMA));
            }
        }
        log.error("访客ip:"+ip);
        return ip;
    }
}

lua脚本

-- 下标从 1 开始
local key = KEYS[1]
local now = tonumber(ARGV[1])
local ttl = tonumber(ARGV[2])
local expired = tonumber(ARGV[3])
-- 最大访问量
local max = tonumber(ARGV[4])

-- 清除过期的数据
-- 移除指定分数区间内的所有元素，expired 即已经过期的 score
-- 根据当前时间毫秒数 - 超时毫秒数，得到过期时间 expired
redis.call('zremrangebyscore', key, 0, expired)

-- 获取 zset 中的当前元素个数
local current = tonumber(redis.call('zcard', key))
local next = current + 1

if next > max then
  -- 达到限流大小 返回 0
  return 0;
else
  -- 往 zset 中添加一个值、得分均为当前时间戳的元素，[value,score]
  redis.call("zadd", key, now, now)
  -- 每次访问均重新设置 zset 的过期时间，单位毫秒
  redis.call("pexpire", key, ttl)
  return next
end

controller层测试

1.常用限流算法

1.1计数器法

计数器是最简单的限流算法，思路是维护一个单位时间内的计数器 Counter，如判断单位时间已经过去，则将计数器归零。

我们假设有个需求对于某个接口 /query 每分钟最多允许访问 200 次。

1. 可以在程序中设置一个变量 count，当过来一个请求我就将这个数 +1，同时记录请求时间。
2. 当下一个请求来的时候判断 count 的计数值是否超过设定的频次，以及当前请求的时间和第一次请求时间是否在 1 分钟内。
3. 如果在 1 分钟内并且超过设定的频次则证明请求过多，后面的请求就拒绝掉。
4. 如果该请求与第一个请求的间隔时间大于 1 分钟，且 count 值还在限流范围内，就重置 count。

1.2滑动窗口

滑动窗口（Sliding window）（https://en.wikipedia.org/wiki/Sliding_window_protocol） 是一种流量控制技术，这个词出现在 TCP 协议中。我们来看看在限流中它是怎样表现的：

上图中我们用红色的虚线代表一个时间窗口（一分钟），每个时间窗口有 6 个格子，每个格子是 10 秒钟。每过 10 秒钟时间窗口向右移动一格，可以看红色箭头的方向。我们为每个格子都设置一个独立的计数器 Counter，假如一个请求在 0:45 访问了那么我们将第五个格子的计数器 +1（也是就是 0:40~0:50），在判断限流的时候需要把所有格子的计数加起来和设定的频次进行比较即可。

我再来回顾一下刚才的计数器算法，我们可以发现，计数器算法其实就是滑动窗口算法。只是它没有对时间窗口做进一步地划分，所以只有1格。

由此可见，当滑动窗口的格子划分的越多，那么滑动窗口的滚动就越平滑，限流的统计就会越精确。

1.3漏桶算法

从图中我们可以看到，整个算法其实十分简单。首先，我们有一个固定容量的桶，有水流进来，也有水流出去。对于流进来的水来说，我们无法预计一共有多少水会流进来，也无法预计水流的速度。但是对于流出去的水来说，这个桶可以固定水流出的速率。而且，当桶满了之后，多余的水将会溢出。

我们将算法中的水换成实际应用中的请求，我们可以看到漏桶算法天生就限制了请求的速度。当使用了漏桶算法，我们可以保证接口会以一个常速速率来处理请求。

漏桶算法有以下特点：

• 漏桶具有固定容量，出水速率是固定常量（流出请求）
• 如果桶是空的，则不需流出水滴
• 可以以任意速率流入水滴到漏桶（流入请求）
• 如果流入水滴超出了桶的容量，则流入的水滴溢出（新请求被拒绝）

漏桶限制的是常量流出速率（即流出速率是一个固定常量值），所以最大的速率就是出水的速率，不能出现突发流量。

1.4令牌桶算法

令牌桶算法和漏桶算法的方向刚好是相反的，我们有一个固定容量的桶，桶里存放着令牌（token）。桶一开始是空的，token以 一个固定的速率r往桶里填充，直到达到桶的容量，多余的令牌将会被丢弃。每当一个请求过来时，就会尝试从桶里移除一个令牌，如果没有令牌的话，请求无法通过。

令牌桶有以下特点：

• 令牌按固定的速率被放入令牌桶中
• 桶中最多存放 B 个令牌，当桶满时，新添加的令牌被丢弃或拒绝
• 如果桶中的令牌不足 N 个，则不会删除令牌，且请求将被限流（丢弃或阻塞等待）

令牌桶限制的是平均流入速率（允许突发请求，只要有令牌就可以处理，支持一次拿3个令牌，4个令牌），并允许一定程度突发流量。

1.5 小结

计数器和滑动窗口比较

计数器算法实现起来最简单，可以看成是滑动窗口的低精度实现。滑动窗口由于需要存储多份的计数器（每一个格子存一份），所以滑动窗口在实现上需要更多的存储空间。也就是说，如果滑动窗口的精度越高，需要的存储空间就越大。

漏桶算法和令牌桶算法比较

2.ratelimit总览

开启zuul服务限流的组件，包含五种内置的限流方式：

只需向列表中添加多个值，就可以将经过身份验证的用户、请求源、URL、角色和请求方法组合在一起

3.用法

添加ratelimit依赖

<dependency>
    <groupId>com.marcosbarbero.cloud</groupId>
    <artifactId>spring-cloud-zuul-ratelimit</artifactId>
    <version>LATEST</version>
</dependency>

使用数据存储不同，则需引入不同依赖

Redis:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

Consul:

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-consul</artifactId>
</dependency>

Spring Data JPA:

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

Bucket4j JCache:

<dependency>
     <groupId>com.github.vladimir-bukhtoyarov</groupId>
     <artifactId>bucket4j-core</artifactId>
</dependency>

<dependency>
     <groupId>com.github.vladimir-bukhtoyarov</groupId>
     <artifactId>bucket4j-jcache</artifactId>
</dependency>

<dependency>
     <groupId>javax.cache</groupId>
     <artifactId>cache-api</artifactId>
</dependency>

Bucket4j Hazelcast (depends on Bucket4j JCache):

<dependency>
     <groupId>com.github.vladimir-bukhtoyarov</groupId>
     <artifactId>bucket4j-hazelcast</artifactId>
</dependency>

<dependency>
     <groupId>com.hazelcast</groupId>
     <artifactId>hazelcast</artifactId>
</dependency>

Bucket4j Infinispan (depends on Bucket4j JCache):

<dependency>
     <groupId>com.github.vladimir-bukhtoyarov</groupId>
     <artifactId>bucket4j-infinispan</artifactId>
</dependency>

<dependency>
     <groupId>org.infinispan</groupId>
     <artifactId>infinispan-core</artifactId>
</dependency>

Bucket4j Ignite (depends on Bucket4j JCache):

<dependency>
     <groupId>com.github.vladimir-bukhtoyarov</groupId>
     <artifactId>bucket4j-ignite</artifactId>
</dependency>

<dependency>
     <groupId>org.apache.ignite</groupId>
     <artifactId>ignite-core</artifactId>
</dependency>

配置示例：

zuul:
  ratelimit:
    key-prefix: your-prefix  #限流key前缀
    enabled: true      #是否启用限流
    repository: REDIS  #使用何种方式存储数据
    behind-proxy: true
    add-response-headers: true
    default-policy-list: #optional - will apply unless specific policy exists  默认策略 （60s内超过10次或请求时间累积超过1000s触发限流）
      - limit: 10 #optional - request number limit per refresh interval window  单位时间内请求次数限制
        quota: 1000 #optional - request time limit per refresh interval window (in seconds)  单位时间内累计请求时间限制（秒）
        refresh-interval: 60 #default value (in seconds)   限流时间窗口，默认60s
        type: #optional  限流方式
          - user
          - origin
          - url
          - httpmethod
    policy-list:  # 自定义策略
      myServiceId: #本例配置：60s内超过10次，请求时间累积超过1000s触发限流
        - limit: 10 #optional - request number limit per refresh interval window 单位时间内请求次数限制
          quota: 1000 #optional - request time limit per refresh interval window (in seconds) 单位时间内累计请求时间限制（秒）
          refresh-interval: 60 #default value (in seconds)  限流时间窗口，默认60s
          type: #optional 限流方式
            - user
            - origin
            - url
        - type: #optional value for each type
            - user=anonymous
            - origin=somemachine.com
            - url=/api #url prefix
            - role=user
            - httpmethod=get #case insensitive

4.多种实现

Memory

1.7.1.RELEASE

2.2.6.RELEASE

5.常用配置解读

zuul.ratelimit. :配置项

policy(策略配置项)：

6.自定义生成key

@RequiredArgsConstructor
public class CustomRateLimitKeyGenerator implements RateLimitKeyGenerator {
 
    private final RateLimitProperties properties;
    private final RateLimitUtils rateLimitUtils;
 
    @Override
    public String key(final HttpServletRequest request, final Route route, final Policy policy) {
        final List<Type> types = policy.getType().stream().map(MatchType::getType).collect(Collectors.toList());
        final StringJoiner joiner = new StringJoiner(":");
        joiner.add(properties.getKeyPrefix());
        if (route != null) {
            joiner.add(route.getId());
        }
        if (!types.isEmpty()) {
            if (types.contains(Type.URL) && route != null) {
                joiner.add(route.getPath());
            }
            if (types.contains(Type.ORIGIN)) {
                joiner.add(rateLimitUtils.getRemoteAddress(request));
            }
            if (types.contains(Type.USER)) {
                joiner.add(rateLimitUtils.getUser(request));
            }
        }
        return joiner.toString();
    }
}

7.源码

properties配置类：

RateLimitProperties加载前缀：zuul.ratelimit的配置

@Data
@Validated
@RefreshScope
@NoArgsConstructor
@ConfigurationProperties(RateLimitProperties.PREFIX)
public class RateLimitProperties {
 
    public static final String PREFIX = "zuul.ratelimit";

key\rate

redis\jpa\consul 用的是计数器的方式实现限流，不同的限流策略生成一个限流key，计算剩余的限流数据等存入rate,key–rate 一一对应，请求进来后由key查询是否已有rate,没有则生成rate保存，后置filter更新剩余请求次数、请求耗时

public class Rate {
 
    @Id
    @Column(name = "rate_key")
    private String key;
    /**
     * 剩余的请求数
     *
     */
    private Long remaining;
    /**
     * 剩余的请求耗时
     *
     */
    private Long remainingQuota;
    /**
     *
     *
     */
    private Long reset;
    /**
     * 过期时间
     *
     */
    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy HH:mm:ss")
    private Date expiration;
}

前置过滤

取得配置的Route信息，策略集合，遍历集合，生成限流key,创建rate(保存或更新),比较limit调用次数，请求时间是否超过阈值

后置过滤

计算请求耗时，更新key值对应的 限流rate的请求时间阈值