Spring框架之spring-webmvc源码完全解析

Spring框架之spring-webmvc源码完全解析

Spring框架提供了构建Web应用程序的全功能MVC模块。Spring MVC分离了控制器、模型对象、分派器以及处理程序对象的角色，支持多种视图技术，如JSP、Velocity、Tiles、iText和POI。

Spring Web模型视图控制器（MVC）框架是基于Servlet功能实现的。通过实现Servlet接口的DispatcherServlet来封装其核心功能实现，通过将请求分派给处理程序，同时具有可配置的处理程序映射，视图解析，区域设置，本地化和主题解析，并且支持上传文件。

Spring MVC框架功能主要三点：1、将Web页面的请求传给服务器；2、根据不同的请求处理不同的逻辑单元；3、返回处理结果数据并跳转到响应的页面。

本文基于version为5.2.4.BUILD-SNAPSHOT的Spring源码，对Spring-webmvc十一个子模块中包含的接口和类进行分析。

介绍spring-webmvc接口和类前先介绍几个概念：

       （1）spring-web和spring-webmvc关系：

spring-web 提供了核心 HTTP 集成，包括一些便捷的 servlet 过滤器， Spring HTTP 调用，用于集成其它 web 框架的基础结构以及技术（Hessian，Burlap）。

spring-webmvc 是 Spring MVC 的一个实现。spring-webmvc 依赖于 spring-web，这样包含它就会间接地添加 spring-web，不必显示添加 spring-web。

       （2）MVC（Model-View-Controller）三元组的概念

Model（模型）：数据模型，提供要展示的数据，因此包含数据和行为，可以认为是领域模型或JavaBean组件（包含数据和行为），不过现在一般都分离开来：Value Object（数据） 和 服务层（行为）。也就是模型提供了模型数据查询和模型数据的状态更新等功能，包括数据和业务。

View（视图）：负责进行模型的展示，一般就是我们见到的用户界面，客户想看到的东西。

Controller（控制器）：接收用户请求，委托给模型进行处理（状态改变），处理完毕后把返回的模型数据返回给视图，由视图负责展示。 也就是说控制器做了调度员的工作。

在Web MVC模式下，模型无法主动推数据给视图，如果用户想要视图更新，需要再发送一次请求（即请求-响应模型）。

       （3）Servlet简介

Servlet就是一个Java接口，只有5个方法的接口，Servlet接口中的5大方法：

1、void init(ServletConfig)：初始化servlet，它是servlet的生命周期方法，由web容器调用一次。

2、void service(ServletRequest, ServletResponse)：为传入的请求提供响应，它由容器的每个请求调用。

3、void destroy()：仅被调用一次，表明servlet正在被销毁。

4、ServletConfig getServletConfig()：返回ServletConfig对象。

5、String getServletInfo()：返回有关servlet的信息，如作者、版权、版本等。

Servlet接口定义的是一套处理网络请求的规范，所有实现servlet的类，都要实现它的5个方法。其中最主要的是两个生命周期方法init()和destroy()，还有一个处理请求service()。也就是说所有实现servlet接口的类，或者说，所有想要处理网络请求的类，都要回答三个问题：初始化要做什么，销毁时要做什么，接受到请求时要做什么。

Spring主要通过DispatcherServlet实现了Servlet。init()接口在其父类HttpServletBean中实现。service()接口在其父类FrameworkServlet中实现（回调了DispatcherServlet的doService()方法）。destroy()接口在父类FrameworkServlet中实现。

实现了servlet的类还不能处理请求。请求是通过servlet容器来到servlet，比如我们最常用的tomcat。所以需要将servlet部署到一个容器中，否则servlet根本不会起作用。容器（如tomcat）才是与客户端直接打交道的，它监听了端口，请求过来后，根据url等信息，确定要将请求交给哪个servlet去处理，然后调用那个servlet的service方法，service方法返回一个response对象，容器再把这个response返回给客户端。

一、web/servlet/

1.1  DispatcherServlet

在整个 Spring MVC 框架中，DispatcherServlet（前置控制器） 处于核心位置，负责协调和组织不同组件完成请求处理并返回响应工作。配置在web.xml文件中的，拦截匹配的请求，将拦截下来的请求，依据相应的规则分发到目标Controller来处理，主要用于进行调度，控制流程。功能主要有：

1、文件上传解析，如果请求类型是multipart将通过MultipartResolver进行文件上传解析；

2、通过HandlerMapping，将请求映射到处理器（返回一个HandlerExecutionChain，它包括一个处理器、多个HandlerInterceptor拦截器）；

3、通过HandlerAdapter支持多种类型的处理器(HandlerExecutionChain中的处理器)；

4、通过ViewResolver解析逻辑视图名到具体视图实现；

5、本地化解析；

6、渲染具体的视图等；

7、如果执行过程中遇到异常将交给HandlerExceptionResolver来解析。

DispatcherServlet默认使用WebApplicationContext作为上下文，上下文中有一些特殊的Bean：

1、Controller：处理器/页面控制器，实现的是MVC中C 那个组成部分，但控制逻辑转移到前端控制器了，用于对请求进行处理；

2、HandlerMapping：请求到处理器的映射，如果映射成功返回一个HandlerExecutionChain对象（包含一个Handler处理器（页面控制器）对象、多个HandlerInterceptor拦截器）对象，如BeanNameUrlHandlerMapping将URL与Bean名字映射，映射成功的Bean就是此处的处理器；

3、HandlerAdapter：HandlerAdapter将会把处理器包装为适配器，从而支持多种类型的处理器，即适配器设计模式的应用，从而很容易支持很多类型的处理器；如SimpleControllerHandlerAdapter将对实现了Controller接口的Bean进行适配，并且掉处理器的handleRequest方法进行功能处理；

4、ViewResolver：ViewResolver将把逻辑视图名解析为对应的视图，通过这种策略模式，很容易更换其他视图技术；如InternalResourceViewResolver将逻辑视图名映射为jsp视图；

5、LocalResover：本地化解析，因为Spring支持国际化，因此LocalResover解析客户端的Locale信息从而方便进行国际化；

6、ThemeResovler：主题解析，解析你的web应用所使用的主题，以提供个性化的布局。通过它来实现一个页面多套风格，即常见的类似于软件皮肤效果；

7、MultipartResolver：文件上传解析，用于支持文件上传；

8、HandlerExceptionResolver：处理器异常解析，可以将异常映射到相应的统一错误界面，从而显示用户友好的界面（而不是给用户看到具体的错误信息）；

9、RequestToViewNameTranslator：当处理器没有返回逻辑视图名等相关信息时，自动将请求URL映射为逻辑视图名；

10、FlashMapManager：用于管理FlashMap的策略接口，FlashMap用于存储一个请求的输出，当进入另一个请求时作为该请求的输入，通常用于重定向场景。

DispatcherServlet 处理请求的流程：

1、Tomcat 启动，对 DispatcherServlet 进行实例化，然后调用它的 init() 方法进行初始化，在这个初始化过程中完成了：对 web.xml 中初始化参数的加载、建立 WebApplicationContext (SpringMVC的IOC容器)、进行组件的初始化；

2、客户端发出请求，由 Tomcat 接收到这个请求，如果匹配 DispatcherServlet 在 web.xml 中配置的映射路径，Tomcat 就将请求转交给 DispatcherServlet 处理；

3、DispatcherServlet 从容器中取出所有 HandlerMapping 实例（每个实例对应一个 HandlerMapping 接口的实现类）并遍历，每个 HandlerMapping 会根据请求信息，通过自己实现类中的方式去找到处理该请求的 Handler（执行程序，如Controller中的方法），并且将这个 Handler 与一堆 HandlerInterceptor（拦截器）封装成一个 HandlerExecutionChain 对象，一旦有一个 HandlerMapping 可以找到 Handler 则退出循环；

4、DispatcherServlet 取出 HandlerAdapter 组件，根据已经找到的 Handler，再从所有 HandlerAdapter 中找到可以处理该 Handler 的 HandlerAdapter 对象；

5、执行 HandlerExecutionChain 中所有拦截器的 preHandler() 方法，然后再利用 HandlerAdapter 执行 Handler ，执行完成得到 ModelAndView，再依次调用拦截器的 postHandler() 方法；

6、利用 ViewResolver 将 ModelAndView 或是 Exception（可解析成 ModelAndView）解析成 View，然后 View 会调用 render() 方法再根据 ModelAndView 中的数据渲染出页面；

7、最后再依次调用拦截器的 afterCompletion() 方法，这一次请求就结束了。

1.2  FrameworkServlet

FrameworkServlet是Spring web框架的基本servlet实现类，通过JavaBean的方式集成了Application context，所有新实现的servlet最好都继承于该类。该类提供了HttpServlet的所有接口实现，自带了一个web容器，它实现了WebApplicationContextAware接口，所以能根据指定的容器配置文件，来初始化自己管理的容器。

FrameworkServlet提供两个功能：

1、为每个servlet管理一个WebApplicationContext实例（即每个servlet会自己的一个web容器），每个servlet都有自己的配置空间，相互独立。

2、对每一个请求，无论是否成功处理，都会在每个请求上发布事件。

1.3  HttpServletBean

dispatcherServlet 继承FrameworkServlet 继承 HttpServletBean 继承 HttpServlet。HttpServletBean继承HttpServlet，因此在Web容器启动时将调用它的init方法，该初始化方法的主要作用：

将Servlet初始化参数（init-param）设置到该组件上（如contextAttribute、contextClass、namespace、contextConfigLocation），通过BeanWrapper简化设值过程，方便后续使用；

提供给子类初始化扩展点，initServletBean()，该方法由FrameworkServlet覆盖。

1.4  FlashMap

FlashMap继承自HashMap，一个FlashMap保存着一套Redirect转发所传递的参数。实际的Session中保存的FlashMap是List<FlashMap>类型，也就是说一个Session可以保存多个FlashMap。

1.5  FlashMapManager

FlashMapManger用于管理FlashMap，FlashMap可以从Manger获取。

1.6  HandlerAdapter

HandlerAdapter处理适配器，就是适配不同的处理器，将他们封装起来调用同一个接口方法，这样DispatcherServlet就只需要调用接口方法，而不需要在DispatcherServlet判断调用哪一个具体的HandlerAdapter的实现类了。

HandlerAdapter处理流程：

1、DispatcherServlet会根据配置文件信息注册HandlerAdapter，如果在配置文件中没有配置，那么DispatcherServlet会获取HandlerAdapter的默认配置，如果是读取默认配置的话，DispatcherServlet会读取DispatcherServlet.properties文件，该文件中配置了三种HandlerAdapter：HttpRequestHandlerAdapter，SimpleControllerHandlerAdapter和AnnotationMethodHandlerAdapter。DispatcherServlet会将这三个HandlerAdapter对象存储到它的handlerAdapters这个集合属性中，这样就完成了HandlerAdapter的注册。

