《Spring技术内幕》笔记-第四章 Spring MVC与web环境

​上下文在web容器中的启动

1，IoC容器的启动过程

    IoC的启动过程就是建立上下文的过程。该上下文是与ServletContext相伴。在Spring中存在一个核心控制分发器，DispatcherServlet，这是Spring的核心。在web容器启动Spring应用程序时。首先建立根上下文，然后ContextLoader建立WebApplicationContext。

    Web容器中启动Spring步骤例如以下：


    在web.xml中。已经配置了ContextLoadListener，该类实现了ServletLoaderListener接口。

ServletLoaderListener是在Servlet API中定义的接口，接口提供Servlet生命周期。而详细的IoC加载过程是ContextLoadListener交由ContextLoader完毕，ContextLoader是ContextLoadListener的父类。三者关系例如以下：


    在ContextLoader中。完毕了两个IoC建立的基本过程，一是在Web容器中建立起双亲IoC容器，还有一个是生成对应的WebApplicationContext并将其初始化。

2。Web容器中的上下文设计。

    Spring为Web提供了上下文扩展接口WebApplicationContext来满足启动过程的须要。

该接口主要提供getServletContext方法，通过这种方法能够获取容器的Web上下文。


  1. /**
  2. 	 * Return the standard Servlet API ServletContext for this application.
  3. 	 * <p>Also available for a Portlet application, in addition to the PortletContext.
  4. 	 */
  5. 	ServletContext getServletContext();

在启动过程中，Spring使用XmlWebApplicationContext作为默认的实现。

    XmlWebApplicationContext定义了一系列常量，定义了默认的配置文件，文件位置以及文件类型。

  2. 	/** Default config location for the root context */
  3. 	public static final String DEFAULT_CONFIG_LOCATION = "/WEB-INF/applicationContext.xml";
  5. 	/** Default prefix for building a config location for a namespace */
  6. 	public static final String DEFAULT_CONFIG_LOCATION_PREFIX = "/WEB-INF/";
  8. 	/** Default suffix for building a config location for a namespace */
  9. 	public static final String DEFAULT_CONFIG_LOCATION_SUFFIX = ".xml";

通时。该类的方法中。定义了通过xml启动IoC的过程：

  1. 	@Override
  2. 	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
  3. 		// Create a new XmlBeanDefinitionReader for the given BeanFactory.
  4. 		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
  6. 		// Configure the bean definition reader with this context's
  7. 		// resource loading environment.
  8. 		beanDefinitionReader.setEnvironment(getEnvironment());
  9. 		beanDefinitionReader.setResourceLoader(this);
  10. 		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
  12. 		// Allow a subclass to provide custom initialization of the reader,
  13. 		// then proceed with actually loading the bean definitions.
  14. 		initBeanDefinitionReader(beanDefinitionReader);
  15. 		loadBeanDefinitions(beanDefinitionReader);
  16. 	}

完毕对配置文件的读取：

  1. protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
  2. 		String[] configLocations = getConfigLocations();
  3. 		if (configLocations != null) {
  4. 			for (String configLocation : configLocations) {
  5. 				reader.loadBeanDefinitions(configLocation);
  6. 			}
  7. 		}
  8. 	}

获取配置文件位置。

  1. protected String[] getDefaultConfigLocations() {
  2. 		if (getNamespace() != null) {
  3. 			return new String[] {DEFAULT_CONFIG_LOCATION_PREFIX + getNamespace() + DEFAULT_CONFIG_LOCATION_SUFFIX};
  4. 		}
  5. 		else {
  6. 			return new String[] {DEFAULT_CONFIG_LOCATION};
  7. 		}
  8. 	}

XmlWebApplicationContext类代码中能够看到，该类仅仅是实现了基础的基于XML文件的部分操作。详细的Servlet上下文，则默认取自其父类。

3。ContextLoader的设计与实现

    ContextLoaderListener通过ContextLoader完毕IoC的初始化。

    ContextLoaderListener的详细实现思路例如以下：ContextLoaderListener监听器启动根IoC容器并把它加载到Web容器的主要功能模块，这也是这个SpringWeb应用加载IoC的第一个地方。

从加载过程能够看到，首先从Servelt事件中得到ServletContext，然后能够读取配置在web.xml中的各个相关属性。记着ContextLoader会实例化WebApplicationContext，并完毕其加载和初始化过程。这个被初始化的第一个上下文作为根上下文存在，这个根上下文加载后。被绑定到Web应用程序的ServletCOntext上。怎样须要訪问根上下文的应用程序代码都能够通过WebApplicationContextUtils类的静态方法中得到。该根上下文存储至：ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE


 在ContextLoaderListener中，会监听ServletContext的详细变化，如创建和销毁，并再监听器中定义了对应的回调方法。

  1. 	public ContextLoaderListener(WebApplicationContext context) {
  2. 		super(context);
  3. 	}
  5. 	/**
  6. 	 * Initialize the root web application context.
  7. 	 */
  8. 	@Override
  9. 	public void contextInitialized(ServletContextEvent event) {
  10. 		initWebApplicationContext(event.getServletContext());
  11. 	}
  14. 	/**
  15. 	 * Close the root web application context.
  16. 	 */
  17. 	@Override
  18. 	public void contextDestroyed(ServletContextEvent event) {
  19. 		closeWebApplicationContext(event.getServletContext());
  20. 		ContextCleanupListener.cleanupAttributes(event.getServletContext());
  21. 	}

