SSM项目Bean的加载时机与DispatcherServlet的执行流程分析

Bertha 。 2022-12-09 14:57 118阅读 0赞

前言：对SSM项目中bean的加载时机产生了兴趣，我们都知道Spring项目启动时会扫描所有模式注解、xml中的配置，以把相关的类注册成bean，那我们SSM项目是跑在服务器上的，不像SpringBoot直接执行main，它是在什么时候执行的注册bean的操作呢。同时它不像普通的web项目会配置很多servlet，SpringMVC靠一个DispatcherServlet来分发所有请求，个人对这个也比较好奇，想求证一下DispatcherServlet是不是靠getBean来获取对应的处理函数（RequestMapping对应的那个）

参考：

[https://blog.csdn.net/h2604396739/article/details/84899251][https_blog.csdn.net_h2604396739_article_details_84899251]

[https://www.jianshu.com/p/523bfddf0810][https_www.jianshu.com_p_523bfddf0810]

[https://blog.csdn.net/hong10086/article/details/88715960][https_blog.csdn.net_hong10086_article_details_88715960]

[https://blog.csdn.net/q610376681/article/details/108740943][https_blog.csdn.net_q610376681_article_details_108740943]

[https://blog.csdn.net/Elena\_jun/article/details/82698210][https_blog.csdn.net_Elena_jun_article_details_82698210]

[https://blog.csdn.net/hufuzhi1146231094/article/details/103074676][https_blog.csdn.net_hufuzhi1146231094_article_details_103074676]

[https://www.jianshu.com/p/0f981efdfbbd][https_www.jianshu.com_p_0f981efdfbbd]

**目录**

第一章 SSM项目Bean的加载时机

1.1 listener概要

1.2 servletContext

1.3  ContextLoaderListener

第二章 DispatcherServlet的执行流程

2.1 getHandler方法解析

--------------------

# 第一章 SSM项目Bean的加载时机 #

## 1.1 listener概要 ##

web项目中web.xml中配置的选项的加载顺序为**context-param -> listener -> filter -> servlet** ，而同个类型之间的实际程序调用的时候的顺序是根据对应的mapping 的顺序进行调用的。

现在来说说Servlet的监听器Listener，它是实现了javax.servlet.ServletContextListener 接口的服务器端程序，它也是随web应用的启动而启动，**只初始化一次**，随web应用的停止而销毁。**主要作用是： 做一些初始化的内容添加工作、设置一些基本的内容、比如一些参数或者是一些固定的对象等等。**

实现了ServletContextListener 接口后，在项目启动时就会调用contextInitialized中的方法。

public interface ServletContextListener extends EventListener {
        public default void contextInitialized(ServletContextEvent sce) {
        }
        public default void contextDestroyed(ServletContextEvent sce) {
        }
    }

## 1.2 servletContext ##

javaEE标准规定了，servlet容器需要在应用项目启动时，给应用项目初始化一个ServletContext作为公共环境容器存放公共信息。ServletContext中的信息都是由容器提供的。

举例：

通过自定义contextListener获取web.xml中配置的参数  
1.容器启动时，找到配置文件中的context-param作为键值对放到ServletContext中  
2.然后找到listener，容器调用它的contextInitialized(ServletContextEvent event)方法，执行其中的操作

## 1.3 ContextLoaderListener ##

接下来到我们的正主了，我们在web.xml都会配置下面的监听器 ,ContextLoaderListener可以指定在Web应用程序启动时载入Ioc容器，正是通过ContextLoader来实现的，ContextLoader来完成实际的WebApplicationContext，也就是Ioc容器的初始化工作。

<listener>
    		<listener-class>
    			org.springframework.web.context.ContextLoaderListener
    		</listener-class>
    	</listener>

然后项目启动时就会调用this.initWebApplicationContext(event.getServletContext())

public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
        public ContextLoaderListener() {
        }
    
        public ContextLoaderListener(WebApplicationContext context) {
            super(context);
        }
    
        public void contextInitialized(ServletContextEvent event) {
            this.initWebApplicationContext(event.getServletContext());
        }
    
        public void contextDestroyed(ServletContextEvent event) {
            this.closeWebApplicationContext(event.getServletContext());
            ContextCleanupListener.cleanupAttributes(event.getServletContext());
        }
    }

bean的加载正是在这段代码下完成的 configureAndRefreshWebApplicationContext(cwac, servletContext)

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
    		//省略
    		long startTime = System.currentTimeMillis();
    		try {
    			// Store context in local instance variable, to guarantee that
    			// it is available on ServletContext shutdown.
    			if (this.context == null) {
    				this.context = createWebApplicationContext(servletContext);
    			}
    			if (this.context instanceof ConfigurableWebApplicationContext) {
    				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
    				if (!cwac.isActive()) {
    					// The context has not yet been refreshed -> provide services such as
    					// setting the parent context, setting the application context id, etc
    					if (cwac.getParent() == null) {
    						// The context instance was injected without an explicit parent ->
    						// determine parent for root web application context, if any.
    						ApplicationContext parent = loadParentContext(servletContext);
    						cwac.setParent(parent);
    					}
    					configureAndRefreshWebApplicationContext(cwac, servletContext);
    				}
    			}
    			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
    
                //省略
    			return this.context;
    		}
    		catch (RuntimeException | Error ex) {
    			logger.error("Context initialization failed", ex);
    			servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
    			throw ex;
    		}
    	}

看向下面的wac.refresh()，是不是感觉很熟悉，没错，这就是常用的加载bean的代码，在Spring和SpringBoot都常出现

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
    		if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
    			// The application context id is still set to its original default value
    			// -> assign a more useful id based on available information
    			String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
    			if (idParam != null) {
    				wac.setId(idParam);
    			}
    			else {
    				// Generate default id...
    				wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
    						ObjectUtils.getDisplayString(sc.getContextPath()));
    			}
    		}
    
    		wac.setServletContext(sc);
    		String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
    		if (configLocationParam != null) {
    			wac.setConfigLocation(configLocationParam);
    		}
    
    		// The wac environment's #initPropertySources will be called in any case when the context
    		// is refreshed; do it eagerly here to ensure servlet property sources are in place for
    		// use in any post-processing or initialization that occurs below prior to #refresh
    		ConfigurableEnvironment env = wac.getEnvironment();
    		if (env instanceof ConfigurableWebEnvironment) {
    			((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
    		}
    
    		customizeContext(sc, wac);
    		wac.refresh();
    	}

不熟悉refresh()的可以看这个[https://blog.csdn.net/q610376681/article/details/108740943][https_blog.csdn.net_q610376681_article_details_108740943]

@Override
    	public void refresh() throws BeansException, IllegalStateException {
    		synchronized (this.startupShutdownMonitor) {
    			// Prepare this context for refreshing.
    			prepareRefresh();
    
    			// Tell the subclass to refresh the internal bean factory.
    			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    			// Prepare the bean factory for use in this context.
    			prepareBeanFactory(beanFactory);
    
    			try {
    				// Allows post-processing of the bean factory in context subclasses.
    				postProcessBeanFactory(beanFactory);
    
    				// Invoke factory processors registered as beans in the context.
    				invokeBeanFactoryPostProcessors(beanFactory);
    
    				// Register bean processors that intercept bean creation.
    				registerBeanPostProcessors(beanFactory);
    
    				// Initialize message source for this context.
    				initMessageSource();
    
    				// Initialize event multicaster for this context.
    				initApplicationEventMulticaster();
    
    				// Initialize other special beans in specific context subclasses.
    				onRefresh();
    
    				// Check for listener beans and register them.
    				registerListeners();
    
    				// Instantiate all remaining (non-lazy-init) singletons.
    				finishBeanFactoryInitialization(beanFactory);
    
    				// Last step: publish corresponding event.
    				finishRefresh();
    			}
    
    			catch (BeansException ex) {
    				if (logger.isWarnEnabled()) {
    					logger.warn("Exception encountered during context initialization - " +
    							"cancelling refresh attempt: " + ex);
    				}
    
    				// Destroy already created singletons to avoid dangling resources.
    				destroyBeans();
    
    				// Reset 'active' flag.
    				cancelRefresh(ex);
    
    				// Propagate exception to caller.
    				throw ex;
    			}
    
    			finally {
    				// Reset common introspection caches in Spring's core, since we
    				// might not ever need metadata for singleton beans anymore...
    				resetCommonCaches();
    			}
    		}
    	}

# 第二章 DispatcherServlet的执行流程 #

我们都知道，前端的请求会在DispatcherServlet处进行分发处理，那到底是不是获取bean进行处理呢？在这里我复习一下DispatcherServlet的加载流程，顺便求证下这个问题。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvbmcxMDA4Ng_size_16_color_FFFFFF_t_70][]

大概的流程为：

1. 根据request获取处理请求的handler（加了Controller注解的类）

2. 根据反射拿到能执行这个类所有方法的适配器

3. 让适配器去执行目标方法（加了RequestMapping注解的方法），将目标方法执行后的返回值作为视图名并保存到ModelAndView中。（无论方法的返回值怎么写，适配器最后都会把执行后的结果封装成ModelAndView）

4. `HandlerAdapter类`将上一步`Handler`执行结果的`ModelAndView 类`的对象返回给前端控制器

5. `DispatcherServlet类`遍历所有配置的`ViewResolver类`请求进行视图解析，`ViewResolver类`进行视图解析并获取`View`对象，`ViewResolver类`向前端控制器返回上一步骤的`View`对象

6. `DispatcherServlet类`进行视图`View`的渲染，填充`Model，``DispatcherServlet类`向用户返回响应。

具体的流程代码如下（5步与6步没在代码中体现，具体代码在哪本人回头再去探索一下）：

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    		HttpServletRequest processedRequest = request;
    		HandlerExecutionChain mappedHandler = null;
    		boolean multipartRequestParsed = false;
    
    		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    
    		try {
    			ModelAndView mv = null;
    			Exception dispatchException = null;
    
    			try {
    				processedRequest = checkMultipart(request);
    				multipartRequestParsed = (processedRequest != request);
    
    				// Determine handler for the current request.
    				mappedHandler = getHandler(processedRequest);
    				if (mappedHandler == null) {
    					noHandlerFound(processedRequest, response);
    					return;
    				}
    
    				// Determine handler adapter for the current request.
    				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    
    				// Process last-modified header, if supported by the handler.
    				String method = request.getMethod();
    				boolean isGet = "GET".equals(method);
    				if (isGet || "HEAD".equals(method)) {
    					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
    					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
    						return;
    					}
    				}
    
    				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
    					return;
    				}
    
    				// Actually invoke the handler.
    				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    
    				if (asyncManager.isConcurrentHandlingStarted()) {
    					return;
    				}
    
    				applyDefaultViewName(processedRequest, mv);
    				mappedHandler.applyPostHandle(processedRequest, response, mv);
    			}
    			catch (Exception ex) {
    				dispatchException = ex;
    			}
    			catch (Throwable err) {
    				// As of 4.3, we're processing Errors thrown from handler methods as well,
    				// making them available for @ExceptionHandler methods and other scenarios.
    				dispatchException = new NestedServletException("Handler dispatch failed", err);
    			}
    			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    		}
            //省略catch和finally
    	}

## 2.1 getHandler方法解析 ##

在下面的代码，我将得到处理请求的类

mappedHandler = getHandler(processedRequest);

点进去后发现，它是在handlerMapping中进行循环，找到合适的HandlerExecutionChain 后进行返回。

@Nullable
    	protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    		if (this.handlerMappings != null) {
    			for (HandlerMapping mapping : this.handlerMappings) {
    				HandlerExecutionChain handler = mapping.getHandler(request);
    				if (handler != null) {
    					return handler;
    				}
    			}
    		}
    		return null;
    	}

