SpringCloud Gateway高级应用

╰+哭是因爲堅強的太久メ 2024-03-17 10:53 18阅读 0赞

#### 目录 ####

*  1 SpringCloud技术栈
 *   *  1.1 SpringCloud技术栈
     *  1.2 SpringCloud经典技术介绍
     *  1.3 SpringCloud项目场景
 *  2 SpringCloud Gateway
 *   *  2.1 Gateway工作原理
     *  2.2 Gateway路由
     *   *  2.2.1 业务说明
         *  2.2.2 基于配置路由设置
         *  2.2.3 基于代码路由配置
         *  2.2.4 Gateway-Predicate
         *  2.2.5 断言源码剖析
     *  2.3 Gateway过滤器
     *   *  2.3.1 过滤器分类
         *  2.3.2 默认过滤器的使用
         *  2.3.3自定义GatewayFilter
         *  2.3.4 自定义GlobalFilter
     *  2.4 跨域配置
     *  2.5 限流
     *   *  2.5.1 令牌桶算法讲解
         *  2.5.2 限流案例

--------------------

## 1 SpringCloud技术栈 ##

![在这里插入图片描述][ae85f285b97c467cabeaa4a6a6233574.png]

*  清楚SpringCloud技术栈分类
 *  能够说出SpringCloud Gateway的工作流程
 *  至少掌握Gateway动态路由配置中基于Path的路由方式
 *  能实现全局过滤器和局部过滤器的创建和使用
 *  能写出SpringCloud Gateway跨域配置
 *  理解限流漏桶算法
 *  能够实现基于漏桶算法的限流操作

开发分布式系统可能具有挑战性，复杂性已从应用程序层转移到网络层，并要求服务之间进行更多的交互。将代码设为“cloud-native”就需要解决12-factor，例如外部配置，服务无状态，日志记录以及连接到备份服务之类的问题，Spring Cloud项目套件包含使您的应用程序在云中运行所需的许多服务。

12-factor（云原生应用程序的12要素）：

![在这里插入图片描述][632bee5f312b4d0eb6b10ef1bd4bfeda.png]

SpringCloud架构：

![在这里插入图片描述][64b00ad594e14d43a89cd677b71a4ee6.png]

### 1.1 SpringCloud技术栈 ###

![在这里插入图片描述][1056d1e82c074e588b84ecb1af73b3dc.png]

SpringCloud技术栈非常丰富，这也是SpringCloud为什么在微服务领域中如此受欢迎的原因之一，技术栈如上图，在服务注册与配置、服务调用、微服务网关、消息组件、链路追踪、配置中心、安全控制、将极限流等诸多方面技术栈都比较完善，而且阿里巴巴也出了一套SpringCloud Alibaba版本，主要集成了Alibaba中主流的技术栈。

### 1.2 SpringCloud经典技术介绍 ###

微服务项目近几年非常火爆，推出来的相关技术解决方案热度也非常活跃，但SpringCloud技术栈中也有一部分技术组件在逐步被淘汰或者闭源，但都有更优秀的技术方案替代。在不久的将来，那些闭源或者将被淘汰的技术有很大概率将不在项目中使用，所以我们学习的时候可以直接学习更优秀的替代技术方案。

**Eureka闭源：**

![在这里插入图片描述][117ea1102fbd46c3a719ea64c03b453e.png]

上面英文大概意思是：`Eureka 2.0` 的开源工作已经停止，依赖于开源库里面的 `Eureka 2.x` 分支构建的项目或者相关代码，风险自负。

Eureka在微服务项目中主要承担服务注册与发现工作，可以替代的技术方案比较多，而且很多方案都比Eureka优秀，比如Consul、Nacos等。

**Hystrix停止更新：**

![在这里插入图片描述][4871674eefb843dabf006d86e74f6a81.png]

Hystrix在项目中主要做服务熔断、降级，但官方宣布将不在开发，目前处于维护状态，但官方表示 1.5.18 版本的 Hystrix 已经足够稳定，可以满足 Netflix 现有应用的需求。

关于Hystrix可替代的产品也比较多，比如官方推荐的`resilience4j`，`resilience4j`是一个轻量级熔断框架，但`resilience4j`目前在国内使用频率还不高，功能也不够强，我们更推荐使用功能更加强悍的`SpringCloud Alibaba Sentinel`。

**Zuul过时：**

`Zuul`是一个微服务网关技术，但`Zuul1.x`使用的是阻塞式的API，不支持长连接，没有提供异步，高并发场景下性能低。`SpringCloud`官网推出了全新的微服务网关技术`SpringCloud Gateway`，比`Zuul`性能更强悍、功能更丰富、且支持异步等多种特性。

**SpringCloud Config实用性差：**

`SpringCloud Config`主要用于管理项目的配置文件，每次要使用`SpringCloud Config`的时候，总得经过一波操作和配置的折腾，才可以使用`SpringCloud Config`实现配置管理，而且单独使用无法支持配置实时刷新，在项目中用起来，真比较头疼的。

当前有很多技术可以取代`SpringCloud Config`，比如携程的`Apollo`、`SpringCloud Alibaba Nacos`，功能都比`SpringCloud Config`强，并且支持实时刷新配置。

**SpringCloud Bus实用性差：**