详细的调用。交由ContextLoader实现。例如以下。ContextLoader的初始化容器方法：

  1. /**
  2. 	 * Initialize Spring's web application context for the given servlet context,
  3. 	 * using the application context provided at construction time, or creating a new one
  4. 	 * according to the "{@link #CONTEXT_CLASS_PARAM contextClass}" and
  5. 	 * "{@link #CONFIG_LOCATION_PARAM contextConfigLocation}" context-params.
  6. 	 * @param servletContext current servlet context
  7. 	 * @return the new WebApplicationContext
  8. 	 * @see #ContextLoader(WebApplicationContext)
  9. 	 * @see #CONTEXT_CLASS_PARAM
  10. 	 * @see #CONFIG_LOCATION_PARAM
  11. 	 */
  12. 	public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
  13. 		if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {//是否已存在根上下文
  14. 			throw new IllegalStateException(
  15. 					"Cannot initialize context because there is already a root application context present - " +
  16. 					"check whether you have multiple ContextLoader* definitions in your web.xml!");
  17. 		}
  19. 		Log logger = LogFactory.getLog(ContextLoader.class);
  20. 		servletContext.log("Initializing Spring root WebApplicationContext");
  21. 		if (logger.isInfoEnabled()) {
  22. 			logger.info("Root WebApplicationContext: initialization started");
  23. 		}
  24. 		long startTime = System.currentTimeMillis();
  26. 		try {
  27. 			// Store context in local instance variable, to guarantee that
  28. 			// it is available on ServletContext shutdown.
  29. 			if (this.context == null) {//创建上下文
  30. 				this.context = createWebApplicationContext(servletContext);
  31. 			}
  32. 			if (this.context instanceof ConfigurableWebApplicationContext) {
  33. ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
  34. 				if (!cwac.isActive()) {
  35. 					// The context has not yet been refreshed -> provide services such as
  36. 					// setting the parent context, setting the application context id, etc
  37. 					if (cwac.getParent() == null) {
  38. 						// The context instance was injected without an explicit parent ->
  39. 						// determine parent for root web application context, if any.加载双亲上下文
  40. 						ApplicationContext parent = loadParentContext(servletContext);
  41. 						cwac.setParent(parent);
  42. 					}

  43. //配置各项參数。以及对应的初始化方法
  44. 					configureAndRefreshWebApplicationContext(cwac, servletContext);
  45. 				}
  46. 			}
  47. 			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
  49. 			ClassLoader ccl = Thread.currentThread().getContextClassLoader();
  50. 			if (ccl == ContextLoader.class.getClassLoader()) {
  51. 				currentContext = this.context;
  52. 			}
  53. 			else if (ccl != null) {
  54. 				currentContextPerThread.put(ccl, this.context);
  55. 			}
  57. 			if (logger.isDebugEnabled()) {
  58. 				logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
  59. 						WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
  60. 			}
  61. 			if (logger.isInfoEnabled()) {
  62. 				long elapsedTime = System.currentTimeMillis() - startTime;
  63. 				logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
  64. 			}
  66. 			return this.context;
  67. 		}
  68. 		catch (RuntimeException ex) {
  69. 			logger.error("Context initialization failed", ex);
  70. 			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
  71. 			throw ex;
  72. 		}
  73. 		catch (Error err) {
  74. 			logger.error("Context initialization failed", err);
  75. 			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
  76. 			throw err;
  77. 		}
  78. 	}

createWebApplicationContext是详细的创建根上下文的方法。

  1. protected WebApplicationContext createWebApplicationContext(ServletContext sc) {
  2. 		Class<?> contextClass = determineContextClass(sc);//Return the WebApplicationContext implementation class to use
  3. 		if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
  4. 			throw new ApplicationContextException("Custom context class [" + contextClass.getName() +
  5. 					"] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");
  6. 		}
  7. 		return (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
  8. 	}
创建好上下文的后。调用了configureAndRefreshWebApplicationContext方法： 


  1. protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
  2. 		if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
  3. 			// The application context id is still set to its original default value
  4. 			// -> assign a more useful id based on available information
  5. 			String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
  6. 			if (idParam != null) {
  7. 				wac.setId(idParam);
  8. 			}
  9. 			else {
  10. 				// Generate default id...
  11. 				wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
  12. 						ObjectUtils.getDisplayString(sc.getContextPath()));
  13. 			}
  14. 		}
  16. 		wac.setServletContext(sc);
  17. 		String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
  18. 		if (configLocationParam != null) {
  19. 			wac.setConfigLocation(configLocationParam);
  20. 		}
  22. 		// The wac environment's #initPropertySources will be called in any case when the context
  23. 		// is refreshed; do it eagerly here to ensure servlet property sources are in place for
  24. 		// use in any post-processing or initialization that occurs below prior to #refresh
  25. 		ConfigurableEnvironment env = wac.getEnvironment();
  26. 		if (env instanceof ConfigurableWebEnvironment) {
  27. 			((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
  28. 		}
  30. 		customizeContext(sc, wac);
  31. 		wac.refresh();
  32. 	}

determineContextClass方法中。详细了详细实现什么上下文对象。默觉得XmlWebApplicationContext。

  1. protected Class<?> determineContextClass(ServletContext servletContext) {

  2. //配置參数

  3. 		String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);
  4. 		if (contextClassName != null) {
  5. 			try {
  6. 				return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader());
  7. 			}
  8. 			catch (ClassNotFoundException ex) {
  9. 				throw new ApplicationContextException(
  10. 						"Failed to load custom context class [" + contextClassName + "]", ex);
  11. 			}
  12. 		}
  13. 		else {//没有额外配置则採用默认的配置
  14. 			contextClassName = defaultStrategies.getProperty(WebApplicationContext.class.getName());
  15. 			try {
  16. 				return ClassUtils.forName(contextClassName, ContextLoader.class.getClassLoader());
  17. 			}
  18. 			catch (ClassNotFoundException ex) {
  19. 				throw new ApplicationContextException(
  20. 						"Failed to load default context class [" + contextClassName + "]", ex);
  21. 			}
  22. 		}
  23. 	}

以上就是IoC容器在Web容器中的启动过程，与应用中启动IoC基本同样，唯一不同的是须要考虑web容器特点。设置相应web容器须要的參数。

Spring MVC的设计与实现

    Spring MVC出了配置ContextListener之类，还需配置核心分发器DispatcherServlet。DispatcherServlet作为一个前端控制器，全部web请求都要经过他来处理，其对请求进行转发。匹配，数据处理后。再由页面处理。DispatcherServlet是Spring MVC的核心。

1，概览

    完毕ContextLoaderListener初始化之后，Web容器開始初始化DispatcherServlet。DispatcherServlet会建立自己的上下文来持有Spring MVC的Bean对象。在建立自己的上下文时，会从ServletContext中得到根上下文作为DispatcherServlet持有的上下文的双亲上下文。有了根上下文。在对自己持有上下文进行初始化，最后把自己的上下文保存到ServletContex，供以后使用。

    DispatcherServlet继承自FramworkServlet，FramworkServlet继承HttpServletBean。HttpServletBean继承HttpServlet，通过Servlet API对请求对应。

    DispatcherServlet的工作大致分为两个：-1，初始化部分。由initServletBean启动。通过initWebApplicationContext()方法终于抵用DispatcherServlet的initStraegies方法，在这种方法里，DispatcherServlet对MVC的其它模块进行了初始化。比方handlerMapping，ViewResolver。-2，对HTTP请求进行响应。作为一个Servlet，Web容器会调用Servlet的doGet和doPost方法，在经过FraeWorkServlet处理后。会调用DispatcherServlet的doService()方法，这种方法中封装了doDispatch()方法，doDispatch()是DIspatcher实现MVC的主要部分。

