（十六）SpringCloud学习笔记之微服务网关Spring Cloud Gateway

ゝ一世哀愁。 2023-07-22 09:00 16阅读 0赞

### 微服务网关Spring Cloud Gateway ###

*  1 Gateway概述
 *   *  1.1 简介
     *  1.2 核心概念
 *  2 入门案例
 *   *  2.1 入门案例
     *  2.2 路由规则
     *  2.3 动态路由
     *  2.4 重写转发路径
 *  3 过滤器
 *   *  3.1 过滤器基础
     *  3.2 局部过滤器
     *  3.3 全局过滤器
 *  4 统一鉴权
 *   *  4.1 鉴权逻辑
     *  4.2 代码实现
 *  5 网关限流
 *   *  5.1 常见的限流算法
     *  5.2 基于Filter的限流
     *  5.3 基于Sentinel的限流
 *  6 网关高可用
 *  7 执行流程分析

# 1 Gateway概述 #

## 1.1 简介 ##

Spring Cloud Gateway 是 Spring 官方基于 Spring 5.0，Spring Boot 2.0 和 Project Reactor 等技术开发的网关，旨在为微服务架构提供一种简单而有效的统一的 API 路由管理方式，统一访问接口。SpringCloud Gateway 作为 Spring Cloud 生态系中的网关，目标是替代 Netflix ZUUL，其不仅提供统一的路由方式，并且基于 Filter 链的方式提供了网关基本的功能，例如：安全，监控/埋点，和限流等。它是基于Nttey的响应式开发模式。  
![在这里插入图片描述][20200404223119353.png]  
上表为Spring Cloud Gateway与Zuul的性能对比，从结果可知，Spring Cloud Gateway的RPS是Zuul的1.6倍

## 1.2 核心概念 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70]

1.  **路由（route）** 路由是网关最基础的部分，路由信息由一个ID、一个目的URL、一组断言工厂和一组Filter组成。如果断言为真，则说明请求URL和配置的路由匹配。
2.  **断言（predicates）** Java8中的断言函数，Spring Cloud Gateway中的断言函数输入类型是Spring5.0框架中的ServerWebExchange。Spring Cloud Gateway中的断言函数允许开发者去定义匹配来自Http Request中的任何信息，比如请求头和参数等。
3.  **过滤器（filter**） 一个标准的Spring webFilter，Spring Cloud Gateway中的Filter分为两种类型，分别是Gateway Filter和Global Filter。过滤器Filter可以对请求和响应进行处理。

# 2 入门案例 #

## 2.1 入门案例 ##

**（1） 创建工程导入依赖**  
在项目中添加新的模块 shop\_gateway\_server ，并导入依赖

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

**（2） 配置启动类**

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

**（3） 编写配置文件**  
创建 application.yml 配置文件

*  id：我们自定义的路由 ID，保持唯一
 *  uri：目标服务地址
 *  predicates：路由条件，Predicate 接受一个输入参数，返回一个布尔值结果。该接口包含多种默认方法来将 Predicate 组合成其他复杂的逻辑（比如：与，或，非）。

上面这段配置的意思是，配置了一个 id 为 product-service的路由规则，当访问网关请求地址以product 开头时，会自动转发到地址： http://127.0.0.1:9002/ 。配置完成启动项目即可在浏览器访问进行测试，当我们访问地址 http://localhost:8080/product/1 时会展示页面展示如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 1]

## 2.2 路由规则 ##

Spring Cloud Gateway 的功能很强大，前面我们只是使用了 predicates 进行了简单的条件匹配，其实Spring Cloud Gataway 帮我们内置了很多 Predicates 功能。在 Spring Cloud Gateway 中 Spring 利用Predicate 的特性实现了各种路由匹配规则，有通过 Header、请求参数等不同的条件来进行作为条件匹配到对应的路由。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 2]

## 2.3 动态路由 ##

和zuul网关类似，在SpringCloud GateWay中也支持动态路由：即自动的从注册中心中获取服务列表并访问。  
**（1）添加注册中心依赖**  
在工程的pom文件中添加注册中心的客户端依赖（这里以Eureka为例）

<dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>

**（2）配置动态路由**  
修改 application.yml 配置文件，添加eureka注册中心的相关配置，并修改访问映射的URI为服务名称