SpringCloud Bus是服务消息总线，主要实现通知多个服务执行某个任务，一般和SpringCloud Config一起使用。这个功能其实不太使用，因为很多任务组件基本都具备消息通知功能，比如Nacos、Apollo都能实现所有服务订阅执行相关操作。

### 1.3 SpringCloud项目场景 ###

![在这里插入图片描述][9414f2fca4024880b0464c5e8702cdb9.png]

微服务技术目前已经在很多国内外大厂中都在广泛使用，那么在项目中该如何使用微服务技术呢？我们以滴滴快车业务未来，来讲解一下微服务技术结合业务应用讲解一下。

![在这里插入图片描述][ea9a2778d68844d08011ba4faf1ca408.png]

打车业务如上图：

1:打车的时候会选择车型，选择车型我们调用过程是：Gateway->Driver（加载司机列表）
    2:选择车型后确认打车，相当于要下单了，调用过程是：Gateway->Order（下单）->Driver（司机状态更改）
    3:打车结束后，用户进入支付，调用过程是：Gateway->Pay（支付）->Driver（更新司机状态）
                                                        ->Order（更新订单状态）

## 2 SpringCloud Gateway ##

![在这里插入图片描述][d520568aace842b9b8a9bcaab2a0fc62.png]

Spring Cloud Gateway 是Spring Cloud团队的一个全新项目，基于Spring 5.0、SpringBoot2.0、Project Reactor 等技术开发的网关。旨在为微服务架构提供一种简单有效统一的API路由管理方式。

Spring Cloud Gateway 作为SpringCloud生态系统中的网关，目标是替代Netflix Zuul。Gateway不仅提供统一路由方式，并且基于Filter链的方式提供网关的基本功能。例如：安全，监控/指标，和限流。

**总结：微服务网关就是一个系统，通过暴露该微服务网关系统，方便我们进行相关的鉴权，安全控制，日志统一处理，易于监控，限流等相关功能。**

实现微服务网关的技术有很多，

*  nginx：Nginx (engine x) 是一个高性能的HTTP和反向代理web服务器，同时也提供了IMAP/POP3/SMTP服务
 *  zuul ：Zuul 是 Netflflix 出品的一个基于 JVM 路由和服务端的负载均衡器。
 *  spring-cloud-gateway：是spring 出品的基于spring的网关项目，集成断路器，路径重写，性能比Zuul好。

我们使用gateway这个网关技术，无缝衔接到基于spring cloud的微服务开发中来。

gateway官网：

https://spring.io/projects/spring-cloud-gateway

### 2.1 Gateway工作原理 ###

我们在学习Gateway之前，先弄清楚Gateway的工作原理，后面使用它的各个功能时，就知道该如何使用了，工作流程图如下：

![在这里插入图片描述][ba96651205ae49babfd270af76bee907.png]

Gateway的执行流程如下：

1:Gateway的客户端回向Spring Cloud Gateway发起请求，请求首先会被HttpWebHandlerAdapter进行提取组装成网关的上下文，然后网关的上下文会传递到DispatcherHandler。
    
    2:DispatcherHandler是所有请求的分发处理器，DispatcherHandler主要负责分发请求对应的处理器，比如将请求分发到对应RoutePredicateHandlerMapping(路由断言处理器映射器）。
    
    3:路由断言处理映射器主要用于路由的查找，以及找到路由后返回对应的FilteringWebHandler。
    
    4:FilteringWebHandler主要负责组装Filter链表并调用Filter执行一系列Filter处理，然后把请求转到后端对应的代理服务处理，处理完毕后，将Response返回到Gateway客户端。
    在Filter链中，通过虚线分割Filter的原因是，过滤器可以在转发请求之前处理或者接收到被代理服务的返回结果之后处理。所有的Pre类型的Filter执行完毕之后，才会转发请求到被代理的服务处理。被代理的服务把所有请求完毕之后，才会执行Post类型的过滤器。

### 2.2 Gateway路由 ###

Gateway路由配置分为**基于配置的静态路由**设置和**基于代码动态路由**配置，

静态路由是指在application.yml中把路由信息配置好了，而动态路由则支持在代码中动态加载路由信息，更加灵活，我们接下来把这2种路由操作都实现一次。

#### 2.2.1 业务说明 ####

![在这里插入图片描述][959f520c2add420bbea3b461a466125a.png]

如上图：

1:用户所有请求以/order开始的请求，都路由到 hailtaxi-order服务
    2:用户所有请求以/driver开始的请求，都路由到 hailtaxi-driver服务
    3:用户所有请求以/pay开始的请求，都路由到 hailtaxi-pay服务

#### 2.2.2 基于配置路由设置 ####

![在这里插入图片描述][34dcae7f91e24a26afb268521e654073.png]

如上图所示，正是Gateway静态路由配置：

配置参数说明：

routes:路由配置
    - id:唯一标识符
    uri:路由地址，可以是 lb://IP:端口     也可以是   lb://${
        spring.application.name}
    predicates:断言，是指路由条件
    - Path=/driver/**:路由条件。Predicate 接受一个输入参数，返回一个布尔值结果。这里表示匹配所有以driver开始的请求。
    filters:过滤器
    - StripPrefix=1:真实路由的时候，去掉第1个路径，路径个数以/分割区分

测试url：http://localhost:8001/driver/info/1

#### 2.2.3 基于代码路由配置 ####

我们同样实现上面的功能，但这里基于代码方式实现。所有路由规则我们可以从数据库中读取并加载到程序中。基于代码的路由配置我们只需要创建`RouteLocator`并添加路由配置即可，代码如下：

/***
     * 路由配置
     * @param builder
     * @return
     */
    @Bean
    public RouteLocator routeLocator(RouteLocatorBuilder builder) {
        
    
        return builder.routes()
            .route("hailtaxi-driver", r -> r.path("/driver/**").uri("lb://hailtaxi-driver"))
            .route("hailtaxi-order", r -> r.path("/order/**").uri("lb://hailtaxi-order"))
            .route("hailtaxi-pay", r -> r.path("/pay/**").uri("lb://hailtaxi-pay"))
            .build();
    }

