• springmvc 启动过程

    dispatcher-servlet.xml

    1. "1.0" encoding="UTF-8"?>
    2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
    5.          version="4.0">
    6.     <context-param>
    7.         <param-name>contextConfigLocationparam-name>
    8.         <param-value>/WEB-INF/applicationContext.xmlparam-value>
    9.     context-param>
    10.     <listener>
    11.         <listener-class> org.springframework.web.context.ContextLoaderListenerlistener-class>
    12.     listener>
    13.     <servlet>
    14.         <servlet-name>dispatcherservlet-name>
    15.         <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
    16.         <load-on-startup>1load-on-startup>
    17.     servlet>
    18.     <servlet-mapping>
    19.         <servlet-name>dispatcherservlet-name>
    20.         <url-pattern>/url-pattern>
    21.     servlet-mapping>
    22. web-app>

     

    ContextLoader.java
     

    /**
 * Name of the class path resource (relative to the ContextLoader class)
 * that defines ContextLoader's default strategy names.
 */
private static final String DEFAULT_STRATEGIES_PATH = "ContextLoader.properties";
     

    static {
   // Load default strategy implementations from properties file.
   // This is currently strictly internal and not meant to be customized
   // by application developers.
   try {
      ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, ContextLoader.class);
      defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
   }
   catch (IOException ex) {
      throw new IllegalStateException("Could not load 'ContextLoader.properties': " + ex.getMessage());
   }
}

     

     

    ContextLoader 加载ContextLoader.properties文件，内容如下
     

    org.springframework.web.context.WebApplicationContext=org.springframework.web.context.support.XmlWebApplicationContext
     

     

    通过继承关系可以看到
     

    ContextLoaderListener 继承了ServletContextListener 因此看contextInitialized()方法如何初始化initWebApplicationContext,而initWebApplicationContext()在ContextLoader里实现。
     

    ContextLoaderListener#contextInitialized()
     

    1. public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
    2.  
    3. 	public ContextLoaderListener() {
    4. 	}
    5.  
    6. 	public ContextLoaderListener(WebApplicationContext context) {
    7. 		super(context);
    8. 	}
    9.  
    10. 	/**
    11. 	 * Initialize the root web application context.
    12. 	 */
    13. 	@Override
    14. 	public void contextInitialized(ServletContextEvent event) {
    15. 		initWebApplicationContext(event.getServletContext());
    16. 	}
    17.  
    18. }
     

     

     

    ContextLoader#initWebApplicationContext();
     

    1. ContextLoader.java
    2.  
    3. /**
    4. 	 * The root WebApplicationContext instance that this loader manages.
    5. 	 */
    6. 	@Nullable
    7. 	private WebApplicationContext context;
    8.  
    9.  
    10.  
    11. /**
    12. 	 * Initialize Spring's web application context for the given servlet context,
    13. 	 * using the application context provided at construction time, or creating a new one
    14. 	 * according to the "{@link #CONTEXT_CLASS_PARAM contextClass}" and
    15. 	 * "{@link #CONFIG_LOCATION_PARAM contextConfigLocation}" context-params.
    16. 	 * @param servletContext current servlet context
    17. 	 * @return the new WebApplicationContext
    18. 	 * @see #ContextLoader(WebApplicationContext)
    19. 	 * @see #CONTEXT_CLASS_PARAM
    20. 	 * @see #CONFIG_LOCATION_PARAM
    21. 	 */
    22. public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
    23. 		if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
    24. 			throw new IllegalStateException(
    25. 					"Cannot initialize context because there is already a root application context present - " +
    26. 					"check whether you have multiple ContextLoader* definitions in your web.xml!");
    27. 		}
    28.  
    29. 		servletContext.log("Initializing Spring root WebApplicationContext");
    30. 		Log logger = LogFactory.getLog(ContextLoader.class);
    31. 		if (logger.isInfoEnabled()) {
    32. 			logger.info("Root WebApplicationContext: initialization started");
    33. 		}
    34. 		long startTime = System.currentTimeMillis();
    35.  
    36. 		try {
    37. 			// Store context in local instance variable, to guarantee that
    38. 			// it is available on ServletContext shutdown.
    39. 			if (this.context == null) {
    40. //根据配置文件实例化xmlwebApplicationContext
    41. 				this.context = createWebApplicationContext(servletContext);
    42. 			}
    43. 			if (this.context instanceof ConfigurableWebApplicationContext) {
    44. 				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
    45. 				if (!cwac.isActive()) {
    46. 					// The context has not yet been refreshed -> provide services such as
    47. 					// setting the parent context, setting the application context id, etc
    48. 					if (cwac.getParent() == null) {
    49. 						// The context instance was injected without an explicit parent ->
    50. 						// determine parent for root web application context, if any.
    51. 						ApplicationContext parent = loadParentContext(servletContext);
    52. 						cwac.setParent(parent);
    53. 					}
    54. //调用spring ioc容器完成初始化
    55. 					configureAndRefreshWebApplicationContext(cwac, servletContext);
    56. 				}
    57. 			}
    58. 			// 将上下文放在servletContext中
    59. servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
    60.  
    61. 			ClassLoader ccl = Thread.currentThread().getContextClassLoader();
    62. 			if (ccl == ContextLoader.class.getClassLoader()) {
    63. 				currentContext = this.context;
    64. 			}
    65. 			else if (ccl != null) {
    66. 				currentContextPerThread.put(ccl, this.context);
    67. 			}
    68.  
    69. 			if (logger.isInfoEnabled()) {
    70. 				long elapsedTime = System.currentTimeMillis() - startTime;
    71. 				logger.info("Root WebApplicationContext initialized in " + elapsedTime + " ms");
    72. 			}
    73.  
    74. 			return this.context;
    75. 		}
    76. 		catch (RuntimeException | Error ex) {
    77. 			logger.error("Context initialization failed", ex);
    78. 			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
    79. 			throw ex;
    80. 		}
    81. 	}
     


        执行完上述后，由
     

    Tomcat服务器继续执行后续代码过滤器filterStart、然后执行配置文件的 DispatcherServlet
     

    1. StandardContext.java
    2.  
    3.  
    4.  /**
    5.      * Start this component and implement the requirements
    6.      * of {@link org.apache.catalina.util.LifecycleBase#startInternal()}.
    7.      *
    8.      * @exception LifecycleException if this component detects a fatal error
    9.      *  that prevents this component from being used
    10.      */
    11.     @Override
    12.     protected synchronized void startInternal() throws LifecycleException {
    13.  
    14. ......
    15.  
    16. // Configure and call application event listeners
    17.             if (ok) {
    18. //执行listener
    19.                 if (!listenerStart()) {
    20.                     log.error(sm.getString("standardContext.listenerFail"));
    21.                     ok = false;
    22.                 }
    23.             }
    24.  
    25.             // Check constraints for uncovered HTTP methods
    26.             // Needs to be after SCIs and listeners as they may programmatically
    27.             // change constraints
    28.             if (ok) {
    29.                 checkConstraintsForUncoveredMethods(findConstraints());
    30.             }
    31.  
    32.             try {
    33.                 // Start manager
    34.                 Manager manager = getManager();
    35.                 if ((manager != null) && (manager instanceof Lifecycle)) {
    36.                     ((Lifecycle) manager).start();
    37.                 }
    38.             } catch(Exception e) {
    39.                 log.error(sm.getString("standardContext.managerFail"), e);
    40.                 ok = false;
    41.             }
    42.  
    43.             // Configure and call application filters
    44.             if (ok) {
    45. //执行filter
    46.                 if (!filterStart()) {
    47.                     log.error(sm.getString("standardContext.filterFail"));
    48.                     ok = false;
    49.                 }
    50.             }
    51.  
    52.             // Load and initialize all "load on startup" servlets
    53. //执行servlet
    54.             if (ok) {
    55.                 if (!loadOnStartup(findChildren())){
    56.                     log.error(sm.getString("standardContext.servletFail"));
    57.                     ok = false;
    58.                 }
    59.             }
    60.  
    61. ......
    62.  
    63.    }
     

     

    执行类StandardWarpper# private synchronized void initServlet(Servlet servlet)
     

    1. private synchronized void initServlet(Servlet servlet)
    2.             throws ServletException {
    3.  
    4.         if (instanceInitialized && !singleThreadModel) return;
    5.  
    6.         // Call the initialization method of this servlet
    7.         try {
    8.             instanceSupport.fireInstanceEvent(InstanceEvent.BEFORE_INIT_EVENT,
    9.                                               servlet);
    10.  
    11.             if( Globals.IS_SECURITY_ENABLED) {
    12.                 boolean success = false;
    13.                 try {
    14.                     Object[] args = new Object[] { facade };
    15.                     SecurityUtil.doAsPrivilege("init",
    16.                                                servlet,
    17.                                                classType,
    18.                                                args);
    19.                     success = true;
    20.                 } finally {
    21.                     if (!success) {
    22.                         // destroy() will not be called, thus clear the reference now
    23.                         SecurityUtil.remove(servlet);
    24.                     }
    25.                 }
    26.             } else {
    27.                //调用servlet.init();
    28.                 servlet.init(facade);
    29.             }
    30.  
    31.             instanceInitialized = true;
    32.  
    33.             instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
    34.                                               servlet);
    35.         } catch (UnavailableException f) {
    36.             instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
    37.                                               servlet, f);
    38.             unavailable(f);
    39.             throw f;
    40.         } catch (ServletException f) {
    41.             instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
    42.                                               servlet, f);
    43.             // If the servlet wanted to be unavailable it would have
    44.             // said so, so do not call unavailable(null).
    45.             throw f;
    46.         } catch (Throwable f) {
    47.             ExceptionUtils.handleThrowable(f);
    48.             getServletContext().log("StandardWrapper.Throwable", f );
    49.             instanceSupport.fireInstanceEvent(InstanceEvent.AFTER_INIT_EVENT,
    50.                                               servlet, f);
    51.             // If the servlet wanted to be unavailable it would have
    52.             // said so, so do not call unavailable(null).
    53.             throw new ServletException
    54.                 (sm.getString("standardWrapper.initException", getName()), f);
    55.         }
    56.     }
     


     由继承图可以看到，GenericServlet的init()方法由HttpServletBean的init()实现。
     

     

    1. GenericServlet.java
    2.  
    3.  /**
    4.      * Called by the servlet container to indicate to a servlet that the servlet
    5.      * is being placed into service. See {@link Servlet#init}.
    6.      * 
    7.      * This implementation stores the {@link ServletConfig} object it receives
    8.      * from the servlet container for later use. When overriding this form of
    9.      * the method, call super.init(config).
    10.      *
    11.      * @param config
    12.      *            the ServletConfig object that contains
    13.      *            configuration information for this servlet
    14.      * @exception ServletException
    15.      *                if an exception occurs that interrupts the servlet's
    16.      *                normal operation
    17.      * @see UnavailableException
    18.      */
    19.     @Override
    20.     public void init(ServletConfig config) throws ServletException {
    21.         this.config = config;
    22.         this.init();
    23.     }
    24.  
    25.  
    26. /**
    27.      * A convenience method which can be overridden so that there's no need to
    28.      * call super.init(config).
    29.      * 
    30.      * Instead of overriding {@link #init(ServletConfig)}, simply override this
    31.      * method and it will be called by
    32.      * GenericServlet.init(ServletConfig config). The
    33.      * ServletConfig object can still be retrieved via
    34.      * {@link #getServletConfig}.
    35.      *
    36.      * @exception ServletException
    37.      *                if an exception occurs that interrupts the servlet's
    38.      *                normal operation
    39.      */
    40.     public void init() throws ServletException {
    41.         // NOOP by default
    42.     }
     

    而GenericServlet其自身this.init()方法是空的，需要子类HttpServletBean实现init()
     

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

    FrameworkServlet#initServletBean()
     

    1. FrameworkServlet.java
    2. /**
    3. 	 * Overridden method of {@link HttpServletBean}, invoked after any bean properties
    4. 	 * have been set. Creates this servlet's WebApplicationContext.
    5. 	 */
    6. 	@Override
    7. 	protected final void initServletBean() throws ServletException {
    8. 		getServletContext().log("Initializing Spring " + getClass().getSimpleName() + " '" + getServletName() + "'");
    9. 		if (logger.isInfoEnabled()) {
    10. 			logger.info("Initializing Servlet '" + getServletName() + "'");
    11. 		}
    12. 		long startTime = System.currentTimeMillis();
    13.  
    14. 		try {
    15.   //创建webApplicationContext,默认由XmlWebApplicationContext实现
    16. 			this.webApplicationContext = initWebApplicationContext();
    17.             //空实现
    18. 			initFrameworkServlet();
    19. 		}
    20. 		catch (ServletException | RuntimeException ex) {
    21. 			logger.error("Context initialization failed", ex);
    22. 			throw ex;
    23. 		}
    24.  
    25. 		if (logger.isDebugEnabled()) {
    26. 			String value = this.enableLoggingRequestDetails ?
    27. 					"shown which may lead to unsafe logging of potentially sensitive data" :
    28. 					"masked to prevent unsafe logging of potentially sensitive data";
    29. 			logger.debug("enableLoggingRequestDetails='" + this.enableLoggingRequestDetails +
    30. 					"': request parameters and headers will be " + value);
    31. 		}
    32.  
    33. 		if (logger.isInfoEnabled()) {
    34. 			logger.info("Completed initialization in " + (System.currentTimeMillis() - startTime) + " ms");
    35. 		}
    36. 	}
     

    initWebApplicationContext()方法由ContextLoader.java实现。
     

    1. ContextLoader.java
    2.  
    3. /**
    4. 	 * Initialize Spring's web application context for the given servlet context,
    5. 	 * using the application context provided at construction time, or creating a new one
    6. 	 * according to the "{@link #CONTEXT_CLASS_PARAM contextClass}" and
    7. 	 * "{@link #CONFIG_LOCATION_PARAM contextConfigLocation}" context-params.
    8. 	 * @param servletContext current servlet context
    9. 	 * @return the new WebApplicationContext
    10. 	 * @see #ContextLoader(WebApplicationContext)
    11. 	 * @see #CONTEXT_CLASS_PARAM
    12. 	 * @see #CONFIG_LOCATION_PARAM
    13. 	 */
    14. 	public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
    15. 		if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
    16. 			throw new IllegalStateException(
    17. 					"Cannot initialize context because there is already a root application context present - " +
    18. 					"check whether you have multiple ContextLoader* definitions in your web.xml!");
    19. 		}
    20.  
    21. 		servletContext.log("Initializing Spring root WebApplicationContext");
    22. 		Log logger = LogFactory.getLog(ContextLoader.class);
    23. 		if (logger.isInfoEnabled()) {
    24. 			logger.info("Root WebApplicationContext: initialization started");
    25. 		}
    26. 		long startTime = System.currentTimeMillis();
    27.  
    28. 		try {
    29. 			// Store context in local instance variable, to guarantee that
    30. 			// it is available on ServletContext shutdown.
    31. 			if (this.context == null) {
    32. 				this.context = createWebApplicationContext(servletContext);
    33. 			}
    34. 			if (this.context instanceof ConfigurableWebApplicationContext) {
    35. 				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
    36. 				if (!cwac.isActive()) {
    37. 					// The context has not yet been refreshed -> provide services such as
    38. 					// setting the parent context, setting the application context id, etc
    39. 					if (cwac.getParent() == null) {
    40. 						// The context instance was injected without an explicit parent ->
    41. 						// determine parent for root web application context, if any.
    42. 						ApplicationContext parent = loadParentContext(servletContext);
    43. 						cwac.setParent(parent);
    44. 					}
    45. 					configureAndRefreshWebApplicationContext(cwac, servletContext);
    46. 				}
    47. 			}
    48. 			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
    49.  
    50. 			ClassLoader ccl = Thread.currentThread().getContextClassLoader();
    51. 			if (ccl == ContextLoader.class.getClassLoader()) {
    52. 				currentContext = this.context;
    53. 			}
    54. 			else if (ccl != null) {
    55. 				currentContextPerThread.put(ccl, this.context);
    56. 			}
    57.  
    58. 			if (logger.isInfoEnabled()) {
    59. 				long elapsedTime = System.currentTimeMillis() - startTime;
    60. 				logger.info("Root WebApplicationContext initialized in " + elapsedTime + " ms");
    61. 			}
    62.  
    63. 			return this.context;
    64. 		}
    65. 		catch (RuntimeException | Error ex) {
    66. 			logger.error("Context initialization failed", ex);
    67. 			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
    68. 			throw ex;
    69. 		}
    70. 	}
     

    this.context = createWebApplicationContext(servletContext);

     

    1. /**
    2. 	 * Instantiate the root WebApplicationContext for this loader, either the
    3. 	 * default context class or a custom context class if specified.
    4. 	 * 
      This implementation expects custom contexts to implement the
    5. 	 * {@link ConfigurableWebApplicationContext} interface.
    6. 	 * Can be overridden in subclasses.
    7. 	 * 
      In addition, {@link #customizeContext} gets called prior to refreshing the
    8. 	 * context, allowing subclasses to perform custom modifications to the context.
    9. 	 * @param sc current servlet context
    10. 	 * @return the root WebApplicationContext
    11. 	 * @see ConfigurableWebApplicationContext
    12. 	 */
    13. 	protected WebApplicationContext createWebApplicationContext(ServletContext sc) {
    14. 		Class contextClass = determineContextClass(sc);
    15. 		if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
    16. 			throw new ApplicationContextException("Custom context class [" + contextClass.getName() +
    17. 					"] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");
    18. 		}
    19.      //实例化
    20. 		return (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
    21. 	}
     


       configureAndRefreshWebApplicationContext(wac);
     

    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. 		}
    15.  
    16. 		wac.setServletContext(sc);
    17. 		String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
    18. 		if (configLocationParam != null) {
    19. 			wac.setConfigLocation(configLocationParam);
    20. 		}
    21.  
    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. 		}
    29.  
    30. 		customizeContext(sc, wac);
    31. //调用AbstractApplicationContext  refresh()方法
    32. 		wac.refresh();
    33. 	}
     

     

    AbstractApplicationContext#refresh()
     

    1. @Override
    2. 	public void refresh() throws BeansException, IllegalStateException {
    3. 		synchronized (this.startupShutdownMonitor) {
    4. 			// Prepare this context for refreshing.
    5. 			prepareRefresh();
    6.  
    7. 			// Tell the subclass to refresh the internal bean factory.
    8. 			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    9.  
    10. 			// Prepare the bean factory for use in this context.
    11. 			prepareBeanFactory(beanFactory);
    12.  
    13. 			try {
    14. 				// Allows post-processing of the bean factory in context subclasses.
    15. 				postProcessBeanFactory(beanFactory);
    16.  
    17. 				// Invoke factory processors registered as beans in the context.
    18. 				invokeBeanFactoryPostProcessors(beanFactory);
    19.  
    20. 				// Register bean processors that intercept bean creation.
    21. 				registerBeanPostProcessors(beanFactory);
    22.  
    23. 				// Initialize message source for this context.
    24. 				initMessageSource();
    25.  
    26. 				// Initialize event multicaster for this context.
    27. 				initApplicationEventMulticaster();
    28.  
    29. 				// Initialize other special beans in specific context subclasses.
    30. 				onRefresh();
    31.  
    32. 				// Check for listener beans and register them.
    33. 				registerListeners();
    34.  
    35. 				// Instantiate all remaining (non-lazy-init) singletons.
    36. 				finishBeanFactoryInitialization(beanFactory);
    37.  
    38. 				// Last step: publish corresponding event.
    39. 				finishRefresh();
    40. 			}
    41.  
    42. 			catch (BeansException ex) {
    43. 				if (logger.isWarnEnabled()) {
    44. 					logger.warn("Exception encountered during context initialization - " +
    45. 							"cancelling refresh attempt: " + ex);
    46. 				}
    47.  
    48. 				// Destroy already created singletons to avoid dangling resources.
    49. 				destroyBeans();
    50.  
    51. 				// Reset 'active' flag.
    52. 				cancelRefresh(ex);
    53.  
    54. 				// Propagate exception to caller.
    55. 				throw ex;
    56. 			}
    57.  
    58. 			finally {
    59. 				// Reset common introspection caches in Spring's core, since we
    60. 				// might not ever need metadata for singleton beans anymore...
    61. 				resetCommonCaches();
    62. 			}
    63. 		}
    64. 	}
     


             // Last step: publish corresponding event.
              finishRefresh();
         
     

    1. AbstractApplicationContext.java
    2.  
    3. /**
    4. 	 * Finish the refresh of this context, invoking the LifecycleProcessor's
    5. 	 * onRefresh() method and publishing the
    6. 	 * {@link org.springframework.context.event.ContextRefreshedEvent}.
    7. 	 */
    8. 	protected void finishRefresh() {
    9. 		// Clear context-level resource caches (such as ASM metadata from scanning).
    10. 		clearResourceCaches();
    11.  
    12. 		// Initialize lifecycle processor for this context.
    13. 		initLifecycleProcessor();
    14.  
    15. 		// Propagate refresh to lifecycle processor first.
    16. 		getLifecycleProcessor().onRefresh();
    17.  
    18. 		// Publish the final event.
    19. 		publishEvent(new ContextRefreshedEvent(this));
    20.  
    21. 		// Participate in LiveBeansView MBean, if active.
    22. 		LiveBeansView.registerApplicationContext(this);
    23. 	}
    24.  
    25. /**
    26. 	 * Publish the given event to all listeners.
    27. 	 * 
      Note: Listeners get initialized after the MessageSource, to be able
    28. 	 * to access it within listener implementations. Thus, MessageSource
    29. 	 * implementations cannot publish events.
    30. 	 * @param event the event to publish (may be application-specific or a
    31. 	 * standard framework event)
    32. 	 */
    33. 	@Override
    34. 	public void publishEvent(ApplicationEvent event) {
    35. 		publishEvent(event, null);
    36. 	}
    37.  
    38.  
    39. /**
    40. 	 * Publish the given event to all listeners.
    41. 	 * @param event the event to publish (may be an {@link ApplicationEvent}
    42. 	 * or a payload object to be turned into a {@link PayloadApplicationEvent})
    43. 	 * @param eventType the resolved event type, if known
    44. 	 * @since 4.2
    45. 	 */
    46. 	protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
    47. 		Assert.notNull(event, "Event must not be null");
    48.  
    49. 		// Decorate event as an ApplicationEvent if necessary
    50. 		ApplicationEvent applicationEvent;
    51. 		if (event instanceof ApplicationEvent) {
    52. 			applicationEvent = (ApplicationEvent) event;
    53. 		}
    54. 		else {
    55. 			applicationEvent = new PayloadApplicationEvent<>(this, event);
    56. 			if (eventType == null) {
    57. 				eventType = ((PayloadApplicationEvent) applicationEvent).getResolvableType();
    58. 			}
    59. 		}
    60.  
    61. 		// Multicast right now if possible - or lazily once the multicaster is initialized
    62. 		if (this.earlyApplicationEvents != null) {
    63. 			this.earlyApplicationEvents.add(applicationEvent);
    64. 		}
    65. 		else {
    66. 			getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
    67. 		}
    68.  
    69. 		// Publish event via parent context as well...
    70. 		if (this.parent != null) {
    71. 			if (this.parent instanceof AbstractApplicationContext) {
    72. 				((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
    73. 			}
    74. 			else {
    75. 				this.parent.publishEvent(event);
    76. 			}
    77. 		}
    78. 	}
     


    getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
     

    SimpleApplicationEventMulticaster.java
     

    1. SimpleApplicationEventMulticaster.java
    2.  
    3.  
    4. @Override
    5. 	public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
    6. 		ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
    7. 		Executor executor = getTaskExecutor();
    8. 		for (ApplicationListener listener : getApplicationListeners(event, type)) {
    9. 			if (executor != null) {
    10. 				executor.execute(() -> invokeListener(listener, event));
    11. 			}
    12. 			else {
    13. 				invokeListener(listener, event);
    14. 			}
    15. 		}
    16. 	}
    17.  
    18. 	private ResolvableType resolveDefaultEventType(ApplicationEvent event) {
    19. 		return ResolvableType.forInstance(event);
    20. 	}
     


          else {
              invokeListener(listener, event);
         }
     

    1. /**
    2. 	 * Invoke the given listener with the given event.
    3. 	 * @param listener the ApplicationListener to invoke
    4. 	 * @param event the current event to propagate
    5. 	 * @since 4.1
    6. 	 */
    7. 	protected void invokeListener(ApplicationListener listener, ApplicationEvent event) {
    8. 		ErrorHandler errorHandler = getErrorHandler();
    9. 		if (errorHandler != null) {
    10. 			try {
    11. 				doInvokeListener(listener, event);
    12. 			}
    13. 			catch (Throwable err) {
    14. 				errorHandler.handleError(err);
    15. 			}
    16. 		}
    17. 		else {
    18. 			doInvokeListener(listener, event);
    19. 		}
    20. 	}
     


       else {
           doInvokeListener(listener, event);
        }
      
     

    1. @SuppressWarnings({"rawtypes", "unchecked"})
    2. 	private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
    3. 		try {
    4. 			listener.onApplicationEvent(event);
    5. 		}
    6. 		catch (ClassCastException ex) {
    7. 			String msg = ex.getMessage();
    8. 			if (msg == null || matchesClassCastMessage(msg, event.getClass())) {
    9. 				// Possibly a lambda-defined listener which we could not resolve the generic event type for
    10. 				// -> let's suppress the exception and just log a debug message.
    11. 				Log logger = LogFactory.getLog(getClass());
    12. 				if (logger.isTraceEnabled()) {
    13. 					logger.trace("Non-matching event type for listener: " + listener, ex);
    14. 				}
    15. 			}
    16. 			else {
    17. 				throw ex;
    18. 			}
    19. 		}
    20. 	}
     

     


       try {
           listener.onApplicationEvent(event);
        }
      
     

    SourceFilteringListener.java
     

    1. @Override
    2. 	public void onApplicationEvent(ApplicationEvent event) {
    3. 		if (event.getSource() == this.source) {
    4. 			onApplicationEventInternal(event);
    5. 		}
    6. 	}
    7.  
    8.  
    9. /**
    10. 	 * Actually process the event, after having filtered according to the
    11. 	 * desired event source already.
    12. 	 * 
      The default implementation invokes the specified delegate, if any.
    13. 	 * @param event the event to process (matching the specified source)
    14. 	 */
    15. 	protected void onApplicationEventInternal(ApplicationEvent event) {
    16. 		if (this.delegate == null) {
    17. 			throw new IllegalStateException(
    18. 					"Must specify a delegate object or override the onApplicationEventInternal method");
    19. 		}
    20. //这个this.delegate又委托GenericApplicationListenerAdapter类的onApplicationEvent方法
    21. 		this.delegate.onApplicationEvent(event);
    22. 	}
     

    1. GenericApplicationListenerAdapter.java
    2.  
    3.  
    4. 	@Override
    5. 	public void onApplicationEvent(ApplicationEvent event) {
    6. //这个this.delegate又委托ContextRefreshListener类的onApplicationEvent方法
    7. 		this.delegate.onApplicationEvent(event);
    8. 	}
     

     

    事件源XmlWebApplicationContext
     

    事件ContextRefreshedEvent
     

    监听器 ContextRefreshListener
     

     

    FrameworkServlet.java
     

    1. FrameworkServlet.java
    2.  
    3.  
    4. /**
    5. 	 * ApplicationListener endpoint that receives events from this servlet's WebApplicationContext
    6. 	 * only, delegating to {@code onApplicationEvent} on the FrameworkServlet instance.
    7. 	 */
    8. //内部类
    9. 	private class ContextRefreshListener implements ApplicationListener {
    10.  
    11. 		@Override
    12. 		public void onApplicationEvent(ContextRefreshedEvent event) {
    13. 			FrameworkServlet.this.onApplicationEvent(event);
    14. 		}
    15. 	}
     

    1. FrameworkServlet.java
    2.  
    3. /**
    4. 	 * Callback that receives refresh events from this servlet's WebApplicationContext.
    5. 	 * 
      The default implementation calls {@link #onRefresh},
    6. 	 * triggering a refresh of this servlet's context-dependent state.
    7. 	 * @param event the incoming ApplicationContext event
    8. 	 */
    9. 	public void onApplicationEvent(ContextRefreshedEvent event) {
    10. 		this.refreshEventReceived = true;
    11. 		synchronized (this.onRefreshMonitor) {
    12. 			onRefresh(event.getApplicationContext());
    13. 		}
    14. 	}
    15.  
    16.  
    17.  
    18. 	/**
    19. 	 * Template method which can be overridden to add servlet-specific refresh work.
    20. 	 * Called after successful context refresh.
    21. 	 * 
      This implementation is empty.
    22. 	 * @param context the current WebApplicationContext
    23. 	 * @see #refresh()
    24. 	 */
    25. 	protected void onRefresh(ApplicationContext context) {
    26. 		// For subclasses: do nothing by default.
    27. 	}
     

     

    因为DispatcherServlet extends FrameworkServlet,所以执行子类DispatcherServlet#onRefresh()
     

     

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

    initStrategies就是springmvc大家熟悉的流程了。。。

     

    
                
    
                    
    
                
    • 

                
  • 

                    相关阅读:
    
                    
C#静态类和静态类成员                            
    
博客摘录「 hyperf使用jwt的redis储存驱动实现用户token认证」2024年4月9日                            
    
分段读取csv文件并可视化处理                            
    
《More Effective C++》- 极精简版 11-20条                            
    
3、Elasticsearch功能使用                            
    
2024 MCM数学建模美赛2024年A题复盘，思路与经验分享：资源可用性与性别比例 | 七鳃鳗的性别比例变化对生态系统稳定性的影响（四）                            
    
数据驱动智能护理：看AI如何塑造医疗领域，为灰暗夕阳带来新的曙光                            
    
elasticsearch5-RestAPI操作                            
    
Vuex,Vue-router                            
    
Kafka消费者重平衡                            
    
                        
                
    • 
                
  • 
                    原文地址：https://blog.csdn.net/SOMECT/article/details/126957785
                
    •