SpringCloud Alibaba微服务分布式组件---Gateway

7. SpringCloud 微服务网关Gateway组件

---

当设计多个微服务之后，会出现诸多的问题：

• 每个业务都会需要鉴权、限流、权限校验、跨域等逻辑，如果每个业务都各自为战，自己造轮子实现一遍，会很繁冗，我们可以将其抽出来，放到一个统一的地方去管理
• 如果业务量比较简单的话，这种方式前期是不会有什么问题的，但随着业务越来越复杂，比如淘宝、亚马逊打开一个页面可能涉及到数百个微服务协同工作，如果每一个微服务都分配一个域名的话，一方面客户端代码会很难维护，涉及到数百个域名，另一个方面是连接数的瓶颈
• 后期如果需要对微服务进行重构的话，也会变得非常麻烦，需要客户端配合你一起进行改造，比如商品服务，随着业务越来越复杂，后期需要进行拆分多各微服务，这个时候对外提供的服务业需要拆分成多个，同时需要客户端配合你进行改造

上面的这些问题我们可以通过 API 网关来解决

所谓的 API 网关，就是指系统的统一入口，它封装了应用程序的内部结构，为客户端提供统一服务，一些与业务本身功能无关的公共逻辑可以在这里实现，诸如认证、授权、监控、路由转发等等

7.1 什么是SpringCloud Gateway

网关作为流量入口，常用的功能包括路由转发、权限校验、限流等

• SpringCloud Gateway 是 SpringCloud 官方推出的第二代网关框架，定位于取代 Neflix Zuul。相比 Zuul 来说，SpringCloud Gateway 提供更优秀的性能，更强大的功能

• SpringCloud Gateway 是由 WebFlux Netty Reactor 实现的响应式的 API 网关。它不能在传统的 servlet 容器中工作，也不能构建成 war 包

• SpringCloud Gateway 旨在为微服务架构提供一种简单且有效的 API 路由的管理方式，并基于 Filter 的方式提供网关的基本功能，例如说安全认证、监控、限流等等

很多地方说 Zuul 是阻塞的，Gateway 是非阻塞的，这么说不严谨。准确地讲，Zuul 1.x 版本是阻塞的，而在 Zuul 2.x 也是基于 Netty，是非阻塞的

官方文档：https://docs.spring.io/spring-cloud-gateway/docs/current/reference/html/#gateway-starter

SpringCloud Gateway 功能特性

• 基于Spring Framework 5，Project Reactor 和 SpringBoot 2.0 进行构建
• 动态路由，能够匹配任何请求属性
• 支持路径重写
• 集成 SpringCloud 服务发现功能（Nacos、Eruka）
• 可集成流控降级
• 可以对路由指定易于编写的 Predicate（断言）和 Filter （过滤器）

7.1.1 核心概念

• 路由（Route）

路由是网关中最基础的部分，路由信息包括一个 ID、一个目的 URL、一组 Filter 组成。如果断言为真，则说明请求的 URL 和配置的路由匹配

• 断言（Predicate）

Java8 中的断言函数，SpringCloud Gateway中的断言函数类型是 Spring5.0 框架中的 ServerWebExchange。断言函数允许开发者去定义匹配 Http request 中的任何信息，比如请求头和参数等

• 过滤器（Filter）

SpringCloud Gateway 中的 Gateway Filter 和 Global Filter。Filter 可以对请求和响应进行处理

7.1.2 工作原理

7.2 SpringCloud Gateway 快速开始

1）创建一个springcloud-gateway-8088模块

2）导入依赖pom.xml

<dependencies>
    <!--gateway的依赖 springcloud开发-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
</dependencies>

3）配置application.yml文件

server:
  port: 8088
