微服务架构中的重要组成部分， 基于高性能的Reactor模式响应式通信 框架Netty，异步非阻塞模型 ，
Spring Cloud GateWay不仅提供统了的路由方式（反向代理）并且基于 Filter(定义 过滤器对请求过滤，完成一些功能) 链的方式提供了网关基本的功能，例如：鉴权、 流量控制、熔断、路径重写、日志监控等。
image.png

核心概念

路由（route）： 网关最基础的部分，也是网关比较基础的工作单元。路由由一个ID、一个目标URL（最终路由到的地址）、一系列的断言（匹配条件判断）和 Filter过滤器（精细化控制）组成。如果断言为true，则匹配该路由。
断言（predicates）：参考了Java8中的断言java.util.function.Predicate，开发人员可以匹配Http请求中的所有内容（包括请求头、请求参数等）（类似于 nginx中的location匹配一样），如果断言与请求相匹配则路由。
过滤器（filter）：一个标准的Spring webFilter，使用过滤器，可以在请求之前 或者之后执行业务逻辑。 来自官网的一张图
image.png
Predicates断言就是我们的匹配条件，而Filter就可以理解为一个无所不 能的拦截器，有了这两个元素，结合目标URL，就可以实现一个具体的路由转 发。

工作过程

image.png
客户端向Spring Cloud GateWay发出请求，然后在GateWay Handler Mapping中找到与请求相匹配的路由，将其发送到GateWay Web Handler；Handler再通过指定的过滤器链来将请求发送到我们实际的服务执行业务逻辑，然后返回。过滤器之间用虚线分开是因为过滤器可能会在发送代理请求之前（pre）或者之后（post）执行业务逻辑。 Filter在“pre”类型过滤器中可以做参数校验、权限校验、流量监控、日志输出、协议 转换等，在“post”类型的过滤器中可以做响应内容、响应头的修改、日志的输出、流量监控等。
核心逻辑：路由转发+执行过滤器链

GateWay应用

使用网关对自动投递微服务进行代理（添加在它的上游，相当于隐藏了具体微服务 的信息，对外暴露的是网关）
GateWay不需要使用web模块，它引入的是WebFlux（类似于SpringMVC）

1、创建网关项目并导入依赖

不要引入starter-web模块，需要引入web-flux，如果父项目没有引入，而继承父类的子项目单独引入，而又引入网关中也会报错的。 主要是引入spring-cloud-starter-gateway

  1.  <!--spring boot 父启动器依赖-->
  2.     <parent>
  3.         <groupId>org.springframework.boot</groupId>
  4.         <artifactId>spring-boot-starter-parent</artifactId>
  5.         <version>2.1.6.RELEASE</version>
  6.     </parent>
  8.     <dependencies>
  9.         <dependency>
  10.             <groupId>org.springframework.cloud</groupId>
  11.             <artifactId>spring-cloud-commons</artifactId>
  12.         </dependency>
  13.         <dependency>
  14.             <groupId>org.springframework.cloud</groupId>
  15.             <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
  16.         </dependency>
  17.         <!--GateWay 网关-->
  18.        <dependency>
  19.             <groupId>org.springframework.cloud</groupId>
  20.             <artifactId>spring-cloud-starter-gateway</artifactId>
  21.         </dependency>
  22.         <!--引入webflux-->
  23.         <dependency>
  24.             <groupId>org.springframework.boot</groupId>
  25.             <artifactId>spring-boot-starter-webflux</artifactId>
  26.         </dependency>
  27.         <!--日志依赖-->
  28.         <dependency>
  29.             <groupId>org.springframework.boot</groupId>
  30.             <artifactId>spring-boot-starter-logging</artifactId>
  31.         </dependency>
  32.         <!--测试依赖-->
  33.         <dependency>
  34.             <groupId>org.springframework.boot</groupId>
  35.             <artifactId>spring-boot-starter-test</artifactId>
  36.             <scope>test</scope>
  37.         </dependency>
  38.         <!--lombok工具-->
  39.         <dependency>
  40.             <groupId>org.projectlombok</groupId>
  41.             <artifactId>lombok</artifactId>
  42.             <version>1.18.4</version>
  43.             <scope>provided</scope>
  44.         </dependency>
  46.         <!--引入Jaxb，开始-->
  47.         <dependency>
  48.             <groupId>com.sun.xml.bind</groupId>
  49.             <artifactId>jaxb-core</artifactId>
  50.             <version>2.2.11</version>
  51.         </dependency>
  52.         <dependency>
  53.             <groupId>javax.xml.bind</groupId>
  54.             <artifactId>jaxb-api</artifactId>
  55.         </dependency>
  56.         <dependency>
  57.             <groupId>com.sun.xml.bind</groupId>
  58.             <artifactId>jaxb-impl</artifactId>
  59.             <version>2.2.11</version>
  60.         </dependency>
  61.         <dependency>
  62.             <groupId>org.glassfish.jaxb</groupId>
  63.             <artifactId>jaxb-runtime</artifactId>
  64.             <version>2.2.10-b140310.1920</version>
  65.         </dependency>
  66.         <dependency>
  67.             <groupId>javax.activation</groupId>
  68.             <artifactId>activation</artifactId>
  69.             <version>1.1.1</version>
  70.         </dependency>
  71.         <!--引入Jaxb，结束-->
  73.         <!-- Actuator可以帮助你监控和管理Spring Boot应用-->
  74.         <dependency>
  75.             <groupId>org.springframework.boot</groupId>
  76.             <artifactId>spring-boot-starter-actuator</artifactId>
  77.         </dependency>
  78.         <!--热部署-->
  79.         <dependency>
  80.             <groupId>org.springframework.boot</groupId>
  81.             <artifactId>spring-boot-devtools</artifactId>
  82.             <optional>true</optional>
  83.         </dependency>
  84.     </dependencies>
  86.     <dependencyManagement>
  87.         <!--spring cloud依赖版本管理-->
  88.         <dependencies>
  89.             <dependency>
  90.                 <groupId>org.springframework.cloud</groupId>
  91.                 <artifactId>spring-cloud-dependencies</artifactId>
  92.                 <version>Greenwich.RELEASE</version>
  93.                 <type>pom</type>
  94.                 <scope>import</scope>
  95.             </dependency>
  96.         </dependencies>
  97.     </dependencyManagement>
  99.     <build>
  100.         <plugins>
  101.             <!--编译插件-->
  102.             <plugin>
  103.                 <groupId>org.apache.maven.plugins</groupId>
  104.                 <artifactId>maven-compiler-plugin</artifactId>
  106.                 <configuration>
  107.                     <source>11</source>
  108.                     <target>11</target>
  109.                     <encoding>utf-8</encoding>
  110.                 </configuration>
  111.             </plugin>
  112.             <!--打包插件-->
  113.             <plugin>
  114.                 <groupId>org.springframework.boot</groupId>
  115.                 <artifactId>spring-boot-maven-plugin</artifactId>
  116.             </plugin>
  117.         </plugins>
  118.     </build>

