看透 Spring MVC 源代码分析与实践 —— 俯视 Spring MVC

http://mp.weixin.qq.com/s/2fU4K6u-swIQxSkj0BwJ6A

Spring MVC 之初体验

环境搭建

在 IDEA 中新建一个 web 项目，用 Maven 管理项目的话，在 pom.xml 中加入 Spring MVC 和 Servlet 依赖即可。

1. <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->

2. <dependency>

3.    <groupId>org.springframework</groupId>

4.    <artifactId>spring-webmvc</artifactId>

5.    <version>4.3.9.RELEASE</version>

6. </dependency>

7. <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->

8. <dependency>

9.    <groupId>javax.servlet</groupId>

10.    <artifactId>javax.servlet-api</artifactId>

11.    <version>3.1.0</version>

12.    <scope>provided</scope>

13. </dependency>

Spring MVC 简单配置

• 在 web.xml 中配置 Servlet

• 创建 Spring MVC 的 xml 配置文件

• 创建 Controller 和 View

1、web.xml

1. <!-- Spring MVC配置 -->

2. <!-- ====================================== -->

3. <servlet>

4.    <servlet-name>spring</servlet-name>

5.    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

6.    <!-- 可以自定义servlet.xml配置文件的位置和名称，默认为WEB-INF目录下，名称为[<servlet-name>]-servlet.xml，如spring-servlet.xml

7.    <init-param>

8.        <param-name>contextConfigLocation</param-name>

9.        <param-value>/WEB-INF/spring-servlet.xml</param-value>&nbsp; 默认

10.    </init-param>

11.    -->

12.    <load-on-startup>1</load-on-startup>

13. </servlet>

15. <servlet-mapping>

16.    <servlet-name>spring</servlet-name>

17.    <url-pattern>*.do</url-pattern>

18. </servlet-mapping>

21. <!-- Spring配置 -->

22. <!-- ====================================== -->

23. <listener>

24.   <listenerclass>

25.     org.springframework.web.context.ContextLoaderListener

26.   </listener-class>

27. </listener>

30. <!-- 指定Spring Bean的配置文件所在目录。默认配置在WEB-INF目录下 -->

31. <context-param>

32.    <param-name>contextConfigLocation</param-name>

33.    <param-value>classpath:config/applicationContext.xml</param-value>

34. </context-param>

2、spring-servlet.xml

1. <?xml version="1.0" encoding="UTF-8"?>

2. <beans xmlns="http://www.springframework.org/schema/beans"

3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

4.        xmlns:context="http://www.springframework.org/schema/context"

5.   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

6.       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd

7.       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

8.       http://www.springframework.org/schema/context <a href="http://www.springframework.org/schema/context/spring-context-3.0.xsd">http://www.springframework.org/schema/context/spring-context-3.0.xsd</a>">

10.    <!-- 启用spring mvc 注解 -->

11.    <context:annotation-config />

13.    <!-- 设置使用注解的类所在的jar包 -->

14.    <context:component-scan base-package="controller"></context:component-scan>

16.    <!-- 完成请求和注解POJO的映射 -->

17.    <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />

18. 　　

19.    <!-- 对转向页面的路径解析。prefix：前缀， suffix：后缀 -->

20.    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" p:prefix="/jsp/" p:suffix=".jsp" />

21. </beans>

3、Controller

1. package controller;

3. import javax.servlet.http.HttpServletRequest;

5. import org.springframework.stereotype.Controller;

6. import org.springframework.web.bind.annotation.RequestMapping;

7. import org.springframework.web.bind.annotation.RequestParam;

9. import entity.User;

11. @Controller  //类似Struts的Action