server:
      port: 8080 #端口
    spring:
      application:
        name: api-gateway-server #服务名称
      cloud: #配置SpringCloudGateway的路由
        gateway:
          routes:
          #配置路由 : 路由id,路由到微服务的uri,断言(判断条件)
          - id: product-service  #保持唯一
            #uri: http://127.0.0.1:9001 #目标微服务请求地址
            uri: lb://service-product    #lb:// 根据微服务名称从注册中心中拉取服务请求路径
            predicates:
            - Path=/product/**  #路由条件 path : 路由匹配条件
    #eureka注册中心
    eureka:
      client:
        service-url:
          defaultZone: http://localhost:9000/eureka/
      instance:
        prefer-ip-address: true #使用ip地址注册

*  uri ： uri以 lb: //开头（lb代表从注册中心获取服务），后面接的就是你需要转发到的服务名称

## 2.4 重写转发路径 ##

在SpringCloud Gateway中，路由转发是直接将匹配的路由path直接拼接到映射路径（URI）之后，那么在微服务开发中往往没有那么便利。这里就可以通过RewritePath机制来进行路径重写。  
**（1） 案例改造**  
修改 application.yml ，将匹配路径改为 /product-service/\*\*

spring:
      application:
        name: api-gateway-server #服务名称
      cloud: #配置SpringCloudGateway的路由
        gateway:
          routes:
          #配置路由 : 路由id,路由到微服务的uri,断言(判断条件)
          - id: product-service  #保持唯一
            #uri: http://127.0.0.1:9001 #目标微服务请求地址
            uri: lb://service-product    #lb:// 根据微服务名称从注册中心中拉取服务请求路径
            predicates:
            #- Path=/product/** #路由条件 path : 路由匹配条件
            - Path=/product-service/** #将当前请求转发到 http://127.0.0.1:9001/product/1

重新启动网关，我们在浏览器访问http://127.0.0.1:8080/product-service/product/1，会抛出404。这是由于路由转发规则默认转发到商品微服务（ http://127.0.0.1:9002/product- service/product/1 ）路径上，而商品微服务又没有 product-service 对应的映射配置。

**（2） 添加RewritePath重写转发路径**  
修改 application.yml ，添加重写规则。

通过RewritePath配置重写转发的url，将/product-service/(?.\*)，重写为\{segment\}，然后转发到订单微服务。比如在网页上请求http://localhost:8080/product-service/product，此时会将请求转发到http://127.0.0.1:9002/product/1（ 值得注意的是在yml文档中 $ 要写成 $\\ ）

# 3 过滤器 #

Spring Cloud Gateway除了具备请求路由功能之外，也支持对请求的过滤。通过Zuul网关类似，也是通过过滤器的形式来实现的。那么接下来我们一起来研究一下Gateway中的过滤器

## 3.1 过滤器基础 ##

**（1） 过滤器的生命周期**  
Spring Cloud Gateway 的 Filter 的生命周期不像 Zuul 的那么丰富，它只有两个：“pre” 和 “post”。

*  PRE： 这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、在集群中选择请求的微服务、记录调试信息等。
 *  POST：这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准HTTP Header、收集统计信息和指标、将响应从微服务发送给客户端等。  
    **（2） 过滤器类型**  
    Spring Cloud Gateway 的 Filter 从作用范围可分为另外两种GatewayFilter 与 GlobalFilter。
 *  GatewayFilter：应用到单个路由或者一个分组的路由上。
 *  GlobalFilter：应用到所有的路由上。

## 3.2 局部过滤器 ##

局部过滤器（GatewayFilter），是针对单个路由的过滤器。可以对访问的URL过滤，进行切面处理。在Spring Cloud Gateway中通过GatewayFilter的形式内置了很多不同类型的局部过滤器。这里简单将Spring Cloud Gateway内置的所有过滤器工厂整理成了一张表格，虽然不是很详细，但能作为速览使用。如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 3]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 4]!\[在这里插入图片描述\](https://img-blog.csdnimg.cn/20200404230901900.png?x-oss-process=image/watermark,type\_ZmFuZ3poZW5naGVpdGk,shadow\_10,text\_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ==,size\_16,color\_FFFFFF,t\_70![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 6]  
每个过滤器工厂都对应一个实现类，并且这些类的名称必须以 GatewayFilterFactory 结尾，这是Spring Cloud Gateway的一个约定，例如 AddRequestHeader 对应的实现类为  
AddRequestHeaderGatewayFilterFactory 。对于这些过滤器的使用方式可以参考官方文档

## 3.3 全局过滤器 ##

全局过滤器（GlobalFilter）作用于所有路由，Spring Cloud Gateway 定义了Global Filter接口，用户可以自定义实现自己的Global Filter。通过全局过滤器可以实现对权限的统一校验，安全性验证等功能，并且全局过滤器也是程序员使用比较多的过滤器。

Spring Cloud Gateway内部也是通过一系列的内置全局过滤器对整个路由转发进行处理如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 7]

# 4 统一鉴权 #

内置的过滤器已经可以完成大部分的功能，但是对于企业开发的一些业务功能处理，还是需要我们自己编写过滤器来实现的，那么我们一起通过代码的形式自定义一个过滤器，去完成统一的权限校验。

## 4.1 鉴权逻辑 ##

开发中的鉴权逻辑：

*  当客户端第一次请求服务时，服务端对用户进行信息认证（登录）
 *  认证通过，将用户信息进行加密形成token，返回给客户端，作为登录凭证
 *  以后每次请求，客户端都携带认证的token
 *  服务端对token进行解密，判断是否有效。  
    \-![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 8]  
    如上图，对于验证用户是否已经登录鉴权的过程可以在网关层统一检验。检验的标准就是请求中是否携带token凭证以及token的正确性。

## 4.2 代码实现 ##

下面的我们自定义一个GlobalFilter，去校验所有请求的请求参数中是否包含“access-token”，如何不包含请求参数“token”则不转发路由，否则执行正常的逻辑。

/** * 自定义一个全局过滤器 * 实现 globalfilter , ordered接口 */
    @Component
    public class LoginFilter implements GlobalFilter,Ordered { 
    
        /** * 执行过滤器中的业务逻辑 * 对请求参数中的access-token进行判断 * 如果存在此参数:代表已经认证成功 * 如果不存在此参数 : 认证失败. * ServerWebExchange : 相当于请求和响应的上下文(zuul中的RequestContext) */
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) { 
            System.out.println("执行了自定义的全局过滤器");
            //1.获取请求参数access-token
            String token = exchange.getRequest().getQueryParams().getFirst("access-token");
            //2.判断是否存在
            if(token == null) { 
                //3.如果不存在 : 认证失败
                System.out.println("没有登录");
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                return exchange.getResponse().setComplete(); //请求结束
            }
            //4.如果存在,继续执行
            return chain.filter(exchange); //继续向下执行
        }
    
        /** * 指定过滤器的执行顺序 , 返回值越小,执行优先级越高 */
        public int getOrder() { 
            return 0;
        }
    }

