spring源码学习之springMVC（一）

　　个人感觉《Spring技术内幕：深入解析Spring架构与设计原理(第2版)》这本书对spring的解读要优于《Spring源码深度解析（第2版）》这本书的，后者感觉就是再陈述一些代码，没有自己的理解，有点呆板！下面是《Spring技术内幕》中的springMVC的描述：

　　在部署描述中，为这个DispatcherServlet定义了对应的URL映射，这些URL映射为这个servlet指定了需要处理的HTTP请求。context-param 参数的配置用来指定spring IoC容器读取Bean定义的XML文件的路径，作为springMVC启动类，ContextLoaderListener被定义一个监听器，这个监听器是与web服务器的生命周期相关联的，由ContextLoaderListener监听器负责完成IoC容器
　　在web环境中的启动工作，DispatcherServlet和ContextLoaderListener提供了在web容器中对spring的接口，也就是说，这些接口与web容器耦合是通过ServletContext来实现的，这个ServletContext为spring的IoC容器体系提供了一个宿主环境，在宿主环境中，springMVC建立起一个IoC容器的体系。这个IoC容器体系是通过ContextLoaderListener初始化来建立起来的，在建立IoC容器的体系后，把DispatcherServlet作为spring MVC处理web请求的转发器建立起来，从而完成响应HTTP请求的准备，有了这些基本的配置，建立在IOC容器基础上的spring MVC就可以正常的发挥作用了。

《Spring源码深度解析（第2版）》中的内容：

　　spring框架提供了构建完整的Web应用程序的全功能MVC模块，通过策略接口，spring框架是高度可配置的，而且支持多种视图技术，springMVC框架并不知道使用的视图，
所以不会强迫您只使用JSP技术，springMVC分离了控制器、模型对象、分派器以及处理程序对象的角色，这种分离让他们更容易进行定制

spring的NVC是基于Servlet功能实现的，通过实现servlet接口DispatcherServlet来封装其核心功能实现，通过将请求分配给程序处理，同时带有可配置的处理程序映射，
视图解析、本地语言、主体解析以及下载文件支持。默认的处理程序是非常简单的Controller接口，只有一个方法ModelAndView handleRequest(request, response);
spring提供了一个控制器层次结构，可以派生子类。

springMVC解决的问题主要就是以下几点：
　　将web页面的请求传给服务器
　　根据不同的请求处理不同的逻辑单元
　　返回处理结果数据并跳转至结果页面

一、ContextLoaderListener

　　对于springMVC功能实现的分析，我们首先从web.xml开始，在web.xml 文件中我们首先配置的就是ContextLoaderListener，那么它所提供的功能有哪些，又是
如何实现的呢？
　　当使用编程方式的时候我们可以直接将spring配置信息作为参数注入spring容器中，如ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
但是在web下，我们需要更多的是与web环境相互结合，通常的办法是将路径以context-param的方式注册并使用ContextLoaderListener进行监听读取
　　ContextLoaderListener的作用就是启动web容器时，自动装配ApplicationContext的配置信息。因为它实现了ServletContextListener这个接口，在web.xml配置这个监听器，
启动容器时，就会默认执行它实现的方法，使用ServletContextListener接口，开发者能够在为客户端请求提供服务之前向ServletContext中添加任意的对象，这个对象在
ServletContext启动的时候被初始化，然后在ServletContext整个运行期间都是可用的
每一个web应用都有一个ServletContext与之相关联。ServletContext对象在应用启动时被创建，在应用关闭的时候被销毁。ServletContext在全局范围内有效，
类似于应用中的一个全局变量
　　在ServletContextListener中核心逻辑便是初始化WebApplicationContext实例并存放至ServletContext中

1、ServletContextListener的使用
（1）创建自定义的ServletContextListener
首先我们创建ServletContextListener，目标是在系统启动时添加自定义属性，以便于在全局范围内可以随时调用。系统启动的时候会调用ServletContextListener实现类的
contextInitialized方法，所以需要实现在这个方法中实现我们的初始化逻辑。

public class MyDataContextListener implements ServletContextListener{
    private ServletContext context = null;
    public MyDataContextListener(){
        
    }
    // 该方法在ServletContext启动之后调用，并准备好处理客户端请求
    public void contextInitialized (SevrvletContextEvent event){
        this.context = event.getServletContext();
        // 实现自己的逻辑并将结果记录在属性中
        context = setAttribute("myData","this is myData");
    }
    // 这个方法在ServletContext关闭时调用
    public void contextDestroyed(SevrvletContextEvent event){
        this.context = null;
    }
}

