java架构-Spring MVC 与 Servlet-白红宇

相信大家都能够在上网上看到Spring MVC的核心类其实就是DispatherServlet，也就是Spring MVC处理请求的核心分发器。其实核心分发器几乎是所有MVC框架设计中的核心概念，像在Struts2也有类似的分发器FilterDispatcher。只不过Spring MVC中的是一个Servlet，而Struts2里面的是一个Filter.既然我们知道了Spring MVC的中核心类DispatcherServlet是一个Servlet。下面我们就来了解一下Servlet相关的概念。以助于我们后面分析Spring MVC的整体框架。

1、Servlet容器的加载顺序

相信大多数写Java Web程序的都接触过web.xml这个配置文件。下面我们就来看一下里面最主要的几个元素。

context-param : 对于所有Servlet都可用的全局变量,被封装于ServletContext时。

listener : 基于观察者模式设计的，用于对开发Servlet应用程序提供了一种快捷的手段，能够方便的从另一个纵向维度控制程序和数据。

filter : 用于拦截Servlet，可以在调用Servlet之前或者之后修改Servlet中Request或者Response的值。

servlet : 用于监听并处理所有的Web请求。在service及其相关方法中对Http请求的处理流程。

这里是Servlet容器中我们使用到最多的几个元素。它们在Servlet里面的初始化顺序如下：

context-param –> listener -> filter -> servlet复制代码

具体可以参见：web.xml 初始化顺序

2、Servlet的生命周期

了解了Servlet里面的主要元素的加载顺序，下面我们就来看一下Servlet里面的生命周期：

public interface Servlet {    public void init(ServletConfig config) throws ServletException;    public ServletConfig getServletConfig();    public void service(ServletRequest req, ServletResponse res)    throwsServletException;, IOException;    public String getServletInfo();    public void destroy();}复制代码

我们可以看到在Servlet接口里面有5个方面。

init()：Servlet的初始化方法,因为Servlet是单例，所以整个系统启动时，只会运行一次。

getServletConfig() : 获取Servlet配置信息，也就是之前所说的context-param配置的值。

service() : 监听并响应客户端的请求

getServletInfo() : 获取Servlet信息

destroy() : Servlet容器调用，用于销毁Servlet.

所以，Servlet生命周期分为三个阶段：

1.初始化阶段，调用init()方法

2.响应客户请求阶段，调用service()方法

3.终止阶段，调用destroy()方法

了解了这些Servlet的相关信息，我相信下面再来分析Spring MVC大家就会清楚很多。

3、Spring MVC父子容器及初始化组件

在Spring中我们都知道，它的核心概念是bean。而Spring容器又是通过BeanFactory来管理bean的。当我们查看Spring的BeanFactory的体系结构的时候不难发现HierarchicalBeanFactory这个接口。

