继承体系结构如下所示：

 

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

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

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

 

Java代码   收藏代码
  1. public abstract class HttpServletBean extends HttpServlet implements EnvironmentAware{  
  2. @Override  
  3.     public final void init() throws ServletException {  
  4.        //省略部分代码  
  5.        //1、如下代码的作用是将Servlet初始化参数设置到该组件上  
  6. //如contextAttribute、contextClass、namespace、contextConfigLocation；  
  7.        try {  
  8.            PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);  
  9.            BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);  
  10.            ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());  
  11.            bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, this.environment));  
  12.            initBeanWrapper(bw);  
  13.            bw.setPropertyValues(pvs, true);  
  14.        }  
  15.        catch (BeansException ex) {  
  16.            //…………省略其他代码  
  17.        }  
  18.        //2、提供给子类初始化的扩展点，该方法由FrameworkServlet覆盖  
  19.        initServletBean();  
  20.        if (logger.isDebugEnabled()) {  
  21.            logger.debug("Servlet '" + getServletName() + "' configured successfully");  
  22.        }  
  23.     }  
  24.     //…………省略其他代码  
  25. }  

   

2、FrameworkServlet继承HttpServletBean，通过initServletBean()进行Web上下文初始化，该方法主要覆盖一下两件事情：

    初始化web上下文；

    提供给子类初始化扩展点；

Java代码   收藏代码
  1. public abstract class FrameworkServlet extends HttpServletBean {  
  2. @Override  
  3.     protected final void initServletBean() throws ServletException {  
  4.         //省略部分代码  
  5.        try {  
  6.              //1、初始化Web上下文  
  7.            this.webApplicationContext = initWebApplicationContext();  
  8.              //2、提供给子类初始化的扩展点  
  9.            initFrameworkServlet();  
  10.        }  
  11.         //省略部分代码  
  12.     }  
  13. }  

 

Java代码   收藏代码
  1. protected WebApplicationContext initWebApplicationContext() {  
  2.         //ROOT上下文（ContextLoaderListener加载的）  
  3.        WebApplicationContext rootContext =  
  4.               WebApplicationContextUtils.getWebApplicationContext(getServletContext());  
  5.        WebApplicationContext wac = null;  
  6.        if (this.webApplicationContext != null) {  
  7.            // 1、在创建该Servlet注入的上下文  
  8.            wac = this.webApplicationContext;  
  9.            if (wac instanceof ConfigurableWebApplicationContext) {  
  10.               ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;  
  11.               if (!cwac.isActive()) {  
  12.                   if (cwac.getParent() == null) {  
  13.                       cwac.setParent(rootContext);  
  14.                   }  
  15.                   configureAndRefreshWebApplicationContext(cwac);  
  16.               }  
  17.            }  
  18.        }  
  19.        if (wac == null) {  
  20.              //2、查找已经绑定的上下文  
  21.            wac = findWebApplicationContext();  
  22.        }  
  23.        if (wac == null) {  
  24.             //3、如果没有找到相应的上下文，并指定父亲为ContextLoaderListener  
  25.            wac = createWebApplicationContext(rootContext);  
  26.        }  
  27.        if (!this.refreshEventReceived) {  
  28.              //4、刷新上下文（执行一些初始化）  
  29.            onRefresh(wac);  
  30.        }  
  31.        if (this.publishContext) {  
  32.            // Publish the context as a servlet context attribute.  
  33.            String attrName = getServletContextAttributeName();  
  34.            getServletContext().setAttribute(attrName, wac);  
  35.            //省略部分代码  
  36.        }  
  37.        return wac;  
  38.     }  

  

从initWebApplicationContext（）方法可以看出，基本上如果ContextLoaderListener加载了上下文将作为根上下文（DispatcherServlet的父容器）。 

最后调用了onRefresh()方法执行容器的一些初始化，这个方法由子类实现，来进行扩展。

  

3、DispatcherServlet继承FrameworkServlet，并实现了onRefresh()方法提供一些前端控制器相关的配置： 

Java代码   收藏代码
  1. public class DispatcherServlet extends FrameworkServlet {  
  2.      //实现子类的onRefresh()方法，该方法委托为initStrategies()方法。  
  3.     @Override  
  4.     protected void onRefresh(ApplicationContext context) {  
  5.        initStrategies(context);  
  6.     }  
  7.    
  8.     //初始化默认的Spring Web MVC框架使用的策略（如HandlerMapping）  
  9.     protected void initStrategies(ApplicationContext context) {  
  10.        initMultipartResolver(context);  
  11.        initLocaleResolver(context);  
  12.        initThemeResolver(context);  
  13.        initHandlerMappings(context);  
  14.        initHandlerAdapters(context);  
  15.        initHandlerExceptionResolvers(context);  
  16.        initRequestToViewNameTranslator(context);  
  17.        initViewResolvers(context);  
  18.        initFlashMapManager(context);  
  19.     }  
  20. }  

  

从如上代码可以看出，DispatcherServlet启动时会进行我们需要的Web层Bean的配置，如HandlerMapping、HandlerAdapter等，而且如果我们没有配置，还会给我们提供默认的配置。

 

从如上代码我们可以看出，整个DispatcherServlet初始化的过程和做了些什么事情，具体主要做了如下两件事情：

1、初始化Spring Web MVC使用的Web上下文，并且可能指定父容器为（ContextLoaderListener加载了根上下文）；

2、初始化DispatcherServlet使用的策略，如HandlerMapping、HandlerAdapter等。 

 

服务器启动时的日志分析（此处加上了ContextLoaderListener从而启动ROOT上下文容器）： 

 信息: Initializing Spring root WebApplicationContext //由ContextLoaderListener启动ROOT上下文

 

2012-03-12 13:33:55 [main] INFO  org.springframework.web.context.ContextLoader - Root WebApplicationContext: initialization started

