SpringCloud学习系列Gateway-（3）限流篇

最新推荐文章于 2024-06-05 22:51:17 发布
最新推荐文章于 2024-06-05 22:51:17 发布
阅读量2.9k 收藏 3
点赞数 1
分类专栏： SpringCloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012661488/article/details/107126234
版权

目录

前言

简单限流

源码分析

扩展限流

前言

通常一个应用，无论是全部请求还是细化到每一个接口的请求，都会有一个每秒请求量QPS的峰值，一般会通过压测的方式评估出接口的峰值是多少，一旦超过这个峰值，应用将会响应缓慢，严重的甚至会导致应用假死。

如何防止这种情况的发生呢？这时候就需要对请求进行限流，在某一时刻只允许一部分低于峰值的请求流量进来应用，提高系统的可用性。

这章节就会基于SpringCloud Gateway进行限流实现。

简单限流

一、通过配置的方式进行限流，配置gateway的application.yml文件，如下：

server:
  port: 8099
spring:
  application:
    name: gateway-frame
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true
          # 服务名小写
          lower-case-service-id: true
      routes:
      - id: gateway-service
        # lb代表从注册中心获取服务，且已负载均衡方式转发
        uri: lb://gateway-service
        predicates:
        - Path=/service/**
        # 限流filter配置
        filters:
        - name: RequestRateLimiter
          args:
            key-resolver: '#{@uriKeyResolver}'
            redis-rate-limiter.replenishRate: 300
            redis-rate-limiter.burstCapacity: 300
  redis:
      host: xxxxxxx
      port: 6379
      password: xxxxxx
      database: 0

# 注册中心
eureka:
  instance:
    prefer-ip-address: true
  client:
    service-url:
      defaultZone: http://xxxxxxx:8761/eureka/

限流配置组成解读：

1、引入filte的配置-name: RequestRateLimiter，这个是使用已经实现好的RequestRateLimiterGatewayFilterFactory类进行限流；

2、key-resolver：用于获取限流维度的实现类，可以根据ip、uri、设备号、用户id等进行限流，这里使用的uriKeyResolver对应实现使用uri限流的类；

3、redis-rate-limiter.burstCapacity：令牌桶容量，就是没秒能够同时有多少个访问请求；

4、redis-rate-limiter.replenishRate：令牌桶每秒的填充量

5、因为限流类依赖于redis进行统计数据的存储，所以这里要加上redis的连接配置；

二、编写key-resolver

使用uri的维度限流

import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

public class UriKeyResolver implements KeyResolver {

    @Override
    public Mono<String> resolve(ServerWebExchange exchange) {
        return Mono.just(exchange.getRequest().getURI().getPath());
    }

}

三、bean初始化

@Component
public class RateConfig {
   
    @Bean
    public UriKeyResolver uriKeyResolver() {
        return new UriKeyResolver();
    }

}

这样就完成了应用的简单限流。测试的时候可以把令牌桶的参数设置小一点，然后使用jmeter进行压测。

源码分析

首先，我们来看下SpringCloud Gateway的初始化方式和路由执行方式。（gateway的maven版本：2.2.3.RELEASE）

1、初始化配置信息，我们来看下org.springframework.cloud:spring-cloud-gateway-core包下面的META-INF/spring.factories文件；

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
// 校验引用配置
org.springframework.cloud.gateway.config.GatewayClassPathWarningAutoConfiguration,\
// gateway网关的核心配置，路由等
org.springframework.cloud.gateway.config.GatewayAutoConfiguration,\
// 熔断配置
org.springframework.cloud.gateway.config.GatewayHystrixCircuitBreakerAutoConfiguration,\
org.springframework.cloud.gateway.config.GatewayResilience4JCircuitBreakerAutoConfiguration,\
// 负载均衡配置
org.springframework.cloud.gateway.config.GatewayLoadBalancerClientAutoConfiguration,\
org.springframework.cloud.gateway.config.GatewayNoLoadBalancerClientAutoConfiguration,\
org.springframework.cloud.gateway.config.GatewayMetricsAutoConfiguration,\
// redis限流配置
org.springframework.cloud.gateway.config.GatewayRedisAutoConfiguration,\
// 注册中心配置
org.springframework.cloud.gateway.discovery.GatewayDiscoveryClientAutoConfiguration,\
org.springframework.cloud.gateway.config.SimpleUrlHandlerMappingGlobalCorsAutoConfiguration,\
org.springframework.cloud.gateway.config.GatewayReactiveLoadBalancerClientAutoConfiguration
 
org.springframework.boot.env.EnvironmentPostProcessor=\
org.springframework.cloud.gateway.config.GatewayEnvironmentPostProcessor

这一章，我们关注redis限流配置类org.springframework.cloud.gateway.config.GatewayRedisAutoConfiguration

class GatewayRedisAutoConfiguration {

	@Bean
	@SuppressWarnings("unchecked")
	public RedisScript redisRequestRateLimiterScript() {
		DefaultRedisScript redisScript = new DefaultRedisScript<>();
		redisScript.setScriptSource(new ResourceScriptSource(
				new ClassPathResource("META-INF/scripts/request_rate_limiter.lua")));
		redisScript.setResultType(List.class);
		return redisScript;
	}

	@Bean
	@ConditionalOnMissingBean
	public RedisRateLimiter redisRateLimiter(ReactiveStringRedisTemplate redisTemplate,
			@Qualifier(RedisRateLimiter.REDIS_SCRIPT_NAME) RedisScript<List<Long>> redisScript,
			ConfigurationService configurationService) {
		return new RedisRateLimiter(redisTemplate, redisScript, configurationService);
	}

}

这里初始化了两个类：

一个是RedisScript，用于执行redis的限流数据操作的lua脚本，lua文件路径定义；

另外一个是RedisRateLimiter，负责限流判断逻辑，这里采用@ConditionalOnMissingBean，就是当没有继承RateLimiter接口类的bean进行初始化时才生效。（注意：这里就是预留的让我们进行自定义限流的实现方式，后面实现动态限流就可以从这里入手）

那么什么时候才会用到这个RedisRateLimiter类呢，先别急，我们回头再看我们配置里的-name: RequestRateLimiter对应的工厂类RequestRateLimiterGatewayFilterFactory，限流的入口就是从这里来的：

@ConfigurationProperties("spring.cloud.gateway.filter.request-rate-limiter")
public class RequestRateLimiterGatewayFilterFactory extends
		AbstractGatewayFilterFactory<RequestRateLimiterGatewayFilterFactory.Config> {

	@SuppressWarnings("unchecked")
	@Override
	public GatewayFilter apply(Config config) {
		// 这里设置使用配置的限流维度实现类KeyResolver和限流逻辑类RateLimiter
		KeyResolver resolver = getOrDefault(config.keyResolver, defaultKeyResolver);
		RateLimiter<Object> limiter = getOrDefault(config.rateLimiter,
				defaultRateLimiter);
		boolean denyEmpty = getOrDefault(config.denyEmptyKey, this.denyEmptyKey);
		HttpStatusHolder emptyKeyStatus = HttpStatusHolder
				.parse(getOrDefault(config.emptyKeyStatus, this.emptyKeyStatusCode));

		return (exchange, chain) -> resolver.resolve(exchange).defaultIfEmpty(EMPTY_KEY)
				.flatMap(key -> {
					if (EMPTY_KEY.equals(key)) {
						if (denyEmpty) {
							setResponseStatus(exchange, emptyKeyStatus);
							return exchange.getResponse().setComplete();
						}
						return chain.filter(exchange);
					}
					String routeId = config.getRouteId();
					if (routeId == null) {
						Route route = exchange
								.getAttribute(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR);
						routeId = route.getId();
					}
					// 执行限流判断
					return limiter.isAllowed(routeId, key).flatMap(response -> {

						for (Map.Entry<String, String> header : response.getHeaders()
								.entrySet()) {
							exchange.getResponse().getHeaders().add(header.getKey(),
									header.getValue());
						}

						if (response.isAllowed()) {
							return chain.filter(exchange);
						}

						setResponseStatus(exchange, config.getStatusCode());
						return exchange.getResponse().setComplete();
					});
				});
	}

}

这里就会调用RedisRateLimiter的isAllowed方法判断是否进行限流：

@ConfigurationProperties("spring.cloud.gateway.redis-rate-limiter")
public class RedisRateLimiter extends AbstractRateLimiter<RedisRateLimiter.Config>
		implements ApplicationContextAware {

	@Override
	@SuppressWarnings("unchecked")
	public Mono<Response> isAllowed(String routeId, String id) {
		if (!this.initialized.get()) {
			throw new IllegalStateException("RedisRateLimiter is not initialized");
		}
        // 根据服务应用id获取限流配置
		Config routeConfig = loadConfiguration(routeId);

		// 设置的令牌每秒加入数量
		int replenishRate = routeConfig.getReplenishRate();
        // 设置的令牌桶容量
		int burstCapacity = routeConfig.getBurstCapacity();

		// How many tokens are requested per request?
		int requestedTokens = routeConfig.getRequestedTokens();

		try {
            // 获取redis的中的统计数据查询key
			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)
			Flux<List<Long>> flux = this.redisTemplate.execute(this.script, keys,
					scriptArgs);
			// .log("redisratelimiter", Level.FINER);
			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(routeConfig, 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(routeConfig, -1L)));
	}
	
}

我们可以debug看下传入的参数routeId和id，分别是请求的应用服务id和uri：

看下getKeys(id)方法，知道redis中的统计数据存储格式：

	static List<String> getKeys(String id) {
		String prefix = "request_rate_limiter.{" + id;

		String tokenKey = prefix + "}.tokens";
		String timestampKey = prefix + "}.timestamp";
		return Arrays.asList(tokenKey, timestampKey);
	}
  • request_rate_limiter.{uri}.tokens 可使用的令牌数量
  • request_rate_limiter.{uri}.timestamp  最后一个请求的时间

扩展限流

在实际生产中，限流参数不是一开始就定好不变，会根据实际业务情况进行相应的调整，而且一般会采用数据库存储的方式。但是由于RequestRateLimiterGatewayFilterFactory初始化后，不能实时进行限流参数的变更，那么限流的作用就要大打折扣了。

这时候，我们可以通过继承RateLimiter接口类实现isAllow方法进行拓展成实现刷新限流配置的效果。

1、仿照RedisRateLimiter类实现DynamicRedisRateLimiter


import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeansException;
import org.springframework.cloud.gateway.filter.ratelimit.AbstractRateLimiter;
import org.springframework.cloud.gateway.support.ConfigurationService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.data.redis.core.ReactiveStringRedisTemplate;
import org.springframework.data.redis.core.script.RedisScript;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.time.Instant;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * @PackageName 
 * @ClassName DynamicRedisRateLimiter
 * @Description 动态限流模块
 * @Auth 
 * @Date 2020/6/20 19:02
 * @Version 1.0
 **/