*  自定义全局过滤器需要实现GlobalFilter和Ordered接口。
 *  在filter方法中完成过滤器的逻辑判断处理
 *  在getOrder方法指定此过滤器的优先级，返回值越大级别越低
 *  ServerWebExchange 就相当于当前请求和响应的上下文，存放着重要的请求-响应属性、请求实例和响应实例等等。一个请求中的request，response都可以通过ServerWebExchange 获取
 *  调用 chain.filter 继续向下游执行

# 5 网关限流 #

## 5.1 常见的限流算法 ##

**（1） 计数器**  
计数器限流算法是最简单的一种限流实现方式。其本质是通过维护一个单位时间内的计数器，每次请求计数器加1，当单位时间内计数器累加到大于设定的阈值，则之后的请求都被拒绝，直到单位时间已经过去，再将计数器重置为零  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 9]  
**（2） 漏桶算法**  
漏桶算法可以很好地限制容量池的大小，从而防止流量暴增。漏桶可以看作是一个带有常量服务时间的单服务器队列，如果漏桶（包缓存）溢出，那么数据包会被丢弃。 在网络中，漏桶算法可以控制端口的流量输出速率，平滑网络上的突发流量，实现流量整形，从而为网络提供一个稳定的流量。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 10]  
**（3） 令牌桶算法**  
令牌桶算法是对漏桶算法的一种改进，桶算法能够限制请求调用的速率，而令牌桶算法能够在限制调用的平均速率的同时还允许一定程度的突发调用。在令牌桶算法中，存在一个桶，用来存放固定数量的令牌。算法中存在一种机制，以一定的速率往桶中放令牌。每次请求调用需要先获取令牌，只有拿到令牌，才有机会继续执行，否则选择选择等待可用的令牌、或者直接拒绝。放令牌这个动作是持续不断的进行，如果桶中令牌数达到上限，就丢弃令牌，所以就存在这种情况，桶中一直有大量的可用令牌，这时进来的请求就可以直接拿到令牌执行，比如设置qps为100，那么限流器初始化完成一秒后，桶中就已经有100个令牌了，这时服务还没完全启动好，等启动完成对外提供服务时，该限流器可以抵挡瞬时的100个请求。所以，只有桶中没有令牌时，请求才会进行等待，最后相当于以一定的速率执行。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 11]