2012-03-12 13:33:55 [main] INFO  org.springframework.web.context.support.XmlWebApplicationContext - Refreshing Root WebApplicationContext: startup date [Mon Mar 12 13:33:55 CST 2012]; root of context hierarchy

2012-03-12 13:33:55 [main] DEBUG org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader - Loading bean definitions

2012-03-12 13:33:55 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loaded 0 bean definitions from location pattern [/WEB-INF/ContextLoaderListener.xml]

2012-03-12 13:33:55 [main] DEBUG org.springframework.web.context.support.XmlWebApplicationContext - Bean factory for Root WebApplicationContext: org.springframework.beans.factory.support.DefaultListableBeanFactory@1c05ffd: defining beans []; root of factory hierarchy

2012-03-12 13:33:55 [main] DEBUG org.springframework.web.context.support.XmlWebApplicationContext - Bean factory for Root WebApplicationContext:

2012-03-12 13:33:55 [main] DEBUG org.springframework.web.context.ContextLoader - Published root WebApplicationContext as ServletContext attribute with name [org.springframework.web.context.WebApplicationContext.ROOT] //将ROOT上下文绑定到ServletContext

2012-03-12 13:33:55 [main] INFO  org.springframework.web.context.ContextLoader - Root WebApplicationContext: initialization completed in 438 ms  //到此ROOT上下文启动完毕

 

 2012-03-12 13:33:55 [main] DEBUG org.springframework.web.servlet.DispatcherServlet - Initializing servlet 'chapter2'

信息: Initializing Spring FrameworkServlet 'chapter2'  //开始初始化FrameworkServlet对应的Web上下文

2012-03-12 13:33:55 [main] INFO  org.springframework.web.servlet.DispatcherServlet - FrameworkServlet 'chapter2': initialization started

2012-03-12 13:33:55 [main] DEBUG org.springframework.web.servlet.DispatcherServlet - Servlet with name 'chapter2' will try to create custom WebApplicationContext context of class 'org.springframework.web.context.support.XmlWebApplicationContext', using parent context [Root WebApplicationContext: startup date [Mon Mar 12 13:33:55 CST 2012]; root of context hierarchy]

//此处使用Root WebApplicationContext作为父容器。

2012-03-12 13:33:55 [main] INFO  org.springframework.web.context.support.XmlWebApplicationContext - Refreshing WebApplicationContext for namespace 'chapter2-servlet': startup date [Mon Mar 12 13:33:55 CST 2012]; parent: Root WebApplicationContext

2012-03-12 13:33:55 [main] INFO  org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loading XML bean definitions from ServletContext resource [/WEB-INF/chapter2-servlet.xml]

2012-03-12 13:33:55 [main] DEBUG org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader - Loading bean definitions