public class DynamicRedisRateLimiter extends AbstractRateLimiter<DynamicRedisRateConfig> implements ApplicationContextAware {

    private static final String CONFIGURATION_PROPERTY_NAME = "custom-redis-rate-limiter";
    private static final String REDIS_SCRIPT_NAME = "redisRequestRateLimiterScript";
    private static final String REMAINING_HEADER = "X-RateLimit-Remaining";
    private static final String REPLENISH_RATE_HEADER = "X-RateLimit-Replenish-Rate";
    private static final String BURST_CAPACITY_HEADER = "X-RateLimit-Burst-Capacity";
    private static final String REQUESTED_TOKENS_HEADER = "X-RateLimit-Requested-Tokens";

    private Log log;
    private ReactiveStringRedisTemplate redisTemplate;
    private RedisScript<List<Long>> script;
    private AtomicBoolean initialized;
    private DynamicRedisRateConfig defaultConfig;
    private boolean includeHeaders;
    private String remainingHeader;
    private String replenishRateHeader;
    private String burstCapacityHeader;
    private String requestedTokensHeader;

    public DynamicRedisRateLimiter(int defaultReplenishRate, int defaultBurstCapacity, int defaultRequestedTokens) {
        super(DynamicRedisRateConfig.class, CONFIGURATION_PROPERTY_NAME, (ConfigurationService)null);
        this.log = LogFactory.getLog(this.getClass());
        this.initialized = new AtomicBoolean(false);
        this.includeHeaders = true;
        this.remainingHeader = REMAINING_HEADER;
        this.replenishRateHeader = REPLENISH_RATE_HEADER;
        this.burstCapacityHeader = BURST_CAPACITY_HEADER;
        this.requestedTokensHeader = REQUESTED_TOKENS_HEADER;
        this.defaultConfig = (new DynamicRedisRateConfig()).setReplenishRate(defaultReplenishRate).setBurstCapacity(defaultBurstCapacity).setRequestedTokens(defaultRequestedTokens);
    }