## 5.2 基于Filter的限流 ##

SpringCloudGateway官方就提供了基于令牌桶的限流支持。基于其内置的过滤器工厂  
RequestRateLimiterGatewayFilterFactory 实现。在过滤器工厂中是通过Redis和lua脚本结合的方式进行流量控制。  
**（1） 环境搭建**

*  导入redis的依赖  
    首先在工程的pom文件中引入gateway的起步依赖和redis的reactive依赖，代码如下：

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

*  准备redis

**（2） 修改application.yml配置文件**  
在application.yml配置文件中加入限流的配置，代码如下

spring:
      application:
        name: api-gateway-server #服务名称
      redis:
        host: localhost
        pool: 6379
        database: 0
      cloud: #配置SpringCloudGateway的路由
        gateway:
          routes:
          - id: order-service
            uri: lb://order-service
            predicates:
            - Path=/order-service/**
            filters:
            - RewritePath=/order-service/(?<segment>.*), /$\{ segment}
          - id: product-service
            uri: lb://product-service
            predicates:
            - Path=/product-service/**
            filters:
            # 配置限流
            - name: RequestRateLimiter
              args:
                # 使用SpEL从容器中获取对象
                key-resolver: '#{@pathKeyResolver}'
                # 令牌桶每秒填充平均速率
                redis-rate-limiter.replenishRate: 1
                # 令牌桶的上限
                redis-rate-limiter.burstCapacity: 3
            - RewritePath=/product-service/(?<segment>.*), /$\{ segment}
    
      # RequestRateLimiter : 使用限流过滤器,是springcloud gateway提供的
      # 参数 replenishRate : 向令牌桶中填充的速率
      # burstCapacity :令牌桶的容量

在 application.yml 中添加了redis的信息，并配置了RequestRateLimiter的限流过滤器：

*  burstCapacity，令牌桶总容量。
 *  replenishRate，令牌桶每秒填充平均速率。
 *  key-resolver，用于限流的键的解析器的 Bean 对象的名字。它使用 SpEL 表达式根据\#\{@beanName\}从 Spring 容器中获取 Bean 对象。  
    **（3） 配置KeyResolver**  
    为了达到不同的限流效果和规则，可以通过实现 KeyResolver 接口，定义不同请求类型的限流键。

@Configuration
    public class KeyResolverConfiguration { 
    
    	/** * 编写基于请求路径的限流规则 * //abc * //基于请求ip 127.0.0.1 * //基于参数 */
    	@Bean
    	public KeyResolver pathKeyResolver() { 
    		//自定义的KeyResolver
    		return new KeyResolver() { 
    			/** * ServerWebExchange : * 上下文参数 */
    			public Mono<String> resolve(ServerWebExchange exchange) { 
    				return Mono.just( exchange.getRequest().getPath().toString());
    			}
    		};
    	}
    
    	/** * 基于请求参数的限流 * * 请求 abc ? userId=1 */
    // @Bean
    	public KeyResolver userKeyResolver() { 
    
    
    
    		return exchange -> Mono.just(
    				exchange.getRequest().getQueryParams().getFirst("userId")
    				//exchange.getRequest().getHeaders().getFirst("X-Forwarded-For") 基于请求ip的限流
    		);
    	}
    }

