Spring Cloud Gateway 源码剖析之Predicate谓词详解

男娘i 2022-10-22 04:14 263阅读 0赞

> 欢迎大家关注我的微信公众号【老周聊架构】，Java后端主流技术栈的原理、源码分析、架构以及各种互联网高并发、高性能、高可用的解决方案。

## 一、前言 ##

我们上一篇[Spring Cloud Gateway 源码剖析之Route数据模型][Spring Cloud Gateway _Route]中讲到了 Route 数据模型，其中有 Predicate 属性。  
![在这里插入图片描述][20210403191021185.png]  
这一篇我们就来讲一讲 Predicate 谓词相关源码。Predicate 对象是由 RoutePredicateFactory 工厂类创建，那我们就来看下 RoutePredicateFactory 是如何创建 Predicate 的。

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

## 二、RoutePredicateFactory ##

从上图可知

*  \#name() 默认方法，调用 NameUtils\#normalizePredicateName(Class) 方法，获得 RoutePredicateFactory 的名字。该方法截取类名前半段，例如 QueryRoutePredicateFactory 的结果为 Query 。
 *  \#apply() 接口方法，创建 Predicate 。

可以直接看到处理器类与相关谓词工厂类如下  
![在这里插入图片描述][20210403204001183.png]  
这里再对相关谓词工厂进行分类：

![在这里插入图片描述][20210403204353202.png]  
**2.1 AfterRoutePredicateFactory**

*  Route 匹配 ：请求时间满足在配置时间之后
 *  配置：
    
        spring:
          cloud:
            gateway:
              routes:
              - id: after_route
                uri: http://example.org
                predicates:
                - After=2017-01-20T17:42:47.789-07:00[America/Denver]
 *  代码：
    
        public Predicate<ServerWebExchange> apply(AfterRoutePredicateFactory.Config config) { 
            ZonedDateTime datetime = config.getDatetime();
            return (exchange) -> { 
                ZonedDateTime now = ZonedDateTime.now();
                return now.isAfter(datetime);
            };
        }

**2.2 BeforeRoutePredicateFactory**

*  Route 匹配 ：请求时间满足在配置时间之前
 *  配置：
    
        spring:
          cloud:
            gateway:
              routes:
              - id: before_route
                uri: http://example.org
                predicates:
                - Before=2017-01-20T17:42:47.789-07:00[America/Denver]
 *  代码：
    
        public Predicate<ServerWebExchange> apply(BeforeRoutePredicateFactory.Config config) { 
            ZonedDateTime datetime = config.getDatetime();
            return (exchange) -> { 
                ZonedDateTime now = ZonedDateTime.now();
                return now.isBefore(datetime);
            };
        }

**2.3 BetweenRoutePredicateFactory**

*  Route 匹配 ：请求时间满足在配置时间之间
 *  配置：
    
        spring:
          cloud:
            gateway:
              routes:
              - id: between_route
                uri: http://example.org
                predicates:
                - Betweeen=2017-01-20T17:42:47.789-07:00[America/Denver], 2017-01-21T17:42:47.789-07:00[America/Denver]
 *  代码：
    
        public Predicate<ServerWebExchange> apply(BetweenRoutePredicateFactory.Config config) { 
            ZonedDateTime datetime1 = config.datetime1;
            ZonedDateTime datetime2 = config.datetime2;
            Assert.isTrue(datetime1.isBefore(datetime2), config.datetime1 + " must be before " + config.datetime2);
            return (exchange) -> { 
                ZonedDateTime now = ZonedDateTime.now();
                return now.isAfter(datetime1) && now.isBefore(datetime2);
            };
        }

**2.4 CookieRoutePredicateFactory**