在真实场景中，基于配置文件的方式更直观、简介，但代码的路由配置是更强大，可以实现很丰富的功能，可以把路由规则存在数据库中，每次直接从数据库中加载规则，这样的好处是可以动态刷新路由规则，通常应用于权限系统动态配置。

spring: 
        cloud: 
            gateway:
              #路由配置
              routes:
                #唯一标识符
                - id: hailtaxi-driver
                  uri: lb://hailtaxi-driver
                  #路由断言
                  predicates:
                    - Path=/driver/**
                #唯一标识符
                - id: hailtaxi-order
                  uri: lb://hailtaxi-order
                  #路由断言
                  predicates:
                    - Path=/order/**
                #唯一标识符
                - id: hailtaxi-pay
                  uri: lb://hailtaxi-pay
                  #路由断言
                  predicates:
                    - Path=/pay/**

#### 2.2.4 Gateway-Predicate ####

上面路由匹配规则中我们都用了`- Path`方式，其实就是路径匹配方式，除了路径匹配方式，Gateway还支持很多丰富的匹配方式，我们对这些方式分别进行讲解。

关于`Predicate`学习地址，可以参考官网：

https://docs.spring.io/spring-cloud-gateway/docs/2.2.5.RELEASE/reference/html/\#gateway-request-predicates-factories

或者：

https://cloud.spring.io/spring-cloud-static/spring-cloud-gateway/2.1.1.RELEASE/single/spring-cloud-gateway.html\#gateway-request-predicates-factories

routes下面的属性含义如下：

id：我们自定义的路由 ID，保持唯一
    
    uri：目标服务地址
    
    predicates：路由条件，Predicate 接受一个输入参数，返回一个布尔值结果。该属性包含多种默认方法来将 Predicate 组合成其他复杂的逻辑（比如：与，或，非）

Predicate 来源于 Java 8，Predicate 接受一个输入参数，返回一个布尔值结果。该接口包含多种默认方法来将 Predicate 组合成其他复杂的逻辑（比如：与，或，非）。

在 Spring Cloud Gateway 中 Spring 利用 Predicate 的特性实现了各种路由匹配规则，通过 Header、请求参数等不同的条件来作为条件匹配到对应的路由。

下面的一张图(来自网络)总结了 Spring Cloud 内置的几种 Predicate 的实现:

![在这里插入图片描述][75999dde7864483db288978bde43d5d3.png]

我们在这里讲解几个断言匹配 方式。

**Cookie：**

Gateway的Cookie匹配接收两个参数：一个是 Cookie name ,一个是正则表达式。路由规则就是通过获取对应的 Cookie name 值和正则表达式去匹配，如果匹配上就会执行路由，如果没有匹配上则不执行。如下配置：

gateway:
          routes:
          - id: hailtaxi-driver
            uri: lb://hailtaxi-driver
            predicates:
            - Path=/driver/**
            - Cookie=username,itheima

这里表示请求携带了cookie为username的数据，并且值为itheima，就允许通过。

**Header 匹配：**

Header 匹配 和 Cookie 匹配 一样，也是接收两个参数，一个 header 中属性名称和一个正则表达式，这个属性值和正则表达式匹配则执行。配置如下：

gateway:
          routes:
          - id: hailtaxi-driver
            uri: lb://hailtaxi-driver
            predicates:
            - Path=/driver/**
            - Header=token,^(?!\d+$)[\da-zA-Z]+$

上面的匹配规则，就是请求头要有token属性，并且值必须为数字和字母组合的正则表达式，例如携带token=`19and30`就可以通过访问。

**请求方式匹配：**

通过请求的方式是 POST、GET、PUT、DELETE 等进行路由。配置如下：

gateway:
          routes:
          - id: hailtaxi-driver
            uri: lb://hailtaxi-driver
            predicates:
            - Path=/driver/**
            - Method=GET,POST

通过`yml`的完整代码如下（**注释掉java的配置**）

server:
      port: 8001
    spring:
      application:
        name: hailtaxi-gateway
      main:
        allow-bean-definition-overriding: true
      cloud:
        #Consul配置
        consul:
          host: 127.0.0.1
          port: 8500
          discovery:
            #注册到Consul中的服务名字
            service-name: ${
        spring.application.name}
            #注册的服务的实例 Id，最好不要重复，这里参考官网建议的方式 带随机数 默认：应用名:port
            #instance-id: ${spring.application.name}:${vcap.application.instance_id:${spring.application.i nstance_id:${random.value}}}
            # 自定义实例id为:应用名:ip:port
            instance-id: ${
        spring.application.name}:${
        spring.cloud.client.ip-address}:${
        server.port}
            prefer-ip-address: true
            # 开启服务注册
            register: true
            # 开启服务发现
            enabled: true
            #2 分钟之后健康检查未通过取消注册
            health-check-critical-timeout: 2m
            #consul 健康检查的轮询周期
            health-check-interval: 10s
        gateway:
          #路由配置
          routes:
            #唯一标识符
            - id: hailtaxi-driver
              uri: lb://hailtaxi-driver
              #路由断言
              predicates:
                - Path=/driver/**
                - Cookie=username,itheima
                - Header=token,^(?!\d+$)[\da-zA-Z]+$
                - Method=GET,POST
            #唯一标识符
            - id: hailtaxi-order
              uri: lb://hailtaxi-order
              #路由断言
              predicates:
                - Path=/order/**
            #唯一标识符
            - id: hailtaxi-pay
              uri: lb://hailtaxi-pay
              #路由断言
              predicates:
                - Path=/pay/**

#### 2.2.5 断言源码剖析 ####

拿`Cookie`断言来说，首先看它的体系结构

![在这里插入图片描述][4062bb07e18b434bbbaee8f7304c8230.png]

public class CookieRoutePredicateFactory
            extends AbstractRoutePredicateFactory<CookieRoutePredicateFactory.Config> {
        
    
        /**
         * Name key.
         */
        public static final String NAME_KEY = "name";
    
        /**
         * Regexp key.
         */
        public static final String REGEXP_KEY = "regexp";
    
        public CookieRoutePredicateFactory() {
        
            super(Config.class);
        }
        
        /*
          通过shortcutFieldOrder方法设置Config配置类中的属性,需要根据具体的规则来设置
          通过shortcutType方法获取具体规则，具体参看：org.springframework.cloud.gateway.support.ShortcutConfigurable.ShortcutType
          规则包括以下几种：
            DEFAULT : 按照shortcutFieldOrder顺序依次赋值
        */
        @Override
        public List<String> shortcutFieldOrder() {
        
            return Arrays.asList(NAME_KEY, REGEXP_KEY);
        }
    
        @Override
        public Predicate<ServerWebExchange> apply(Config config) {
        
            return new GatewayPredicate() {
        
                @Override
                public boolean test(ServerWebExchange exchange) {
        
                    List<HttpCookie> cookies = exchange.getRequest().getCookies()
                            .get(config.name);
                    if (cookies == null) {
        
                        return false;
                    }
                    for (HttpCookie cookie : cookies) {
        
                        if (cookie.getValue().matches(config.regexp)) {
        
                            return true;
                        }
                    }
                    return false;
                }
    
                @Override
                public String toString() {
        
                    return String.format("Cookie: name=%s regexp=%s", config.name,
                            config.regexp);
                }
            };
        }
        
        /*
         内部配置类是用来接收在配置文件中配置的参数的
          routes:
            #唯一标识符
            - id: hailtaxi-driver
              uri: lb://hailtaxi-driver
              #路由断言
              predicates:
                - Cookie=username,itheima
        */
        @Validated
        public static class Config {
        
    
            @NotEmpty
            private String name;
    
            @NotEmpty
            private String regexp;
    
            public String getName() {
        
                return name;
            }
    
            public Config setName(String name) {
        
                this.name = name;
                return this;
            }
    
            public String getRegexp() {
        
                return regexp;
            }
    
            public Config setRegexp(String regexp) {
        
                this.regexp = regexp;
                return this;
            }
    
        }
    
    }

