SpringCloud（八）网关组件之GateWay

SpringCloud（八）网关组件之GateWay

网关：微服务架构中的重要组成部分

局域网中就有网关这个概念，局域网接收或者发送数据出去通过这个网关，比如用Vmware虚拟机软件搭建虚拟机集群的时候，往往我们需要选择IP段中的一个IP作为网关地址。

老夫最近学习的GateWay–>Spring Cloud GateWay（它只是众多网关解决方案中的一种）

GateWay简介

Spring Cloud GateWay是Spring Cloud的一个全新项目，目标是取代Netflix Zuul，它基于Spring5.0+SpringBoot2.0+WebFlux（基于高性能的Reactor模式响应式通信框架Netty，异步非阻塞模型）等技术开发，性能高于Zuul，官方测试，GateWay是Zuul的1.6倍，旨在为微服务架构提供一种简单有效的统一的API路由管理方式。

Spring Cloud GateWay不仅提供统一的路由方式（反向代理）并且基于 Filter(定义过滤器对请求过滤，完成一些功能) 链的方式提供了网关基本的功能，例如：鉴权、流量控制、熔断、路径重写、日志监控等。

网关在架构中的位置

GateWay核心概念

Spring Cloud GateWay天生就是异步非阻塞的，基于Reactor模型（同步非阻塞的I/O多路复用机制）

一个请求—>网关根据一定的条件匹配—匹配成功之后可以将请求转发到指定的服务地址；而在这个过程中，我们可以进行一些比较具体的控制（限流、日志、黑白名单）

• 路由（route）： 网关最基础的部分，也是网关比较基础的工作单元。路由由一个ID、一个目标URL（最终路由到的地址）、一系列的断言（匹配条件判断）和Filter过滤器（精细化控制）组成。如果断言为true，则匹配该路由。
• 断言（predicates）：参考了Java8中的断言java.util.function.Predicate，开发人员可以匹配Http请求中的所有内容（包括请求头、请求参数等）（类似于nginx中的location匹配一样），如果断言与请求相匹配则路由。
• 过滤器（filter）：一个标准的Spring webFilter，使用过滤器，可以在请求之前或者之后执行业务逻辑。

GateWay如何工作

Spring 官方介绍：

客户端向Spring Cloud GateWay发出请求，然后在GateWay Handler Mapping中找到与请求相匹配的路由，将其发送到GateWay Web Handler；Handler再通过指定的过滤器链来将请求发送到我们实际的服务执行业务逻辑，然后返回。过滤器之间用虚线分开是因为过滤器可能会在发送代理请求之前（pre）或者之后（post）执行业务逻辑。

Filter在“pre”类型过滤器中可以做参数校验、权限校验、流量监控、日志输出、协议转换等，在“post”类型的过滤器中可以做响应内容、响应头的修改、日志的输出、流量监控等。

GateWay应用

使用网关对静态化微服务进行代理（添加在它的上游，相当于隐藏了具体微服务的信息，对外暴露的是网关）