2012-03-12 13:33:55 [main] DEBUG org.springframework.beans.factory.xml.BeanDefinitionParserDelegate - Neither XML 'id' nor 'name' specified - using generated bean name[org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping#0]  //我们配置的HandlerMapping

2012-03-12 13:33:55 [main] DEBUG org.springframework.beans.factory.xml.BeanDefinitionParserDelegate - Neither XML 'id' nor 'name' specified - using generated bean name[org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter#0] //我们配置的HandlerAdapter

2012-03-12 13:33:55 [main] DEBUG org.springframework.beans.factory.xml.BeanDefinitionParserDelegate - Neither XML 'id' nor 'name' specified - using generated bean name [org.springframework.web.servlet.view.InternalResourceViewResolver#0] //我们配置的ViewResolver

2012-03-12 13:33:55 [main] DEBUG org.springframework.beans.factory.xml.BeanDefinitionParserDelegate - No XML 'id' specified - using '/hello' as bean name and [] as aliases 

//我们的处理器（HelloWorldController）

2012-03-12 13:33:55 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loaded 4 bean definitions from location pattern [/WEB-INF/chapter2-servlet.xml]

2012-03-12 13:33:55 [main] DEBUG org.springframework.web.context.support.XmlWebApplicationContext - Bean factory for WebApplicationContext for namespace 'chapter2-servlet': org.springframework.beans.factory.support.DefaultListableBeanFactory@1372656: defining beans [org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping#0,org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter#0,org.springframework.web.servlet.view.InternalResourceViewResolver#0,/hello]; parent: org.springframework.beans.factory.support.DefaultListableBeanFactory@1c05ffd

//到此容器注册的Bean初始化完毕

 

2012-03-12 13:33:56 [main] DEBUG org.springframework.web.servlet.DispatcherServlet - Unable to locate MultipartResolver with name 'multipartResolver': no multipart request handling provided

 

2012-03-12 13:33:56 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating instance of bean 'org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver'

//默认的LocaleResolver注册

2012-03-12 13:33:56 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating instance of bean 'org.springframework.web.servlet.theme.FixedThemeResolver'

//默认的ThemeResolver注册

 

2012-03-12 13:33:56 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Returning cached instance of singleton bean 'org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping#0'

//发现我们定义的HandlerMapping 不再使用默认的HandlerMapping。

 

2012-03-12 13:33:56 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Returning cached instance of singleton bean 'org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter#0'

//发现我们定义的HandlerAdapter 不再使用默认的HandlerAdapter。

 

2012-03-12 13:33:56 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating instance of bean 'org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver'

//异常处理解析器ExceptionResolver

2012-03-12 13:33:56 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating instance of bean 'org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver'

 

2012-03-12 13:33:56 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Returning cached instance of singleton bean 'org.springframework.web.servlet.view.InternalResourceViewResolver#0'

 

2012-03-12 13:33:56 [main] DEBUG org.springframework.web.servlet.DispatcherServlet - Published WebApplicationContext of servlet 'chapter2' as ServletContext attribute with name [org.springframework.web.servlet.FrameworkServlet.CONTEXT.chapter2]

//绑定FrameworkServlet初始化的Web上下文到ServletContext

2012-03-12 13:33:56 [main] INFO  org.springframework.web.servlet.DispatcherServlet - FrameworkServlet 'chapter2': initialization completed in  297 ms

2012-03-12 13:33:56 [main] DEBUG org.springframework.web.servlet.DispatcherServlet - Servlet 'chapter2' configured successfully

//到此完整流程结束 

  

从如上日志我们也可以看出，DispatcherServlet会进行一些默认的配置。接下来我们看一下默认配置吧。

  

3.5、DispatcherServlet默认配置

DispatcherServlet的默认配置在DispatcherServlet.properties（和DispatcherServlet类在一个包下）中，而且是当Spring配置文件中没有指定配置时使用的默认策略：

 

Java代码   收藏代码
  1. org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver  
  2.   
  3. org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver  
  4.   
  5. org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\  
  6.     org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping  
  7.   
  8. org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\  
  9.     org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\  
  10.     org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter  
  11.   
  12. org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver,\  
  13.     org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\  
  14.     org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver  
  15.   
  16. org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator  
  17.   
  18. org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver  
  19.   
  20. org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager  

   

从如上配置可以看出DispatcherServlet在启动时会自动注册这些特殊的Bean，无需我们注册，如果我们注册了，默认的将不会注册。 

因此如第二章的BeanNameUrlHandlerMapping、SimpleControllerHandlerAdapter是不需要注册的，DispatcherServlet默认会注册这两个Bean。

 

从DispatcherServlet.properties可以看出有许多特殊的Bean，那接下来我们就看看Spring Web MVC主要有哪些特殊的Bean。

3.6、DispatcherServlet中使用的特殊的Bean

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将把逻辑视图名解析为具体的View，通过这种策略模式，很容易更换其他视图技术；如InternalResourceViewResolver将逻辑视图名映射为jsp视图；

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

6、ThemeResovler：主题解析，通过它来实现一个页面多套风格，即常见的类似于软件皮肤效果；

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

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

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

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

  

到此DispatcherServlet我们已经了解了，接下来我们就需要把上边提到的特殊Bean挨个击破，那首先从控制器开始吧。

 

==========================以上部分来自跟开涛学MVC==================================

==================================哥是分割线========================================

 

 主要方法和类分析：

DispatcherServlet启动时，会依次加载配置文件中所有的Resolver(包括MultipartResolver,LocaleResolver,ThemeResolver)、HandlerMappings、HandlerAdapter、HandlerExceptionResolver、ViewResolver，若没有，则会提供默认的相应配置

 如：

Java代码   收藏代码
  1. protected void initStrategies(ApplicationContext context) {  
  2.         initMultipartResolver(context);  
  3.         initLocaleResolver(context);  
  4.         initThemeResolver(context);  
  5.         initHandlerMappings(context);  
  6.         initHandlerAdapters(context);  
  7.         initHandlerExceptionResolvers(context);  
  8.         initRequestToViewNameTranslator(context);  
  9.         initViewResolvers(context);  
  10.         initFlashMapManager(context);  
  11.     }  

 

 其中，这三个Resolver(MultipartResolver,LocaleResolver,ThemeResolver)是直接通过bean加载

 

Java代码   收藏代码
  1. private void initLocaleResolver(ApplicationContext context) {  
  2.         try {  
  3.             this.localeResolver = context.getBean(LOCALE_RESOLVER_BEAN_NAME, LocaleResolver.class);  
  4.             if (logger.isDebugEnabled()) {  
  5.                 logger.debug("Using LocaleResolver [" + this.localeResolver + "]");  
  6.             }  
  7.         }  
  8.         catch (NoSuchBeanDefinitionException ex) {  
  9.             // We need to use the default.  
  10.             this.localeResolver = getDefaultStrategy(context, LocaleResolver.class);  
  11.             if (logger.isDebugEnabled()) {  
  12.                 logger.debug("Unable to locate LocaleResolver with name '" + LOCALE_RESOLVER_BEAN_NAME +  
  13.                         "': using default [" + this.localeResolver + "]");  
  14.             }  
  15.         }  
  16.     }  
  17.   
  18. public static final String LOCALE_RESOLVER_BEAN_NAME = "localeResolver";  

 

而HandlerMappings、HandlerAdapters、HandlerExceptionResolvers则是通过通用方法构造一个相应的Map，如Map<String, HandlerMapping>，Map<String, HandlerAdapter>等，然后获得所有的handlerMappings / handlerAdapters.. List对象，如：

Java代码   收藏代码
  1. private void initHandlerMappings(ApplicationContext context) {  
  2.         this.handlerMappings = null;  
  3.   
  4.         if (this.detectAllHandlerMappings) {  
  5.             // Find all HandlerMappings in the ApplicationContext, including ancestor contexts.  
  6.             Map<String, HandlerMapping> matchingBeans =  
  7.                     BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);  
  8.             if (!matchingBeans.isEmpty()) {  
  9.                 this.handlerMappings = new ArrayList<HandlerMapping>(matchingBeans.values());  
  10.                 // We keep HandlerMappings in sorted order.  
  11.                 OrderComparator.sort(this.handlerMappings);  
  12.             }  
  13.         }  
  14.         else {  
  15.             try {  
  16.                 HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);  
  17.                 this.handlerMappings = Collections.singletonList(hm);  
  18.             }  
  19.             catch (NoSuchBeanDefinitionException ex) {  
  20.                 // Ignore, we'll add a default HandlerMapping later.  
  21.             }  
  22.         }  
  23.   
  24.         // Ensure we have at least one HandlerMapping, by registering  
  25.         // a default HandlerMapping if no other mappings are found.  
  26.         if (this.handlerMappings == null) {  
  27.             this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);  
  28.             if (logger.isDebugEnabled()) {  
  29.                 logger.debug("No HandlerMappings found in servlet '" + getServletName() + "': using default");  
  30.             }  
  31.         }  
  32.     }  

 

Java代码   收藏代码
  1. Map<String, HandlerAdapter> matchingBeans =  
  2.                     BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);  
  3.   
  4. Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils  
  5.                     .beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);  

 当没有找到HandlerMapping等时，会从DispatcherServlet.properties找到一个默认的Mapping，另两个也是