（2）注册监听器

<listener>
    <listener-class>com.test.MyDataContextListener</listener-class>
</listener>

（3）测试
一旦web应用启动的时候，我们就鞥在任意的servlet或者jsp中通过下面方式获取我们初始化的参数：

String myData = (String) getServletContext().getAttribute("myData");

2、spring中的contextLoaderListener

ServletContext启动之后会调用ServletContextListener的contextInitialized方法，可以从这个方法开始：
org.springframework.web.context.ContextLoaderListener类中的contextInitialized

@Override
public void contextInitialized(ServletContextEvent event) {
    // 初始化WebApplicationContext
    initWebApplicationContext(event.getServletContext());
}

这里有一个WebApplicationContext，WebApplicationContext继承自ApplicationContext，在ApplicationContext的基础上又追加了一些特定于web的操作与特性，看一下这个类的初始化源码：

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
    if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
        // web.xml 中存在多次ContextLoader定义
        throw new IllegalStateException(
                "Cannot initialize context because there is already a root application context present - " +
                "check whether you have multiple ContextLoader* definitions in your web.xml!");
    }

    Log logger = LogFactory.getLog(ContextLoader.class);
    servletContext.log("Initializing Spring root WebApplicationContext");
    if (logger.isInfoEnabled()) {
        logger.info("Root WebApplicationContext: initialization started");
    }
    long startTime = System.currentTimeMillis();

    try {
        // Store context in local instance variable, to guarantee that
        // it is available on ServletContext shutdown.
        if (this.context == null) {
            // 初始化WebApplicationContext
            this.context = createWebApplicationContext(servletContext);
        }
        if (this.context instanceof ConfigurableWebApplicationContext) {
            ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
            if (!cwac.isActive()) {
                // The context has not yet been refreshed -> provide services such as
                // setting the parent context, setting the application context id, etc
                if (cwac.getParent() == null) {
                    // The context instance was injected without an explicit parent ->
                    // determine parent for root web application context, if any.
                    ApplicationContext parent = loadParentContext(servletContext);
                    cwac.setParent(parent);
                }
                configureAndRefreshWebApplicationContext(cwac, servletContext);
            }
        }
        // 记录在servletContext中
        servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

        ClassLoader ccl = Thread.currentThread().getContextClassLoader();
        if (ccl == ContextLoader.class.getClassLoader()) {
            currentContext = this.context;
        }
        else if (ccl != null) {
            currentContextPerThread.put(ccl, this.context);
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
                    WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
        }
        if (logger.isInfoEnabled()) {
            long elapsedTime = System.currentTimeMillis() - startTime;
            logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
        }

        return this.context;
    }
    catch (RuntimeException ex) {
        logger.error("Context initialization failed", ex);
        servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
        throw ex;
    }
    catch (Error err) {
        logger.error("Context initialization failed", err);
        servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
        throw err;
    }
}

步骤如下：
（1）WebApplicationContext存在性的验证
（2）创建WebApplicationContext
主要就是创建WebApplicationContext类，看一下创建过程的源码，在createWebApplicationContext方法中:
org.springframework.web.context.ContextLoader类中的createWebApplicationContext

protected WebApplicationContext createWebApplicationContext(ServletContext sc) {
    Class<?> contextClass = determineContextClass(sc);
    // 这里判断使用什么样的类在web容器中作为IoC容器
    if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
        throw new ApplicationContextException("Custom context class [" + contextClass.getName() +
                "] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");
    }
    // 直接实例化需要产生的IoC容器，并设置IoC容器的各个参数，然后通过refresh启动容器的初始化
    return (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
}

protected Class<?> determineContextClass(ServletContext servletContext) {
    String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);
    if (contextClassName != null) {
        try {
            return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader());
        }
        catch (ClassNotFoundException ex) {
            throw new ApplicationContextException(
                    "Failed to load custom context class [" + contextClassName + "]", ex);
        }
    }
    else {
        contextClassName = defaultStrategies.getProperty(WebApplicationContext.class.getName());
        try {
            return ClassUtils.forName(contextClassName, ContextLoader.class.getClassLoader());
        }
        catch (ClassNotFoundException ex) {
            throw new ApplicationContextException(
                    "Failed to load default context class [" + contextClassName + "]", ex);
        }
    }
}
// 其中ContextLoader类中有这样的静态代码块：
static {
    // Load default strategy implementations from properties file.
    // This is currently strictly internal and not meant to be customized
    // by application developers.
    try {
        ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, ContextLoader.class);
        defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
    }
    catch (IOException ex) {
        throw new IllegalStateException("Could not load 'ContextLoader.properties': " + ex.getMessage());
    }
}