12. public class TestController {

14.    @RequestMapping("/test/login.do")  // 请求url地址映射，类似Struts的action-mapping

15.    public String testLogin(@RequestParam(value="username")String username, String password, HttpServletRequest request) {

16.        // @RequestParam是指请求url地址映射中必须含有的参数(除非属性 required=false, 默认为 true)

17.        // @RequestParam可简写为：@RequestParam("username")

19.        if (!"admin".equals(username) || !"admin".equals(password)) {

20.            return "loginError"; // 跳转页面路径（默认为转发），该路径不需要包含spring-servlet配置文件中配置的前缀和后缀

21.        }

22.        return "loginSuccess";

23.    }

25.    @RequestMapping("/test/login2.do")

26.    public ModelAndView testLogin2(String username, String password, int age){

27.        // request和response不必非要出现在方法中，如果用不上的话可以去掉

28.        // 参数的名称是与页面控件的name相匹配，参数类型会自动被转换

30.        if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {

31.            return new ModelAndView("loginError"); // 手动实例化ModelAndView完成跳转页面（转发），效果等同于上面的方法返回字符串

32.        }

33.        return new ModelAndView(new RedirectView("../index.jsp"));  // 采用重定向方式跳转页面

34.        // 重定向还有一种简单写法

35.        // return new ModelAndView("redirect:../index.jsp");

36.    }

38.    @RequestMapping("/test/login3.do")

39.    public ModelAndView testLogin3(User user) {

40.        // 同样支持参数为表单对象，类似于Struts的ActionForm，User不需要任何配置，直接写即可

41.        String username = user.getUsername();

42.        String password = user.getPassword();

43.        int age = user.getAge();

45.        if (!"admin".equals(username) || !"admin".equals(password) || age < 5) {

46.            return new ModelAndView("loginError");

47.        }

48.        return new ModelAndView("loginSuccess");

49.    }

51.    @Resource(name = "loginService")  // 获取applicationContext.xml中bean的id为loginService的，并注入

52.    private LoginService loginService;  //等价于spring传统注入方式写get和set方法，这样的好处是简洁工整，省去了不必要得代码

54.    @RequestMapping("/test/login4.do")

55.    public String testLogin4(User user) {

56.        if (loginService.login(user) == false) {

57.            return "loginError";

58.        }

59.        return "loginSuccess";

60.    }

61. }

@RequestMapping 可以写在方法上，也可以写在类上，上面代码方法上的 RequestMapping 都含有 /test ， 那么我们就可以将其抽出直接写在类上，那么方法里面就不需要写 /test 了。

如下即可：

1. @Controller

2. @RequestMapping("/test")

3. public class TestController {

5.    @RequestMapping("/login.do")  // 请求url地址映射，类似Struts的action-mapping

6.    public String testLogin(@RequestParam(value="username")String username, String password, HttpServletRequest request) {

7.        // @RequestParam是指请求url地址映射中必须含有的参数(除非属性 required=false, 默认为 true)

8.        // @RequestParam可简写为：@RequestParam("username")

10.        if (!"admin".equals(username) || !"admin".equals(password)) {

11.            return "loginError"; // 跳转页面路径（默认为转发），该路径不需要包含spring-servlet配置文件中配置的前缀和后缀

12.        }

13.        return "loginSuccess";

14.    }

15.    //省略其他的

16. }

上面的代码方法的参数中可以看到有一个 @RequestParam 注解，其实还有 @PathVariable 。这两个的区别是啥呢？

• @PathVariable 标记在方法的参数上，利用它标记的参数可以利用请求路径传值。

• @RequestParam是指请求url地址映射中必须含有的参数(除非属性 required=false, 默认为 true)

看如下例子：

1. @RequestMapping("/user/{userId}")  // 请求url地址映射

2. public String userinfo(Model model, @PathVariable("userId") int userId,  HttpSession session) {

3.         System.out.println("进入  userinfo  页面");

4.        //判断是否有用户登录

5.        User user1 = (User) session.getAttribute("user");

6.        if (user1 == null) {

7.            return "login";

8.        }

9.        User user = userService.selectUserById(userId);

10.        model.addAttribute("user", user);

11.        return "userinfo";

12.    }

上面例子中如果浏览器请求的是 /user/1 的时候，就表示此时的用户 id 为 1，此时就会先从 session 中查找是否有 “user” 属性，如果有的话，就代表用户此时处于登录的状态，如果没有的话，就会让用户返回到登录页面，这种机制在各种网站经常会使用的，然后根据这个 id = 1 ，去查找用户的信息，然后把查找的 “user” 放在 model 中，然后返回用户详情页面，最后在页面中用 $!{user.name} 获取用户的名字，同样的方式可以获取用户的其他信息，把所有的用户详情信息展示出来。