Java代码   收藏代码
  1. private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties";     
  2.     private static final Properties defaultStrategies;  
  3.           
  4.     static {  
  5.         // Load default strategy implementations from properties file.  
  6.         // This is currently strictly internal and not meant to be customized  
  7.         // by application developers.  
  8.         try {  
  9.             ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);  
  10.             defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);  
  11.         }  
  12.         catch (IOException ex) {  
  13.             throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + ex.getMessage());  
  14.         }  
  15.     }  

 

Java代码   收藏代码
  1. // Ensure we have at least one HandlerMapping, by registering  
  2.         // a default HandlerMapping if no other mappings are found.  
  3.         if (this.handlerMappings == null) {  
  4.             this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);  
  5.             if (logger.isDebugEnabled()) {  
  6.                 logger.debug("No HandlerMappings found in servlet '" + getServletName() + "': using default");  
  7.             }  
  8.         }  

 

Java代码   收藏代码
  1. /** 
  2.      * Create a List of default strategy objects for the given strategy interface. 
  3.      * <p>The default implementation uses the "DispatcherServlet.properties" file (in the same 
  4.      * package as the DispatcherServlet class) to determine the class names. It instantiates 
  5.      * the strategy objects through the context's BeanFactory. 
  6.      * @param context the current WebApplicationContext 
  7.      * @param strategyInterface the strategy interface 
  8.      * @return the List of corresponding strategy objects 
  9.      */  
  10.     @SuppressWarnings("unchecked")  
  11.     protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {  
  12.         String key = strategyInterface.getName();  
  13.         String value = defaultStrategies.getProperty(key);  
  14.         if (value != null) {  
  15.             String[] classNames = StringUtils.commaDelimitedListToStringArray(value);  
  16.             List<T> strategies = new ArrayList<T>(classNames.length);  
  17.             for (String className : classNames) {  
  18.                 try {  
  19.                     Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());  
  20.                     Object strategy = createDefaultStrategy(context, clazz);  
  21.                     strategies.add((T) strategy);  
  22.                 }  
  23.                 catch (ClassNotFoundException ex) {  
  24.                     throw new BeanInitializationException(  
  25.                             "Could not find DispatcherServlet's default strategy class [" + className +  
  26.                                     "] for interface [" + key + "]", ex);  
  27.                 }  
  28.                 catch (LinkageError err) {  
  29.                     throw new BeanInitializationException(  
  30.                             "Error loading DispatcherServlet's default strategy class [" + className +  
  31.                                     "] for interface [" + key + "]: problem with class file or dependent class", err);  
  32.                 }  
  33.             }  
  34.             return strategies;  
  35.         }  
  36.         else {  
  37.             return new LinkedList<T>();  
  38.         }  
  39.     }  

 

Java代码   收藏代码
  1. /** 
  2.      * Create a default strategy. 
  3.      * <p>The default implementation uses {@link org.springframework.beans.factory.config.AutowireCapableBeanFactory#createBean}. 
  4.      * @param context the current WebApplicationContext 
  5.      * @param clazz the strategy implementation class to instantiate 
  6.      * @return the fully configured strategy instance 
  7.      * @see org.springframework.context.ApplicationContext#getAutowireCapableBeanFactory() 
  8.      * @see org.springframework.beans.factory.config.AutowireCapableBeanFactory#createBean 
  9.      */  
  10.     protected Object createDefaultStrategy(ApplicationContext context, Class<?> clazz) {  
  11.         return context.getAutowireCapableBeanFactory().createBean(clazz);  
  12.     }  

 

 DispatcherServlet中最主要的核心功能是由doService和doDispatch实现的。

 

当请求到达后HttpServlet将调用service方法进行处理，由于我们是通过输入网址方式的get方法请求，Servlet将调用doGet方法

此处的doGet方法在FrameworkServlet中实现，doGet方法调用processRequest方法，

processRequest则调用doService方法处理，而doService在DispatcherServlet中实现，

doService再调用了DispatcherServlet的doDispatch方法，该方法则会根据request找到转发对象，并进行请求转发操作,

即dispatcherservlet中无论是通过post方式还是get方式提交的request，最终都会交由doservice()处理。

 

具体流程如下：

 

Java代码   收藏代码
  1. //HttpServlet  
  2. protected void service(HttpServletRequest req, HttpServletResponse resp)  
  3.         throws ServletException, IOException  
  4.     {  
  5.         String method = req.getMethod();  
  6.   
  7.         if (method.equals(METHOD_GET)) {  
  8.             long lastModified = getLastModified(req);  
  9.             if (lastModified == -1) {  
  10.                 // servlet doesn't support if-modified-since, no reason  
  11.                 // to go through further expensive logic  
  12.                 doGet(req, resp);  
  13.             } else {  
  14.                 long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);  
  15.                 if (ifModifiedSince < lastModified) {  
  16.                     // If the servlet mod time is later, call doGet()  
  17.                     // Round down to the nearest second for a proper compare  
  18.                     // A ifModifiedSince of -1 will always be less  
  19.                     maybeSetLastModified(resp, lastModified);  
  20.                     doGet(req, resp);  
  21.                 } else {  
  22.                     resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);  
  23.                 }  
  24.             }  
  25.   
  26.         } else if (method.equals(METHOD_HEAD)) {  
  27.             long lastModified = getLastModified(req);  
  28.             maybeSetLastModified(resp, lastModified);  
  29.             doHead(req, resp);  
  30.   
  31.         } else if (method.equals(METHOD_POST)) {  
  32.             doPost(req, resp);  
  33.               
  34.         } else if (method.equals(METHOD_PUT)) {  
  35.             doPut(req, resp);  
  36.               
  37.         } else if (method.equals(METHOD_DELETE)) {  
  38.             doDelete(req, resp);  
  39.               
  40.         } else if (method.equals(METHOD_OPTIONS)) {  
  41.             doOptions(req,resp);  
  42.               
  43.         } else if (method.equals(METHOD_TRACE)) {  
  44.             doTrace(req,resp);  
  45.               
  46.         } else {  
  47.             //  
  48.             // Note that this means NO servlet supports whatever  
  49.             // method was requested, anywhere on this server.  
  50.             //  
  51.   
  52.             String errMsg = lStrings.getString("http.method_not_implemented");  
  53.             Object[] errArgs = new Object[1];  
  54.             errArgs[0] = method;  
  55.             errMsg = MessageFormat.format(errMsg, errArgs);  
  56.               
  57.             resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);  
  58.         }  
  59.     }  

 

