文章一直更新中......
众所周知，Spring mvc 将所有请求都在 DispatcherServlet 中处理，并且配置有一个监听器
在源码了解之前，我们需要知道的是服务器启动时候，listener filter servlet 执行顺序：---.大家可以自己去测试
1.listener 2.filter 3.servlet
（一）.所以我们第一步先看一看监听器listener 做了什么事情？
1.实现了 ServletContextListener 接口 ，用监听servletcontext的动作
2.继承了ContextLoader ，执行根应用程序的上下文实际的初始化工作被 ContextLoaderListener（我们的监听器）所调用
所以在服务器启动时候，率先进行了 invoke initWebApplicationContext() method;
我们点进去看一看它的实现
因为是初始化--先进行了判断保证我们的servletcontext 是一个干净的servletcontext
执行流程：
1.private WebApplicationContext context;
初始化是null；
2.在createWebApplicationCotext()方法中 成员变量 context 被实例化为 class org.springframework.web.context.support.XmlWebApplicationContext 类型，这个类型实现了 ConfigurableWebApplicationContext 接口，也是必须要实现的；
ConfigurableWebApplicationContext 接口的描述：
*Interface to be implemented by configurable web application contexts.
* Supported by {@link ContextLoader} and
* {@link org.springframework.web.servlet.FrameworkServlet}.
*该接口由可配置的web 上下文所实现，对contextloader（监听器） frameworkservlet（servlet 容器）有支持，可以得知该接口专门为web 打造的；
3.isActive() 方法： 翻译看源码，我们并没有进行刷新的操作，所以返回默认值false
/** * Determine whether this application context is active, that is, * whether it has been refreshed at least once and has not been closed yet. * @return whether the context is still active * @see #refresh() * @see #close() * @see #getBeanFactory() */
确定是否这个应用上下文处于活动状态，也就是说它至少被刷新过一次，并尚未关闭
boolean isActive();
4.configureAndRefreshWebApplicationContext（）：完成bean 的解析，加载，初始化，很重要的操作；
只一步主要就是 refresh（） 操作： 源码对此方法对解释 /** * Load or refresh the persistent representation of the configuration, * which might an XML file, properties file, or relational database schema. * <p>As this is a startup method, it should destroy already created singletons * if it fails, to avoid dangling resources. In other words, after invocation * of that method, either all or no singletons at all should be instantiated. * @throws BeansException if the bean factory could not be initialized * @throws IllegalStateException if already initialized and multiple refresh * attempts are not supported */
可以持久化的加载或者刷新配置文件，可能是XML 文件，也可能是properties 文件，或者是关系型数据库的模式
作为启动的方法，如果启动失败，他应该销毁已经创建的单例，去避免挂起资源； 换句话说，在调用这个方法后，所有实例化的和不实例化的
都应该被实例化
public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // Prepare this context for refreshing. prepareRefresh(); // Tell the subclass to refresh the internal bean factory. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // Prepare the bean factory for use in this context. prepareBeanFactory(beanFactory); try { // Allows post-processing of the bean factory in context subclasses. postProcessBeanFactory(beanFactory); // Invoke factory processors registered as beans in the context. invokeBeanFactoryPostProcessors(beanFactory); // Register bean processors that intercept bean creation. registerBeanPostProcessors(beanFactory); // Initialize message source for this context. initMessageSource(); // Initialize event multicaster for this context. initApplicationEventMulticaster(); // Initialize other special beans in specific context subclasses. onRefresh(); // Check for listener beans and register them. registerListeners(); // Instantiate all remaining (non-lazy-init) singletons. finishBeanFactoryInitialization(beanFactory); // Last step: publish corresponding event. finishRefresh(); } catch (BeansException ex) { // Destroy already created singletons to avoid dangling resources. destroyBeans(); // Reset 'active' flag. cancelRefresh(ex); // Propagate exception to caller. throw ex; } } }
其中主要就是第2部和第11部：
obtainFreshBeanFactory（）：进行解析我们的xml 以及我们自定义的xml 标签，每一个<bean> 都是 BeanDefinitions对象，里面维护了bean的一些详细信息，方便实例化
注意，这一步并没有实例化bean ，只是解析XML ，将所有的eanDefinitions对象都放入了 beanDefinitionMap中；我们看它的实现
(-)使用默认的bean工厂DefaultListableBeanFactory, loadBeanDefinitions(beanFactory)
(二).使用XmlBean解析器去解析xml bean definition
(三). 注册bean
（四）.这一步很重要了，开始干活了，解析xml
（五）.循环遍历查找使用哪一种解析器，像一些默认的标签bean，alias，import，beans 会进入第一个方法；
像context ，aspect，dubbo 这种标签是属于自定义标签，只要符合Spring 规则就可以加载进行加载；下面我会说；
我们先看parseDefaultElement(ele,delegate)方法：
是不是提供了默认的标签bean，alias，import，beans的解析：
我们看它解析bean 的实现；源码多，具体需要自己去看，就是拿到，ID class 等信息：
bdholder 是一个装饰类，里面拿到了bean的所有信息
注册bean
注册bean：
点进去可以看到：其实就是将bean 的信息对象注册到我们DefaultListableBeanFactory 工厂维护的beanDefinitionMap中；名字放入了List<String> beanDefinitionNames 中
这里bean 的注册就完成了；
（六）关于自定义的XML 标签解析，也是Spring很有魅力的一个地方，像一些aop 标签，dubbo 标签都是通过自定义解析器去实现的，当然要遵循Spring 解析配置规则
才会被Spring扫描解析到，那么如何让才能让Spring解析我们自定义的标签呢？
以Spring-aop 包为例： 1.定义spring.handlers ：键值对，里面存放的是我们组册解析我们自定义XML的类，有我们自己实现，会被反射实例化执行里面的方法，
2.spring.schemas :我们XML 所遵循的schemas，如果schemas地址是无效的，请META-INF目录下放入自己的xsd文件
看Spring 解析方法：handler 就是在Spring.handlers 对应的被反射实例化的对象，parse 方法就是对自定义标签的解析
实例化并调用init ，init 方法是将标签的属性进行注册存放到map 中，由parse 方法去获取并对应解析
自定义解析请看link：https://www.cnblogs.com/iscys/p/9905608.html
1.spring 加载的时候，使用的bean 工厂 是默认的 DefaultListableBeanFactory 对象
2.工厂内部维护着 Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64);beanmap
3.解析XML 时候，会分别识别bean 标签，import标签，alias 标签，beans 标签并做不同的判断 注册bean时候调用了registerBeanDefinition（）将bean 注册到 beanDefinitionMap中
beanDefinitionMap.put(beanName, beanDefinition);
关于第11步，是很重要的，会完成bean 的实例化，以及自定义InitializingBean aware 的接口实现的调用，
我单独写了文章；link：https://www.cnblogs.com/iscys/p/9903766.html
5.将 this.context 即XmlWebApplicationContext 放入servletContext上下文中，servlet 可以进行共享此applicattioncontext，以此达到共享bean 的目的
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
扩展：我们可以通过得知监听器给我们创建的applicationcontext 的类型
WebApplicationContext rootContext =WebApplicationContextUtils.getWebApplicationContext(getServletContext());
System.out.println(rootContext.getClass());
（二）.Servlet 的实现
我们看一看它的类层次结构：DispatcherServlet---> FrameworkServlet--> HttpServletBean ---> HttpServlet
可以得知底层其实实现了HttpServlet，其实就是一个servlet
给大家翻译一下 DispatcherServlet 文档：
/** * Central dispatcher for HTTP request handlers/controllers, e.g. for web UI controllers or HTTP-based remote service * exporters. Dispatches to registered handlers for processing a web request, providing convenient mapping and exception * handling facilities.
处理http 请求处理器和控制器的中央调度器，例如，用于web ui 控制器或者基于http的远程；调度注册的处理程序为web 请求
提供便利的映射和异常处理；
* <p>This servlet is very flexible: It can be used with just about any workflow, with the installation of the * appropriate adapter classes. It offers the following functionality that distinguishes it from other request-driven * web MVC frameworks:
这个servlet 是非常精巧的：它几乎可以被任何的工作流所使用，只要安装了合适的适配器类，它提供了如下功能使之区别其他请求驱动的web mvc 框架
* <ul> <li>It is based around a JavaBeans configuration mechanism.
它是基于java bean 的配置机制的 * * <li>It can use any {@link HandlerMapping} implementation - pre-built or provided as part of an application - to * control the routing of requests to handler objects. Default is {@link org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping} * and {@link org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping}. HandlerMapping objects * can be defined as beans in the servlet's application context, implementing the HandlerMapping interface, overriding * the default HandlerMapping if present. HandlerMappings can be given any bean name (they are tested by type).
它可以使用基于handlermapping 的实现，提前构建或者提供作为应用程序的一部分，来控制请求到处理对象之间的路由；默认提供了beannameurlhandlermapping
以及default annotationmapping ；处理器映射器对象可以被定义作为servlet 上下问对象的bean ；实现handlermapping 接口，覆盖默认的handlempping
handlermapping 会被赋予一个bean 名字；
* <li>It can use any {@link HandlerAdapter}; this allows for using any handler interface. Default adapters are {@link * org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter}, {@link org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter}, * for Spring's {@link org.springframework.web.HttpRequestHandler} and {@link org.springframework.web.servlet.mvc.Controller} * interfaces, respectively. A default {@link org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter} * will be registered as well. HandlerAdapter objects can be added as beans in the application context, overriding the * default HandlerAdapters. Like HandlerMappings, HandlerAdapters can be given any bean name (they are tested by type). 它可以使用一些处理器适配器；它允许使用任何处理接口
默认的适配器是 HttpRequestHandlerAdapter，simplecontrollerhandleradapter分别对应着 HttpRequestHandler，Controller handler接口
默认的annotationhandler也会被注册 处理器适配器对象也会在application 上下文加载进来为bean
* <li>The dispatcher's exception resolution strategy can be specified via a {@link HandlerExceptionResolver}, for
* example mapping certain exceptions to error pages. Default are
* {@link org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver},
* {@link org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver}, and
* {@link org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver}. These HandlerExceptionResolvers can be overridden
* through the application context. HandlerExceptionResolver can be given any bean name (they are tested by type).
*
* <li>Its view resolution strategy can be specified via a {@link ViewResolver} implementation, resolving symbolic view
* names into View objects. Default is {@link org.springframework.web.servlet.view.InternalResourceViewResolver}.
* ViewResolver objects can be added as beans in the application context, overriding the default ViewResolver.
* ViewResolvers can be given any bean name (they are tested by type).
*
* <li>If a {@link View} or view name is not supplied by the user, then the configured {@link
* RequestToViewNameTranslator} will translate the current request into a view name. The corresponding bean name is
* "viewNameTranslator"; the default is {@link org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator}.
*
* <li>The dispatcher's strategy for resolving multipart requests is determined by a {@link
* org.springframework.web.multipart.MultipartResolver} implementation. Implementations for Jakarta Commons FileUpload
* and Jason Hunter's COS are included; the typical choise is {@link org.springframework.web.multipart.commons.CommonsMultipartResolver}.
* The MultipartResolver bean name is "multipartResolver"; default is none.
*
* <li>Its locale resolution strategy is determined by a {@link LocaleResolver}. Out-of-the-box implementations work via
* HTTP accept header, cookie, or session. The LocaleResolver bean name is "localeResolver"; default is {@link
* org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver}.
*
* <li>Its theme resolution strategy is determined by a {@link ThemeResolver}. Implementations for a fixed theme and for
* cookie and session storage are included. The ThemeResolver bean name is "themeResolver"; default is {@link
* org.springframework.web.servlet.theme.FixedThemeResolver}. </ul>
*
* <p><b>NOTE: The {@code @RequestMapping} annotation will only be processed if a corresponding
* {@code HandlerMapping} (for type level annotations) and/or {@code HandlerAdapter} (for method level
* annotations) is present in the dispatcher.</b> This is the case by default. However, if you are defining custom
* {@code HandlerMappings} or {@code HandlerAdapters}, then you need to make sure that a corresponding custom
* {@code DefaultAnnotationHandlerMapping} and/or {@code AnnotationMethodHandlerAdapter} is defined as well -
* provided that you intend to use {@code @RequestMapping}.
*
* <p><b>A web application can define any number of DispatcherServlets.</b> Each servlet will operate in its own
* namespace, loading its own application context with mappings, handlers, etc. Only the root application context as
* loaded by {@link org.springframework.web.context.ContextLoaderListener}, if any, will be shared.
*
* <p>As of Spring 3.1, {@code DispatcherServlet} may now be injected with a web
* application context, rather than creating its own internally. This is useful in Servlet
* 3.0+ environments, which support programmatic registration of servlet instances. See
* {@link #DispatcherServlet(WebApplicationContext)} Javadoc for details.
*
其实根据上一篇对servlet 详解，我们知道对于servlet 的初始化动作一定放在init 方法中，设置start 等级，这样就可以服务器启动，初始化servlet
/**
* Map config parameters onto bean properties of this servlet, and
* invoke subclass initialization.
* @throws ServletException if bean properties are invalid (or required
* properties are missing), or if subclass initialization fails.
*/
将文件配置参数映射到servlet 的bean 属性上，并调用子类初始化；
@Override
public final void init() throws ServletException {
关于我们的请求是经过什么的过程呢？下面这张图就是它的执行流程，网上一堆，那么我一个一个的给大家解析跟随源代码；你就不会迷茫了；
1.发送请求，这个就不用说了，哈哈，地址栏回车；接下来就是我们的DispatcherServlet操作了
2.映射处理器：熟悉servlet 都知道，请求第一步进入doService(request,response) 方法 ，就是这个方法。
里面会有一个doDispatch() ;这个我们可以理解为方法入口，进行分发 ；
所有的方法执行都在doDispatch()中；我们看一看获取HandlerMapping，就是这个方法，通过request 请求得到mappedHandler,是个 HandlerExecutionChain
执行链：
确定一个handler通过我们的request请求；
我们看一看getHandler()方法：会遍历我们注册过的handlermapping（handlerMapping是在初始化注册的） ；
执行getHandler(request);往后面点，可以看到它会根据地址去我们的urlMap中去找HandlerMethod ,就是执行这个url
所匹配的类名和方法；后期会被反射调用；
去看有没有拦截器之类的，并返回执行链：
其实可以得出，这个执行链就是一些需要执行方法的链路，就是一些类方法组成的；如下：
HandlerExecutionChain with handler [public void com.thirdparty.controller.gzh.WxConnectionController.wxConnection(javax.servlet.http.HttpServletResponse,java.lang.String,java.lang.String,java.lang.String,java.lang.String) throws java.lang.Exception] and 1 interceptor
到这里handlerMapping 就结束了并返回执行链；
3.开始获得处理器适配器； 得到执行链中的需要执行的methodhandler来匹配HandlerAdapter;
得到HandlerAdapter ,我们就可以通过这个适配器 去执行里面的方法；看第四步；
4.关键的方法调用就来了，通过反射调用执行的方法，返回ModelAndView
方法调用：
Java 反射：
这样，其实方法就执行完了；
5.视图解析
