探索SpringMVC-web上下文

Evan_L

已于 2023-01-18 22:48:17 修改

阅读量824

点赞数 1

分类专栏：探索SpringMVC 文章标签： java

于 2022-12-02 11:26:23 首次发布

本文链接：https://blog.csdn.net/Evan_L/article/details/128061149

版权

探索SpringMVC 专栏收录该内容

11 篇文章 4 订阅

订阅专栏

前言

SpringMVC提供了很多可拓展的组件，例如：参数解析器、拦截器、异常处理器等等。但是如果想要理解/找到这些组件工作的位置/时机，很多时候总是容易迷失在其层层调用的源码之中。因此想要写一些东西记录一下，愿景是从Spring的上下文启动到SpringMVC接受客户端请求的处理过程。由于涉及的内容比较多，在朋友的建议下，决定改成一个系列。
在不断的了解更多SpringMVC的内部细节的过程中，发现要想理解DispatcherServlet完整的请求处理链路和逻辑，还需要了解其内部结构。因此决定调整系列文章的结构。

DispatcherServlet

相信大家都认识这东西，作用啥的也就不多说了。但请先暂时记住这一点: 他是javax.servlet.Servlet。

WebApplicationContext

什么是上下文

还记得以前做阅读理解题目的时候吗？老师经常说的一句话是：联系上下文。又比如，你跟淘宝客服聊天，有时候我们总是先把商品发给对方，然后再说这个有没有其他颜色之类的。而这些推动事情继续发展的“背景知识”就可以叫做上下文。
回到Spring，像环境配置、bean对象在哪里、事件发布等等，都属于上下文信息。即使，不是直接的进行参与，至少也要能够“联系”到对应的人来处理。例如，BeanFactory。如果从这个角度看的话，还能这样理解，他就是一个信息机构，有点像情报机构。你想要的东西他都能给你找来。实际上，我们在工作中，临时接入某个事情的时候，都需要进行交接/学习“上下文”。在了解事情的背景知识之后，我们才能进一步开展工作。
在这里插入图片描述
不过，由于Spring的上下文，是整个应用运行的上下文，因此Spring的上下文需要具备的背景知识比较庞杂，理解起来不容易。但我们可以从他的继承关系来理解他的能力。这里就不扩展了。

父子上下文

在这里插入图片描述
SpringMVC把上下文分为Servlet容器的上下文，和根应用上下文。这点可能有不少人知道。但是，为什么要这样分呢？先看下两个上下文的职责分工。

Servlet上下文包含控制器、试图解析器，以及其他web相关的bean
Root上下文，则包含中间层服务，数据源等。

可能有同学会问，为什么要多此一举呢？只使用一个上下文不行吗？还更容易理解。但是，有的情况下，我们的web应用可能不止提供http服务。例如：定时任务。定时任务跟Servlet有关系吗？
从设计原则上说，这种划分可能也是基于最少知识原则，降低系统的耦合，也为其可维护性埋下伏笔。简而言之，web上下文只管web相关的bean，应用上下文管其他与web无关的bean。

Root ApplicationContext怎么加载呢？

DispatcherServlet通过自己的上下文来提供web服务。并且该web上下文还有个父亲。我们很容易想到在DispatcherServlet创建/初始化时，创建一个web上下文并扫描相关的webBean。但是Root ApplicationContext增加加载呢？怎么衔接起来呢？
DispatcherServlet不就是一个servlet吗？通过ServletContext传递不就好了。但是什么时候创建呢？于是我们就需要到tomcat里面来了。
tomcat启动的时候，也有自己的上下文:ServletContext。这个时候，可能有同学要晕车。。其实，你回过头再理解一下上下文，或许就好了。这就类似于我们现实生活中，做不同的事情，所需要了解的背景知识不一样。如果你用SpringCloud，还有个Bootstrap ApplicationContex，可以自己理解一下，它又是干啥的。
当ServletContext初始化完成后，就会发布一个ServletContextEvent。这时只要我们实现ServletContextListener，即可收到通知。于是，我们便可借此机会初始化Root ApplicationContext，并放到ServletContext里面。
在这里插入图片描述

