springmvc最简单配置的解析（1）-----------【springmvc源码】

配置一个springmvc的话，需要三步即可。

1. 在web.xml中配置Servlet。（配置它是为了能找到第二步的文件。）
2. 创建springmvc的xml配置文件。（那么它就是寻找第三步的东西）
3. 创建Controller和view。（而它则是为了减少程序员的时间。那么问题来，为什么不直接到这里，还要那么多步？-----------我觉的可能是为了方便管理，毕竟那么多的Controller和view）

 

它们的流程大概如此。（一个http请求所引发的灾难）

 

那么现在我有一个疑问，为什么DispatcherServlet能找到文件？

我们都知道它是springmvc的唯一入口，可是它为什么是唯一的入口呢？它是如何被设计为唯一入口的？这就是我所抱有的疑问，为什么。。。

那么我们就来看看它DispatcherServlet；大概如下图所示：

 

挺多的，但是和url请求有关的嘛。也就是其中一个方法：doService

那么仔细看下它doService吧！

   /**
	 * Exposes the DispatcherServlet-specific request attributes and delegates to {@link #doDispatch}
	 * for the actual dispatching.
	 */


	@Override
	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
		logRequest(request);

		// Keep a snapshot of the request attributes in case of an include,
		// to be able to restore the original attributes after the include.
		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));
				}
			}
		}

		// Make framework objects available to handlers and view objects.
		request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
		request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
		request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
		request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

		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 {
			doDispatch(request, response);
		}
		finally {
			if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
				// Restore the original attribute snapshot, in case of an include.
				if (attributesSnapshot != null) {
					restoreAttributesAfterInclude(request, attributesSnapshot);
				}
			}
		}
	}

你就会发现doService也就做了事情那么两件。

1. 保存request的Attribute并在框架处理完之后恢复回去，以防止attribute在框架处理的过程中被迫坏。
2. 在第36行调用doDispatch，进入真正的spring mvc流程中。

 

 

至于第一个，那就不分析了。

所以我们看下doDispatch吧，这可是DispatchServlet控制整个spring mvc流程的核心。

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

		try {
			ModelAndView mv = null;
			Exception dispatchException = null;

			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				// Determine handler for the current request.
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					noHandlerFound(processedRequest, response);
					return;
				}

				// Determine handler adapter for the current request.
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

				// Process last-modified header, if supported by the handler.
				String method = request.getMethod();
				boolean isGet = "GET".equals(method);
				if (isGet || "HEAD".equals(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}

				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// Actually invoke the handler.
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}

				applyDefaultViewName(processedRequest, mv);
				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);
			}
			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 {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				if (mappedHandler != null) {
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
			}
			else {
				// Clean up any resources used by a multipart request.
				if (multipartRequestParsed) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}

好吧，代码有点多。

 

但是如果你仔细分析这个方法的话，它的核心功能也就那么几个。

1. 获取用于处理模型所需的处理器HanderExecutionChain和适配器HandlerAdapter
2. 处理http请求得到模型和视图（存在一个ModelAndView对象中）
3. 处理拦截器
4. 渲染视图
5. 卸载multipart内容

大概功能就是：处理请求和渲染页面。

 

 

好吧，到了这里我们也就了解它为什么是入口了（优点）。至于为什么是唯一的话，那是因为它本身就是集中访问点，也就是前端控制器。它作用也就是控制其他组件的执行，统一调度，降低组件之间的耦合度，方便后期扩展。 

 

至于为什么能找到文件的话，那就得多亏适配器或处理器了。

 

参考资料：

SpringMVC的工作流程浅析

【Spring】Spring MVC原理及配置详解