六、统一网关 Gateway

6.1 网关介绍

Spring Cloud Gateway 是 Spring Cloud 的一个全新项目，该项目是基于 Spring 5.0，Spring Boot 2.0 和 Project

Reactor 等响应式编程和事件流技术开发的网关，它旨在为微服务架构提供一种简单有效的统一的 API 路由管理方

式。

那么，我们为什么需要网关呢？

我们先说一下，在前面的项目中，我们的系统是怎么玩的（架构）。

1、首先，我们的系统分成了很多个微服务，例如Order和User。

2、对于这些微服务，我们提供nacos服务注册中心进行各个服务的注册登记和调用。（我们的微服务还可以读取在nacos中为其环境所定制的配置信息）

3、然后，我们的微服务的数据交互一直都是，前端直接访问我们的服务接口，然后我们的服务就去调用我们的数据库。

用一下黑马程序员的贴图，如下：

那么问题来了，现在，有一些服务或者接口，我们可能是只允许内网使用，而不是所有用户都能使用的，这个时候，我们网关就起到他的作用了。

Gateway网关作为所有微服务的统一入口，可谓是服务的守门神。他的核心功能特性如下：

1. 权限控制：网关作为微服务入口，需要校验用户是是否有请求资格，如果没有则进行拦截。

2. 路由和负载均衡：一切请求都必须先经过gateway，但网关不处理业务，而是根据某种规则，把请求转发到某个微服务，这个过程叫做路由。当然路由的目标服务有多个时，还需要做负载均衡。

3. 限流：当请求流量过高时，在网关中按照下流的微服务能够接受的速度来放行请求，避免服务压力过大。

加上网关后，我们的系统是这么玩的（架构）：

在SpringCloud中网关的实现包括两种：

• zuul：基于Servlet的实现，属于阻塞式编程。
• gateway：基于Spring5中提供的WebFlux，属于响应式编程的实现，具备更好的性能。

6.2 快速搭建网关

废话不多说，直接进行网关服务的搭建（源码）。

步骤一、新建Moodle，引入依赖，写SpringBoot启动文件。

首先，我们创建一个Moodle，项目名我就叫gatewat。然后我们在pom文件中引入依赖如下：

<dependencies>
    
    <dependency>
        <groupId>org.springframework.cloudgroupId>
        <artifactId>spring-cloud-starter-gatewayartifactId>
    dependency>
    
    <dependency>
        <groupId>com.alibaba.cloudgroupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discoveryartifactId>
    dependency>
dependencies>
1
2
3
4
5
6
7
8
9
10
11
12

引入spring官网提供的gateway网关场景这个没有异议吧。而引入nacos服务注册发现依赖，是因为网关服务本身也是一个微服务，因此，我们自然也需要将其注册到我们的nacos中。

然后，我们写我们服务的启动文件如下：

package com.example.gateway;

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

@SpringBootApplication
public class GatewayApplication {
    public static void main(String[] args) {
        SpringApplication.run(GatewayApplication.class, args);
    }
}
1
2
3
4
5
6
7
8
9
10
11

步骤二、配置各个服务的路由和nacos地址。

#服务的端口号
server:
  port: 10010