创建 Spring MVC 之器

Spring MVC 核心 Servlet 架构图如下：

Java 中常用的 Servlet 我在另外一篇文章写的很清楚了，有兴趣的请看：通过源码详解 Servlet ，这里我就不再解释了。

这里主要讲 Spring 中的 HttpServletBean、FrameworkServlet、DispatcherServlet 这三个类的创建过程。

通过上面的图，可以看到这三个类直接实现三个接口：EnvironmentCapable、EnvironmentAware、ApplicationContextAware。下面我们直接看下这三个接口的内部是怎样写的。

EnvironmentCapable.java

1. public interface EnvironmentCapable {

2.    //返回组件的环境，可能返回 null 或者默认环境

3.    @Nullable

4.    Environment getEnvironment();

5. }

EnvironmentAware.java

1. public interface EnvironmentAware extends Aware {

2.    //设置组件的运行环境

3.    void setEnvironment(Environment environment);

4. }

ApplicationContextAware.java

1. public interface ApplicationContextAware extends Aware {

2.    //设置运行对象的应用上下文

3.    //当类实现这个接口后，这个类可以获取ApplicationContext中所有的bean，也就是说这个类可以直接获取Spring配置文件中所有有引用到的bean对象

4.    void setApplicationContext(ApplicationContext applicationContext) throws BeansException;

5. }

怎么使用这个这个接口呢？

参考文章：org.springframework.context.ApplicationContextAware使用理解

HttpServletBean

这里就直接看其中最重要的 init() 方法的代码了：

1. /**

2. * 将配置参数映射到此servlet的bean属性，并调用子类初始化。

3. *  如果 bean 配置不合法（或者需要的参数丢失）或者子类初始化发生错误，那么就会抛出 ServletException 异常

4. */

5. @Override

6. public final void init() throws ServletException {

7.   //日志代码删除了

9.   // 从init参数设置bean属性。

10.   //获得web.xml中的contextConfigLocation配置属性，就是spring MVC的配置文件

11.   PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);

12.   if (!pvs.isEmpty()) {

13.      try {

14.         BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);

15.         //获取服务器的各种信息

16.         ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());

17.         bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));

18.         //模板方法，可以在子类中调用，做一些初始化工作，bw代表DispatcherServelt

19.         initBeanWrapper(bw);

20.         //将配置的初始化值设置到DispatcherServlet中

21.         bw.setPropertyValues(pvs, true);

22.      }

23.      catch (BeansException ex) {

24.         //日志代码

25.         throw ex;

26.      }

27.   }

29.   // Let subclasses do whatever initialization they like.

30.   //模板方法，子类初始化的入口方法

31.   initServletBean();

33.   //日志代码删除了

34. }

FrameworkServlet

其中重要方法如下：里面也就两句关键代码，日志代码我直接删掉了

1. protected final void initServletBean() throws ServletException {

2.        //日志代码删除了

3.        long startTime = System.currentTimeMillis();

5.        //就是 try 语句里面有两句关键代码

6.        try {

7.            //初始化 webApplicationContext

8.            this.webApplicationContext = initWebApplicationContext();

9.            //模板方法，

10.            initFrameworkServlet();

11.        }

12.        catch (ServletException ex) {

13.            this.logger.error("Context initialization failed", ex);

14.            throw ex;

15.        }

16.        catch (RuntimeException ex) {

17.            this.logger.error("Context initialization failed", ex);

18.            throw ex;

19.        }

21.        //日志代码删除了

22.    }

再来看看上面代码中调用的 initWebApplicationContext() 方法