尽管Spring Cloud Gateway已经包含了很多路由匹配规则，有时候我们需要开发自定义路由匹配规则来满足需求，下面简单的介绍一下如何自定义路由匹配规则。

**案例**

需求：转发带token的请求到`hailtaxi-drvier`服务中，这里定义请求带token是指包含某个请求头的请求，至于是什么请求头可以由配置指定

1、修改配置文件

gateway:
          #路由配置
          routes:
            #唯一标识符
            - id: hailtaxi-driver
              uri: lb://hailtaxi-driver
              #路由断言
              predicates:
                # 自定义一个Token断言,如果请求包含Authorization的token信息则通过
                - Token=Authorization

2、创建 RoutePredicateFactory

**断言工厂默认命名规则必须按照"名称"+RoutePredicateFactory，如上TokenRoutePredicateFactory的断言名称为Token**

@Slf4j
    @Component // 要交给spring容器管理
    public class TokenRoutePredicateFactory extends AbstractRoutePredicateFactory<TokenRoutePredicateFactory.Config> {
        
    
        public TokenRoutePredicateFactory() {
        
            super(Config.class);
        }
    
        public Predicate<ServerWebExchange> apply(Config config) {
        
            return exchange -> {
        
                // 打印配置文件参数值
                String headerName = config.getHeaderName();
                HttpHeaders headers = exchange.getRequest().getHeaders();
                List<String> header = headers.get(headerName);
                log.info("Token Predicate headers:{}", header);
                // 断言返回的是boolean值
                return header!=null && header.size()>0;
            };
        }
    
        @Override
        public List<String> shortcutFieldOrder() {
        
            return Arrays.asList("headerName");//指定配置文件中加载到的配置信息应填充到Config的哪个属性上
        }
    
        @Override
        public ShortcutType shortcutType() {
        
            return ShortcutType.DEFAULT;
        }
    
        @Data
        public static class Config {
         //static class
            private String headerName;//存储从配置文件中加载的配置
        }
    }