    public DynamicRedisRateLimiter(DynamicRedisRateConfig defaultConfig) {
        super(DynamicRedisRateConfig.class, CONFIGURATION_PROPERTY_NAME, (ConfigurationService)null);
        this.log = LogFactory.getLog(this.getClass());
        this.initialized = new AtomicBoolean(false);
        this.includeHeaders = true;
        this.remainingHeader = REMAINING_HEADER;
        this.replenishRateHeader = REPLENISH_RATE_HEADER;
        this.burstCapacityHeader = BURST_CAPACITY_HEADER;
        this.requestedTokensHeader = REQUESTED_TOKENS_HEADER;
        this.defaultConfig = defaultConfig;
    }

    private static List<String> getKeys(String routeKey) {
        String prefix = "request_rate_limiter.{" + routeKey;
        String tokenKey = prefix + "}.tokens";
        String timestampKey = prefix + "}.timestamp";
        return Arrays.asList(tokenKey, timestampKey);
    }

    public boolean isIncludeHeaders() {
        return this.includeHeaders;
    }

    public void setIncludeHeaders(boolean includeHeaders) {
        this.includeHeaders = includeHeaders;
    }

    public String getRemainingHeader() {
        return this.remainingHeader;
    }

    public void setRemainingHeader(String remainingHeader) {
        this.remainingHeader = remainingHeader;
    }