1. protected WebApplicationContext initWebApplicationContext() {

2.        //获取 rootContext

3.        WebApplicationContext rootContext =

4.                WebApplicationContextUtils.getWebApplicationContext(getServletContext());

5.        WebApplicationContext wac = null;

7.        if (this.webApplicationContext != null) {

8.            // 上下文实例在构造时注入 - >使用它

9.            wac = this.webApplicationContext;

10.            if (wac instanceof ConfigurableWebApplicationContext) {

11.                ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;

12.                if (!cwac.isActive()) {

13.                // 如果上下文尚未刷新 -> 提供诸如设置父上下文，设置应用程序上下文ID等服务

14.                    if (cwac.getParent() == null) {

15.            // 上下文实例被注入没有显式的父类 -> 将根应用程序上下文（如果有的话可能为null）设置为父级

16.                        cwac.setParent(rootContext);

17.                    }

18.                    configureAndRefreshWebApplicationContext(cwac);

19.                }

20.            }

21.        }

22.        if (wac == null) {

23.    // 当 WebApplicationContext 已经存在 ServletContext 中时，通过配置在 servlet 中的 ContextAttribute 参数获取

24.            wac = findWebApplicationContext();

25.        }

26.        if (wac == null) {

27.            // 如果 WebApplicationContext 还没有创建，则创建一个

28.            wac = createWebApplicationContext(rootContext);

29.        }

30.        if (!this.refreshEventReceived) {

31.            // 当 ContextRefreshedEvent 事件没有触发时调用此方法，模板方法，可以在子类重写

32.            onRefresh(wac);

33.        }

34.        if (this.publishContext) {

35.            // 将 ApplicationContext 保存到 ServletContext 中去

36.            String attrName = getServletContextAttributeName();

37.            getServletContext().setAttribute(attrName, wac);

38.            if (this.logger.isDebugEnabled()) {

39.                this.logger.debug("Published WebApplicationContext of servlet '" + getServletName() +

40.                        "' as ServletContext attribute with name [" + attrName + "]");

41.            }

42.        }

43.        return wac;

44.    }

initWebApplicationContext 方法做了三件事：

• 获取 Spring 的根容器 rootContext

• 设置 webApplicationContext 并根据情况调用 onRefresh 方法

• 将 webApplicationContext 设置到 ServletContext 中

这里在讲讲上面代码中的 wac == null 的几种情况：

1）、当 WebApplicationContext 已经存在 ServletContext 中时，通过配置在 servlet 中的 ContextAttribute 参数获取，调用的是 findWebApplicationContext() 方法

1. protected WebApplicationContext findWebApplicationContext() {

2.        String attrName = getContextAttribute();

3.        if (attrName == null) {

4.            return null;

5.        }

6.        WebApplicationContext wac =

7.                WebApplicationContextUtils.getWebApplicationContext(getServletContext(), attrName);

8.        if (wac == null) {

9.            throw new IllegalStateException("No WebApplicationContext found: initializer not registered?");

10.        }

11.        return wac;

12.    }

2)、如果 WebApplicationContext 还没有创建，调用的是 createWebApplicationContext 方法

1. protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {

2.        //获取创建类型

3.        Class<?> contextClass = getContextClass();

4.        //删除了打印日志代码

6.        //检查创建类型

7.        if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {

8.            throw new ApplicationContextException(

9.                    "Fatal initialization error in servlet with name '" + getServletName() +

10.                    "': custom WebApplicationContext class [" + contextClass.getName() +

11.                    "] is not of type ConfigurableWebApplicationContext");

12.        }

13.        //具体创建

14.        ConfigurableWebApplicationContext wac =

15.                (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

17.        wac.setEnvironment(getEnvironment());

18.        wac.setParent(parent);

19.  //并设置的 contextConfigLocation 参数传给 wac，默认是 WEB-INFO/[ServletName]-Servlet.xml

20.        wac.setConfigLocation(getContextConfigLocation());

22.        //调用的是下面的方法

23.        configureAndRefreshWebApplicationContext(wac);

25.        return wac;

26.    }

28. protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {

29.        if (ObjectUtils.identityToString(wac).equals(wac.getId())) {

30.            // The application context id is still set to its original default value

31.            // -> assign a more useful id based on available information

32.            if (this.contextId != null) {

33.                wac.setId(this.contextId);

34.            }

35.            else {

36.                // Generate default id...

37.                wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +

38.                        ObjectUtils.getDisplayString(getServletContext().getContextPath()) + '/' + getServletName());

39.            }

40.        }

42.        wac.setServletContext(getServletContext());

43.        wac.setServletConfig(getServletConfig());

44.        wac.setNamespace(getNamespace());

45.        wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));