*  Route 匹配 ：请求指定 Cookie 正则匹配指定值。
 *  配置：
    
        spring:
          cloud:
            gateway:
              routes:
              - id: cookie_route
                uri: http://example.org
                predicates:
                - Cookie=chocolate, ch.p
 *  代码：
    
        public Predicate<ServerWebExchange> apply(CookieRoutePredicateFactory.Config config) { 
            return (exchange) -> { 
                List<HttpCookie> cookies = (List)exchange.getRequest().getCookies().get(config.name);
                if (cookies == null) { 
                    return false;
                } else { 
                    Iterator var3 = cookies.iterator();
        
                    HttpCookie cookie;
                    do { 
                        if (!var3.hasNext()) { 
                            return false;
                        }
        
                        cookie = (HttpCookie)var3.next();
                    } while(!cookie.getValue().matches(config.regexp));
        
                    return true;
                }
            };
        }

**2.5 HeaderRoutePredicateFactory**

*  Route 匹配 ：请求头满足匹配
 *  配置：
    
        spring:
          cloud:
            gateway:
              routes:
              - id: header_route
                uri: http://example.org
                predicates:
                - Header=X-Request-Id, \d+
 *  代码：
    
        public Predicate<ServerWebExchange> apply(HeaderRoutePredicateFactory.Config config) { 
            boolean hasRegex = !StringUtils.isEmpty(config.regexp);
            return (exchange) -> { 
                List<String> values = (List)exchange.getRequest().getHeaders().getOrDefault(config.header, Collections.emptyList());
                if (values.isEmpty()) { 
                    return false;
                } else { 
                    return hasRegex ? values.stream().anyMatch((value) -> { 
                        return value.matches(config.regexp);
                    }) : true;
                }
            };
        }

**2.6 HostRoutePredicateFactory**

*  Route 匹配 ：请求 Host 匹配指定值
 *  配置：
    
        spring:
          cloud:
            gateway:
              routes:
              - id: host_route
                uri: http://example.org
                predicates:
                - Host=**.somehost.org
 *  代码：
    
        public Predicate<ServerWebExchange> apply(HostRoutePredicateFactory.Config config) { 
            return (exchange) -> { 
                String host = exchange.getRequest().getHeaders().getFirst("Host");
                Optional<String> optionalPattern = config.getPatterns().stream().filter((pattern) -> { 
                    return this.pathMatcher.match(pattern, host);
                }).findFirst();
                if (optionalPattern.isPresent()) { 
                    Map<String, String> variables = this.pathMatcher.extractUriTemplateVariables((String)optionalPattern.get(), host);
                    ServerWebExchangeUtils.putUriTemplateVariables(exchange, variables);
                    return true;
                } else { 
                    return false;
                }
            };
        }

**2.7 MethodRoutePredicateFactory**

*  Route 匹配 ：请求 Method 匹配指定值
 *  配置：
    
        spring:
          cloud:
            gateway:
              routes:
              - id: method_route
                uri: http://example.org
                predicates:
                - Method=GET
 *  代码：
    
        public Predicate<ServerWebExchange> apply(MethodRoutePredicateFactory.Config config) { 
            return (exchange) -> { 
                HttpMethod requestMethod = exchange.getRequest().getMethod();
                return requestMethod == config.getMethod();
            };
        }

**2.8 PathRoutePredicateFactory**

*  Route 匹配 ：请求 Path 匹配指定值
 *  配置：
    
        spring:
          cloud:
            gateway:
              routes:
              - id: host_route
                uri: http://example.org
                predicates:
                - Path=/foo/{segment}
 *  代码：
    
        public Predicate<ServerWebExchange> apply(PathRoutePredicateFactory.Config config) { 
            ArrayList<PathPattern> pathPatterns = new ArrayList();
            synchronized(this.pathPatternParser) { 
                this.pathPatternParser.setMatchOptionalTrailingSeparator(config.isMatchOptionalTrailingSeparator());
                config.getPatterns().forEach((pattern) -> { 
                    PathPattern pathPattern = this.pathPatternParser.parse(pattern);
                    pathPatterns.add(pathPattern);
                });
            }
        
            return (exchange) -> { 
                PathContainer path = PathContainer.parsePath(exchange.getRequest().getURI().getPath());
                Optional<PathPattern> optionalPathPattern = pathPatterns.stream().filter((pattern) -> { 
                    return pattern.matches(path);
                }).findFirst();
                if (optionalPathPattern.isPresent()) { 
                    PathPattern pathPattern = (PathPattern)optionalPathPattern.get();
                    traceMatch("Pattern", pathPattern.getPatternString(), path, true);
                    PathMatchInfo pathMatchInfo = pathPattern.matchAndExtract(path);
                    ServerWebExchangeUtils.putUriTemplateVariables(exchange, pathMatchInfo.getUriVariables());
                    return true;
                } else { 
                    traceMatch("Pattern", config.getPatterns(), path, false);
                    return false;
                }
            };
        }

