gateway - 調用

RoutePredicateHandlerMapping#getHandlerInternal

webflux的入口是DispatcherHandler，他這裏會調用HandlerMapping的getHandler方法。AbstractHandlerMapping實現了HandlerMapping接口，他有個抽象方法getHandlerInternal須要子類實現。
RoutePredicateHandlerMapping繼承了AbstractHandlerMapping，因此咱們的重點就是他的getHandlerInternal方法。這裏面就是用來處理是否有對應的Route。
這個方法，其實主要調用lookupRoute方法。

protected Mono<?> getHandlerInternal(ServerWebExchange exchange) {
    // don't handle requests on management port if set and different than server port
    if (this.managementPortType == DIFFERENT && this.managementPort != null
            && exchange.getRequest().getURI().getPort() == this.managementPort) {
        return Mono.empty();
    }
    exchange.getAttributes().put(GATEWAY_HANDLER_MAPPER_ATTR, getSimpleName());

    return lookupRoute(exchange)
            // .log("route-predicate-handler-mapping", Level.FINER) //name this
            .flatMap((Function<Route, Mono<?>>) r -> {
                exchange.getAttributes().remove(GATEWAY_PREDICATE_ROUTE_ATTR);
                if (logger.isDebugEnabled()) {
                    logger.debug(
                            "Mapping [" + getExchangeDesc(exchange) + "] to " + r);
                }

                exchange.getAttributes().put(GATEWAY_ROUTE_ATTR, r);
                return Mono.just(webHandler);
            }).switchIfEmpty(Mono.empty().then(Mono.fromRunnable(() -> {
                exchange.getAttributes().remove(GATEWAY_PREDICATE_ROUTE_ATTR);
                if (logger.isTraceEnabled()) {
                    logger.trace("No RouteDefinition found for ["
                            + getExchangeDesc(exchange) + "]");
                }
            })));
}

RoutePredicateHandlerMapping#lookupRoute

咱們能夠看到他有個r.getPredicate().apply這樣的代碼，他這個apply最終會調用每一個Predicate的test方法，返回false或者true。

protected Mono<Route> lookupRoute(ServerWebExchange exchange) {
    return this.routeLocator.getRoutes()
            // individually filter routes so that filterWhen error delaying is not a
            // problem
            .concatMap(route -> Mono.just(route).filterWhen(r -> {
                // add the current route we are testing
                exchange.getAttributes().put(GATEWAY_PREDICATE_ROUTE_ATTR, r.getId());
                return r.getPredicate().apply(exchange);
            })
    // 其餘略        
}

DefaultAsyncPredicate#apply

在這裏，會把每一個Predicate的test方法調用過去。

public Publisher<Boolean> apply(T t) {
    return Mono.just(delegate.test(t));
}

FilteringWebHandler#handle

咱們已經從上面的方法中拿到了一個Route（沒有就不繼續了），那就開始調用Filter。
DispatcherHandler在調用完handlerMappings後，會調用他的invokeHandler方法。

private Mono<HandlerResult> invokeHandler(ServerWebExchange exchange, Object handler) {
    if (this.handlerAdapters != null) {
        for (HandlerAdapter handlerAdapter : this.handlerAdapters) {
            if (handlerAdapter.supports(handler)) {
                return handlerAdapter.handle(exchange, handler);
            }
        }
    }
    return Mono.error(new IllegalStateException("No HandlerAdapter: " + handler));
}

而後會調用webHandler.handle方法。

public Mono<HandlerResult> handle(ServerWebExchange exchange, Object handler) {
    WebHandler webHandler = (WebHandler) handler;
    Mono<Void> mono = webHandler.handle(exchange);
    return mono.then(Mono.empty());
}

咱們的FilteringWebHandler就是一個WebHandler，咱們看看他的handle方法。
他會先獲取對應Route的Filters，再和通用的Filters合併排序，最後開始Filters的調用鏈。

public Mono<Void> handle(ServerWebExchange exchange) {
    // 獲取Route
    Route route = exchange.getRequiredAttribute(GATEWAY_ROUTE_ATTR);
    // 取出Filters
    List<GatewayFilter> gatewayFilters = route.getFilters();
    // 加入通用的Filters
    List<GatewayFilter> combined = new ArrayList<>(this.globalFilters);
    combined.addAll(gatewayFilters);
    // TODO: needed or cached?
    // 排序
    AnnotationAwareOrderComparator.sort(combined);

    if (logger.isDebugEnabled()) {
        logger.debug("Sorted gatewayFilterFactories: " + combined);
    }
    // 調用鏈
    return new DefaultGatewayFilterChain(combined).filter(exchange);
}

總體流程

這邊忽略了DispatcherHandler部分