2、DispatcherServlet会根据handlerMapping传过来的controller与已经注册好了的HandlerAdapter进行匹配，看哪一种HandlerAdapter支持该controller类型，如果找到了其中一种HandlerAdapter是支持传过来的controller类型，那么该HandlerAdapter会调用自己的handle方法，handle方法运用java的反射机制执行controller的具体方法来获得ModelAndView，例如SimpleControllerHandlerAdapter是支持实现了controller接口的控制器，如果自己写的控制器实现了controller接口，那么SimpleControllerHandlerAdapter就会去执行自己写控制器中的具体方法来完成请求。

几种适配器对应的处理器以及这些处理器的作用：

1、AnnotationMethodHandlerAdapter主要是适配注解类处理器，注解类处理器就是我们经常使用的@Controller的这类处理器。

2、HttpRequestHandlerAdapter主要是适配静态资源处理器，静态资源处理器就是实现了HttpRequestHandler接口的处理器，这类处理器的作用是处理通过SpringMVC来访问的静态资源的请求。

3、SimpleControllerHandlerAdapter是Controller处理适配器，适配实现了Controller接口或Controller接口子类的处理器，比如我们经常自己写的Controller来继承MultiActionController，那么自己写的这些Controller就会由SimpleControllerHandlerAdapter来适配。

4、SimpleServletHandlerAdapter是Servlet处理适配器，适配实现了Servlet接口或Servlet的子类的处理器，我们不仅可以在web.xml里面配置Servlet，其实也可以用SpringMVC来配置Servlet，不过这个适配器很少用到，而且SpringMVC默认的适配器没有他，默认的是前面的三种。

1.7  HandlerExecutionChain

HandlerExecutionChain类（处理器执行链）：由一个handler（处理器对象）和若干的HandlerInterceptor（拦截器）构成。就是对handle进行包装，将拦截器和handle组合起来执行。HandlerExecutionChain只能通过HanderMapping接口中的getHandler方法（getHandler方法是HandlerMapping接口中的唯一方法，此方法可以利用用户请求request中的信息来生成HandlerExecutionChain对象）来获得。

这个类中有几个主要的方法：

1、applyPreHandle()，按照列表中interceptor的顺序来执行它们的preHandle方法，直到有一个返回false。返回false后这个方法就会调用triggerAfterCompletion方法，此时this.interceptorIndex指向上一个返回true的interceptor的位置，所以它会按逆序执行所有返回true的interceptor的afterCompletion方法。

2、applyPostHandle()，就是按照逆序执行所有interceptor的postHandle方法。

3、triggerAfterCompletion()也是从最后一次preHandle成功的interceptor处逆序执行afterCompletion方法。

SpringMVC的流程。

1、 用户发送请求，经过前端控制器Dispacherservlet（Controller的核心）将url交给处理器映射器HandlerMapping处理。

2、 处理器映射器HandlerMapping处理url，返回HandlerExecutionChain（可能包含拦截器，一定包含自定义的Controller(handler)）。

3、 前端控制器将Controller交给处理器适配器HandlerAdapter处理，处理完成后，返回MV对象（ModelAndView）。

4、 前端控制器将MV交给视图解析器处理ViewResolver，处理的过程：将MV拆分成Model和view两个对象，并且将model渲染到view视图上，并且将view返回给前端控制器。

5、 最后，前端控制器将视图响应给用户。

1.8  HandlerInterceptor

HandlerInterceptor是一个Spring Web接口，实现该接口的组件可以拦截客户端请求并提供自定义处理逻辑。该接口定义了三种核心方法：

1、boolean preHandle()

此方法拦截请求处理的执行。在控制器处理请求并返回布尔值（用于确定下一步处理）之前将其触发。如果方法返回true，则请求转到处理程序。如果返回错误，则请求被中断。该方法可用于验证先决条件，例如令牌。

2、void postHandle()

在 Spring控制器处理程序之后，但在呈现视图之前（如果您构建的是遵循MVC架构的应用程序），将触发此方法。因此，在这种情况下，您可以修改ModelAndView将要显示的内容并附加其他数据。比如，当我们想向用户显示用于渲染页面的时间时。

3、void afterCompletion()

最后，这里的第三个方法afterCompletion()是在处理程序处理完并向用户呈现视图之后调用。在处理程序执行的任何情况下都将调用此方法，但前提是相应的preHandle()方法返回true。我们可以使用这种方法来记录处理程序处理的结果。

运行流程总结如下：

1、拦截器执行顺序是按照Spring配置文件中定义的顺序而定的。

2、会先按照顺序执行所有拦截器的preHandle方法，一直遇到return false为止，比如第二个preHandle方法是return false，则第三个以及以后所有拦截器都不会执行。若都是return true，则按顺序加载完preHandle方法。

3、然后执行主方法（自己的controller接口），若中间抛出异常，则跟return false效果一致，不会继续执行postHandle，只会倒序执行afterCompletion方法。

4、在主方法执行完业务逻辑（页面还未渲染数据）时，按倒序执行postHandle方法。若第三个拦截器的preHandle方法return false，则会执行第二个和第一个的postHandle方法和afterCompletion（postHandle都执行完才会执行这个，也就是页面渲染完数据后，执行after进行清理工作）方法。（postHandle和afterCompletion都是倒序执行）

HandlerInterceptor拦截器常见的用途有：

1、日志记录：记录请求信息的日志，以便进行信息监控、信息统计、计算PV（Page View）等。

2、权限检查：如登录检测，进入处理器检测检测是否登录，如果没有直接返回到登录页面；

3、性能监控：有时候系统在某段时间莫名其妙的慢，可以通过拦截器在进入处理器之前记录开始时间，在处理完后记录结束时间，从而得到该请求的处理时间（如果有反向代理，如apache可以自动记录）；

4、通用行为：读取cookie得到用户信息并将用户对象放入请求，从而方便后续流程使用，还有如提取Locale、Theme信息等，只要是多个处理器都需要的即可使用拦截器实现。

本质也是AOP（面向切面编程），也就是说符合横切关注点的所有功能都可以放入拦截器实现。

1.9  AsyncHandlerInterceptor

继承自HandlerInterceptor接口，新增了一个afterConcurrentHandlingStarted()方法，这个方法会在Controller方法异步执行时开始执行（HandlerInterceptor的postHandle方法则是需要等到Controller的异步执行完才能执行） 。

当开始处理一个异步请求的时候，DispatcherServlet退出，不会去调用postHandle和afterCompletion（这两个函数主要用于同步请求），因为请求处理的结果（如ModelAndView）可能从另一个线程中产生，可能还没准备完毕。在这种情况下，会调用afterConcurrentHandlingStarted方法，从而去执行一些任务，比如：将线程释放到Servlet容器之前，清除线程绑定的属性等。

当异步处理完成时，请求会被分发到容器中做进一步的处理。这个时候，DispatcherServlet就可以调用preHandle ， postHandle和afterCompletion 方法了。拦截器通过检查javax.servlet.ServletRequest的javax.servlet.DispatcherType属性值是”REQUEST”还是”ASYNC”来区分是“原始的请求”还是“异步处理完成后分发的请求”。

需要注意的是，当网络错误引发的异步请求超时或者完成，HandlerInterceptor的实现类都要做一些处理工作。因为这种情况下，Servlet容器不会调度，postHandle和afterCompletion方法自然也不会被调用。相反，可以通过WebAsyncManager中的registerCallbackInterceptor和registerDeferredResultInterceptor方法注册拦截器来跟踪异步请求。对于每一个异步请求，在其开始被处理之前，这项工作就可以通过preHandle提前进行。

1.10  HandlerMapping

HandlerMapping接口的实现对象定义了web请求映射和处理器（Handler）之间的映射。根据request找到相应的Handler处理器，并将 Handler与一堆 HandlerInterceptor（拦截器）封装到 HandlerExecutionChain 对象中。

在 HandlerMapping 接口的内部只有一个方法：HandlerExecutionChain getHandler(HttpServletRequest request);。HandlerMapping 是由 DispatcherServlet 调用，DispatcherServlet 会从容器中取出所有 HandlerMapping 实例并遍历，让 HandlerMapping 实例根据自己实现类的方式去尝试查找 Handler。

HandlerMapping的使用主要分为两步：注册和查找。

注册是根据配置文件中的配置将一个字符串和一个Controller类以<key,value>的形式存入到Map中，这个key就是对应的url中的某个字段。

查找就是HandlerMapping根据url中的的某个字段，在Map中以这个字段为key值对应的Controller类，并将Controller类封装成一个HandlerExecutionChain对象，HandlerExecutionChain中除了有Controller对象外，还有一组拦截器。

HandlerMapping有三种比较常见

1、BeanNameUrlHandlerMapping 根据bean标签的名称找到对应的Controller类

2、SimpleUrlHandlerMapping 根据bean的id查找对应的Controller类。

3、ControllerClassNameHandlerMapping 根据controller类的名字找到对应的Controller。

1.11  RequestToViewNameTranslator

RequestToViewNameTranslator 组件，视图名称转换器，用于解析出请求的默认视图名。就是说当 ModelAndView 对象不为 null，但是它的 View 对象为 null，则需要通过 RequestToViewNameTranslator 组件根据请求解析出一个默认的视图名称。

RequestToViewNameTranslator就是一个请求解析器，他的每个实现有各自的一个解析请求的算法（SpringMVC提供一个DefaultRequestToViewNameTranslator实现类），经过这个算法，从请求的url中获得一个字符串，将这个字符串作为要显示的jsp的名字，去jsp文件目录中查找，找到就显示，找不到才最终显示404。

1.12  View

视图基础接口，它的各种实现类是无状态的，因此是线程安全的。 该接口定义了两个方法：　getContentType()获取当前view的ContentType()，同http请求中的ContenType()是一样的作用。

render()这个是为视图绑定Request，Response和Model的方法。

1.13  SmartView

继承自View，提供了一些额外的信息，比如是否执行重定向。

1.14  ModelAndView

使用ModelAndView类用来存储处理完后的结果数据，以及显示该数据的视图。从名字上看ModelAndView中的Model代表模型，View代表视图，这个名字就很好地解释了该类的作用。业务处理器调用模型层处理完用户请求后，把结果数据存储在该类的model属性中，把要返回的视图信息存储在该类的view属性中，然后让该ModelAndView返回该Spring MVC框架。框架通过调用配置文件中定义的视图解析器，对该对象进行解析，最后把结果数据显示在指定的页面上。

具体作用：

1、返回指定页面：ModelAndView构造方法可以指定返回的页面名称，也可以通过setViewName()方法跳转到指定的页面 。

2、返回所需数值：使用addObject()设置需要返回的值，addObject()有几个不同参数的方法，可以默认和指定返回对象的名字。

1.15  ViewResolver

用来将String类型的视图名和Locale解析为View类型的视图。该接口只有1个方法，通过视图名称viewName和Locale对象得到View接口实现类。

1.16  ThemeResolver

