public interface ConfigurableWebServerApplicationContext
		extends ConfigurableApplicationContext, WebServerApplicationContext {
	/**
	 * 設(shè)置服務(wù)的命名空間
	 */
	void setServerNamespace(String serverNamespace);
}

public interface WebServerApplicationContext extends ApplicationContext {
	/**
	 * 獲取WebServer管理對象
	 */
	WebServer getWebServer();
	/**
	 * 獲取服務(wù)的命名空間
	 */
	String getServerNamespace();
}

   /**
	 * 默認(rèn)構(gòu)造方法
	 */
	public ServletWebServerApplicationContext() {
	}
	/**
	 * 指定beanFactory的構(gòu)造方法
	 */
	public ServletWebServerApplicationContext(DefaultListableBeanFactory beanFactory) {
		super(beanFactory);
	}

@Override
public final void refresh() throws BeansException, IllegalStateException {
    try {
        // 由父類方法初始化Spring上下文
        super.refresh();
    }
    catch (RuntimeException ex) {
        // 如果異常， 停止WebServer啟動并釋放資源
        stopAndReleaseWebServer();
        throw ex;
    }
}

private void createWebServer() {
		WebServer webServer = this.webServer;
        // 獲取ServletContext上下文
		ServletContext servletContext = getServletContext();
		if (webServer == null && servletContext == null) {
            // 如果為空， 則進行初始化創(chuàng)建
			ServletWebServerFactory factory = getWebServerFactory();
			this.webServer = factory.getWebServer(getSelfInitializer());
		}
		else if (servletContext != null) {
			try {
                // 如果不為空，則直接啟動
				getSelfInitializer().onStartup(servletContext);
			}
			catch (ServletException ex) {
				throw new ApplicationContextException("Cannot initialize servlet context", ex);
			}
		}
    	// 初始化屬性資源配置信息
		initPropertySources();
	}

	private void selfInitialize(ServletContext servletContext) throws ServletException {
        // 將ServeltContext設(shè)置為WebApplicationContext相關(guān)屬性
		prepareWebApplicationContext(servletContext);
        // 注冊ApplicationScope作用域
		registerApplicationScope(servletContext);
        // 注冊環(huán)境變量中的bean信息， 在BeanFactory中也可以獲得servletContext上下文信息
		WebApplicationContextUtils.registerEnvironmentBeans(getBeanFactory(), servletContext);
		for (ServletContextInitializer beans : getServletContextInitializerBeans()) {
            // 設(shè)置Bean在ServletContext加載完畢后進行初始化
			beans.onStartup(servletContext);
		}
	}

	@Override
	protected void finishRefresh() 
        // 完成刷新邏輯處理， 比如清除緩存， 發(fā)布刷新事件等
		super.finishRefresh();
		// 啟動WebServer
		WebServer webServer = startWebServer();
		if (webServer != null) 
            // 發(fā)布WebServer初始化完成事件
			publishEvent(new ServletWebServerInitializedEvent(webServer, this));
		}
	}

    @Override
	public void start() throws WebServerException {
        // 增加同步鎖
		synchronized (this.monitor) {
			if (this.started) {
                // 如果啟動， 則直接返回
				return;
			}
			try {
                //處理tomcat的Connectors連接配置信息， 就是tomcat得xml配置得Connector信息
				addPreviouslyRemovedConnectors();
				Connector connector = this.tomcat.getConnector();
				if (connector != null && this.autoStart) {
                    // 如果存在Connector， 且為自動啟動， 設(shè)置Tomcat的內(nèi)置上下文延遲處理（服務(wù)成功啟動后執(zhí)行）
					performDeferredLoadOnStartup();
				}
                // 檢查配置的Connectors是否已經(jīng)啟動， 避免沖突
				checkThatConnectorsHaveStarted();
				this.started = true;
				logger.info("Tomcat started on port(s): " + getPortsDescription(true) + " with context path '"
						+ getContextPath() + "'");
			}
			catch (ConnectorStartFailedException ex) {
                // 出現(xiàn)異常， 靜默停止
				stopSilently();
				throw ex;
			}
			catch (Exception ex) {
				if (findBindException(ex) != null) {
					throw new PortInUseException(this.tomcat.getConnector().getPort());
				}
				throw new WebServerException("Unable to start embedded Tomcat server", ex);
			}
			finally {
                // 獲取TOMCAT內(nèi)置上下文
				Context context = findContext();
                // 解除與classloader類加載器的綁定關(guān)系
				ContextBindings.unbindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
			}
		}
	}

    @Override
	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception 
		// LOG日志記錄請求信息
		logRequest(request);
		// 記錄Request級別作用域的請求變量信息， 必須要開啟INCLUDE_REQUEST_URI_ATTRIBUTE屬性
		Map<String, Object> attributesSnapshot = null;
		if (WebUtils.isIncludeRequest(request)) {
			attributesSnapshot = new HashMap<>();
			Enumeration<?> attrNames = request.getAttributeNames();
			while (attrNames.hasMoreElements()) {
				String attrName = (String) attrNames.nextElement();
				if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
					attributesSnapshot.put(attrName, request.getAttribute(attrName));
				}
			}
		}
		// 設(shè)置context上下文信息
		request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
		// 設(shè)置locale區(qū)域信息
		request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
		// 設(shè)置theme解析器
		request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
		// 設(shè)置theme源信息
		request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
		// 設(shè)置flashmap信息， FlashMap 是傳遞重定向參數(shù)的時候要用到的一個類
		if (this.flashMapManager != null) {
            
			FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
			if (inputFlashMap != null) {
				request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
			}
			request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
			request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
		}
		try {
            // 分發(fā)請求， 對請求做真正的邏輯處理
			doDispatch(request, response);
		}
		finally {
            // 判斷是否異步處理請求
			if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
				// 上面初始化設(shè)置attributesSnapshot， 這里如果有記錄， 做還原處理
				if (attributesSnapshot != null) {
					restoreAttributesAfterInclude(request, attributesSnapshot);
				}
			}
		}
	}

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        // 定義初始變量
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;
		// 獲取Web異步請求管理器
		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
		try {
			ModelAndView mv = null;
			Exception dispatchException = null;
			try {
                // 檢查請求是否為form-multipart提交類型，我們常見的文件上傳就是采用此類型
				processedRequest = checkMultipart(request);
                // 如果是multipart該類型， 通過MultipartResolver解析
				multipartRequestParsed = (processedRequest != request);

				// 獲取當(dāng)前請求的映射處理器， 也就是自定義的controller， 如果沒有找到， 則返回， 不做下面邏輯處理
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					noHandlerFound(processedRequest, response);
					return;
				}
				// 根據(jù)映射處理器， 獲取處理適配器（實際為RequestMappingHandlerAdapter） 
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
				// 獲取請求類型，包含GET,HEAD,POST,PUT,PATCH,DELETE,OPTIONS等
				String method = request.getMethod();
                // 判斷是否為GET類型 
				boolean isGet = "GET".equals(method);
				if (isGet || "HEAD".equals(method)) {
                    // 獲取上次請求修改標(biāo)記， 如果沒有修改， 默認(rèn)返回-1
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}
				// 在進入處理器之前， 先要判斷有沒設(shè)置攔截器， 如果有， 進入攔截器的前置處理邏輯， 默認(rèn)有ResourceUrlProviderExposingInterceptor等攔截器
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}
				// 這里就是真正調(diào)用處理器， 也就是我們在controller中定義的方法
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
				// 異步處理判斷
				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}
				// 判斷有沒采用ModelAndView返回， 并進行對應(yīng)設(shè)置
				applyDefaultViewName(processedRequest, mv);
                // 這里是攔截器的后置處理邏輯， 如果有匹配設(shè)置， 則會進行調(diào)用處理
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
				dispatchException = ex;
			}
			catch (Throwable err) {
				// As of 4.3, we're processing Errors thrown from handler methods as well,
				// making them available for @ExceptionHandler methods and other scenarios.
				dispatchException = new NestedServletException("Handler dispatch failed", err);
			}
            // 設(shè)置分發(fā)處理結(jié)果， 如果處理器的執(zhí)行出現(xiàn)異常，會根據(jù)設(shè)置做對應(yīng)渲染； 如果有設(shè)置視圖， 則會進行渲染解析
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
			triggerAfterCompletion(processedRequest, response, mappedHandler,
					new NestedServletException("Handler processing failed", err));
		}
		finally {
            // 異步請求標(biāo)記處理
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				if (mappedHandler != null) {
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
			}
			else {
				//如果采用multipart類型提交， 會做一些清除工作， 比如上傳文件緩存等
				if (multipartRequestParsed) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}

public class ReactiveWebServerApplicationContext extends GenericReactiveWebApplicationContext
		implements ConfigurableWebServerApplicationContext {
	// 服務(wù)管理類， 包含服務(wù)啟動與停止， 以及請求handler處理
	private volatile ServerManager serverManager;
	// 服務(wù)命名空間
	private String serverNamespace;
	/**
	 * 默認(rèn)構(gòu)造方法
	 */
	public ReactiveWebServerApplicationContext() {
	}
	/**
	 * 指定beanFactory的構(gòu)造方法
	 */
	public ReactiveWebServerApplicationContext(DefaultListableBeanFactory beanFactory) {
		super(beanFactory);
	}

    /**
	 * 服務(wù)管理類
	 */
	static final class ServerManager implements HttpHandler {
		// WebServer服務(wù)
		private final WebServer server;
		// 是否懶加載
		private final boolean lazyInit;
		// Http Handler請求處理器
		private volatile HttpHandler handler;
		// 構(gòu)造方法， 注入serverFactory與延遲加載標(biāo)記
		private ServerManager(ReactiveWebServerFactory factory, boolean lazyInit) {
			this.handler = this::handleUninitialized;
			this.server = factory.getWebServer(this);
			this.lazyInit = lazyInit;
		}
		// 處理未初始化的請求， 暫未實現(xiàn)
		private Mono<Void> handleUninitialized(ServerHttpRequest request, ServerHttpResponse response) {
			throw new IllegalStateException("The HttpHandler has not yet been initialized");
		}
		// 重載方法， 處理Web請求
		@Override
		public Mono<Void> handle(ServerHttpRequest request, ServerHttpResponse response) {
			return this.handler.handle(request, response);
		}
		public HttpHandler getHandler() {
			return this.handler;
		}
		// 獲取ServerManager服務(wù)管理類
		public static ServerManager get(ReactiveWebServerFactory factory, boolean lazyInit) {
			return new ServerManager(factory, lazyInit);
		}
        // 獲取WebServer服務(wù)
		public static WebServer getWebServer(ServerManager manager) {
			return (manager != null) ? manager.server : null;
		}
        // 通過serverManager啟動服務(wù)
		public static void start(ServerManager manager, Supplier<HttpHandler> handlerSupplier) {
			if (manager != null && manager.server != null) {
				manager.handler = manager.lazyInit ? new LazyHttpHandler(Mono.fromSupplier(handlerSupplier))
						: handlerSupplier.get();
				manager.server.start();
			}
		}
		// 通過serverManager停止服務(wù)
		public static void stop(ServerManager manager) {
			if (manager != null && manager.server != null) {
				try {
					manager.server.stop();
				}
				catch (Exception ex) {
					throw new IllegalStateException(ex);
				}
			}
		}
	}

	private WebServer startReactiveWebServer() {        
		ServerManager serverManager = this.serverManager;
        // 啟動WebServer, 從BeanFactory中獲取HttpHandler
		ServerManager.start(serverManager, this::getHttpHandler);
        // 獲取返回WebServer
		return ServerManager.getWebServer(serverManager);
	}

protected HttpHandler getHttpHandler() {
		// 獲取所有實現(xiàn)HttpHandler接口的實現(xiàn)類
		String[] beanNames = getBeanFactory().getBeanNamesForType(HttpHandler.class);
    	// HttpHandler實現(xiàn)類只能存在一個， 沒有配置或多個都會拋出異常
		if (beanNames.length == 0) {
            // 
			throw new ApplicationContextException(
					"Unable to start ReactiveWebApplicationContext due to missing HttpHandler bean.");
		}
    	// 存在多個， 拋出異常
		if (beanNames.length > 1) {
			throw new ApplicationContextException(
					"Unable to start ReactiveWebApplicationContext due to multiple HttpHandler beans : "
							+ StringUtils.arrayToCommaDelimitedString(beanNames));
		}
    	// 返回HttpHandler
		return getBeanFactory().getBean(beanNames[0], HttpHandler.class);
	}

@Override
protected void onClose() {
    // 先調(diào)用父類方法， 關(guān)閉邏輯處理， 目前是空實現(xiàn)
    super.onClose();
    // 通過ServerManager停止服務(wù)
    stopAndReleaseReactiveWebServer();
}

// 定義Reactive服務(wù)的HttpHandler， 
@Bean
public HttpHandler httpHandler() {
   return WebHttpHandlerBuilder.applicationContext(this.applicationContext)
         .build();
}

@Override
public WebServer getWebServer(HttpHandler httpHandler) {
   // 創(chuàng)建HTTP SERVER服務(wù)
   HttpServer httpServer = createHttpServer();
   // 定義HTTP HANDLER處理適配器 
   ReactorHttpHandlerAdapter handlerAdapter = new ReactorHttpHandlerAdapter(
         httpHandler);
   // 采用Netty作為WebServer實現(xiàn) 
   return new NettyWebServer(httpServer, handlerAdapter, this.lifecycleTimeout);
}

public Mono<Void> handle(ServerWebExchange exchange) {
        // 校驗handlerMappings是否存在
		if (this.handlerMappings == null) {
			return createNotFoundError();
		}
    	// 響應(yīng)式操作， 調(diào)用Handler實現(xiàn)類處理邏輯， handleResult處理執(zhí)行結(jié)果
		return Flux.fromIterable(this.handlerMappings)
				.concatMap(mapping -> mapping.getHandler(exchange))
				.next()
				.switchIfEmpty(createNotFoundError())
				.flatMap(handler -> invokeHandler(exchange, handler))
				.flatMap(result -> handleResult(exchange, result));
	}

	private Mono<HandlerResult> invokeHandler(ServerWebExchange exchange, Object handler) {
        // 校驗Handler適配器是否存在
		if (this.handlerAdapters != null) {
            // 遍歷handlerAdapters
			for (HandlerAdapter handlerAdapter : this.handlerAdapters) {
                // 判斷是否支持的適配器類型
				if (handlerAdapter.supports(handler)) {
                    // 處理Handler適配器具體邏輯
					return handlerAdapter.handle(exchange, handler);
				}
			}
		}
		return Mono.error(new IllegalStateException("No HandlerAdapter: " + handler));
	}