根据以上代码，肯定会存在当前目录下的属性文件ContextLoader.properties，你当然可以在源码中看到这个配置：
spring-web下的resources文件夹下的org.springframework.web.context.ContextLoader.properties

org.springframework.web.context.WebApplicationContext=org.springframework.web.context.support.XmlWebApplicationContext
综合代码来看，在初始化过程中，程序首先会读取ContextLoader类的同目录下的属性文件ContextLoader.properties，并根据其中的配置提取将要实现的WebApplicationContext类的
实现类，并且根据反射方式进行实例的创建
（3）将实例记录在servletContext中
（4）映射当前的类加载器与创建的实例到全局变量currentContextPerThread中

二、DispatcherServlet

1、DispatcherServlet的初始化
在servlet初始化阶段，我们知道会首先调用其init方法，在DispatcherServlet中查找init方法的实现，查找方法直接查看该类的调用关系，在其父类中：
org.springframework.web.servlet.HttpServletBean中的init方法：

@Override
public final void init() throws ServletException {
    if (logger.isDebugEnabled()) {
        logger.debug("Initializing servlet '" + getServletName() + "'");
    }

    // Set bean properties from init parameters.
    // 解析init-param 并封装到pvs中
    PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
    if (!pvs.isEmpty()) {
        try {
            // 将当前的这个servlet类转换成BeanWrapper，从而能够以spring的方式对init-param的值进行注入
            BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
            ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
            // 注册自定义的属性编辑器，一旦使用Resource类型的属性将会使用ResourceEditor进行解析
            bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
            // 空实现，留给子类覆盖
            initBeanWrapper(bw);
            // 属性注入
            bw.setPropertyValues(pvs, true);
        }
        catch (BeansException ex) {
            if (logger.isErrorEnabled()) {
                logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
            }
            throw ex;
        }
    }

    // Let subclasses do whatever initialization they like.
    // 留给子类扩展
    initServletBean();

    if (logger.isDebugEnabled()) {
        logger.debug("Servlet '" + getServletName() + "' configured successfully");
    }
}

DispatcherServlet的初始化过程是通过将当前servlet类型实例转换为BeanWrapper类型实例，以便使用spring中提供的注入功能进行对应属性的注入，这些属性如contextAttribute、
contextClass、nameSpace等，都可以在web.xml文件中以初始化参数的方式。DispatcherServlet继承自FrameworkServlet，FrameworkServlet类上包含同名属性，spring会保证这些
这些参数被注入到对应的值中。属性注入主要包含以下几个步骤：

（1）封装以及验证初始化参数
ServletConfigPropertyValues除了封装属性还有对属性的验证功能
org.springframework.web.servlet.HttpServletBean.ServletConfigPropertyValues类中

public ServletConfigPropertyValues(ServletConfig config, Set<String> requiredProperties)
        throws ServletException {

    Set<String> missingProps = (!CollectionUtils.isEmpty(requiredProperties) ?
            new HashSet<>(requiredProperties) : null);

    Enumeration<String> paramNames = config.getInitParameterNames();
    while (paramNames.hasMoreElements()) {
        String property = paramNames.nextElement();
        Object value = config.getInitParameter(property);
        addPropertyValue(new PropertyValue(property, value));
        if (missingProps != null) {
            missingProps.remove(property);
        }
    }

    // Fail if we are still missing properties.
    if (!CollectionUtils.isEmpty(missingProps)) {
        throw new ServletException(
                "Initialization from ServletConfig for servlet '" + config.getServletName() +
                "' failed; the following required properties were missing: " +
                StringUtils.collectionToDelimitedString(missingProps, ", "));
    }
}

// 从代码中得知，封装属性主要是对初始化的参数进行封装，也就是servlet中配置的<init-param>中配置的封装。