47.        // The wac environment's #initPropertySources will be called in any case when the context

48.        // is refreshed; do it eagerly here to ensure servlet property sources are in place for

49.        // use in any post-processing or initialization that occurs below prior to #refresh

50.        ConfigurableEnvironment env = wac.getEnvironment();

51.        if (env instanceof ConfigurableWebEnvironment) {

52.            ((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());

53.        }

55.        postProcessWebApplicationContext(wac);

56.        applyInitializers(wac);

57.        wac.refresh();

58.    }

里面还有 doXXX() 方法，大家感兴趣的可以去看看。

DispatcherServlet

DispatcherServlet 继承自 FrameworkServlet，onRefresh 方法是 DispatcherServlet 的入口方法，在 initStrategies 方法中调用了 9 个初始化的方法。

这里分析其中一个初始化方法：initLocaleResolver() 方法

1. private void initLocaleResolver(ApplicationContext context) {

2.        try {

3.            //在 context 中获取

4.            this.localeResolver = context.getBean(LOCALE_RESOLVER_BEAN_NAME, LocaleResolver.class);

5.            //删除了打印日志的代码

6.        }

7.        catch (NoSuchBeanDefinitionException ex) {

8.            //使用默认的策略

9.            this.localeResolver = getDefaultStrategy(context, LocaleResolver.class);

10.            //删除了打印日志的代码

11.        }

12.    }

查看默认策略代码：

1. protected <T> T getDefaultStrategy(ApplicationContext context, Class<T> strategyInterface) {

2.        //调用 getDefaultStrategies 方法

3.        List<T> strategies = getDefaultStrategies(context, strategyInterface);

4.        if (strategies.size() != 1) {

5.            throw new BeanInitializationException(

6.                    "DispatcherServlet needs exactly 1 strategy for interface [" + strategyInterface.getName() + "]");

7.        }

8.        return strategies.get(0);

9.    }

11.    /**

12.     * Create a List of default strategy objects for the given strategy interface.

13.     * <p>The default implementation uses the "DispatcherServlet.properties" file (in the same

14.     * package as the DispatcherServlet class) to determine the class names. It instantiates

15.     * the strategy objects through the context's BeanFactory.

16.     */

17.    @SuppressWarnings("unchecked")

18.    protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {

19.        String key = strategyInterface.getName();

20.        //根据策略接口的名字从 defaultStrategies 获取所需策略的类型

21.        String value = defaultStrategies.getProperty(key);

22.        if (value != null) {

23.            //如果有多个默认值的话，就以逗号分隔为数组

24.            String[] classNames = StringUtils.commaDelimitedListToStringArray(value);

25.            List<T> strategies = new ArrayList<>(classNames.length);

26.            //按获取到的类型初始化策略

27.            for (String className : classNames) {

28.                try {

29.                    Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());

30.                    Object strategy = createDefaultStrategy(context, clazz);

31.                    strategies.add((T) strategy);

32.                }

33.                catch (ClassNotFoundException ex) {

34.                    throw new BeanInitializationException(

35.                            "Could not find DispatcherServlet's default strategy class [" + className + "] for interface [" + key + "]", ex);

36.                }

37.                catch (LinkageError err) {

38.                    throw new BeanInitializationException(

39.                            "Error loading DispatcherServlet's default strategy class [" + className + "] for interface [" + key + "]: problem with class file or dependent class", err);

40.                }

41.            }

42.            return strategies;

43.        }

44.        else {

45.            return new LinkedList<>();

46.        }

47.    }

其他几个方法大概也类似，我就不再写了。

小结

