SpringMVC探秘-请求之路

SpringMVC探秘-请求之路

开始

今天来分析一下SpringMVC的原理，探究SpringMVC如何把请求传递到每个Controller的方法上，从Servlet到Controller,一个请求走了哪些艰难曲折的路。

基本核心组件

在开始分析之前，先了解SpringMVC中的几个概念，后面提到的时候不至于不知道这个是干什么用的，不过不用彻底知道这个组件是如何实现的，现在只需要知道有这个东西就行了， 先混个脸熟

组件	说明
DispatcherServlet	SpringMVC中的中心，处理请求的分发，视图的解析等，本质上是一个Servlet
HandlerMapping	一个映射，<URL,Handler>，可以根据URL找到匹配的Handler,这儿的Handler是HandlerExecutionChain
HandlerAdapter	Hander的适配器，委托这个适配器去调用具体的某个Hander
ViewResolver	视图解析器，用于将视图名称解析为视图对象 View。

这些组件都是经过DispatcherServlet的协调，把一个请求分发到具体的一个Hander，然后根据Hander的返回值，来做不同的处理，不同的组件处理不同的逻辑。

追根溯源

请求的入口-Servlet

我们都知道Servlet是一个标准，我们的处理逻辑代码只需要写到Servlet中，而对于Http请求响应的解析处理都不需要我们关心，已经有很多服务器实现了这部分，比如熟悉的小猫猫Tomcat,它就是按照Servlet的标准来实现的。

ServletConfig

/**
 * A servlet configuration object used by a servlet container to pass
 * information to a servlet during initialization.
 * 当servlet实例化的时候，servlet容器传递给servlet的配置
 */
public interface ServletConfig {

    /**
     * Returns the name of this servlet instance. The name may be provided via
     * server administration, assigned in the web application deployment
     * descriptor, or for an unregistered (and thus unnamed) servlet instance it
     * will be the servlet's class name.
     * 返回servlet的名字，如果没有指定，则返回servlet的类名
     * @return the name of the servlet instance
     */
    public String getServletName();

    /**
     * Returns a reference to the {@link ServletContext} in which the caller is
     * executing.
     * 返回调用者当前执行环境的ServletContext引用
     * @return a {@link ServletContext} object, used by the caller to interact
     *         with its servlet container
     * @see ServletContext
     */
    public ServletContext getServletContext();

    /**
     * Returns a <code>String</code> containing the value of the named
     * initialization parameter, or <code>null</code> if the parameter does not
     * exist.
     * 返回一个字符串类型的值，这个值是初始化的参数
     * @param name
     *            a <code>String</code> specifying the name of the
     *            initialization parameter
     * @return a <code>String</code> containing the value of the initialization
     *         parameter
     */
    public String getInitParameter(String name);

    /**
     * Returns the names of the servlet's initialization parameters as an
     * <code>Enumeration</code> of <code>String</code> objects, or an empty
     * <code>Enumeration</code> if the servlet has no initialization parameters.
     * 返回所有的初始化参数
     * @return an <code>Enumeration</code> of <code>String</code> objects
     *         containing the names of the servlet's initialization parameters
     */
    public Enumeration<String> getInitParameterNames();
}

Servlet

package javax.servlet;

import java.io.IOException;

/**
 * 所有的servlet都应该实现这里的方法
 *
 * servlet是一个运行在Web Server的小Java程序，它们接受对来自web客户端的请求并做出响应，这些请求通常通过HTTP传达
 *
 * 为了实现这个接口，你可以写一个基于javax.servlet.GenericServlet，或者HTTP     Servletjavax.servlet.http.HttpServlet派生的servlet类
 *
 * 这个接口定义了实例化servlet，接受请求，从server移除的方法，这些方法被称为生命周期方法：并且按照一些的顺序调用：
 * 1. servlet被实例化，调用init()方法初始化
 * 2. 当有来自客户端的调用，serviceI()方法被调用
 * 3. servlet退出服务，destory()方法被调用，然后执行GC
 *
 * 除了生命周期方法外，这个接口还提供了getServletConfig方法来获取启动信息，getServletInfo来获取
 * servlet自身的基本信息，比如作者，版本，版权等
 *
 * @see GenericServlet
 * @see javax.servlet.http.HttpServlet
 */