2。DispatcherServlet的启动和初始化

    DispatcherServlet的初始化方法的開始。是由HttpServletBean的init()方法開始的。该方法负责获取相应的各项配置參数：

  1. 	/**
  2. 	 * Map config parameters onto bean properties of this servlet, and
  3. 	 * invoke subclass initialization.
  4. 	 * @throws ServletException if bean properties are invalid (or required
  5. 	 * properties are missing), or if subclass initialization fails.
  6. 	 */
  7. 	@Override
  8. 	public final void init() throws ServletException {
  9. 		if (logger.isDebugEnabled()) {
  10. 			logger.debug("Initializing servlet '" + getServletName() + "'");
  11. 		}
  13. 		// Set bean properties from init parameters.
  14. 		try {
  15. 			PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
  16. 			BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
  17. 			ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
  18. 			bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
  19. 			initBeanWrapper(bw);
  20. 			bw.setPropertyValues(pvs, true);
  21. 		}
  22. 		catch (BeansException ex) {
  23. 			logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
  24. 			throw ex;
  25. 		}
  27. 		// Let subclasses do whatever initialization they like.
  28. 		initServletBean();
  30. 		if (logger.isDebugEnabled()) {
  31. 			logger.debug("Servlet '" + getServletName() + "' configured successfully");
  32. 		}
  33. 	}

在该方法中。调用了子类的initServletBean()方法，即FrameworkServlet中的initServletBean()方法：

    

  1. /**
  2. 	 * Overridden method of {@link HttpServletBean}, invoked after any bean properties
  3. 	 * have been set. Creates this servlet's WebApplicationContext.
  4. 	 */
  5. 	@Override
  6. 	protected final void initServletBean() throws ServletException {
  7. 		getServletContext().log("Initializing Spring FrameworkServlet '" + getServletName() + "'");
  8. 		if (this.logger.isInfoEnabled()) {
  9. 			this.logger.info("FrameworkServlet '" + getServletName() + "': initialization started");
  10. 		}
  11. 		long startTime = System.currentTimeMillis();
  13. 		try {//初始化上下文
  14. 			this.webApplicationContext = initWebApplicationContext();
  15. 			initFrameworkServlet();
  16. 		}
  17. 		catch (ServletException ex) {
  18. 			this.logger.error("Context initialization failed", ex);
  19. 			throw ex;
  20. 		}
  21. 		catch (RuntimeException ex) {
  22. 			this.logger.error("Context initialization failed", ex);
  23. 			throw ex;
  24. 		}
  26. 		if (this.logger.isInfoEnabled()) {
  27. 			long elapsedTime = System.currentTimeMillis() - startTime;
  28. 			this.logger.info("FrameworkServlet '" + getServletName() + "': initialization completed in " +
  29. 					elapsedTime + " ms");
  30. 		}
  31. 	}

该方法中，通过initWebApplicationContext()完毕初始化上下文操作：

  1. protected WebApplicationContext initWebApplicationContext() {
  2. 		WebApplicationContext rootContext =
  3. 				WebApplicationContextUtils.getWebApplicationContext(getServletContext());
  4. 		WebApplicationContext wac = null;
  6. 		if (this.webApplicationContext != null) {
  7. 			// A context instance was injected at construction time -> use it
  8. 			wac = this.webApplicationContext;
  9. 			if (wac instanceof ConfigurableWebApplicationContext) {
  10. 				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
  11. 				if (!cwac.isActive()) {
  12. 					// The context has not yet been refreshed -> provide services such as
  13. 					// setting the parent context, setting the application context id, etc
  14. 					if (cwac.getParent() == null) {
  15. 						// The context instance was injected without an explicit parent -> set
  16. 						// the root application context (if any; may be null) as the parent
  17. 						cwac.setParent(rootContext);
  18. 					}
  19. 					configureAndRefreshWebApplicationContext(cwac);
  20. 				}
  21. 			}
  22. 		}
  23. 		if (wac == null) {
  24. 			// No context instance was injected at construction time -> see if one
  25. 			// has been registered in the servlet context. If one exists, it is assumed
  26. 			// that the parent context (if any) has already been set and that the
  27. 			// user has performed any initialization such as setting the context id
  28. 			wac = findWebApplicationContext();
  29. 		}
  30. 		if (wac == null) {
  31. 			// No context instance is defined for this servlet -> create a local one
  32. 			wac = createWebApplicationContext(rootContext);
  33. 		}
  35. 		if (!this.refreshEventReceived) {
  36. 			// Either the context is not a ConfigurableApplicationContext with refresh
  37. 			// support or the context injected at construction time had already been
  38. 			// refreshed -> trigger initial onRefresh manually here.
  39. 			onRefresh(wac);
  40. 		}
  42. 		if (this.publishContext) {
  43. 			// Publish the context as a servlet context attribute.
  44. 			String attrName = getServletContextAttributeName();
  45. 			getServletContext().setAttribute(attrName, wac);
  46. 			if (this.logger.isDebugEnabled()) {
  47. 				this.logger.debug("Published WebApplicationContext of servlet '" + getServletName() +
  48. 						"' as ServletContext attribute with name [" + attrName + "]");
  49. 			}
  50. 		}
  52. 		return wac;
  53. 	}