• 创建工程szx-cloud-gateway导入依赖，将项目放在 szx-parent 下，却不依赖 szx-parent

  GateWay不需要使用web模块，它引入的是WebFlux（类似于SpringMVC）

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.szx</groupId>
    <artifactId>szx-cloud-gateway</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--spring boot 父启动器依赖-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.6.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-commons</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </dependency>
        <!--GateWay 网关-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-gateway</artifactId>
        </dependency>
        <!--引入webflux-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <!--日志依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-logging</artifactId>
        </dependency>
        <!--测试依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--lombok工具-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.4</version>
            <scope>provided</scope>
        </dependency>
        <!--引入Jaxb，开始-->
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-core</artifactId>
            <version>2.2.11</version>
        </dependency>
        <dependency>
            <groupId>javax.xml.bind</groupId>
            <artifactId>jaxb-api</artifactId>
        </dependency>
        <dependency>
            <groupId>com.sun.xml.bind</groupId>
            <artifactId>jaxb-impl</artifactId>
            <version>2.2.11</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jaxb</groupId>
            <artifactId>jaxb-runtime</artifactId>
            <version>2.2.10-b140310.1920</version>
        </dependency>
        <dependency>
            <groupId>javax.activation</groupId>
            <artifactId>activation</artifactId>
            <version>1.1.1</version>
        </dependency>
        <!--引入Jaxb，结束-->
        <!-- Actuator可以帮助你监控和管理Spring Boot应用-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <!--热部署-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>
        <!--链路追踪-->
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-sleuth</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-zipkin</artifactId>
        </dependency>
    </dependencies>
    <dependencyManagement>
        <!--spring cloud依赖版本管理-->
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>Greenwich.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
    <build>
        <plugins>
            <!--编译插件-->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>11</source>
                    <target>11</target>
                    <encoding>utf-8</encoding>
                </configuration>
            </plugin>
            <!--打包插件-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

注意：不要引入starter-web模块，需要引入web-flux

• application.yml 配置文件内容

#配置端口
server:
  port: 9300

#配置Eurake，将网关注册到Eureka
eureka:
  client:
    service-url:
      defaultZone: http://127.0.0.1:9202/eureka/,http://127.0.0.1:9201/eureka/
  instance:
    prefer-ip-address: true
    instance-id: ${spring.cloud.client.ip-address}:${spring.application.name}:${server.port}:@project.version@

