springcloudgateway实现自定义限流

目录

概要

1，限流的原理

2，自定义限流的代码实现

3，限流工具的使用

复杂例子和完整代码

疑难杂症1：限流不起作用

疑难杂症2：限流的类取不到前面HeaderDealFilter中我放入header中的信息

---

---

概要

springcloudgateway的限流网上有很多介绍的，官网上说的也很详细。我想说的是限流的key要有不同的限流配置参数，

实现自定义限流。

通用的例子是，你定义一个KeyResolver，然后再在yml配置限流需要得2个参数：redis-rate-limiter.replenishRate（限流速率），redis-rate-limiter.burstCapacity（令牌桶大小）。

这样限流就做好了。

例子不再贴代码。

这样的限流是根据你定义的KeyResolver（可以是url,IP,系统名称，用户参数等，总之就是一个字符串，这就是限流的key或者叫限流的维度），用配置的replenishRate（限流速率）和burstCapacity（令牌桶大小）去限流。

问题是：我想在KeyResolver上，每个具体的KeyResolver值有不同的replenishRate（限流速率）和burstCapacity（令牌桶大小），

而不是用yml中写死的那个。比如你要根据IP进行限流，你定义你的KeyResolver为：

@Bean
	public KeyResolver hostAddrKeyResolver2() {
		return exchange -> Mono.just(exchange.getRequest().getRemoteAddress().getHostName());
	}

定义的限流参数为：

           redis-rate-limiter.replenishRate: 1
           redis-rate-limiter.burstCapacity: 2

那么请求的所有请求来得IP都是这一个限流配置。

我想实现自定义限流，比如同样按照IP进行限流，但是192.168.2.11的限流是

           redis-rate-limiter.replenishRate: 1
           redis-rate-limiter.burstCapacity: 2

192.168.2.12的限流是

           redis-rate-limiter.replenishRate: 100
           redis-rate-limiter.burstCapacity: 200

192.168.2.13的限流是

           redis-rate-limiter.replenishRate: 500
           redis-rate-limiter.burstCapacity: 2000

这才是实际场景下的客户需求。那要怎么实现呢？

这就是我要说的自定义限流。

文章结构主要如下，只讲干货：

1，限流的原理

限流目前通用的是令牌桶算法，有2个关键参数 replenishRate（限流速率），burstCapacity（令牌桶大小）

限流速率可以理解为，1秒钟放出几个令牌到令牌桶。

令牌桶大小就是令牌桶最多能放几个令牌。

限流的核心思路就是，每过来一个请求，必须从令牌桶取一个令牌，有了这个通行证，才不会被限流。

想象一个水管往一个桶匀速的注入水（1秒2滴），有个桶能装100滴水。

有请求过来后，从桶里取一滴水才能通行，取不到水的请求就被拦截了。

这个结构，令牌桶不是必须的，因为直接从水管取水也是可以的，这就是漏桶算法。

加一个令牌桶就是有机会缓存一桶水。当请求少的时候，令牌桶的水是多余流速 （1秒2滴）的。

这样就发生一种现象，最开始的时候，桶里可能存满了水（100滴），这时候有大量请求一起访问。

那么在最初的1秒，这个令牌桶结构可以提供100滴水，而不是2滴。假如后面请求还是很多，那么

令牌桶的水就取决取水管流速的大小（即注入的水马上就被抢光了），这时候也就是限流的阶段了。

这个令牌桶也是原来漏桶算法的改进。

 

回到代码实现，在代码中怎么实现这个原理呢？

首先对请求限流，首先想到的必然是filter拦截器。

满足条件的放行，不满足的拒绝。

然后，限流维度的定义。

我们既然要根据请求的不同特征取限流，那必然要从request中获取这些信息。

所以，request能获取到的信息都可以作为限流的维度。

比如，你可以从request获取到IP地址，URL，parameter，cookie，还能从header中获取一些信息。

这些信息都可以作为限流的维度。

最后，令牌桶要根据具体的限流维度的key值，运转水管和水桶。

这个临时信息放在那里呢？

令牌桶的算法是固定的，你桶里目前有没有水，这个信息是实时变化的。必须存起来，下一个请求过来时，

才能决定限流是否通过。

 

这些临时信息存储的地方也是有很多选择。

比如，我可以放在java的内存中，可以放在数据库中，可以放在文件中。

还可以放在redis中。

这些方案最终影响是不同的。

在多实例分布式的场景中，如果放在内存冲，如果没有做内存同步，那么每个实例内存中的令牌桶都是各自为营。

你定义的限流速率和令牌桶大小都是每个实例中各一套。

如果我想所有应用实例总共的请求做一个公共的限流，那么就必须把令牌桶放在一个公共的地方，

这样不管哪个应用实例来得请求，都是在公共的这个令牌桶排队，也就是全局的限流。

目前通用的方案都是redis。redis速度快，本身在分布式架构中做session和缓存服务器，所以

目前通用的限流都依赖redis。

说了这么多，看看springcloudgateway的filter怎么实现的：

#        - name: RequestRateLimite
#          args:
#            key-resolver: "#{@uriKeyResolverMy}" 
#            redis-rate-limiter.replenishRate: 1
#            redis-rate-limiter.burstCapacity: 2

这个filter其实是：RequestRateLimiterGatewayFilterFactory

源码：

/*
 * Copyright 2013-2017 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

package org.springframework.cloud.gateway.filter.factory;

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.cloud.gateway.filter.ratelimit.RateLimiter;
import org.springframework.cloud.gateway.route.Route;
import org.springframework.cloud.gateway.support.ServerWebExchangeUtils;
import org.springframework.http.HttpStatus;

import java.util.Map;

/**
 * User Request Rate Limiter filter. See https://stripe.com/blog/rate-limiters and
 */
public class RequestRateLimiterGatewayFilterFactory extends AbstractGatewayFilterFactory {

	public static final String KEY_RESOLVER_KEY = "keyResolver";

	private final RateLimiter defaultRateLimiter;
	private final KeyResolver defaultKeyResolver;

	public RequestRateLimiterGatewayFilterFactory(RateLimiter defaultRateLimiter,
												  KeyResolver defaultKeyResolver) {
		super(Config.class);
		this.defaultRateLimiter = defaultRateLimiter;
		this.defaultKeyResolver = defaultKeyResolver;
	}

	public KeyResolver getDefaultKeyResolver() {
		return defaultKeyResolver;
	}

	public RateLimiter getDefaultRateLimiter() {
		return defaultRateLimiter;
	}

	@SuppressWarnings("unchecked")
	@Override
	public GatewayFilter apply(Config config) {
		KeyResolver resolver = (config.keyResolver == null) ? defaultKeyResolver : config.keyResolver;
		RateLimiter