通过WebApplicationContextUtils.getWebApplicationContext获取根上下文。

  1. public static WebApplicationContext getWebApplicationContext(ServletContext sc) {
  2. 		return getWebApplicationContext(sc, WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
  3. 	}
  6. 	public static WebApplicationContext getWebApplicationContext(ServletContext sc, String attrName) {
  7. 		Assert.notNull(sc, "ServletContext must not be null");
  8. 		Object attr = sc.getAttribute(attrName);
  9. 		if (attr == null) {
  10. 			return null;
  11. 		}
  12. 		if (attr instanceof RuntimeException) {
  13. 			throw (RuntimeException) attr;
  14. 		}
  15. 		if (attr instanceof Error) {
  16. 			throw (Error) attr;
  17. 		}
  18. 		if (attr instanceof Exception) {
  19. 			throw new IllegalStateException((Exception) attr);
  20. 		}
  21. 		if (!(attr instanceof WebApplicationContext)) {
  22. 			throw new IllegalStateException("Context attribute is not of type WebApplicationContext: " + attr);
  23. 		}
  24. 		return (WebApplicationContext) attr;
  25. 	}

建立好根上下文后，在通过createWebApplicationContext建立DispatcherServlet的上下文。

  1. protected WebApplicationContext createWebApplicationContext(ApplicationContext parent) {
  2. 		Class<?> contextClass = getContextClass();
  3. 		if (this.logger.isDebugEnabled()) {
  4. 			this.logger.debug("Servlet with name '" + getServletName() +
  5. 					"' will try to create custom WebApplicationContext context of class '" +
  6. 					contextClass.getName() + "'" + ", using parent context [" + parent + "]");
  7. 		}
  8. 		if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
  9. 			throw new ApplicationContextException(
  10. 					"Fatal initialization error in servlet with name '" + getServletName() +
  11. 					"': custom WebApplicationContext class [" + contextClass.getName() +
  12. 					"] is not of type ConfigurableWebApplicationContext");
  13. 		}
  14. 		ConfigurableWebApplicationContext wac =
  15. 				(ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
  17. 		wac.setEnvironment(getEnvironment());
  18. 		wac.setParent(parent);
  19. 		wac.setConfigLocation(getContextConfigLocation());
  21. 		configureAndRefreshWebApplicationContext(wac);
  23. 		return wac;
  24. 	}

再通过configureAndRefreshWebApplicationContext完毕各项配置以及初始化：

  1. protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
  2. 		if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
  3. 			// The application context id is still set to its original default value
  4. 			// -> assign a more useful id based on available information
  5. 			if (this.contextId != null) {
  6. 				wac.setId(this.contextId);
  7. 			}
  8. 			else {
  9. 				// Generate default id...
  10. 				wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
  11. 						ObjectUtils.getDisplayString(getServletContext().getContextPath()) + "/" + getServletName());
  12. 			}
  13. 		}
  15. 		wac.setServletContext(getServletContext());
  16. 		wac.setServletConfig(getServletConfig());
  17. 		wac.setNamespace(getNamespace());
  18. 		wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));
  20. 		// The wac environment's #initPropertySources will be called in any case when the context
  21. 		// is refreshed; do it eagerly here to ensure servlet property sources are in place for
  22. 		// use in any post-processing or initialization that occurs below prior to #refresh
  23. 		ConfigurableEnvironment env = wac.getEnvironment();
  24. 		if (env instanceof ConfigurableWebEnvironment) {
  25. 			((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
  26. 		}
  28. 		postProcessWebApplicationContext(wac);
  29. 		applyInitializers(wac);
  30. 		wac.refresh();//初始化
  31. 	}

以上完毕了DispatcherServlet的IoC容器的建立。

在Spring MVC DispatcherServlet的初始化过程中。以对HandlerMapping的初始化作为開始。该初始化过程。以HttpServletbean的init方法開始，到FrameWorkServlet的initServletBean，再到DispatcherServlet的onRefresh方法。最后到initStrategies()，启动整个MVC的初始化。

  1. /**
  2. 	 * This implementation calls {@link #initStrategies}.
  3. 	 */
  4. 	@Override
  5. 	protected void onRefresh(ApplicationContext context) {
  6. 		initStrategies(context);
  7. 	}
  9. 	/**
  10. 	 * Initialize the strategy objects that this servlet uses.
  11. 	 * <p>May be overridden in subclasses in order to initialize further strategy objects.
  12. 	 */
  13. 	protected void initStrategies(ApplicationContext context) {
  14. 		initMultipartResolver(context);
  15. 		initLocaleResolver(context);
  16. 		initThemeResolver(context);
  17. 		initHandlerMappings(context);
  18. 		initHandlerAdapters(context);
  19. 		initHandlerExceptionResolvers(context);
  20. 		initRequestToViewNameTranslator(context);
  21. 		initViewResolvers(context);
  22. 		initFlashMapManager(context);
  23. 	}

HandlerMappings的初始化例如以下：

  1. private void initHandlerMappings(ApplicationContext context) {
  2. 		this.handlerMappings = null;
  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. 		}
  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. 	}

以上即为HandlerMappings的读取过程。

MVC处理HTTP分发请求

1。HandlerMapping的配置和设计原理    

    在初始化完毕时。在上下文环境中已经定义的全部HandlerMapping都已经被载入了，这些HandlerMapping被放入List并排序。存储着HTTP请求的相应映射数据。Spring提供了一系列HandlerMapping实现。SimpleUrlHandlerMapping为例。在SimpleUrlHandlerMapping中定义了一个Map持有一系列的映射关系，这些映射关系使SpringMVC能够相应到Controller中。

    这些映射关系通过HandlerMapping接口封装。通过getHandler获取相应的HandlerExcutionChain，在HandlerExcutionChain中封装详细的Controller。

    HandlerMapping接口的方法例如以下：

  1. HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;