spring:
  application:
    # 服务名称
    name: api-gateway
  cloud:
    inetutils:
      # 配置忽略的网卡信息
      ignored-interfaces: 'VMware Virtual Ethernet Adapter for VMnet1,VMware Virtual Ethernet Adapter for VMnet8'
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        - id: consumer_route  # 路由的唯一标识,路由到consumer
          uri: http://localhost:80  # 需要转发的地址
          # 断言规则  用于路由规则的匹配
          predicates:
            - Path=/consumer_serv/**
              # http://localhost:8088/consumer_serv/consumer/dept/msg 路由到
              # http://localhost:80/consumer_serv/consumer/dept/msg
          filters:
            # http://localhost:80/consumer/dept/msg
            - StripPrefix=1   # 转发之前,过滤掉第一层前缀 "consumer_serv"

4）测试

1. 启动 Nacos 服务注册中心
2. 启动springcloud-provider-dept-8001
3. 启动springcloud-consumer-dept-80
4. 启动springcloud-gateway-8088
5. 访问http://localhost:8088/consumer_serv/consumer/dept/msg

7.3 Gateway—整合 Nacos

1）修改application.yml

server:
  port: 8088
spring:
  application:
    # 服务名称
    name: api-gateway
  cloud:
    inetutils:
      # 配置忽略的网卡信息
      ignored-interfaces: 'VMware Virtual Ethernet Adapter for VMnet1,VMware Virtual Ethernet Adapter for VMnet8'
    # gateway 配置
    gateway:
      discovery:
        locator:
          enabled: true   # 是否启动自动识别nacos服务
    # 配置 Nacos
    nacos:
      discovery:
        # nacos 服务注册地址
        server-addr: 192.168.159.100:7070,192.168.159.100:7080,192.168.159.100:7090
        username: nacos
        password: nacos

2）启动springcloud-gateway-8088

1. 访问http://localhost:8088/springcloud-consumer-dept/consumer/dept/msg

推荐使用如下配置的application.yml，这样能够更灵活，配置更具体

server:
  port: 8088
spring:
  application:
    # 服务名称
    name: api-gateway
  cloud:
    inetutils:
      # 配置忽略的网卡信息
      ignored-interfaces: 'VMware Virtual Ethernet Adapter for VMnet1,VMware Virtual Ethernet Adapter for VMnet8'
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        - id: consumer_route  # 路由的唯一标识,路由到consumer
          uri: lb://springcloud-consumer-dept  # 从nacos中按照服务名获取微服务   lb: 使用nacos中的本地负载均衡策略
          # 断言规则  用于路由规则的匹配
          predicates:
            - Path=/consumer_serv/**
              # http://localhost:8088/consumer_serv/consumer/dept/msg 路由到
              # http://localhost:80/consumer_serv/consumer/dept/msg
          filters:
            # http://localhost:80/consumer/dept/msg
            - StripPrefix=1   # 转发之前,过滤掉第一层前缀 "consumer_serv"
    # 配置 Nacos
    nacos:
      discovery:
        server-addr: 192.168.159.100:7070,192.168.159.100:7080,192.168.159.100:7090
        username: nacos
        password: nacos

7.4 Gateway—内置路由断言工厂

7.4.1 路由断言工厂（Route Predicate Factorys）配置

https://docs.spring.io/spring-cloud-gateway/docs/current/reference/html/#gateway-request-predicates-factories

作用：当请求 gateway 的时候，使用断言对请求进行匹配，如果匹配成功就路由转发，如果匹配失败就返回404

类型：内置

SpringCloud Gateway 断言工厂

SpringCloud Gate 包括许多内置的断言工厂，所有这些断言都与 HTTP 请求的不同属性匹配

• 基于 Datetime 类型的断言工厂

System.out.println(ZonedDateTime.now());		# 获取区域时间

此类型的断言根据时间做判断，主要有三个：

AfterRoutePredicateFactory：接收一个日期参数，判断请求日期是否晚于指定日期

BeforeRoutePredicateFactory：接收一个日期参数，判断请求日期是否早于指定日期

BetweenRoutePredicateFactory：接收两个日期参数，判断请求日期是否在指定时间段内

AfterRoutePredicateFactory

- After=2021-05-13T13:14:57.028 08:00[Asia/Shanghai]

server:
  port: 8088
spring:
  application:
    # 服务名称
    name: api-gateway
  cloud:
    inetutils:
      # 配置忽略的网卡信息
      ignored-interfaces: 'VMware Virtual Ethernet Adapter for VMnet1,VMware Virtual Ethernet Adapter for VMnet8'
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        - id: consumer_route  # 路由的唯一标识,路由到consumer
          uri: lb://springcloud-consumer-dept  # 从nacos中按照服务名获取微服务   lb: 使用nacos中的本地负载均衡策略
          # 断言规则  用于路由规则的匹配
          predicates:
            - Path=/consumer/**
              # 访问20201-05-13...之后
            - After=2021-05-13T13:14:57.028 08:00[Asia/Shanghai]
#          filters:
#             # http://localhost:80/consumer/dept/msg
#            - StripPrefix=1   # 转发之前,过滤掉第一层前缀 "consumer_serv"
    # 配置 Nacos
    nacos:
      discovery:
        server-addr: 192.168.159.100:7070,192.168.159.100:7080,192.168.159.100:7090
        username: nacos
        password: nacos

接口测试工具：ApiPost

下载客户端地址

• 基于远程地址的断言工厂

The RemoteAddr Route Predicate Factory：接收一个 IP 地址，判断请求主机地址是否在地址段中

- RemoteAddr=192.168.1.1/24

• 基于 Cookie 的断言工厂

The Cookie Route Predicate Factory：接收两个参数，cookie 名字和一个人正则表达式，判断请求

- Cookie=chocolate, ch.p

• 基于 Header 的断言工厂

The Header Route Predicate Factory：接收两个参数，标题名称和正则表达式，判断请求 Header 是否具有给定名称且值与正则表达式匹配

- Header=X-Request-Id,\d 

由于设置响应头不好操作，我们使用ApiPost工具

spring:
  cloud:
    gateway:
      routes:
        - id: consumer_route  # 路由的唯一标识,路由到consumer
          uri: lb://springcloud-consumer-dept  # 从nacos中按照服务名获取微服务   lb: 使用nacos中的本地负载均衡策略
          predicates:
            - Path=/consumer/**
              # 访问20201-05-13...之后
            - After=2021-05-13T13:14:57.028 08:00[Asia/Shanghai]
              # 匹配一个或多个数字的正则表达式
            - Header=X-Request-Id,\d 

• 基于 Host 的断言工厂

The Host Route Predicate Factory：接收一个参数，主机名模式，判断请求的 Host 是否满足匹配规则

- Host=**.somehost.org,**.anotherhost.org

• 基于 Method 请求方法的断言工厂

The Method Route Predicate Factory：接受一个参数，判断请求类型是否跟指定的类型匹配

- Method=GET,POST

spring:
  cloud:
    gateway:
      routes:
        - id: consumer_route  # 路由的唯一标识,路由到consumer
          uri: lb://springcloud-consumer-dept  # 从nacos中按照服务名获取微服务   lb: 使用nacos中的本地负载均衡策略
          predicates:
            - Path=/consumer/**
              # 访问20201-05-13...之后
            - After=2021-05-13T13:14:57.028 08:00[Asia/Shanghai]
              # 匹配一个或多个数字的正则表达式
            - Header=X-Request-Id,\d 
              # 只允许是GET请求的接口
            - Method=GET

• 基于 Path 请求路径的断言工厂

The Path Route Predicate Factory：接受一个参数，判断请求的 URI 部分是否满足路径规则

- Path=/red/{segment},/blue/{segment}

• 基于 Query 请求参数的断言工厂

The Query Route Predicate Factory：接收两个参数，请求 param 和正则表达式，判断请求是否具有给定名称且值与正则表达式匹配

- Query=green

spring:
  cloud:
    gateway:
      routes:
        - id: consumer_route  # 路由的唯一标识,路由到consumer
          uri: lb://springcloud-consumer-dept  # 从nacos中按照服务名获取微服务   lb: 使用nacos中的本地负载均衡策略
          predicates:
            - Path=/consumer/**
              # 访问20201-05-13...之后
            - After=2021-05-13T13:14:57.028 08:00[Asia/Shanghai]
              # 匹配一个或多个数字的正则表达式
            - Header=X-Request-Id,\d 
              # 只允许是GET请求的接口
            - Method=GET
              # 必须要有一个"name"的参数,可以选择该参数的指定的值
            - Query=name,vinjcent|totoro

• 基于路由权重的断言工厂

The Weight Route Predicate Factory：接收到 [组名，权重]，然后对于同一个组内的路由按照权重转发

spring:
  cloud:
    gateway:
      routes:
      - id: weight_high
        uri: https://weighthigh.org
        predicates:
        - Path=/product/**
        # 代表在group1组中，10次访问有8次路由到 https://weighthigh.org服务下的/product/** 地址
        - Weight=group1, 8
      - id: weight_low
        uri: https://weightlow.org
        predicates:
        - Path=/product/**
        # 10次访问有2次路由到 https://weightlow.org服务下的/product/** 地址
        - Weight=group1, 2

7.4.2 自定义路由断言工厂

自定义理由断言工厂需要继承 AbstractRoutePredicateFactory 类，重写 apply() 方法。在 apply() 1方法中可以通过 exchange.getRequest() 拿到 ServerHttpRequest 对象，从而可以获取到请求的参数、请求方式、请求头等信息

实现条件：

• 必须是 spring 组件 bean
• 类必须加上 RoutePredicateFactory 作为结尾，由于底层采用的是反射的方式，会根据配置文件中 Query RoutePredicateFactory 找到自定义的路由断言工厂
• 必须继承 AbstractRoutePredicateFactory
• 必须在自定义类中实现静态内部类 AbstractRoutePredicateFactory<CheckAuthRoutePredicateFactory.Config> 声明属性来接受配置文件中对应的断言信息，需要结合 shortcutFieldOrder() 方法进行绑定
• 通过 apply() 方法进行逻辑判断，true 就是匹配成功，false 就是匹配失败

测试

1. 自定义一个类 DivCheckAuthRoutePredicateFactory.class，必须以xxxRoutePredicateFactory结尾

package com.vinjcent.springcloud.config;

import org.springframework.cloud.gateway.handler.predicate.AbstractRoutePredicateFactory;
import org.springframework.cloud.gateway.handler.predicate.GatewayPredicate;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.server.ServerWebExchange;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

/**
 * 自定义路由断言工厂
 * 如果匹配的"name"不是vinjcent
 * 那么就会返回404
 */