再继续往下点，进入getHandler代码中,发现现根据request获取到bean的name（个人感觉就是controller的name），**然后调用ApplicationContext获取相应的bean**，这也就说明了DispatcherServle确实是靠获取bean处理的请求。

public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    		Object handler = getHandlerInternal(request);
    		if (handler == null) {
    			handler = getDefaultHandler();
    		}
    		if (handler == null) {
    			return null;
    		}
    		// Bean name or resolved handler?
    		if (handler instanceof String) {
    			String handlerName = (String) handler;
    			handler = obtainApplicationContext().getBean(handlerName);
    		}
    
    		HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
    
    		
    
    		//省略...
    
    		return executionChain;
    	}

[https_blog.csdn.net_h2604396739_article_details_84899251]: https://blog.csdn.net/h2604396739/article/details/84899251
[https_www.jianshu.com_p_523bfddf0810]: https://www.jianshu.com/p/523bfddf0810
[https_blog.csdn.net_hong10086_article_details_88715960]: https://blog.csdn.net/hong10086/article/details/88715960
[https_blog.csdn.net_q610376681_article_details_108740943]: https://blog.csdn.net/q610376681/article/details/108740943
[https_blog.csdn.net_Elena_jun_article_details_82698210]: https://blog.csdn.net/Elena_jun/article/details/82698210
[https_blog.csdn.net_hufuzhi1146231094_article_details_103074676]: https://blog.csdn.net/hufuzhi1146231094/article/details/103074676
[https_www.jianshu.com_p_0f981efdfbbd]: https://www.jianshu.com/p/0f981efdfbbd
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2hvbmcxMDA4Ng_size_16_color_FFFFFF_t_70]: /images/20221123/73fb71f1d8624676b2a059f8bcbbede2.png