SpringCloud Gateway-服务网关

1.Gateway介绍

1.1引出问题

没有使用网关服务时：

使用网关服务后：

1.2Gateway网络拓扑图

1.3Gateway是什么

官网：Spring Cloud Gateway

1. Gateway是Spring生态系统之上构建的API网关服务，基于Spring、SpringBoot和Project Reactor等技术
2. Gateway旨在提供一种简单有效的方式来对API进行路由，以及提供一切强大的过滤器功能，例如：熔断、限流、重试等

1.4Gateway核心功能

1. 鉴权
2. 流量控制
3. 熔断
4. 日志监控
5. 反向代理

1.5Gateway vs Zuul

（1）Gateway和Zuul的区别：

1. SpringCloud Gateway 作为Spring Cloud 生态系统中的网关，目标是替代Zuul
2. SpringCloud Gateway 是基于Spring WebFlux 框架实现的
3. Spring WebFlux框架底层则使用了高性能的Reactor模式通信框架Netty，提高了网关性能

（2）Gateway特性：

SpringCloud Gateway 基于 Spring Framework（支持Spring WebFlux），Project Reactor 和 Spring Boot 进行构建，具有如下特性：

• 动态路由
• 可以对路由指定 Predicate（断言）和 Filter（过滤器）
• 继承 Hystrix 的断路器功能
• 继承 Spring Cloud 服务发现功能
• 请求限流功能
• 支持路径重写

2.Gateway基本原理

2.1Gateway核心组件（路由、断言、过滤）

• Route（路由）

一句话：路由是构建网关的基本模块，它由ID，目标URI，一系列的断言和过滤器组成，如果断言为true，则匹配该路由

• Predicate（断言）

一句话：对Http请求中的所有内容（例如请求头或请求参数）进行匹配，如果请求与断言相匹配则进行路由。

简单举例：比如配置路径

Path=/member/get/** //断言，如果Http请求的路径匹配，则进行路由转发，如果不匹配则不进行路由转发

• Filter（过滤）

一句话：使用过滤器，可以在请求被路由前或者之后对请求进行处理。可以理解为，在对Http请求断言匹配成功之后，可以通过网关的过滤机制，对Http请求处理

简单举例：

filters:
  AddRequestParameter=color,blue 
  #过滤器在匹配的请求头加上一对请求头,名称为color,值为 blue, 比如原来的 http 请求为
  #http://localhost:10000/member/get/1 
  #--过滤器处理后->http://localhost:10000/member/get/1?color=blue

2.2工作机制

说明：

1. 客户端向 Spring Cloud Gateway 发出请求。然后在 Gateway Handler Mapping 中找到与请求相匹配的路由，将其发送到 Gateway Web Handler。
2. Handler 再通过指定的过滤器链来将请求发送到我们实际的服务执行业务逻辑，然后返回。
3. 过滤器之间用虚线分开是因为过滤器可能会在发送代理请求之前（"pre"）或之后（"post"）执行业务逻辑。（可以参考SpringMVC的拦截器执行顺序）
4. Filter 在"pre"类型的过滤器可以做参数校验、权限校验、流量监控、日志输出、协议转换等。
5. 在"post"类型的过滤器中可以做响应内容、响应头的修改，日志的输出，流量监控等有着非常重要的作用。
6. 一句话：路由转发+执行过滤器链

3.搭建Gateway微服务

3.1搭建Gateway-应用实例

3.1.1思路分析

如下，将原来的服务消费方升级成Gateway网关。

• 引入Gateway项目架构
• 通过网关暴露的接口，实现调用真正的服务
• 网关本身也是一个微服务模块

3.1.2代码实现

（1）参照之前的消费方member-service-consumer-80，创建e-commerce-gateway-20000项目

（2）修改项目的pom.xml文件

<!--引入相关的依赖，版本都使用父项目声明的版本-->
<dependencies>
    <!--引入Gateway starter，网关场景启动器-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>

    <!--引入EurekaClient场景启动器starter-->
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
    </dependency>

    <!--不要引入springboot-starter-web和springboot-starter-actuator，
    因为Gateway是网关服务，不需要web-->

    <!--lombok-->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>com.li.springcloud</groupId>
        <artifactId>e_commerce_center_common-api</artifactId>
        <version>${project.version}</version>
    </dependency>
</dependencies>

（3）配置项目的application.yml文件

当有用户发送请求到网关Gateway，如 http://localhost:20000/member/get/1，前面 http://localhost:20000 是网关的ip地址，后面的 /member/get/** 是你配置的某一个路由地址的断言predicates，Gateway根据配置的uri（服务提供方的uri），将uri和对应path拼接，得到真正的服务提供方地址。

如果网关匹配不到对应的断言，则给客户端返回404

server:
  port: 20000

spring:
  application:
    name: e-commerce-gateway
  cloud:
    gateway:
      routes: #配置路由，可以配置多个
        - id: member_router01 #路由id，要求唯一
          #gateway 最终访问的url=uri+path, uri可以是任意的地址如 http://www.baidu.com
          #这里的uri是虽然固定的，在真正开发情况下，是到Eureka Server等去发现uri的
          uri: http://localhost:10000 #服务提供方的接口
          predicates: #断言，可以有多种形式
            - Path=/member/get/**
        - id: member_router02
          uri: http://localhost:10000
          predicates:
            - Path=/member/save

#配置EurekaClient
eureka:
  instance:
    hostname: e-commerce-service
  client:
    register-with-eureka: true #将自己注册到EurekaServer
    #表示从EurekaServer抓取注册信息
    fetch-registry: true
    service-url:
      #表示将自己注册到哪个EurekaServer
      defaultZone: http://eureka9001.com:9001/eureka

（4）配置主启动类

package com.li.springcloud;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

/**
 * @author 李
 * @version 1.0
 */
