手把手教你搭建SpringCloud项目（十三）集成Gateway新一代服务网关

た入场券 2022-12-04 08:35 92阅读 0赞

### Spring Cloud全集文章目录： ###

零、[什么是微服务？一看就会系列！][Link 1]

一、[手把手教你搭建SpringCloud项目（一）图文详解，傻瓜式操作][SpringCloud]

二、[手把手教你搭建SpringCloud项目（二）生产者与消费者][SpringCloud 1]

三、[手把手教你搭建SpringCloud项目（三）集成Eureka服务注册中心][SpringCloud_Eureka]

四、[手把手教你搭建SpringCloud项目（四）Eureka集群版搭建][SpringCloud_Eureka 1]

五、[手把手教你搭建SpringCloud项目（五）生产者集群版搭建][SpringCloud 2]

六、[手把手教你搭建SpringCloud项目（六）Eureka实现服务发现][SpringCloud_Eureka 2]

七、[手把手教你搭建SpringCloud项目（七）集成Consul服务注册中心][SpringCloud_Consul]

八、[手把手教你搭建SpringCloud项目（八）集成Ribbon负载均衡器][SpringCloud_Ribbon]

九、[手把手教你搭建SpringCloud项目（九）集成OpenFeign服务接口调用][SpringCloud_OpenFeign]

十、[手把手教你搭建SpringCloud项目（十）集成Hystrix之服务降级][SpringCloud_Hystrix]

十一、[手把手教你搭建SpringCloud项目（十一）集成Hystrix之服务熔断][SpringCloud_Hystrix 1]

十二、[手把手教你搭建SpringCloud项目（十二 ）集成Hystrix之图形化Dashboard实时监控][SpringCloud_ _Hystrix_Dashboard]

十三、[手把手教你搭建SpringCloud项目（十三 ）集成Gateway新一代网关][SpringCloud_Gateway]

十四、[手把手教你搭建SpringCloud项目（十四 ）集成Config分布式配置中心][SpringCloud_Config]

十五、[手把手教你搭建SpringCloud项目（十五）集成Bus消息总线][SpringCloud_Bus]

十六、[手把手教你搭建SpringCloud项目（十六）集成Stream消息驱动][SpringCloud_Stream]

十七、[手把手教你搭建SpringCloud项目（十七）集成Sleuth分布式链路跟踪][SpringCloud_Sleuth]

文章继续更新中，欢迎点赞关注！

###  ###

### Gateway简介 ###

### **1、什么是API 网关？** ###

是作为一个 API 架构，用来保护、增强和控制对于 API 服务的访问。API 网关是一个处于应用程序或服务（提供 REST API 接口服务）之前的系统，用来管理授权、访问控制和流量限制等，这样 REST API 接口服务就被 API 网关保护起来，对所有的调用者透明。因此，隐藏在 API 网关后面的业务系统就可以专注于创建和管理服务，而不用去处理这些策略性的基础设施。

**2、API 网关都有哪些职能？**

![format_png][]

**3、API 网关的分类与功能？**

![format_png 1][]

**4、Gateway是什么**

Spring Cloud Gateway是Spring官方基于Spring 5.0，Spring Boot 2.0和Project Reactor等技术开发的网关，Spring Cloud Gateway旨在为微服务架构提供一种简单而有效的统一的API路由管理方式。Spring Cloud Gateway作为Spring Cloud生态系中的网关，目标是替代ZUUL，其不仅提供统一的路由方式，并且基于Filter链的方式提供了网关基本的功能，例如：安全，监控/埋点，和限流等。

**5. 为什么用Gateway**

Spring Cloud Gateway 可以看做是一个 Zuul 1.x 的升级版和代替品，比 Zuul 2 更早的使用 Netty 实现异步 IO，从而实现了一个简单、比 Zuul 1.x 更高效的、与 Spring Cloud 紧密配合的 API 网关。  
Spring Cloud Gateway 里明确的区分了 Router 和 Filter，并且一个很大的特点是内置了非常多的开箱即用功能，并且都可以通过 SpringBoot 配置或者手工编码链式调用来使用。  
比如内置了 10 种 Router，使得我们可以直接配置一下就可以随心所欲的根据 Header、或者 Path、或者 Host、或者 Query 来做路由。  
比如区分了一般的 Filter 和全局 Filter，内置了 20 种 Filter 和 9 种全局 Filter，也都可以直接用。当然自定义 Filter 也非常方便。

**6、最重要的几个概念**