public interface Servlet {

    /**
     * 被servlet容器调用，表示这个servlet将要开始服务
	 *
     * servlet实例化之后马上调用这个方法，在开始处理请求前这个方法必须调用成功
     *
     * 如果这个方法抛出异常或者在指定的时间段没有返回，那么这个serlet也不能处理请求
     * @exception ServletException
     *                if an exception has occurred that interferes with the
     *                servlet's normal operation
     *
     * @see UnavailableException
     * @see #getServletConfig
     */
    public void init(ServletConfig config) throws ServletException;

    /**
   	 * 获取ServletConfig,存储了启动参数
     * @return the <code>ServletConfig</code> object that initializes this
     *         servlet
     *
     * @see #init
     */
    public ServletConfig getServletConfig();

    /**
     * 被Servlet容器调用，用来对一个请求做出响应
  	 *
     * 只有当servlet中的init()方法调用成功后这个方法才会调用
     *
     * 应该为抛出异常或者错误的servlet返回的response设置响应码
     *
     * 这个方法可能被并发调用，所以开发者对于共享的资源要同步操作，共享的资源比如，文件，网络连接，
     * 还有servlet的类变量和实例变量
     * @param req
     *            the <code>ServletRequest</code> object that contains the
     *            client's request
     *
     * @param res
     *            the <code>ServletResponse</code> object that contains the
     *            servlet's response
     *
     * @exception ServletException
     *                if an exception occurs that interferes with the servlet's
     *                normal operation
     *
     * @exception IOException
     *                if an input or output exception occurs
     */
    public void service(ServletRequest req, ServletResponse res)
            throws ServletException, IOException;

    /**
	 * 获取Servlet基本信息
     *
     * @return a <code>String</code> containing servlet information
     */
    public String getServletInfo();

    /**
     * 这个方法被调用，表明这个servlet已经不再处理请求，这个方法在多线程环境也只调用一次，调用后，
     * service方法将不会再调用
     *
     * 给一个servlet释放资源的机会，比如文件，还有需要持久化的资源需和内存中的状态同步
     */
    public void destroy();
}

GenericServlet

GenericServlet 实现了 Servlet 和 ServletConfig 两个接口，为这两个接口中的部分方法提供了简单的实现。比如该类实现了 Servlet 接口中的 void init(ServletConfig) 方法，并在方法体内调用了内部提供了一个无参的 init 方法，子类可覆盖该无参 init 方法。除此之外，GenericServlet 还实现了 ServletConfig 接口中的 getInitParameter 方法，用户可直接调用该方法获取到配置信息。而不用先获取 ServletConfig，然后再调用 ServletConfig 的 getInitParameter 方法获取

GenericServlet 是一个协议无关的 servlet，是一个比较原始的实现，通常我们不会直接继承该类。一般情况下，我们都是继承 GenericServlet 的子类 HttpServlet，该类是一个和 HTTP 协议相关的 Servlet。那下面我们来看一下这个类

HttpServlet

HttpServlet，从名字上就可看出，这个类是和 HTTP 协议相关。该类的关注点在于怎么处理 HTTP 请求，比如其定义了 doGet 方法处理 GET 类型的请求，定义了 doPost 方法处理 POST 类型的请求等。我们若需要基于 Servlet 写 Web 应用，应继承该类，并覆盖指定的方法。doGet 和 doPost 等方法并不是处理的入口方法，所以这些方法需要由其他方法调用才行。其他方法是哪个方法呢？对，在Servlet接口定义处理请求的方法service中。当然在HttpServlet中还有一些处理缓存的逻辑

请求分发中央-DispatcherServlt

在认识它之前，介绍一下它在家族中的地位

对于Servlet相关的类和接口上面已经介绍过了，这里多了一些以Aware结尾的接口，是Spring IOC中的接口，

HttpServletBean

重写了GenericServlet中的init()方法，设置servlet配置的初始化参数

FrameworkServlet

FrameworkServlet 是 Spring Web 框架中的一个基础类，该类会在初始化时创建一个容器。同时该类覆写了 doGet、doPost 等方法，并将所有类型的请求委托给 doService 方法去处理。doService 是一个抽象方法，需要子类实现。