主题解析，这种类似于我们手机更换主题，不同的UI，css等。

1.17  HandlerExceptionResolver

在Spring MVC中，所有用于处理在请求处理过程中抛出的异常，都要实现HandlerExceptionResolver接口。HandlerExceptionResolver是Spring MVC提供的非常好的通用异常处理工具，不过需要注意的是，它只能处理请求过程中抛出的异常，异常处理本身所抛出的异常和视图解析过程中抛出的异常它是不能处理的。

一个基于Spring MVC的Web应用程序中，可以存在多个实现了HandlerExceptionResolver的异常处理类，他们的执行顺序，由其order属性决定， order值越小，越是优先执行， 在执行到第一个返回不是null的ModelAndView的Resolver时，不再执行后续的尚未执行的Resolver的异常处理方法。

1.18  LocaleResolver

LocaleResolver主要作用在于从request中解析出Locale。Locale表示用户的区域，比如zh-cn，对不同的区域的用户，显示不同的结果，比如针对美国用户可以提供一个视图，而针对中国用户则可以提供另一个视图，这就是i18n。

1.19  LocaleContextResolver

继承自LocalResolver，添加对rich locale context的支持（可能包括区域设置和时区信息）。

1.20  ModelAndViewDefiningException

继承自ServletException，处理器处理任何时候都可能抛出该异常。

1.21  NoHandlerFoundException

默认情况下，当DispatcherServlet为一个请求找不到一个匹配的处理器的时候会发送一个404响应报文。但是当其属性值throwExceptionIfNoHandlerFound设置为true的时候，该异常抛出，可能会被一个HandlerExceptionResolver进行处理。

二、web/servlet/config

2.1  AnnotationDrivenBeanDefinitionParser 

负责解析xml的<tx:annotation-driven>元素。

2.2  CorsBeanDefinitionParser

实现BeanDefinitionParser 接口，包括一个parse方法。从xml文件中读取跨域配置信息，对 CorsConfiguration进行初始化，最后在Spring中注册。

2.3  DefaultServletHandlerBeanDefinitionParser

实现BeanDefinitionParser 接口，解析default-servlet-handler元素，注册DefaultServletHttpRequestHandler。

2.4  FreeMarkerConfigurerBeanDefinitionParser

mvc:freemarker-configurer 标签的解析器，同时注册FreeMarkerConfigurer bean。

2.5  GroovyMarkupConfigurerBeanDefinitionParser

解析mvc:groovy-configurer标签，注册GroovyConfigurer bean。

2.6  InterceptorsBeanDefinitionParser

解析mvc:interceptors元素，并注册成MappedInterceptorsDefinition集合。

2.7  MvcNamespaceHandler

解析mvc命名空间。

2.8  MvcNamespaceUtils

MVC 命名空间中的BeanDefinitionParsers使用到的功能函数。

2.9  ResourcesBeanDefinitionParser

继承自BeanDefinitionParser，解析resources元素，为映射资源请求请求注册ResourceHttpRequestHandler、SimpleUrlHandlerMapping和HttpRequestHandlerAdapter。同时也会使用ResourceResolvers和ResourceTransformers创建一个资源处理链。

2.10  ScriptTemplateConfigurerBeanDefinitionParser

解析mvc:script-template-configurer元素，注册一个ScriptTemplateConfigurer bean。

2.11  TilesConfigurerBeanDefinitionParser

解析mvc: tiles-configurer元素，注册一个相应的TilesConfigurer bean。

2.12  ViewControllerBeanDefinitionParser

继承自BeanDefinitionParser，用来下面三个MVC命名空间元素：view-controller、redirect-view-controller、status-controller。

2.13  ViewResolversBeanDefinitionParser

解析MVC命名空间元素：view-resolvers，注册ViewResolver bean definitions。

web/servlet/config/annotation

2.14  AsyncSupportConfigurer

为异步请求处理进行配置选项的帮助类。

2.15  ContentNegotiationConfigurer

创建一个ContentNegotiationManager，用一个或者多个ContentNegotiationStrategy实例配置它。

2.16  CorsRegistration

协助创建CorsConfiguration实例，为一个给定的URL路径模式。

2.17  CorsRegistry

跨域注册表，同理持有一组CorsRegistration，然后可以直接获取CorsConfiguration。

2.18  DefaultServletHandlerConfigurer

配置一个请求处理器，通过将请求转发到Servlet容器的默认Servlet，主要为静态资源服务。

2.19  DelegatingWebMvcConfiguration

DelegatingWebMvcConfiguration是对Spring MVC进行配置的一个代理类。它结合缺省配置和用户配置定义Spring MVC运行时最终使用的配置。继承自WebMvcConfigurationSupport，而WebMvcConfigurationSupport为Spring MVC提供缺省配置。

2.20  EnableWebMvc

在@Configuration注解的配置类中添加，用于为该应用添加SpringMVC的功能，即添加之后可以在项目中，可以使用@RequestMapping，@Controller等注解来定义请求处理与请求uri的映射和其他SpringMvc提供的功能。

2.21  InterceptorRegistration   

帮助创建一个MappedInterceptor。

2.22  InterceptorRegistry

拦截器注册表，管理一组InterceptorRegistration拦截器配置类，可以通过getInterceptor()方法得到MappedInterceptor对象。

2.23  PathMatchConfigurer

帮助配置一组mapped interceptors。

2.24  RedirectViewControllerRegistration

帮助注册一个单一的重定向视图控制器。

2.25  ResourceChainRegistration

帮助注册资源解析器和转换器。

2.26  ResourceHandlerRegistration

封装一些在创建资源处理器时需要的信息。

2.27  ResourceHandlerRegistry

存储资源处理器的注册，主要是为一些静态资源服务，如图片、CSS文件等。

2.28  UrlBasedViewResolverRegistration

帮助配置一个UrlBasedViewResolver。Spring MVC使用ViewResolver来根据controller中返回的view名关联到具体的View对象。使用View对象来渲染返回值以生成最终的视图，如html，json或pdf等。

2.29  ViewControllerRegistration

帮助注册一个视图控制器。

2.30  ViewControllerRegistry    

帮助注册一个简单的自动配置的控制器。

2.31  ViewResolverRegistry

帮助配置一系列的ViewResolver实例，该类会被configureViewResolvers使用。

2.32  WebMvcConfigurationSupport

这是MVC Java配置的一个主要的类，通过在@Configuration应用类加入注解@EnableWebMvc导入，一个更有效的方法是直接继承该类，然后重新里面的方法，在继承类中要添加@Configuration注解，要覆盖的@Bean方法添加@Bean注解。

2.33  WebMvcConfigurer

WebMvcConfigurer是一个接口，提供很多自定义的拦截器，例如跨域设置、类型转化器等等。可以说此接口为开发者提前想到了很多拦截层面的需求，方便开发者自由选择使用。

WebMvcConfigurer配置类其实是Spring内部的一种配置方式，采用JavaBean的形式来代替传统的xml配置文件形式进行针对框架个性化定制。基于java-based方式的spring mvc配置，需要创建一个配置类并实现WebMvcConfigurer 接口。

2.34  WebMvcConfigurerAdapter

在Spring Boot 1.5版本都是靠重写WebMvcConfigurerAdapter的方法来添加自定义拦截器，消息转换器等。SpringBoot 2.0 后，该类被标记为@Deprecated（弃用）。官方推荐直接实现WebMvcConfigurer或者直接继承WebMvcConfigurationSupport，方式一实现WebMvcConfigurer接口（推荐），方式二继承WebMvcConfigurationSupport类。

2.35  WebMvcConfigurerComposite

此类是一个委托代理类，在DelegatingWebMvcConfiguration类中实例化，并将系统自带或者自定义的配置类注入到成员变量delegates之中。

三、web/servlet/function

3.1  DefaultEntityResponseBuilder

EntityResponse.Builder的默认实现类。

3.2  DefaultRenderingResponseBuilder

RenderingResponse.Builder的默认实现类。

3.3  DefaultServerRequest

基于HttpServletRequest的ServerRequest的实现类。

3.4  DefaultServerRequestBuilder

ServerRequest.Builder的默认实现类。

3.5  DefaultServerResponseBuilder

ServerResponse.BodyBuilder的默认实现类。

3.6  EntityResponse

指定实体的ServerResponse子接口，暴露了实体数据。

3.7  HandlerFilterFunction

表示一个函数，用来过滤HandlerFunction。

3.8  HandlerFunction 

一个函数接口，用来处理ServerRequest。

3.9  PathResourceLookupFunction

查找函数，被RouterFunctions#resources(String, Resource)函数使用。

3.10  RenderingResponse

指定渲染的ServerResponse的子接口，暴露模型和临时性数据。

3.11  RequestPredicate

表示一个用来评估给定的ServerRequest的函数。

3.12  RequestPredicates

实现RequestPredicate接口的抽象类，实现了几个有用的请求匹配的操作，如基于path、HTTP方法的匹配。

3.13  ResourceHandlerFunction

基于资源的HandlerFunction接口的实现类。

3.14  RouterFunction

表示路由到一个HandlerFunction的函数。

3.15  RouterFunctionBuilder

RouterFunctions.Builder的默认实现类。

3.16  RouterFunctions

Spring功能性web框架的核心入口。

3.17  ServerRequest

表示服务端的HTTP请求，通过HandlerFunction处理。

3.18  ServerResponse

表示服务器端的一个HTTP响应，通过HandlerFunction或HandlerFilterFunction返回得到。

3.19  ToStringVisitor

RouterFunctions.Visitor的实现类，用来创建表示router函数的格式化字符串。

web/servlet/function/support

3.20  HandlerFunctionAdapter

HandlerAdapter接口实现类，用来支持HandlerFunction。

3.21  RouterFunctionMapping

HandlerMapping实现类，用来支持RouterFunctions。

四、web/servlet/handler

4.1  AbstractDetectingUrlHandlerMapping

抽象类，通过重写initApplicationContext来注册Handler，调用detectHandlers方法会根据配置的detectHand-lersInAcestorContexts参数从springMVC容器或者springMVC集群父容器中找到所有bean的beanName，然后调用determineUrlsForHandler方法对每个beanName解析出对应的urls，如果解析的结果不为空，则将解析出的urls和beanName注册到父类的map中。

4.2  AbstractHandlerExceptionResolver

实现HandlerExceptionResolver接口和Orderd接口，是HandlerExceptionResolver类的实现的基类。ResponseStatusExceptionResolver等具体的异常处理类均在AbstractHandlerExceptionResolver之上，实现了具体的异常处理方式。

4.3  AbstractHandlerMapping

AbstractHandlerMapping是HandlerMapping的抽象实现，所有的HandlerMapping都继承自AbstractHandlerMapping。

AbstractHandlerMapping采用模板模式设计了HandlerMapping实现的整体结构，子类只需要提供一些初始值或者具体的算法即可。

