第二代微服务网关组件——Spring Cloud Gateway

1、学习目标：

2、什么是Spring Cloud Gateway：

Spring Cloud Gateway 作为 Spring Cloud 生态系统中的网关，目标是替代 Netflix Zuul ( Zuul1.0 网关是阻塞 IO，且不支

持长连接，2019年5月，Netflix终于开源了支持异步IO的Zuul 2.0)，其不仅提供统一的路由方式，并且还基于 Filter 链的方

式提供了网关基本的功能。

Spring Cloud Gateway 是基于 Spring 生态系统之上构建的 API 网关，包括：Spring 5、Spring Boot 2 和 Project

Reactor。Spring Cloud Gateway旨在提供一种简单而有效的方法来实现 API 路由，并为它们提供跨领域的关注点，例

如：安全性、监视/指标、限流等。由于Spring 5 支持 Netty，Http 2，而 Spring Boot 2.0 支持 Spring 5，因此，Spring

Cloud Gateway 也顺理成章的支持 Netty 和 Http 2。

3、什么是服务网关：

API Gateway (API网关)，顾名思义，是出现在系统边界上的一个面向 API 的、串行集中式的强管控服务，这里的边界是企

业 IT 系统的边界，可以理解为企业级应用防火墙，主要起到隔离外部访问与内部系统的作用。在微服务概念流行之前，

API 网关就已经诞生了，例如：银行、证券等领域常见的前置系统，就是解决访问认证、报文转换、访问统计等问题。

API 网关的流行，源于近几年来移动应用与企业间互联需求的兴起。移动应用、企业互联，使得后台服务支持的对象，从

以前单一的 web 应用，扩展到多种使用场景，且每种使用场景对后台服务的要求都不尽相同。这不仅增加了后台服务的

响应量，还增加了后台服务的复杂性，随着微服务架构概念的提出，API网关称为了微服务架构的一个标配组件。

API 网关是一个服务器，是系统对外的唯一入口。API 网关封装了系统内部架构，为每个客户提供定制的 API。所有的客

户端和消费端都通过统一的网关接入微服务，在网关层处理所有的非业务功能。API 网关并不是微服务场景中必须的组

件，如下图，不管有没有 API 网关，后端微服务都可以通过 API 很好的支持客户端的访问。

但对于服务数量众多、复杂度比较高、规模比较庞大的业务来说，引入 API 网关也有一系列的好处：

聚合接口，使得服务对调用者透明，客户端与后端的耦合度降低；
聚合后台服务，节省流量、提高性能、提升用户体验；
提供安全、流控、过滤、缓存、计费、监控等 API 管理功能；

4、为什么要使用网关：

单体应用：浏览器发起请求到单体应用所在的服务器，应用从数据库查询数据后返回给浏览器，对于单体应用来说是

不需要网关的。
微服务：微服务的应用可能部署在不同机房、不同地区、不同域名下。此时客户端(浏览器/手机/软件工具)想要请求对

用的服务，都需要知道机器的具体 IP 或者域名 URL，当微服务实例众多时，对于客户端来说太难以维护。此时就有

了网关，客户端相关的请求直接发送到网关，由网关根据请求标识解析判断出具体的服务地址，再把请求转发到微服

务实例。

我们需要网关介于客户端与后台应用之间的中间层，所有外部请求先经过微服务网关，客户端只需要与网关交

互，只需要知道网关地址即可。这样便简化了开发且具有以下优点：
- 易于监控，可在微服务网关收集监控数据并将其推送到外部系统进行分析；
- 易于认证，可在微服务网管上进行认证，然后再将请求转发到后端的微服务，无需再每个微服务中进行认证；
- 减少了客户端与各个微服务之间交互的次数；

5、网关解决了什么问题：

网关具有身份认证与安全、审查与监控、动态路由、负载均衡、请求分片与管理、静态响应处理等功能，当然最主要的职

责还是与“外界联系”。总结一下，网关应当具备以下功能：

性能：API 高可用，负载均衡，容错机制；
安全：权限身份认证、脱敏、流量清洗、后端签名(保证全链路可信调用)、黑名单(非法调用限制)；
日志：日志记录，一旦涉及分布式，全链路跟踪必不可少；
缓存：数据缓存；
限流：流量控制、错峰流控，可以定义多种限流规则；
灰度：线上灰度部署，可以减小风险；
路由：动态路由规则；

6、常用的网关解决方案：

6.1、Nginx + Lua：

Nginx 是由 Igor Sysoev 为俄罗斯访问量第二的 Rambler.ru 站点开发的，一个高性能的 HTTP 反向代理服务器。Nginx

一方面可以做反向代理，另外一方面可以做静态资源服务器。

Nginx 适合做门户网关，是作为整个全局的网关；而 Spring Cloud Gateway 属于业务网关，主要用来对应不同的客户端

提供服务，用于聚合业务。Spring Cloud Gateway 可以实现熔断、重试等功能，这是Nginx不具备的。

6.2、Kong：

Kong 是 Mashape 提供的一款 API 管理软件，它本身是基于 Nginx + Lua 实现的，但比 Nginx 提供了更简单的配置方

式，数据采用了 Apache Cassandra/PostgreSQL 存储，并且提供了一些优秀的插件，比如：验证插件、日志插件、限流

插件等。Kong 非常诱人的地方就是提供了大量的插件来扩展应用，通过不同的插件可以为服务提供各种增强的功能。

Kong 基于 Nginx 实现，所以在性能和稳定性上都没有问题。Kong 作为一款商业软件，在 Nginx 上作了很多扩展工作，

而且还有很多付费的商业插件。Kong 本身也有付费的企业版，其中包括技术支持、使用培训服务以及 API 分析插件。