#配置网关
spring:
  application:
    name: szx-cloud-gateway
  cloud:
    gateway:
      #配置路由
      routes:
        - id: service-page-router
          uri: http://127.0.0.1:9100
          predicates:   #当断言成功后，交给某一个微服务处理时使用的是转发
            - Path=/page/**
        - id: service-product-router
          uri: http://127.0.0.1:9000
          predicates:
            - Path=/product/**
          filters:
            #http://localhost:9300/product/service/getPort  -> http://localhost:9300//service/getPort  ->  商品微服务
            - StripPrefix=1       #表示去掉uri中的第一部分，所以就要求我们通过网关访问的时候，把uri的第一部分设置为product，从uri的第二部分开始才是真正的uri

@SpringBootApplication
@EnableDiscoveryClient
public class GateWayServerApplication {

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

}

• 测试：

  • 商品微服务：

    http://localhost:9300/product/product/selectProductById/1

    http://localhost:9300/product/service/getPort

  • 页面静态化微服务：

    http://localhost:9300/page/getProductServerPort

GateWay路由规则详解

Spring Cloud GateWay 帮我们内置了很多 Predicates功能，实现了各种路由匹配规则（通过Header、请求参数等作为条件）匹配到对应的路由。

时间点后匹配

spring:
  application:
    name: szx-cloud-gateway
  cloud:
    gateway:
      #配置路由
      routes:
        - id: service-page-router
          uri: http://127.0.0.1:9100
          predicates:   #当断言成功后，交给某一个微服务处理时使用的是转发
            - After=2017-01-20T17:42:47.789-07:00[America/Denver]

时间点前匹配

spring:
  application:
    name: szx-cloud-gateway
  cloud:
    gateway:
      #配置路由
      routes:
        - id: service-page-router
          uri: http://127.0.0.1:9100
          predicates:   #当断言成功后，交给某一个微服务处理时使用的是转发
            - Before=2017-01-20T17:42:47.789-07:00[America/Denver]

时间区间匹配

spring:
  application:
    name: szx-cloud-gateway
  cloud:
    gateway:
      #配置路由
      routes:
        - id: service-page-router
          uri: http://127.0.0.1:9100
          predicates:   #当断言成功后，交给某一个微服务处理时使用的是转发
            - Between=2017-01-20T17:42:47.789-07:00[America/Denver], 2017-01-21T17:42:47.789-07:00[America/Denver]

指定Cookie正则匹配指定值

spring:
  application:
    name: szx-cloud-gateway
  cloud:
    gateway:
      #配置路由
      routes:
        - id: service-page-router
          uri: http://127.0.0.1:9100
          predicates:   #当断言成功后，交给某一个微服务处理时使用的是转发
            - Cookie=chocolate, ch.p

指定Header正则匹配指定值

spring:
  application:
    name: szx-cloud-gateway
  cloud:
    gateway:
      #配置路由
      routes:
        - id: service-page-router
          uri: http://127.0.0.1:9100
          predicates:   #当断言成功后，交给某一个微服务处理时使用的是转发
            - Header=X-Request-Id, \d+

请求Host匹配指定值

spring:
  application:
    name: szx-cloud-gateway
  cloud:
    gateway:
      #配置路由
      routes:
        - id: service-page-router
          uri: http://127.0.0.1:9100
          predicates:   #当断言成功后，交给某一个微服务处理时使用的是转发
            - Host=**.somehost.org,**.anotherhost.org

请求Method匹配指定请求方式

spring:
  application:
    name: szx-cloud-gateway
  cloud:
    gateway:
      #配置路由
      routes:
        - id: service-page-router
          uri: http://127.0.0.1:9100
          predicates:   #当断言成功后，交给某一个微服务处理时使用的是转发
            - Method=GET,POST

请求包含某参数

spring:
  application:
    name: szx-cloud-gateway
  cloud:
    gateway:
      #配置路由
      routes:
        - id: service-page-router
          uri: http://127.0.0.1:9100
          predicates:   #当断言成功后，交给某一个微服务处理时使用的是转发
            - Query=green

请求包含某参数并且参数值匹配正则表达式

spring:
  application:
    name: szx-cloud-gateway
  cloud:
    gateway:
      #配置路由
      routes:
        - id: service-page-router
          uri: http://127.0.0.1:9100
          predicates:   #当断言成功后，交给某一个微服务处理时使用的是转发
            - Query=red, gree.

远程地址匹配

spring:
  application:
    name: szx-cloud-gateway
  cloud:
    gateway:
      #配置路由
      routes:
        - id: service-page-router
          uri: http://127.0.0.1:9100
          predicates:   #当断言成功后，交给某一个微服务处理时使用的是转发
            - RemoteAddr=192.168.1.1/24

GateWay动态路由详解

GateWay支持自动从注册中心中获取服务列表并访问，即所谓的动态路由

实现步骤如下

1）pom.xml中添加注册中心客户端依赖（因为要获取注册中心服务列表，eureka客户端已经引入）

2）动态路由配置

spring:
  application:
    name: szx-cloud-gateway
  cloud:
    gateway:
      #配置路由
      routes:
        - id: service-page-router
          #动态路由：从注册中心获取对应服务的实例
          uri: lb://szx-service-page
          predicates:   #当断言成功后，交给某一个微服务处理时使用的是转发
            - Path=/page/**
        - id: service-product-router
          uri: lb://szx-service-product
          predicates:
            - Path=/product/**
          filters:
            #http://localhost:9300/product/service/getPort  -> http://localhost:9300//service/getPort  ->  商品微服务
            - StripPrefix=1       #表示去掉uri中的第一部分，所以就要求我们通过网关访问的时候，把uri的第一部分设置为product，从uri的第二部分开始才是真正的uri

注意：动态路由设置时，uri以 lb: //开头（lb代表从注册中心获取服务），后面是需要转发到的服务名称

GateWay过滤器

GateWay过滤器简介

从过滤器生命周期（影响时机点）的角度来说，主要有两个pre和post：

生命周期时机点	作用
pre	这种过滤器在请求被路由之前调用。我们可利用这种过滤器实现身份验证、在集群中选择 请求的微服务、记录调试信息等。
post	这种过滤器在路由到微服务以后执行。这种过滤器可用来为响应添加标准的 HTTPHeader、收集统计信息和指标、将响应从微服务发送给客户端等。

从过滤器类型的角度，Spring Cloud GateWay的过滤器分为GateWayFilter和GlobalFilter两种

过滤器类型	影响范围
GateWayFilter	应用到单个路由路由上
GlobalFilter	应用到所有的路由上

如Gateway Filter可以去掉url中的占位后转发路由，比如

predicates:
  - Path=/product/**
filters:
  #http://localhost:9300/product/service/getPort  -> http://localhost:9300//service/getPort  ->  商品微服务
  - StripPrefix=1       #表示去掉uri中的第一部分，所以就要求我们通过网关访问的时候，把uri的第一部分设置为product，从uri的第二部分开始才是真正的uri

注意：GlobalFilter全局过滤器是程序员使用比较多的过滤器，老夫主要学习这种类型

自定义全局过滤器实现IP访问限制（黑白名单）

请求过来时，判断发送请求的客户端的ip，如果在黑名单中，拒绝访问

自定义GateWay全局过滤器时，我们实现Global Filter接口即可，通过全局过滤器可以实现黑白名单、限流等功能。

/**
 * @Program: springclouddemo
 * @Author: XiaoXing
 * @Create: 2021-02-09 17:00
 * @Description: 网关黑白名单，通常情况下，网关自定义过滤器时，需要实现两个接口：GlobalFilter（过滤器主要核心功能） 和 Ordered（排序接口，指定过滤器的执行顺序）
 **/