HandlerMapping的作用是根据request查找Handler和Interceptors。获取Handler的过程通过模板方法getHandlerInternal交给子类。AbstractHandlerMapping保存了所用配置的Interceptor，在获取Handler之后会自己根据从request中提取的lookupPath将相应的Interceptors装配上去。

定义了getHandlerInternal基本流程，进行url匹配HandlerMethod，如果有多于1个HandlerMethod被匹配，抛出错误信息，否则设置request的attribute信息将HandlerMapping接口中的几个属性暴露出来，最后返回HandlerMethod。同时它也实现了Handler和Method的收集和url映射规则。它实现了InitializingBean，在初始化时调用子类判定bean和method是否需要映射，如果需要将映射信息保存到MappingRegistry内部类中。

4.4  AbstractHandlerMethodExceptionResolver

它是ExceptionHandlerExceptionResolver的抽象父类，服务于处理器类型是HandlerMethod类型的抛出的异常，它并不规定实现方式必须是@ExceptionHandler。它复写了抽象父类AbstractHandlerExceptionResolver的shouldApplyTo方法。

AbstractHandlerMethodExceptionResolver和ExceptionHandlerExceptionResolver一起使用，完成使用@ExceptionHandler注释的方法进行对异常的解析。

4.5  AbstractHandlerMethodMapping

HandlerMapping实现类的抽象基类，定义了请求和HandlerMethod之间的映射关系。

4.6  AbstractUrlHandlerMapping

AbstractUrlHandlerMapping是AbstractHandlerMapping中两个主要继承类中的一个，任何以URL映射Handler的HandlerMapping都是继承了AbstractUrlHandlerMapping，其中主要负责的流程有两个，一个是自身的创建和初始化，而初始化则是为了初始化内部的HandlerMap，可是初始化HandlerMap其实是由子类实现的，AbstractUrlHandlerMapping只是提供子类注册Handler的途径，然后由不同的子类注册不同的Handler到Map中去，之后在AbstractUrlHandlerMapping就可以使用注册完成的HandlerMap对Handler进行查找。

4.7  BeanNameUrlHandlerMapping

BeanNameUrlHandlerMapping处理器映射器，会根据请求的url和Spring容器中定义的处理器bean的name属性值进行匹配，从而在spring容器中找到处理器bean的实例。

4.8  ConversionServiceExposingInterceptor   

Spring MVC的一个HandlerInterceptor，用于向请求添加一个属性，属性名称为ConversionService.class.getName()，值是Spring MVC配置定义的一个类型转换服务。该类型转换服务会在请求处理过程中用于请求参数或者返回值的类型转换。缺省情况下，Spring MVC配置机制会主动构建一个ConversionServiceExposingInterceptor应用于所有的请求。

4.9  DispatcherServletWebRequest

ServletWebRequest子类。

4.10  HandlerExceptionResolverComposite   

作为容器使用，可以封装别的Resolver，它并不会解析具体的异常，而是调用其他的异常解析器处理异常。

4.11  HandlerInterceptorAdapter

有三个方法：方别是preHandle，postHandle， afteCompletion。当我们需要使用的HandlerInterceptorAdapter实现相应的功能的时候（配置一个拦截器），就需要继承HandlerInterceptorAdapter，并实现其中相应的方法。

4.12  HandlerMappingIntrospector

从HandlerMapping中获取信息的帮助类，用来为一个指定的请求服务。提供了方法getMatchableHandlerMapping获取一个HandlerMapping，方法getCorsConfiguration获取CORS配置。

4.13  HandlerMethodMappingNamingStrategy

策略接口，用于将一个名字分配给一个handler method的 mapping。

4.14  MappedInterceptor

一个包括includePatterns和excludePatterns字符串集合并带有HandlerInterceptor的类。用于对于某些地址做特殊包括和排除的拦截器。

4.15  MatchableHandlerMapping

继承自HandlerMapping，用来判断指定的请求是否符合请求条件。

4.16  RequestMatchResult

用来保存通过MatchableHandlerMapping方法进行请求模式匹配得到的结果的容器。

4.17  SimpleMappingExceptionResolver

通过配置的异常类和view的对应关系来解析异常。

4.18  SimpleServletHandlerAdapter

简单Servlet处理器适配器，它是spring提供的处理适配器，专门适配类型为javax.servlet.Servlet的处理器，其最终执行的方法是Servlet的service方法。

4.19  SimpleServletPostProcessor

BeanPostProcessor接口实现类，将初始化和销毁回调函数应用到实现Servlet接口的bean。

4.20  SimpleUrlHandlerMapping

通过指定urlMap属性来实现请求URL到控制器（controller handler bean）的映射，当我们访问特定的URL时，就会查询由哪个handler处理该请求。

4.21  UserRoleAuthorizationInterceptor

继承了抽象类HandlerInterceptorAdapter，实现了用户登录认证的拦截功能，如果当前用户没有通过认证，会报403错误。

4.22  WebRequestHandlerInterceptorAdapter

实现了Servlet HandlerInterceptor接口的适配器，封装了一个WebRequestInterceptor。

五、web/servlet/i18n

5.1  AbstractLocaleContextResolver

LocaleContextResolver实现类的抽象基类，提供了对默认地区和默认时区的支持。

5.2  AbstractLocaleResolver

LocaleResolver接口实现类的抽象基类，提供了对默认地区的支持。

5.3  AcceptHeaderLocaleResolver

其实没有任何具体实现，是通过浏览器头部的语言信息来进行多语言选择。

5.4  CookieLocaleResolver

将语言信息设置到Cookie中，这样整个系统就可以获得语言信息。

5.5  FixedLocaleResolver

设置固定的语言信息，这样整个系统的语言是一成不变的。

5.6  LocaleChangeInterceptor

地区更改拦截器，可以通过配置请求的参数（默认的参数名为“locale”）在每个请求中对当前的地区值进行更改。

5.7  SessionLocaleResolver

与CookieLocaleResolver类似将语言信息放到Session中，这样整个系统就可以从Session中获得语言信息。

六、web/servlet/mvc

6.1  AbstractController

如果你想让控制器具备一些基本的特性，如过滤受支持的HTTP方法（GET、POST和HEAD），以及在HTTP响应中生成cache-control头部等，你可以让它扩展AbstractController类。

6.2  AbstractUrlViewController

根据请求URL路径直接转化为逻辑视图名的支持基类。

6.3  Controller    

Controller接口，定义一个方法，作用就是处理用户请求。

6.4  HttpRequestHandlerAdapter

主要是适配静态资源处理器，静态资源处理器就是实现了HttpRequestHandler接口的处理器，这类处理器的作用是处理通过SpringMVC来访问的静态资源的请求。

6.5  LastModified

支持最新修改的HTTP请求，方便进行内容的缓存。

6.6  ParameterizableViewController

参数化视图控制器，根据参数的逻辑视图名直接选择需要展示的视图。

6.7  ServletForwardingController

将Spring Handler接收的请求转发给一个Servlet去执行。

6.8  ServletWrappingController

Servlet包装控制器。

6.9  SimpleControllerHandlerAdapter

是Controller处理适配器，适配实现了Controller接口或Controller接口子类的处理器，比如我们经常自己写的Controller来继承MultiActionController，那么自己写的这些Controller就会由SimpleControllerHandlerAdapter来适配。

6.10  UrlFilenameViewController

url解析后直接访问资源视图.可以简单的配置BeanName映射然后访问静态资源。

6.11  WebContentInterceptor

支持最新修改的HTTP请求，方便进行内容的缓存。

web/servlet/mvc/annotation

6.12  ModelAndViewResolver

SPI，用于解析从指定的处理器方法中的自定义的返回值。通常，其实现类用来检测检查专门的返回类型，解析常用的返回值。

SPI全称Service Provider Interface，是Java提供的一套用来被第三方实现或者扩展的API，它可以用来启用框架扩展和替换组件。面向的对象的设计里，我们一般推荐模块之间基于接口编程，模块之间不对实现类进行硬编码。一旦代码里涉及具体的实现类，就违反了可拔插的原则，如果需要替换一种实现，就需要修改代码。为了实现在模块装配的时候不用在程序里动态指明，这就需要一种服务发现机制。java spi就是提供这样的一个机制：为某个接口寻找服务实现的机制。这有点类似IOC的思想，将装配的控制权移到了程序之外。

我们在“调用方”和“实现方”之间需要引入“接口”，那么什么情况应该把接口放入调用方，什么时候可以把接口归为实现方。

先来看看接口属于实现方的情况，这个很容易理解，实现方提供了接口和实现，我们可以引用接口来达到调用某实现类的功能，这就是我们经常说的api，它具有以下特征：

1、概念上更接近实现方；

2、组织上位于实现方所在的包中；

3、实现和接口在一个包中。

当接口属于调用方时，我们就将其称为spi，全称为：service provider interface，spi的规则如下：

1、概念上更依赖调用方；

2、组织上位于调用方所在的包中；

3、实现位于独立的包中（也可认为在提供方中）。

6.13  ResponseStatusExceptionResolver

当程序发生异常时，ResponseStatusExceptionResolver异常解释器用来解析@ResponseStatus标注的异常类，并把异常的状态码返回给客户端。DispatcherServlet默认装配了ResponseStatusExceptionResolver 的Bean。

web/servlet/mvc/condition

6.14  AbstractMediaTypeExpression

支持在RequestMapping的consumes()和produces()中描述的MIME类型表达式。

6.15  AbstractNameValueExpression

支持在RequestMapping#params()和headers()中描述的"name=value"类型的表达式。

6.16  AbstractRequestCondition

框架对接口RequestCondition有一组具体实现类。对这些具体实现类的一些通用逻辑，比如equals、hashCode和toString，是被放到抽象基类AbstractRequestCondition来实现的。同时AbstractRequestCondition还通过protected抽象方法约定了实现类其他的一些内部通用逻辑。

6.17  CompositeRequestCondition

本身不带任何的匹配条件，只是用于包装其他的RequestCondition进行匹配。

6.18  MediaTypeExpression

MIME类型表达式（如"text/plain"、 "!text/plain"）的约定，这些表达式在"consumes"和 "produces" 条件的@RequestMapping注解中定义。

6.19  NameValueExpression

"name!=value"类型表达式的约定，用来在@RequestMapping注解中指定请求参数和请求头条件。

6.20  RequestCondition

接口RequestCondition是Spring MVC对一个请求匹配条件的概念建模。最终的实现类可能是针对以下情况之一：路径匹配，头部匹配，请求参数匹配，可产生MIME匹配，可消费MIME匹配，请求方法匹配，或者是以上各种情况的匹配条件的一个组合。

6.21  RequestConditionHolder

一个匹配条件持有器，用于持有某个RequestCondition对象。如果你想持有一个RequestCondition对象，但其类型事先不可知，那么这种情况下该工具很有用。但要注意的是如果要合并或者比较两个RequestConditionHolder对象，也就是二者所持有的RequestCondition对象，那么二者所持有的RequestCondition对象必须是类型相同的，否则会抛出异常ClassCastException。