DispatcherServlet启动

DispatcherServlet有一个Web上下文，并且由他管理着所有的web相关的bean。这意味着，在DispatcherServlet具备提供服务的能力之前，我们需要先将这个上下文准备好。而之前说的，只是Root Application。
如果是你，你会怎么做呢？很容易想到就是在创建DispatcherServlet的时候对上下文进行初始化。只不过我们的DispatcherServlet本质上是Servlet，因此只需要跟随Servlet的生命周期函数就好。所以选择在javax.servlet.Servlet#init方法进行初始化。
实际的实现在：org.springframework.web.servlet.FrameworkServlet#initServletBean
要找到他的实际创建和刷新上下文，还是有点绕的，调用链路贴一下：
在这里插入图片描述
在串联上面的过程前，先把DispatcherServlet的配置也贴一下:

现在我们来串一下上面说的过程：

初始化Root ApplicationContext：通过ServletContextListener刷新Root上下文，并设置到ServletContext里面。
初始化Web ApplicationContext：在DispatcherServlet启动时，初始化web上下文。从ServletContext中获取Root上下文设置到web上下文的parent属性，绑定父子关系。
注意，配置上面已经贴过了：Spring的监听器就是大家在web.xml里面配置的org.springframework.web.context.ContextLoaderListener。

初始化Root ApplicationContext


	/**
	 * Initialize the root web application context.
	 * 实例化root上下文.
	 * 该方法的代码来自：org.springframework.web.context.ContextLoaderListener
	 */
	@Override
	public void contextInitialized(ServletContextEvent event) {
		initWebApplicationContext(event.getServletContext());
	}

	// 下方所有代码来自：org.springframework.web.context.ContextLoader
	/**
	 * 为servletContext实例化上下文
	 */
	public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
		// 省略...
		try {
			if (this.context == null) {
				// 1. 创建上下文
				this.context = createWebApplicationContext(servletContext);
			}
			if (this.context instanceof ConfigurableWebApplicationContext) {
				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
				if (!cwac.isActive()) {
					// 省略...
					// 2. 这个方法会获取我们在web.xml中配置的applicationContext.xml交给上下文对象，最终实现上下文的初始化
					configureAndRefreshWebApplicationContext(cwac, servletContext);
				}
				// 3. 将root上下文设置到servlet上下文中
				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;
		}
	/**
	 * 1. 推断root上下文
	 * 2. 通过反射构建root上下文
	 */
	protected WebApplicationContext createWebApplicationContext(ServletContext sc) {
		// 推断上下文Class
		Class<?> contextClass = determineContextClass(sc);
		if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
			throw new ApplicationContextException("Custom context class [" + contextClass.getName() +
					"] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");
		}
		// 反射构建上下文
		return (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
	}
	
	/**
	 * 推断root上下文
	 */
	protected Class<?> determineContextClass(ServletContext servletContext) {
		// 从servletContext获取contextClass
		String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);
		if (contextClassName != null) {
			// 省略...
		}
		else {
			// 没有配置contextClass，使用默认的配置：来自ClassLoader.properties
			// 该配置里面为：XmlWebApplicationContext
			contextClassName = defaultStrategies.getProperty(WebApplicationContext.class.getName());
			try {
				return ClassUtils.forName(contextClassName, ContextLoader.class.getClassLoader());
			}
			catch (ClassNotFoundException ex) {
				throw new ApplicationContextException(
						"Failed to load default context class [" + contextClassName + "]", ex);
			}
		}
	}
	// 好了，到这里我们看到了怎么找到contextClass，以及怎么实例化的。
	// 但是还没看到使用我们在web.xml里面配置applicationContext.xml
	// 让我们再次回到initWebApplicationContext(ServletContext servletContext)方法
	// 他调用了我在上面埋下伏笔的备注：获取applicationContext.xml
	
	protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
		// 省略...
		wac.setServletContext(sc);
		// 获取contextConfigLocation，这就是我们配置在web.xml中的applicationContext.xml了
		String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
		if (configLocationParam != null) {
			wac.setConfigLocation(configLocationParam);
		}
		// 省略...
		// 刷新root上下文
		wac.refresh();
	}