    public String getReplenishRateHeader() {
        return this.replenishRateHeader;
    }

    public void setReplenishRateHeader(String replenishRateHeader) {
        this.replenishRateHeader = replenishRateHeader;
    }

    public String getBurstCapacityHeader() {
        return this.burstCapacityHeader;
    }

    public void setBurstCapacityHeader(String burstCapacityHeader) {
        this.burstCapacityHeader = burstCapacityHeader;
    }

    public String getRequestedTokensHeader() {
        return this.requestedTokensHeader;
    }

    public void setRequestedTokensHeader(String requestedTokensHeader) {
        this.requestedTokensHeader = requestedTokensHeader;
    }



    public DynamicRedisRateConfig getDefaultConfig() {
        return defaultConfig;
    }

    public void setDefaultConfig(DynamicRedisRateConfig defaultConfig) {
        this.defaultConfig = defaultConfig;
    }

    public void setApplicationContext(ApplicationContext context) throws BeansException {
        if (this.initialized.compareAndSet(false, true)) {
            if (this.redisTemplate == null) {
                this.redisTemplate = context.getBean(ReactiveStringRedisTemplate.class);
            }

            this.script = (RedisScript)context.getBean(REDIS_SCRIPT_NAME, RedisScript.class);
            if (context.getBeanNamesForType(ConfigurationService.class).length > 0) {
                this.setConfigurationService(context.getBean(ConfigurationService.class));
            }
        }

    }