（2）将当前的servlet实例转化成BeanWrapper实例
PropertyAccessorFactory.forBeanPropertyAccess(this);是spring中提供的方法，主要作用就是将制定实例转化为spring中可以处理的BeanWrapper实例
（3）注册相对于Resource的属性编辑器
在当前实例的属性注入过程中一旦遇到Resource类型的属性就会使用ResourceEditor去解析
（4）属性注入
BeanWrapper为spring中的方法，支持spring的自动注入。其实我们最常用的属性注入无非是contextAttribute、contextClass、nameSpace等
（5）servletBean实例化
在ContextLoaderListener加载的时候已经创建了WebApplicationContext实例，而在这个函数中最重要的就是对这个类的进一步补充实例化
看一下initServletBean源码：
org.springframework.web.servlet.FrameworkServlet中

@Override
protected final void initServletBean() throws ServletException {
    getServletContext().log("Initializing Spring FrameworkServlet '" + getServletName() + "'");
    if (logger.isInfoEnabled()) {
        logger.info("FrameworkServlet '" + getServletName() + "': initialization started");
    }
    long startTime = System.currentTimeMillis();

    try {
        this.webApplicationContext = initWebApplicationContext();
        // 设计为子类覆盖
        initFrameworkServlet();
    }
    catch (ServletException | RuntimeException ex) {
        logger.error("Context initialization failed", ex);
        throw ex;
    }

    if (logger.isInfoEnabled()) {
        long elapsedTime = System.currentTimeMillis() - startTime;
        logger.info("FrameworkServlet '" + getServletName() + "': initialization completed in " +
                elapsedTime + " ms");
    }
}

最为关键的初始化逻辑其实由initWebApplicationContext方法实现：

2、WebApplicationContext的初始化

initWebApplicationContext方法的主要工作就是创建或刷新WebApplicationContext实例并对servlet功能所使用的变量进行初始化
org.springframework.web.servlet.FrameworkServlet类中

protected WebApplicationContext initWebApplicationContext() {
    WebApplicationContext rootContext =
            WebApplicationContextUtils.getWebApplicationContext(getServletContext());
    WebApplicationContext wac = null;

    if (this.webApplicationContext != null) {
        // A context instance was injected at construction time -> use it
        // context实例在构造函数中被注入
        wac = this.webApplicationContext;
        if (wac instanceof ConfigurableWebApplicationContext) {
            ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
            if (!cwac.isActive()) {
                // The context has not yet been refreshed -> provide services such as
                // setting the parent context, setting the application context id, etc
                if (cwac.getParent() == null) {
                    // The context instance was injected without an explicit parent -> set
                    // the root application context (if any; may be null) as the parent
                    cwac.setParent(rootContext);
                }
                // 刷新上下文环境
                configureAndRefreshWebApplicationContext(cwac);
            }
        }
    }
    if (wac == null) {
        // No context instance was injected at construction time -> see if one
        // has been registered in the servlet context. If one exists, it is assumed
        // that the parent context (if any) has already been set and that the
        // user has performed any initialization such as setting the context id
        // 根据contextAttribute属性加载WebApplicationContext
        wac = findWebApplicationContext();
    }
    if (wac == null) {
        // No context instance is defined for this servlet -> create a local one
        wac = createWebApplicationContext(rootContext);
    }

    if (!this.refreshEventReceived) {
        // Either the context is not a ConfigurableApplicationContext with refresh
        // support or the context injected at construction time had already been
        // refreshed -> trigger initial onRefresh manually here.
        synchronized (this.onRefreshMonitor) {
            onRefresh(wac);
        }
    }

    if (this.publishContext) {
        // Publish the context as a servlet context attribute.
        String attrName = getServletContextAttributeName();
        getServletContext().setAttribute(attrName, wac);
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Published WebApplicationContext of servlet '" + getServletName() +
                    "' as ServletContext attribute with name [" + attrName + "]");
        }
    }

    return wac;
}

对于本函数的初始化主要分为这几个部分：

（1）寻找和创建对应的WebApplicationContext实例
寻找和创建对应的WebApplicationContext实例主要分为以下几个步骤：
1.1 通过构造函数的注入进行初始化
1.2 通过contextAttribute进行初始化
org.springframework.web.servlet.FrameworkServlet中的findWebApplicationContext方法

@Nullable
protected WebApplicationContext findWebApplicationContext() {
    String attrName = getContextAttribute();
    if (attrName == null) {
        return null;
    }
    WebApplicationContext wac =
            WebApplicationContextUtils.getWebApplicationContext(getServletContext(), attrName);
    if (wac == null) {
        throw new IllegalStateException("No WebApplicationContext found: initializer not registered?");
    }
    return wac;
}

1.3 重新创建WebApplicationContext实例

org.springframework.web.servlet.FrameworkServlet类中createWebApplicationContext

protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
    // 获取servlet的初始化参数contextClass，如果没有默认匹配XmlWebApplicationContext.class
    Class<?> contextClass = getContextClass();
    if (this.logger.isDebugEnabled()) {
        this.logger.debug("Servlet with name '" + getServletName() +
                "' will try to create custom WebApplicationContext context of class '" +
                contextClass.getName() + "'" + ", using parent context [" + parent + "]");
    }
    if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
        throw new ApplicationContextException(
                "Fatal initialization error in servlet with name '" + getServletName() +
                "': custom WebApplicationContext class [" + contextClass.getName() +
                "] is not of type ConfigurableWebApplicationContext");
    }
    // 通过反射方式实例化contextClass
    ConfigurableWebApplicationContext wac =
            (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

    wac.setEnvironment(getEnvironment());
    // parent为在ContextLoaderListener中创建的实例，在ContextLoaderListener加载的时候初始化的WebApplicationContext类型实例
    wac.setParent(parent);
    // 获取ContextConfigLocation属性，配置在servlet初始化参数中
    String configLocation = getContextConfigLocation();
    if (configLocation != null) {
        wac.setConfigLocation(configLocation);
    }
    // 初始化spring环境包括加载配置文件等
    configureAndRefreshWebApplicationContext(wac);

    return wac;
}

（2）configureAndRefreshWebApplicationContext刷新上下文环境

org.springframework.web.servlet.FrameworkServlet.configureAndRefreshWebApplicationContext方法中

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
    if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
        // The application context id is still set to its original default value
        // -> assign a more useful id based on available information
        if (this.contextId != null) {
            wac.setId(this.contextId);
        }
        else {
            // Generate default id...
            wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
                    ObjectUtils.getDisplayString(getServletContext().getContextPath()) + '/' + getServletName());
        }
    }

    wac.setServletContext(getServletContext());
    wac.setServletConfig(getServletConfig());
    wac.setNamespace(getNamespace());
    wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));

    // The wac environment's #initPropertySources will be called in any case when the context
    // is refreshed; do it eagerly here to ensure servlet property sources are in place for
    // use in any post-processing or initialization that occurs below prior to #refresh
    ConfigurableEnvironment env = wac.getEnvironment();
    if (env instanceof ConfigurableWebEnvironment) {
        ((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
    }

    postProcessWebApplicationContext(wac);
    applyInitializers(wac);
    // 加载配置文件及整合parent到wac
    wac.refresh();
}
// 无论调用方式如何变化，只要使用ApplicationContext所提供的的功能最后都免不了使用公共父类AbstractApplicationContext提供的refresh()方法

（3）刷新

onRefresh是在FrameworkServlet类中提供的模板方法，在其子类DispatcherServlet中进行重写，主要用于刷新在web功能实现中所必须使用的全局变量。

@Override
protected void onRefresh(ApplicationContext context) {
    initStrategies(context);
}

protected void initStrategies(ApplicationContext context) {
    // 初始化MultipartResolver
    initMultipartResolver(context);
    // 初始化LocaleResolver
    initLocaleResolver(context);
    // 初始化ThemeResolver
    initThemeResolver(context);
    // 初始化HandlerMappings
    initHandlerMappings(context);
    // 初始化HandlerAdapters
    initHandlerAdapters(context);
    // 初始化HandlerExceptionResolvers
    initHandlerExceptionResolvers(context);
    // 初始化RequestToViewNameTranslator
    initRequestToViewNameTranslator(context);
    // 初始化ViewResolvers
    initViewResolvers(context);
    // 初始化FlashMapManager
    initFlashMapManager(context);
}

3.1 初始化MultipartResolver
在spring中，MultipartResolver主要用来处理文件上传。常用的配置如下：

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="maxmunFileSize">
        <value>1000</value>
    </property>
</bean>

org.springframework.web.servlet.DispatcherServlet类中：
private void initMultipartResolver(ApplicationContext context) {
    try {
        this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
        if (logger.isDebugEnabled()) {
            logger.debug("Using MultipartResolver [" + this.multipartResolver + "]");
        }
    }
    catch (NoSuchBeanDefinitionException ex) {
        // Default is no multipart resolver.
        this.multipartResolver = null;
        if (logger.isDebugEnabled()) {
            logger.debug("Unable to locate MultipartResolver with name '" + MULTIPART_RESOLVER_BEAN_NAME +
                    "': no multipart request handling provided");
        }
    }
}

就写一个吧，其他的基本类似！