此处是典型的命令模式。

    HandlerExecutionChain中持有一个Inteceptor链和一个handler对象。该handler实际就是Controller对象。


  1. public class HandlerExecutionChain {
  3. 	private static final Log logger = LogFactory.getLog(HandlerExecutionChain.class);
  5. 	private final Object handler;
  7. 	private HandlerInterceptor[] interceptors;
  9. 	private List<HandlerInterceptor> interceptorList;
  11. 	private int interceptorIndex = -1;

构造函数：

  1. /**
  2. 	 * Create a new HandlerExecutionChain.
  3. 	 * @param handler the handler object to execute
  4. 	 * @param interceptors the array of interceptors to apply
  5. 	 * (in the given order) before the handler itself executes
  6. 	 */
  7. 	public HandlerExecutionChain(Object handler, HandlerInterceptor[] interceptors) {
  8. 		if (handler instanceof HandlerExecutionChain) {
  9. 			HandlerExecutionChain originalChain = (HandlerExecutionChain) handler;
  10. 			this.handler = originalChain.getHandler();
  11. 			this.interceptorList = new ArrayList<HandlerInterceptor>();
  12. 			CollectionUtils.mergeArrayIntoCollection(originalChain.getInterceptors(), this.interceptorList);
  13. 			CollectionUtils.mergeArrayIntoCollection(interceptors, this.interceptorList);
  14. 		}
  15. 		else {
  16. 			this.handler = handler;
  17. 			this.interceptors = interceptors;
  18. 		}
  19. 	}

HandlerExecutionChain中定义的Handler和Interceptor须要在定义HandlerMapping的时候配置好。

    以SimpleUrlHandlerMapping为例。

在初始化时。会调用。

  1. /**
  2. 	 * Calls the {@link #registerHandlers} method in addition to the
  3. 	 * superclass's initialization.
  4. 	 */
  5. 	@Override
  6. 	public void initApplicationContext() throws BeansException {
  7. 		super.initApplicationContext();
  8. 		registerHandlers(this.urlMap);
  9. 	}
  11. 	/**
  12. 	 * Register all handlers specified in the URL map for the corresponding paths.
  13. 	 * @param urlMap Map with URL paths as keys and handler beans or bean names as values
  14. 	 * @throws BeansException if a handler couldn't be registered
  15. 	 * @throws IllegalStateException if there is a conflicting handler registered
  16. 	 */
  17. 	protected void registerHandlers(Map<String, Object> urlMap) throws BeansException {
  18. 		if (urlMap.isEmpty()) {
  19. 			logger.warn("Neither 'urlMap' nor 'mappings' set on SimpleUrlHandlerMapping");
  20. 		}
  21. 		else {
  22. 			for (Map.Entry<String, Object> entry : urlMap.entrySet()) {
  23. 				String url = entry.getKey();
  24. 				Object handler = entry.getValue();
  25. 				// Prepend with slash if not already present.
  26. 				if (!url.startsWith("/")) {
  27. 					url = "/" + url;
  28. 				}
  29. 				// Remove whitespace from handler bean name.
  30. 				if (handler instanceof String) {
  31. 					handler = ((String) handler).trim();
  32. 				}
  33. 				registerHandler(url, handler);
  34. 			}
  35. 		}
  36. 	}

部分发放基于其父类，AbstractUrlhandlerMapping。

  1. /**
  2. 	 * Register the specified handler for the given URL path.
  3. 	 * @param urlPath the URL the bean should be mapped to
  4. 	 * @param handler the handler instance or handler bean name String
  5. 	 * (a bean name will automatically be resolved into the corresponding handler bean)
  6. 	 * @throws BeansException if the handler couldn't be registered
  7. 	 * @throws IllegalStateException if there is a conflicting handler registered
  8. 	 */
  9. 	protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {
  10. 		Assert.notNull(urlPath, "URL path must not be null");
  11. 		Assert.notNull(handler, "Handler object must not be null");
  12. 		Object resolvedHandler = handler;
  14. 		// Eagerly resolve handler if referencing singleton via name.
  15. 		if (!this.lazyInitHandlers && handler instanceof String) {
  16. 			String handlerName = (String) handler;
  17. 			if (getApplicationContext().isSingleton(handlerName)) {
  18. 				resolvedHandler = getApplicationContext().getBean(handlerName);
  19. 			}
  20. 		}
  22. 		Object mappedHandler = this.handlerMap.get(urlPath);
  23. 		if (mappedHandler != null) {
  24. 			if (mappedHandler != resolvedHandler) {
  25. 				throw new IllegalStateException(
  26. 						"Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
  27. 						"]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
  28. 			}
  29. 		}
  30. 		else {
  31. 			if (urlPath.equals("/")) {
  32. if (logger.isInfoEnabled()) {
  33. 					logger.info("Root mapping to " + getHandlerDescription(handler));
  34. 				}
  35. 				setRootHandler(resolvedHandler);
  36. 			}
  37. 			else if (urlPath.equals("/*")) {
  38. 				if (logger.isInfoEnabled()) {
  39. 					logger.info("Default mapping to " + getHandlerDescription(handler));
  40. 				}
  41. 				setDefaultHandler(resolvedHandler);
  42. 			}
  43. 			else {
  44. 				this.handlerMap.put(urlPath, resolvedHandler);
  45. 				if (logger.isInfoEnabled()) {
  46. 					logger.info("Mapped URL path [" + urlPath + "] onto " + getHandlerDescription(handler));
  47. 				}
  48. 			}
  49. 		}
  50. 	}

hadnlerMap保存了URL和controller的映射关系。

  1. private final Map<String, Object> handlerMap = new LinkedHashMap<String, Object>();

2，使用HandlerMapping完毕请求的处理。

    在HandlerExecutionChain的启动过程中，调用了getHandler方法，该方法就是完毕请求映射处理的地方。AbstractHadnlerMapping的getHandler方法例如以下：

  1. /**
  2. 	 * Look up a handler for the given request, falling back to the default
  3. 	 * handler if no specific one is found.
  4. 	 * @param request current HTTP request
  5. 	 * @return the corresponding handler instance, or the default handler
  6. 	 * @see #getHandlerInternal
  7. 	 */
  8. 	@Override
  9. 	public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
  10. 		Object handler = getHandlerInternal(request);
  11. 		if (handler == null) {
  12. 			handler = getDefaultHandler();
  13. 		}
  14. 		if (handler == null) {
  15. 			return null;
  16. 		}
  17. 		// Bean name or resolved handler?
  18. 		if (handler instanceof String) {
  19. 			String handlerName = (String) handler;
  20. 			handler = getApplicationContext().getBean(handlerName);
  21. 		}
  22. 		return getHandlerExecutionChain(handler, request);
  23. 	}
  1. /**
  2. 	 * Build a {@link HandlerExecutionChain} for the given handler, including
  3. 	 * applicable interceptors.
  4. 	 * <p>The default implementation builds a standard {@link HandlerExecutionChain}
  5. 	 * with the given handler, the handler mapping's common interceptors, and any
  6. 	 * {@link MappedInterceptor}s matching to the current request URL. Subclasses
  7. 	 * may override this in order to extend/rearrange the list of interceptors.
  8. 	 * <p><b>NOTE:</b> The passed-in handler object may be a raw handler or a
  9. 	 * pre-built {@link HandlerExecutionChain}. This method should handle those
  10. 	 * two cases explicitly, either building a new {@link HandlerExecutionChain}
  11. 	 * or extending the existing chain.
  12. 	 * <p>For simply adding an interceptor in a custom subclass, consider calling
  13. 	 * {@code super.getHandlerExecutionChain(handler, request)} and invoking
  14. 	 * {@link HandlerExecutionChain#addInterceptor} on the returned chain object.
  15. 	 * @param handler the resolved handler instance (never {@code null})
  16. 	 * @param request current HTTP request
  17. 	 * @return the HandlerExecutionChain (never {@code null})
  18. 	 * @see #getAdaptedInterceptors()
  19. 	 */
  20. 	protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
  21. 		HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
  22. 				(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
  23. 		chain.addInterceptors(getAdaptedInterceptors());
  25. 		String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
  26. 		for (MappedInterceptor mappedInterceptor : this.mappedInterceptors) {
  27. 			if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
  28. 				chain.addInterceptor(mappedInterceptor.getInterceptor());
  29. 			}
  30. 		}
  32. 		return chain;
  33. 	}