    public Mono<Response> isAllowed(String routeId, String id) {
        if (!this.initialized.get()) {
            throw new IllegalStateException("RedisRateLimiter is not initialized");
        } else {
            // 采用服务应用id+uri的方式组成统计唯一key，防止多应用的uri存在冲突问题
            String routeKey = routeId + id;
            // 实时获取限流配置的地方
            DynamicRedisRateConfig routeConfig = this.loadConfiguration(routeKey);
            int replenishRate = routeConfig.getReplenishRate();
            int burstCapacity = routeConfig.getBurstCapacity();
            int requestedTokens = routeConfig.getRequestedTokens();

            try {
                List<String> keys = getKeys(routeKey);
                List<String> scriptArgs = Arrays.asList(replenishRate + "", burstCapacity + "", Instant.now().getEpochSecond() + "", requestedTokens + "");
                Flux<List<Long>> flux = this.redisTemplate.execute(this.script, keys, scriptArgs);
                return flux.onErrorResume((throwable) -> {
                    if (this.log.isDebugEnabled()) {
                        this.log.debug("Error calling rate limiter lua", throwable);
                    }

                    return Flux.just(Arrays.asList(1L, -1L));
                }).reduce(new ArrayList(), (longs, l) -> {
                    longs.addAll(l);
                    return longs;
                }).map((results) -> {
                    boolean allowed = ((Long)results.get(0)).longValue() == 1L;
                    Long tokensLeft = (Long)results.get(1);
                    Response response = new Response(allowed, this.getHeaders(routeConfig, tokensLeft));
                    if (this.log.isDebugEnabled()) {
                        this.log.debug("response: " + response);
                    }

                    return response;
                });
            } catch (Exception var10) {
                this.log.error("Error determining if user allowed from redis", var10);
                return Mono.just(new Response(true, this.getHeaders(routeConfig, -1L)));
            }
        }
    }

    private DynamicRedisRateConfig loadConfiguration(String routeKey) {
        // 根据routeId到配置map中获取对应的配置
        DynamicRedisRateConfig routeConfig = BizRateRule.BIZ_RATE_MAP.get(routeKey);
        if (routeConfig == null) {
            routeConfig = this.defaultConfig;
        }

        if (routeConfig == null) {
            throw new IllegalArgumentException("No Configuration found for routeKey " + routeKey);
        } else {
            return routeConfig;
        }
    }

    private Map<String, String> getHeaders(DynamicRedisRateConfig config, Long tokensLeft) {
        Map<String, String> headers = new HashMap<>(8);
        if (this.isIncludeHeaders()) {
            headers.put(this.remainingHeader, tokensLeft.toString());
            headers.put(this.replenishRateHeader, String.valueOf(config.getReplenishRate()));
            headers.put(this.burstCapacityHeader, String.valueOf(config.getBurstCapacity()));
            headers.put(this.requestedTokensHeader, String.valueOf(config.getRequestedTokens()));
        }
        return headers;
    }


}

关键不同代码就是isAllow()方法中：

这里的this.loadConfiguration(routeKey)方法实现获取动态限流配置：

private DynamicRedisRateConfig loadConfiguration(String routeKey) {
	// 根据routeId到配置map中获取对应的配置
	DynamicRedisRateConfig routeConfig = BizRateRule.BIZ_RATE_MAP.get(routeKey);
	if (routeConfig == null) {
		routeConfig = this.defaultConfig;
	}

	if (routeConfig == null) {
		throw new IllegalArgumentException("No Configuration found for routeKey " + routeKey);
	} else {
		return routeConfig;
	}
}

2、定义DynamicRedisRateConfig类

import org.springframework.core.style.ToStringCreator;
import org.springframework.validation.annotation.Validated;

import javax.validation.constraints.Min;

/**
 * @PackageName 
 * @ClassName DynamicRedisRateConfig
 * @Description 配置类
 * @Auth Sam.Chen
 * @Date 2020/6/20 19:10
 * @Version 1.0
 **/
@Validated
public class DynamicRedisRateConfig {

    // 令牌桶每秒填充平均速率
    @Min(1L)
    private int replenishRate;

    // 令牌桶总容量
    @Min(0L)
    private int burstCapacity = 1;


    @Min(1L)
    private int requestedTokens = 1;

    public DynamicRedisRateConfig() {
    }

    public int getReplenishRate() {
        return this.replenishRate;
    }

    public DynamicRedisRateConfig setReplenishRate(int replenishRate) {
        this.replenishRate = replenishRate;
        return this;
    }

    public int getBurstCapacity() {
        return this.burstCapacity;
    }

    public DynamicRedisRateConfig setBurstCapacity(int burstCapacity) {
        this.burstCapacity = burstCapacity;
        return this;
    }