Java代码   收藏代码
  1. //FrameworkServlet  
  2.   
  3. @Override  
  4.     protected final void doGet(HttpServletRequest request, HttpServletResponse response)  
  5.             throws ServletException, IOException {  
  6.   
  7.         processRequest(request, response);  
  8.     }  
  9.   
  10. protected final void processRequest(HttpServletRequest request, HttpServletResponse response)  
  11.             throws ServletException, IOException {  
  12.   
  13.         long startTime = System.currentTimeMillis();  
  14.         Throwable failureCause = null;  
  15.   
  16.         LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();  
  17.         LocaleContext localeContext = buildLocaleContext(request);  
  18.   
  19.         RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();  
  20.         ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);  
  21.   
  22.         WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);  
  23.         asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());  
  24.   
  25.         initContextHolders(request, localeContext, requestAttributes);  
  26.   
  27.         try {  
  28.             doService(request, response);  
  29.         }  
  30.         catch (ServletException ex) {  
  31.             failureCause = ex;  
  32.             throw ex;  
  33.         }  
  34.         catch (IOException ex) {  
  35.             failureCause = ex;  
  36.             throw ex;  
  37.         }  
  38.         catch (Throwable ex) {  
  39.             failureCause = ex;  
  40.             throw new NestedServletException("Request processing failed", ex);  
  41.         }  
  42.   
  43.         finally {  
  44.             resetContextHolders(request, previousLocaleContext, previousAttributes);  
  45.             if (requestAttributes != null) {  
  46.                 requestAttributes.requestCompleted();  
  47.             }  
  48.   
  49.             if (logger.isDebugEnabled()) {  
  50.                 if (failureCause != null) {  
  51.                     this.logger.debug("Could not complete request", failureCause);  
  52.                 }  
  53.                 else {  
  54.                     if (asyncManager.isConcurrentHandlingStarted()) {  
  55.                         logger.debug("Leaving response open for concurrent processing");  
  56.                     }  
  57.                     else {  
  58.                         this.logger.debug("Successfully completed request");  
  59.                     }  
  60.                 }  
  61.             }  
  62.   
  63.             publishRequestHandledEvent(request, startTime, failureCause);  
  64.         }  
  65.     }  

 

 DispatcherServlet中doService：

Java代码   收藏代码
  1. @Override  
  2.     protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {  
  3.         if (logger.isDebugEnabled()) {  
  4.             String requestUri = urlPathHelper.getRequestUri(request);  
  5.             String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : "";  
  6.             logger.debug("DispatcherServlet with name '" + getServletName() + "'" + resumed +  
  7.                     " processing " + request.getMethod() + " request for [" + requestUri + "]");  
  8.         }  
  9.   
  10.         // Keep a snapshot of the request attributes in case of an include,  
  11.         // to be able to restore the original attributes after the include.  
  12.         Map<String, Object> attributesSnapshot = null;  
  13.         if (WebUtils.isIncludeRequest(request)) {  
  14.             logger.debug("Taking snapshot of request attributes before include");  
  15.             attributesSnapshot = new HashMap<String, Object>();  
  16.             Enumeration<?> attrNames = request.getAttributeNames();  
  17.             while (attrNames.hasMoreElements()) {  
  18.                 String attrName = (String) attrNames.nextElement();  
  19.                 if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {  
  20.                     attributesSnapshot.put(attrName, request.getAttribute(attrName));  
  21.                 }  
  22.             }  
  23.         }  
  24.   
  25.         // Make framework objects available to handlers and view objects.  
  26.         request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());  
  27.         request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);  
  28.         request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);  
  29.         request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());  
  30.   
  31.         FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);  
  32.         if (inputFlashMap != null) {  
  33.             request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));  
  34.         }  
  35.         request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());  
  36.         request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);  
  37.   
  38.         try {  
  39.             doDispatch(request, response);  
  40.         }  
  41.         finally {  
  42.             if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {  
  43.                 return;  
  44.             }  
  45.             // Restore the original attribute snapshot, in case of an include.  
  46.             if (attributesSnapshot != null) {  
  47.                 restoreAttributesAfterInclude(request, attributesSnapshot);  
  48.             }  
  49.         }  
  50.     }  

 

 doDispatch方法：处理拦截，转发请求，并绘制VIEW

 

 doDispatch()中的处理逻辑大致分以下几个步骤：

1.根据request得到相应的处理器

 HandlerExecutionChain  mappedhandler = getHandler(request)

2.调用注册的所有拦截器的prehandle方法

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

 

3.调用处理器 

 

//这里使用了adapter模式

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

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

 

4.调用注册的所有拦截器的posthandle方法

mappedHandler.applyPostHandle(processedRequest, response, mv);

 

5.绘制mv

render(mv, request, response);

 

