请求处理流程

//org.springframework.web.server.handler.FilteringWebHandler#handle
public Mono<Void> handle(ServerWebExchange exchange) {
    //chain类型：DefaultWebFilterChain
	return this.chain.filter(exchange);
}

//org.springframework.web.server.handler.DefaultWebFilterChain#filter
public Mono<Void> filter(ServerWebExchange exchange) {
	return Mono.defer(() ->
			this.currentFilter != null && this.next != null ?
					this.currentFilter.filter(exchange, this.next) :
					this.handler.handle(exchange));
}

private final WebFilter currentFilter;//当前WebFilter实例
private final DefaultWebFilterChain next;//下一个chain实例

//org.springframework.web.reactive.DispatcherHandler#handle
public Mono<Void> handle(ServerWebExchange exchange) {
    //校验handlerMappings是否为空
	if (this.handlerMappings == null) {
		return createNotFoundError();
	}
	return Flux.fromIterable(this.handlerMappings)//遍历handlerMappings集合进行请求处理
			.concatMap(mapping -> mapping.getHandler(exchange))//通过mapping获取对应的handler
			.next()
			.switchIfEmpty(createNotFoundError())
			.flatMap(handler -> invokeHandler(exchange, handler))//调用handler处理
			.flatMap(result -> handleResult(exchange, result));
}

public Mono<Object> getHandler(ServerWebExchange exchange) {
	return getHandlerInternal(exchange).map(handler -> {//调用子类中getHandlerInternal()获取handler
		if (logger.isDebugEnabled()) {
			logger.debug(exchange.getLogPrefix() + "Mapped to " + handler);
		}
		if (CorsUtils.isCorsRequest(exchange.getRequest())) {//判断是否跨域
			CorsConfiguration configA = this.corsConfigurationSource.getCorsConfiguration(exchange);
			CorsConfiguration configB = getCorsConfiguration(handler, exchange);
			CorsConfiguration config = (configA != null ? configA.combine(configB) : configB);
			if (!getCorsProcessor().process(config, exchange) ||
					CorsUtils.isPreFlightRequest(exchange.getRequest())) {
				return REQUEST_HANDLED_HANDLER;
			}
		}
		return handler;
	});
}

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);
				}
				//将匹配到的Route放置到Attribute中
				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) + "]");
				}
			})));
}

protected Mono<Route> lookupRoute(ServerWebExchange exchange) {
	return this.routeLocator.getRoutes()//调用CachingRouteLocator#getRoutes从缓存中获取routes
			.concatMap(route -> Mono.just(route).filterWhen(r -> {
				exchange.getAttributes().put(GATEWAY_PREDICATE_ROUTE_ATTR, r.getId());//
				return r.getPredicate().apply(exchange);//通过路由断言Predicate过滤掉不可用路由信息
			}).doOnError(e -> logger.error(
								"Error applying predicate for route: " + route.getId(), e))
				.onErrorResume(e -> Mono.empty()))
			.next()
			.map(route -> {
				if (logger.isDebugEnabled()) {
					logger.debug("Route matched: " + route.getId());
				}
				validateRoute(route, exchange);
				return route;
			});
}

private Mono<HandlerResult> invokeHandler(ServerWebExchange exchange, Object handler) {
	if (this.handlerAdapters != null) {
        //遍历handlerAdapter列表，通过supports()方法找到支持该handler的Adapter
		for (HandlerAdapter handlerAdapter : this.handlerAdapters) {
			if (handlerAdapter.supports(handler)) {
				return handlerAdapter.handle(exchange, handler);
			}
		}
	}
	return Mono.error(new IllegalStateException("No HandlerAdapter: " + handler));
}

//org.springframework.web.reactive.result.SimpleHandlerAdapter#handle
public Mono<HandlerResult> handle(ServerWebExchange exchange, Object handler) {
	WebHandler webHandler = (WebHandler) handler;
	Mono<Void> mono = webHandler.handle(exchange);
	return mono.then(Mono.empty());
}

//org.springframework.cloud.gateway.handler.FilteringWebHandler#handle
public Mono<Void> handle(ServerWebExchange exchange) {
    //获取匹配的Route，该Route是在RoutePredicateHandlerMapping中匹配并放置到exchange的attribute中的
	Route route = exchange.getRequiredAttribute(GATEWAY_ROUTE_ATTR);
    //获取配置的过滤器
	List<GatewayFilter> gatewayFilters = route.getFilters();

    //获取全局过滤器
	List<GatewayFilter> combined = new ArrayList<>(this.globalFilters);
    //将两种过滤器合并一起
	combined.addAll(gatewayFilters);
    //对过滤器进行排序
	AnnotationAwareOrderComparator.sort(combined);

	if (logger.isDebugEnabled()) {
		logger.debug("Sorted gatewayFilterFactories: " + combined);
	}

    //将过滤器封装到chain并执行filter方法
	return new DefaultGatewayFilterChain(combined).filter(exchange);
}

//DefaultGatewayFilterChain#filter
public Mono<Void> filter(ServerWebExchange exchange) {
	return Mono.defer(() -> {
		if (this.index < filters.size()) {
			GatewayFilter filter = filters.get(this.index);
			DefaultGatewayFilterChain chain = new DefaultGatewayFilterChain(this, this.index + 1);
			return filter.filter(exchange, chain);
		}
		else {
			return Mono.empty(); // complete
		}
	});
}