SpringMVC源码剖析（一）

1、处理过程分析

一、首先，Tomcat每次启动时都会加载并解析/WEB-INF/web.xml文件，因此能够先从web.xml找突破口，主要代码以下：

<servlet >
    <servlet-name >spring-mvc</servlet-name>
    <!-- servlet类 -->
    <servlet-class >org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <!-- 初始化参数 -->
    <init-param >
      <param-name >contextConfigLocation</param-name>
      <param-value >classpath:/spring-mvc.xml</param-value>
    </init-param>
    <!-- 启动时加载 -->
    <load-on-startup >1</load-on-startup>
  </servlet>
  <servlet-mapping >
    <servlet-name >spring-mvc</servlet-name>
    <url-pattern >/</url-pattern>
  </servlet-mapping>
   .
   .
   .
</servlet >

咱们能够从web.xml文件得到三个信息，分别是：servlet类为DispatcherServlet，它在启动时加载，加载时初始化参数contextConfigLocation 
为classpath下spring-mvc.xml的文件地址，接下来咱们将目光移到DispatcherServlet类。

二、打开DispatcherServlet类，咱们先将目光聚焦在它的结构体系上，以下图：

很明显，它是一个Servlet的子类，其实不用说也知道，由于web.xml早已有配置。既然是Servlet，咱们就要专一于它的service、doGet、doPost等相关方法，在它的父类FrameServlet，咱们找到了service方法。

/**
     * Override the parent class implementation in order to intercept PATCH
     * requests.
     */
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        String method = request.getMethod();
        if (method.equalsIgnoreCase(RequestMethod.PATCH.name())) {
            processRequest(request, response);
        }
        else {
            super.service(request, response);
        }
    }

根据service方法，咱们一步步找到一个方法链service –> processRequest –> doService –> doDispatch，咱们最终将目光定位在doDispatch，由于从它的方法体就能够看出它是整个SpringMVC的核心方法。

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;

                // 解析请求，获取HandlerExecutionChain对象
                mappedHandler = getHandler(processedRequest);
                if (mappedHandler == null || mappedHandler.getHandler() == null) {
                    noHandlerFound(processedRequest, response);
                    return;
                }

                // 从HandlerExecutionChain对象获取HandlerAdapter对象，其实是从HandlerMapping对象中获取
                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 (logger.isDebugEnabled()) {
                        logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                    }
                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                        return;
                    }
                }

                //在controller方法执行前，执行拦截器的相关方法（pre）
                if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                    return;
                }

                try {
                    // 执行HandlerAdapter对象的handler方法，返回ModelAndView
                    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
                }
                finally {
                    if (asyncManager.isConcurrentHandlingStarted()) {
                        return;
                    }
                }

                applyDefaultViewName(request, mv);
                //在controller方法执行后，执行拦截器的相关方法（post）
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            }
            catch (Exception ex) {
                dispatchException = ex;
            }
            //进行视图解析
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        }
        catch (Exception ex) {
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        }
        catch (Error err) {
            triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);
        }
        finally {
            if (asyncManager.isConcurrentHandlingStarted()) {
                // Instead of postHandle and afterCompletion
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                return;
            }
            // Clean up any resources used by a multipart request.
            if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
            }
        }
    }

说它是核心一点也不为过，从上述代码的中文注释能够看出，它包含了解析请求，执行相关拦截器，执行handle方法（到这里关于handle方法是什么，咱们一脸懵逼。别急，接下来咱们会讲述，总之它很重要就对了），执行视图解析方法。 
三、至于HandlerAdapter是干吗用的？它的handler方法有什么用？咱们毫无概念，接下来咱们从另外一个角度切入（就像两我的相对而行，一我的筋疲力尽了，惟有靠另外一我的努力前行才能相遇），因此我选择Controller，得先从配置文件入手，由于它采用了spring的IOC。

<bean id="controller" class="com.mvc.controller.MyController"></bean>

    <bean id="interceptor" class="com.mvc.interceptor.MyInterceptor"></bean>

    <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <props>
                <prop key="controller">controller</prop>
            </props>
        </property>
        <property name="interceptors">
            <array>
                <ref bean="interceptor"></ref>
            </array>
        </property>
    </bean>

配置文件又给了咱们一条重要的信息：controller和拦截器都是做为SimpleUrlHandlerMapping的参数传进去的，而SimpleUrlHandlerMapping是HandlerMapping的子类。从这里就能够猜想，controller的核心方法要么被HandlerMapping直接调用，要么被HandlerMapping的附属产品（类）进行调用，接下来咱们查看一下controller核心方法的调用状况。

很幸运，看到SimpleControllerHandlerAdapter和DispatcherServlet.doDispatch(request, response),我好像发现了新大陆，这不正是咱们想要的吗？HandlerAdapter类和doDispatch(request, response)方法完美地结合在了一块儿。再看SimpleControllerHandlerAdapter的handler方法：

@Override
    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {

        return ((Controller) handler).handleRequest(request, response);
    }

这里也有一个方法的调用链，从上图就能够看出，handle方法最终是调用handleRequestInternal方法，也就是咱们在controller中自定义的方法。总而言之，HandlerAdapter的handler方法是用来调用controller中的handleRequestInternal方法的，而handleRequestInternal的方法体正是咱们用户自定义的业务逻辑。 
好，SpringMVC的主要源码咱们就解析到这里了，接下来咱们就SpringMVC的处理过程作一个总结。

2、SpringMVC处理过程总结
    先放一张图，咱们再慢慢解析：
流程解析：  一、当request到来时，DispatcherServlet对request进行捕获，并执行doService方法，继而执行doDispatch方法。  二、HandlerMapping解析请求，而且返回HandlerExecutionChain（其中包含controllers和interceptors），而后经过HandlerExecutionChain获得Handler相关类，根据Handler获取执行它的HandlerAdapter类。  三、先执行拦截器的pre相关方法，接着执行handler方法，它会调用controller的handleRequestInternal方法（方法体由用户自定义），最后调用拦截器的post相关方法。  四、解析handler方法返回的ModelAndView（能够在配置文件中配置ResourceViewResolver，也就是视图解析器），渲染页面并response给客户端。