6.3、Spring Cloud Netflix Zuul：

Zuul 是 Netflix 公司开源的一个 API 网关组件，Spring Cloud 对其进行二次基于 Spring Boot 的注解封装做到开箱即用。

目前来说，结合 Spring Cloud 提供的服务治理体系，可以做到请求转发、根据配置或者默认的路由规则进行路由和 Load

Balance，无缝集成 Hystrix。

Zuul 虽然可以通过自定义 Filter 实现我们想要的功能，但是由于 Zuul 1.0 本身的设计是基于单线程的接收请求和转发处

理，是阻塞 IO，不支持长连接，目前来看 Zuul 就显得很鸡肋。随着 Zuul 2.x 一直跳票(2019年5月发布)，Spring Cloud

推出了自己的网关组件——Spring Cloud Gateway。

Zuul 1.0

Zuul 2.x

6.4、Spring Cloud Gateway：

文章开头已介绍

7、Nginx实现API网关：

7.1、下载Nginx：

wget http://nginx.org/download/nginx-1.19.10.tar.gz

7.2、解压Nginx：

tar zxvf nginx-1.19.10.tar.gz

7.3、Nginx依赖包安装：

yum -y install gcc pcre-devel zlib-devel openssl openssl-devel

7.4、编译nginx：

./configure --prefix=/usr/local/dev/nginx/
make install

7.5、启动Nhinx：

cd /usr/local/dev/nginx/sbin
./nginx

7.6、访问Nginx：

7.7、配置路由规则：

cd /usr/local/dev/nginx/conf
vim nginx.conf
http {

    ...
    
    server {
        listen      80;
        server_name localhost;
        
        location / {
            root   html;
            index  index.html index.htm;
        }
        ...
        
        # 路由到商品服务
        location /api/product {
            proxy_pass  http://192.168.1.103:8888/product/;
        }
       
        ...
   
    }
    
    ...

}                                                                       24,0-1        15%

7.8、重启Nginx：

cd /usr/local/dev/nginx/sbin
./nginx -s reload

7.9、访问Nginx配置的路由：

之前我们如果想要访问服务，必须由客户端指定具体服务地址进行访问，现在统一访问 Nginx ，由 Nginx 实现网关功能将

请求路由至具体的服务。访问 http://localhost/api/product 结果如下：

8、Spring Cloud Gateway实现API网关：

8.1、核心概念：

路由(Route)：路由是网关最基础的部分，路由信息由 ID 、目标 URI、一组断言和一组过滤器组成。如果断言路由

为真，则说明请求的 URI 和配置匹配。
断言(Predicate)：Java8 中的断言函数。Spring Cloud Gateway 中的断言函数输入类型是 Spring 5.0 框架中的

ServerWebExchange。Spring Cloud Gateway 中的断言函数允许开发者去定义匹配来自于 Http

Request 中的任何信息，比如请求头和请求参数等。
过滤器(Filter)：一个标准的 Spring Web Filter。Spring Cloud Gateway 中的 Filter 分为两种类型，分别是 Gateway

Filter 和 Global Filter。过滤器将会对请求和响应进行处理。

8.2、工作原理：

如上图所示，客户端向 Spring Cloud Gateway 发出请求，再由网关处理程序 Gateway Web Handler 映射确定与请求相

匹配的路由，将其发送到网关 Web 处理程序 Gateway Web Handler ，该处理程序通过指定的过滤器链将请求发送到我们

实际的微服务，微服务处理完业务逻辑后再返回。过滤器由虚线分隔的原因是：过滤器可以在发送代理请求之前和之后运

行逻辑，pre 过滤器是在发出代理请求之前执行，然后发出代理请求后，post 过滤器是在接收微服务响应后执行。

8.3、搭建网关：

创建网关项目——gateway-server：

添加网关依赖：

<!-- 引入 spring cloud gateway 网关依赖,内置 webflux 依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

配置文件——application.yaml：

server:
  port: 9000                   # 端口 
spring:
  application:
    name: gateway-server       # 应用名称

启动类：

package com.zjg;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class GatewayServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(GatewayServerApplication.class, args);
    }

}

8.4、配置路由规则：

server:
  port: 9000                                      # 端口