使用Jmetter模拟5组线程访问，会发现如下结果，当达到令牌桶的总容量3时，其他的请求会返回429错误。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 12]  
通过reids的MONITOR可以监听redis的执行过程。这时候Redis中会有对应的数据：  
![在这里插入图片描述][20200404233641762.png]  
大括号中就是我们的限流Key,这边是IP，本地的就是localhost

*  timestamp:存储的是当前时间的秒数，也就是System.currentTimeMillis() / 1000或者  
    Instant.now().getEpochSecond()
 *  tokens:存储的是当前这秒钟的对应的可用的令牌数量
 *

Spring Cloud Gateway目前提供的限流还是相对比较简单的，在实际中我们的限流策略会有很多种情况，比如：对不同接口的限流被限流后的友好提示这些可以通过自定义RedisRateLimiter来实现自己的限流策略，这里我们不做讨论

## 5.3 基于Sentinel的限流 ##

Sentinel 支持对 Spring Cloud Gateway、Zuul 等主流的 API Gateway 进行限流。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 13]  
从 1.6.0 版本开始，Sentinel 提供了 Spring Cloud Gateway 的适配模块，可以提供两种资源维度的限流：

*  route 维度：即在 Spring 配置文件中配置的路由条目，资源名为对应的 routeId
 *  自定义 API 维度：用户可以利用 Sentinel 提供的 API 来自定义一些 API 分组

Sentinel 1.6.0 引入了 Sentinel API Gateway Adapter Common 模块，此模块中包含网关限流的规则和自定义 API 的实体和管理逻辑：

*  GatewayFlowRule ：网关限流规则，针对 API Gateway 的场景定制的限流规则，可以针对不同route 或自定义的 API 分组进行限流，支持针对请求中的参数、Header、来源 IP 等进行定制化的限流。
 *  ApiDefinition ：用户自定义的 API 定义分组，可以看做是一些 URL 匹配的组合。比如我们可以定义一个 API 叫 my\_api ，请求 path 模式为 /foo/\*\* 和 /baz/\*\* 的都归到 my\_api 这个 API分组下面。限流的时候可以针对这个自定义的 API 分组维度进行限流。  
    **（1）环境搭建**  
    导入Sentinel 的响应依赖

<dependency>
        <groupId>com.alibaba.csp</groupId>
        <artifactId>sentinel-spring-cloud-gateway-adapter</artifactId>
        <version>1.6.3</version>
    </dependency>

**（2） 编写配置类**

/** * sentinel限流的配置 */
    @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;
    	}
    
    	/** * 配置限流的异常处理器:SentinelGatewayBlockExceptionHandler */
    	@Bean
    	@Order(Ordered.HIGHEST_PRECEDENCE)
    	public SentinelGatewayBlockExceptionHandler sentinelGatewayBlockExceptionHandler() { 
    		return new SentinelGatewayBlockExceptionHandler(viewResolvers, serverCodecConfigurer);
    	}
    
    	/** * 配置限流过滤器 */
    	@Bean
    	@Order(Ordered.HIGHEST_PRECEDENCE)
    	public GlobalFilter sentinelGatewayFilter() { 
    		return new SentinelGatewayFilter();
    	}
    
    	/** * 配置初始化的限流参数 * 用于指定资源的限流规则. * 1.资源名称 (路由id) * 2.配置统计时间 * 3.配置限流阈值 */
    	@PostConstruct
    	public void initGatewayRules() { 
    		Set<GatewayFlowRule> rules = new HashSet<>();
    		rules.add(new GatewayFlowRule("product-service")
    				.setCount(1)
    				.setIntervalSec(1)
    		);
    		GatewayRuleManager.loadRules(rules);
    	}
    
    	/** * 自定义API限流分组 * 1.定义分组 * 2.对小组配置限流规则 */
    	@PostConstruct
    	private void initCustomizedApis() { 
    		Set<ApiDefinition> definitions = new HashSet<>();
    		ApiDefinition api1 = new ApiDefinition("product_api")
    				.setPredicateItems(new HashSet<ApiPredicateItem>() { { 
    					add(new ApiPathPredicateItem().setPattern("/product-service/product/**"). //已/product-service/product/开都的所有url
    							setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX));
    				}});
    		ApiDefinition api2 = new ApiDefinition("order_api")
    				.setPredicateItems(new HashSet<ApiPredicateItem>() { { 
    					add(new ApiPathPredicateItem().setPattern("/order-service/order")); //完全匹配/order-service/order 的url
    				}});
    		definitions.add(api1);
    		definitions.add(api2);
    		GatewayApiDefinitionManager.loadApiDefinitions(definitions);
    	}
    
    	/** * 自定义限流处理器 */
    	//@PostConstruct
    	public void initBlockHandlers() { 
    		BlockRequestHandler blockHandler = new BlockRequestHandler() { 
    			public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) { 
    				Map map = new HashMap();
    				map.put("code",001);
    				map.put("message","不好意思,限流啦");
    				return ServerResponse.status(HttpStatus.OK)
    						.contentType(MediaType.APPLICATION_JSON_UTF8)
    						.body(BodyInserters.fromObject(map));
    			}
    		};
    		GatewayCallbackManager.setBlockHandler(blockHandler);
    	}
    }