取得Handler的详细方法在getHandlerInternal()。该方法的详细实如今AbstractUrlHandlerMapping中：

  1. /**
  2. 	 * Look up a handler for the URL path of the given request.
  3. 	 * @param request current HTTP request
  4. 	 * @return the handler instance, or {@code null} if none found
  5. 	 */
  6. 	@Override
  7. 	protected Object getHandlerInternal(HttpServletRequest request) throws Exception {

  8. //从request获取请求路径

  9. 		String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);

  10. //请求路径与Handler匹配

  11. 		Object handler = lookupHandler(lookupPath, request);
  12. 		if (handler == null) {
  13. 			// We need to care for the default handler directly, since we need to
  14. 			// expose the PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE for it as well.
  15. 			Object rawHandler = null;
  16. 			if ("/".equals(lookupPath)) {
  17. 				rawHandler = getRootHandler();
  18. 			}
  19. 			if (rawHandler == null) {
  20. 				rawHandler = getDefaultHandler();
  21. 			}
  22. 			if (rawHandler != null) {
  23. 				// Bean name or resolved handler?
  24. 				if (rawHandler instanceof String) {
  25. 					String handlerName = (String) rawHandler;
  26. 					rawHandler = getApplicationContext().getBean(handlerName);
  27. 				}
  28. 				validateHandler(rawHandler, request);
  29. 				handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
  30. 			}
  31. 		}
  32. 		if (handler != null && logger.isDebugEnabled()) {
  33. 			logger.debug("Mapping [" + lookupPath + "] to " + handler);
  34. 		}
  35. 		else if (handler == null && logger.isTraceEnabled()) {
  36. 			logger.trace("No handler mapping found for [" + lookupPath + "]");
  37. 		}
  38. 		return handler;
  39. 	}



  1. /**
  2. 	 * Look up a handler instance for the given URL path.
  3. 	 * <p>Supports direct matches, e.g. a registered "/test" matches "/test",
  4. 	 * and various Ant-style pattern matches, e.g. a registered "/t*" matches
  5. 	 * both "/test" and "/team". For details, see the AntPathMatcher class.
  6. 	 * <p>Looks for the most exact pattern, where most exact is defined as
  7. 	 * the longest path pattern.
  8. 	 * @param urlPath URL the bean is mapped to
  9. 	 * @param request current HTTP request (to expose the path within the mapping to)
  10. 	 * @return the associated handler instance, or {@code null} if not found
  11. 	 * @see #exposePathWithinMapping
  12. 	 * @see org.springframework.util.AntPathMatcher
  13. 	 */
  14. 	protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
  15. 		// Direct match?
  16. 		Object handler = this.handlerMap.get(urlPath);
  17. 		if (handler != null) {
  18. 			// Bean name or resolved handler?
  19. 			if (handler instanceof String) {
  20. 				String handlerName = (String) handler;
  21. 				handler = getApplicationContext().getBean(handlerName);
  22. 			}
  23. 			validateHandler(handler, request);
  24. 			return buildPathExposingHandler(handler, urlPath, urlPath, null);
  25. 		}
  26. 		// Pattern match?
  27. 		List<String> matchingPatterns = new ArrayList<String>();
  28. 		for (String registeredPattern : this.handlerMap.keySet()) {
  29. 			if (getPathMatcher().match(registeredPattern, urlPath)) {
  30. 				matchingPatterns.add(registeredPattern);
  31. 			}
  32. 		}
  33. 		String bestPatternMatch = null;
  34. 		Comparator<String> patternComparator = getPathMatcher().getPatternComparator(urlPath);
  35. 		if (!matchingPatterns.isEmpty()) {
  36. 			Collections.sort(matchingPatterns, patternComparator);
  37. 			if (logger.isDebugEnabled()) {
  38. 				logger.debug("Matching patterns for request [" + urlPath + "] are " + matchingPatterns);
  39. 			}
  40. 			bestPatternMatch = matchingPatterns.get(0);
  41. 		}
  42. 		if (bestPatternMatch != null) {
  43. 			handler = this.handlerMap.get(bestPatternMatch);
  44. 			// Bean name or resolved handler?
  45. 			if (handler instanceof String) {
  46. 				String handlerName = (String) handler;
  47. 				handler = getApplicationContext().getBean(handlerName);
  48. 			}
  49. 			validateHandler(handler, request);
  50. 			String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestPatternMatch, urlPath);
  52. 			// There might be multiple 'best patterns', let's make sure we have the correct URI template variables
  53. 			// for all of them
  54. 			Map<String, String> uriTemplateVariables = new LinkedHashMap<String, String>();
  55. 			for (String matchingPattern : matchingPatterns) {
  56. 				if (patternComparator.compare(bestPatternMatch, matchingPattern) == 0) {
  57. 					Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(matchingPattern, urlPath);
  58. 					Map<String, String> decodedVars = getUrlPathHelper().decodePathVariables(request, vars);
  59. 					uriTemplateVariables.putAll(decodedVars);
  60. 				}
  61. 			}
  62. 			if (logger.isDebugEnabled()) {
  63. 				logger.debug("URI Template variables for request [" + urlPath + "] are " + uriTemplateVariables);
  64. 			}
  65. 			return buildPathExposingHandler(handler, bestPatternMatch, pathWithinMapping, uriTemplateVariables);
  66. 		}
  67. 		// No handler found...
  68. 		return null;
  69. 	}

经过一系列对HTTP请求进行解析和匹配handler的过程，得到了与请求对一个的handler处理器。在返回的handler中。已经完毕了在HandlerExecutionChain中的封装工作，为handler对HTTP请求的响应做好了准备。


3，Spring对HTTP请求的分发处理。

    DispatcherServlet是Servlet的子类，通过doService来响应HTTP请求。


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

doDispatch方法：

  1. /**
  2. 	 * Process the actual dispatching to the handler.
  3. 	 * <p>The handler will be obtained by applying the servlet's HandlerMappings in order.
  4. 	 * The HandlerAdapter will be obtained by querying the servlet's installed HandlerAdapters
  5. 	 * to find the first that supports the handler class.
  6. 	 * <p>All HTTP methods are handled by this method. It's up to HandlerAdapters or handlers
  7. 	 * themselves to decide which methods are acceptable.
  8. 	 * @param request current HTTP request
  9. 	 * @param response current HTTP response
  10. 	 * @throws Exception in case of any kind of processing failure
  11. 	 */
  12. 	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
  13. 		HttpServletRequest processedRequest = request;
  14. 		HandlerExecutionChain mappedHandler = null;
  15. 		boolean multipartRequestParsed = false;
  17. 		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
  19. 		try {
  20. 			ModelAndView mv = null;
  21. 			Exception dispatchException = null;
  23. 			try {
  24. 				processedRequest = checkMultipart(request);
  25. 				multipartRequestParsed = (processedRequest != request);
  27. 				// Determine handler for the current request.
  28. 				mappedHandler = getHandler(processedRequest);
  29. 				if (mappedHandler == null || mappedHandler.getHandler() == null) {
  30. 					noHandlerFound(processedRequest, response);
  31. 					return;
  32. 				}
  34. 				// Determine handler adapter for the current request.
  35. 				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
  37. 				// Process last-modified header, if supported by the handler.
  38. 				String method = request.getMethod();
  39. 				boolean isGet = "GET".equals(method);
  40. 				if (isGet || "HEAD".equals(method)) {
  41. 					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
  42. 					if (logger.isDebugEnabled()) {
  43. 						logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
  44. 					}
  45. 					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
  46. 						return;
  47. 					}
  48. 				}
  50. 				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
  51. 					return;
  52. 				}
  54. 				try {
  55. 					// Actually invoke the handler.
  56. 					mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
  57. 				}
  58. 				finally {
  59. 					if (asyncManager.isConcurrentHandlingStarted()) {
  60. 						return;
  61. 					}
  62. 				}
  64. 				applyDefaultViewName(request, mv);
  65. 				mappedHandler.applyPostHandle(processedRequest, response, mv);
  66. 			}
  67. 			catch (Exception ex) {
  68. 				dispatchException = ex;
  69. 			}
  70. 			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
  71. 		}
  72. 		catch (Exception ex) {
  73. 			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
  74. 		}
  75. 		catch (Error err) {
  76. 			triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);
  77. 		}
  78. 		finally {
  79. 			if (asyncManager.isConcurrentHandlingStarted()) {
  80. 				// Instead of postHandle and afterCompletion
  81. 				mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
  82. 				return;
  83. 			}
  84. 			// Clean up any resources used by a multipart request.
  85. 			if (multipartRequestParsed) {
  86. 				cleanupMultipart(processedRequest);
  87. 			}
  88. 		}
  89. 	}
  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. 	}

  1. 	protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
  2. 		for (HandlerAdapter ha : this.handlerAdapters) {
  3. 			if (logger.isTraceEnabled()) {
  4. 				logger.trace("Testing handler adapter [" + ha + "]");
  5. 			}
  6. 			if (ha.supports(handler)) {
  7. 				return ha;
  8. 			}
  9. 		}
  10. 		throw new ServletException("No adapter for handler [" + handler +
  11. 				"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
  12. 	}