@Component
public class DivCheckAuthRoutePredicateFactory extends AbstractRoutePredicateFactory<DivCheckAuthRoutePredicateFactory.Config>  {

    public DivCheckAuthRoutePredicateFactory() {
        super(DivCheckAuthRoutePredicateFactory.Config.class);
    }

    // 绑定 config()
    public List<String> shortcutFieldOrder() {
        return Arrays.asList("name");
    }

    public Predicate<ServerWebExchange> apply(DivCheckAuthRoutePredicateFactory.Config config) {
        return new GatewayPredicate() {
            public boolean test(ServerWebExchange exchange) {

                if (config.getName().equals("vinjcent")){
                    return true;
                }
                return false;
            }

        };
    }

    // 用于接收配置文件中  断言的信息
    @Validated
    public static class Config {

        private String name;

        public Config(String name) {
            this.name = name;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}

1. 启动springcloud-gateway-8088

2. 访问http://localhost:8088/consumer/dept/msg

3. 修改 application.yml

4. 访问http://localhost:8088/consumer/dept/msg

7.5 Gateway—过滤器工厂（Gateway Filter Factory）配置

Gateway 内置了很多的过滤器工厂，我们可以通过一些过滤器工厂进行一些业务逻辑处理器，比如添加剔除响应头，添加去除参数等

33个过滤器

https://docs.spring.io/spring-cloud-gateway/docs/current/reference/html/#gatewayfilter-factories

AddRequestHeader 测试

1. 在springcloud-consumer-dept-80模块controller中添加一个/consumer/header接口

@RestController
@RequestMapping("/consumer")
@SuppressWarnings("all")
public class DeptController {