spring:
  application:
    name: gateway-server                          # 应用名称
  cloud:
    gateway:
      routes:                                      # 路由规则
        - id: product-service                      # 路由ID，唯一
          uri: http://192.168.1.103:8888           # 目标，路由到微服务的地址
          predicates:                              # 断言(判断条件)
            - Path=/product/**                     # 匹配对应URL的请求，将匹配到的请求追加在目标URI之后

请求 http://localhost:9000/product 将会路由到 http://192.168.1.103:8888/product/

9、Spring Cloud Gateway路由规则：

9.1、Path：

spring:
  cloud:
    gateway:
      routes:                               # 路由规则
        - id: product-service               # 路由ID，唯一
          uri: http://192.168.1.103:8888    # 目标，路由到微服务的地址
          predicates:                       # 断言(判断条件)
            - Path=/product/**              # 匹配对应URL的请求，将匹配到的请求追加在目标URI之后

请求 http://localhost:9000/product 将会路由到 http://192.168.1.103:8888/product

9.2、Query：

spring:
  cloud:
    gateway:
      routes:                              # 路由规则
        - id: product-service              # 路由ID，唯一
          uri: http://192.168.1.103:8888   # 目标，路由到微服务的地址
          predicates:                      # 断言(判断条件)
            - Query=token,abc.             # 匹配请求参数中包含token并且其参数值满足正则表达式abc.的请求

Query=token ：比如：http://localhost:9000/product/token=123
Query=token,abc. ：比如：http://localhost:9000/product/token=abc1

9.3、Method：

spring:
  cloud:
    gateway:
      routes:                                      # 路由规则
        - id: product-service                      # 路由ID，唯一
          uri: http://192.168.1.103:8888           # 目标，路由到微服务的地址
          predicates:                              # 断言(判断条件)
            - Method=GET                           # 匹配任意GET请求

9.4、Datetime：

spring:
  cloud:
    gateway:
      routes:                                      # 路由规则
        - id: product-service                      # 路由ID，唯一
          uri: http://192.168.1.103:8888           # 目标，路由到微服务的地址
          predicates:                              # 断言(判断条件)
            # 匹配规定时间之后的请求
            - After=2021-05-04T16:09:00.000+08:00[Asia/Shanghai]      
            # 匹配规定时间之前的请求
            - Before=2021-05-04T16:09:00.000+08:00[Asia/Shanghai]
            # 匹配规定时间段之间的请求
            - Between=2021-05-04T16:00:00.000+08:00[Asia/Shanghai],2021-05-04T16:30:00.000+08:00[Asia/Shanghai]

9.5、RemoteAddr：

spring:
  cloud:
    gateway:
      routes:                                      # 路由规则
        - id: product-service                      # 路由ID，唯一
          uri: http://192.168.1.103:8888           # 目标，路由到微服务的地址
          predicates:                              # 断言(判断条件)
            - RemoteAddr=192.168.1.1/0             # 匹配远程请求地址是RemoteAddr的请求，0表示子网掩码

RemoteAddr=192.168.1.1/0 ：比如：http://192.168.1.103:9000/product

9.6、Header：

spring:
  cloud:
    gateway:
      routes:                                      # 路由规则
        - id: product-service                      # 路由ID，唯一
          uri: http://192.168.1.103:8888           # 目标，路由到微服务的地址
          predicates:                              # 断言(判断条件)
            # 匹配请求头包含 X-Request-Id 并且其值匹配正则表达式 d+ 的请求
            - Header=X-Request-Id,d+

10、Spring Cloud Gateway动态路由(服务发现的路由规则)：

动态路由其实就是面向服务的路由，Spring Cloud Gateway 支持与 Eureka/Consul 整合开发，根据serviceId自动从注册

中心获取服务地址并转发请求，这样做的好处不仅可以通过但各端点来访问应用的所有服务，而且在添加或移除服务实例

时不用修改 Gateway 的路由配置。

10.1、添加`Consul`依赖：

<!-- spring cloud consul 服务注册与发现依赖 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-consul-discovery</artifactId>
</dependency>

10.2、添加`Consul`配置：

spring:
  cloud:
    consul:
      host: 192.168.1.99
      port: 8500
      discovery:
        # 是否需要注册到Consul
        register: true
        # 注册的服务实例 id(必须唯一)
        instance-id: ${spring.application.name}:${spring.cloud.client.ip-address}:${server.port}
         # 服务名称
        service-name: ${spring.application.name}
        # 服务端口
        port: ${server.port}
        # 是否使用ip地址注册
        prefer-ip-address: true
        # 服务请求ip
        ip-address: ${spring.cloud.client.ip-address}
        # 健康检查的间隔时间，默认10s
        healthCheckInterval: 10s
        # 健康检查的地址
        health-check-url: http://${spring.cloud.client.ip-address}:${server.port}/actuator/health

10.3、添加注解：

package com.zjg;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@EnableDiscoveryClient
@SpringBootApplication
public class GatewayServiceApplication {

    public static void main(String[] args) {
        SpringApplication.run(GatewayServiceApplication.class, args);
    }

}

10.4、动态获取URI(重点部分)：

spring:
  cloud:
    gateway:
      routes:                                      # 路由规则
        - id: product-service                      # 路由ID，唯一
          uri: lb://user-service                   # lb:// 根据服务名称从注册中心获取服务请求地址
          predicates:                              # 断言(判断条件)
            - Path=/user-service/**                # 匹配对应URL的请求，将匹配到的请求追加在目标URI之后

10.5、服务名称转发：

通过在 Spring Cloud Gateway 配置相应的路由转发策略，网关就可以很具匹配的路由将请求转发到对应的微服务，但是

在生产环境中，往往会有几十甚至上百个微服务，我们不可能针对每一个微服务都在配置文件中配置好路由，这时就需要

Spring Cloud Gateway与服务注册中心相结合，如下：

spring:
  cloud:
    gateway:
      discovery:
        locator:                            # 网关与服务注册中心结合，通过serviceId转发到具体的服务实例
          enabled: true                     # 是否开启基于服务发现的路由规则
          lower-case-service-id: true       # 是否将服务名称转小写

此时，就可以通过 http://localhost:9000/user-service/login/ 访问到用户服务中的登录接口，user-service 就是服务福注册

中心中用户服务的服务名称。

11、Spring Cloud Gateway过滤器：

Spring Cloud Gateway 根据作用范围划分为 GatewayFilter 和 GlobalFilter。

11.1、网关过滤器——GatewayFilter：

GatewayFilter：网关过滤器，需要通过 spring.cloud.routes.filters 配置在具体路由上，只作用在当前路由或

通过 spring.cloud.default.filters 配置在全局，作用在所有路由上。

网关过滤器用于拦截并链式处理 Web 请求，可以实现横切与应用无关的需求，比如：安全、访问超时设置等，修改传入

的 HTTP 请求或传出的 HTTP 响应。Spring Cloud Gateway 包含许多内置的网关过滤器工厂一共有22个，包括头部过滤

器、路径类过滤器、Hystrix 过滤器、重写 URL 的过滤器，还有参数和状态码等其他类型的过滤器。根据过滤器工厂的用

途来划分，可以分为以下几种：Header、Parameter、Path、Body、Status、Session、Redirect、Retry、RateLimiter

和Hystrix。

11.1.1、Path路径过滤器：

Path 路径过滤器可以实现 URL 重写，通过重写 URL 可以实现隐藏实际路径，提高安全性，易于用户记忆和键入，易于被

搜索引擎收录等优点，实现方式如下：

RewritePathGatewayFilterFactory：

RewritePath 网关过滤器工厂使用 Java 正则表达式来灵活地重写请求路径。

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/user-service/**
          filters:                                    # 网关过滤器
            # 将请求路径中的/api-gateway/login 重写为 /login 传递到下游服务
            - RewritePath=/user-service(?<segment>/?.*),${segment}

PrefixPathGatewayFilterFactory：

PrefixPath 网关过滤器工厂为匹配的 URI 添加指定前缀：

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/user-service/**   # 匹配对应 URI 的请求，将匹配到的请求追加在目标 URI 之后
          filters:                    # 网关过滤器
            # 将请求路径中的 /user-service/login 重写为 /api/user-service/login 传递到下游服务
            - PrefixPath=/api

StripPrefixGatewayFilterFactory：

StripPrefix 网关过滤工厂表示将请求发送到下游服务之前从请求中剥离指定的路径个数：

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/user-service/**    # 匹配对应 URI 的请求，将匹配到的请求追加在目标 URI 之后
          filters:                     # 网关过滤器
            # 将请求路径中的 /user-service/login 重写为 /login 传递到下游服务
            - StripPrefix=1

SetPathGatewayFilterFactory：

SetPath 网关过滤工厂采用路径模板参数，它提供一种通过允许模板化路径段来操作请求路径的简单方法，使用了

Spring Framework 中的 uri 模板，允许多个匹配段。

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            # 匹配对应 URI 请求，将匹配到的请求追加待目标 URI 之后
            - Path=/api-gateway/user-service/{segment}  
          filters:                     # 网关过滤器
            # 将请求路径中的 /api-gateway/user-service/login 
            # 重写为 /user-service/login 传递到下游服务
            - SetPath=/user-service/{segment}

11.1.2、Parameter参数过滤器：

AddRequestParameter 网关过滤器工厂会将指定参数添加至匹配到的下游请求中。

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            # 匹配对应 URI 请求，将匹配到的请求追加待目标 URI 之后
            - Path=/user-service/**
          filters:                     # 网关过滤器
            # 将请求路径中的/api-gateway/login 重写为 /login 传递到下游服务
            - RewritePath=/user-service(?<segment>/?.*),${segment}
            # 在下游请求中添加flag=1
            - AddRequestParameter=flag,1

11.1.3、Status状态过滤器：

SetStatus 网关过滤器工厂采用单个状态参数，它必须是有效的 Spring HttpStatus。它可以是整数404或枚举

NOT_FOUND 的字符串表示。

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            # 匹配对应 URI 请求，将匹配到的请求追加待目标 URI 之后
            - Path=/user-service/**
          filters:                     # 网关过滤器
            # 将请求路径中的/api-gateway/login 重写为 /login 传递到下游服务
            - RewritePath=/user-service(?<segment>/?.*),${segment}
            # 任何情况下，响应的 HTTP 状态都将设置为404
            - SetStatus=404            # 404 或者 对应的枚举 NOT_FOUND

11.2、全局过滤器——GlobalFilter：

全局过滤器，不需要在配置文件中配置，作用在所有路由上，最终通过 GatewayFilterAdapter 包装成GatewayFilterChain

可识别的过滤器，它为请求业务以及路由的 URI 转换为真实业务服务请求地址的核心过滤器，不需要配置，系统初始化时

加载，并作用在每个路由上。

11.3、自定义过滤器：

即使 Spring Cloud Gateway 自带自多使用的GatewayFilter Factory、Gateway Filter、Global Filter，但是在很多情景下我

们仍然希望可以自定义自己的过滤器，实现特殊的功能。

11.3.1、自定义网关过滤器：

自定义网关过滤器需要实现以下两个接口：GatewayFilter、Ordered。

创建过滤器：

package com.zjg.filter;

import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.core.Ordered;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

/**
 * 自定义网关过滤器
 */

