小白学习spring-cloud(七)：spring-cloud-gateway的内置predicate

耗子会飞
184 阅读5分钟

spring-cloud-gateway核心概念：

核心概念描述
Route（路由）网关最基本的模块。它由一个 ID、一个目标 URI、一组断言（Predicate）和一组过滤器（Filter）组成。
Predicate（断言）路由转发的判断条件，我们可以通过 Predicate 对 HTTP 请求进行匹配，例如请求方式、请求路径、请求头、参数等，如果请求与断言匹配成功，则将请求转发到相应的服务。
Filter（过滤器）过滤器，我们可以使用它对请求进行拦截和修改，还可以使用它对上文的响应进行再处理。

注意：其中 Route 和 Predicate 必须同时声明。

Predicate

After

  • After表示路由在指定时间之后才生效
  • 配置文件，注意时间字符串的格式，+08:00表示东八区： 
    spring:
  cloud:
    gateway:
      routes:
      - id: after_route
        uri: http://127.0.0.1:8082
        predicates:
        - After=2021-08-16T07:36:00.000+08:00[Asia/Shanghai]
  • 动态路由的JSON格式，注意args参数要用datetime： 
    [
    {
        "id": "after_route",
        "uri": "http://127.0.0.1:8082",
        "predicates":[
            {
                "name": "After",
                "args": {
                    "datetime": "2021-08-16T07:36:00.000+08:00[Asia/Shanghai]"
                }
            }
        ]
    }
]

Before

  • Before表示路由在指定时间之前才生效
  • 配置文件： 
    spring:
  cloud:
    gateway:
      routes:
      - id: before_route
        uri: http://127.0.0.1:8082
        predicates:
        - Before=2021-08-16T07:36:00.000+08:00[Asia/Shanghai]
  • 动态路由的JSON格式，注意args参数要用datetime：
[
    {
        "id": "before_route",
        "uri": "http://127.0.0.1:8082",
        "predicates":[
            {
                "name": "Before",
                "args": {
                    "datetime": "2021-08-16T07:36:00.000+08:00[Asia/Shanghai]"
                }
            }
        ]
    }
]

Between

  • Between表示路由在指定时间段之内才生效，既然是时间段就是两个参数，注意它们的写法
  • 配置文件： 
    spring:
  application:
    name: gateway
  cloud:
    gateway:
      routes:
        - id: between_route
          uri: http://127.0.0.1:8082
          predicates:
            - Between=2021-08-16T07:36:00.000+08:00[Asia/Shanghai], 2021-08-16T08:15:00.000+08:00[Asia/Shanghai]
  • 动态路由的JSON格式，注意args参数，起始时间是datetime1，结束时间是datetime2： 
    [
    {
        "id": "path_route_addr",
        "uri": "http://127.0.0.1:8082",
        "predicates":[
            {
                "name": "Between",
                "args": {
                    "datetime1": "2021-08-16T07:36:00.000+08:00[Asia/Shanghai]",
                    "datetime2": "2021-08-16T08:18:00.000+08:00[Asia/Shanghai]"
                }
            }
        ]
    }
]

Cookie

  • Cookie表示cookie存在指定名称，并且对应的值符合指定正则表达式，才算匹配成功
  • 配置文件： 
    spring:
  cloud:
    gateway:
      routes:
      - id: cookie_route
        uri: https://example.org
        predicates:
        - Cookie=chocolate, ch.p
  • 动态路由的JSON格式，注意args参数： 
    [
    {
        "id": "cookie_route",
        "uri": "http://127.0.0.1:8082",
        "predicates":[
            {
                "name": "Cookie",
                "args": {
                        "name": "chocolate",
                    "regexp": "ch.p"
                }
            }
        ]
    }
]