启动测试：http://localhost:8001/driver/info/1

### 2.3 Gateway过滤器 ###

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

*  GatewayFilter : 需要通过spring.cloud.routes.filters 配置在具体路由下，只作用在当前路由上或通过spring.cloud.default-filters配置在全局，作用在所有路由上；gateway内置了多种过滤器工厂，配套的过滤器可以直接使用，如下图所示：

![在这里插入图片描述][962901aeea324f9a8f47389abee3edbb.png]

![在这里插入图片描述][8ea4b2e57b1a41a4ab9cebafb1560b72.png]

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

![在这里插入图片描述][cc30c5ebaba04081a10c2d691bc6f4a5.png]

过滤器作为Gateway的重要功能。常用于请求鉴权、服务调用时长统计、修改请求或响应header、限流、去除路径等等。

关于Gateway过滤器的更多使用，大家可以参考官方地址：

https://docs.spring.io/spring-cloud-gateway/docs/2.2.5.RELEASE/reference/html/\#gatewayfilter-factories

或者：

https://cloud.spring.io/spring-cloud-static/spring-cloud-gateway/2.1.1.RELEASE/single/spring-cloud-gateway.html\#\_gatewayfilter\_factories

#### 2.3.1 过滤器分类 ####

默认过滤器:出厂自带，实现好了拿来就用，不需要实现
      全局默认过滤器
      局部默认过滤器
      
    自定义过滤器:根据需求自己实现，实现后需配置，然后才能用哦。
      全局过滤器:作用在所有路由上。
      局部过滤器:配置在具体路由下，只作用在当前路由上。

默认过滤器十好几个，常见如下：

<table> 
 <thead> 
  <tr> 
   <th>过滤器名称</th> 
   <th>说明</th> 
   <th>对应的类</th> 
   <th align="center">父类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>AddRequestHeader</td> 
   <td>对匹配上的请求加上Header</td> 
   <td>AddRequestHeaderGatewayFilterFactory</td> 
   <td align="center">AbstractNameValueGatewayFilterFactory</td> 
  </tr> 
  <tr> 
   <td>AddRequestParameters</td> 
   <td>对匹配上的请求路由</td> 
   <td>AddRequestHeaderGatewayFilterFactory</td> 
   <td align="center">AbstractNameValueGatewayFilterFactory</td> 
  </tr> 
  <tr> 
   <td>AddResponseHeader</td> 
   <td>对从网关返回的响应添加Header</td> 
   <td>AddResponseHeaderGatewayFilterFactory</td> 
   <td align="center">AbstractNameValueGatewayFilterFactory</td> 
  </tr> 
  <tr> 
   <td>StripPrefix</td> 
   <td>对匹配上的请求路径去除前缀</td> 
   <td>StripPrefixGatewayFilterFactory</td> 
   <td align="center">AbstractGatewayFilterFactory</td> 
  </tr> 
 </tbody> 
</table>

#### 2.3.2 默认过滤器的使用 ####

所谓默认过滤器就是系统自带的。有很多，这里简要说明几个：（**通过java配置，注释掉yaml配置**）

**1)添加响应头**

AddResponseHeaderGatewayFilterFactory 属于 GatewayFilter

对输出响应头设置属性，比如对输出的响应设置其头部属性名称为：X-Response-Default-MyName , 值为itheima

修改配置文件，配置如下：

spring:
      cloud:
        gateway:
         # 配置全局默认过滤器 作用在所有路由上，也可单独为某个路由配置
          default-filters:
          # 往响应过滤器中加入信息
            - AddResponseHeader=X-Response-Default-MyName,itheima

请求`http://localhost:8001/driver/info/1`，响应数据添加了`X-Response-Default-MyName: itheima`，如下图：

![在这里插入图片描述][fb6be11c09ea4ef892b2df7696f8eddc.png]

**2)前缀处理**

在项目中做开发对接接口的时候，我们很多时候需要统一API路径，比如统一以`/api`开始的请求调用`hailtaxi-driver`服务，但真实服务接口地址又没有`/api`路径，我们可以使用Gateway的过滤器处理请求路径。

在gateway中可以通过配置路由的过滤器StripPrefix实现映射路径中的前缀处理，我们来使用一下该过滤器，再进一步做说明。