6.22  ConsumesRequestCondition

ConsumesRequestCondition（请求媒体类型过滤器）。

1、 创建跟请求匹配的过滤条件对象：筛选出同请求Accpet匹配的媒体类型表达式列表， 然后创建新的过滤条件对象， 并返回。

2、组合两个过滤条件对象：如果传入的过滤器的媒体类型表达式列表不为空， 则优先使用，这样处理的目的是方法的匹配覆盖类的配置。

3、比较过滤条件对象优先级：同请求Accpet匹配度高的过滤对象优先级高。

6.23  ProducesRequestCondition

ProducesRequestCondition（应答媒体类型过滤器）。

1、 创建跟请求匹配的过滤条件对象：筛选出同请求Content-Type匹配的媒体类型表达式列表， 然后创建新的过滤条件对象， 并返回。

2、组合两个过滤条件对象：如果传入的过滤器的媒体类型表达式列表不为空， 则优先使用，这样处理的目的是方法的匹配覆盖类的配置。

3、比较过滤条件对象优先级：同请求Content-Type匹配度高的过滤对象优先级高。

6.24  RequestMethodsRequestCondition

RequestMethodsRequestCondition （请求方法过滤器）。

1、 创建跟请求匹配的过滤条件对象：筛选出同request请求匹配的方法名称， 然后创建新的过滤条件对象，并返回，如果返回null，则认为过滤器不匹配请求。

2、组合两个过滤条件对象：把两个过滤对象的方法名称集合累加起来，  然后创建新的过滤对象， 并返回。

3、比较过滤条件对象优先级：请求方法名称个数多的那个过滤器优先级高。

6.25  HeadersRequestCondition

HeadersRequestCondition（头字段过滤器）。

1、 创建跟请求匹配的过滤条件对象：判断所有的头字段表达式是否都匹配请求对象， 是则返回本过滤器，否则返回null，认为过滤器不匹配request请求。

2、组合两个过滤条件对象：把两个过滤对象的头字段表达式集合累加起来，  然后创建新的过滤对象， 并返回。

3、比较过滤条件对象优先级：头字段表达式个数多的过滤器优先级高。

6.26  ParamsRequestCondition

ParamsRequestCondition（请求参数过滤器）。

1、 创建跟请求匹配的过滤条件对象：判断所有的参数表达式是否都匹配request请求对象， 是则返回本过滤对象， 否则返回null，认为过滤对象不匹配request请求。

2、组合两个过滤条件对象：把两个过滤对象的参数表达式集合累加起来，  然后创建新的请求参数过滤对象， 并返回。

3、比较过滤条件对象优先级：参数表达式个数多的那个过滤器优先级高。

6.27  PatternsRequestCondition

PatternsRequestCondition（模式请求路径过滤器）。

1、 创建跟请求匹配的过滤器对象：从持有的模式请求路径列表中筛选出同request请求匹配的模式请求路径，可能会有多个，对筛选后的模式请求路径列表执行排序，最详细最具体的路径排在前面，然后使用过滤后的模式请求列表创建一个新的过滤器并返回。多个模式请求路径之间是或关系，只要有一个模式请求路径跟request请求匹配，就认为过滤对象跟request请求匹配。

2、组合两个过滤条件对象：对两个模式请求路径列表中的元素进行自然连接后，再执行简单拼接，

然后创建新的模式请求路径过滤条件对象， 并返回。

3、比较过滤条件对象优先级：规则是谁的模式请求路径跟请求路径匹配度更高。

web/servlet/mvc/method

6.28  AbstractHandlerMethodAdapter

HandlerAdapter接口的简单抽象类，实现了接口定义的方法，同时增加了执行顺序Order。

6.29  RequestMappingInfo

使用@RequestMapping注解时，配置的信息最后都设置到了请求映射信息对象RequestMappingInfo中。

RequestMappingInfo封装了PatternsRequestCondition，RequestMethodsRequestCondition，ParamsRequestCondition等，所有的工作都是委托给具体的condition处理。

springMVC在启动时会扫描所有的@RequestMapping并封装成对应的RequestMapingInfo。一个请求过来会与RequestMapingInfo进行逐个比较，找到最适合那个RequestMapingInfo。

6.30  RequestMappingInfoHandlerMapping

为Handler引入具化类型RequestMappingInfo，同时实现部分父类抽象方法。

6.31  RequestMappingInfoHandlerMethodMappingNamingStrategy

RequestMappingHandlerMapping继承于AbstractHandlerMethodMapping，其中AbstractHandlerMethodMapping系列是将method作为handler来使用，里面涉及三个map：

1、handlerMethods：保存着匹配条件（也就是RequestCondition）和HandlerMethod的对应关系。

2、urlMap：保存着URL与匹配条件的对应关系。

3、nameMap：这个Map保存着name和HandlerMethod的对应关系，一个name可以有多个HandlerMethod，这里的name是使用HandlerMethodMappingNamingStratety策略的实现类从HandlerMethod中解析处理。解析规则是：类名里的大写字母+“#”+方法名。

该类就是HandlerMethodMappingNamingStratety接口的实现类。

web/servlet/mvc/method/annotation

6.32  AbstractMappingJacksonResponseBodyAdvice

ResponseBodyAdvice接口实现的抽象基类，在JSON序列化之前对响应进行定制。

6.33  AbstractMessageConverterMethodArgumentResolver

抽象基类，使用HttpMessageConverters从请求体中解析方法参数值。

6.34  AbstractMessageConverterMethodProcessor

继承自AbstractMessageConverterMethodArgumentResolver，通过HttpMessageConverters写入响应，从而处理方法返回值。

6.35  AsyncTaskMethodReturnValueHandler

处理WebAsyncTask类型的返回值。

6.36  CallableMethodReturnValueHandler

处理Callable类型的返回值。

6.37  DeferredResultMethodReturnValueHandler

处理DeferredResult、ListenableFuture、CompletionStage类型的返回值。

6.38  ExceptionHandlerExceptionResolver

继承自AbstractHandlerMethodExceptionResolver，通过@ExceptionHandler注解的方法解析异常。

6.39  ExtendedServletRequestDataBinder

ServletRequestDataBinder的子类，将URI信息也一起绑定到对象属性中。

6.40  HttpEntityMethodProcessor

解析HttpEntity、RequestEntity方法参数值，同时也处理HttpEntity、RequestEntity返回值。

6.41  HttpHeadersReturnValueHandler

支持返回类型HttpHeaders。

6.42  JsonViewRequestBodyAdvice

RequestBodyAdvice接口的实现类，增加了对Jackson的@JsonView注解的支持，该注解声明在Spring MVC @HttpEntity或者@RequestBody方法参数上。

6.43  JsonViewResponseBodyAdvice

RequestBodyAdvice接口的实现类，增加了对Jackson的@JsonView注解的支持，该注解声明在Spring MVC @RequestMapping或者@ExceptionHandler方法上。

6.44  MatrixVariableMapMethodArgumentResolver

解析一个使用@MatrixVariable注解的Map类型的参数，该注解并不指定一个名字。换句话来说，这个解析器的目的是提供到multiple matrix变量的访问方法。

6.45  MatrixVariableMethodArgumentResolver

解析使用@MatrixVariable注解的参数。

6.46  ModelAndViewMethodReturnValueHandler

处理ModelAndView类型的返回值，将view和model信息拷贝到ModelAndContainer。如果返回值为空，那么ModelAndViewContainer#setRequestHandled(boolean)标志位设置为true，表示请求已经直接被处理了。

6.47  ModelAndViewResolverMethodReturnValueHandler

该返回值处理器排在其他所有处理器之后，用来处理任意类型的返回值。

6.48  MvcUriComponentsBuilder

通过Spring MVC控制器的@RequestMapping注解的方法，创建UriComponentsBuilder实例。

6.49  PathVariableMapMethodArgumentResolver

支持Map参数类型的@PathVariable注解解析。

6.50  PathVariableMethodArgumentResolver

支持非Map参数类型的@PathVariable注解解析。

6.51  ReactiveTypeHandler

帮助处理响应式返回值类型。

6.52  RedirectAttributesMethodArgumentResolver      

解析RedirectAttributes类型的方法参数。

6.53  RequestAttributeMethodArgumentResolver

支持参数注解@RequestAttribute解析。

6.54  RequestBodyAdvice

在读取请求body之前或者在body转换成对象之前可以做相应的增强。

6.55  RequestBodyAdviceAdapter

ResponseBodyAdvice接口实现类的抽象基类，对接口的一些方法进行了实现。

6.56  RequestMappingHandlerAdapter

该类继承了 AbstractHandlerMethodAdapter 类，真正意义上实现了 HandlerAdapter 接口定义的功能。

该方法的具体过程如下：

1、校验请求，即检查是否支持当前 rqeuest 的 method 和 session；

2、判断控制器是否存在 @SessionAttributes 注解，有则设置缓存，否则准备响应；

3、处理器调用，返回 ModelAndView 。

对RequestMappingInfo这个Handler的具化处理，这是一个主要的映射处理类。初始化了默认的参数解析器，@InitBinder时调用的参数解析器，返回值参数解析器，支持了@ControllerAdvice注解类中@InitBinder方法的全局调用，@ModelAttribute注解的方法级调用和全局调用。

6.57  RequestMappingHandlerMapping

引入@Controller和@RequestMapping注解的实现，实现父类需要具体判断的抽象方法。

6.58  RequestPartMethodArgumentResolver

支持参数注解@RequestPart解析。

6.59  RequestResponseBodyAdviceChain

持有一组RequestBodyAdvice和ResponseBodyAdvice。在RequestResponseBodyMethodProcessor对参数进行解析前后，触发所有的回调。

6.60  RequestResponseBodyMethodProcessor

通过HttpMessageConverter对请求和响应进行读写，从而解析@RequestBody注解的方法参数、处理@ResponseBody返回值。

6.61  ResponseBodyAdvice

是spring4.1的新特性，其作用是在响应体写出之前做一些处理；比如，修改返回值、加密等。

6.62  ResponseBodyEmitter

一个控制器方法，为异步请求处理返回值类型。

6.63  ResponseBodyEmitterReturnValueHandler

ResponseBodyEmitter类型的返回的的处理器，SseEmitter等的子类。

6.64  ResponseEntityExceptionHandler

ResponseEntityExceptionHandler中包装了各种SpringMVC在处理请求时可能抛出的异常的处理，处理结果都是封装成一个ResponseEntity对象。通过ResponseEntity我们可以指定需要响应的状态码、header和body等信息，响应的body会被HttpMessageConverter处理，所以如果你响应的body是一个对象，而你的HttpMessageConverter列表中有一个是可以把对象转换为JSON的HttpMessageConverter，那么客户端收到的就是一段JSON。