public class CustomGatewayFilter implements GatewayFilter, Ordered {

    /**
     * 过滤器业务逻辑
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        System.out.println("自定义网关过滤器被执行");
        return chain.filter(exchange);     // 继续向下执行
    }

    /**
     * 过滤器执行顺序，数值越小，优先级越高
     */
    @Override
    public int getOrder() {
        return 0;
    }

}

注册过滤器：

package com.zjg.configuration;

import com.zjg.filter.CustomGatewayFilter;
import org.springframework.cloud.gateway.route.RouteLocator;
import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 网关路由配置类
 */

@Configuration
public class GatewayRoutesConfiguration {

    @Bean
    public RouteLocator routeLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route(p -> p
                        // 断言(判断条件)
                        .path("/user-service//**")
                        // 注册自定义网关过滤器
                        .filters(new CustomGatewayFilter())
                        // 路由 ID ，唯一
                        .id("user-service")
                        // 目标 URI，路由到微服务的地址
                        .uri("lb://user-service"))
                        .build();
    }

}

11.3.2、自定义全局过滤器：

自定义全局过滤器需要实现以下两个接口：GlobalFilter、Ordered。

通过全局过滤器可以实现权限校验、安全性验证等功能。

创建过滤器：

package com.zjg.filter;

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

/**
 * 自定义全局过滤器
 */

@Component
public class CustomGlobalFilter implements GlobalFilter, Ordered {