@Component
public class BlackListFilter implements GlobalFilter, Ordered {

    /**
     * 加载黑名单列表
     * MySQL    ->      Redis       ->      加载到内存中
     */
    private static List<String> blackList = new ArrayList<>();

    static {
        //将本机地址加入到黑名单中
        blackList.add("127.0.0.1");
        blackList.add("localhost");
        blackList.add("0:0:0:0:0:0:0:1");
    }

    /**
     * GlobalFilter 的方法，核心逻辑
     * @param exchange      封装了 Request 和 Response 上下文
     * @param chain         网关过滤器调用链
     * @return
     */
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        System.out.println("....BlackListFilter....");
        //获得 Request 和 Response
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        //获取来访者的 IP
        String clientIP = request.getRemoteAddress().getHostString();
        System.out.println("clientIP = " + clientIP);
        System.out.println(blackList.contains(clientIP));
        //判断是否存在于黑名单中
        if (blackList.contains(clientIP)){
            //存在于黑名单，拒绝访问
            response.setStatusCode(HttpStatus.UNAUTHORIZED);     //没有授权
            //错误信息
            String data = "request be denied";
            //定义输出响应信息
            DataBuffer wrap = response.bufferFactory().wrap(data.getBytes());
            //输出响应错误信息
            return response.writeWith(Mono.just(wrap));
        }
        //不存在于黑名单，则继续执行下面逻辑
        return chain.filter(exchange);
    }

    /**
     * Ordered 的方法，定义过滤器执行顺序，getOrder方法返回值的大小决定了过滤器执行的优先级，越小优先级越高
     * @return
     */
    @Override
    public int getOrder() {
        return 0;
    }
}

GateWay高可用

网关作为非常核心的一个部件，如果挂掉，那么所有请求都可能无法路由处理，因此我们需要做GateWay的高可用。

GateWay的高可用很简单：可以启动多个GateWay实例来实现高可用，在GateWay的上游使用Nginx等负载均衡设备进行负载转发以达到高可用的目的。

启动多个GateWay实例（假如说两个，一个端口9301，一个端口9302），剩下的就是使用Nginx等完成负载代理即可。示例如下：

#配置多个GateWay实例
upstream gateway {
	server 127.0.0.1:9301;
	server 127.0.0.1:9302;
}
location / {
	proxy_pass http://gateway;
}