**2.9 QueryRoutePredicateFactory**

*  Route 匹配 ：请求 QueryParam 匹配指定值
 *  配置：
    
        spring:
          cloud:
            gateway:
              routes:
              - id: query_route
                uri: http://example.org
                predicates:
                - Query=baz
                - Query=foo, ba.
 *  代码：
    
        public Predicate<ServerWebExchange> apply(QueryRoutePredicateFactory.Config config) { 
            return (exchange) -> { 
                if (!StringUtils.hasText(config.regexp)) { 
                    return exchange.getRequest().getQueryParams().containsKey(config.param);
                } else { 
                    List<String> values = (List)exchange.getRequest().getQueryParams().get(config.param);
                    if (values == null) { 
                        return false;
                    } else { 
                        Iterator var3 = values.iterator();
        
                        String value;
                        do { 
                            if (!var3.hasNext()) { 
                                return false;
                            }
        
                            value = (String)var3.next();
                        } while(value == null || !value.matches(config.regexp));
        
                        return true;
                    }
                }
            };
        }

**2.10 RemoteAddrRoutePredicateFactory**

*  Route 匹配 ：请求来源 IP 在指定范围内
 *  配置：
    
        spring:
          cloud:
            gateway:
              routes:
              - id: remoteaddr_route
                uri: http://example.org
                predicates:
                - RemoteAddr=192.168.1.1/24
 *  代码：
    
        public Predicate<ServerWebExchange> apply(RemoteAddrRoutePredicateFactory.Config config) { 
            List<IpSubnetFilterRule> sources = this.convert(config.sources);
            return (exchange) -> { 
                InetSocketAddress remoteAddress = config.remoteAddressResolver.resolve(exchange);
                if (remoteAddress != null && remoteAddress.getAddress() != null) { 
                    String hostAddress = remoteAddress.getAddress().getHostAddress();
                    String host = exchange.getRequest().getURI().getHost();
                    if (log.isDebugEnabled() && !hostAddress.equals(host)) { 
                        log.debug("Remote addresses didn't match " + hostAddress + " != " + host);
                    }
        
                    Iterator var6 = sources.iterator();
        
                    while(var6.hasNext()) { 
                        IpSubnetFilterRule source = (IpSubnetFilterRule)var6.next();
                        if (source.matches(remoteAddress)) { 
                            return true;
                        }
                    }
                }
        
                return false;
            };
        }

## 三、RoutePredicateHandlerMapping ##

我们先来看下 Spring Cloud Gateway 官网提供的架构图：

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

上一节讲完了常见分类的 Predicate 匹配规则，客户端发送请求过来，通过 HandlerMapping 进行 predicate 的匹配，匹配成功再进行下面的处理。

**3.1 org.springframework.web.reactive.DispatcherHandler**

接收到请求，匹配 HandlerMapping ，此处会匹配到 RoutePredicateHandlerMapping。 由于 Gateway 是构建在 reactive 上的，所以这边的 web 类型就是 reactive。

public class DispatcherHandler implements WebHandler, ApplicationContextAware { 
        private static final Exception HANDLER_NOT_FOUND_EXCEPTION;
        @Nullable
        private List<HandlerMapping> handlerMappings;
        @Nullable
        private List<HandlerAdapter> handlerAdapters;
        @Nullable
        private List<HandlerResultHandler> resultHandlers;
    