Java代码   收藏代码
  1. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {  
  2.         HttpServletRequest processedRequest = request;  
  3.         HandlerExecutionChain mappedHandler = null;  
  4.         boolean multipartRequestParsed = false;  
  5.   
  6.         WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);  
  7.   
  8.         try {  
  9.             ModelAndView mv = null;  
  10.             Exception dispatchException = null;  
  11.   
  12.             try {  
  13.                 processedRequest = checkMultipart(request);  
  14.                 multipartRequestParsed = processedRequest != request;  
  15.   
  16.                 // Determine handler for the current request.  
  17.                 mappedHandler = getHandler(processedRequest);  
  18.                 if (mappedHandler == null || mappedHandler.getHandler() == null) {  
  19.                     noHandlerFound(processedRequest, response);  
  20.                     return;  
  21.                 }  
  22.   
  23.                 // Determine handler adapter for the current request.  
  24.                 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  
  25.   
  26.                 // Process last-modified header, if supported by the handler.  
  27.                 String method = request.getMethod();  
  28.                 boolean isGet = "GET".equals(method);  
  29.                 if (isGet || "HEAD".equals(method)) {  
  30.                     long lastModified = ha.getLastModified(request, mappedHandler.getHandler());  
  31.                     if (logger.isDebugEnabled()) {  
  32.                         String requestUri = urlPathHelper.getRequestUri(request);  
  33.                         logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);  
  34.                     }  
  35.                     if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {  
  36.                         return;  
  37.                     }  
  38.                 }  
  39.   
  40.                 if (!mappedHandler.applyPreHandle(processedRequest, response)) {  
  41.                     return;  
  42.                 }  
  43.   
  44.                 try {  
  45.                     // Actually invoke the handler.  
  46.                     mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  
  47.                 }  
  48.                 finally {  
  49.                     if (asyncManager.isConcurrentHandlingStarted()) {  
  50.                         return;  
  51.                     }  
  52.                 }  
  53.   
  54.                 applyDefaultViewName(request, mv);  
  55.                 mappedHandler.applyPostHandle(processedRequest, response, mv);  
  56.             }  
  57.             catch (Exception ex) {  
  58.                 dispatchException = ex;  
  59.             }  
  60.             processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);  
  61.         }  
  62.         catch (Exception ex) {  
  63.             triggerAfterCompletion(processedRequest, response, mappedHandler, ex);  
  64.         }  
  65.         catch (Error err) {  
  66.             triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);  
  67.         }  
  68.         finally {  
  69.             if (asyncManager.isConcurrentHandlingStarted()) {  
  70.                 // Instead of postHandle and afterCompletion  
  71.                 mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);  
  72.                 return;  
  73.             }  
  74.             // Clean up any resources used by a multipart request.  
  75.             if (multipartRequestParsed) {  
  76.                 cleanupMultipart(processedRequest);  
  77.             }  
  78.         }  
  79.     }  
Java代码   收藏代码
  1. protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {  
  2.         for (HandlerMapping hm : this.handlerMappings) {  
  3.             if (logger.isTraceEnabled()) {  
  4.                 logger.trace(  
  5.                         "Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");  
  6.             }  
  7.             HandlerExecutionChain handler = hm.getHandler(request);  
  8.             if (handler != null) {  
  9.                 return handler;  
  10.             }  
  11.         }  
  12.         return null;  
  13.     }  

参考：

SpringMVC中DispatcherServlet工作原理探究

spring中dispatcherservlet的运行机制

 

 几个实例对象：

1个HandlerMapping有1个HandlerExecutionChain

HandlerExecutionChain下有多个过滤器HandlerInterceptor

 

过滤器HandlerInterceptor下有前置方法和后置方法

Java代码   收藏代码
  1. public interface HandlerMapping {  
  2.   
  3.     /** 
  4.      * Return a handler and any interceptors for this request. The choice may be made 
  5.      * on request URL, session state, or any factor the implementing class chooses. 
  6.      * <p>The returned HandlerExecutionChain contains a handler Object, rather than 
  7.      * even a tag interface, so that handlers are not constrained in any way.     
  8.      */  
  9.     HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;  
  10.   
  11. }  

 