Header

  • Header表示header存在指定名称，并且对应的值符合指定正则表达式，才算匹配成功
  • 下面的例子要求header中必须存在X-Request-Id，并且值一定要是数字
  • 配置文件： 
    spring:
  cloud:
    gateway:
      routes:
      - id: header_route
        uri: http://localhost:9001
        predicates:
        - Path: /nacos/**
        - Header=X-Request-Id, \d+
  • 动态路由的JSON格式，注意args参数是header和regexp，还要注意的是regexp的值里面有两个反斜杠（转义问题）： 
    [
  {
    "id": "path_route_provider",
    "uri": "http://127.0.0.1:9001",
    "order": 1,
    "predicates":[
      {
        "name": "Path",
        "args": {
          "pattern": "/nacos/**"
        }
      },
      {
        "name": "Header",
        "args": {
          "header": "X-Request-Id",
          "regexp": "\d+"
        }
      }
    ]
  }
]
  • 用postman测试
    • 当请求头未携带X-Request-Id时，如下图： image.png
    • 当请求头携带X-Request-Id时，如下图： image.png

Host

  • Host表示请求的host要和指定的字符串匹配，并且对应的值符合指定正则表达式，才算匹配成功，可以同时指定多个host匹配表达式，下面的例子给了两个，其中第一个指定了端口：
  • 配置文件：
spring:
  cloud:
    gateway:
      routes:
      - id: host_route
        uri: http://127.0.0.1:9001
        predicates:
        - Host=test.com:8081,**.anotherhost.org
  • 动态路由的JSON格式，注意args参数，另外通过实测发现，这里regex的值是个正则表达式，因此上面配置文件中的多个host，在此处要通过正则表达式的写法实现（json数组的写法，在反序列化的时候总是出现异常，无法解析成功）：
[
    {
        "id": "header_route",
        "uri": "http://127.0.0.1:9001",
        "predicates":[
            {
                "name": "Path",
                "args": {
                  "pattern": "/nacos/**"
                }
            },
            {
                "name": "Host",
                "args": {
                    "regex": "test.com:8086"
                }
            }
        ]
    }
]

Method

  • Method非常好理解，匹配指定的方法类型（可以有多个）
  • 配置文件：
spring:
  cloud:
    gateway:
      routes:
      - id: method_route
        uri: http://127.0.0.1:9001
        predicates:
        - Method=GET,POST
  • 动态路由的JSON格式，同样，由于个人水平问题，暂时只实践出指定单个方法的JSON写法，如果你知道如何指定多个方法，还望告知，谢谢：
[
  {
    "id": "method_route",
    "uri": "http://127.0.0.1:9001",
    "predicates":[
      {
        "name": "Method",
        "args": {
          "methods": "GET"
        }
      }
    ]
  }
]

Path

  • Path很常用，匹配指定的方法类型（可以有多个）
  • 配置文件，注意{segment}，表示该位置的真实值可以被提取出来，在filter中可以使用，这在后续的filter文章中会有说明：
spring:
  cloud:
    gateway:
      routes:
      - id: path_route
        uri: http://127.0.0.1:9001
        predicates:
        - Path=/nacos/{segment},/consumer/{segment}
  • 动态路由的JSON格式:
[
    {
        "id": "path_route",
        "uri": "http://127.0.0.1:9001",
        "predicates":[
            {
                "name": "Path",
                "args": { 
                    "pattern": "/nacos/{segment}"
                }
            }
        ]
    }
]

Query

  • Query匹配的是请求中是否带有指定的参数，也能要求该参数等于指定的值（正则表达式）才被匹配上
  • 配置文件，只要带有名为name的请求参数就被匹配：
spring:
  cloud:
    gateway:
      routes:
      - id: query_route
        uri: http://127.0.0.1:9001
        predicates:
        - Query=name
  • 如下所示，还可以指定name参数的值必须aaa.，这个小数点表示匹配一个字符，例如name=aaa1或者name=aaa2都可以：
spring:
  cloud:
    gateway:
      routes:
      - id: query_route
        uri: http://127.0.0.1:9001
        predicates:
        - Query=name,aaa.
  • 动态路由的JSON格式，注意参数名和参数值分别用param和regexp来设置：
[
    {
      "id": "path_route_provider",
      "uri": "http://127.0.0.1:9001",
      "order": 1,
      "predicates":[
        {
          "name": "Path",
          "args": {
            "pattern": "/nacos/**"
          }
        },
        {
          "name": "Header",
          "args": {
            "header": "X-Request-Id",
            "regexp": "\d+"
          }
        },
        {
          "name": "Query",
          "args": {
            "param": "name",
            "regexp": "aaa."
          }
        }
      ]
    }
]
  • 测试如下：

image.png

RemoteAddr

  • RemoteAddr很好理解，匹配的指定来源的请求
  • 配置文件：
spring:
  cloud:
    gateway:
      routes:
      - id: remoteaddr_route
        uri: http://127.0.0.1:9001
        predicates:
        - RemoteAddr=192.168.50.134/24
  • 动态路由的JSON格式，注意参数名和参数值分别用param和regexp来设置：
[
  {
    "id": "path_route_provider",
    "uri": "http://127.0.0.1:9001",
    "order": 1,
    "predicates":[
      {
        "name": "Header",
        "args": {
          "header": "X-Request-Id",
          "regexp": "\d+"
        }
      },
      {
        "name": "Query",
        "args": {
          "param": "name",
          "regexp": "aaa."
        }
      },
      {
        "name": "RemoteAddr",
        "args": {
          "sources": "192.168.159.1/24" // 远程ip用的是本机的ip地址，/24固定的
        }
      }
    ]
  }
]
  • 测试如下，注意测试的时候主机地址不要用localhost和127.0.0.1，这样会导致服务端判断来源的时候取得的网卡地址为0.0.0.0：

image.png

Weight

  • Weight顾名思义，按照权重将请求分发到不同位置
  • 配置文件：
spring:
  cloud:
    gateway:
      routes:
      - id: weight_high
        uri: http://192.168.159.1:9001
        predicates:
        - Weight=group1, 8
      - id: weight_low
        uri: http://192.168.159.1:9001
        predicates:
        - Weight=group1, 2

以上就是常用的断言类型了，可见功能已经很强大了，希望能给您一些参考

avatar
文章
阅读
粉丝