spring:
  application:
    name: gateway #服务的名称
  cloud:
    nacos:
      server-addr: 127.0.0.1:8848 #nacos地址
    gateway:
      #网关路由配置
      routes:
        #自定义的路由id，需要确保id的唯一
        - id: user-service
          #路由的目标地址，lb(LoadBalance)是负载均衡的缩写，后面跟着的是服务的名称
          uri: lb://user
          #uri写法二
          #uri: http://http://127.0.0.1:8081  #http表示路由到固定地址
          #predicates 路由断言,判断请求是否符合路由规则的条件
          predicates:
            #下面的语句表示，按照路径匹配，只要以/user/开头就符合要求
            - Path=/user/**
        - id: order-service
          uri: lb://order
          predicates:
            - Path=/order/**
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

步骤三、使用网关路由我们的服务。

我们启动我们的User、Order还有Gateway服务。启动完成后，我们使用地址 localhost:10010/order/101 以及 localhost:10010/user/3 分别访问我们的网关服务。结果如下：

6.3 断言工厂

我们在配置文件中写的断言规则只是字符串，这些字符串会被Predicate Factory读取并处理，转变为路由判断的条件

例如 Path=/user/** 是按照路径匹配，这个规则是由org.springframework.cloud.gateway.handler.predicate.PathRoutePredicateFactory类来处理的，像这样的断言工厂在SpringCloudGateway还有十几个:（详细的用法可以点击此处查看官网）

我们最常用的断言工厂是Path，上面已经演示过了，这里就不再演示了。上面的表格大概有印象就可以了，真正需要用的时候，就去官网看一下用法，然后拿来用即可。

这里再简单说一下RemoteAddr吧，假设我们现在某部分服务只能是内网访问，而我们内网下的ip地址是10.20.30.x。那么，我们就应该添加以下断言：

- RemoteAddr=10.20.30.1/24
1

如果，我们的服务在 2022年07月31日 21:14:47.433 后才可以被路由（访问），那么我们应该添加以下断言：（他表示，亚洲/上海 东八区时间 2022年07月31日21时14分47秒443）

- After=2022-07-31T21:14:47.433+08:00[Asia/Shanghai]
1

6.4 过滤器工厂

添加网关后，我们的用户访问我们的网关再到我们的服务中间，其实网关不只能做路由作用，他还能对用户发送的请求或微服务返回的响应做过滤处理。（例如，添加请求头，添加响应头等等，详细还是查看官网的教程，一共有30来个）
他的完整流程如下图所示：

由于量大，这里就全部列举了。需要用或者感兴趣的朋友直接上官网看就完了。

这里，我们还是找一个做实例，比如我们现在要给user服务的请求都添加一个请求头：
那么，我们修改gateway的application.yaml文件，路由到user服务的配置信息如下：

spring:
  application:
    name: gateway #服务的名称
  cloud:
    nacos:
      server-addr: 127.0.0.1:8848 #nacos地址
    gateway:
      #网关路由配置
      routes:
        #自定义的路由id，需要确保id的唯一
        - id: user-service
          #路由的目标地址，lb(LoadBalance)是负载均衡的缩写，后面跟着的是服务的名称
          uri: lb://user
          #uri写法二
          #uri: http://http://127.0.0.1:8081  #http表示路由到固定地址
          #predicates 路由断言,判断请求是否符合路由规则的条件
          predicates:
            #下面的语句表示，按照路径匹配，只要以/user/开头就符合要求
            - Path=/user/**
            - After=2022-07-31T21:14:47.433+08:00[Asia/Shanghai]
          filters:
            - AddRequestHeader=key, HelloWorld!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

上面的 AddRequestHeader=key, HelloWorld! 就是请求头的键值对，其中的键值我设置为key，值我设置为HelloWorld! 。
然后我们在Controller控制器方法中获取我们的请求头中键值为key的值。如下：

    @GetMapping("/user/{id}")
    public User selectById(@PathVariable("id") Long id,
                           @RequestHeader(value = "key", required = false) String key){
        System.out.println("添加的请求头为: "+key);
        return userService.selectById(id);
    }
1
2
3
4
5
6

之后，重启我们的User服务和Gateway服务，访问 http://localhost:10010/user/1，结果如下：

当然，以上的做法是只针对一个服务的，如果我们相对所有的服务都添加以上的请求头，那么我们首先要删掉前面的 filters。然后，我们在gateway配置下，routes同级位置添加属性 **default-filters。**详细配置信息如下：

#服务的端口号
server:
  port: 10010

spring:
  application:
    name: gateway #服务的名称
  cloud:
    nacos:
      server-addr: 127.0.0.1:8848 #nacos地址
    gateway:
      #网关路由配置
      routes:
        #自定义的路由id，需要确保id的唯一
        - id: user-service
          #路由的目标地址，lb(LoadBalance)是负载均衡的缩写，后面跟着的是服务的名称
          uri: lb://user
          #uri写法二
          #uri: http://http://127.0.0.1:8081  #http表示路由到固定地址
          #predicates 路由断言,判断请求是否符合路由规则的条件
          predicates:
            #下面的语句表示，按照路径匹配，只要以/user/开头就符合要求
            - Path=/user/**
            - After=2022-07-31T21:14:47.433+08:00[Asia/Shanghai]
        - id: order-service
          uri: lb://order
          predicates:
            - Path=/order/**
      default-filters:
        - AddRequestHeader=key, HelloWorld!
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

此时，我们通过gateway访问order或者user服务都能获取到请求头key：HelloWorld!

注意：当我们访问order服务的时候，我们知道order作为消费者，他需要再去访问user服务，此时，user服务的请求头中则是没有key:value的。

6.5 全局过滤器 GlobalFIlter

前面，我们说到，对每个服务的过滤器，我们使用 filters: 属性在某个网关路由配置中进行配置。
对于所有服务的过滤器，我们使用 default-filters: 属性在 gateway属性 下进行配置。

这里，我们再讲一个全局过滤器 GlobalFilter，他的作用是处理一切进入网关的请求和微服务响应，与GatewayFilter作用一样。但他的作用场景却不同，我们知道，Spring官网给我们提供的过滤器也就写死的那30多种，这显然不可能满足我们社会上所有的需求，而GlobalFilter实现的过滤器，他的业务逻辑是由我们自己根据实际情况手动编写实现的。

要想编写自己的全局过滤器也很简单，只需要实现我们的GlobalFilter接口，并将实现类注册到Spring容器中即可（添加@Component注解）。我们先来看看GlobalFilter接口吧。

public interface GlobalFilter {
    Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain);
}
1
2
3

这里，
ServerWebExchange 对象主要用来获取我们的请求体和响应体的信息。
GatewayFilterChain 对象主要是用来处理我们的过滤器链，因为过滤器他是一个一个过的，他主要用于处理是否给予放行到下一个过滤器。

废话少说，举个例子，现在，要想访问我们的服务，必须在请求体中有包含键值对为 authorization ： admin，我们才给予放行，那么，我们的代码应该如下：

package com.example.gateway.filters;

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.annotation.Order;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpRequest;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.stereotype.Component;
import org.springframework.util.MultiValueMap;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
@Order(-1)
public class AuthorizeFilter implements GlobalFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        //1. 获取请求参数(请求体）
        ServerHttpRequest request = exchange.getRequest();
        //2. 获取请求参数中的 authorization 参数
        MultiValueMap<String, String> queryParams = request.getQueryParams();
        String authorization = queryParams.getFirst("authorization");
        //3. 判断其值是否为 admin
        if (authorization != null && authorization.equals("admin")) {
            //4. 放行
            return chain.filter(exchange);
        }
        //5. 获取响应参数（响应体）
        ServerHttpResponse response = exchange.getResponse();
        //5.1 设置状态码
        response.setStatusCode(HttpStatus.UNAUTHORIZED);
        //5.2 拦截
        return response.setComplete();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

设置好后，我们重启我们的gateway服务，然后访问一下：

http://localhost:10010/user/1?authorization=admin

这个时候，如果我们直接访问

http://localhost:10010/user/1

会发现请求失败，如下：

6.6 过滤器的执行顺序

请求进入网关会碰到三类过滤器：当前路由的过滤器、DefaultFilter、GlobalFilter

请求路由后，会将当前路由过滤器和DefaultFilter、GlobalFilter，合并到一个过滤器链（集合）中，排序后依次执行每个过滤器：

其中，排序的规则如下：

• 每一个过滤器都必须指定一个int类型的order值，order值越小，优先级越高，执行顺序越靠前。
• GlobalFilter通过实现Ordered接口，或者添加@Order注解来指定order值，由我们自己指定
• 路由过滤器和defaultFilter的order由Spring指定，默认是按照声明顺序从1递增。（在defaultFilter中从1开始，在每个路由过滤器中也是从1开始，简单说就是会重复给1）
• 当过滤器的order值一样时，会按照 defaultFilter > 路由过滤器 > GlobalFilter的顺序执行。

详细内容，可以查看源码：

org.springframework.cloud.gateway.route.RouteDefinitionRouteLocator#getFilters()方法是先加载defaultFilters，然后再加载某个route的filters，然后合并。

org.springframework.cloud.gateway.handler.FilteringWebHandler#handle()方法会加载全局过滤器，与前面的过滤器合并后根据order排序，组织过滤器链。

6.7. 跨域问题

网关是基于Spring5的WebFlux实现的，没有Servlet相关的API，因此，使用Servlet的跨域问题不一定适用网关。那么，网关怎么解决跨域问题呢？首先，我们回顾一下什么是跨域啊。
跨域有以下两种：
1、域名不同：例如，www.baidu.com 和 www.taobao.com。
2、域名相同，但是端口号不同：http://127.0.0.1:8080， http://127.0.0.1:8081。

跨域问题：浏览器禁止请求的发起者与服务端发生跨域ajax请求，请求被浏览器拦截的问题。 比如，我们将项目进行前后端分离，用我们的Vue框架去请求我们的SpringCloud的服务，那么就会有这种请求被浏览器拦截的问题。

网关处理跨域问题采用的是CORS方案。只需要在我们的配置文件中添加以下配置即可：

spring:
  cloud:
    gateway:
      # 。。。
      globalcors: # 全局的跨域处理
        add-to-simple-url-handler-mapping: true # 解决options请求被拦截问题
        corsConfigurations:
          '[/**]':
            allowedOrigins: # 允许哪些网站的跨域请求 
              - "http://localhost:8090"
            allowedMethods: # 允许的跨域ajax的请求方式
              - "GET"
              - "POST"
              - "DELETE"
              - "PUT"
              - "OPTIONS"
            allowedHeaders: "*" # 允许在请求中携带的头信息
            allowCredentials: true # 是否允许携带cookie
            maxAge: 360000 # 这次跨域检测的有效期
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19