HandlerAdapter的基本实现。SimpleControllerHandlerAddapter。
  1. public class SimpleControllerHandlerAdapter implements HandlerAdapter {
  3. 	@Override
  4. 	public boolean supports(Object handler) {
  5. 		return (handler instanceof Controller);
  6. 	}
  8. 	@Override
  9. 	public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
  10. 			throws Exception {
  12. 		return ((Controller) handler).handleRequest(request, response);
  13. 	}
  15. 	@Override
  16. 	public long getLastModified(HttpServletRequest request, Object handler) {
  17. 		if (handler instanceof LastModified) {
  18. 			return ((LastModified) handler).getLastModified(request);
  19. 		}
  20. 		return -1L;
  21. 	}
  23. }

经过上面的处理。获取到Controller对象，開始调用Handler对象的HTTP响应动作。

运行完获取到视图，并将视图返回。

Spring MVC视图的呈现


1，DispatcherServlet视图呈现设计

    在DIspatchServlet的doDispatch()方法中，获取到视图后调用了processDispatchResult()方法处理结果。视图的处理採用render方法。

  1. /**
  2. 	 * Render the given ModelAndView.
  3. 	 * <p>This is the last stage in handling a request. It may involve resolving the view by name.
  4. 	 * @param mv the ModelAndView to render
  5. 	 * @param request current HTTP servlet request
  6. 	 * @param response current HTTP servlet response
  7. 	 * @throws ServletException if view is missing or cannot be resolved
  8. 	 * @throws Exception if there's a problem rendering the view
  9. 	 */
  10. 	protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
  11. 		// Determine locale for request and apply it to the response.
  12. 		Locale locale = this.localeResolver.resolveLocale(request);
  13. 		response.setLocale(locale);
  15. 		View view;
  16. 		if (mv.isReference()) {
  17. 			// We need to resolve the view name.
  18. 			view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);
  19. 			if (view == null) {
  20. 				throw new ServletException("Could not resolve view with name '" + mv.getViewName() +
  21. 						"' in servlet with name '" + getServletName() + "'");
  22. 			}
  23. 		}
  24. 		else {
  25. 			// No need to lookup: the ModelAndView object contains the actual View object.
  26. 			view = mv.getView();
  27. 			if (view == null) {
  28. 				throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
  29. 						"View object in servlet with name '" + getServletName() + "'");
  30. 			}
  31. 		}
  33. 		// Delegate to the View object for rendering.
  34. 		if (logger.isDebugEnabled()) {
  35. 			logger.debug("Rendering view [" + view + "] in DispatcherServlet with name '" + getServletName() + "'");
  36. 		}
  37. 		try {
  38. 			view.render(mv.getModelInternal(), request, response);
  39. 		}
  40. 		catch (Exception ex) {
  41. 			if (logger.isDebugEnabled()) {
  42. 				logger.debug("Error rendering view [" + view + "] in DispatcherServlet with name '" +
  43. 						getServletName() + "'", ex);
  44. 			}
  45. 			throw ex;
  46. 		}
  47. 	}

resolveViewName通过对视图名称对象解析，获取视图。

  1. protected View resolveViewName(String viewName, Map<String, Object> model, Locale locale,
  2. 			HttpServletRequest request) throws Exception {
  4. 		for (ViewResolver viewResolver : this.viewResolvers) {
  5. 			View view = viewResolver.resolveViewName(viewName, locale);
  6. 			if (view != null) {
  7. 				return view;
  8. 			}
  9. 		}
  10. 		return null;
  11. 	}

ViewResolver的resolveViewName方法，BeanNameViewresolver是其经常使用实现。


  1. @Override
  2. 	public View resolveViewName(String viewName, Locale locale) throws BeansException {
  3. 		ApplicationContext context = getApplicationContext();
  4. 		if (!context.containsBean(viewName)) {
  5. 			// Allow for ViewResolver chaining.
  6. 			return null;
  7. 		}
  8. 		return context.getBean(viewName, View.class);
  9. 	}

Spring为了实现视图的灵活性，方便应用使用各种视图。在View接口下实现了不同View对象。各View对象依据其详细的使用，氛围不同的视图。

2，JSP视图的实现

    使用jsp作为视图，Sprinng採用JstlView来作为View对象，而其render方法继承自父类AbstractView。

  1. /**
  2. 	 * Prepares the view given the specified model, merging it with static
  3. 	 * attributes and a RequestContext attribute, if necessary.
  4. 	 * Delegates to renderMergedOutputModel for the actual rendering.
  5. 	 * @see #renderMergedOutputModel
  6. 	 */
  7. 	@Override
  8. 	public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
  9. 		if (logger.isTraceEnabled()) {
  10. 			logger.trace("Rendering view with name '" + this.beanName + "' with model " + model +
  11. 				" and static attributes " + this.staticAttributes);
  12. 		}
  14. 		Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
  15. 		prepareResponse(request, response);
  16. 		renderMergedOutputModel(mergedModel, request, response);
  17. 	}