主要讲了 Spring MVC 自身创建过程，分析了 Spring MVC 中 Servlet 的三个层次：HttpServletBean、FrameworkServlet 和 DispatcherServlet。HttpServletBean 继承自 Java 的 HttpServlet，其作用是将配置的参数设置到相应的属性上；FrameworkServlet 初始化了 WebApplicationContext；DispatcherServlet 初始化了自身的 9 个组件。

Spring MVC 之用

分析 Spring MVC 是怎么处理请求的。首先分析 HttpServletBean、FrameworkServlet 和 DispatcherServlet 这三个 Servlet 的处理过程，最后分析 doDispatcher 的结构。

HttpServletBean

参与了创建工作，并没有涉及请求的处理。

FrameworkServlet

在类中的 service() 、doGet()、doPost()、doPut()、doDelete()、doOptions()、doTrace() 这些方法中可以看到都调用了一个共同的方法 processRequest() ，它是类在处理请求中最核心的方法。

1. protected final void processRequest(HttpServletRequest request, HttpServletResponse response)

2.            throws ServletException, IOException {

4.        long startTime = System.currentTimeMillis();

5.        Throwable failureCause = null;

6.        //获取 LocaleContextHolder 中原来保存的 LocaleContext

7.        LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();

8.        //获取当前请求的 LocaleContext

9.        LocaleContext localeContext = buildLocaleContext(request);

10.        //获取 RequestContextHolder 中原来保存的 RequestAttributes

11.        RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();

12.        //获取当前请求的 ServletRequestAttributes

13.        ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

15.        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

16.        asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

17. //将当前请求的 LocaleContext 和 ServletRequestAttributes 设置到 LocaleContextHolder 和 RequestContextHolder

18.        initContextHolders(request, localeContext, requestAttributes);

20.        try {

21.            //实际处理请求的入口，这是一个模板方法，在 Dispatcher 类中才有具体实现

22.            doService(request, response);

23.        }catch (ServletException ex) {

24.            failureCause = ex;

25.            throw ex;

26.        }catch (IOException ex) {

27.            failureCause = ex;

28.            throw ex;

29.        }catch (Throwable ex) {

30.            failureCause = ex;

31.            throw new NestedServletException("Request processing failed", ex);

32.        }finally {

33.            //将 previousLocaleContext，previousAttributes 恢复到 LocaleContextHolder 和 RequestContextHolder 中

34.            resetContextHolders(request, previousLocaleContext, previousAttributes);

35.            if (requestAttributes != null) {

36.                requestAttributes.requestCompleted();

37.            }

38.            //删除了日志打印代码

39.            //发布了一个 ServletRequestHandledEvent 类型的消息

40.            publishRequestHandledEvent(request, response, startTime, failureCause);

41.        }

42.    }

DispatcherServlet

上一章中其实还没把该类讲清楚，在这个类中，里面的智行处理的入口方法应该是 doService 方法，方法里面调用了 doDispatch 进行具体的处理，在调用 doDispatch 方法之前 doService 做了一些事情：首先判断是不是 include 请求，如果是则对 request 的 Attribute 做个快照备份，等 doDispatcher 处理完之后（如果不是异步调用且未完成）进行还原 ，在做完快照后又对 request 设置了一些属性。

1. protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {

2.        // Keep a snapshot of the request attributes in case of an include,

3.        // to be able to restore the original attributes after the include.

4.        Map<String, Object> attributesSnapshot = null;

5.        if (WebUtils.isIncludeRequest(request)) {

6.            attributesSnapshot = new HashMap<>();

7.            Enumeration<?> attrNames = request.getAttributeNames();

8.            while (attrNames.hasMoreElements()) {

9.                String attrName = (String) attrNames.nextElement();

10.                if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)){

11.                    attributesSnapshot.put(attrName, request.getAttribute(attrName));

12.                }

13.            }

14.        }

15.        // Make framework objects available to handlers and view objects.

16.        request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());

17.        request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);

18.        request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);

19.        request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

21.        FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);

22.        if (inputFlashMap != null) {

23.            request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));

24.        }

25.        request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());

26.        request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);