    /**
     * 过滤器业务逻辑
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        System.out.println("自定义全局过滤器被执行");
        return chain.filter(exchange);       // 继续向下执行
    }

    /**
     * 过滤器执行顺序，数值越小，优先级越高
     */
    @Override
    public int getOrder() {
        return 0;
    }
}

全局过滤器无需注册，只需通过@Component注解向Spring BeanFactory注入即可。

11.3.3、统一鉴权：

接下来我们在网关过滤器中通过 token 判断用户是否登录，完成一个统一鉴权案例。

创建过滤器：

package com.zjg.filter;

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

/**
 * 权限验证过滤器
 */

@Component
public class AccessGlobalFilter implements GlobalFilter, Ordered {

    /**
     * 过滤器业务逻辑
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        // 获取请求参数
        String token = exchange.getRequest().getQueryParams().getFirst("token");
        // 业务逻辑处理
        if(null == token){
            System.out.println("token is null...");
            ServerHttpResponse response = exchange.getResponse();
            // 响应类型
            response.getHeaders().add("Content-Type","application/json;charset=utf-8");
            // 响应状态码，HTTP 401 错误代表用户没有访问权限
            response.setStatusCode(HttpStatus.UNAUTHORIZED);
            // 响应内容
            String message = "{"message":"}" + HttpStatus.UNAUTHORIZED.getReasonPhrase() + ""}";
            DataBuffer buffer = response.bufferFactory().wrap(message.getBytes());
            // 请求结束，不再继续向下请求
            return response.writeWith(Mono.just(buffer));
        }
        // 使用token进行身份验证
        System.out.println("token is ok");
        return chain.filter(exchange);       // 继续向下执行
    }

    /**
     * 过滤器执行顺序，数值越小，优先级越高
     */
    @Override
    public int getOrder() { return 1; }
}

12、网关限流：

顾名思义，限流就是限制流量，通过限流可以更好地控制系统的 QPS，从而达到保护系统的目的。

12.1、为什么需要限流：

比如 web 服务、对外 API，这种类型的服务有以下几种可能导致机器被拖垮：

用户增长过快；
因为某个热点事件；
竞争对象爬虫；
恶意请求；

这些情况是无法预知的，不知道什么时候会有10倍甚至几十倍的流量打进来，如果真碰上这种情况，扩容根本来不及。

从上图可以看出，对内而言：上游的 A、B 服务直接依赖了下游的基础服务 C，对于 A、B 服务都依赖的基础服务 C 这种

场景，服务 A 和 B 其实处于某种竞争关系，如果服务 A 的并发阈值设置的过大，当流量高峰期来临，有可能直接拖垮基

础服务 C 并影响服务 B ，即雪崩效应。

12.2、限流算法：

常见的先硫酸法有：

计数器算法；
漏桶(Leaky Bucket)算法；
令牌桶(Token Bucket)算法；

12.2.1.1、计数器算法：

计数器算法是限流算法里最简单也是最容易实现的一种算法，比如我们规定，对于 A 接口来说，1分钟的访问次数不能超

过100个，那么我们可以这样做：开始的时候设置一个计数器 counter，每当一个请求过来的时候，counter 就加1，如果

counter 的值大于100并且该请求与第一个请求的时间间隔在1分钟之内，触发限流；如果该请求与第一个请求的间隔时间

大于1分钟，重置 counter 重新计数，具体算法的示意图如下：

这个算法虽然简单，但是有一个十分致命的问题，那就是临界问题，我们看下图：

从上图我们可以看出，假设有一个恶意用户，他在 0:59 时瞬间发送了100个请求，并且 1:00 又瞬间发送了100个请求，其

实这个用户在1秒内瞬间发送了200个请求。我们刚才规定的是1分钟最多100个请求，也就是每秒钟最多1.7个请求，

用户通过在时间窗口的重置节点出突发请求，可以瞬间超过我们的速率限制。用户有可能通过这个算法的这个漏洞，瞬间

压垮我们的应用。

还有资源浪费的问题存在，我们的预期想法是希望100个请求可以均匀分散在这1分钟内，假设30s以内就达到请求上限，

那么剩余的30s时间服务器就会处于闲置状态，如下图：

12.2.1.2、漏桶算法：

漏桶算法其实也很简单，可以粗略的认为就是注水漏水的过程，往桶中以任意速率注入水，以一定速率流出水，当水超过

桶容量则丢弃，因为桶容量是不变的，保证了整体的速率。

漏桶算法是使用队列机制实现的。

12.2.1.3、令牌桶算法：

令牌桶算法是对漏桶算法的一种改进，漏桶算法能够限制请求调用的频率，而令牌桶算法能够在限制调用平均速率的同时

还允许一定程度的突发调用。在令牌桶算法中，存在一个桶，用来存放固定数量的令牌。算法中存在一种机制，以一定的

速率往桶中放令牌。每次请求调用需要先获取令牌，只有拿到令牌，才有机会继续执行，否则选择等待可用的令牌、或直

接拒绝。放令牌这个动作是持续不断的进行，如果桶中令牌数达到上限，就丢弃令牌。

场景大概就是这样的：桶中一直有大量的可用令牌，这时进来的请求可以直接拿到令牌执行，比如设置 QPS 为

100/s，那么限流器初始化完成一秒后，桶中就已经有100个令牌了，等服务启动完成对外提供服务时，该限流器

就可以抵挡瞬时的100个请求。当桶中没有令牌时，请求会进行等待，最后相当于以一定的速率执行。

Spring Cloud Gateway 内部使用的就是令牌桶算法，大概描述如下：