Route(路由)：这是网关的基本构建块，它由一个ID，一个URI，一组断言和一组过滤器定义。如果断言为真，则路由匹配。

Predicate（断言）：输入类类是一个ServerWebExchange。我们可以使用它来匹配来自HTTP请求的任何内容，例如headers。如果请求与断言相匹配则进行路由。

Filter（过滤器）：Spring框架中GatewayFilter的实例，使用过滤器，可以在请求被路由前或者后对请求进行修改。

**7、工作流程**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70][]

客户端向Spring Cloud Gateway发出请求，然后在Gateway Hander Mapping中找到与请求相匹配的路由，将其发送到Gateway Web Handler。

Handler在通过指定的过滤器链来将请求发送到我们实际的服务业务逻辑，然后返回。过滤器之间用虚线分是因为过滤器可能会在发送代理请求之间（“pre”）或之后(“post”)执行业务逻辑。

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

主要核心就是路由转发+执行过滤器链

### 二、入门配置 ###

新建module，服务名称为cloud-gateway-gateway9527，修改pom.xml文件，主要还是新增了gateway的依赖。采坑提示，不要引入web依赖，不然会报错，项目都起不来。如下图：

<?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>mcroservice</artifactId>
            <groupId>com.study.springcloud</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>cloud-gateway-gateway9527</artifactId>
        <dependencies>
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-gateway</artifactId>
            </dependency>
            
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
        
            <dependency>
                <groupId>com.study.springcloud</groupId>
                <artifactId>cloud-api-commons</artifactId>
                <version>${project.version}</version>
            </dependency>
    
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
    
        </dependencies>
    
    </project>

新建yml配置文件，如下图：

server:
      port: 9527
    
    spring:
      application:
        name: cloud-gateway  
    eureka:
      instance:
        hostname: cloud-gateway-service
      client: #服务提供者provider注册进eureka服务列表内
        service-url:
          register-with-eureka: true
          fetch-registry: true
          defaultZone: http://eureka7001.com:7001/eureka

新建主启动类，如下图：

package com.buba.springcloud.gateway;
    
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
    
    @SpringBootApplication
    @EnableEurekaClient
    public class GatewayMain {
        public static void main(String[] args) {
            SpringApplication.run(GatewayMain.class,args);
        }
    }

那接下去启动Eureka7001服务和我们新建的Gateway的网关服务，看看网关服务是否成功注册到Eureka注册中心？

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 1][]