ResponseEntityExceptionHandler是一个抽象类，通常我们需要定义一个用来处理异常的使用@ControllerAdvice注解标注的异常处理类来继承自ResponseEntityExceptionHandler。以下是ResponseEntityExceptionHandler的源码，从源码中我们可以看出它可以处理的异常，并为每个异常的处理都单独定义了一个方法，如果默认的处理不能满足你的需求，则可以重写对某个异常的处理。默认的实现最终都会调用handleExceptionInternal()方法，如果有通用的处理也可以从这里入手。

6.65  ServletCookieValueMethodArgumentResolver

继承自AbstractCookieValueMethodArgumentResolver，从HttpServletRequest中解析cookie值。

6.66  ServletInvocableHandlerMethod

ServletInvocableHandlerMethod是对InvocableHandlerMethod的进一步扩展，扩展了处理控制器方法返回值和注解@ResponseStatus的能力。而InvocableHandlerMethod是HandlerMethod的扩展，它基于一组HandlerMethodArgumentResolver从请求上下文中解析出控制器方法的参数值。HandlerMethod类在应用启动过程中搜集Web控制器方法信息阶段用于记录每个控制器方法的信息。

ServletInvocableHandlerMethod对控制器方法返回值的处理是通过一组注册了的HandlerMethodReturnValueHandler完成的。

如果返回值是null或者void，则ServletInvocableHandlerMethod会综合考虑@ResponseStatus注解，not-modified检查条件，或者控制器方法参数中提供的response对象然后决定是否将请求设置为已经处理。

如果返回值不是null/void，但是有注解@ResponseStatus并且其属性reason被设置，请求也将会被设置为已处理。

对于其他返回值情况，ServletInvocableHandlerMethod会构造一个ModelAndView对象给调用者。

另外对于浏览器端重定向redirect，ServletInvocableHandlerMethod还会考虑对请求属性flash attributes的更新设置。

6.67  ServletModelAttributeMethodProcessor

继承自ModelAttributeMethodProcessor，通过ServletRequestDataBinder类型的WebDataBinder进行数据绑定。

6.68  ServletRequestDataBinderFactory

它继承自InitBinderDataBinderFactory，用于创建ServletRequestDataBinder。ServletRequestDataBinder：在bind时支持将reqesut.getParameterNames中的属性绑定到类对象属性。

6.69  ServletRequestMethodArgumentResolver

支持servlet的一些api参数解析，如：WebRequest、ServletRequest、MultipartRequest、HttpSession、PushBuilder、Principal、 InputStream、Reader、HttpMethod、Locale、TimeZone、java.time.ZoneId。

6.70  ServletResponseMethodArgumentResolver

支持servlet的一些api返回值解析.如:ServletResponse、OutputStream、Writer。

6.71  ServletWebArgumentResolverAdapter

继承自AbstractWebArgumentResolverAdapter，从ServletRequestAttributes创建一个NativeWebRequest。

6.72  SessionAttributeMethodArgumentResolver

支持参数注解@SessionAttribute解析。

6.73  SseEmitter

该类继承自ResponseBodyEmitter，专门用来发送Server-Sent Events。

SSE(Server-Sent Events)，一种基于HTTP的，以流的形式由服务端持续向客户端发送数据的技术。我们常见的 http 交互方式是客户端发起请求，服务端响应，然后一次请求完毕；但是在 sse 的场景下，客户端发起请求，连接一直保持，服务端有数据就可以返回数据给客户端，这个返回可以是多次间隔的方式。springmvc不断输出文本到网页，采用的是对response不断进行write和flush实现的。在spring 4.2版本的时候提供了一个SseEmitter可以直接用来实现这个功能。

SSE 最大的特点，可以简单规划为两个：1、长连接。2、服务端可以向客户端推送信息。

websocket也是长连接，可以推送信息，但是它们有一个明显的区别：SSE是单通道，只能服务端向客户端发消息；而 webscoket 是双通道。

6.74  StreamingResponseBody

一个Controller在处理异步请求的时候，StreamingResponseBody会直接把流写入到response的输出流中，并且不会占用Servlet容器线程。

6.75  StreamingResponseBodyReturnValueHandler

HandlerMethodReturnValueHandler接口的实现类，支持StreamingResponseBody类型的返回值。

6.76  UriComponentsBuilderMethodArgumentResolver

解析UriComponentsBuilder类型的参数，返回的实例通过fromServletMapping(HttpServletRequest)进行初始化。

6.77  ViewMethodReturnValueHandler

处理View类型的返回值。

6.78  ViewNameMethodReturnValueHandler

支持String类型的返回值当做viewName进行解析。

web/servlet/mvc/support

6.79  DefaultHandlerExceptionResolver

DefaultHandlerExceptionResolver是Spring MVC对接口HandlerExceptionResolver的一个内置实现，这个HandlerExceptionResolver，顾名思义，是作为”缺省”HandlerExceptionResolver被使用的，也就是说，如果其他HandlerExceptionResolver不能处理指定的异常，最后会使用DefaultHandlerExceptionResolver来处理。而DefaultHandlerExceptionResolver能够解析标准Spring MVC异常，将其翻译成相应的HTTP状态码，通过response.sendError方法处理响应。

该异常解析器是Spring MVC的前端控制器DispatcherServlet缺省启用的HandlerExceptionResolver之一，并且被设置为最低优先级。

核心方法是#doResolveException，该方法内部根据异常的类型调用不同的方法将异常翻译成相应的HTTP状态码并sendError到响应对象，并且返回值是一个空ModelAdnView对象，也就是一个其#isEmpty方法总是为true的对象，此返回值告诉调用者：请使用缺省视图渲染相应的错误信息。

6.80  RedirectAttributes

RedirectAttributes是Spring mvc 3.1版本之后出来的一个功能，专门用于重定向之后还能带参数跳转的，有两种带参的方式：

第一种：attr.addAttribute(“param”, value);

这种方式就相当于重定向之后，在url后面拼接参数，这样在重定向之后的页面或者控制器再去获取url后面的参数就可以了，但这个方式因为是在url后面添加参数的方式，所以暴露了参数，有风险。

第二种：attr.addFlashAttribute(“param”, value);

这种方式也能达到重新向带参，而且能隐藏参数，其原理就是放到session中，session在跳到页面后马上移除对象。所以你刷新一下后这个值就会丢掉。

6.81  RedirectAttributesModelMap

继承自ModelMap、RedirectAttributes，使用DataBinder将值格式为String类型。同时提供了存储flash attributes的空间，使得在重定向的时候得以保存，而不用嵌入到重定向URL中。

七、web/servlet/resource

7.1  AbstractResourceResolver

ResourceResolver接口实现类的抽象基类，提供了一致的日志记录。

7.2  AbstractVersionStrategy

VersionStrateg接口实现类的抽象基类。

7.3  AppCacheManifestTransformer

帮助处理 HTML5 离线应用的 AppCache 清单内的文件

7.4  CachingResourceResolver

CachingResourceResolver 用于缓存其它 Resource Resolver 查找到的资源。因此 CachingResourceResolver 会被放在解析器链的最外层。请求先到达 CachingResourceResolver ，尝试在缓存中查找，如果找到，则直接返回，如果找不到，则依次调用后面的 resolver ，直到有一个 resolver 能够找到资源， CachingResourceResolver 将找到的资源缓存起来，下次请求同样的资源时，就可以从缓存中取了。

7.5  CachingResourceTransformer

缓存其它 transfomer 的结果，作用同 CachingResourceResolver。

7.6  ContentVersionStrategy    

继承自AbstractVersionStrategy，用于计算资源的MD5哈希值，用十六进制表示，并将其加到文件名中，如："styles/main-e36d2e05253c6c7085a91522ce43a0b4.css"。

7.7  CssLinkResourceTransformer

处理 css 文件中的链接，为其加上版本号。

7.8  DefaultResourceResolverChain

便于通过责任链模式操作ResourceResolver列表。

7.9  DefaultResourceTransformerChain

便于通过责任链模式操作ResourceTransformer列表。

7.10  DefaultServletHttpRequestHandler

DefaultServletHttpRequestHandler是Spring MVC提供的使用Servlet容器缺省Servlet处理静态文件的HttpRequestHandler实现。

因为Spring MVC可以支持多种Servlet容器，比如Tomat、Jetty、Jboss、GlassFish、Resin、GAE、WebLogic、WebSphere等。而在这些容器中，缺省Servlet的名字又不尽相同。所以该HttpRequestHandler会运行时检测ServletContext所对应的Servlet容器的类型，从而确保无论使用哪种Servlet容器，它总是能够正确地获取到缺省Servlet并转发相应的静态文件处理请求。

7.11  EncodedResourceResolver

解析器，如果发现一个资源，它将尝试找到一个编码器（如gzip、brotli），此编码器要被请求头"Accept-Encoding"所接受。

7.12  FixedVersionStrategy

继承自AbstractVersionStrategy，使用一个固定的版本作为请求路径的前缀，如缩减的SHA、版本名、发布时间等。

7.13  GzipResourceResolver

用来查找资源的压缩版本，它首先使用下一个 Resource Resolver 查找资源，如果可以找到，则再尝试查找该资源的 gzip 版本。如果存在 gzip 版本则返回 gzip 版本的资源，否则返回非 gzip 版本的资源。

7.14  HttpResource

继承自Resource的接口，用来写入到一个HTTP响应中。

7.15  PathResourceResolver

一个简单的资源解析器，尝试在给定的位置找到一个和请求路径相匹配的资源。该解析器是解析器链的最后一个，不会对解析器链做任何操作。

7.16  ResourceHttpRequestHandler

一个HttpRequestHandler实现类，用于处理静态资源请求。

7.17  ResourceResolver

策略接口，用于解析一个请求到服务器端资源。

7.18  ResourceResolverChain

调用资源解析器链的约定，每个解析器都提供一个到链的引用，以方便在需要的时候调用。

7.19  ResourceTransformer

转换给定的资源。

7.20  ResourceTransformerChain

资源转换器链。

7.21  ResourceTransformerSupport

ResourceTransformer接口实现类的抽象基类，提供了一些帮助性的方法。

7.22  ResourceUrlEncodingFilter

过滤器，封装了HttpServletResponse，重写了其encodeURL()方法来版本化的资源地址。

7.23  ResourceUrlProvider

一个核心组件，用来获取公共的URL路径，从而可以让客户端使用来访问一个静态的资源。

7.24  ResourceUrlProviderExposingInterceptor

Spring MVC的一个HandlerInterceptor，用于向请求添加一个属性，属性名称为ResourceUrlProvider.class.getName()，值是Spring MVC配置定义的一个资源URL提供者对象ResourceUrlProvider。

缺省情况下，Spring MVC配置机制会主动构建一个ResourceUrlProviderExposingInterceptor应用于所有的请求。

7.25  TransformedResource

继承自ByteArrayResource，资源转换器可以使用该类来表示一个原始的资源，只保留其内容而去除了其他所有的信息。

7.26  VersionPathStrategy

策略接口，用来在它的URL路径中提取出或者嵌入资源的版本。