所有的请求在处理之前都需要拿到一个可用的令牌才会被处理；
根据限流大小，设置按照一定的速率往桶里添加令牌；
桶里设置最大的放置令牌限制，当桶满时，新添加的令牌就被丢弃或者拒绝；
请求达到后首选获取令牌桶中的令牌，拿着令牌才可以进行其他的业务逻辑，处理完业务逻辑后将令牌直接删除；
令牌桶有最低限额，当桶中的令牌达到最低限额时，请求处理完之后将不会删除令牌，以此保证足够的限流。

漏桶算法主要用途在于保护它人，而令牌桶算法主要目的在于保护自己，将请求压力交由目标服务处理。假设倜然进来很

多请求，只要拿到令牌这些请求会瞬时被处理调用目标服务。

12.3、Spring Cloud Gateway限流：

Spring Cloud Gateway 官方提供了 RequestRateLimiterGatewayFilterFactory 过滤器工厂，使用 Redis 和 Lua 脚本实现

了基于令牌桶方式的限流。

12.3.1、基于令牌桶算法的URI限流：

添加依赖：

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

<!-- commons-pool2 对象池依赖 -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

配置Redis连接：

spring:
  redis:
    timeout: 10000       # 连接超时时间
    host: 192.168.1.99   # Redis服务器地址
    port: 6379           # Redis服务器端口
    password: 123456     # Redis服务器密码
    database: 0          # 选择使用第一个数据库
    lettuce:
      pool:
        max-active: 1024 # 最大连接数，默认：8
        max-wait: 10000  # 最大连接阻塞等待时间，单位毫秒，默认：-1
        max-idle: 200    # 最大空闲连接数，默认：8
        min-idle: 5      # 最小空闲连接数，默认：0

编写限流配置类：

package com.zjg.configuration;

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 KeyResolverConfiguration {

    /**
     * 限流规则
     */
    @Bean
    public KeyResolver pathKeyResolver(){
        return exchange -> Mono.just(exchange.getRequest().getURI().getPath());
    }

}

定义限流规则：

spring:
  cloud:
    gateway:
      routes:                                       # 路由规则
        - id: user-service                          # 路由ID，唯一
          uri: lb://user-service                    # lb:// 根据服务名称从注册中心获取服务请求地址
     			  predicates:
              - Path=/user-service/**
            filters:                                # 网关过滤器
              # 将请求路径中的/user-service/login 重写为 /login 传递到下游服务
              - RewritePath=/user-service(?<segment>/?.*),${segment}
              - name: RequestRateLimiter            # 限流过滤器
                  args:
                  redis-rate-limiter.replenishRate: 1 # 令牌每秒填充速率
                  redis-rate-limiter.burstCapacity: 2 # 令牌桶总容量
                  key-resolver: "#{@pathKeyResolver}" # 使用SpEL表达式按名称引用bean

通过网关访问：

多次访问： http://localhost:9000/user-service/logiin/111/111 结果如下：

12.3.2、基于令牌桶算法的参数限流：

编写限流配置类：

package com.zjg.configuration;

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 KeyResolverConfiguration {

    /**
     * 根据参数限流
     */
    @Bean
    public KeyResolver parameterKeyResolver(){
        return exchange -> Mono.just(exchange.getRequest().getQueryParams().getFirst("userId"));
    }

}

定义限流规则：

spring:
  cloud:
    gateway:
      routes:                                       # 路由规则
        - id: user-service                          # 路由ID，唯一
          uri: lb://user-service                    # lb:// 根据服务名称从注册中心获取服务请求地址
     			  predicates:
              - Path=/user-service/**
            filters:                                # 网关过滤器
              # 将请求路径中的/user-service/login 重写为 /login 传递到下游服务
              - RewritePath=/user-service(?<segment>/?.*),${segment}
              - name: RequestRateLimiter            # 限流过滤器
                  args:
                  redis-rate-limiter.replenishRate: 1 # 令牌每秒填充速率
                  redis-rate-limiter.burstCapacity: 2 # 令牌桶总容量
                  key-resolver: "#{@parameterKeyResolver}" # 使用SpEL表达式按名称引用bean

12.3.3、基于令牌桶算法的IP限流：

编写限流配置类：

package com.zjg.configuration;

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 KeyResolverConfiguration {

    /**
     * 根据 IP 限流
     */
    @Bean
    public KeyResolver ipKeyResolver(){
        return exchange -> Mono.just(exchange.getRequest().getRemoteAddress().getHostName());
    }

}

定义限流规则：

