Spring Cloud Gateway实战之四：内置predicate小结

悠悠 2022-09-05 00:20 13阅读 0赞

### 欢迎访问我的GitHub ###

> 这里分类和汇总了欣宸的全部原创(含配套源码)：[https://github.com/zq2599/blog\_demos][https_github.com_zq2599_blog_demos]

### 本篇概览 ###

*  本文是《Spring Cloud Gateway实战》系列的第四篇，咱们将已有的断言（predicate）的类型做个小结，今天的内容中，除了官方推荐的简化版配置，还给出了动态路由时该断言的JSON格式配置；

### 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: hello-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: https://example.org
            predicates:
            - Header=X-Request-Id, \d+

*  动态路由的JSON格式，注意args参数是header和regexp，还要注意的是regexp的值里面有两个反斜杠（转义问题）：

[
        { 
            "id": "header_route",
            "uri": "http://127.0.0.1:8082",
            "predicates":[
                { 
                    "name": "Header",
                    "args": { 
                        "header": "X-Request-Id",
                        "regexp": "\\d+"
                    }
                }
            ]
        }
    ]

用postman测试的参数填写和结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center]

### Host ###

*  Host表示请求的host要和指定的字符串匹配，并且对应的值符合指定正则表达式，才算匹配成功，可以同时指定多个host匹配表达式，下面的例子给了两个，其中第一个指定了端口：
 *  配置文件：

spring:
      cloud:
        gateway:
          routes:
          - id: host_route
            uri: http://127.0.0.1:8082
            predicates:
            - Host=test.com:8081,**.anotherhost.org

*  动态路由的JSON格式，注意args参数，另外通过实测发现，这里regex的值是个正则表达式，因此上面配置文件中的多个host，在此处要通过正则表达式的写法实现（json数组的写法，在反序列化的时候总是出现异常，无法解析成功）：

[
        { 
            "id": "header_route",
            "uri": "http://127.0.0.1:8082",
            "predicates":[
                { 
                    "name": "Host",
                    "args": { 
                        "regex": "test.com:8086"
                    }
                }
            ]
        }
    ]

### Method ###

*  Method非常好理解，匹配指定的方法类型（可以有多个）
 *  配置文件：

spring:
      cloud:
        gateway:
          routes:
          - id: method_route
            uri: http://127.0.0.1:8082
            predicates:
            - Method=GET,POST

*  动态路由的JSON格式，同样，由于个人水平问题，暂时只实践出指定单个方法的JSON写法，如果你知道如何指定过个方法，还望告知，谢谢：

[
        { 
            "id": "method_route",
            "uri": "http://127.0.0.1:8082",
            "predicates":[
                { 
                    "name": "Method",
                    "args": {  
                        "methods": "GET"
                    }
                }
            ]
        }
    ]

### Path ###

*  Path很常用，匹配指定的方法类型（可以有多个）
 *  配置文件，注意\{segment\}，表示该位置的真实值可以被提取出来，在filter中可以使用，这在后续的filter文章中会有说明：

spring:
      cloud:
        gateway:
          routes:
          - id: path_route
            uri: http://127.0.0.1:8082
            predicates:
            - Path=/hello/{ segment},/lbtest/{ segment}

*  动态路由的JSON格式，同样，由于个人水平问题，暂时只实践出指定单个方法的JSON写法，如果你知道如何指定过个方法，还望告知，谢谢：

[
        { 
            "id": "path_route",
            "uri": "http://127.0.0.1:8082",
            "predicates":[
                { 
                    "name": "Path",
                    "args": {  
                        "pattern": "/hello/{segment}"
                    }
                }
            ]
        }
    ]

### Query ###

*  Query匹配的是请求中是否带有指定的参数，也能要求该参数等于指定的值（正则表达式）才被匹配上
 *  配置文件，只要带有名为name的请求参数就被匹配：

spring:
      cloud:
        gateway:
          routes:
          - id: query_route
            uri: http://127.0.0.1:8082
            predicates:
            - Query=name

*  如下所示，还可以指定name参数的值必须aaa.，这个小数点表示匹配一个字符，例如name=aaa1或者name=aaa2都可以：

spring:
      cloud:
        gateway:
          routes:
          - id: query_route
            uri: http://127.0.0.1:8082
            predicates:
            - Query=name,aaa.

*  动态路由的JSON格式，注意参数名和参数值分别用param和regexp来设置：

[
        { 
            "id": "query_route",
            "uri": "http://127.0.0.1:8082",
            "predicates":[
                { 
                    "name": "Query",
                    "args": {  
                        "param": "name",
                        "regexp": "aaa."
                    }
                }
            ]
        }
    ]

*  测试如下：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70]

### RemoteAddr ###

*  RemoteAddr很好理解，匹配的指定来源的请求
 *  配置文件：

spring:
      cloud:
        gateway:
          routes:
          - id: remoteaddr_route
            uri: http://127.0.0.1:8082
            predicates:
            - RemoteAddr=192.168.50.134/24

*  动态路由的JSON格式，注意参数名和参数值分别用param和regexp来设置：

[
        { 
            "id": "remoteaddr_route",
            "uri": "http://127.0.0.1:8082",
            "predicates":[
                { 
                    "name": "RemoteAddr",
                    "args": {  
                        "sources": "192.168.50.134/24"
                    }
                }
            ]
        }
    ]

*  测试如下，注意测试的时候主机地址不要用localhost和127.0.0.1，这样会导致服务端判断来源的时候取得的网卡地址为0.0.0.0：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 1]

### Weight ###

*  Weight顾名思义，按照权重将请求分发到不同位置
 *  配置文件：

spring:
      cloud:
        gateway:
          routes:
          - id: weight_high
            uri: http://192.168.50.134:8082
            predicates:
            - Weight=group1, 8
          - id: weight_low
            uri: http://192.168.50.135:8082
            predicates:
            - Weight=group1, 2

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

### 你不孤单，欣宸原创一路相伴 ###

1.  [Java系列][Java]
2.  [Spring系列][Spring]
3.  [Docker系列][Docker]
4.  [kubernetes系列][kubernetes]
5.  [数据库+中间件系列][Link 1]
6.  [DevOps系列][DevOps]

[https_github.com_zq2599_blog_demos]: https://github.com/zq2599/blog_demos
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70_pic_center]: /images/20220829/8d67e3ffda984c00ba3721f5cc9262f2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70]: /images/20220829/040d5ad6bd594c159fbe4b0d1a29f00e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JvbGluZ19jYXZhbHJ5_size_16_color_FFFFFF_t_70 1]: /images/20220829/e0168b6ad09b4d8da773199c91fbbc8a.png
[Java]: https://xinchen.blog.csdn.net/article/details/105068742
[Spring]: https://xinchen.blog.csdn.net/article/details/105086498
[Docker]: https://xinchen.blog.csdn.net/article/details/105086732
[kubernetes]: https://xinchen.blog.csdn.net/article/details/105086794
[Link 1]: https://xinchen.blog.csdn.net/article/details/105086850
[DevOps]: https://xinchen.blog.csdn.net/article/details/105086920