public interface HierarchicalBeanFactory extends BeanFactory {    BeanFactory getParentBeanFactory();    boolean containsLocalBean(String name);`}复制代码

可以看到它有一个getParentBeanFactory()方法。那么Spring框架就可以建立起.器的结构.在使用Spring MVC的时候我们可以看出，Spring MVC的体系是基于Spring容器来的。下面我们就来看一下Spring MVC是如何构建起父子容器的。在此之前我们先来看一段web.xml配置文件。


            
     
      contextConfigLocation
             
     
      classpath:applicationContext.xml
         
        
        
            
     
      org.springframework.web.context.ContextLoaderListener
         
        
        
            
     
      dispatcher
             
     
      org.springframework.web.servlet.DispatcherServlet
             
                 
      
       contextConfigLocation
                  
      
       /WEB-INF/dispatcher-servlet.xml
              
             
     
      1
         
    复制代码

相信大家对于以上配置文件不会陌生，以我们之前的Servlet容器的初始化顺序我们来看一下以上配置文件。

首先，把contextConfigLocation这个参数以及它的值初始化到ServletContext中。

然后，初始化ContextLoaderListener加载contextConfigLocation里面配置的Spring配置文件，构建起root容器

最后，初始化DispatcherServlet加载它里面的contextConfigLocation，构造起web容器。再把root容器与web容器建立起父子关系。

下面我们以源代码的形式来说明以上的过程：

首先，我们先来看一下ContextLoaderListener类结构。

可以看到ContextLoaderListener实现了ServletContextListener这个接口，而这个接口的里面有2个方法。

contextInitialized() ：容器初始化的时候调用。

contextDestroyed() ：容器销毁的时候调用。

所以在Servlet容器初始化的时候会调用contextInitialized方法。

这里它会调用它的类父ContextLoader的initWebApplicationContext方法。

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {        try {            if (this.context == null) {                this.context = createWebApplicationContext(servletContext);            }            if (this.context instanceof ConfigurableWebApplicationContext) {                ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;                if (!cwac.isActive()) {                    if (cwac.getParent() == null) {                        ApplicationContext parent = loadParentContext(servletContext);                        cwac.setParent(parent);                    }                    configureAndRefreshWebApplicationContext(cwac, 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);            }            return this.context;        }    }复制代码

3.1 通过反射创建root容器对象

在最开始它会通过反射的方式调用createWebApplicationContext()创建默认的配置在ContextLoader.properties里面的WebApplicationContext接口实例XmlWebApplicationContext。

protected WebApplicationContext createWebApplicationContext(ServletContext sc) {        // 检测ContextClass        Class
     contextClass = determineContextClass(sc);        if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {            throw new ApplicationContextException("Custom context class [" + contextClass.getName() +                    "] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");        }        return (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);    }复制代码

因为没有配置contextClass所以会加载配置在ContextLoader.properties里面的对象。

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);            }        }    }复制代码

3.2 加载相应配置文件，初始化root容器

然后调用configureAndRefreshWebApplicationContext方法获取到配置在web.xml里面的configLocationParam值。把它配置成Spring容器的资源位置，最后通过调用wac.refresh()对于整个Spring容器进行加载。

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) { if (ObjectUtils.identityToString(wac).equals(wac.getId())) { String idParam = sc.getInitParameter(CONTEXT_ID_PARAM); if (idParam != null) { wac.setId(idParam); } else { wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + ObjectUtils.getDisplayString(sc.getContextPath())); } }

wac.setServletContext(sc);    // 获取contextConfigLocation值    String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);    if (configLocationParam != null) {        wac.setConfigLocation(configLocationParam);    }    ConfigurableEnvironment env = wac.getEnvironment();    if (env instanceof ConfigurableWebEnvironment) {        ((ConfigurableWebEnvironment) env).initPropertySources(sc, null);    }    customizeContext(sc, wac);    // 加载并刷新Spring容器    wac.refresh();}复制代码

3.3 把root容器放在ServletContext中

把初始化好的root 容器以WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE为key，放在Servlet容器当中，以备后面使用。

3.4 关联Servlet WebApplicationContext与 Root WebApplicationContext

我们知道servlet的规范中，servlet装载时会调用其init()方法，那么自然是调用DispatcherServlet的init方法，通过源码一看，竟然没有，但是并不带表真的没有，你会发现在父类的父类中：org.springframework.web.servlet.HttpServletBean有这个方法，如下图所示：

public final void init() throws ServletException {        if (logger.isDebugEnabled()) {            logger.debug("Initializing servlet '" + getServletName() + "'");        }        // 把DispatcherServlet里面的init-param转化成PropertyValues        PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);        if (!pvs.isEmpty()) {            try {                // 把DispatcherServlet转换成BeanWrapper,这样就把DispatcherServlet转换成了Spring中的Bean管理                BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);                ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());                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");        }    }复制代码

注意代码：initServletBean(); 其余的都和加载bean关系并不是特别大，跟踪进去会发I发现这个方法是在类：org.springframework.web.servlet.FrameworkServlet类中（是DispatcherServlet的父类、HttpServletBean的子类），内部通过调用initWebApplicationContext()来初始化一个WebApplicationContext，源码片段（篇幅所限，不拷贝所有源码，仅仅截取片段）

接下来需要知道的是如何初始化这个context的（按照使用习惯，其实只要得到了ApplicationContext，就得到了bean的信息，所以在初始化ApplicationCotext的时候，就已经初始化好了bean的信息，至少至少，它初始化好了bean的路径，以及描述信息），所以我们一旦知道ApplicationCotext是怎么初始化的，就基本知道bean是如何加载的了。

// 获取到root 容器    protected WebApplicationContext initWebApplicationContext() {        WebApplicationContext rootContext =                WebApplicationContextUtils.getWebApplicationContext(getServletContext());        WebApplicationContext wac = null;        if (this.webApplicationContext != null) {            wac = this.webApplicationContext;            if (wac instanceof ConfigurableWebApplicationContext) {                ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;                if (!cwac.isActive()) {                    if (cwac.getParent() == null) {                        // 设置父容器                        cwac.setParent(rootContext);                    }                    configureAndRefreshWebApplicationContext(cwac);                }            }        }        if (wac == null) {            wac = findWebApplicationContext();        }        if (wac == null) {            wac = createWebApplicationContext(rootContext);        }        if (!this.refreshEventReceived) {            onRefresh(wac);        }        if (this.publishContext) {            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;    }复制代码

最后调用configureAndRefreshWebApplicationContext方法获取到DispatcherServlet里面的contextConfigLocation值，创建并这个Servlet WebApplicationContex.

3.5 初始化Spring MVC默认组件

DispatcherServlet的初始化主线的执行体系是顺着其继承结构依次进行的，我们在之前曾经讨论过它的执行次序。所以，只有在FrameworkServlet完成了对于WebApplicationContext和组件的初始化之后，执行权才被正式转移到DispatcherServlet中。我们可以来看看DispatcherServlet此时究竟干了哪些事：

/**  * This implementation calls {@link #initStrategies}.  */  @Override  protected void onRefresh(ApplicationContext context) {      initStrategies(context);  }  /**  * Initialize the strategy objects that this servlet uses.  * May be overridden in subclasses in order to initialize further strategy objects.  */  protected void initStrategies(ApplicationContext context) {      initMultipartResolver(context);      initLocaleResolver(context);      initThemeResolver(context);      initHandlerMappings(context);      initHandlerAdapters(context);      initHandlerExceptionResolvers(context);      initRequestToViewNameTranslator(context);      initViewResolvers(context);      initFlashMapManager(context);  }  复制代码

onRefresh是FrameworkServlet中预留的扩展方法，在DispatcherServlet中做了一个基本实现：initStrategies。我们粗略一看，很容易就能明白DispatcherServlet到底在这里干些什么了：初始化组件。

读者或许会问，组件不是已经在WebApplicationContext初始化的时候已经被初始化过了嘛？这里所谓的组件初始化，指的又是什么呢？让我们来看看其中的一个方法的源码：

/**  * Initialize the MultipartResolver used by this class.  * If no bean is defined with the given name in the BeanFactory for this namespace,  * no multipart handling is provided.  */  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");          }      }  } 复制代码

原来，这里的初始化，指的是DispatcherServlet从容器（WebApplicationContext）中读取组件的实现类，并缓存于DispatcherServlet内部的过程。还记得我们之前给出的DispatcherServlet的数据结构吗？这些位于DispatcherServlet内部的组件实际上只是一些来源于容器缓存实例，不过它们同样也是DispatcherServlet进行后续操作的基础。

到了这里，把Spring MVC与Servlet容器的关系，以及Spring MVC通过Servlet容器的初始化顺序创建父子容器，以及根据Servlet的生命周期的init()方法来初始化Spring MVC的默认组件展现了出来。

4、Spring MVC的处理HTTP请求 Spring MVC要处理http请求，它首先要解决3个问题。

URL到框架的映射。

http请求参数绑定

http响应的生成和输出

4.1 URL到框架的映射

在Spring MVC我们只需要创建一个对象在上面标注@Controller注解。然后创建一个方法标注@RequestMapping然后这个方法就能够处理对应的url了。具体解析可以参看 – Spring MVC @RequestMapping

4.2 http请求参数绑定

对于http请求参数的绑定，在Spring MVC生成URL到框架的映射关系时会创建一个HandlerMethod对象。这个对象里面包括了这个url对应Spring对应标注了@RequestMapping方法的MethodParameter(方法参数)。通过HttpServletRequest获取到请求参数，然后再通过HandlerMethodArgumentResolver接口把请求参数绑定到方法参数中。

public interface HandlerMethodArgumentResolver {    boolean supportsParameter(MethodParameter parameter);    Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,            NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception;}复制代码

具体可以参考 – Spring MVC DataBinder

4.3 http响应的生成和输出

在整个系统运行的过程中处于Servlet的service()方法都处于侦听模式，侦听并处理所有的Web请求。因此，在service及其相关方法中，我们看到的则是对Http请求的处理流程。

在Spring MVC容器在初始的时候创建了URL到框架的映射，当前端请求的到来的时候。Spring MVC会获取到对应的HandlerMethod对象,HandlerMethod包括里面的属性。

public class HandlerMethod {    /** Logger that is available to subclasses */    protected final Log logger = LogFactory.getLog(getClass());    private final Object bean;    private final BeanFactory beanFactory;    private final Class
     beanType;    private final Method method;    private final Method bridgedMethod;    private final MethodParameter[] parameters;    private HttpStatus responseStatus;    private String responseStatusReason;    private HandlerMethod resolvedFromHandlerMethod;}复制代码

其中最主要的属性是以下三个：

bean ： @Controller对象实例。

method ：@Controller对象实例标注了@RequestMapping的方法对象，也就是处理对应url的方法

parameters ： @RequestMapping里面的方法参数。

通过http请求参数绑定，把Request请求的参数绑定解析成对应的方法参数。然后通过反射:

method.invoke(bean, paramters);复制代码

完成对http请求的整个响应。具体可以参见 – Spring MVC DispatcherServlet

为什么某些人会一直比你优秀，是因为他本身就很优秀还一直在持续努力变得更优秀，而你是不是还在满足于现状内心在窃喜!

合理利用自己每一分每一秒的时间来学习提升自己，不要再用"没有时间“来掩饰自己思想上的懒惰！趁年轻，使劲拼，给未来的自己一个交代！

To-陌霖Java架构

分享互联网最新文章关注互联网最新发展