gateway:
          routes:
          - id: hailtaxi-driver
            uri: lb://hailtaxi-driver
            predicates:
            - Path=/api/driver/**
            filters:
              - StripPrefix=1

此处`- StripPrefix=1`表示真实请求地址是当前用户请求以`/api`开始的uri中去除第1个路径`/api`.

上面配置最终执行如下表：

<table> 
 <thead> 
  <tr> 
   <th>配置</th> 
   <th>路由地址</th> 
   <th>访问地址</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>StripPrefix=1</td> 
   <td>http://localhost:8001/api/driver/info/2</td> 
   <td>http://localhost:18081/driver/info/2</td> 
  </tr> 
  <tr> 
   <td>StripPrefix=2</td> 
   <td>http://localhost:8001/api/suri/driver/info/2</td> 
   <td>http://localhost:18081/driver/info/2</td> 
  </tr> 
 </tbody> 
</table>

有时候为了简化用户请求地址，比如用户请求`http://localhost:8001/info/1`我们想统一路由到`http://localhost:18081/driver/info/1`，可以使用`PrefixPath`过滤器增加前缀。

gateway:
          routes:
          - id: hailtaxi-driver
            uri: lb://hailtaxi-driver
            predicates:
            - Path=/**
            filters:
              - PrefixPath=/driver

上面配置最终执行如下表：

<table> 
 <thead> 
  <tr> 
   <th align="left">配置</th> 
   <th>路由地址</th> 
   <th>访问地址</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">- PrefixPath=/driver</td> 
   <td>http://localhost:8001/info/2</td> 
   <td>http://localhost:18081/driver/info/2</td> 
  </tr> 
 </tbody> 
</table>

#### 2.3.3自定义GatewayFilter ####

1、实现GatewayFilter接口

GatewayFilter 一般作用在某一个路由上，需要实例化创建才能使用，局部过滤器需要实现接口`GatewayFilter、Ordered`。

创建`com.itheima.filter.PayFilter`代码如下：

public class PayFilter implements GatewayFilter,Ordered {
        
    
        /***
         * 过滤器执行拦截
         * @param exchange
         * @param chain
         * @return
         */
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        
            System.out.println("GatewayFilter拦截器执行---pre-----PayFilter");
            return chain.filter(exchange).then(Mono.fromRunnable(()->{
        
                System.out.println("GatewayFilter拦截器执行---post-----PayFilter");
            }));
        }
    
        @Override
        public int getOrder() {
        
            return 0;
        }
    }

使用局部过滤器：(使用下面RouteLocator的时候，配置文件中的路由记得注释或删除)

/***
     * 路由配置
     * @param builder
     * @return
     */
     @Bean
        public RouteLocator routeLocator(RouteLocatorBuilder builder) {
        
            return builder.routes()
                    .route("hailtaxi-driver", r -> r.path("/api/driver/**")
                            .and().cookie("username","itheima")
                            .and().header("token","123456")
                                    .filters(f->f.filter(new PayFilter()).addResponseHeader("X-Response-Default-MyName", "itheima")
                                            .addRequestHeader("myheader", "1234567")
                                    .stripPrefix(1)
                                    )
                           // .and().method(HttpMethod.POST)
                            .uri("lb://hailtaxi-driver")
                            //.filter(new PayFilter())
                     )
                    .route("hailtaxi-order", r -> r.path("/order/**").uri("lb://hailtaxi-order"))
                    .route("hailtaxi-pay", r -> r.path("/pay/**").uri("lb://hailtaxi-pay"))
                    .build();
        }

为了更好看到效果，我们在`RouterFilter`添加`System.out.println("GlobalFilter拦截器执行");`再访问测试。

访问：http://localhost:8001/api/driver/info/1，注意使用postman发送请求时添加请求头，添加cookie。

2、继承GatewayFilterFactory

如果定义局部过滤器，想在配置文件中进行配置来使用，可以继承`AbstractGatewayFilterFactory<T>`抽象类或者`AbstractNameValueGatewayFilterFactory`

整个体系结构为：

![在这里插入图片描述][2f60d8d20f064c5eb08c63be71532b9e.png]

这两个抽象类的区别就是前者接收一个参数（像StripPrefix和我们创建的这种），后者接收两个参数（像AddResponseHeader）

代码的编写可以参考：`StripPrefixGatewayFilterFactory` 和 `AddRequestHeaderGatewayFilterFactory`

