一、原生限流

1.1添加依赖

<dependency>
	<groupId>org.springframework.cloud</groupId>
	<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>

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

1.2创建限流配置类

package com.lg.cloudgateway.config;

import org.springframework.cloud.gateway.filter.ratelimit.KeyResolver;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import reactor.core.publisher.Mono;

@Configuration
public class Raonfiguration {

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

1.3添加配置

nacos配置文件中添加redis配置和限流配置

server:
  port: 8090
spring:
  redis:
    host: 192.168.2.5
    password: 123456
    port: 6379
  cloud:
    nacos:
      discovery:
        server-addr: 192.168.2.6:8001
    gateway:
      discovery:
        locator:
          enabled: true
      routes:
      - id: product-service
        uri: lb://product-service
        order: 10000
        predicates: 
        - Path=/product/**
        filters:
        - StripPrefix=1
        - name: RequestRateLimiter
          args:
            redis-rate-limiter.replenishRate: 1
            redis-rate-limiter.burstCapacity: 3
            key-resolver: '#{@ipKeyResolver}'
      - id: account-service
        uri: lb://account-service
        predicates:
          - Path=/account/**
        filters:
        - StripPrefix=1
      - id: order-service
        uri: lb://order-service
        predicates:
          - Path=/order/**
        filters:
        - StripPrefix=1

在上面的配置文件，配置了 redis 的信息，并给product-service配置了 RequestRateLimiter 的限流过滤器，该过滤器需要配置三个参数：

burstCapacity，令牌桶总容量。

replenishRate，令牌桶每秒填充平均速率。

key-resolver，用于限流的键的解析器的 Bean 对象的名字。它使用 SpEL 表达式根据#{@beanName}从 Spring 容器中获取 Bean 对象。

二、sentinel限流

2.1添加依赖

<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId>
</dependency>

<!--Sentinel-->
<dependency>
	<groupId>com.alibaba.cloud</groupId>
	<artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

<dependency>
	<groupId>com.alibaba.csp</groupId>
	<artifactId>sentinel-datasource-nacos</artifactId>
</dependency>

2.2添加配置

sentinel:
      transport:
        dashboard: 192.168.2.6:8858 #配置Sentinel dashboard地址
        # 默认就是8719端口，如果占用会依次+1开始扫描
        # 取消延迟加载
        eager: true
      datasource:
        ds3:
          nacos:
            server-addr: 192.168.2.6:8001
            namespace: 9bb83945-f4a3-4839-8d3b-363f1b78db36
            dataId: ${spring.application.name}-sentinel
            group: DEFAULT_GROUP
            data-type: json
            rule-type: gw-flow

2.3naocs限流配置

添加如下配置文件

[
  {
    "resource": "ReactiveCompositeDiscoveryClient_product-service",
    "count": 1,
    "grade": 1,
    "paramItem": {
        "parseStrategy": 0
    }
  }
]

常用限流策略常量

以客户端IP作为限流因子

public static final int PARAM_PARSE_STRATEGY_CLIENT_IP = 0;

以客户端HOST作为限流因子

public static final int PARAM_PARSE_STRATEGY_HOST = 1;

以客户端HEADER参数作为限流因子

public static final int PARAM_PARSE_STRATEGY_HEADER = 2;

以客户端请求参数作为限流因子

public static final int PARAM_PARSE_STRATEGY_URL_PARAM = 3;

以客户端请求Cookie作为限流因子

public static final int PARAM_PARSE_STRATEGY_COOKIE = 4;

2.4sentinel查看流控规则

2.5趟坑限流不生效问题

debug模式启动网关服务，然后对网关过滤器 SentinelGatewayFilter 中的filter方法进行调试，我发现sentinel获取到的网关id并不是我们配置的product-service，而是加了ReactiveCompositeDiscoveryClient_前缀，如下图所示

2.6限流测试

通过网关访问接口http://localhost:8090/product-service/product/1

2.7自定义响应异常

创建JsonSentinelGatewayBlockExceptionHandler

package com.lg.cloudgateway.handler;

import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.util.function.Supplier;
import com.alibaba.fastjson.JSON;
import com.lg.common.model.ResultData;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.codec.HttpMessageWriter;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.reactive.result.view.ViewResolver;
import org.springframework.web.server.ServerWebExchange;
import org.springframework.web.server.WebExceptionHandler;
import reactor.core.publisher.Mono;

import java.util.List;

public class JsonSentinelGatewayBlockExceptionHandler implements WebExceptionHandler {

    private List<ViewResolver> viewResolvers;
    private List<HttpMessageWriter<?>> messageWriters;

    private final Supplier<ServerResponse.Context> contextSupplier = () -> new ServerResponse.Context() {
        @Override
        public List<HttpMessageWriter<?>> messageWriters() {
            return JsonSentinelGatewayBlockExceptionHandler.this.messageWriters;
        }
        @Override
        public List<ViewResolver> viewResolvers() {
            return JsonSentinelGatewayBlockExceptionHandler.this.viewResolvers;
        }
    };

    public JsonSentinelGatewayBlockExceptionHandler(
            List<ViewResolver> viewResolvers, ServerCodecConfigurer serverCodecConfigurer) {
        this.viewResolvers = viewResolvers;
        this.messageWriters = serverCodecConfigurer.getWriters();
    }
    /**
     * 自定义返回
     * @param response
     * @param exchange
     * @return
     */
    private Mono<Void> writeResponse(ServerResponse response, ServerWebExchange exchange) {
        ServerHttpResponse resp = exchange.getResponse();
        resp.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        ResultData<Object> resultData = ResultData.fail("服务限流");
        String resultString = JSON.toJSONString(resultData);
        DataBuffer buffer = resp.bufferFactory().wrap(resultString.getBytes());
        return resp.writeWith(Mono.just(buffer));
    }