    public int getRequestedTokens() {
        return this.requestedTokens;
    }

    public DynamicRedisRateConfig setRequestedTokens(int requestedTokens) {
        this.requestedTokens = requestedTokens;
        return this;
    }

    public String toString() {
        return (new ToStringCreator(this)).append("replenishRate", this.replenishRate).append("burstCapacity", this.burstCapacity).append("requestedTokens", this.requestedTokens).toString();
    }
    
}

3、定义BizRateRule.BIZ_RATE_MAP对应的缓存类BizRateRule

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @PackageName 
 * @ClassName BizRateRule
 * @Description 存储业务限流规则
 * @Auth
 * @Date 2020/6/20 20:28
 * @Version 1.0
 **/
public class BizRateRule {

    public static Map<String, DynamicRedisRateConfig> BIZ_RATE_MAP = new ConcurrentHashMap<>();

    private static final String LOCK = "1";

    /**
     * @Description 刷新bizMap
     * @Date 2020/6/20 20:34
     **/
    public static void refreshBizRateMap(Map<String, DynamicRedisRateConfig> newMap) {
        Map<String, DynamicRedisRateConfig> tmpMap = new ConcurrentHashMap<>();
        tmpMap.putAll(newMap);
        synchronized (LOCK) {
            BIZ_RATE_MAP.clear();
            BIZ_RATE_MAP = tmpMap;
        }
    }

}

4、定义初始化这些类的config：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import java.util.HashMap;
import java.util.Map;

/**
 * @PackageName 
 * @ClassName BizRateConfig
 * @Description 限流配置
 * @Auth 
 * @Date 2020/6/20 20:10
 * @Version 1.0
 **/
@Component
public class BizRateConfig {

    @Value("${rate.limiter.config.default.replenishRate}")
    private int defaultReplenishRate=1;

    @Value("${rate.limiter.config.default.burstCapacity}")
    private int defaultBurstCapacity = 1;

    @Value("${rate.limiter.config.default.requestedTokens}")
    private int defaultRequestedTokens = 1;

    @Bean
    @Primary
    public DynamicRedisRateLimiter customRedisRateLimiter(DynamicRedisRateConfig defaultDynamicRedisRateConfig) {
        return new DynamicRedisRateLimiter(defaultDynamicRedisRateConfig);
    }

    @Bean
    public DynamicRedisRateConfig defaultCustomRedisRateConfig() {
        DynamicRedisRateConfig config = new DynamicRedisRateConfig();
        config.setReplenishRate(defaultReplenishRate);
        config.setBurstCapacity(defaultBurstCapacity);
        config.setRequestedTokens(defaultRequestedTokens);
        return config;
    }

    @Bean
    public UriKeyResolver uriKeyResolver() {
        return new UriKeyResolver();
    }

    @PostConstruct
    public void initBizData() {
        // 后面可以接入配置中心或者定时任务刷新数据库，这里先采用硬编码方式
        Map<String, DynamicRedisRateConfig> map = new HashMap<>(4);
        DynamicRedisRateConfig config = new DynamicRedisRateConfig();
        config.setReplenishRate(1);
        config.setBurstCapacity(1);
        config.setRequestedTokens(1);
        map.put("gateway-service/service/client/test", config);
        BizRateRule.refreshBizRateMap(map);
    }

}

扩展限流结束，赶紧跑起来试下！！！886.。。。。

 