**过滤器工厂默认命名规则必须按照"名称"+GatewayFilterFactory\`，如上StripPrefixGatewayFilterFactory的过滤器名称为StripPrefix**

**2.1、继承`AbstractGatewayFilterFactory`**

需求：

在网关中统一支付方式，编写一个过滤器：`PayMethodGatewayFilterFactory`，

1、编写过滤器

@Slf4j
    @Component //一定要将其交给spring容器管理
    public class PayMethodGatewayFilterFactory extends AbstractGatewayFilterFactory<PayMethodGatewayFilterFactory.Config> {
        
    
        public PayMethodGatewayFilterFactory() {
        
            super(Config.class);
        }
    
        @Override
        public GatewayFilter apply(Config config) {
        
            return (exchange, chain) -> {
        
                String paymethod = config.getPayMethod();
                String msg = config.getMsg();
                log.info("PayMethodGatewayFilterFactory 加载到的配置信息为:{}---{}",paymethod,msg);
                //将paymethod添加到请求头中
                exchange.getRequest().mutate().header("paymethod",paymethod);
                return chain.filter(exchange);
            };
        }
    
        @Override
        public List<String> shortcutFieldOrder() {
        
            return  Arrays.asList("payMethod","msg");//指定从yml中提前出来的配置信息填充到配置类中哪个属性,按规则配置
        }
    
        @Override
        public ShortcutType shortcutType() {
        
            return ShortcutType.DEFAULT;//默认规则
        }
    
        /**
         * 加载从yml中提取出来的配置信息
         */
        @Data
        public static class Config {
        
            private String payMethod;
            private String msg;
        }
    }

2、配置文件中使用如下：

再次测试，查看hailtaxi-driver 服务接收到请求后是否多了`paymethod`请求头信息

**2.2、继承`AbstractNameValueGatewayFilterFactory`**

直接查看`AddRequestHeaderGatewayFilterFactory`源码，分析即可！

#### 2.3.4 自定义GlobalFilter ####

定义全局过滤器需要实现GlobalFilter,Ordered接口：

GlobalFilter:过滤器拦截处理方法
    Ordered:过滤器也有多个，这里主要定义过滤器执行顺序，里面有个方法getOrder()会返回过滤器执行顺序，返回值越小，越靠前执行

**需求**：

我们创建全局过滤器并完成常见业务用户权限校验，如果请求中有带有一个名字为`token`的请求参数，则认为请求有效放行，如果没有则拦截提示授权无效。

创建全局过滤器：`com.itheima.filter.RouterFilter`，代码如下：

@Component
    public class RouterFilter implements GlobalFilter,Ordered {
        
    
        /***
         * 路由拦截
         * @param exchange
         * @param chain
         * @return
         */
        @Override
        public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        
            log.info("RouterFilter----------------");
            //获取请求参数
            String token = exchange.getRequest().getQueryParams().getFirst("token");
            //如果token为空，则表示没有登录
            if(StringUtils.isEmpty(token)){
        
                //没登录,状态设置403
                exchange.getResponse().setStatusCode(HttpStatus.PAYLOAD_TOO_LARGE);
                //结束请求
                return exchange.getResponse().setComplete();
            }
            //放行
            return chain.filter(exchange);
        }
    
        /***
         * 拦截器顺序
         * @return
         */
        @Override
        public int getOrder() {
        
            return 0;
        }
    }

此时请求，我们不携带token参数，效果如下：

![在这里插入图片描述][ce53eb92c1a14a8ea66ecf53a34009e6.png]

我们携带token参数则可以正常访问，效果如下：

![在这里插入图片描述][5087b537ef6f4a57bd6fde9f44a75516.png]

### 2.4 跨域配置 ###

出于浏览器的同源策略限制。同源策略（Sameoriginpolicy）是一种约定，它是浏览器最核心也最基本的安全功能，如果缺少了同源策略，则浏览器的正常功能可能都会受到影响。可以说Web是构建在同源策略基础之上的，浏览器只是针对同源策略的一种实现。同源策略会阻止一个域的javascript脚本和另外一个域的内容进行交互。所谓同源（即指在同一个域）就是两个页面具有相同的协议（protocol），主机（host）和端口号（port）。

在Spring Cloud Gateway中配置跨域是非常简单的，如下面`application.yml`所示：

gateway:
          globalcors:
            corsConfigurations:
              '[/**]':
                allowedOrigins: "*"
                allowedMethods:
                  - GET
                  - POST
                  - PUT

另外一种写法就需要创建`CorsWebFilter`过滤器，代码如下：

/**
     * 配置跨域
     * @return
     */
    @Bean
    public CorsWebFilter corsFilter() {
        
        CorsConfiguration config = new CorsConfiguration();
        // cookie跨域
        config.setAllowCredentials(Boolean.TRUE);
        config.addAllowedMethod("*");
        config.addAllowedOrigin("*");
        config.addAllowedHeader("*");
        // 配置前端js允许访问的自定义响应头
        config.addExposedHeader("Authorization");
    
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource(new PathPatternParser());
        source.registerCorsConfiguration("/**", config);
        return new CorsWebFilter(source);
    }

### 2.5 限流 ###

网关可以做很多的事情，比如，限流，当我们的系统 被频繁的请求的时候，就有可能 将系统压垮，所以 为了解决这个问题，需要在每一个微服务中做限流操作，但是如果有了网关，那么就可以在网关系统做限流，因为所有的请求都需要先通过网关系统才能路由到微服务中。

#### 2.5.1 令牌桶算法讲解 ####

![在这里插入图片描述][3c1fccc22aeb4fc2ace1eed0e2bd8955.png]

令牌桶算法是常见的限流算法之一，我们讲解一下漏桶算法：

1）所有的请求在处理之前都需要拿到一个可用的令牌才会被处理；
    2）根据限流大小，设置按照一定的速率往桶里添加令牌；
    3）桶设置最大的放置令牌限制，当桶满时、新添加的令牌就被丢弃或者拒绝；
    4）请求达到后首先要获取令牌桶中的令牌，拿着令牌才可以进行其他的业务逻辑，处理完业务逻辑之后，将令牌直接删除；
    5）令牌桶有最低限额，当桶中的令牌达到最低限额的时候，请求处理完之后将不会删除令牌，以此保证足够的限流

令牌桶算法的实现，有很多技术，Guaua是其中之一，redis客户端也有其实现。

#### 2.5.2 限流案例 ####

spring cloud gateway 默认使用redis的RateLimter限流算法来实现，外面来简要实现一下：

1、引入依赖

首先需要引入redis的依赖：

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
        <version>2.2.1.RELEASE</version>
    </dependency>

同时不要忘记Redis配置：

redis:
        host: 127.0.0.1
        port: 6379

2、定义KeyResolver

在Application引导类中添加如下代码，KeyResolver用于计算某一个类型的限流的KEY也就是说，可以通过KeyResolver来指定限流的Key。

我们可以根据IP来限流，比如每个IP每秒钟只能请求一次，在GatewayApplication定义key的获取，获取客户端IP，将IP作为key，如下代码：

/***
     * IP限流
     * @return
     */
    @Bean(name="ipKeyResolver")
    public KeyResolver userKeyResolver() {
        
        return new KeyResolver() {
        
            @Override
            public Mono<String> resolve(ServerWebExchange exchange) {
        
                //获取远程客户端IP
                String hostName = exchange.getRequest().getRemoteAddress().getAddress().getHostAddress();
                System.out.println("hostName:"+hostName);
                return Mono.just(hostName);
            }
        };
    }

在路由中配置如下：

gateway:
          #路由配置
          routes:
            #唯一标识符
            - id: hailtaxi-driver
              uri: lb://hailtaxi-driver
              #路由断言
              predicates:
                - Path=/driver/**
                - Cookie=username,itheima
                - Header=token,^(?!\d+$)[\da-zA-Z]+$
                - Method=GET,POST
                - Token=Authorization
              filters:
                - PayMethod=alipay,业务整合
                - name: RequestRateLimiter #请求数限流 名字不能随便写 ，使用默认的facatory
                  args:
                    key-resolver: "#{@ipKeyResolver}"
                    redis-rate-limiter.replenishRate: 1
                    redis-rate-limiter.burstCapacity: 1

参数说明：

redis-rate-limiter.replenishRate是您希望允许用户每秒执行多少请求，而不会丢弃任何请求。这是令牌桶填充的速率
    redis-rate-limiter.burstCapacity是指令牌桶的容量，允许在一秒钟内完成的最大请求数,将此值设置为零将阻止所有请求。
    key-resolver: “#{@ipKeyResolver}” 用于通过SPEL表达式来指定使用哪一个KeyResolver.

如上配置： 表示 一秒内，允许 一个请求通过，令牌桶的填充速率也是一秒钟添加一个令牌。 最大突发状况 也只允许 一秒内有一次请求，可以根据业务来调整 。

我们请求`http://localhost:8001/driver/info/1?token=aa`执行测试，效果如下：