    @Autowired
    private RestTemplate restTemplate;

    private static final String REST_URL_PREFIX = "http://springcloud-provider-dept";

    @GetMapping("/dept/msg")
    public String getMessage() {

        return restTemplate.getForObject(REST_URL_PREFIX   "/dept/msg", String.class);
    }

    @GetMapping("/header")
    public String getHeader(@RequestHeader("X-Request-color") String color) {

        return color;
    }

}

2. 修改springcloud-gateway-8088模块下applicatiom.yml文件

server:
  port: 8088
spring:
  application:
    # 服务名称
    name: api-gateway
  cloud:
    inetutils:
      # 配置忽略的网卡信息
      ignored-interfaces: 'VMware Virtual Ethernet Adapter for VMnet1,VMware Virtual Ethernet Adapter for VMnet8'
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        - id: consumer_route  # 路由的唯一标识,路由到consumer
          uri: lb://springcloud-consumer-dept  # 从nacos中按照服务名获取微服务   lb: 使用nacos中的本地负载均衡策略
          # 断言规则  用于路由规则的匹配
          predicates:
            - Path=/consumer/**
#            - DivCheckAuth=vinjcent
#              # 访问20201-05-13...之后
#            - After=2021-05-13T13:14:57.028 08:00[Asia/Shanghai]
#              # 匹配一个或多个数字的正则表达式
#            - Header=X-Request-Id,\d 
#              # 只允许是GET请求的接口
#            - Method=GET
#              # 必须要有一个"name"的参数,可以选择该参数的指定的值
#            - Query=name,vinjcent|totoro
          filters:
            - AddRequestHeader=X-Request-color, blue    # 添加请求头
#             # http://localhost:80/consumer/dept/msg
#            - StripPrefix=1   # 转发之前,过滤掉第一层前缀 "consumer_serv"
    # 配置 Nacos
 ......

3. 启动springcloud-consumer-dept-80
4. 启动springcloud-gateway-8088
5. 访问http://localhost:8088/consumer/header

PrefixPath 测试

1. 修改springcloud-consumer-dept-80模块application.yml文件

server:
  port: 80
  servlet:
    context-path: /vinjcent

spring:
  application:
    name: springcloud-consumer-dept
  # 配置nacos
  cloud:
    nacos:
      # nacos 服务地址
      server-addr: 192.168.159.100:7070,192.168.159.100:7080,192.168.159.100:7090
      discovery:
        username: nacos   # nacos用户名
        password: nacos
        namespace: public   # 分隔开发环境和测试环境使用

# 调用的服务提供方
springcloud-provider-dept:
  ribbon:
    # 复制NacosRule类的引用路径
    NFLoadBalancerRuleClassName: com.vincjent.ribbon.MyRibbon
......

2. 修改springcloud-gateway-8088模块application.yml文件

server:
  port: 8088
spring:
  application:
    # 服务名称
    name: api-gateway
  cloud:
    inetutils:
      # 配置忽略的网卡信息
      ignored-interfaces: 'VMware Virtual Ethernet Adapter for VMnet1,VMware Virtual Ethernet Adapter for VMnet8'
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        - id: consumer_route  # 路由的唯一标识,路由到consumer
          uri: lb://springcloud-consumer-dept  # 从nacos中按照服务名获取微服务   lb: 使用nacos中的本地负载均衡策略
          # 断言规则  用于路由规则的匹配
          predicates:
            - Path=/consumer/**
#            - DivCheckAuth=vinjcent
#              # 访问20201-05-13...之后
#            - After=2021-05-13T13:14:57.028 08:00[Asia/Shanghai]
#              # 匹配一个或多个数字的正则表达式
#            - Header=X-Request-Id,\d 
#              # 只允许是GET请求的接口
#            - Method=GET
#              # 必须要有一个"name"的参数,可以选择该参数的指定的值
#            - Query=name,vinjcent|totoro
          filters:
            - AddRequestHeader=X-Request-color, blue    # 添加请求头
            - PrefixPath=/vinjcent    # 添加前缀,对应微服务需要配置context-path

3. 启动springcloud-consumer-dept-80
4. 启动springcloud-gateway-8088
5. 访问http://localhost:8088/consumer/dept/msg

6. 访问http://localhost/consumer/dept/msg

7. 访问http://localhost/vinjcent/consumer/dept/msg

RedirectTo 测试

1. 修改springcloud-gateway-8088模块application.yml文件

server:
  port: 8088
spring:
  application:
    # 服务名称
    name: api-gateway
  cloud:
    inetutils:
      # 配置忽略的网卡信息
      ignored-interfaces: 'VMware Virtual Ethernet Adapter for VMnet1,VMware Virtual Ethernet Adapter for VMnet8'
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        - id: consumer_route  # 路由的唯一标识,路由到consumer
          uri: lb://springcloud-consumer-dept  # 从nacos中按照服务名获取微服务   lb: 使用nacos中的本地负载均衡策略
          # 断言规则  用于路由规则的匹配
          predicates:
            - Path=/consumer/**
#            - DivCheckAuth=vinjcent
#              # 访问20201-05-13...之后
#            - After=2021-05-13T13:14:57.028 08:00[Asia/Shanghai]
#              # 匹配一个或多个数字的正则表达式
#            - Header=X-Request-Id,\d 
#              # 只允许是GET请求的接口
#            - Method=GET
#              # 必须要有一个"name"的参数,可以选择该参数的指定的值
#            - Query=name,vinjcent|totoro
          filters:
            - AddRequestHeader=X-Request-color, blue    # 添加请求头
            - PrefixPath=/vinjcent    # 添加前缀,对应微服务需要配置context-path
            - RedirectTo=302,https://www.百度.com/   # 302错误重定向到百度

7.5.1 自定义过滤器工厂

1. 在springcloud-gateway-8088模块下创建一个DivFilterGatewayFilterFactory.class类，注意后缀必须是 xxxGatewayFilterFactory

import org.apache.commons.lang.StringUtils;
import org.springframework.cloud.gateway.filter.GatewayFilter;
import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
import java.util.Arrays;
import java.util.List;

@Component
public class DivFilterGatewayFilterFactory extends AbstractGatewayFilterFactory<DivFilterGatewayFilterFactory.Config> {


    public DivFilterGatewayFilterFactory() {
        super(DivFilterGatewayFilterFactory.Config.class);
    }

    public List<String> shortcutFieldOrder() {
        return Arrays.asList("value");
    }

    public GatewayFilter apply(DivFilterGatewayFilterFactory.Config config) {
        return new GatewayFilter() {
            @Override
            public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

                String name = exchange.getRequest().getQueryParams().getFirst("name");

                if (StringUtils.isNotBlank(name)){
                    if (config.getValue().equals(name)){
                        return chain.filter(exchange);
                    }else {
                        // 返回404
                        exchange.getResponse().setStatusCode(HttpStatus.NOT_FOUND);
                        return exchange.getResponse().setComplete();
                    }
                }
                // 正常请求

                return chain.filter(exchange);
            }
        };
    }



    public static class Config {
        String value;

        public Config() {
        }

        public String getValue() {
            return value;
        }

        public void setValue(String value) {
            this.value = value;
        }

        public Config(String value) {
            this.value = value;
        }
    }
}

2. 修改application.yml文件

server:
  port: 8088
spring:
  application:
    # 服务名称
    name: api-gateway
  cloud:
    inetutils:
      # 配置忽略的网卡信息
      ignored-interfaces: 'VMware Virtual Ethernet Adapter for VMnet1,VMware Virtual Ethernet Adapter for VMnet8'
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        - id: consumer_route  # 路由的唯一标识,路由到consumer
          uri: lb://springcloud-consumer-dept  # 从nacos中按照服务名获取微服务   lb: 使用nacos中的本地负载均衡策略
          # 断言规则  用于路由规则的匹配
          predicates:
            - Path=/consumer/**
#            - DivCheckAuth=vinjcent
#              # 访问20201-05-13...之后
#            - After=2021-05-13T13:14:57.028 08:00[Asia/Shanghai]
#              # 匹配一个或多个数字的正则表达式
#            - Header=X-Request-Id,\d 
#              # 只允许是GET请求的接口
#            - Method=GET
#              # 必须要有一个"name"的参数,可以选择该参数的指定的值
#            - Query=name,vinjcent|totoro
          filters:
            - DivFilter=vinjcent	#指定过滤参数可以为null或参数值为"vinjcent"
#            - AddRequestHeader=X-Request-color, blue    # 添加请求头
#            - PrefixPath=/vinjcent    # 添加前缀,对应微服务需要配置context-path
#            - RedirectTo=302,https://www.百度.com/   # 302错误重定向到百度
#             # http://localhost:80/consumer/dept/msg
#            - StripPrefix=1   # 转发之前,过滤掉第一层前缀 "consumer_serv"
    # 配置 Nacos
......

3. 启动springcloud-gateway-8088

4. 访问http://localhost:8088/consumer/dept/msg?name=hhh

5. 访问http://localhost:8088/consumer/dept/msg

6. 访问http://localhost:8088/consumer/dept/msg?name=vinjcent

7.6 Gateway—全局过滤器

7.6.1 全局过滤器（Global Filter）配置

局部过滤器和全局过滤器区别：

• 局部：局部针对某个路由请求
• 全局：针对所有的路由请求，一旦定义了就会投入使用

GlobalFilter 接口和 GatewayFilter 有一样的接口定义，只不过，GlobalFilter 会作用于所有路由

LoadBalancerClientFilter

LoadBalancerClientFilter 会查看exchange的属性 ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR 的值（一个RUI），如果该值的 scheme 是 lb，比如：lb://myservice，它将会使用 SpringCloud 的 LoadBalancerClient 来将 myservice 解析成实际的 host 和port，并替换掉 ServerWebExchangeUtils.GATEWAY_REQUEST_URL_ATTR 的内容

自定义全局过滤器

1. 在springcloud-gateway-8088模块下创建DivGlobalFilter.class并实现GlobalFilter接口重写filter方法

@Component
public class DivGlobalFilter implements GlobalFilter {

    Logger log = LoggerFactory.getLogger(this.getClass());
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

        // 在控制台打印请求资源路径
        log.info(exchange.getRequest().getPath().value());
        return chain.filter(exchange);
    }
}

2. 启动springcloud-gateway-8088并访问
3. 访问http://localhost:8088/consumer/dept/msg

7.7 Gateway—请求日志记录&跨域处理

Reactor Netty 访问日志

要启动 Reactor Netty 访问日志，请设置 -Dreactor.netty.http.server.accessLogEnabled=true

它必须是 Java 系统属性，而不是 SpringBoot 属性配置

可以将日志记录系统配置为具有单独的访问日志文件。以下示例创建一个 Logback 配置

• logback.xml

<appender name="accessLog" class="ch.qos.logback.core.FileAppender">
    <file>access_log.log</file>
    <encoder>
        <pattern>%msg%n</pattern>
    </encoder>
</appender>
<appender name="async" class="ch.qos.logback.classic.AsyncAppender">
    <appender-ref ref="accessLog" />
</appender>

<logger name="reactor.netty.http.server.AccessLog" level="INFO" additivity="false">
    <appender-ref ref="async"></appender-ref>
</logger>

1. 启动springcloud-gateway-8088并访问

2. 访问http://localhost:8088/consumer/dept/msg

Gateway 跨域配置（CORS Configuration）

官方文档：https://docs.spring.io/spring-cloud-gateway/docs/current/reference/html/#cors-configuration

spring:
  cloud:
    gateway:
      globalcors:
        cors-configurations:
          '[/**]':
            allowedOrigins: "https://docs.spring.io"
            allowedMethods:
            - GET

使用配置文件方式

1. 在springcloud-gateway-8088模块下，添加一个main.html位置于pom.xml同一等级目录下

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>单选页面</title>
    <head>
        <meta charset="utf-8">
        <title>Bootstrap 实例 - 悬停表格</title>
        <script src="https://cdn.staticfile.org/jquery/2.1.1/jquery.min.js"></script>
        <link rel="stylesheet" href="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/css/bootstrap.min.css">
        <script src="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/js/bootstrap.min.js"></script>
    </head>
    <style>
        .btn-block{
            border: darkgray 2px solid
        }
        .toStore{
            margin-top: 20px;
        }
        .toStore a{
            text-decoration: none;
        }
    </style>
<body>
<p class="toStore"><a href="/toStore">点击跳转库存页面</a></p>
<form action="/choose" onsubmit="">
<table class="table table-hover">
    <caption>你心中的偶像是?</caption>
    <thead>
    <tr>
        <th>名称</th>
        <th>单选框</th>
    </tr>
    </thead>
    <tbody>
    <tr>
        <td>Tanmay</td>
        <td><input type="radio" value="Tanmay" name="idol" checked></td>
    </tr>
    <tr>
        <td>Sachin</td>
        <td><input type="radio" value="Sachin" name="idol"></td>
    </tr>
    <tr>
        <td>Uma</td>
        <td><input type="radio" value="Uma" name="idol"></td>
    </tr>
    <tr>
        <td>Totoro</td>
        <td><input type="radio" value="Totoro" name="idol"></td>
    </tr>
    <tr>
        <td>Vinjcent</td>
        <td><input type="radio" value="Vinjcent" name="idol"></td>
    </tr>
    </tbody>
</table>
    <p>
    <div class="input-group">
        <span class="input-group-addon">年龄</span>
        <input type="text" id="age" name="age" class="form-control" placeholder="Say something...">
    </div>
    </p>
    <p>
    <input type="button" class="btn btn-default btn-lg btn-block" value="点击跨域请求" onclick="getMsg()" />

    </p>
</form>

</body>
<script>

    function getMsg(){
        $.get('http://localhost:8088/consumer/dept/msg',function (data){
            alert(data);
        });
    }

</script>

</html>

2. 在 IDEA 中打开该网页并点击按钮请求

3. 修改application.yml文件

spring:
  cloud:
    gateway:
      globalcors:
        cors-configurations:
          '[/**]':    # 允许跨域访问的资源
            allowedOrigins: "*"    # 跨域允许的来源,如www.vinjcent.com
            allowedMethods:		# 允许请请求的类型	
              - GET
              - POST

4. 重新启动springcloud-gateway-8088并代开网页请求

通过代码实现

1. 在模块中创建一个CORSConfiguration.class

package com.vinjcent.springcloud.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.cors.CorsConfiguration;

import org.springframework.web.cors.reactive.CorsWebFilter;
import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource;
import org.springframework.web.util.pattern.PathPatternParser;

@Configuration
public class CORSConfiguration {
    
    @Bean
    public CorsWebFilter corsWebFilter() {

        CorsConfiguration config = new CorsConfiguration();
        // 设置所有请求方法都可以访问
        config.addAllowedMethod("*");
        // 设置所有请求源地址都可以访问
        config.addAllowedOrigin("*");
        // 设置所有请求响应头都可以访问
        config.addAllowedHeader("*");

        // 运行访问的资源
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(new PathPatternParser());
        source.registerCorsConfiguration("/**",config);
        
        return new CorsWebFilter(source);
    
    }
}

2. 重新启动springcloud-gateway-8088并代开网页请求

7.8 Gateway—整合sentinel降级

网关作为内部系统外的一层屏障，对内起到一定的保护作用，限流便是其中之一. 网关层和限流可以简单地针对不同路由进行限流，也可以针对业务的接口进行限流，或者根据接口的特征分组限流

源码地址：https://github.com/alibaba/Sentinel/wiki/网关限流

1）在springcloud-gateway-8088模块下

1. 添加依赖pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>springcloud</artifactId>
        <groupId>com.vinjcent</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>gateway</artifactId>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <!--gateway的依赖 springcloud开发-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <!--nacos-服务注册与发现-->
        <dependency>
            <groupId>com.alibaba.cloud</groupId>
            <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
        </dependency>
        <!--sentinel 整合 gateway-->
        <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>
    </dependencies>


</project>

2. 添加配置application.yml

server:
  port: 8088
spring:
  application:
    # 服务名称
    name: api-gateway
  cloud:
    # 配置 Nacos
    nacos:
      discovery:
        server-addr: 192.168.159.100:7070,192.168.159.100:7080,192.168.159.100:7090
        username: nacos
        password: nacos
    # 配置Sentinel
    sentinel:
      transport:
        dashboard: 127.0.0.1:8858   # Sentinel控制台地址
    inetutils:
      # 配置忽略的网卡信息
      ignored-interfaces: 'VMware Virtual Ethernet Adapter for VMnet1,VMware Virtual Ethernet Adapter for VMnet8'
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        - id: consumer_route  # 路由的唯一标识,路由到consumer
          uri: lb://springcloud-consumer-dept  # 从nacos中按照服务名获取微服务   lb: 使用nacos中的本地负载均衡策略
          # 断言规则  用于路由规则的匹配
          predicates:
            - Path=/consumer/**
#            - DivCheckAuth=vinjcent
#              # 访问20201-05-13...之后
#            - After=2021-05-13T13:14:57.028 08:00[Asia/Shanghai]
#              # 匹配一个或多个数字的正则表达式
#            - Header=X-Request-Id,\d 
#              # 只允许是GET请求的接口
#            - Method=GET
#              # 必须要有一个"name"的参数,可以选择该参数的指定的值
#            - Query=name,vinjcent|totoro
#          filters:
#            - DivFilter=vinjcent
#            - AddRequestHeader=X-Request-color, blue    # 添加请求头
#            - PrefixPath=/vinjcent    # 添加前缀,对应微服务需要配置context-path
#            - RedirectTo=302,https://www.百度.com/   # 302错误重定向到百度
#             # http://localhost:80/consumer/dept/msg
#            - StripPrefix=1   # 转发之前,过滤掉第一层前缀 "consumer_serv"
      # 跨域配置
#      globalcors:
#        cors-configurations:
#          '[/**]':    # 允许跨域访问的资源
#            allowedOrigins: "*"    # 跨域允许的来源,如www.vinjcent.com
#            allowedMethods:
#              - GET
#              - POST

3. 运行 sentinel-dashboard服务

4. 启动springcloud-gateway-8088
5. 访问网关中的任意接口http://localhost:8088/consumer/dept/msg，从而使服务注册到我们的 Sentinel 监控服务中
6. 【注意，在自己设置的 Sentinel服务中打开】打开http://localhost:8858/#/dashboard/gateway/flow/api-gateway，并对改网关设置流控规则

7. 任意快速访问在该网关中的微服务接口

Sentinel 流控降级详细配置

Burst size（最大容许数量）

Client IP（客户端IP）

Header（请求头）

URL 参数

API 分组

降级规则

并同时在页面中访问出现异常的接口http://localhost:8088/consumer/exception

自定义异常处理（使用 Java 配置）

1. 在springcloud-gateway-8088模块下添加GatewayConfig.class类

import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.BlockRequestHandler;
import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

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

@Configuration
public class GatewayConfig {

    @PostConstruct
    public void init() {

        BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {

            @Override
            public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {

			   // 异常输出	
                System.out.println(throwable);

                Map<String, String> map = new HashMap<>();
                map.put("code",HttpStatus.TOO_MANY_REQUESTS.toString());
                map.put("message","限流了!!!");


                // 设置响应状态码
                return ServerResponse.status(HttpStatus.OK)
                        // 设置相应类型
                        .contentType(MediaType.APPLICATION_JSON)
                        // 设置相应内容
                        .body(BodyInserters.fromValue(map));


            }
        };

        GatewayCallbackManager.setBlockHandler(blockRequestHandler);

    }

}

2. 访问任意接口使得网关服务在 Sentinel 监控台显示
3. 配置该网关接口的流控规则

4. 快速访问通过该网关的接口

自定义异常处理（使用 application.yml 配置）

server:
  port: 8088
spring:
  application:
    # 服务名称
    name: api-gateway
  cloud:
    # 配置 Nacos
    nacos:
      discovery:
        server-addr: 192.168.159.100:7070,192.168.159.100:7080,192.168.159.100:7090
        username: nacos
        password: nacos
    # 配置Sentinel
    sentinel:
      transport:
        dashboard: 127.0.0.1:8858   # Sentinel控制台地址
      # 配置自定义异常
      scg:
        fallback:
          mode: response
          response-body: "{code:'404',message:'服务出错啦!'}"
    inetutils:
      # 配置忽略的网卡信息
      ignored-interfaces: 'VMware Virtual Ethernet Adapter for VMnet1,VMware Virtual Ethernet Adapter for VMnet8'
    # gateway 配置
    gateway:
      # 路由规则
      routes:
        - id: consumer_route  # 路由的唯一标识,路由到consumer
          uri: lb://springcloud-consumer-dept  # 从nacos中按照服务名获取微服务   lb: 使用nacos中的本地负载均衡策略
          # 断言规则  用于路由规则的匹配
          predicates:
            - Path=/consumer/**
#            - DivCheckAuth=vinjcent
#              # 访问20201-05-13...之后
#            - After=2021-05-13T13:14:57.028 08:00[Asia/Shanghai]
#              # 匹配一个或多个数字的正则表达式
#            - Header=X-Request-Id,\d 
#              # 只允许是GET请求的接口
#            - Method=GET
#              # 必须要有一个"name"的参数,可以选择该参数的指定的值
#            - Query=name,vinjcent|totoro
#          filters:
#            - DivFilter=vinjcent
#            - AddRequestHeader=X-Request-color, blue    # 添加请求头
#            - PrefixPath=/vinjcent    # 添加前缀,对应微服务需要配置context-path
#            - RedirectTo=302,https://www.百度.com/   # 302错误重定向到百度
#             # http://localhost:80/consumer/dept/msg
#            - StripPrefix=1   # 转发之前,过滤掉第一层前缀 "consumer_serv"
      # 跨域配置
#      globalcors:
#        cors-configurations:
#          '[/**]':    # 允许跨域访问的资源
#            allowedOrigins: "*"    # 跨域允许的来源,如www.vinjcent.com
#            allowedMethods:
#              - GET
#              - POST

使用代码配置断言、异常、访问接口

同样也可以使用代码的方式配置规则，接口为 GatewayxxxRule

package com.vinjcent.springcloud.config;

import com.alibaba.csp.sentinel.adapter.gateway.common.SentinelGatewayConstants;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiDefinition;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPathPredicateItem;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.ApiPredicateItem;
import com.alibaba.csp.sentinel.adapter.gateway.common.api.GatewayApiDefinitionManager;
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.callback.BlockRequestHandler;
import com.alibaba.csp.sentinel.adapter.gateway.sc.callback.GatewayCallbackManager;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

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

@Configuration
public class GatewayConfig {

    @PostConstruct
    public void init() {

        BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {

            @Override
            public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {


                System.out.println(throwable);

                Map<String, String> map = new HashMap<>();
                map.put("code",HttpStatus.TOO_MANY_REQUESTS.toString());
                map.put("message","限流了!!!");


                // 设置响应状态码
                return ServerResponse.status(HttpStatus.OK)
                        // 设置相应类型
                        .contentType(MediaType.APPLICATION_JSON)
                        // 设置相应内容
                        .body(BodyInserters.fromValue(map));
            }
        };

        GatewayCallbackManager.setBlockHandler(blockRequestHandler);

    }

    @PostConstruct
    public void initRules() {

        // 初始化自定义的API
        initCustomizedApis();
        // 初始化网关的流控规则
        initGatewayRules();
        // 自定义限流异常处理器
        initBlockRequestHandler();

    }

    private void initCustomizedApis() {

        HashSet<ApiDefinition> definitions = new HashSet<>();
        ApiDefinition api = new ApiDefinition("user_service_api")
                .setPredicateItems(new HashSet<ApiPredicateItem>() {{
                    add(new ApiPathPredicateItem().setPattern("/user/**")
                            .setMatchStrategy(SentinelGatewayConstants.URL_MATCH_STRATEGY_PREFIX));
                }});

        definitions.add(api);
        GatewayApiDefinitionManager.loadApiDefinitions(definitions);
    }

    private void initGatewayRules() {
        Set<GatewayFlowRule> rules = new HashSet<>();
        // resource: 资源名称,可以是网关中的 route 名称或者用户自定义的 API 分组名称
        // count: 限流阈值
        // intervalSec: 统计时间窗口,单位是秒,默认是1s
        rules.add(new GatewayFlowRule("order_route")
                .setCount(2)
                .setIntervalSec(1)
        );

        rules.add(new GatewayFlowRule("user_service_api")
                .setCount(2)
                .setIntervalSec(1)
        );

        // 加载网关
        GatewayRuleManager.loadRules(rules);

    }

    private void initBlockRequestHandler() {
        BlockRequestHandler blockRequestHandler = new BlockRequestHandler() {
            @Override
            public Mono<ServerResponse> handleRequest(ServerWebExchange serverWebExchange, Throwable throwable) {
                HashMap<String, String> result = new HashMap<>();
                result.put("code",String.valueOf(HttpStatus.TOO_MANY_REQUESTS));
                result.put("msg",HttpStatus.TOO_MANY_REQUESTS.getReasonPhrase());

                return ServerResponse.status(HttpStatus.TOO_MANY_REQUESTS)
                        .contentType(MediaType.APPLICATION_JSON)
                        .body(BodyInserters.fromValue(result));
            }
        };

        // 设置自定义异常处理器
        GatewayCallbackManager.setBlockHandler(blockRequestHandler);
    }

}

网关高可用

为了保证 Gateway 的高可用性,可以同时启动多个 Gateway 实例进行负载，在 Gateway 的上游使用 Nginx 或者 F5 进行负载转发以达到高可用

下一篇文章《SkyWalking 微服务链路追踪》

这篇好文章是转载于：学新通技术网