初始化Web ApplicationContext

这部分就是DispatcherServlet的初始化过程了，跟着javax.servlet.Servlet#init方法往下看

// 首先是org.springframework.web.servlet.HttpServletBean#init
	@Override
	public final void init() throws ServletException {
		// 省略...
		initServletBean();
	}
// 接着是org.springframework.web.servlet.FrameworkServlet#initServletBean
	@Override
	protected final void initServletBean() throws ServletException {
	 	// 省略...
		this.webApplicationContext = initWebApplicationContext();
	 	// 省略...
	}
	
	protected WebApplicationContext initWebApplicationContext() {
		// 1. 从ServletContext中，把root上下文拿出来
		WebApplicationContext rootContext =
				WebApplicationContextUtils.getWebApplicationContext(getServletContext());
		WebApplicationContext wac = null;

		if (this.webApplicationContext != null) {
			// 如果直接设置了在DispatcerServlet的构造器中传了上下文，进行配置和刷新
			// 这里省略...，不关注这种情况，因为通常情况下，我们并不会直接设置他的上下文
		}
		if (wac == null) {
			// 并没有通过DispatcherServlet的构造器设置上下文，则假设在servletContext中已经初始化了一个web上下文，在这里拿出来。
			// 很显然这里也是没有web上下文的
			wac = findWebApplicationContext();
		}
		if (wac == null) {
			// 创建默认的web上下文
			wac = createWebApplicationContext(rootContext);
		}

		if (!this.refreshEventReceived) {
			// 上下文已经刷新了，则初始化web相关组件：九大组件
			synchronized (this.onRefreshMonitor) {
				onRefresh(wac);
			}
		}
		// 省略...
		return wac;
	}
	// 创建web上下文
	protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
		// 1. 获取contextClass，这里默认是XmlWebApplicationContext
		Class<?> contextClass = getContextClass();
		// 2. 通过反射实例化web上下文
		ConfigurableWebApplicationContext wac =
				(ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

		wac.setEnvironment(getEnvironment());
		// 3. 设置root上下文，到此。我们把root上下文跟web上下文绑定了父子关系
		wac.setParent(parent);
		// 4. 从web.xml拿到DipatcherServlet的ContextConfigLocation
		// 并设置到上下文中
		String configLocation = getContextConfigLocation();
		if (configLocation != null) {
			wac.setConfigLocation(configLocation);
		}
		// 5. 配置并刷新上下文
		configureAndRefreshWebApplicationContext(wac);

		return wac;
	}
	
	// 配置并刷新上下文
	protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
		if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
			// 设置上下文ID
			// 省略
		}
		
		wac.setServletContext(getServletContext());
		wac.setServletConfig(getServletConfig());
		wac.setNamespace(getNamespace());
		wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));
		
		ConfigurableEnvironment env = wac.getEnvironment();
		if (env instanceof ConfigurableWebEnvironment) {
			((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
		}
		// 提供扩展方法，允许子类在上下文实例化后进行配置
		postProcessWebApplicationContext(wac);
		// 执行ApplicationContextInitializer
		applyInitializers(wac);
		// 刷新上下文
		wac.refresh();
	}

到这里DispatcherServlet的web上下文就已经准备就绪了。

小结

DispatcherServlet本质上还是javax.servlet.Servlet，他的web上下文的启动依赖于Servlet的加载机制（Servlet#init方法）。同时，为了实例化和刷新root上下文，利用了tomcat的监听器机制。再通过ServletContext作为桥梁，将web上下文和root上下文绑定父子关系。