        public Mono<Void> handle(ServerWebExchange exchange) { 
            return this.handlerMappings == null ? this.createNotFoundError() : 
            // 顺序使用 handlerMappings 获得对应的 WebHandler 
    		Flux.fromIterable(this.handlerMappings).concatMap((mapping) -> { 
    			// 获得 Handler 
                return mapping.getHandler(exchange);
            // 如果匹配不到 WebHandler ，返回 HANDLER_NOT_FOUND_EXCEPTION 。
            }).next().switchIfEmpty(this.createNotFoundError()).flatMap((handler) -> { 
            	// 调用 invokeHandler() 方法，执行 Handler 。
                return this.invokeHandler(exchange, handler);
            }).flatMap((result) -> { 
            	// 调用 handleResult() 方法，处理结果
                return this.handleResult(exchange, result);
            });
        }
    
    	...
    }

继续跟一下 invokeHandler() 方法：

private Mono<HandlerResult> invokeHandler(ServerWebExchange exchange, Object handler) { 
        if (this.handlerAdapters != null) { 
        	// 获取Adapters， WebHandler 的处理器适配器。
            Iterator var3 = this.handlerAdapters.iterator();
    
            while(var3.hasNext()) { 
                HandlerAdapter handlerAdapter = (HandlerAdapter)var3.next();
                // 调用support方法 ，是否支持 WebHandler
                if (handlerAdapter.supports(handler)) { 
                	// 调用handle 方法，执行处理器
                    return handlerAdapter.handle(exchange, handler);
                }
            }
        }
    
        return Mono.error(new IllegalStateException("No HandlerAdapter: " + handler));
    }

public boolean supports(Object handler) { 
        return WebHandler.class.isAssignableFrom(handler.getClass());
    }

public Mono<HandlerResult> handle(ServerWebExchange exchange, Object handler) { 
        WebHandler webHandler = (WebHandler)handler;
        // 执行处理器。例如，WebHandler 为 FilteringWebHandler 时，获得 Route 的 GatewayFilter 数组，创建 GatewayFilterChain 处理请求。
        Mono<Void> mono = webHandler.handle(exchange);
        // 在 WebHandler 执行完后 #then(Mongo)，然后返回 Mono.empty() 。
        return mono.then(Mono.empty());
    }

SimpleHandlerAdapter 返回的是 Mono.empty() ，所以不会触发该方法。

private Mono<Void> handleResult(ServerWebExchange exchange, HandlerResult result) { 
        return this.getResultHandler(result).handleResult(exchange, result).onErrorResume((ex) -> { 
            return result.applyExceptionHandler(ex).flatMap((exceptionResult) -> { 
                return this.getResultHandler(exceptionResult).handleResult(exchange, exceptionResult);
            });
        });
    }

**3.2 org.springframework.cloud.gateway.handler.RoutePredicateHandlerMapping**

接收到请求，匹配 Route ，并返回处理 Route 的 FilteringWebHandler。

SimpleHandlerAdapter\#handle(ServerWebExchange, Object) 调用 FilteringWebHandler\#handle(ServerWebExchange) 方法，处理请求。

public class RoutePredicateHandlerMapping extends AbstractHandlerMapping { 
        private final FilteringWebHandler webHandler;
        private final RouteLocator routeLocator;
        private final Integer managmentPort;
    
        public RoutePredicateHandlerMapping(FilteringWebHandler webHandler, RouteLocator routeLocator, GlobalCorsProperties globalCorsProperties, Environment environment) { 
            this.webHandler = webHandler;
            this.routeLocator = routeLocator;
            if (environment.containsProperty("management.server.port")) { 
                this.managmentPort = new Integer(environment.getProperty("management.server.port"));
            } else { 
                this.managmentPort = null;
            }
    		// RequestMappingHandlerMapping 之后
            this.setOrder(1);
            this.setCorsConfigurations(globalCorsProperties.getCorsConfigurations());
        }
    