可以看到网关Gateway成功的注册了注册中心，那网关如何做映射呢？那我们以cloud-provide-payment生产者服务为例来映射一下。打开PaymentControler控制层，对get和lb两个方法做进行演示，因为我们之前访问都是[http://localhost:8001/payment/get/1][http_localhost_8001_payment_get_1]的访问，但是我们访问的时候是将我们的端口8001，暴露在了外边，不安全，但是我们不想暴露真的[8001][http_localhost_8001_payment_get_1]端口号，希望在外面8001外边包上一层我们的Gateway的端口9527，这就需要在yml配置新增路由配置。如下图：

server:
      port: 9527
    
    spring:
      application:
        name: cloud-gateway
      cloud:
        gateway:
          routes:
            - id: payment_route # 路由的id,没有规定规则但要求唯一,建议配合服务名
             #匹配后提供服务的路由地址
              uri: http://localhost:8001
              predicates:
                - Path=/payment/get/** # 断言，路径相匹配的进行路由
            - id: payment_route2
              uri: http://localhost:8001
              predicates:
                Path=/payment/lb/** #断言,路径相匹配的进行路由
    
    eureka:
      instance:
        hostname: cloud-gateway-service
      client:
        fetch-registry: true
        register-with-eureka: true
        service-url:
          defaultZone: http://eureka7001.com:7001/eureka/

然后我们访问[http://localhost:9527/payment/get/1][http_localhost_9527_payment_get_1]，可以成功访问，说明我们的网关的路由和断言就配置成功啦！如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 2][]

我们现在配置的是YML进行配置的，还有一种配置方案就是通过硬编码的方式。就是代码中注入RouteLocator的Bean，是为了解决YML文件配置太多，文件太大的问题。那就开始撸起来吧！我们只要演示通过9527网关访问到外网的百度新闻网址。

新建一个config配置文件,如下图：

package com.buba.springcloud.gateway.config;
    
    import org.springframework.cloud.gateway.route.RouteLocator;
    import org.springframework.cloud.gateway.route.builder.RouteLocatorBuilder;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * 配置了一个id为routr-name的路由规则
     * 当访问地址http://localhost:9527/guonei时会自动转发到http://news.baidu.com/guonei
     * */
    @Configuration
    public class GateWayConfig
    {
        @Bean
        public RouteLocator customRouteLocator(RouteLocatorBuilder routeLocatorBuilder){
            RouteLocatorBuilder.Builder routes = routeLocatorBuilder.routes();
            routes.route("patn_route_buba",r -> r.path("/guonei").uri("http://news.baidu.com/guonei")).build();
            return routes.build();
        }
    }

配置完毕，重新启动服务，我们访问[http://localhost:9527/guonei][http_localhost_9527_guonei]，可以成功转发到如下界面，说明我们GateWay通过编码的方式进行路由的映射配置。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 3][]

### 三、实现动态路由 ###

看我们的YML配置文件，我们配置的是http://localhost:8001是写死的，但是在我们微服务中生产者服务是不可能有一台机器的，所以说必须要进行负载均衡的配置。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 4][]

默认情况下Gateway会根据注册中心注册的服务列表，以注册中心上微服务名为路径创建动态路由进行转发，从而实现动态路由的功能。那我们就需要修改Gateway的YML配置文件，开启从注册中心动态创建路由的功能，利用微服务名称进行路由，匹配后提供服务的路由地址修改为生产者的服务名称，具体配置如下图：

server:
      port: 9527
    spring:
      application:
        name: cloud-gateway
      cloud:
        gateway:
          discovery:
            locator:
              enabled: true # 开启从注册中心动态创建路由的功能，利用微服务名称j进行路由
          routes:
            - id: payment_route # 路由的id,没有规定规则但要求唯一,建议配合服务名
              #匹配后提供服务的路由地址
              #uri: http://localhost:8001
              uri: lb://MCROSERVICE-PAYMENT
              predicates:
                - Path=/payment/get/** # 断言，路径相匹配的进行路由
            - id: payment_route2
              #uri: http://localhost:8001
              uri: lb://MCROSERVICE-PAYMENT
              predicates:
                Path=/payment/lb/** #断言,路径相匹配的进行路由
    eureka:
      instance:
        hostname: cloud-gateway-service
      client:
        fetch-registry: true
        register-with-eureka: true
        service-url:
          defaultZone: http://eureka7001.com:7001/eureka/

为了测试负载均衡，我们需要启动Eureka7001，启动生产者服务8001和8002，启动Gateway服务，要记得在8002服务中也加上返回端口的lb方法。成功的实现了负载均衡。测试如下：

![20200908113301145.gif][]

### 四、常用的Predicate断言 ###

我们启动我们的cloud-gateway-gateway9527的服务，可以看到控制台有如下的界面：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 5][]

Spring Cloud Gateway将路由匹配作为Spring WebFlux HandlerMapping基础框架的一部分，它包含许多内置的RoutePredicateFactory，所有这些Predicate都与HTTP请求的不同属性匹配。多个Route Predicate工厂进行组合。Spring Cloud Gateway 创建Route对象时，使用RoutePredicateFactory创建Predicate对象，Predicate对象可以赋值给Route，Spring Cloud Gateway包含许多内置的Route Predicate Factoriess。所有的这些谓词都匹配HTTP的不同属性。多种谓工厂可以组合，并通过逻辑and。

然后在我们的YML的配置文件也可以看到路由配置，我们使用的是path，就是请求的Path（路径）匹配配置值。如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 6][]  
我们常用的路由配置，就是为了实现一组匹配规则，让请求过来找到对应的Route进行处理。如下图：

![format_png 2][]

我们这里实例一下After，其他的差不多，我们先看一下官网是如何配置的，如下图：

![20200908210506964.png][]

红色区域我们可以看到是一串时间，官网使用的是国外的时间，那我们怎么才能使用到当前的时间呢，就使用如下的一个类，获取到我们当前国内的时间，默认的是上海。如下图：

package com.buba.test;
    
    import java.time.ZonedDateTime;
    
    public class T2 {
        public static void main(String[] args) {
            ZonedDateTime time =  ZonedDateTime.now();//使用默认时间
            System.out.println(time);
    
    
        }
    }

得到时间后，我们进行配置YML文件，我们只配置payment/get的方法，如下图：

server:
      port: 9527
    spring:
      application:
        name: cloud-gateway
      cloud:
        gateway:
          discovery:
            locator:
              enabled: true # 开启从注册中心动态创建路由的功能，利用微服务名称j进行路由
          routes:
            - id: payment_route # 路由的id,没有规定规则但要求唯一,建议配合服务名
              #匹配后提供服务的路由地址
              #uri: http://localhost:8001
              uri: lb://MCROSERVICE-PAYMENT
              predicates:
                - Path=/payment/get/** # 断言，路径相匹配的进行路由
                - After=2020-09-08T21:11:46.662+08:00[Asia/Shanghai] #断言在当前时间之后才可以访问
            - id: payment_route2
              #uri: http://localhost:8001
              uri: lb://MCROSERVICE-PAYMENT
              predicates:
                Path=/payment/lb/** #断言,路径相匹配的进行路由
    eureka:
      instance:
        hostname: cloud-gateway-service
      client:
        fetch-registry: true
        register-with-eureka: true
        service-url:
          defaultZone: http://eureka7001.com:7001/eureka/

那我们先进行测试一下，现在是否可以访问成功，因为现在的时间肯定比配置的时间之后了，如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 7][]

我们将时间进行修改一下，将时间推后一天，然后测试一下payment/get的方法，如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 8][]

可以看到配置之后就不可以访问了，像这个After，我们就可以上线新功能的时候使用，比如你公司上线是在晚上10点上线，你可以提前上线，然后等到设置的时间再生效。那我们测试一下没有配置After断言的payment/lb的方法，看看能否访问成功，如下图：

![2020090821351745.png][]

可以看到成功访问，说明我们的配置是没有问题的，11种断言的配置，大家可以根据自己的需求进行配置。

### 五、Filter的使用 ###

filter是Gateway的三大核心之一，路由过滤器可用于修改进入HTTP请求和返回的HTTP响应，路由过滤器只能指定路由进行使用。Gateway内置了多种路由过滤器，他们都由GatewayFilter工程类来产生。

**Filter的作用**

当我们有很多个服务时，比如下图中的user-service、goods-service、sales-service等服务，客户端请求各个服务的Api时，每个服务都需要做相同的事情，比如鉴权、限流、日志输出等。

![1.png][]

对于这样重复的工作，有没有办法做的更好，答案是肯定的。在微服务的上一层加一个全局的权限控制、限流、日志输出的Api Gatewat服务，然后再将请求转发到具体的业务服务层。这个Api Gateway服务就是起到一个服务边界的作用，外接的请求访问系统，必须先通过网关层。

![2.png][]

**Filter的生命周期**

Spring Cloud Gateway同zuul类似，生命周期只有pre和post。在路由处理之前，需要经过“pre”类型的过滤器处理，处理返回响应之后，可以由“post”类型的过滤器处理。在“pre”类型的过滤器可以做参数校验、权限校验、流量监控、日志输出、协议转换等，在“post”类型的过滤器中可以做响应内容、响应头的修改，日志的输出，流量监控等。

比如上图中的user-service，收到业务服务的响应之后，再经过“post”类型的filter处理，最后返回响应到客户端。

![3.png][]

与zuul不同的是，filter除了分为“pre”和“post”两种方式的filter外，在Spring Cloud Gateway中，filter从作用范围可分为另外两种，一种是针对于单个路由的gateway filter，它在配置文件中的写法同predict类似；另外一种是针对于所有路由的global gateway filer。现在从作用范围划分的维度来讲解这两种filter。

**Spring Cloud Gateway的Filter种类分为GatewayFilter（单一的）和GlobalFilter（全局的）**

Spring Cloud Gateway根据作用范围划分为GatewayFilter和GlobalFilter，二者区别如下：

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

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

GatewayFilter介绍

GatewayFilter工厂同上一篇介绍的Predicate工厂类似，都是在配置文件application.yml中配置，遵循了约定大于配置的思想，只需要在配置文件配置GatewayFilter Factory的名称，而不需要写全部的类名，比如AddRequestHeaderGatewayFilterFactory只需要在配置文件中写AddRequestHeader，而不是全部类名。在配置文件中配置的GatewayFilter Factory最终都会相应的过滤器工厂类处理。

Spring Cloud Gateway 内置的过滤器工厂一览表如下：

![1.png][1.png 1]

每一个过滤器工厂在官方文档都给出了详细的使用案例，现在的版本有30种，[点击查看官网][Link 2]，如果不清楚的还可以在org.springframework.cloud.gateway.filter.factory看每一个过滤器工厂的源码。在我们实际的开发过程中，一般GatewayFilter是无法满足的，就需要我们自定义过滤器。

那下面我们自己开始自义定过滤器吧！

主要就是实现实现这两个接口GlobalFilter, Ordered,然后实现具体的业务逻辑，如下图：

package com.buba.springcloud.gateway.filter;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.cloud.gateway.filter.GatewayFilterChain;
    import org.springframework.cloud.gateway.filter.GlobalFilter;
    import org.springframework.core.Ordered;
    import org.springframework.http.HttpStatus;
    import org.springframework.stereotype.Component;
    import org.springframework.web.server.ServerWebExchange;
    import reactor.core.publisher.Mono;
    
    import java.util.Date;
    
    @Component
    @Slf4j
    public class MyLogGatewatFilter implements GlobalFilter, Ordered {
        //你要访问我时候需要一个指定的用户名才能进行访问，
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
            log.info("************come in MyLogGatewatFilter "+ new Date());
            //判断是否携带uname的key
            String uname = exchange.getRequest().getQueryParams().getFirst("uname");
            //非法用户请离开
            if(uname==null){
                log.info("************用户名为null，非法用户");
                exchange.getResponse().setStatusCode(HttpStatus.NOT_ACCEPTABLE);
                return exchange.getResponse().setComplete();
            }
            //合法用户进行下一个过滤链进行过滤验证
            return chain.filter(exchange);
        }
        //这个0数字代表加载过滤器的顺序，就是越小优先级越高，因为是全局的，所以必须是第一位的。
        @Override
        public int getOrder() {
            return 0;
        }
    }

该过滤器主要是要访问的路径，需要携带参数uname，如果不携带自己就会校验不合法，会报错，无法访问，只有写单且合法才会访问成功，我们访问[http://localhost:9527/payment/get/1?uname=zs][http_localhost_9527_payment_get_1_uname_zs]进行测试，成功如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 9][]

然后不带参数进行访问，失败如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 10][]

**GlobalFilter介绍**

Spring Cloud Gateway框架内置的GlobalFilter如下：

![微信截图\_20181204175448.png][20181204175448.png]

上图中每一个GlobalFilter都作用在每一个router上，能够满足大多数的需求。但是如果遇到业务上的定制，可能需要编写满足自己需求的GlobalFilter。在下面的案例中将讲述如何编写自己GlobalFilter，该GlobalFilter会校验请求中是否包含了请求参数“token”，如何不包含请求参数“token”则不转发路由，否则执行正常的逻辑。代码如下：

public class TokenFilter implements GlobalFilter, Ordered {
    
        Logger logger=LoggerFactory.getLogger( TokenFilter.class );
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
            String token = exchange.getRequest().getQueryParams().getFirst("token");
            if (token == null || token.isEmpty()) {
                logger.info( "token is empty..." );
                exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
                return exchange.getResponse().setComplete();
            }
            return chain.filter(exchange);
        }
    
        @Override
        public int getOrder() {
            return -100;
        }
    }

在上面的TokenFilter需要实现GlobalFilter和Ordered接口，这和实现GatewayFilter很类似。然后根据ServerWebExchange获取ServerHttpRequest，然后根据ServerHttpRequest中是否含有参数token，如果没有则完成请求，终止转发，否则执行正常的逻辑。

然后需要将TokenFilter在工程的启动类中注入到Spring Ioc容器中，代码如下：

@Bean
    public TokenFilter tokenFilter(){
            return new TokenFilter();
    }

启动工程，使用curl命令请求：

curl localhost:8081/customer/123

可以看到请没有被转发，请求被终止，并在控制台打印了如下日志：

2018-11-16 15:30:13.543  INFO 19372 --- [ctor-http-nio-2] gateway.TokenFilter                      : token is empty...

上面的日志显示了请求进入了没有传“token”的逻辑。

我们Spring Cloud Gateway到这里就学习完毕了，so easy！

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 11][]

文章部分摘于方志朋，[点击查看原文][Link 3]

下一篇文章我们学习Spring Cloud Config分布式配置中心，文章持续更新，欢迎关注！

![9d4a501cabec14b69aeb15035a33a690.png][]

[Link 1]: https://blog.csdn.net/weixin_38007185/article/details/108119724
[SpringCloud]: https://blog.csdn.net/weixin_38007185/article/details/108186254
[SpringCloud 1]: https://blog.csdn.net/weixin_38007185/article/details/108187607
[SpringCloud_Eureka]: https://blog.csdn.net/weixin_38007185/article/details/108242162
[SpringCloud_Eureka 1]: https://blog.csdn.net/weixin_38007185/article/details/108308517
[SpringCloud 2]: https://blog.csdn.net/weixin_38007185/article/details/108315696
[SpringCloud_Eureka 2]: https://blog.csdn.net/weixin_38007185/article/details/108309758
[SpringCloud_Consul]: https://blog.csdn.net/weixin_38007185/article/details/108310912
[SpringCloud_Ribbon]: https://blog.csdn.net/weixin_38007185/article/details/108329635
[SpringCloud_OpenFeign]: https://blog.csdn.net/weixin_38007185/article/details/108359507
[SpringCloud_Hystrix]: https://blog.csdn.net/weixin_38007185/article/details/108415392
[SpringCloud_Hystrix 1]: https://blog.csdn.net/weixin_38007185/article/details/108429780
[SpringCloud_ _Hystrix_Dashboard]: https://blog.csdn.net/weixin_38007185/article/details/108436460
[SpringCloud_Gateway]: https://blog.csdn.net/weixin_38007185/article/details/108440631
[SpringCloud_Config]: https://blog.csdn.net/weixin_38007185/article/details/108506514
[SpringCloud_Bus]: https://blog.csdn.net/weixin_38007185/article/details/111825717
[SpringCloud_Stream]: https://blog.csdn.net/weixin_38007185/article/details/111825959
[SpringCloud_Sleuth]: https://blog.csdn.net/weixin_38007185/article/details/111826112
[format_png]: /images/20221123/e3c760136c7449bb8c299f2afd195ff7.png
[format_png 1]: /images/20221123/44f9b8be9fbc4424b373bcd5cb5a6b8a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70]: /images/20221123/a51c308e25404e5c9782740a669c6d67.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 1]: /images/20221123/6d32f415d8694fde8a66d7a3162fdd2a.png
[http_localhost_8001_payment_get_1]: http://localhost:8001/payment/get/1
[http_localhost_9527_payment_get_1]: http://localhost:9527/payment/get/1
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 2]: /images/20221123/319ff82a62f4405e8442b974202a8387.png
[http_localhost_9527_guonei]: http://localhost:9527/guonei
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 3]: /images/20221123/da0b2dc8e8c7454a8a774fc5cdf5eeda.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 4]: /images/20221123/e04e887d084542969443571f534358c9.png
[20200908113301145.gif]: /images/20221123/9092b7ecac0146779c1df8967852a9b5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 5]: /images/20221123/04a9b94a01c2444898291bed60e3ee74.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 6]: /images/20221123/7f5b5d4e7a594c10918f19f43567c02b.png
[format_png 2]: /images/20221123/4404e949a86b4ad1b4e9dbfcb26b65cb.png
[20200908210506964.png]: /images/20221123/c29b6884b1104e90bcf095ed1a3480ad.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 7]: /images/20221123/7943faa746734ecfae3c96f599903fa1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 8]: /images/20221123/9adf65d05e5e479a8b16965785738695.png
[2020090821351745.png]: /images/20221123/d96cda0a0df443c5973c57663f118f87.png
[1.png]: /images/20221123/bc29ae89510043cf83a925c57d72ba42.png
[2.png]: /images/20221123/b482b33cec8a449d8fa26f33198db71c.png
[3.png]: /images/20221123/928a86b272cf4ec1b1ea7fd25f4bd5cf.png
[1.png 1]: /images/20221123/00465978811d498fa078efa1bba94c0c.png
[Link 2]: https://docs.spring.io/spring-cloud-gateway/docs/3.0.0-SNAPSHOT/reference/html/#gatewayfilter-factories
[http_localhost_9527_payment_get_1_uname_zs]: http://localhost:9527/payment/get/1?uname=zs
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 9]: /images/20221123/df5c29b88d2c477580e0e134a0dec6e3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 10]: /images/20221123/322c44d626214b04ab0535fe99524642.png
[20181204175448.png]: /images/20221123/202996bf725d408ab386cd73d3049b41.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODAwNzE4NQ_size_16_color_FFFFFF_t_70 11]: /images/20221123/158f85ca83ce48c99e028ddc29d1b71e.png
[Link 3]: https://www.cnblogs.com/forezp/p/10135714.html
[9d4a501cabec14b69aeb15035a33a690.png]: /images/20221123/2ce1fc2620444eb68780a806afd7f0e9.png