SpringCloud-Gateway之RoutePredicateFactory

Bertha 。 2022-12-18 03:58 188阅读 0赞

转载自：https://blog.csdn.net/weixin\_44100910/article/details/106439122

### 前言： ###

本篇介绍SpringCloud的网关模块的RoutePredicateFactory，通过提供的RoutePredicateFactory来实现配置不同的路由规则。目前支持12种RoutePredicateFactory，简介如下：

*  QueryRoutePredicateFactory：根据query参数路由
 *  PathRoutePredicateFactory：根据Path路由
 *  AfterRoutePredicateFactory：根据请求的时间路由，在指定时间之后
 *  BeforeRoutePredicateFactory：根据请求的时间路由，在指定时间之前
 *  BetweenRoutePredicateFactory：根据请求的时间路由，在指定时间范围内
 *  CookieRoutePredicateFactory：根据请求头中的Cookie路由
 *  HeaderRoutePredicateFactory：根据请求头中的值路由
 *  HostRoutePredicateFactory：根据请求头中的Host路由
 *  MethodRoutePredicateFactory：根据请求Method路由
 *  RemoteAddrRoutePredicateFactory：根据请求的远程IP路由
 *  WeightRoutePredicateFactory：根据权重路由
 *  ReadBodyPredicateFactory ：暂未官方文档说明

### 1、QueryRoutePredicateFactory ###

根据查询的参数路由，配置关键词：**Query**，示例如下：

spring: 
        cloud: 
        gateway: 
        routes: 
        - id: query_hello # 自定义的路由ID 
        uri: forward:/hello # 跳转的路径，这里forward协议是跳转到当前的服务的API 
        predicates: 
        - Query=q, hello # 路由规则，根据查询条件，需要满足{url}?q=hello

*  Query=\{key\}：只需要满足query参数中存在key即可
 *  Query=\{key\}, \{value\}，需要满足query的参数中存在key的参数值必须为value
 *  其中，key不支持正则表达式，value支持正则表达式

**源码：**

public boolean test(ServerWebExchange exchange) { 
        //如果没有配置{value}，则只需要判断{key}是否存在即可 
        if (!StringUtils.hasText(config.regexp)) { 
        return exchange.getRequest().getQueryParams() 
        .containsKey(config.param); 
        } 
        //校验{value}是否匹配 
        List<String> values = exchange.getRequest().getQueryParams() 
        .get(config.param); 
        if (values == null) { 
        return false; 
        } 
        for (String value : values) { 
        if (value != null && value.matches(config.regexp)) { 
        return true; 
        } 
        } 
        return false; 
        }

### 2、PathRoutePredicateFactory ###

根据请求Path路由，配置关键词：**Path**，示例如下：