2、对application.yml配置

配置了一个 id 为 service-autodeliver-router 的路由规 则 

  1. server:
  2.   port: 9002
  3. eureka:
  4.   client:
  5.     serviceUrl: # eureka server的路径
  6.       defaultZone: http://lagoucloudeurekaservera:8761/eureka/,http://lagoucloudeurekaserverb:8762/eureka/ #把 eureka 集群中的所有 url 都填写了进来，也可以只写一台，因为各个 eureka server 可以同步注册表
  7.   instance:
  8.     #使用ip注册，否则会使用主机名注册了（此处考虑到对老版本的兼容，新版本经过实验都是ip）
  9.     prefer-ip-address: true
  10.     #自定义实例显示格式，加上版本号，便于多版本管理，注意是ip-address，早期版本是ipAddress
  11.     instance-id: ${spring.cloud.client.ip-address}:${spring.application.name}:${server.port}:@project.version@
  12. spring:
  13.   application:
  14.     name: lagou-cloud-gateway
  15.   cloud:
  16.     gateway:
  17.       routes: # 路由可以有多个     
  18.         - id: service-autodeliver-router # 我们自定义的路由 ID，保持唯一
  19.           #uri: http://127.0.0.1:8096  # 目标服务地址  自动投递微服务（部署多实例）  
  20.           # 动态路由：uri配置的应该是一个服务名称，而不应该是一个具体的服务实例的地址
  21.           uri: lb://lagou-service-autodeliver                                                                    # gateway网关从服务注册中心获取实例信息然后负载后路由
  22.           predicates:      
  23.           # 断言：路由条件，Predicate 接受一个输入参数，返回一个布尔值结果。
  24.           #该接口包含多种默 认方法来将 Predicate 组合成其他复杂的逻辑（比如：与，或，非）。
  25.             - Path=/autodeliver/**
  26.         - id: service-resume-router   # 我们自定义的路由 ID，保持唯一
  27.           #http://127.0.0.1:8081/openstate/1545132
  28.           uri: lb://lagou-service-resume
  29.           predicates: 
  30.            # 断言：路由条件，Predicate 接受一个输入参数，返回一个布尔值结果。
  31.            #该接口包含多种默 认方法来将 Predicate 组合成其他复杂的逻辑（比如：与，或，非）。
  32.             - Path=/resume/**
  33.           filters:
  34.             - StripPrefix=1

路由规则详解

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

1、时间点后匹配 。。。。

动态路由详解

GateWay支持自动从注册中心中获取服务列表并访问，即所谓的动态路由
实现步骤如下
1）pom.xml中添加注册中心客户端依赖（因为要获取注册中心服务列表，eureka 客户端已经引入）
2）动态路由配置
注意：动态路由设置时，uri以 lb: //开头（lb代表从注册中心获取服务），后面是 需要转发到的服务名称 

  1. spring:
  2.   application:
  3.     name: lagou-cloud-gateway
  4.   cloud:
  5.     gateway:
  6.       routes: # 路由可以有多个     
  7.         - id: service-autodeliver-router # 我们自定义的路由 ID，保持唯一            
  8.           # 动态路由：uri配置的应该是一个服务名称，而不应该是一个具体的服务实例的地址
  9.           uri: lb://lagou-service-autodeliver                                                                    # gateway网关从服务注册中心获取实例信息然后负载后路由
  10.           predicates:             
  11.             - Path=/autodeliver/**

网关过滤器

1、从过滤器生命周期看

| pre

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

2、从过滤器类型的⻆度

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

如Gateway Filter可以去掉url中的占位后转发路由，比如
注意：GlobalFilter全局过滤器是程序员使用比较多的过滤器 

  1. predicates:
  2.  - Path=/resume/**
  3.  filters:
  4.  - StripPrefix=1 # 可以去掉resume之后转发

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

请求过来时，判断发送请求的客户端的ip，如果在黑名单中，拒绝访问。
自定义GateWay全局过滤器，实现GlobalFilter接口即可，通过全局过滤器可以实现黑白名单、限流等功能。 

  2. /**
  3.  * 定义全局过滤器，会对所有路由生效
  4.  */
  5. @Slf4j
  6. @Component  // 让容器扫描到，等同于注册了
  7. public class BlackListFilter implements GlobalFilter, Ordered {
  9.     // 模拟黑名单（实际可以去数据库或者redis中查询）
  10.     private static List<String> blackList = new ArrayList<>();
  12.     static {
  13.         blackList.add("0:0:0:0:0:0:0:1");  // 模拟本机地址
  14.     }
  16.     /**
  17.      * 过滤器核心方法
  18.      * @param exchange 封装了request和response对象的上下文
  19.      * @param chain 网关过滤器链（包含全局过滤器和单路由过滤器）
  20.      * @return
  21.      */
  22.     @Override
  23.     public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
  24.         // 思路：获取客户端ip，判断是否在黑名单中，在的话就拒绝访问，不在的话就放行
  25.         // 从上下文中取出request和response对象
  26.         ServerHttpRequest request = exchange.getRequest();
  27.         ServerHttpResponse response = exchange.getResponse();
  29.         // 从request对象中获取客户端ip
  30.         String clientIp = request.getRemoteAddress().getHostString();
  31.         // 拿着clientIp去黑名单中查询，存在的话就决绝访问
  32.         if(blackList.contains(clientIp)) {
  33.             // 决绝访问，返回
  34.             response.setStatusCode(HttpStatus.UNAUTHORIZED); // 状态码
  35.             log.debug("=====>IP:" + clientIp + " 在黑名单中，将被拒绝访问！");
  36.             String data = "Request be denied!";
  37.             DataBuffer wrap = response.bufferFactory().wrap(data.getBytes());
  38.             //Mono对数据流进行封装
  39.             return response.writeWith(Mono.just(wrap));
  40.         }
  42.         // 合法请求，放行，执行后续的过滤器
  43.         return chain.filter(exchange);
  44.     }
  47.     /**
  48.      * 返回值表示当前过滤器的顺序(优先级)，数值越小，优先级越高
  49.      * @return
  50.      */
  51.     @Override
  52.     public int getOrder() {
  53.         return 0;
  54.     }
  55. }

GateWay高可用

1、网关作为非常核心的一个部件，如果挂掉，那么所有请求都可能无法路由处理，因此我们需要做GateWay的高可用
2、GateWay的高可用很简单：可以启动多个GateWay实例来实现高可用，在GateWay 的上游使用Nginx等负载均衡设备进行负载转发以达到高可用的目的。
3、启动多个GateWay实例（假如说两个，一个端口9002，一个端口9003），剩下的就 是使一Nginx等完成负载代理即可 

  1. #配置多个GateWay实例
  2. upstream gateway {
  3.  server 127.0.0.1:9002;
  4.  server 127.0.0.1:9003;
  5. }
  6. location / {
  7.  proxy_pass http://gateway;
  8. }