createMergedOutputModel方法：

  2. 	/**
  3. 	 * Creates a combined output Map (never {@code null}) that includes dynamic values and static attributes.
  4. 	 * Dynamic values take precedence over static attributes.
  5. 	 */
  6. 	protected Map<String, Object> createMergedOutputModel(Map<String, ?> model, HttpServletRequest request,
  7. 			HttpServletResponse response) {
  9. 		@SuppressWarnings("unchecked")
  10. 		Map<String, Object> pathVars = (this.exposePathVariables ?
  11. 			(Map<String, Object>) request.getAttribute(View.PATH_VARIABLES) : null);
  13. 		// Consolidate static and dynamic model attributes.
  14. 		int size = this.staticAttributes.size();
  15. 		size += (model != null) ? model.size() : 0;
  16. 		size += (pathVars != null) ? pathVars.size() : 0;
  17. 		Map<String, Object> mergedModel = new LinkedHashMap<String, Object>(size);
  18. 		mergedModel.putAll(this.staticAttributes);
  19. 		if (pathVars != null) {
  20. 			mergedModel.putAll(pathVars);
  21. 		}
  22. 		if (model != null) {
  23. 			mergedModel.putAll(model);
  24. 		}
  26. 		// Expose RequestContext?
  27. 		if (this.requestContextAttribute != null) {
  28. 			mergedModel.put(this.requestContextAttribute, createRequestContext(request, response, mergedModel));
  29. 		}
  31. 		return mergedModel;
  32. 	}

renderMergedOutputModel，在InternalResourceView中完毕，InternalResourceView也属于JstlView的基类。

  1. /**
  2. 	 * Render the internal resource given the specified model.
  3. 	 * This includes setting the model as request attributes.
  4. 	 */
  5. 	@Override
  6. 	protected void renderMergedOutputModel(
  7. 			Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
  9. 		// Determine which request handle to expose to the RequestDispatcher.
  10. 		HttpServletRequest requestToExpose = getRequestToExpose(request);
  12. 		// Expose the model object as request attributes.
  13. 		exposeModelAsRequestAttributes(model, requestToExpose);
  15. 		// Expose helpers as request attributes, if any.
  16. 		exposeHelpers(requestToExpose);
  18. 		// Determine the path for the request dispatcher.
  19. 		String dispatcherPath = prepareForRendering(requestToExpose, response);
  21. 		// Obtain a RequestDispatcher for the target resource (typically a JSP).
  22. 		RequestDispatcher rd = getRequestDispatcher(requestToExpose, dispatcherPath);
  23. 		if (rd == null) {
  24. 			throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +
  25. 					"]: Check that the corresponding file exists within your web application archive!");
  26. 		}
  28. 		// If already included or response already committed, perform include, else forward.
  29. 		if (useInclude(requestToExpose, response)) {
  30. 			response.setContentType(getContentType());
  31. 			if (logger.isDebugEnabled()) {
  32. 				logger.debug("Including resource [" + getUrl() + "] in InternalResourceView '" + getBeanName() + "'");
  33. 			}
  34. 			rd.include(requestToExpose, response);
  35. 		}
  37. 		else {
  38. 			// Note: The forwarded resource is supposed to determine the content type itself.
  39. 			if (logger.isDebugEnabled()) {
  40. 				logger.debug("Forwarding to resource [" + getUrl() + "] in InternalResourceView '" + getBeanName() + "'");
  41. 			}
  42. 			rd.forward(requestToExpose, response);
  43. 		}
  44. 	}

AbstractView的exposeModelAsRequestAttributes()方法：

  1. /**
  2. 	 * Expose the model objects in the given map as request attributes.
  3. 	 * Names will be taken from the model Map.
  4. 	 * This method is suitable for all resources reachable by {@link javax.servlet.RequestDispatcher}.
  5. 	 * @param model Map of model objects to expose
  6. 	 * @param request current HTTP request
  7. 	 */
  8. 	protected void exposeModelAsRequestAttributes(Map<String, Object> model, HttpServletRequest request) throws Exception {
  9. 		for (Map.Entry<String, Object> entry : model.entrySet()) {
  10. 			String modelName = entry.getKey();
  11. 			Object modelValue = entry.getValue();
  12. 			if (modelValue != null) {
  13. 				request.setAttribute(modelName, modelValue);
  14. 				if (logger.isDebugEnabled()) {
  15. 					logger.debug("Added model object '" + modelName + "' of type [" + modelValue.getClass().getName() +
  16. 							"] to request in view with name '" + getBeanName() + "'");
  17. 				}
  18. 			}
  19. 			else {
  20. 				request.removeAttribute(modelName);
  21. 				if (logger.isDebugEnabled()) {
  22. 					logger.debug("Removed model object '" + modelName +
  23. 							"' from request in view with name '" + getBeanName() + "'");
  24. 				}
  25. 			}
  26. 		}
  27. 	}

  1. /**
  2. 	 * Prepare for rendering, and determine the request dispatcher path
  3. 	 * to forward to (or to include).
  4. 	 * <p>This implementation simply returns the configured URL.
  5. 	 * Subclasses can override this to determine a resource to render,
  6. 	 * typically interpreting the URL in a different manner.
  7. 	 * @param request current HTTP request
  8. 	 * @param response current HTTP response
  9. 	 * @return the request dispatcher path to use
  10. 	 * @throws Exception if preparations failed
  11. 	 * @see #getUrl()
  12. 	 */
  13. 	protected String prepareForRendering(HttpServletRequest request, HttpServletResponse response)
  14. 			throws Exception {
  16. 		String path = getUrl();
  17. 		if (this.preventDispatchLoop) {
  18. 			String uri = request.getRequestURI();
  19. 			if (path.startsWith("/") ?
     uri.equals(path) : uri.equals(StringUtils.applyRelativePath(uri, path))) {
  20. 				throw new ServletException("Circular view path [" + path + "]: would dispatch back " +
  21. 						"to the current handler URL [" + uri + "] again. Check your ViewResolver setup! " +
  22. 						"(Hint: This may be the result of an unspecified view, due to default view name generation.)");
  23. 			}
  24. 		}
  25. 		return path;
  26. 	}

视图的解析过程大概就例如以下代码。



总而言之。Spring MVC的建立有下面几个过程：

    -1。须要建立Controller和HTTP请求之间的映射关系。在HandlerMapping中封装HandlerExecutionChain对象完毕。而对Controller和HTTP请求关系的描写叙述是在Bean定义的描写叙述。并在IoC初始化时。通过初始化HandlerMapping来完毕，这些映射关系存储在handlerMap中。

    -2，在MVC接收请求的时候，DispatcherServlet会依据详细的URL请求信息。在HandlerMapping中查询，从而得到HandlerExecutionChain。在HandlerExecutionChain中封装了Controller，这个请求的COntroller会完毕请求对应，以及生成须要的ModelAndView对象。


    -3。得到ModelAndView对象后，DispatcherServlet将ModelAndView对象交给特定的视图对象。通过视图对象完毕数据呈现工作。


【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/claireyuancy/p/6927216.html