7.27  VersionResourceResolver

解析包含了一个版本字符串的请求路径。

7.28  VersionStrategy 

继承自VersionPathStrategy，增加了一个判断资源实际版本的方法。

7.29  WebJarsResourceResolver

资源解析器，负责解析一个包含WebJar JAR文件的资源。webjars 是将前端的库（比如 jQuery）打包成 Jar 文件，然后使用基于 JVM 的包管理器（比如 Maven、Gradle 等）管理前端依赖的方案。

八、web/servlet/support

8.1  AbstractAnnotationConfigDispatcherServletInitializer

自动被加载，负责应用程序中 servlet 上下文中的 DispatcherServlet 和 Spring 其他上下文的配置。在Spring3.0环境中，容器会在类路径中查找实现javax.servlet.ServletContainerInitializer接口的类，如果能发现的话，就会用它来配置Servlet容器。Spring提供了这个接口的实现，名为SpringServletContainerInitializer。这个类反过来会查找实现WebApplicationInitializer的类并将配置的任务交给它们来完成。

Spring3.2引入了一个便利的WebApplicationInitializer基础实现，也就是AbstractAnnotationConfigDispatcherServletInitializer，DispatcherServlet实现了AbstractAnnotationConfigDispatcherServletInitializer，因此当部署到Servlet3.0容器中的时候，容器会自动发现它，并用它来配置Servlet上下文。

8.2  AbstractDispatcherServletInitializer

WebApplicationInitializer实现类的父类，在servlet context中注册一个DispatcherServlet。

8.3  AbstractFlashMapManager

FlashMapManager实现类的基类。

8.4  BindStatus

用于暴露一个域或对象的绑定状态。此类被JSP bind tag和FreeMarker macros作为一个变量使用。

8.5  JspAwareRequestContext

JSP-aware的RequestContext的子类。

8.6  JstlUtils

准备JSTL视图的帮助类，特别是用于暴露一个JSTL本地化的上下文。

JSTL（Java server pages standarded tag library，即JSP标准标签库），主要提供给Java Web开发人员一个标准通用的标签库，开发人员可以利用这些标签取代JSP页面上的Java代码，从而提高程序的可读性，降低程序的维护难度。

8.7  RequestContext

请求的上下文，保存着请求的状态，如当前web应用上下文，当前的地区信息、当前的主题、绑定错误等。

8.8  RequestContextUtils

提供访问请求状态的方便，通过DispatcherServlet设置。

8.9  RequestDataValueProcessor

请求数据在被视图渲染或者重定向之前，对其进行检查和修改，比如URL请求参数、表单数据等。

8.10  ServletUriComponentsBuilder

UriComponentsBuilder同其他静态工厂方法一道，基于当前的HttpServletRequest创建links。

8.11  SessionFlashMapManager

将FlashMap存储到HTTP session，或者从HTTP session中提取FlashMap。

8.12  WebContentGenerator     

便捷的为任何类型的网页内容产生的父类，像AbstractController、WebContentInterceptor

也可用于自定义处理器HandlerAdapter 。支持HTTP缓存控制选项。 对应的HTTP头的使用可以通过控制”cacheSeconds”和”cacheControl”属性。

九、web/servlet/tags

9.1  ArgumentAware  

允许实现该接口的标签使用嵌套的spring:argument标签。

Aware接口：Spring提供了广泛的Aware回调接口，让bean向容器表明它们需要某种基础设施依赖。通常Aware有这样一个规则：Aware接口的名称，表示依赖对象的类名称。例如，一个bean需要使用ApplicationContext，实现ApplicationContextAware接口即可。

9.2  ArgumentTag

<argument>标签基于JSTL fms:param标签，目的是支持消息和主题标签里的参数。

9.3  BindErrorsTag

<hasBindErrors>标签在发生绑定错误情况下提供了Errors实例。

9.4  BindTag

<bind>标签为一个某个bean或者bean属性绑定errors。

9.5  EditorAwareTag

被JSP标签类实现的接口，为一个属性暴露当前绑定到的属性编辑器。

9.6  EscapeBodyTag

<escapeBody>标签用来转义它封闭的正文内容，使用HTML转义和/或JavaScript转义。

9.7  EvalTag

<eval>标签用于评估一个SpEL，然后要么将结果打印出来要么将它赋值给一个变量。

9.8  HtmlEscapeTag

设置当前页面的默认HTML转义值。

9.9  HtmlEscapingAwareTag

输出内容可能得到HTML转义的标签的一个父类。

9.10  MessageTag

使用给定的代码检索消息，如果代码不可解析则返回文本。

9.11  NestedPathTag

设置绑定标记的路径要使用的嵌套路径。

9.12  Param

该bean用来将ParamTag的键-值对传送到ParamAware标签。

9.13  ParamAware

实现该接口的标签方便使用嵌套的spring:param标签。

9.14  ParamTag

<param>标签负责收集键-值对参数，然后将他们传送到标签层级树的ParamAware的父类。

9.15  RequestContextAwareTag

所有需要RequestContext的标签的父类。

9.16  ThemeTag

使用给定的代码检索主题消息，如果代码不可解析，则检索文本。

9.17  TransformTag

使用BindTag中的适当自定义PropertyEditor将变量转换为String（只能在BindTag中使用）。

9.18  UrlTag

<url>标签创建URLs。

web/servlet/tags/form

9.19  AbstractCheckedElementTag

抽象基类，为实现databinding-aware的JSP标签提供一些通用的方法，使用'checkbox' 或者' radio'渲染HTML的‘input’元素。

9.20  AbstractDataBoundFormElementTag

所有data-binding aware的JSP格式的标签的父类。

9.21  AbstractFormTag

所有JSP标签的父类。

9.22  AbstractHtmlElementBodyTag

使用AbstractHtmlElementTag的databinding features进行内容渲染的Html标签的父类。

9.23  AbstractHtmlElementTag

渲染HTML元素的databing-aware JSP标签的基类。

9.24  AbstractHtmlInputElementTag

渲染HTML格式input元素的databing-aware JSP标签的基类。

9.25  AbstractMultiCheckedElementTag

为实现databing-aware JSP标签的类通用方法的抽象基类，这些JSP标签使用‘checkbox’、‘radio’渲染多个HTML元素。

9.26  AbstractSingleCheckedElementTag

为实现databing-aware JSP标签的类通用方法的抽象基类，这些JSP标签使用‘checkbox’、‘radio’渲染一个单独的HTML‘input’元素。

9.27  ButtonTag

<button>标签，渲染一个在HTML ‘button’标签中的表单field label。

9.28  CheckboxesTag

<checkboxes>标签使用’checkbox’来渲染多个HTML ‘input’标签。

9.29  CheckboxTag

<checkboxes>标签使用‘checkbox’来渲染一个HTML ‘input’标签。

9.30  ErrorsTag

<errors>标签渲染在一个HTML ‘span’标签中的域错误。

9.31  FormTag    

<form>标签渲染一个HTML ‘form’标签，暴露一个binding path给内部的标签用于绑定。

9.32  HiddenInputTag

<hidden>标签渲染一个HTML ‘input’标签。

9.33  InputTag

<input>标签使用‘text’渲染一个HTML ‘input’标签。

9.34  LabelTag

<label>标签渲染渲染在HTML ‘lablel’标签中的form filed label。

9.35  OptionsTag

<options>标签渲染一列HTML ‘option’标签。

9.36  OptionTag

<option>标签渲染单独一个HTML ‘option’。

9.37  OptionWriter

提供了渲染一列‘option’标签功能性函数。这些标签基于相同的源对象，这些对象要么是数组、集合或者map。

9.38  PasswordInputTag

<password>标签使用‘password’类型来渲染HTML ‘input’标签。

9.39  RadioButtonsTag

<radiobuttons>标签使用‘radio’类型来渲染多个HTML ‘input’标签。

9.40  RadioButtonTag

<radiobutton>标签使用‘radio’渲染一个HTML ‘input’标签。

9.41  SelectedValueComparator

该类用来测试一个value是否和BindStatus#getValue匹配。

9.42  SelectTag

<select>标签渲染一个HTML ‘select’元素。

9.43  TagIdGenerator

JSP标签id生成器。

9.44  TagWriter

将HTML内容写入到一个Writer实例中。

9.45  TextareaTag

<textarea>标签，用来渲染一个HTML ‘textarea’。

9.46  ValueFormatter

数据格式器，格式化数据以通过标签标签进行渲染。

十、web/servlet/theme

10.1  AbstractThemeResolver

ThemeResolver实现类的抽象基类，对默认的主题名提供支持。

10.2  CookieThemeResolver

使用客户端cookie存储的主题。

10.3  FixedThemeResolver

默认的主题解析器，使用固定的主题，通过defaultThemeName属性设置，即此属性指定主题属性文件的文件名。此解析器不能动态设置主题。

10.4  SessionThemeResolver    

通过用户会话来保持主题，每个会话（session）仅需设置一次，所有请求共享主题，但是不能两个会话共享。

10.5  ThemeChangeInterceptor

该拦截器用来根据一个可配置的请求参数（默认的参数名为：“theme”），来指定每个请求当前使用的主题。

十一、web/servlet/view

11.1  AbstractCachingViewResolver 

带有缓存功能的ViewResolver接口基础实现抽象类，该类有个属性名为viewAccessCache的以 “viewName_locale” 为key， View接口为value的Map。

该抽象类实现的resolveViewName方法内部会调用createView方法，方法内部会调用loadView抽象方法。

11.2  AbstractTemplateView    

继承自AbstractUrlBasedView抽象类，重写了renderMergedOutputModel方法，在该方法中会调用renderMergedTemplateModel方法，renderMergedTemplateModel方法为新定义的抽象方法。

该抽象类有几个boolean属性exposeSessionAttributes，exposeRequestAttributes。 设置为true的话会将request和session中的键值和值丢入到renderMergedTemplateModel方法中的model这个Map参数中。

这个类是某些模板引擎视图类的父类。 比如FreemarkerView，VelocityView。

11.3  AbstractTemplateViewResolver

继承自UrlBasedViewResolver，重写了buildView方法，主要就是构造AbstractTemplateView以及为它设置相应的属性。

11.4  AbstractUrlBasedView

继承自AbstractView抽象类，增加了1个类型为String的url参数。

11.5  AbstractView

View接口的基础实现类。

11.6  BeanNameViewResolver

使用视图的名字来解析视图。

11.7  ContentNegotiatingViewResolver

实现ViewResolver根据请求文件名或Accept头解析视图的界面。

11.8  DefaultRequestToViewNameTranslator

RequestToViewNameTranslator就是一个请求解析器，他的每个实现有各自的一个解析请求的算法，经过这个算法，从请求的url中获得一个字符串，将这个字符串作为要显示的jsp的名字，去jsp文件目录中查找，找到就显示，找不到才最终显示404。