spring: 
        cloud: 
        gateway: 
        routes: 
        - id: path_baidu 
        uri: https: //www.baidu.com 
        predicates: 
        - Path=/baidu 
        - id: path_var 
        uri: forward:/hello? var={ziya} 
        predicates: 
        - Path=/ var/{ziya} 
        filters: 
        - AddRequestParameter=ziya, zy-{ziya} # 在AddRequestParameter Filter中引用URI模板变量：ziya 
        - id: path_regex 
        uri: forward:/hello 
        predicates: 
        - Path=/regex /**

支持的配置格式：

*  Path=/baidu：固定路径
 *  Path=/var/\{ziya\}：支持定义URL模板变量，该变量可以在自定义的GatewayFilter中使用，也可以结合springcloud-gateway自带的GatewayFilter使用，在配置文件中使用该变量

//在自定义的GatewayFilter中读取URL模板变量：hello 
        String value = ServerWebExchangeUtils.getUriTemplateVariables(exchange).get( "hello");

*  Path=/regex/\*\*：支持模糊匹配的路径，该配置将/regex下的所有请求转到指定的uri。

**源码：**

//根据配置的路径创建Pattern 
        synchronized ( this.pathPatternParser) { 
        pathPatternParser.setMatchOptionalTrailingSeparator( 
        config.isMatchOptionalTrailingSeparator()); 
        config.getPatterns().forEach(pattern -> { 
        PathPattern pathPattern = this.pathPatternParser.parse(pattern); 
        pathPatterns.add(pathPattern); 
        }); 
        } 
        
        public boolean test(ServerWebExchange exchange) { 
        //获得Path 
        PathContainer path = parsePath( 
        exchange.getRequest().getURI().getRawPath()); 
        //用编译好的Patterns来匹配Path 
        Optional<PathPattern> optionalPathPattern = pathPatterns.stream() 
        .filter(pattern -> pattern.matches(path)).findFirst(); 
        
        //如果匹配到，将URI中的模板参数提取出来，放到Exchange中 
        if (optionalPathPattern.isPresent()) { 
        PathPattern pathPattern = optionalPathPattern.get(); 
        traceMatch( "Pattern", pathPattern.getPatternString(), path, true); 
        PathMatchInfo pathMatchInfo = pathPattern.matchAndExtract(path); 
        putUriTemplateVariables(exchange, pathMatchInfo.getUriVariables()); 
        return true; 
        } 
        else { 
        traceMatch( "Pattern", config.getPatterns(), path, false); 
        return false; 
        } 
        }

### 3、AfterRoutePredicateFactory ###

根据请求时间路由，配置关键词：**After**，示例如下：

spring: 
        cloud: 
        gateway: 
        routes: 
        - id: after_world 
        uri: forward:/world 
        predicates: 
        - After= 2020- 05- 28T22: 10: 00. 000+ 08: 00[Asia/Shanghai] 
        - id: after_baidu 
        uri: https: //www.baidu.com 
        predicates: 
        - After= 2020- 05- 28T22: 00: 00. 000+ 08: 00[Asia/Shanghai]

当请求的时间在指定时间之后，就会将请求路由到指定的uri上

注意：

*  如果有多个满足条件的after配置，则会路由到第一个uri。
 *  参数格式，满足ZonedDateTime格式，

如：2020-05-28T22:00:00.000+08:00\[Asia/Shanghai\]

**源码：**

public boolean test(ServerWebExchange serverWebExchange) { 
        final ZonedDateTime now = ZonedDateTime.now(); 
        return now.isAfter(config.getDatetime()); 
        }

### 4、BeforeRoutePredicateFactory ###

根据请求时间路由，配置关键词：**Before**，示例如下：

spring: 
        cloud: 
        gateway: 
        routes: 
        - id: before_hello 
        uri: forward:/hello 
        predicates: 
        - Before= 2020- 05- 29T22: 01: 00. 000+ 08: 00[Asia/Shanghai] 
        - id: before_world 
        uri: forward:/world 
        predicates: 
        - Before= 2020- 05- 29T22: 00: 00. 000+ 08: 00[Asia/Shanghai]

当请求的时间在指定时间之前，将会将请求路由到指定的uri上

注意(同after)：

*  如果有多个满足条件的before配置，则会路由到第一个uri。
 *  参数格式，满足ZonedDateTime格式，
    
    如：2020-05-28T22:00:00.000+08:00\[Asia/Shanghai\]

**源码：**

public boolean test(ServerWebExchange serverWebExchange) { 
        final ZonedDateTime now = ZonedDateTime.now(); 
        return now.isBefore(config.getDatetime()); 
        }

### 5、BetweenRoutePredicateFactory ###

根据请求时间路由，配置关键词：**Between**，示例如下：

spring: 
        cloud: 
        gateway: 
        routes: 
        - id: before_world 
        uri: forward:/world 
        predicates: 
        - Between= 2020- 05- 29T10: 00: 00. 000+ 08: 00[Asia/Shanghai], 2020- 05- 29T11: 00: 00. 000+ 08: 00[Asia/Shanghai] 
        - id: before_hello 
        uri: forward:/hello 
        predicates: 
        - Between= 2020- 05- 29T10: 40: 00. 000+ 08: 00[Asia/Shanghai], 2020- 05- 29T10: 55: 00. 000+ 08: 00[Asia/Shanghai]

当请求的时间在指定时间范围内，将会将请求路由到指定的uri上

注意(同after)：

*  如果有多个满足条件的between配置，则会路由到第一个uri。
 *  参数格式，满足ZonedDateTime格式，
    
    如：2020-05-28T22:00:00.000+08:00\[Asia/Shanghai\]
 *  如果同时存在：before，after，between配置，会路由到第一个满足条件的uri

**源码：**

public boolean test(ServerWebExchange serverWebExchange) { 
        final ZonedDateTime now = ZonedDateTime.now(); 
        return now.isAfter(config.getDatetime1()) 
        && now.isBefore(config.getDatetime2()); 
        }

### 6、CookieRoutePredicateFactory ###

根据请求头中的Cookie路由，配置关键词：**Cookie**，示例如下：

spring: 
        cloud: 
        gateway: 
        routes: 
        - id: cookie_hello2 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, cookie-regexp 
        predicates: 
        - Cookie=X-key, v.* 
        - id: cookie_hello 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, cookie-no-value 
        predicates: 
        - Cookie=X-key, value

当请求中存在X-key=value的Cookie，则将请求路由到指定的uri，如果有多个满足，则路由到第一个匹配的URI。匹配规则如下：

*  Cookie=X-key, value：指定Cookie的值
 *  Cookie=X-key, v.\*：正则表达式匹配Cookie的值

**源码：**

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; 
        }

### 7、HeaderRoutePredicateFactory ###

根据请求头中的值路由，配置关键词：**Header**，示例如下：

spring: 
        cloud: 
        gateway: 
        routes: 
        - id: header_hello2 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, header-value-zy 
        predicates: 
        - Header=X-zy, v-zy 
        - id: header_hello1 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, header-no-value 
        predicates: 
        - Header=X-zy

当请求中存在X-key=value的Header，则将请求路由到指定的uri，如果有多个满足，则路由到第一个匹配的URI。配置Value时，支持正则表达式。

注意：如果需要按先匹配指定值优先，然后再匹配Header名，则需要将指定Header值的路由配置在前面。

**  源码：**

//是否配置了Header值 
        boolean hasRegex = !StringUtils.isEmpty(config.regexp); 
        
        public boolean test(ServerWebExchange exchange) { 
        List<String> values = exchange.getRequest().getHeaders() 
        .getOrDefault(config.header, Collections.emptyList()); 
        //如果不存在指定的Header名，返回不匹配 
        if (values.isEmpty()) { 
        return false; 
        } 
        //如果指定了Header值 
        if (hasRegex) { 
        // 通过正则表达式匹配 
        return values.stream() 
        .anyMatch(value -> value.matches(config.regexp)); 
        } 
        //如果配置的时没有指定Header值，则不用判断值，直接匹配 
        return true; 
        }

**8、HostRoutePredicateFactory**

根据请求头中的Host路由，配置关键词：**Host**，示例如下

spring: 
        cloud: 
        gateway: 
        routes: 
        - id: host-hello-dev 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, dev 
        predicates: 
        - Host=dev.wx.com 
        - id: host-hello-multi 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, multi 
        predicates: 
        - Host=dev.wx.com, qa.wx.com 
        - id: host-hello-multi- var 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, {env} 
        predicates: 
        - Host={env}.wx.com, {env}.bd.com 
        - id: host-hello-star 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, env-star 
        predicates: 
        - Host=**.wx.com 
        - id: host-hello-env 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, env-{env} 
        predicates: 
        - Host={env}.wx.com

根据请求头中的Host属性来匹配，如果能匹配到，则将请求路由到指定URI上，如果配置了多个Host，则路由到第一个匹配。匹配规则如下：

*  Host=dev.wx.com：根据固定的Host值匹配
 *  Host=\*\*.wx.com：根据通配符匹配
 *  Host=\{env\}.wx.com：和通配符效果相同，区别是：可以在自定义的GatewayFilter中通过API获取URI模板变量或者通过配置springcloud-gateway提供的GatewayFilter时引用URI模板变量。
 *  Host=dev.wx.com, qa.wx.com：可以配置多个Host来进行匹配

URI模板变量的使用方式：

//通过API获取 
        ServerWebExchangeUtils.getUriTemplateVariables(exchange).get( "env"); 
        //配置文件中配置 
        filter: 
        - AddRequestParameter= var, env-{env}

**源码：**

public boolean test(ServerWebExchange exchange) { 
        //取Header中的第一个host 
        String host = exchange.getRequest().getHeaders().getFirst( "Host"); 
        //如果配置了多个pattern，查找第一个匹配的pattern 
        Optional<String> optionalPattern = config.getPatterns().stream() 
        .filter(pattern -> pathMatcher.match(pattern, host)).findFirst(); 
        
        if (optionalPattern.isPresent()) { 
        //将URI中的模板变量添加到exchange中，供其他GatewayFilter使用 
        Map<String, String> variables = pathMatcher 
        .extractUriTemplateVariables(optionalPattern.get(), host); 
        ServerWebExchangeUtils.putUriTemplateVariables(exchange, variables); 
        return true; 
        } 
        
        return false; 
        }

**注意：**

*  通过源码发现，要注意的是获取Header中的第一个Host，如果通过代理添加了多个Host，其他的会被忽略。
 *  如果配置：Host=dev.wx.com, \{env\}.bd.com，而其他地方引用了\{env\}这个模板变量，当通过dev.wx.com访问时，就会出现500错误，无法获取\{env\}变量。

### 9、MethodRoutePredicateFactory ###

根据请求Method路由，配置关键词：**Method**，示例如下

spring: 
        cloud: 
        gateway: 
        routes: 
        - id: method-post 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, post 
        predicates: 
        - Method=post 
        - id: method-get 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, get 
        predicates: 
        - Method=get, post

根据请求的Method进行匹配，如果能匹配到，则将请求路由到指定URI上；支持指定多个Method；配置的method不区分大小写；如果有多个匹配的Method，则路由到匹配到的第一个URI。

**源码：**

public boolean test(ServerWebExchange exchange) { 
        HttpMethod requestMethod = exchange.getRequest().getMethod(); 
        return stream(config.getMethods()) 
        .anyMatch(httpMethod -> httpMethod == requestMethod); 
        }

### **10、RemoteAddrRoutePredicateFactory** ###

根据请求的远程IP路由，配置关键词：**RemoteAddr**，示例如下

spring: 
        cloud: 
        gateway: 
        routes: 
        - id: remote-addr1 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, addr1 
        predicates: 
        - RemoteAddr= 192.168. 0.100/ 24 
        - id: method-addr2 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, addr2 
        predicates: 
        - RemoteAddr= 192.168. 0.100 
        - id: method-addr3 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, addr2 
        predicates: 
        - RemoteAddr= 192.168. 0.100, 192.168. 0.101, 192.168. 0.102

根据请求的远程IP进行匹配，如果能匹配到，则将请求路由到指定URI上；配置规则如下：

*  指定一个固定的IP
 *  指定多个IP，用逗号隔开
 *  如果配置的IP没有指定子网掩码（\{ip\}/\{子网掩码\}），则默认32（255.255.255.255）

**源码：**

public boolean test(ServerWebExchange exchange) { 
        InetSocketAddress remoteAddress = config.remoteAddressResolver 
        .resolve(exchange); 
        if (remoteAddress != null && remoteAddress.getAddress() != null) { 
        String hostAddress = remoteAddress.getAddress().getHostAddress(); 
        String host = exchange.getRequest().getURI().getHost(); 
        
        for (IpSubnetFilterRule source : sources) { 
        if (source.matches(remoteAddress)) { 
        return true; 
        } 
        } 
        } 
        return false; 
        }

### **11、WeightRoutePredicateFactory** ###

根据权重路由，配置关键词：**Weight**，示例如下：

spring: 
        cloud: 
        gateway: 
        routes: 
        - id: weight-high 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, high 
        predicates: 
        - Weight=group1, 15 
        - Path=/weight 
        - id: method-low 
        uri: forward:/hello 
        filters: 
        - AddRequestParameter= var, low 
        predicates: 
        - Weight=group1, 5 
        - Path=/weight

根据配置的权重来路由，配置权重时需要指定分组，即Weight属性的第一个参数，为分组名，不同group单独计算权重，所以可以配置多个组。权重值为第二个参数，同一组里的权重值的总和 没有要求，最终计算会转换成小于1的double类型。

** 源码：**

*  **WeightCalculatorWebFilter**

//项目启动时执行，解析配置的权重，并将整型的权重转换成小于1的double权重，按照从小到大的顺序放入到List中。 
        //将最终解析的结果存储在变量groupWeights中 
        void addWeightConfig(WeightConfig weightConfig) { 
          String group = weightConfig.getGroup(); 
        GroupWeightConfig config; 
        if (groupWeights.containsKey(group)) { 
        config = new GroupWeightConfig(groupWeights.get(group)); 
        } else { 
        config = new GroupWeightConfig(group); 
        } 
        config.weights.put(weightConfig.getRouteId(), weightConfig.getWeight()); 
        //将权重的int类型转换成double类型 
        int weightsSum = 0; 
        for (Integer weight : config.weights.values()) { 
        weightsSum += weight; 
        } 
        
        final AtomicInteger index = new AtomicInteger( 0); 
        for (Map.Entry<String, Integer> entry : config.weights.entrySet()) { 
        String routeId = entry.getKey(); 
        Integer weight = entry.getValue(); 
        Double nomalizedWeight = weight / ( double) weightsSum; 
        config.normalizedWeights.put(routeId, nomalizedWeight); 
        config.rangeIndexes.put(index.getAndIncrement(), routeId); 
        } 
        
        config.ranges.clear() 
        config.ranges.add( 0.0); 
        
        List<Double> values = new ArrayList<>(config.normalizedWeights.values()); 
        for ( int i = 0; i < values.size(); i++) { 
        Double currentWeight = values.get(i); 
        Double previousRange = config.ranges.get(i); 
        Double range = previousRange + currentWeight; 
        config.ranges.add(range); 
        } 
        // only update after all calculations 
        groupWeights.put(group, config); 
        } 
        
        //当接收到请求时执行，从变量groupWeights中读取配置，根据生成的随机值，选择routeId， 
        //再放入到ServerWebExchange的Attributes中，key为：{pre}.routeWeight 
        public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) { 
        Map<String, String> weights = getWeights(exchange); 
        for (String group : groupWeights.keySet()) { 
        GroupWeightConfig config = groupWeights.get(group); 
        if (config == null) { 
        continue; // nothing we can do, but this is odd 
        } 
        //生成随机变量 
        double r = this.random.nextDouble(); 
        List<Double> ranges = config.ranges; 
        //根据随机值选择RouteId 
        for ( int i = 0; i < ranges.size() - 1; i++) { 
        if (r >= ranges.get(i) && r < ranges.get(i + 1)) { 
        String routeId = config.rangeIndexes.get(i); 
        weights.put(group, routeId); 
        break; 
        } 
        } 
        } 
        return chain.filter(exchange); 
        }

*  **WeightRoutePredicateFactory**

//从ServerWebExchange中读取{pre}.routeWeight属性，该属性读取到的就是根据权重计算的routeId 
        public boolean test(ServerWebExchange exchange) { 
        Map<String, String> weights = exchange.getAttributeOrDefault(WEIGHT_ATTR, 
        Collections.emptyMap()); 
        //该值是在RoutePredicateHandlerMapping的lookupRoute方法中，遍历所有配置的路由 
        //每次遍历，将值放入到GATEWAY_PREDICATE_ROUTE_ATTR属性中，有所有的RoutePredicateFactory来执行 
        String routeId = exchange.getAttribute(GATEWAY_PREDICATE_ROUTE_ATTR); 
        String group = config.getGroup(); 
        if (weights.containsKey(group)) { 
        String chosenRoute = weights.get(group); 
        return routeId.equals(chosenRoute); 
        } 
        return false; 
        }

### **12、ReadBodyPredicateFactory** ###

*  缓存请求体，这样可以在后续多次读取请求体
 *  该Predicate在官方文档上没有说明。
 *  参考网上资料：
    
    https://www.cnblogs.com/hyf-huangyongfei/p/12849406.html

### **最后：** ###

*  不同的Predicate可以组合配置，但是需要同时满足才匹配成功。
 *  如果一个请求能满足多个配置，则请求会被转发到第一个匹配的URI。