@SpringBootApplication
@EnableEurekaClient
public class GateWayApplication20000 {
    public static void main(String[] args) {
        SpringApplication.run(GateWayApplication20000.class, args);
    }
}

3.1.3测试

1. 顺序启动 e-commerce-eureka-server-9001，e-commerce-service-provider-10000，e-commerce-gateway-20000

1. 通过浏览器（网关访问）访问 http://localhost:20000/member/get/1，访问成功，说明网关gateway正常运行。

1. 如果访问的uri不匹配，则返回404提示

1. 用postman进行测试

3.2Gateway路由配置方式

1. 通过application.yml文件配置（上述例子）

2. 通过编写配置类注入：

@Configuration
public class GateWayRoutesConfig {
    @Bean
    public RouteLocator myRouteLocatior03(RouteLocatorBuilder routeLocatorBuilder) {
        RouteLocatorBuilder.Builder routes = routeLocatorBuilder.routes();
        //分别指定id，path，uri
        // 其中第二个参数是一个函数式接口（lambda），接收类型是PredicateSpec, 返回类型 Route.AsyncBuilder
        return routes.route(
                "member_router03",
                r -> r.path("/member/get/**").uri("http://localhost:10000")
        ).build();
    }
}

两种方式选择一种即可，最好不要混用。

关于lambda表达式的使用，例子：

import java.util.function.Function;

/**
 * @author 李
 * @version 1.0
 */
public class LambdaTest {
    public static void main(String[] args) {
        //第一种形式
        //Dog dog = hi("小花", (String str) -> {//这里其实就是实现apply接口
        //    Cat cat = new Cat();
        //    cat.setName(str);
        //    return cat;
        //});

        //第二种形式，简写
        //Dog dog = hi("小花", str -> {//这里的str不指定类型也可以，因为hi方法已经指定了
        //    Cat cat = new Cat();
        //    cat.setName(str);
        //    return cat;
        //});

        //第二种形式简写后：
        //Dog dog = hi("小花", str -> {
        //    return new Cat(str);
        //});

        //对上面的lambda表达式再进行简写
        Dog dog = hi("小花", x -> new Cat(x));

        System.out.println(dog);
    }