在springmvc中默认使用的是一个名字为DefaultRequestToViewNameTranslator（默认也只有这一个实现类），他解析请求的算法是将我们的请求直接解析为jsp的名字，然后从存放jsp的目录中去找，比如我们上面的请求是/view/hellojsp，那么经过这个实现类的解析后得到的便是/view/hellojsp这个字符串，有了这个值后，就会在执行一次就等同于在controller中return “/view/viewjsp”一样的效果，也就是去jsp目录下的view文件夹下去找viewjsp.jsp文件，如果找到就显示，找不到就404，因为我们没有这个文件，所以就最终404了。

11.9  InternalResourceView

内部资源视图.通过RequestDispatcher的include(request, response);方法直接解析。

11.10  InternalResourceViewResolver

内部资源视图解析器。比较常用的视图解析器，可以配置前后缀方便代码简化，以前使用的非常多，现在前后端分离后几乎不使用了。

11.11  JstlView

JSTL视图，继承自InternalResourceView，该类大致上与InternalResourceView类一致。

11.12  RedirectView

继承自AbstractUrlBasedView，并实现SmartView接口。SmartView接口定义了1个boolean isRedirectView();方法。

该视图的renderMergedOutputModel方法主要就是通过response.sendRedirect进行重定向。

11.13  ResourceBundleViewResolver

实现ViewResolver它使用bean定义ResourceBundle，由bundle基本名称指定。通常，您可以在属性文件中定义bundle，该属性文件位于类路径中。默认文件名是views.properties。

11.14  UrlBasedViewResolver

继承自AbstractCachingViewResolver抽象类、并实现Ordered接口的类，是ViewResolver接口简单的实现类。

11.15  ViewResolverComposite

ViewResolver接口实现类总体的就有四大类（StaticViewResolver 除外 用于单元测试）：BeanNameViewResolver、ContentNegituatingViewResolver、AbstractCachingViewResolver、ViewResolverComposite。

ViewResolverComposite: 是包含其他几种的组合类。

11.16  XmlViewResolver

实现ViewResolver它接受使用与Spring的XML bean工厂相同的DTD使用XML编写的配置文件。默认配置文件是/WEB-INF/views.xml。

11.17  AbstractPdfStamperView

Pdf视图抽象基类，可通过Bruno Lowagie的iText库将数据导出到pdf文件。

11.18  AbstractPdfView

输出格式为pdf的视图的父类。

11.19  AbstractXlsView

传统XLS格式的Excel文档视图的父类，兼容Apache POI 3.5或者更高的版本。

11.20  AbstractXlsxStreamingView

Office 2007版的XLSX格式的Excel文档视图的父类，使用POI的流变体。

Apache POI是基于Office Open XML标准（OOXML）和Microsoft的OLE 2复合文档格式（OLE2）处理各种文件格式的开源项目。 简而言之，您可以使用Java读写MS Excel文件，可以使用Java读写MS Word和MS PowerPoint文件。

11.21  AbstractXlsxView

Office 2007版的XLSX格式的Excel文档视图的父类（被POI-OOXML支持）。和Apache POI 3.5或者更高的版本兼容。

web/servlet/view/feed

11.22  AbstractAtomFeedView

Atom Feed视图的父类，使用ROME包。

Rome是为RSS聚合而开发的开源包，它可以支持0.91、0.92、0.93、0.94、1.0、2.0，可以说rss的版本基本上都支持了。

RSS是站点用来和其他站点之间共享内容的一种简易方式（也叫聚合内容），通常被用于新闻和其他按顺序排列的网站，例如Blog。

11.23  AbstractFeedView

Atom 和RSS Feed视图的父类，使用ROME包。

11.24  AbstractRssFeedView

RSS Feed视图的父类，使用ROME包。

web/servlet/view/freemarker

11.25  FreeMarkerConfig

实现该接口的对象会在web环境中对FreeMarker配置对象进行配置和管理。该接口实现类被FreeMarkerView检测和使用。

11.26  FreeMarkerConfigurer

JavaBean，通过configLocation、freemarkerSettings、templateLoaderPath来为web使用配置FreeMarker。

11.27  FreeMarkerView

使用FreeMarker模板引擎的视图。

FreeMarker是一个用Java语言编写的模板引擎，它基于模板来生成文本输出。FreeMarker与Web容器无关，即在Web运行时，它并不知道Servlet或HTTP。它不仅可以用作表现层的实现技术，而且还可以用于生成XML，JSP或Java 等。

简而言之，Freemarker就是在Jave Web开发中以模板的方式在页面展示从服务器端获取的信息。

11.28  FreeMarkerViewResolver

UrlBasedViewResolver的子类，支持FreeMarkerView和其自定义子类。

web/servlet/view/groovy

11.29  GroovyMarkupConfig    

实现该接口的对象负责配置和管理Groovy MarkupTemplateEngine，用于在web环境中自动查找。该接口实现类被GroovyMarkupView检测和实现。

11.30  GroovyMarkupConfigurer

继承自TemplateConfiguration、实现Spring MVC的GroovyMarkupConfig接口，用来创建在web应用中使用的MarkupTemplateEngine。配置该类最基本的方式是通过设置“resourceLoaderPath”。

11.31  GroovyMarkupView

继承自AbstractTemplateView，基于Groovy XML/XHTML标记模板。

Groovy 是 用于Java虚拟机的一种敏捷的动态语言，它是一种成熟的面向对象编程语言，既可以用于面向对象编程，又可以用作纯粹的脚本语言。使用该种语言不必编写过多的代码，同时又具有闭包和动态语言中的其他特性。

Groovy是JVM的一个替代语言（替代是指可以用 Groovy 在Java平台上进行 Java 编程），使用方式基本与使用 Java代码的方式相同，该语言特别适合与Spring的动态语言支持一起使用，设计时充分考虑了Java集成，这使 Groovy 与 Java 代码的互操作很容易。

11.32  GroovyMarkupViewResolver

继承自AbstractTemplateViewResolver，支持GroovyMarkupView（如：Groovy XML/XHTML markup templates）和它的子类。

web/servlet/view/json

11.33  AbstractJackson2View

基于Jackson和内容类型无关的AbstractView接口实现类的抽象基类。兼容Jackson 2.6或者更高的版本。

11.34  MappingJackson2JsonView

Spring MVC 视图，使用Jackson 2 的ObjectMapper为当前的请求，通过序列化model来渲染JSON内容。

web/servlet/view/script

11.35  RenderingContext

传给ScriptTemplateView的上下文，渲染函数，使得应用的上下文、地区、模板载入器、url在脚本端都可获取。

11.36  ScriptTemplateConfig    

实现该接口的类用来配置和管理JSR-223脚本引擎，用于在web环境中进行自动查找。该类被ScriptTemplateView检测和使用。

11.37  ScriptTemplateConfigurer

Spring MVC的ScriptTemplateConfig接口的实现类，用来在web应用中创建脚本引擎。

11.38  ScriptTemplateView

AbstractUrlBasedView的子类，设计用来基于一个JSR-223脚本引擎来运行任意的模板库。

11.39  ScriptTemplateViewResolver

UrlBasedViewResolver子类，支持ScriptTemplateView及其子类。

web/servlet/view/tiles3

11.40  AbstractSpringPreparerFactory

org.apache.tiles.preparer.PreparerFactory接口的抽象实现类，获取当前的Spring WebApplicationContext容器，实现方法getPreparer(String,WebApplicationContext)。

Apache Tiles是表现层的布局引擎。Tiles 是复合视图模式（Composite View pattern）的一个实现。Tiles将该模式添加到自己的概念中是该模式具体化。Tiles的实现是以复合式模式为理论。概念包括：Template，Attribute和Definition、View Preparer 。

1、模板（Template）：在Tiles中，模板（Template）是一个页面的布局部分。你能将一个页面结构看成是由不同的需要填补空白组成。

2、属性（Attribute）：属性是模板中的空白，它在你的应用程序中被填充到模板中。属性可以是以下三种类型：

string:属性是string的话，会将string直接呈现在页面。

template:属性是一个模板（Template），有无属性都行。如果有属性的话，你也要将他们填充后再呈现页面。

definition:它是一个可重复使用组成的页面，包含所有的属性来填充以呈现页面。

3、定义（definition）：定义是呈现给最终用户的组合物；本质上，一个定义是由一个模板和完全或部分填充的属性组成的。说白了就是：一个定义是由一个模板和属性组成的。

如果所有的“属性”都填充了，它将可以呈现给最终用户。

如果不是所有的属性都填充了，这个定义称为“抽象定义”（abastract definition），它可以被用作“父定义”，让其他“定义”继承，失去的“属性”能在运行时填充。

4、视图助手（View Preparer）：有时候一个定义在呈现之前需要“预处理”。例如，显示一个menu时，menu的结构必须被创建并且已经保存在request范围内。为了达到“预处理 ”，视图助手将会被用到，视图助手将在呈现定义之前被调用，因此在将“定义”呈现所需的东西都会被正确的“预处理 ”。

11.41  SimpleSpringPreparerFactory

Tiles的PrepareFactory接口实现类，用来创建视图助手实例。

11.42  SpringBeanPreparerFactory

Tiles的PrepareFactory接口实现类，从Spring的ApplicationContext容器中获取视图助手bean的名字和beans。

11.43  SpringLocaleResolver

Tiles的LocaleResolver适配器，代理Spring的LocaleResolver。

11.44  SpringWildcardServletTilesApplicationContext

Tiles ServletApplicationContext中的Spring特定的子类。

11.45  TilesConfigurer

为Spring框架配置Tiles 3.X的帮助类。

11.46  TilesView

视图接口的实现类，通过Tiles 请求API进行渲染。

11.47  TilesViewResolver

UrlBasedViewResolver的子类，支持TilesView（如Tiles定义）及其子类。

web/servlet/view/xml

11.48  MappingJackson2XmlView

Spring MVC的视图，使用Jackson 2的XmlMapper，为当前的请求通过序列化model来渲染XML内容。

11.49  MarshallingView

Spring MVC的视图，渲染响应的上下文作为marshalling的结果。

marshal:直译为“编排”，在计算机中特 指将数据按某种描述格式编排出来，通常来说一般是从非文本格式到文本格式的数据转化。unmarshal自然是指marshal的逆过程。比如在WebService中，我们需要把java对象以xml方式表示并在网络间传输，把java对象转化成xml片段的过程就是marshal。

web/servlet/view/xslt

11.50  XsltView

XSLT-driven视图，允许响应上下文被渲染，作为XSLT转换的结果。

11.51  XsltViewResolver

ViewResolver的实现类，通过将提供的视图名称转换成XSLT stylesheet的URL，来进行XsltView实例的解析。

拓展阅读：

　　Spring框架之beans源码完全解析
　　Spring框架之AOP源码完全解析
　　Spring框架之jms源码完全解析
　　Spring框架之spring-web http源码完全解析
　　Spring框架之spring-web web源码完全解析
　　Spring源码深度解析之Spring MVC