    @Override
    public Mono<Void> handle(ServerWebExchange exchange, Throwable ex) {
        if (exchange.getResponse().isCommitted()) {
            return Mono.error(ex);
        }
        if (!BlockException.isBlockException(ex)) {
            return Mono.error(ex);
        }
        return handleBlockedRequest(exchange, ex)
                .flatMap(response -> writeResponse(response, exchange));
    }
    private Mono<ServerResponse> handleBlockedRequest(ServerWebExchange exchange, Throwable throwable) {
        return GatewayCallbackManager.getBlockHandler().handleRequest(exchange, throwable);
    }
}

创建GatewayConfiguration

package com.lg.cloudgateway.config;

import com.alibaba.csp.sentinel.adapter.gateway.sc.SentinelGatewayFilter;
import com.lg.cloudgateway.handler.JsonSentinelGatewayBlockExceptionHandler;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
import org.springframework.http.codec.ServerCodecConfigurer;
import org.springframework.web.reactive.result.view.ViewResolver;

import java.util.Collections;
import java.util.List;

@Configuration
public class GatewayConfiguration {

    private final List<ViewResolver> views;
    private final ServerCodecConfigurer configurer;

    public GatewayConfiguration(ObjectProvider<List<ViewResolver>> views,
                                ServerCodecConfigurer config) {
        this.views = views.getIfAvailable(Collections::emptyList);
        this.configurer = config;
    }

    /**
     * 配置SentinelGatewayBlockExceptionHandler，限流后异常处理
     * @return
     */
    @Bean("sentinelGatewayBlockExceptionHandler")
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public JsonSentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
        //return new SentinelGatewayBlockExceptionHandler(views, configurer);
        return new JsonSentinelGatewayBlockExceptionHandler(views, configurer);
    }

    /**
     * Sentinel 过滤器
     * @return
     */
    @Bean
    @Order(-1)
    public GlobalFilter sentinelGatewayFilter() {
        return new SentinelGatewayFilter();
    }

}

添加配置

调用测试

{
    "status": 1,
    "message": "服务限流",
    "success": false,
    "timestamp": "2021-02-19 17:57:44"
}

原文地址：https://blog.csdn.net/gang_luo/article/details/113869031

SpringCloud Alibaba 学习教程14-gateway网关限流