28.        try {

29.            //调用 doDispatch 方法

30.            doDispatch(request, response);

31.        }finally {

32.            if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {

33.                // Restore the original attribute snapshot, in case of an include.

34.                if (attributesSnapshot != null) {

35.                    restoreAttributesAfterInclude(request, attributesSnapshot);

36.                }

37.            }

38.        }

39.    }

doDispatch() 方法：

1. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {

2.        HttpServletRequest processedRequest = request;

3.        HandlerExecutionChain mappedHandler = null;

4.        boolean multipartRequestParsed = false;

6.        WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

7.        try {

8.            ModelAndView mv = null;

9.            Exception dispatchException = null;

10.            try {

11.                //检查是不是上传请求

12.                processedRequest = checkMultipart(request);

13.                multipartRequestParsed = (processedRequest != request);

15.                // Determine handler for the current request.  根据 request 找到 Handler

16.                mappedHandler = getHandler(processedRequest);

17.                if (mappedHandler == null || mappedHandler.getHandler() == null) {

18.                    noHandlerFound(processedRequest, response);

19.                    return;

20.                }

22.    // Determine handler adapter for the current request.根据 Handler 找到对应的 HandlerAdapter

23.                HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

24.                // Process last-modified header, if supported by the handler.

25.                //处理 GET 、 HEAD 请求的 LastModified

26.                String method = request.getMethod();

27.                boolean isGet = "GET".equals(method);

28.                if (isGet || "HEAD".equals(method)) {

29.                    long lastModified = ha.getLastModified(request, mappedHandler.getHandler());

30.                    if (logger.isDebugEnabled()) {

31.                        logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);

32.                    }

33.                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {

34.                        return;

35.                    }

36.                }

37.                //执行相应的 Interceptor 的 preHandle

38.                if (!mappedHandler.applyPreHandle(processedRequest, response)) {

39.                    return;

40.                }

41.                // Actually invoke the handler. HandlerAdapter 使用 Handler 处理请求

42.                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

43.                //如果需要异步处理，直接返回

44.                if (asyncManager.isConcurrentHandlingStarted()) {

45.                    return;

46.                }

47.                //当 view 为空时，根据 request 设置默认 view

48.                applyDefaultViewName(processedRequest, mv);

49.                //执行相应 Interceptor 的 postHandler

50.                mappedHandler.applyPostHandle(processedRequest, response, mv);

51.            }catch (Exception ex) {

52.                dispatchException = ex;

53.            }catch (Throwable err) {

54.                // As of 4.3, we're processing Errors thrown from handler methods as well,

55.                // making them available for @ExceptionHandler methods and other scenarios.

56.                dispatchException = new NestedServletException("Handler dispatch failed", err);

57.            }

58.            //调用 processDispatchResult 方法处理上面处理之后的结果（包括处理异常，渲染页面，发出完成通知触发 Interceptor 的 afterCompletion）

59.            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

60.        }catch (Exception ex) {

61.            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);

62.        }catch (Throwable err) {

63.            triggerAfterCompletion(processedRequest, response, mappedHandler,

64.                    new NestedServletException("Handler processing failed", err));

65.        }finally {

66.          //判断是否执行异步请求

67.            if (asyncManager.isConcurrentHandlingStarted()) {

68.                // Instead of postHandle and afterCompletion

69.                if (mappedHandler != null) {

70.                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);

71.                }

72.            }else {

73.                // Clean up any resources used by a multipart request. 删除上传请求的资源

74.                if (multipartRequestParsed) {

75.                    cleanupMultipart(processedRequest);

76.                }

77.            }

78.        }

79.    }

Handler，HandlerMapping，HandlerAdapter 三个区别：

• Handler：处理器，对应 MVC 的 C层，也就是 Controller 层，具体表现形式有很多种，可以是类，方法，它的类型是 Object，只要可以处理实际请求就可以是 Handler。

• HandlerMapping：用来查找 Handler 的。

• HandlerAdapter ：Handler 适配器，

另外 View 和 ViewResolver 的原理与 Handler 和 HandlerMapping 的原理类似。

小结

本章分析了 Spring MVC 的请求处理的过程。