Java代码   收藏代码
  1. public class HandlerExecutionChain {  
  2.   
  3.     private final Object handler;  
  4.   
  5.     private HandlerInterceptor[] interceptors;  
  6.   
  7.     private List<HandlerInterceptor> interceptorList;  
  8.   
  9.     private int interceptorIndex = -1;  
  10.   
  11.   
  12.     public HandlerExecutionChain(Object handler) {  
  13.         this(handler, null);  
  14.     }  
  15.   
  16.     public HandlerExecutionChain(Object handler, HandlerInterceptor[] interceptors) {  
  17.         if (handler instanceof HandlerExecutionChain) {  
  18.             HandlerExecutionChain originalChain = (HandlerExecutionChain) handler;  
  19.             this.handler = originalChain.getHandler();  
  20.             this.interceptorList = new ArrayList<HandlerInterceptor>();  
  21.             CollectionUtils.mergeArrayIntoCollection(originalChain.getInterceptors(), this.interceptorList);  
  22.             CollectionUtils.mergeArrayIntoCollection(interceptors, this.interceptorList);  
  23.         }  
  24.         else {  
  25.             this.handler = handler;  
  26.             this.interceptors = interceptors;  
  27.         }  
  28.     }  
  29.       
  30.     public Object getHandler() {  
  31.         return this.handler;  
  32.     }  
  33.   
  34.     public void addInterceptor(HandlerInterceptor interceptor) {  
  35.         initInterceptorList();  
  36.         this.interceptorList.add(interceptor);  
  37.     }  
  38.   
  39.     public void addInterceptors(HandlerInterceptor[] interceptors) {  
  40.         if (interceptors != null) {  
  41.             initInterceptorList();  
  42.             this.interceptorList.addAll(Arrays.asList(interceptors));  
  43.         }  
  44.     }  
  45.   
  46.     private void initInterceptorList() {  
  47.         if (this.interceptorList == null) {  
  48.             this.interceptorList = new ArrayList<HandlerInterceptor>();  
  49.         }  
  50.         if (this.interceptors != null) {  
  51.             this.interceptorList.addAll(Arrays.asList(this.interceptors));  
  52.             this.interceptors = null;  
  53.         }  
  54.     }  
  55.   
  56.     /** 
  57.      * Return the array of interceptors to apply (in the given order). 
  58.      * @return the array of HandlerInterceptors instances (may be {@code null}) 
  59.      */  
  60.     public HandlerInterceptor[] getInterceptors() {  
  61.         if (this.interceptors == null && this.interceptorList != null) {  
  62.             this.interceptors = this.interceptorList.toArray(new HandlerInterceptor[this.interceptorList.size()]);  
  63.         }  
  64.         return this.interceptors;  
  65.     }  
  66.   
  67.     /** 
  68.      * 过滤器前置方法 
  69.      */  
  70.     boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {  
  71.         if (getInterceptors() != null) {  
  72.             for (int i = 0; i < getInterceptors().length; i++) {  
  73.                 HandlerInterceptor interceptor = getInterceptors()[i];  
  74.                 if (!interceptor.preHandle(request, response, this.handler)) {  
  75.                     triggerAfterCompletion(request, response, null);  
  76.                     return false;  
  77.                 }  
  78.                 this.interceptorIndex = i;  
  79.             }  
  80.         }  
  81.         return true;  
  82.     }  
  83.   
  84.     /** 
  85.      * 过滤器后置方法 
  86.      */  
  87.     void applyPostHandle(HttpServletRequest request, HttpServletResponse response, ModelAndView mv) throws Exception {  
  88.         if (getInterceptors() == null) {  
  89.             return;  
  90.         }  
  91.         for (int i = getInterceptors().length - 1; i >= 0; i--) {  
  92.             HandlerInterceptor interceptor = getInterceptors()[i];  
  93.             interceptor.postHandle(request, response, this.handler, mv);  
  94.         }  
  95.     }  
  96.   
  97.     /** 
  98.      * Trigger afterCompletion callbacks on the mapped HandlerInterceptors. 
  99.      * Will just invoke afterCompletion for all interceptors whose preHandle invocation 
  100.      * has successfully completed and returned true. 
  101.      */  
  102.     void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, Exception ex)  
  103.             throws Exception {  
  104.   
  105.         if (getInterceptors() == null) {  
  106.             return;  
  107.         }  
  108.         for (int i = this.interceptorIndex; i >= 0; i--) {  
  109.             HandlerInterceptor interceptor = getInterceptors()[i];  
  110.             try {  
  111.                 interceptor.afterCompletion(request, response, this.handler, ex);  
  112.             }  
  113.             catch (Throwable ex2) {  
  114.                 logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);  
  115.             }  
  116.         }  
  117.     }  
  118.   
  119.     /** 
  120.      * Apply afterConcurrentHandlerStarted callback on mapped AsyncHandlerInterceptors. 
  121.      */  
  122.     void applyAfterConcurrentHandlingStarted(HttpServletRequest request, HttpServletResponse response) {  
  123.         if (getInterceptors() == null) {  
  124.             return;  
  125.         }  
  126.         for (int i = getInterceptors().length - 1; i >= 0; i--) {  
  127.             if (interceptors[i] instanceof AsyncHandlerInterceptor) {  
  128.                 try {  
  129.                     AsyncHandlerInterceptor asyncInterceptor = (AsyncHandlerInterceptor) this.interceptors[i];  
  130.                     asyncInterceptor.afterConcurrentHandlingStarted(request, response, this.handler);  
  131.                 }  
  132.                 catch (Throwable ex) {  
  133.                     logger.error("Interceptor [" + interceptors[i] + "] failed in afterConcurrentHandlingStarted", ex);  
  134.                 }  
  135.             }  
  136.         }  
  137.     }  
  138.   
  139. }  

   适配器：

Java代码   收藏代码
  1. public interface HandlerAdapter {  
  2.       
  3.     /** 
  4.      * 处理请求Controller业务逻辑 
  5.      */  
  6.     ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;  
  7.   
  8. }  

 

Java代码   收藏代码
  1. public interface HandlerInterceptor {  
  2.   
  3.     /** 
  4.      * Intercept the execution of a handler. Called after HandlerMapping determined 
  5.      * an appropriate handler object, but before HandlerAdapter invokes the handler.  
  6.      */  
  7.     boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)  
  8.         throws Exception;  
  9.   
  10.           
  11.     /** 
  12.      * Intercept the execution of a handler. Called after HandlerAdapter actually 
  13.      * invoked the handler, but before the DispatcherServlet renders the view.   
  14.      */  
  15.     void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)  
  16.             throws Exception;  
  17.   
  18.     /** 
  19.      * Callback after completion of request processing, that is, after rendering     * 
  20.      */  
  21.     void afterCompletion(  
  22.             HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)  
  23.             throws Exception;  
  24.   
  25. }  

 

 