*  基于Sentinel 的Gateway限流是通过其提供的Filter来完成的，使用时只需注入对应的  
    SentinelGatewayFilter 实例以及 SentinelGatewayBlockExceptionHandler 实例即可。
 *  @PostConstruct定义初始化的加载方法，用于指定资源的限流规则。这里资源的名称为 product-service ，统计时间是1秒内，限流阈值是1。表示每秒只能访问一个请求。

**（3）网关配置**

在一秒钟内多次访问http://localhost:8080/order-service/order/buy/1就可以看到限流启作用了。  
![在这里插入图片描述][20200404235140730.png]  
**（4）自定义异常提示**  
当触发限流后页面显示的是Blocked by Sentinel: FlowException。为了展示更加友好的限流提示，Sentinel支持自定义异常处理。  
您可以在 GatewayCallbackManager 注册回调进行定制：

*  setBlockHandler ：注册函数用于实现自定义的逻辑处理被限流的请求，对应接口为  
    BlockRequestHandler 。默认实现为 DefaultBlockRequestHandler ，当被限流时会返回类似于下面的错误信息： Blocked by Sentinel: FlowException 。

/** * 自定义限流处理器 */
    	//@PostConstruct
    	public void initBlockHandlers() { 
    		BlockRequestHandler blockHandler = new BlockRequestHandler() { 
    			public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) { 
    				Map map = new HashMap();
    				map.put("code",001);
    				map.put("message","不好意思,限流啦");
    				return ServerResponse.status(HttpStatus.OK)
    						.contentType(MediaType.APPLICATION_JSON_UTF8)
    						.body(BodyInserters.fromObject(map));
    			}
    		};
    		GatewayCallbackManager.setBlockHandler(blockHandler);
    	}

**（5） 参数限流**  
上面的配置是针对整个路由来限流的，如果我们只想对某个路由的参数做限流，那么可以使用参数限流方式：

/** * 配置初始化的限流参数 * 用于指定资源的限流规则. * 1.资源名称 (路由id) * 2.配置统计时间 * 3.配置限流阈值 */
    	@PostConstruct
    	public void initGatewayRules() { 
    		Set<GatewayFlowRule> rules = new HashSet<>();
    		rules.add(new GatewayFlowRule("product-service")
    				.setCount(1)
    				.setIntervalSec(1)
    				.setParamItem(new GatewayParamFlowItem()
    					//通过指定PARAM_PARSE_STRATEGY_URL_PARAM表示从url中获取参数，setFieldName指定参数名称
    					.setParseStrategy(SentinelGatewayConstants.PARAM_PARSE_STRATEGY_URL_PARAM)
    					.setFieldName("id")
    				)
    		);
    		GatewayRuleManager.loadRules(rules);
    	}

**（6） 自定义API分组**

/** * 自定义API限流分组 * 1.定义分组 * 2.对小组配置限流规则 */
    	@PostConstruct
    	private void initCustomizedApis() { 
    		Set<ApiDefinition> definitions = new HashSet<>();
    		ApiDefinition api1 = new ApiDefinition("product_api")
    				.setPredicateItems(new HashSet<ApiPredicateItem>() { { 
    					add(new ApiPathPredicateItem().setPattern("/product-service/product/**"). //已/product-service/product/开都的所有url
    							setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX));
    				}});
    		ApiDefinition api2 = new ApiDefinition("order_api")
    				.setPredicateItems(new HashSet<ApiPredicateItem>() { { 
    					add(new ApiPathPredicateItem().setPattern("/order-service/order")); //完全匹配/order-service/order 的url
    				}});
    		definitions.add(api1);
    		definitions.add(api2);
    		GatewayApiDefinitionManager.loadApiDefinitions(definitions);
    	}