![在这里插入图片描述][5323d24e769d4437b5724f7f5ed06876.png]

[ae85f285b97c467cabeaa4a6a6233574.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/87288ba8e6854637b9d871689c55277c.png
[632bee5f312b4d0eb6b10ef1bd4bfeda.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/609029650dde49619e1ef350a993af9a.png
[64b00ad594e14d43a89cd677b71a4ee6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/3e44175934614073bbc6a3ec7bcfe811.png
[1056d1e82c074e588b84ecb1af73b3dc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/23aecc6c62f84333aa23113cce77b24a.png
[117ea1102fbd46c3a719ea64c03b453e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/53477509038e4832878594d76c6fef20.png
[4871674eefb843dabf006d86e74f6a81.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/93dd75cc811c4d47ac3bbc6869eb7aa9.png
[9414f2fca4024880b0464c5e8702cdb9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/ead0058013a74c87ae44d97e36f32b4d.png
[ea9a2778d68844d08011ba4faf1ca408.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/4f0c71349261489e960abf4dad1c9e47.png
[d520568aace842b9b8a9bcaab2a0fc62.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/7adabc6703164667945d6a7a1a674a8a.png
[ba96651205ae49babfd270af76bee907.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/1126332ec1084bf68119dce66ccbbe37.png
[959f520c2add420bbea3b461a466125a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/27f1b6a352f9440286f7dde612437da7.png
[34dcae7f91e24a26afb268521e654073.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/ddba4937663f4202a936be6cfcb4297d.png
[75999dde7864483db288978bde43d5d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/84706372db4e44b8a44654725b732956.png
[4062bb07e18b434bbbaee8f7304c8230.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/6e678e6e61e14389b0fb3a02fa7523e6.png
[962901aeea324f9a8f47389abee3edbb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/b57d36bbc65b4d848e1006d8374711b9.png
[8ea4b2e57b1a41a4ab9cebafb1560b72.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/8b3801a1e665480eae9cf5284308b641.png
[cc30c5ebaba04081a10c2d691bc6f4a5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/641d85bdc87d4f44ac5c094745854658.png
[fb6be11c09ea4ef892b2df7696f8eddc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/4ab11e458f714da988624e1e1badda67.png
[2f60d8d20f064c5eb08c63be71532b9e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/1ec067260ec246b49f7e485f8692bc61.png
[ce53eb92c1a14a8ea66ecf53a34009e6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/9f46c7137c1c4c2c9d3a84559c0136ff.png
[5087b537ef6f4a57bd6fde9f44a75516.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/6e8b2dc5939a4657ba5c493c99e5b370.png
[3c1fccc22aeb4fc2ace1eed0e2bd8955.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/9be97e178d594fea9a1de6358d71a416.png
[5323d24e769d4437b5724f7f5ed06876.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/17/a164ef7493244c69bb9812a67a010cbe.png