servlet被实例化后，会调用GenericServlet的init(ServletConfig config)方法，然后会无参init()方法，HttpServletBean重写了init()方法，这个方法会调用交给子类去实现的initServletBean()方法，现在就到了FrameworkServlet中的initServletBean(),该方法会调用initWebApplicationContext(),这里创建多个容器我，他们之间的关系后面我们再说

DispatcherServlet

DispatcherServlet就是核心的一个组件，来负责协调各个组件，同事初始化这些组件如，HanderMapping,HanderAdapter等。

中央处理器DispatcherServlet

我们继续从上面的FrameworkServlet调用的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中就是给request设置一些参数，然后调用doDispatch()方法。doDispatch()才是真正处理请求的方法

	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
        // 这个对象包含HnadlerInterceptor集合和Handler对象
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

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

			try {
                // 检查是否是Multipart request,如果是并且有MultipartResolver,则返回MultipartResolver处理后的request
				processedRequest = checkMultipart(request);
                // 是否被MultipartResolver处理
				multipartRequestParsed = (processedRequest != request);

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

				// Determine handler adapter for the current request.
                // 获取可执行处理器逻辑的适配器 HandlerAdapter
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

				// Process last-modified header, if supported by the handler.
                // HTTP缓存相关
				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;
					}
				}

                // 执行拦截器 preHandle 方法
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// 调用处理器逻辑，对应步骤
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

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

                // 如果 controller 未返回 view 名称，这里生成默认的 view 名称
				applyDefaultViewName(processedRequest, mv);
                // 执行拦截器 postHandle 方法
				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);
				}
			}
		}
	}

getHander(HttpServletRequest)

	/**
	 * 遍历所有的HanderMapping,获取一个HanderExecutionChian
	 * Return the HandlerExecutionChain for this request.
	 * <p>Tries all handler mappings in order.
	 * @param request current HTTP request
	 * @return the HandlerExecutionChain, or {@code null} if no handler could be found
	 */
	@Nullable
	protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		if (this.handlerMappings != null) {
			for (HandlerMapping mapping : this.handlerMappings) {
				HandlerExecutionChain handler = mapping.getHandler(request);
				if (handler != null) {
					return handler;
				}
			}
		}
		return null;
	}

getHandlerAdapter

/**
 * Return the HandlerAdapter for this handler object.
 * @param handler the handler object to find an adapter for
 * @throws ServletException if no HandlerAdapter can be found for the handler. This is a fatal error.
 */
protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
   if (this.handlerAdapters != null) {
      for (HandlerAdapter adapter : this.handlerAdapters) {
         if (adapter.supports(handler)) {
            return adapter;
         }
      }
   }
   throw new ServletException("No adapter for handler [" + handler +
         "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
}

processDispatchResult

/**
 * Handle the result of handler selection and handler invocation, which is
 * either a ModelAndView or an Exception to be resolved to a ModelAndView.
 */
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
      @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
      @Nullable Exception exception) throws Exception {

   boolean errorView = false;

   if (exception != null) {
      if (exception instanceof ModelAndViewDefiningException) {
         logger.debug("ModelAndViewDefiningException encountered", exception);
         mv = ((ModelAndViewDefiningException) exception).getModelAndView();
      }
      else {
         Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
         mv = processHandlerException(request, response, handler, exception);
         errorView = (mv != null);
      }
   }

   // Did the handler return a view to render?
   if (mv != null && !mv.wasCleared()) {
      render(mv, request, response);
      if (errorView) {
         WebUtils.clearErrorRequestAttributes(request);
      }
   }
   else {
      if (logger.isTraceEnabled()) {
         logger.trace("No view rendering, null ModelAndView returned.");
      }
   }

   if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
      // Concurrent handling started during a forward
      return;
   }

   if (mappedHandler != null) {
      mappedHandler.triggerAfterCompletion(request, response, null);
   }
}

后记

整个请求的流程就走完了，但是对于HandlerMapping和HandlerAdapter，如何渲染视图这块没有详细说，因为现在我也还不太懂，等后面会再写文章来说明。

再DispatcherServlet初始化后，会创建容器和创建组件，这些在本文中也没有说明，篇幅限制就另外写一篇来做解释了。