# 6 网关高可用 #

高可用HA（High Availability）是分布式系统架构设计中必须考虑的因素之一，它通常是指，通过设计减少系统不能提供服务的时间。我们都知道，单点是系统高可用的大敌，单点往往是系统高可用最大的风险和敌人，应该尽量在系统设计的过程中避免单点。方法论上，高可用保证的原则是“集群化”，或者叫“冗余”：只有一个单点，挂了服务会受影响；如果有冗余备份，挂了还有其他backup能够顶上。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 14]  
我们实际使用 Spring Cloud Gateway 的方式如上图，不同的客户端使用不同的负载将请求分发到后端的 Gateway，Gateway 再通过HTTP调用后端服务，最后对外输出。因此为了保证 Gateway 的高可用性，前端可以同时启动多个 Gateway 实例进行负载，在 Gateway 的前端使用 Nginx 或者 F5 进行负载转发以达到高可用性。  
**（1） 准备多个GateWay工程**  
依次 配置 gateway\_server 的端口号 为 8080 8081，  
**（2） 配置ngnix**  
找到ngnix添加负载均衡配置

#配置多台服务器（这里只在一台服务器上的不同端口）
    upstream gateway { 
       server 127.0.0.1:8081;
       server 127.0.0.1:8080;
    }
    #请求转向mysvr 定义的服务器列表 
    location / {  
       proxy_pass http://gateway; 
    }

在浏览器上通过访问http://localhost/product-service/product/1请求的效果和之前是一样的。这次关闭一台网关服务器，还是可以支持部分请求的访问。

# 7 执行流程分析 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 15]  
Spring Cloud Gateway 核心处理流程如上图所示，Gateway的客户端向 Spring Cloud Gateway 发送请求，请求首先被 HttpWebHandlerAdapter 进行提取组装成网关上下文，然后网关的上下文会传递到 DispatcherHandler 。 DispatcherHandler 是所有请求的分发处理器， DispatcherHandler 主要负责分发请求对应的处理器。比如请求分发到对应的 RoutePredicateHandlerMapping （路由断言处理映射器）。路由断言处理映射器主要作用用于路由查找，以及找到路由后返回对应的FilterWebHandler 。 FilterWebHandler 主要负责组装Filter链并调用Filter执行一系列的Filter处理，然后再把请求转到后端对应的代理服务处理，处理完毕之后将Response返回到Gateway客户端。

[20200404223119353.png]: /images/20230528/d77235848b2e4c60a1fc7498673c6210.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70]: /images/20230528/ce1ac7cb6e644943958efd78abaa8a66.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 1]: /images/20230528/51f0ebef448a43deae8c1ecc5de44fb9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 2]: /images/20230528/eb0c0771a3084dd487f012e8102ac609.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200404230809161.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200404231121175.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 5]: /images/20230528/2b830b2d0d0e4130891004581f4c5d30.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 6]: /images/20230528/1b116103a22f4319b2f88ff9488ba5ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 7]: /images/20230528/ea0101230c30428aae644cfdee2930fb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 8]: /images/20230528/2cc7c23d6a0d4735949f4f8828beeb31.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 9]: /images/20230528/152bc0badbd1466eb1c829bddd89c7f5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 10]: /images/20230528/89424ae40e2f4c048cfc9b4e191830ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 11]: /images/20230528/86ae1273add04c648ac1470f52e6687d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 12]: /images/20230528/ef083960f8a545cf8a3f379a8b7d7936.png
[20200404233641762.png]: /images/20230528/69e103e13e4f46e087087acee9b98489.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 13]: /images/20230528/cc8d042cff694773990442b57a5a48e4.png
[20200404235140730.png]: /images/20230528/6c4e0bbe859f4f61b4371ce50b3a0925.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 14]: /images/20230528/60fdd952e3d1404796d1f0ace62de71f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU5NjkwNQ_size_16_color_FFFFFF_t_70 15]: /images/20230528/f6aad3ca19a348a9bd97cd2948dcd896.png