spring:
  cloud:
    gateway:
      routes:                                       # 路由规则
        - id: user-service                          # 路由ID，唯一
          uri: lb://user-service                    # lb:// 根据服务名称从注册中心获取服务请求地址
     			  predicates:
              - Path=/user-service/**
            filters:                                # 网关过滤器
              # 将请求路径中的/user-service/login 重写为 /login 传递到下游服务
              - RewritePath=/user-service(?<segment>/?.*),${segment}
              - name: RequestRateLimiter            # 限流过滤器
                  args:
                  redis-rate-limiter.replenishRate: 1 # 令牌每秒填充速率
                  redis-rate-limiter.burstCapacity: 2 # 令牌桶总容量
                  key-resolver: "#{@ipKeyResolver}"   # 使用SpEL表达式按名称引用bean

12.4、Sentinel限流：

Sentinel 支持对 Spring Cloud Gateway、Netflix Zuul 等主流的 API Gateway 进行限流。

Sentinel 是阿里巴巴旗下的一款性能非常优秀的、以流量为切入点的流控限流组件。

官网文档：

12.4.1、创建项目：

创建 gateway-server 项目。

12.4.2、添加依赖：

<!-- spring cloud consul 服务注册与发现依赖 -->
<dependency>
    <groupId>org.springframework.cloud</groupId>
		<artifactId>spring-cloud-starter-consul-discovery</artifactId>
</dependency>

<!-- gateway 网关依赖,内置webflux 依赖-->
<dependency>
    <groupId>org.springframework.cloud</groupId>
		<artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

<!-- sentinel gateway adapter 依赖 -->
<dependency>
    <groupId>com.alibaba.csp</groupId>
		<artifactId>sentinel-spring-cloud-gateway-adapter</artifactId>
		<version>1.8.1</version>
</dependency>

12.4.3、配置文件：

server:
  port: 9001                                      # 端口
spring:
  application:
    name: gateway-server                          # 应用名称
  cloud:
    gateway:
      discovery:
        # 是否与服务发现组件相结合，通过serviceId转发到具体服务实例
        locator:
          enabled: true                          # 是否开启基于服务发现的路由规则
          lower-case-service-id: true            # 是否将服务名称转小写
    consul:
      host: 192.168.1.99
      port: 8500
      # 服务提供者信息
      discovery:
        register: true
        instance-id: ${spring.application.name}:${spring.cloud.client.ip-address}:${server.port}
        service-name: ${spring.application.name}
        port: ${server.port}
        prefer-ip-address: true
        ip-address: ${spring.cloud.client.ip-address}
        healthCheckInterval: 10s
        health-check-url: http://${spring.cloud.client.ip-address}:${server.port}/actuator/health

12.4.4、限流规则配置类：

使用时只需注入对应的 SentinelGatewayFilter 实例以及 SentinelGatewayBlockExceptionHandler 实例即可。

package com.zjg.configuration;

import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayFlowRule;
import com.alibaba.csp.sentinel.adapter.gateway.common.rule.GatewayRuleManager;
import com.alibaba.csp.sentinel.adapter.gateway.sc.SentinelGatewayFilter;
import com.alibaba.csp.sentinel.adapter.gateway.sc.exception.SentinelGatewayBlockExceptionHandler;
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 javax.annotation.PostConstruct;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * 限流规则配置类
 */

@Configuration
public class GatewayConfiguration {

    private final List<ViewResolver> viewResolvers;

    private final ServerCodecConfigurer serverCodecConfigurer;

    /**
     * 构造器
     */
    public GatewayConfiguration(ObjectProvider<List<ViewResolver>> viewResolversProvider,
                                ServerCodecConfigurer serverCodecConfigurer) {
        this.viewResolvers = viewResolversProvider.getIfAvailable(Collections::emptyList);
        this.serverCodecConfigurer = serverCodecConfigurer;
    }

    /**
     * 限流异常处理器
     */
    @Bean
    @Order(Ordered.HIGHEST_PRECEDENCE)
    public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() {
        return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
    }

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

    /**
     * Spring 容器初始化时执行该方法
     */
    @PostConstruct
    public void doInit(){
        // 加载网关限流规则
        initGatewayRules();
    }

    /**
     * 网关限流规则
     */
    private void initGatewayRules(){
        Set<GatewayFlowRule> rules = new HashSet<>();
        /*
             resource: 资源名称，可以使网关中的 routes 名称或者用户自定义的 API 分组名称
             count：限流阈值
             intervalSec：统计时间窗口，单位是秒，默认是1秒
         */
        rules.add(new GatewayFlowRule("user-service")
                // 限流阈值
                .setCount(3)
                // 统计时间川窗口，单位是秒，默认是1秒
                .setIntervalSec(60));
        // 加载网关限流规则
        GatewayRuleManager.loadRules(rules);
    }
}

12.4.5、启动类：

package com.zjg;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

@EnableDiscoveryClient
@SpringBootApplication
public class GatewayServiceSentinelApplication {

	public static void main(String[] args) {
		SpringApplication.run(GatewayServiceSentinelApplication.class, args);
	}

}

12.4.6、访问：

多次访问： http://localhost:9000/user-service/login/111/111，结果如下：

接口 BlockRequestHandler 的默认实现为 DefaultBlockRequestHandler ，当触发限流时会返回默认的错误信息：

Blocked by Sentinel : FlowException。我们可以通过 GatewayCallbackManager 定制异常提示信息。

12.4.7、自定义异常提示：

GatewayCallbackManager 的 setBlockHandler 注册函数用于实现自定义的逻辑，处理被限流的请求。

在限流规则配置类中(GatewayConfiguration.java)加入自定义限流异常处理器。

   ........
     
   /**
     * Spring 容器初始化时执行该方法
     */
    @PostConstruct
    public void doInit(){
        // 加载网关限流规则
        initGatewayRules();
        // 加载网关限流自定义异常处理器
        initBlockHandler();
    }

   ........
    
    /**
     * 自定义限流异常处理类
     */
    private void initBlockHandler(){
        BlockRequestHandler blockRequestHandler = (exchange, t) -> {
            Map<String,String> result = new HashMap<>();
            result.put("code",String.valueOf(HttpStatus.TOO_MANY_REQUESTS.value()));
            result.put("message",HttpStatus.TOO_MANY_REQUESTS.getReasonPhrase());
            result.put("route","user-service");
            return ServerResponse
                    .status(HttpStatus.TOO_MANY_REQUESTS)
                    .contentType(MediaType.APPLICATION_JSON)
                    .body(BodyInserters.fromValue(result));
        };
        // 加载自定义限流异常处理器
        GatewayCallbackManager.setBlockHandler(blockRequestHandler);
    }

   ........