Java代码   收藏代码
  1. // 包含一个View对象和一个Map  
  2. //其中setViewName设置逻辑视图名，视图解析器会根据该名字解析到具体的视图页面  
  3. public class ModelAndView {  
  4.   
  5.     private Object view;  
  6.   
  7.     private ModelMap model;  
  8.   
  9.       
  10.     public ModelAndView(String viewName) {  
  11.         this.view = viewName;  
  12.     }  
  13.   
  14.     public ModelAndView(View view) {  
  15.         this.view = view;  
  16.     }  
  17.       
  18.     public ModelAndView(String viewName, Map<String, ?> model) {  
  19.         this.view = viewName;  
  20.         if (model != null) {  
  21.             getModelMap().addAllAttributes(model);  
  22.         }  
  23.     }  
  24.       
  25.     public ModelAndView(View view, Map<String, ?> model) {  
  26.         this.view = view;  
  27.         if (model != null) {  
  28.             getModelMap().addAllAttributes(model);  
  29.         }  
  30.     }  
  31.   
  32.     /** 
  33.      * Convenient constructor to take a single model object. 
  34.      * @param viewName name of the View to render, to be resolved 
  35.      * by the DispatcherServlet's ViewResolver 
  36.      * @param modelName name of the single entry in the model 
  37.      * @param modelObject the single model object 
  38.      */  
  39.     public ModelAndView(String viewName, String modelName, Object modelObject) {  
  40.         this.view = viewName;  
  41.         addObject(modelName, modelObject);  
  42.     }  
  43.   
  44.     /** 
  45.      * Convenient constructor to take a single model object. 
  46.      * @param view View object to render 
  47.      * @param modelName name of the single entry in the model 
  48.      * @param modelObject the single model object 
  49.      */  
  50.     public ModelAndView(View view, String modelName, Object modelObject) {  
  51.         this.view = view;  
  52.         addObject(modelName, modelObject);  
  53.     }  
  54.   
  55.   
  56.     /** 
  57.      * Set a view name for this ModelAndView, to be resolved by the 
  58.      * DispatcherServlet via a ViewResolver. Will override any 
  59.      * pre-existing view name or View. 
  60.      */  
  61.     public void setViewName(String viewName) {  
  62.         this.view = viewName;  
  63.     }  
  64.   
  65.     /** 
  66.      * Return the view name to be resolved by the DispatcherServlet 
  67.      * via a ViewResolver, or {@code null} if we are using a View object. 
  68.      */  
  69.     public String getViewName() {  
  70.         return (this.view instanceof String ? (String) this.view : null);  
  71.     }  
  72.   
  73.     /** 
  74.      * Set a View object for this ModelAndView. Will override any 
  75.      * pre-existing view name or View. 
  76.      */  
  77.     public void setView(View view) {  
  78.         this.view = view;  
  79.     }  
  80.   
  81.     /** 
  82.      * Return the View object, or {@code null} if we are using a view name 
  83.      * to be resolved by the DispatcherServlet via a ViewResolver. 
  84.      */  
  85.     public View getView() {  
  86.         return (this.view instanceof View ? (View) this.view : null);  
  87.     }  
  88.   
  89.     /** 
  90.      * Indicate whether or not this {@code ModelAndView} has a view, either 
  91.      * as a view name or as a direct {@link View} instance. 
  92.      */  
  93.     public boolean hasView() {  
  94.         return (this.view != null);  
  95.     }  
  96.   
  97.     /** 
  98.      * Return whether we use a view reference, i.e. {@code true} 
  99.      * if the view has been specified via a name to be resolved by the 
  100.      * DispatcherServlet via a ViewResolver. 
  101.      */  
  102.     public boolean isReference() {  
  103.         return (this.view instanceof String);  
  104.     }  
  105.   
  106.     /** 
  107.      * Return the model map. May return {@code null}. 
  108.      * Called by DispatcherServlet for evaluation of the model. 
  109.      */  
  110.     protected Map<String, Object> getModelInternal() {  
  111.         return this.model;  
  112.     }  
  113.   
  114.     /** 
  115.      * Return the underlying {@code ModelMap} instance (never {@code null}). 
  116.      */  
  117.     public ModelMap getModelMap() {  
  118.         if (this.model == null) {  
  119.             this.model = new ModelMap();  
  120.         }  
  121.         return this.model;  
  122.     }  
  123.   
  124.     /** 
  125.      * Return the model map. Never returns {@code null}. 
  126.      * To be called by application code for modifying the model. 
  127.      */  
  128.     public Map<String, Object> getModel() {  
  129.         return getModelMap();  
  130.     }  
  131.   
  132.   
  133.     /** 
  134.      * Add an attribute to the model. 
  135.      * @param attributeName name of the object to add to the model 
  136.      * @param attributeValue object to add to the model (never {@code null}) 
  137.      * @see ModelMap#addAttribute(String, Object) 
  138.      * @see #getModelMap() 
  139.      */  
  140.     public ModelAndView addObject(String attributeName, Object attributeValue) {  
  141.         getModelMap().addAttribute(attributeName, attributeValue);  
  142.         return this;  
  143.     }  
  144.   
  145.     /** 
  146.      * Add an attribute to the model using parameter name generation. 
  147.      * @param attributeValue the object to add to the model (never {@code null}) 
  148.      * @see ModelMap#addAttribute(Object) 
  149.      * @see #getModelMap() 
  150.      */  
  151.     public ModelAndView addObject(Object attributeValue) {  
  152.         getModelMap().addAttribute(attributeValue);  
  153.         return this;  
  154.     }  
  155.   
  156.     /** 
  157.      * Add all attributes contained in the provided Map to the model. 
  158.      * @param modelMap a Map of attributeName -> attributeValue pairs 
  159.      * @see ModelMap#addAllAttributes(Map) 
  160.      * @see #getModelMap() 
  161.      */  
  162.     public ModelAndView addAllObjects(Map<String, ?> modelMap) {  
  163.         getModelMap().addAllAttributes(modelMap);  
  164.         return this;  
  165.     }  
  166.   
  167. }  

 

Java代码   收藏代码
  1. public interface ViewResolver {  
  2.   
  3.     /** 
  4.      * Resolve the given view by name. 
  5.      * 从viewName获取View 
  6.      */  
  7.     View resolveViewName(String viewName, Locale locale) throws Exception;  
  8.   
  9. }  

 

Java代码   收藏代码
  1. public interface View {  
  2.   
  3.     /** 
  4.      * Render the view given the specified model. 
  5.      * 渲染页面 
  6.      */  
  7.     void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception;  
  8.   
  9. }  

 ..

Logo
向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

avatar 云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

avatar 云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

avatar 云原生