    public static Dog hi(String str, Function<String, Cat> fn) {
        Cat cat = fn.apply(str);
        Dog dog = new Dog();
        dog.setName(cat.getName() + "~修改为小狗名");
        return dog;
    }
}

class Cat {
    private String name;

    Cat(String name) {
        this.name = name;
    }

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

    public String getName() {
        return name;
    }
}

class Dog {
    private String name;

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

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }
}

3.3动态路由

3.3.1需求分析

上面的例子中，配置的服务提供方的uri是写死的，实际上，gateway可以实现动态路由，自动切换到不同的服务接口。

3.3.2代码实现

1. 修改网关微服务的application.yml文件配置：

spring:
  application:
    name: e-commerce-gateway
  cloud:
    gateway:
      discovery:
        locator:
          enabled: true #启用DiscoveryClient服务发现
      routes: #配置路由，可以配置多个
        - id: member_router01 #路由id，要求唯一
          #gateway 最终访问的url=uri+path, uri可以是任意的地址如 http://www.baidu.com
          #这里的uri是虽然固定的，在真正开发情况下，是到Eureka Server等去发现uri的
          #uri: http://localhost:10000 #服务提供方的接口
          # lb是协议名，member-service-provider 是服务提供方在注册中心的名称，要求小写
          # 默认情况下负载均衡算法为 轮询
          uri: lb://member-service-provider
          predicates: #断言，可以有多种形式
            - Path=/member/get/**
        - id: member_router02
          #uri: http://localhost:10000
          uri: lb://member-service-provider
          predicates:
            - Path=/member/save

1. 重新顺序启动 e-commerce-eureka-server-9001，e-commerce-service-provider-10000，e-commerce-service-provider-10002，e-commerce-gateway-20000

1. 通过浏览器（网关访问）多次访问 http://localhost:20000/member/get/5

访问成功，说明网关gateway正常运行，并且负载均衡算法默认为轮询。

3.3.3注意事项

配置好动态路由之后，Gateway会根据注册中心上的微服务名，为请求创建动态路由，实现动态路由功能，使用的lb协议支持负载均衡-轮询算法。

也可以使用javaconfig方式，配置注入自定义负载均衡算法：

@Configuration
public class RibbonRule {
    @Bean
    public IRule myRibbonRule() {
        return new RandomRule();
    }
}

Ribbon常见负载算法：

策略名	描述
BestAvailableRule	选择一个最小并发请求的server。逐个考察server，如果server被tripped（跳闸）了，则忽略，再选择其中ActiveRequestsCount最小的Server
AvailabilityFilteringRule	过滤掉那些因为一直连接失败的被标记为circuit tripped的后端server，并过滤掉那些高并发的后端server（active connections超过配置的阈值）
WeightedResponseTimeRule	根据响应时间分配一个weight，响应时间越长，weight越小，被选中的可能性越低
RetryRule	对选定的负载均衡策略机上重试机制。在一个配置时间段内当选择Server不成功，则一直尝试使用subRule的方式选择一个可用的server
RoundRobbinRule	轮询index，选择index对应位置的server
RandomRule	随机选择一个server，在index上随机，选择index对应位置的server
ZoneAvoidanceRule	复合判断server所在区域的性能和server的可用性，来选择server

3.4Predicate/断言

3.4.1介绍

gateway-request-predicates-factories

Predicate就是一组匹配规则，当请求匹配成功，就执行对应的Route，匹配失败则放弃处理/转发。

Spring Cloud Gateway 包括许多内置的Route Predicate工厂, 所有这些Predicate都与HTTP请求的不同属性匹配，可以组合使用。

Spring Cloud Gateway 创建 Route 对象时，使用RoutePredicateFactory 创建 Predicate 对象，Predicate 对象可以赋值给Route。

所有这些谓词（判断标准）都匹配HTTP请求的不同属性。多种谓词工厂可以组合。

3.4.2内置断言Factories

Spring Cloud Gateway 2.1.0 中文官网文档-腾讯云开发者社区-腾讯云 (tencent.com)

12.gateway中的断言（predicate）的使用：内置断言介绍、自定义断言_gateway predicates_秀聚的博客-CSDN博客

1.After 路由断言 Factory

After Route Predicate Factory采用一个参数——日期时间。在该日期时间之后发生的请求都将被匹配

例子：

spring:
  cloud:
    gateway:
      routes:
      - id: after_route
        uri: http://example.org
        predicates:
        - After=2017-01-20T17:42:47.789-07:00[America/Denver]

时间格式按照ZoneDateTime.now的格式

2.Before 路由断言 Factory

Before Route Predicate Factory采用一个参数——日期时间。在该日期时间之前发生的请求都将被匹配。

spring:
  cloud:
    gateway:
      routes:
      - id: after_route
        uri: http://example.org
        predicates:
        - Before=2017-01-20T17:42:47.789-07:00[America/Denver]

3.Between 路由断言 Factory

Between 路由断言 Factory有两个参数，datetime1和datetime2。在datetime1和datetime2之间的请求将被匹配。

datetime2参数的实际时间必须在datetime1之后。

spring:
  cloud:
    gateway:
      routes:
      - id: between_route
        uri: http://example.org
        predicates:
        - Between=2017-01-20T17:42:47.789-07:00[America/Denver], 2017-01-21T17:42:47.789-07:00[America/Denver]

4.Cookie 路由断言 Factory

Cookie 路由断言 Factory有两个参数：cookie名称和正则表达式。请求包含cookie名称，且正则表达式为真的将会被匹配

spring:
  cloud:
    gateway:
      routes:
      - id: cookie_route
        uri: http://example.org
        predicates:
        - Cookie=chocolate, ch.p

chocolate 是 cookie 名字；ch.p 是 cookie 的值，支持正则表达式

5.Header 路由断言 Factory

Header 路由断言 Factory有两个参数，header名称和正则表达式。请求包含次header名称且正则表达式为真的将会被匹配

spring:
 cloud:
   gateway:
     routes:
     - id: header_route
       uri: http://example.org
       predicates:
       - Header=X-Request-Id, \d+

X-Request-Id 是 header 的名称, \d+ 是一个正则表达式

6.Host 路由断言 Factory

Host 路由断言 Factory 包括一个参数：host name列表。使用Ant路径匹配规则，Host 可以有多个, 使用逗号间隔。

spring:
  cloud:
    gateway:
      routes:
      - id: host_route
        uri: http://example.org
        predicates:
        - Host=**.somehost.org,**.anotherhost.org

7.Method 路由断言 Factory

Method 路由断言 Factory只包含一个参数: 需要匹配的HTTP请求方式（GET或者POST方式）

spring:
  cloud:
    gateway:
      routes:
      - id: method_route
        uri: http://example.org
        predicates:
        - Method=GET

8.Path 路由断言 Factory

Path 路由断言 Factory 有2个参数：一个Spring PathMatcher表达式列表和可选matchOptionalTrailingSeparator标识

Path 可以有多个, 使用逗号间隔

spring:
  cloud:
    gateway:
      routes:
      - id: host_route
        uri: http://example.org
        predicates:
        - Path=/foo/{segment},/bar/{segment}

9.Query 路由断言 Factory

Query 路由断言 Factory 有2个参数: 必选项 param 和可选项 regexp.

spring:
  cloud:
    gateway:
      routes:
      - id: query_route
        uri: http://example.org
        predicates:
        - Query=email

上面表示包含了请求参数 email 的都将被匹配。

spring:
  cloud:
    gateway:
      routes:
      - id: query_route
        uri: http://example.org
        predicates:
        - Query=email, [\d]+

上面表示，如果请求参数里包含email参数，并且值要匹配数字且至少有一个数字，则将会被路由

10.RemoteAddr 路由断言 Factory

RemoteAddr 路由断言 Factory的参数为 一个CIDR符号（IPv4或IPv6）字符串的列表，最小值为1，例如192.168.0.1/16（其中192.168.0.1是IP地址并且16是子网掩码）

spring:
  cloud:
    gateway:
      routes:
      - id: remoteaddr_route
        uri: http://example.org
        predicates:
        - RemoteAddr=192.168.1.1/24

如上，若请求的remote address 为 192.168.1.10，则会被路由

注意：这里的remote address不是服务方的地址，而是调用端（客户端）的地址。

11.Weight路由断言Factory

WeightRoutePredicateFactory：接收一个 [组名,权重] 然后对于**同一个组**内的路由按照权重转发

gateway:
  routes:
  - id: weight_high
    uri: https://weighthigh.org
    predicates:
      - Weight=group1, 8
  - id: weight_low
    uri: https://weighlow.org
    predicates:
      - Weight= group1, 2

将会把80%的流量转发到weighthigh，将20%的流量转发到weighlow

3.5Filter/过滤器

gatewayfilter-factories

Spring Cloud : Gateway 网关过滤器 GatewayFilter

Spring Cloud Gateway 内置了多种路由过滤器，他们都由GatewayFilter的工厂类来产生。Gateway 根据作用范围划分为 GatewayFilter 和 GlobalFilter，区别如下：

1.GatewayFilter：网关过滤器，需要通过 spring.cloud.routes.filters 配置在具体路由下，只作用在当前路由上或通过 spring.cloud.default-filters 配置在全局，作用在所有路由上。

2.GlobalFilter：全局过滤器，不需要在配置文件中配置，作用在所有的路由上，最终通过GatewayFilterAdapter 包装成 GatewayFilterChain 可识别的过滤器，它为请求业务以及路由的 URI 转换为真实业务服务请求地址的核心过滤器，不需要配置系统初始化时加载，并作用在每个路由上。

3.5.1网关过滤器GatewayFilter

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

Spring Cloud Gateway 包含许多内置的网关过滤器工厂，一共有 22 个，包括头部过滤器、 路径类过滤器、Hystrix 过滤器和重写请求 URL 的过滤器， 还有参数和状态码等其他类型的过滤器。

根据过滤器工厂的用途来划分，可以分为以下几种：Header、Parameter、Path、Body、Status、Session、Redirect、Retry、RateLimiter 和 Hystrix。

请求参数过滤器-例子：

filters:
    AddRequestParameter=color,blue 
    #过滤器在匹配的请求头加上一对请求头,名称为color,值为 blue
    #比如原来的 http 请求为 http://localhost:10000/member/get/1 
    #--过滤器处理后->http://localhost:10000/member/get/1?color=blue

3.5.2全局过滤器GlobalFilter

全局过滤器不需要在配置文件中配置，作用在所有的路由上，最终通过 GatewayFilterAdapter 包装成 GatewayFilterChain 可识别的过滤器，它是请求业务以及路由的 URI 转换为真实业务服务请求地址的核心过滤器，不需要配置系统初始化时加载，并作用在每个路由上。

自定义GlobalFilter需要实现两个接口 ：GatewayFilter，Ordered

例子

package com.li.springcloud.filter;

import ...

/**
 * @author 李
 * @version 1.0
 */
@Component
public class CustomGatewayFilter implements GlobalFilter, Ordered {
    //filter方法中编写业务
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //自定义网关过滤器...
        return chain.filter(exchange);// 继续向下执行
    }

    //order 表示该过滤器执行的顺序，数字越小，优先级越高.
    @Override
    public int getOrder() {
        return 0;
    }
}