12.4.8、Sentinel分组限流：

    ........
      
    /**
     * 网关限流规则
     */
    private void initGatewayRules(){
        Set<GatewayFlowRule> rules = new HashSet<>();
        // 限流分组
        rules.add(new GatewayFlowRule("user-service")
                // 限流阈值
                .setCount(3)
                // 统计时间川窗口，单位是秒，默认是1秒
                .setIntervalSec(60));
        // 加载网关限流规则
        GatewayRuleManager.loadRules(rules);
        // 加载限流分组
        initCustomizedApis();
    }

   ........
    
    /**
     * 限流分组
     */
    private void initCustomizedApis(){
        Set<ApiDefinition> definitions = new HashSet<>();
        // user-service 组
        ApiDefinition api1 = new ApiDefinition("user-service")
                .setPredicateItems(new HashSet<ApiPredicateItem>(){{
                   // 只匹配 /user-service/** 请求
                    add(new ApiPathPredicateItem().setPattern("/user-service/**"));
                }});
        definitions.add(api1);
        // 加载限流分组
        GatewayApiDefinitionManager.loadApiDefinitions(definitions);
    }

   ........

13、Spring Cloud Gateway高可用网关：

业内通常用多少个9来衡量网站的可用性，例如QQ的可用性是4个9，就是说QQ能够保证一年里服务在99.99%的时间里是

可用的，只有0.01%的时间不可用，大约最多53分钟。

对于大多数网站，2个9是基本可用；3个9是高可用；4个9 是拥有自动回复能力的高可用。

实现高可用的主要手段就是数据的冗余备份和服务的失效转移，这两种手段具体可以怎么做？在网关里如何实现？主要有

以下几个方向：

集群部署；
负载均衡；
健康检查；
节点自动重启；
熔断；
服务降级；
接口重试；

13.1、Nginx + 网关集群实现高可用网关：

13.1.1、Nginx配置网关集群：

编辑nginx.conf：

# vim /usr/local/dev/nginx/conf/nginx.conf
http {
  
    ......

    # 定义网关集群
    upstream gateway {
        server 192.168.1.101:9000;
        server 192.168.1.103:9000;
    }
    
    server {
        listen       80;
        server_name  localhost;

        ......

        # 代理网关调用，负载均衡调用(nginx默认的负载均衡算法是轮询)
        location / {
            proxy_pass http://gateway;
        }
     
        ......
    }
    
    ......
}

13.1.2、总结：

一个请求过来，首先经过 Nginx 的一层负载，到达网关，然后由网关负载倒真是后端服务，若后端服务有问题，网关会进

行重试访问，多次访问后仍返回失败，可以通过熔断或服务降级立即返回结果。而且，由于负载均衡，网关重试时不一定

会访问到出错的后端。

相关阅读:
分治法求最大子序列
 6.2 链表 (UVa 11988, 12657)
6.1 栈和队列（UVa 210, 514, 442）
S-Tree (UVa 712) 二叉树
 Equilibrium Mobile (UVa 12166) dfs二叉树
 Patrol Robot (UVa 1600) BFS
Knight Moves (UVa 439) BFS
Tree Recovery (UVa 536) 递归遍历二叉树
 Parentheses Balance (Uva 673) 栈
 Self-Assembly (UVa 1572)
原文地址：https://www.cnblogs.com/xiaoshuzhagen/p/14733058.html

第二代微服务网关组件——Spring Cloud Gateway

1、学习目标：

2、什么是Spring Cloud Gateway：

3、什么是服务网关：

4、为什么要使用网关：

5、网关解决了什么问题：

6、常用的网关解决方案：

6.1、Nginx + Lua：

6.2、Kong：

6.3、Spring Cloud Netflix Zuul：

6.4、Spring Cloud Gateway：

7、Nginx实现API网关：

7.1、下载Nginx：

7.2、解压Nginx：

7.3、Nginx依赖包安装：

7.4、编译nginx：

7.5、启动Nhinx：

7.6、访问Nginx：

7.7、配置路由规则：

7.8、重启Nginx：

7.9、访问Nginx配置的路由：

8、Spring Cloud Gateway实现API网关：

8.1、核心概念：

8.2、工作原理：

8.3、搭建网关：

8.4、配置路由规则：

9、Spring Cloud Gateway路由规则：

9.1、Path：

9.2、Query：

9.3、Method：

9.4、Datetime：

9.5、RemoteAddr：

9.6、Header：

10、Spring Cloud Gateway动态路由(服务发现的路由规则)：

10.1、添加Consul依赖：

10.2、添加Consul配置：

10.3、添加注解：

10.4、动态获取URI(重点部分)：

10.5、服务名称转发：

11、Spring Cloud Gateway过滤器：

11.1、网关过滤器——GatewayFilter：

11.1.1、Path路径过滤器：

11.1.2、Parameter参数过滤器：

11.1.3、Status状态过滤器：

11.2、全局过滤器——GlobalFilter：

11.3、自定义过滤器：

11.3.1、自定义网关过滤器：

11.3.2、自定义全局过滤器：

11.3.3、统一鉴权：

12、网关限流：

12.1、为什么需要限流：

12.2、限流算法：

12.2.1.1、计数器算法：

12.2.1.2、漏桶算法：

12.2.1.3、令牌桶算法：

12.3、Spring Cloud Gateway限流：

12.3.1、基于令牌桶算法的URI限流：

12.3.2、基于令牌桶算法的参数限流：

12.3.3、基于令牌桶算法的IP限流：

12.4、Sentinel限流：

12.4.1、创建项目：

12.4.2、添加依赖：

12.4.3、配置文件：

12.4.4、限流规则配置类：

12.4.5、启动类：

12.4.6、访问：

12.4.7、自定义异常提示：

12.4.8、Sentinel分组限流：

13、Spring Cloud Gateway高可用网关：

13.1、Nginx + 网关集群实现高可用网关：

13.1.1、Nginx配置网关集群：

13.1.2、总结：

10.1、添加`Consul`依赖：

10.2、添加`Consul`配置：