/*
 * 该类是reactor-netty库和spring框架的适配器
 */
public class ReactorHttpHandlerAdapter implements BiFunction<HttpServerRequest, HttpServerResponse, Mono<Void>> {

	private static final Log logger = HttpLogging.forLogName(ReactorHttpHandlerAdapter.class);


	private final HttpHandler httpHandler;


	public ReactorHttpHandlerAdapter(HttpHandler httpHandler) {
		Assert.notNull(httpHandler, "HttpHandler must not be null");
		this.httpHandler = httpHandler;
	}


	/*
	 * 该方法被reactor-netty调用。
	 */
	@Override
	public Mono<Void> apply(HttpServerRequest reactorRequest, HttpServerResponse reactorResponse) {
		NettyDataBufferFactory bufferFactory = new NettyDataBufferFactory(reactorResponse.alloc());
		try {
			ReactorServerHttpRequest request = new ReactorServerHttpRequest(reactorRequest, bufferFactory);
			ServerHttpResponse response = new ReactorServerHttpResponse(reactorResponse, bufferFactory);

			if (request.getMethod() == HttpMethod.HEAD) {
				response = new HttpHeadResponseDecorator(response);
			}

			// 处理请求，参考HttpWebHandlerAdapter
			return this.httpHandler.handle(request, response)
					.doOnError(ex -> logger.trace(request.getLogPrefix() + "Failed to complete: " + ex.getMessage()))
					.doOnSuccess(aVoid -> logger.trace(request.getLogPrefix() + "Handling completed"));
		}
		catch (URISyntaxException ex) {
			if (logger.isDebugEnabled()) {
				logger.debug("Failed to get request URI: " + ex.getMessage());
			}
			reactorResponse.status(HttpResponseStatus.BAD_REQUEST);
			return Mono.empty();
		}
	}

}

// 这是请求到达WebFlux领域的第一站
@Override
public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
    if (this.forwardedHeaderTransformer != null) {
        try {
            request = this.forwardedHeaderTransformer.apply(request);
        }
        catch (Throwable ex) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to apply forwarded headers to " + formatRequest(request), ex);
            }
            response.setStatusCode(HttpStatus.BAD_REQUEST);
            return response.setComplete();
        }
    }
    // 创建exchange对象
    ServerWebExchange exchange = createExchange(request, response);

    LogFormatUtils.traceDebug(logger, traceOn ->
            exchange.getLogPrefix() + formatRequest(exchange.getRequest()) +
                    (traceOn ? ", headers=" + formatHeaders(exchange.getRequest().getHeaders()) : ""));

    // 这里获取的delegate对象是在WebHttpHandlerBuilder的build方法中调用该类构造器是传递进来的。
    return getDelegate().handle(exchange) // 调用的是ExceptionHandlingWebHandler#handle
            .doOnSuccess(aVoid -> logResponse(exchange))
            .onErrorResume(ex -> handleUnresolvedError(exchange, ex))
            .then(Mono.defer(response::setComplete));
}

/*
 * 在SpringBoot中，HttpHandlerAutoConfiguration类有一个静态内部配置类，
 * 该配置类向容器中注入了一个httpHandler，在该方法中调用了此方法以及上面的applicationContext方法。
 */
public HttpHandler build() {
    /*
     * 采用装饰器模式封装handler和filter，这两个属性是在上面的applicationContext方法中被设置的。
     * 这里的webHandler就是核心组件DispatcherHandler
     * 内部会调用默认的过滤器链
     */
    WebHandler decorated = new FilteringWebHandler(this.webHandler, this.filters);
    // 再封装异常处理器
    decorated = new ExceptionHandlingWebHandler(decorated,  this.exceptionHandlers);

    // 创建适配器，并设置一些属性，由此可见adapter里面的delegate保存的是ExceptionHandlingWebHandler实例
    HttpWebHandlerAdapter adapted = new HttpWebHandlerAdapter(decorated);
    if (this.sessionManager != null) {
        adapted.setSessionManager(this.sessionManager);
    }
    if (this.codecConfigurer != null) {
        adapted.setCodecConfigurer(this.codecConfigurer);
    }
    if (this.localeContextResolver != null) {
        adapted.setLocaleContextResolver(this.localeContextResolver);
    }
    if (this.forwardedHeaderTransformer != null) {
        adapted.setForwardedHeaderTransformer(this.forwardedHeaderTransformer);
    }
    if (this.applicationContext != null) {
        adapted.setApplicationContext(this.applicationContext);
    }
    // 目前方法内只有打印日志的语句，不用关注
    adapted.afterPropertiesSet();

    // 如果存在装饰器，则再装饰一下
    return (this.httpHandlerDecorator != null ? this.httpHandlerDecorator.apply(adapted) : adapted);
}

@Override
public Mono<Void> handle(ServerWebExchange exchange) {
    Mono<Void> completion;
    try {
        // 先调用下一个WebHandlerDecorate
        completion = super.handle(exchange);
    }
    catch (Throwable ex) {
        completion = Mono.error(ex);
    }

    // 遍历执行WebExceptionHandler
    for (WebExceptionHandler handler : this.exceptionHandlers) {
        completion = completion.onErrorResume(ex -> handler.handle(exchange, ex));
    }
    return completion;
}

@Override
public Mono<Void> handle(ServerWebExchange exchange) {
    // 默认实现，调用下一个WebHandler的handle方法
    return this.delegate.handle(exchange);
}

public class FilteringWebHandler extends WebHandlerDecorator {

	private final DefaultWebFilterChain chain;


	/**
	 * Constructor.
	 * @param filters the chain of filters
	 */
	public FilteringWebHandler(WebHandler handler, List<WebFilter> filters) {
		// 设置delegate，是DispatcherHandler
		super(handler);
		// 同时把handler传递给webFilterChain
		this.chain = new DefaultWebFilterChain(handler, filters);
	}


	/**
	 * Return a read-only list of the configured filters.
	 */
	public List<WebFilter> getFilters() {
		return this.chain.getFilters();
	}


	@Override
	public Mono<Void> handle(ServerWebExchange exchange) {
		/*
		 * 执行过滤器链
		 * 这里没有调用delegate的handle方法，而是由chain来执行WebHandler的handle方法
		 *
		 */
		return this.chain.filter(exchange);
	}

}

@Override
public Mono<Void> handle(ServerWebExchange exchange) {
    if (this.handlerMappings == null) {
        return createNotFoundError();
    }
    // 处理预检请求
    if (CorsUtils.isPreFlightRequest(exchange.getRequest())) {
        return handlePreFlight(exchange);
    }
    // 遍历所有的handlerMapping
    return Flux.fromIterable(this.handlerMappings)
            // 从HandlerMapping中获取handler
            .concatMap(mapping -> mapping.getHandler(exchange))
            // 因为上面遍历了多个handlerMapping，可能多个mapping会返回handler，这里选取第一个。
            .next()
            // 如果没匹配到handlerMethod，则处理错误
            .switchIfEmpty(createNotFoundError())
            // 执行handler，会由HandlerAdapter处理
            .flatMap(handler -> invokeHandler(exchange, handler))
            .flatMap(result -> handleResult(exchange, result));
}