        protected Mono<?> getHandlerInternal(ServerWebExchange exchange) { 
            if (this.managmentPort != null && exchange.getRequest().getURI().getPort() == this.managmentPort) { 
                return Mono.empty();
            } else { 
                // 设置 GATEWAY_HANDLER_MAPPER_ATTR 为 
                RoutePredicateHandlerMappingexchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_HANDLER_MAPPER_ATTR, this.getSimpleName());
                // 匹配路由
                return this.lookupRoute(exchange).flatMap((r) -> { 
                    exchange.getAttributes().remove(ServerWebExchangeUtils.GATEWAY_PREDICATE_ROUTE_ATTR);
                    if (this.logger.isDebugEnabled()) { 
                        this.logger.debug("Mapping [" + this.getExchangeDesc(exchange) + "] to " + r);
                    }
    				// 设置 GATEWAY_ROUTE_ATTR 为 匹配的 Route
                    exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_ROUTE_ATTR, r);
                    return Mono.just(this.webHandler);
                }).switchIfEmpty(Mono.empty().then(Mono.fromRunnable(() -> {  //匹配不到返回
                    exchange.getAttributes().remove(ServerWebExchangeUtils.GATEWAY_PREDICATE_ROUTE_ATTR);
                    if (this.logger.isTraceEnabled()) { 
                        this.logger.trace("No RouteDefinition found for [" + this.getExchangeDesc(exchange) + "]");
                    }
    
                })));
            }
        }
    }

跟一下 lookupRoute 匹配路由，这个方法是网关的核心，像我们自研的网关，如果你刚接手公司中的网关项目，找到匹配路由再展开，能帮你省很多时间，快速熟悉公司中网关的项目。

protected Mono<Route> lookupRoute(ServerWebExchange exchange) { 
    	// 获取所有路由
        return this.routeLocator.getRoutes().concatMap((route) -> { 
            return Mono.just(route).filterWhen((r) -> { 
                exchange.getAttributes().put(ServerWebExchangeUtils.GATEWAY_PREDICATE_ROUTE_ATTR, r.getId());
                // 并调用 Predicate#apply(ServerWebExchange) 方法，顺序匹配一个 Route。
                return (Publisher)r.getPredicate().apply(exchange);
            // 未来会增加匹配过程中发生异常的处理。目前，任何一个 Predicate#test(ServerWebExchange) 的方法调用发生异常时，都会导致匹配不到 Route。一定要注意。 
            }).doOnError((e) -> { 
                this.logger.error("Error applying predicate for route: " + route.getId(), e);
            }).onErrorResume((e) -> { 
                return Mono.empty();
            });
        }).next().map((route) -> { 
            if (this.logger.isDebugEnabled()) { 
                this.logger.debug("Route matched: " + route.getId());
            }
    
            this.validateRoute(route, exchange);
            return route;
        });
    }

**3.3 org.springframework.cloud.gateway.handler.FilteringWebHandler**

获得 Route 的 GatewayFilter 数组，创建 GatewayFilterChain 处理请求。这里我们放到下一篇来讲，下一篇也很重要，从原理来说也不是很难理解，就是一个过滤器链。但从 Gateway 的两大核心：路由+过滤链来说，这又很重要。

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

欢迎大家关注我的公众号【老周聊架构】，Java后端主流技术栈的原理、源码分析、架构以及各种互联网高并发、高性能、高可用的解决方案。

![在这里插入图片描述][20210305020119946.jpg_pic_center]  
喜欢的话，一键三连走一波。

[Spring Cloud Gateway _Route]: https://riemann.blog.csdn.net/article/details/115362089
[20210403191021185.png]: /images/20221022/2de985a77e114b9b8ee7c4e4e4d5faa1.png
[20210403193113914.png]: /images/20221022/04d59139c5ba4c8b86b55eb9316335be.png
[20210403204001183.png]: /images/20221022/ba5157bbbccb47a8ad3a2a236acaf2bb.png
[20210403204353202.png]: /images/20221022/f28c07119a294abfb1363d45dd7a252c.png
[20210403215837462.png]: /images/20221022/304ad55f6a0c4f8685aa97ba5941833c.png
[20210305020119946.jpg_pic_center]: /images/20221022/d11abb635393459982ac51a6e837e6a3.png