~木木木~
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Cloud Gateway⑤令牌桶算法
太空眼睛的专栏
04-30 2402
目录官网对**Spring Cloud Gateway**的介绍maven依赖核心依赖Redis依赖yml配置项令牌桶算法核心参数解析源码分析 官网对Spring Cloud Gateway的介绍 Spring Cloud Gateway maven依赖 核心依赖 <dependency> <groupId>org.springframework.cloud</groupId> <artifactId
常见的限流算法
yaobo2816的专栏
12-16 347
常见的限流算法 计数器算法 计数器算法采用计数器实现限流有点简单粗暴，一般我们会限制一秒钟的能够通过的请求数，比如限流qps为100，算法的实现思路就是从第一个请求进来开始计时，在接下去的1s内，每来一个请求，就把计数加1，如果累加的数字达到了100，那么后续的请求就会被全部拒绝。等到1s结束后，把计数恢复成0，重新开始计数。具体的实现可以是这样的：对于每次服务调用，可以通过AtomicLong#incrementAndGet()方法来给计数器加1并返回最新值，通过这个最新值和阈值进行比较。这种实现方式
【gateway 进阶】5、性能优化和缓存策略
最新发布
weixin_52938153的博客
06-05 1058
"Gateway" 是一个多义词，在不同的领域有不同的意义。它在计算机网络中是连接不同网络的设备或节点，能在不同协议、数据格式和体系结构之间进行转换，使得不同网络之间能够互相通信；在电子商务中是处理和授权在线支付的服务，确保交易安全顺利进行；在旅游和交通中指的是主要的出入口或枢纽，如国际机场。无论在哪个领域，Gateway 的核心概念都是作为“连接”和“通道”，它是实现两个不同系统或区域之间互动的重要桥梁。
微服务网关限流（使用令牌桶算法基于redis的RateLimter限流算法）
weixin_42696130的博客
11-10 2772
网关限流 网关可以做很多的事情，比如，限流，当我们的系统 被频繁的请求的时候，就有可能 将系统压垮，所以 为了解决这个问题，需要在每一个微服务中做限流操作，但是如果有了网关，那么就可以在网关系统做限流，因为所有的请求都需要先通过网关系统才能路由到微服务中。 令牌桶算法 令牌桶算法是比较常见的限流算法之一，大概描述如下： 1）所有的请求在处理之前都需要拿到一个可用的令牌才会被处理； 2）根据限流大小，设置按照一定的速率往桶里添加令牌； 3）桶设置最大的放置令牌限制，当桶满时、新添加的令牌就被丢.
Spring Cloud Gateway核心过滤器之请求限流详解
asoklove的专栏
12-05 2325
Spring Cloud Gateway核心过滤器之请求限流详解
SpringCloudGateway限流-RedisRateLimiter问题记录
cleancp的博客
01-18 1944
引入RedisRateLimiter 1.类路径： org.springframework.cloud.gateway.filter.ratelimit.RedisRateLimit在这里插入代码片er spring.cloud.gateway.redis-rate-limiter 2.内部类路径： org.springframework.cloud.gateway.filter.ratelimit.RedisRateLimiter.Config spring.cloud.gateway.redis-r.
分布式限流之 - Spring Cloud Gateway层限流实现
it_lihongmin的博客
05-21 3691
写在前面的话 高兵发的三驾马车：缓存、降级、限流，这里仅仅说限流 常用的限流算法有：计数器算法、固定窗口算法、滑动窗口算法、漏桶算法、令牌桶算法；每种算法的特点和优缺点这里不展开，比较适用的限流算法基本都会选择令牌桶，并且这里基于Spring Cloud Gateway Redis本身默认就是基于令牌桶算法实现 限流按照类型分为：单机、分布式； 限流按照请求流量的路径分为：nginx、gateway、微服务 如果仅仅使用于单机环境：谷歌guava的RateLimiter、（AtomicIntege
spring-cloud-gateway-自定义限流DEMO
07-27
spring-cloud-gateway-自定义限流DEMO,自己编写的限流DEMO，实际生产用的很好。
spring cloud gateway整合sentinel实现网关限流
08-25
3. **配置文件设置**：在`application.yml`或`application.properties`中，配置Spring Cloud Gateway和Sentinel的相关参数。例如，设置Nacos服务器地址、命名空间，以及Sentinel的Dashboard地址和传输端口。同时，...
最新Spring Cloud Gateway 官方参考指南-中文版-3.x
08-16
Spring Cloud Gateway 是一款基于Spring生态系统构建的API网关，它主要设计用于提供一种简单而有效的方式来路由API，并为API提供核心关注点，如安全性、监控/度量和弹性。在3.1.3版本中，它利用了Spring Boot 2.x、...
spring-cloud-gateway-demo.zip
08-13
此外，Spring Cloud Gateway 提供了丰富的过滤器，比如 SecurityFilter、RateLimiterFilter 等，可以根据需求定制，实现如认证、限流、熔断等高级功能。在 "spring-cloud-gateway-demo" 中，你可能会看到这些过滤器...
详解Spring Cloud Gateway 限流操作
08-27
Spring Cloud Gateway 限流操作详解 Spring Cloud Gateway 作为一种基于微服务架构的API网关，提供了强大的功能，其中限流操作是其中一个非常重要的功能。限流操作主要是为了保护系统的可用性，防止高并发请求对...
SpringCloud Gateway网关的使用与介绍
qq_62898618的博客
12-10 2289
SpringCloud Gateway 作为 Spring Cloud 生态系统中的网关，目标是替代 Zuul，在Spring Cloud 2.0以上版本中，没有对新版本的Zuul 2.0以上最新高性能版本进行集成，仍然还是使用的Zuul 2.0之前的非Reactor模式的老版本。而为了提升网关的性能，SpringCloud Gateway是基于WebFlux框架实现的，而WebFlux框架底层则使用了高性能的Reactor模式通信框架Netty。
限流算法的理解，流行限流方案的初识
Oneknows的博客
08-06 976
当请求量超过服务器的处理阈值时，服务器将阻塞或宕机。那么，此时我们应该采取合适的应对方案，来避免这样的问题，从而达到保护系统的目的，例如，从硬件上，更换性能更加强劲（更多的线程，更高的主频）的cpu（中央处理器）；从代理层上，配置Nginx限流和负载均衡；从网关上，使用Spring Cloud Gateway限流、熔断以及调整线程数和连接数；从消息中间件上，利用RabbitMQ削峰限流；从缓存中间件上，使用Redis缓存热点数据；从Servlet容器上，调整Tomcat连接数和线程数；从虚拟机上看，进行JV
SpringCloud入门学习之Gateway（三）
weixin_41758046的博客
05-27 2374
SpringCloud Gateway SpringCloud Gateway 是Spring提供的一种网关。 工作原理图: 客户端访问SpringCloud Gateway,如果请求与网关路由匹配，则由SpringCloud Gateway发送到网关的web程序处理。 ...
springcloud-gateway限流
热门推荐
专注于Java架构学习 https://gitee.com/laokouyun https://github.com/KouShenhai
06-06 1万+
小伙伴们，你们好呀！我是老寇！一起学习学习gateway限流。
spring cloud gateway 之限流篇
09-06 507
https://blog.csdn.net/forezp/article/details/85081162/ 版权声明：本文为博主原创文章，遵循 CC 4.0 BY-...
Spring Cloud Gateway 网关限流
ch98000的博客
08-27 2338
已经通过案例实现了通过网关调用服务 API，并已经了解了网关的几个核心概念：routes，predicates，filters。这几个核心概念串起来就是的执行流程：客户端发请求，通过断言predicates进行匹配，若匹配上了则请求就会被发送到网关处理程序，并执行特定的请求过滤器链fliters。Spring Cloud Gateway提供了多种断言predicate工厂和过滤器filter工厂，也可以自定义断言工厂和过滤器工厂。Redis。...
springcloud gateway 网关限流
09-14
Spring Cloud Gateway 提供了多种方式来实现网关的限流功能。下面是一些常用的限流方式： 1. 基于请求频率的限流：可以使用 Redis 或者 Guava 等工具来实现基于请求频率的限流。你可以在 Gateway 的过滤器中统计请求频率，并设置限制阈值来进行限流。 2. 基于令牌桶算法的限流：令牌桶算法是一种常见的限流算法，可以使用框架如 Resilience4j 或者 Sentinel 来实现。通过配置框架提供的限流规则，可以在 Gateway 中应用该限流策略。 3. 使用限流插件：Spring Cloud Gateway 还提供了一些扩展插件，如 `spring-cloud-gateway-starter-ratelimiter`，可以直接在配置文件中配置限流规则。该插件基于 Redis 来实现限流功能，可以按照路由、路径或者客户端 IP 进行限流。 以上是一些常用的方式来实现 Spring Cloud Gateway 的网关限流功能。你可以根据自己的需求选择合适的方式进行配置和实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值