前言
年初面试时接触到一道面试题，在聊到springmvc时提到了springmvc的开发者为何要设计父子容器呢，又或者说是父子容器的设计有什么更实际的作用呢？
首先要理解对于一个web应用，当其部署在web容器上时，容器会为其提供一个全局上下文环境servletcontext，这个上下文环境将为后续的spring提供宿主环境。
springmvc工作流程
dispatcherservlet上下文继承关系
springmvc设计的父子容器
父子容器配置文件
--在web.xml中配置，两个重要的xml:applicationcontext.xml和springmvc-conf.xml
<context-param>
<param-name>contextconfiglocation</param-name>
<param-value>classpath*:applictioncontext.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.contextloaderlistener</listener-class>
</listener>
<servlet>
<servlet-name>dispatcher-servlet</servlet-name>
<servlet-class>org.springframework.web.servlet.dispatcherservlet</servlet-class>
<init-param>
<param-name>contextconfiglocation</param-name>
<param-value>classpath*:springmvc-conf.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher-servlet</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
父子容器的设计目的
根据springmvc的官方解释，父（根）容器主要包括一些基础脚手架的bean，比如pool、datasource、dao、service。目的是在不同的servlet实例之间共享。这些不同的bean可以在子容器中重写。
而子容器主要包括一些controller、view等一些web相关的bean。
dispatcherservlet源码分析
既然springmvc中同时包含spring容器和springmvc容器，那么这两个容器都是在什么时候初始化呢？
根容器初始化
首先，根容器是通过servletcontext监听器进行创建，默认的监听器为contextloaderlistener，当web应用启动时，会调用监听器的contextinitialized方法。
那么根容器的初始化就从contextloaderlistener类说起吧，，spring官方对该类的描述是启动监听器去启动和关闭spring的root webapplicationcontext（翻译的实在有点蹩脚）。
public class contextloaderlistener extends contextloader implements servletcontextlistener {
public contextloaderlistener() {
}
public contextloaderlistener(webapplicationcontext context) {
super(context);
}
//===初始化root webapplicationcontext===
@override
public void contextinitialized(servletcontextevent event) {
initwebapplicationcontext(event.getservletcontext());
}
@override
public void contextdestroyed(servletcontextevent event) {
closewebapplicationcontext(event.getservletcontext());
contextcleanuplistener.cleanupattributes(event.getservletcontext());
}
}
//contextloader.java
public webapplicationcontext initwebapplicationcontext(servletcontext servletcontext) {
//初始化spring容器时如果发现servlet 容器中已存在根spring容根器则抛出异常，证明rootwebapplicationcontext只能有一个。
if (servletcontext.getattribute(webapplicationcontext.root_web_application_context_attribute) != null) {
throw new illegalstateexception(
"cannot initialize context because there is already a root application context present - " +
"check whether you have multiple contextloader* definitions in your web.xml!");
}
try {
//创建webapplicationcontext实例
if (this.context == null) {
this.context = createwebapplicationcontext(servletcontext);
}
if (this.context instanceof configurablewebapplicationcontext) {
configurablewebapplicationcontext cwac = (configurablewebapplicationcontext) this.context;
if (!cwac.isactive()) {
if (cwac.getparent() == null) {
applicationcontext parent = loadparentcontext(servletcontext);
cwac.setparent(parent);
}
//配置webapplicationcontext
configureandrefreshwebapplicationcontext(cwac, servletcontext);
}
}
/**
把生成的webapplicationcontext设置成root webapplicationcontext。保存在servletcontext上下文中。
下一步初始化mvc applicationcontext时需要从servletcontext取出根上下文作为其父上下文。
**/
servletcontext.setattribute(webapplicationcontext.root_web_application_context_attribute, this.context);
classloader ccl = thread.currentthread().getcontextclassloader();
if (ccl == contextloader.class.getclassloader()) {
currentcontext = this.context;
}
else if (ccl != null) {
currentcontextperthread.put(ccl, this.context);
}
return this.context;
}
catch (runtimeexception | error ex) {
servletcontext.setattribute(webapplicationcontext.root_web_application_context_attribute, ex);
throw ex;
}
}
以上代码主要完成两个功能：创建实例webapplicationcontext实例、把所创建的webapplicationcontext设置为根上下文，也就是设置成为root_web_application_context_attribute的值。
mvc容器初始化
大家知道servlet生命周期都是从init方法开始，desctory方法结束，由jvm负责垃圾回收。而dispatcherservlet也是一个普通的servlet，先看一下dispatcherservlet的继承关系图，对整个继承关系有个了解。
既然说起servlet，那就从servlet的初始化（init）方法入手
//httpservletbean.java
@override
public final void init() throws servletexception {
propertyvalues pvs = new servletconfigpropertyvalues(getservletconfig(), this.requiredproperties);
if (!pvs.isempty()) {
try {
beanwrapper bw = propertyaccessorfactory.forbeanpropertyaccess(this);
resourceloader resourceloader = new servletcontextresourceloader(getservletcontext());
bw.registercustomeditor(resource.class, new resourceeditor(resourceloader, getenvironment()));
initbeanwrapper(bw);
bw.setpropertyvalues(pvs, true);
}
catch (beansexception ex) {
throw ex;
}
}
//交给子类重写
initservletbean();
}
//frameworkservlet.java
@override
protected final void initservletbean() throws servletexception {
try {
this.webapplicationcontext = initwebapplicationcontext();
initframeworkservlet();
}
catch (servletexception | runtimeexception ex) {
throw ex;
}
}
//frameworkservlet.java
//初始化mvc容器
protected webapplicationcontext initwebapplicationcontext() {
//从servletcontext取出根上下文
webapplicationcontext rootcontext =
webapplicationcontextutils.getwebapplicationcontext(getservletcontext());
webapplicationcontext wac = null;
if (this.webapplicationcontext != null) {
wac = this.webapplicationcontext;
if (wac instanceof configurablewebapplicationcontext) {
configurablewebapplicationcontext cwac = (configurablewebapplicationcontext) wac;
if (!cwac.isactive()) {
if (cwac.getparent() == null) {
cwac.setparent(rootcontext);
}
configureandrefreshwebapplicationcontext(cwac);
}
}
}
if (wac == null) {
wac = findwebapplicationcontext();
}
//如果还没有webapplicatioincontext，创建webapplicationcontext
if (wac == null) {
wac = createwebapplicationcontext(rootcontext);
}
//子类自定义对servlet子上下文后续操作，在dispatcherservlet中实现
if (!this.refresheventreceived) {
synchronized (this.onrefreshmonitor) {
//执行子类扩展方法onrefresh，在dispatcherservlet内初始化所有web相关组件
onrefresh(wac);
}
}
//发布servlet子上下文到servletcontext
if (this.publishcontext) {
string attrname = getservletcontextattributename();
//将servlet子上下文以org.springframework.web.servlet.frameworkservlet.context. + servletname的属性名称注册到servletcontext中
getservletcontext().setattribute(attrname, wac);
}
return wac;
}
protected webapplicationcontext createwebapplicationcontext(@nullable webapplicationcontext parent) {
return createwebapplicationcontext((applicationcontext) parent);
}
protected webapplicationcontext createwebapplicationcontext(@nullable applicationcontext parent) {
//获取webapplicationcontext实现类，此处其实就是xmlwebapplicationcontext
class<?> contextclass = getcontextclass();
if (!configurablewebapplicationcontext.class.isassignablefrom(contextclass)) {
throw new applicationcontextexception("fatal initialization error in servlet with name '" + getservletname() +
"': custom webapplicationcontext class [" + contextclass.getname() +
"] is not of type configurablewebapplicationcontext");
}
//生成xmlwebapplicationcontext实例
configurablewebapplicationcontext wac =
(configurablewebapplicationcontext) beanutils.instantiateclass(contextclass);
wac.setenvironment(getenvironment());
//设置根容器为父容器
wac.setparent(parent);
string configlocation = getcontextconfiglocation();
if (configlocation != null) {
//设置配置文件
wac.setconfiglocation(configlocation);
}
//配置webapplicationcontext
configureandrefreshwebapplicationcontext(wac);
return wac;
}
protected void configureandrefreshwebapplicationcontext(configurablewebapplicationcontext wac) {
if (objectutils.identitytostring(wac).equals(wac.getid())) {
if (this.contextid != null) {
wac.setid(this.contextid);
}
else {
wac.setid(configurablewebapplicationcontext.application_context_id_prefix + objectutils.getdisplaystring(getservletcontext().getcontextpath()) + '/' + getservletname());
}
}
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);
applyinitializers(wac);
//开始处理bean
wac.refresh();
}
上面的关键代码都在frameworkservlet类中，有几个关键点：取除根上下文，创建子上下文并设置父上下文，完成刷新，把子上下文发布到servletcontext中。 到这里可以说子容器（子上下文）已经创建完成。 并把其他初始化web组件的相关工作交给onrefresh方法完成，由dispatcherservlet来重写onrefresh方法，这就又回到了我们熟悉的initstrategies方法。
web组件初始化
@override
protected void onrefresh(applicationcontext context) {
initstrategies(context);
}
protected void initstrategies(applicationcontext context) {
//文件上传解析器
initmultipartresolver(context);
//本地化解析器
initlocaleresolver(context);
//主题解析器
initthemeresolver(context);
//处理器映射器(url和controller方法的映射)
inithandlermappings(context);
//处理器适配器(实际执行controller方法)
inithandleradapters(context);
//处理器异常解析器
inithandlerexceptionresolvers(context);
//requesttoviewname解析器
initrequesttoviewnametranslator(context);
//视图解析器(视图的匹配和渲染)
initviewresolvers(context);
//flashmap管理者
initflashmapmanager(context);
}
这里我们主要关注一下三个重要组件：handlermapping、handleradapter、viewresolver。分析这3个组件之前，我们先看一下我们的springmvc-conf.xml配置文件，mvc的配置文件中，我们配置了两行代码：
<context:component-scan base-package="com.zhangfei"/> <mvc:annotation-driven>
第二行代码主要是添加了默认的handlemapping,viewresolver,handleadapter。我们看看annotation-driven的源码定义，根据spring自定义schema定义，我们找到如下代码，如图所示：
该文件就一行代码：
http\://www.springframework.org/schema/mvc=org.springframework.web.servlet.config.mvcnamespacehandler
//mvc所有的标签解析器都定义在此
public class mvcnamespacehandler extends namespacehandlersupport {
@override
public void init() {
registerbeandefinitionparser("annotation-driven", new annotationdrivenbeandefinitionparser());
registerbeandefinitionparser("default-servlet-handler", new defaultservlethandlerbeandefinitionparser());
registerbeandefinitionparser("interceptors", new interceptorsbeandefinitionparser());
registerbeandefinitionparser("resources", new resourcesbeandefinitionparser());
registerbeandefinitionparser("view-controller", new viewcontrollerbeandefinitionparser());
registerbeandefinitionparser("redirect-view-controller", new viewcontrollerbeandefinitionparser());
registerbeandefinitionparser("status-controller", new viewcontrollerbeandefinitionparser());
registerbeandefinitionparser("view-resolvers", new viewresolversbeandefinitionparser());
registerbeandefinitionparser("tiles-configurer", new tilesconfigurerbeandefinitionparser());
registerbeandefinitionparser("freemarker-configurer", new freemarkerconfigurerbeandefinitionparser());
registerbeandefinitionparser("groovy-configurer", new groovymarkupconfigurerbeandefinitionparser());
registerbeandefinitionparser("script-template-configurer", new scripttemplateconfigurerbeandefinitionparser());
registerbeandefinitionparser("cors", new corsbeandefinitionparser());
}
}
那么通过分析annotationdrivenbeandefinitionparser类，主要完成以下三大组件的装配工作：
初始化处理器映射器
private void inithandlermappings(applicationcontext context) {
this.handlermappings = null;
//这里detectallhandlermappings默认值为true，可以通过配置文件设置为false
if (this.detectallhandlermappings) {
//从上下文(包含父上下文)中查找所有handlermapping实现类
map<string, handlermapping> matchingbeans =
beanfactoryutils.beansoftypeincludingancestors(context, handlermapping.class, true, false);
if (!matchingbeans.isempty()) {
this.handlermappings = new arraylist<>(matchingbeans.values());
annotationawareordercomparator.sort(this.handlermappings);
}
}
else {
try {
//这里只取固定的bean
handlermapping hm = context.getbean(handler_mapping_bean_name, handlermapping.class);
this.handlermappings = collections.singletonlist(hm);
}
catch (nosuchbeandefinitionexception ex) {
}
}
/***
确保至少有一个handlermapping，如果没能找到，注册一个默认的
默认规则在dispatcherservlet.properties中，这里也就是取beannameurlhandlermapping、requestmappinghandlermapping
***/
if (this.handlermappings == null) {
this.handlermappings = getdefaultstrategies(context, handlermapping.class);
}
}
初始化处理器适配器
private void inithandleradapters(applicationcontext context) {
this.handleradapters = null;
if (this.detectallhandleradapters) {
//从上下文（包括父上下文）中查找所有handleradapter实现类
map<string, handleradapter> matchingbeans =beanfactoryutils.beansoftypeincludingancestors(context, handleradapter.class, true, false);
if (!matchingbeans.isempty()) {
this.handleradapters = new arraylist<>(matchingbeans.values());
annotationawareordercomparator.sort(this.handleradapters);
}
}
else {
try {
//这里取bean名字为handleradapter，类型为handleradapter的处理器适配器
handleradapter ha = context.getbean(handler_adapter_bean_name, handleradapter.class);
this.handleradapters = collections.singletonlist(ha);
}
catch (nosuchbeandefinitionexception ex) {
}
}
/**
如果没找到，则从默认规则里取出指定的三个实现类：httprequesthandleradapter、simplecontrollerhandleradapter、requestmappinghandleradapter
**/
if (this.handleradapters == null) {
this.handleradapters = getdefaultstrategies(context, handleradapter.class);
}
}
初始化试图解析器
private void initviewresolvers(applicationcontext context) {
this.viewresolvers = null;
if (this.detectallviewresolvers) {
//从上下文（包括父上下文）中查找所有viewresolver实现类
map<string, viewresolver> matchingbeans =beanfactoryutils.beansoftypeincludingancestors(context, viewresolver.class, true, false);
if (!matchingbeans.isempty()) {
this.viewresolvers = new arraylist<>(matchingbeans.values());
annotationawareordercomparator.sort(this.viewresolvers);
}
}
else {
try {
viewresolver vr = context.getbean(view_resolver_bean_name, viewresolver.class);
this.viewresolvers = collections.singletonlist(vr);
}
catch (nosuchbeandefinitionexception ex) {
}
}
/**
如果没找到，则从默认规则里取出指定的实现类：internalresourceviewresolver
**/
if (this.viewresolvers == null) {
this.viewresolvers = getdefaultstrategies(context, viewresolver.class);
}
}
三大组件的初始化最后判断为null时都会调用getdefaultstrategies方法，也就是从dispatcherservlet.properties中取出指定默认值。
protected <t> list<t> getdefaultstrategies(applicationcontext context, class<t> strategyinterface) {
string key = strategyinterface.getname();
string value = defaultstrategies.getproperty(key);
if (value != null) {
string[] classnames = stringutils.commadelimitedlisttostringarray(value);
list<t> strategies = new arraylist<>(classnames.length);
for (string classname : classnames) {
try {
class<?> clazz = classutils.forname(classname, dispatcherservlet.class.getclassloader());
object strategy = createdefaultstrategy(context, clazz);
strategies.add((t) strategy);
}
catch (classnotfoundexception ex) {
throw new beaninitializationexception("could not find dispatcherservlet's default strategy class [" + classname +"] for interface [" + key + "]", ex);
}
catch (linkageerror err) {
throw new beaninitializationexception("unresolvable class definition for dispatcherservlet's default strategy class [" +classname + "] for interface [" + key + "]", err);
}
}
return strategies;
}
else {
return new linkedlist<>();
}
}
dispatcherservlet请求处理过程
提到请求处理过程，我们再来回顾一下servlet生命周期，处理请求都放在service方法中处理，那么也从dispatcherservlet的service方法入手。dispatcherservlet继承frameworkservlet，在frameworkservlet中重写了service、doget、dopost、doput、dodelete方法。
//frameworkservlet.java
@override
protected void service(httpservletrequest request, httpservletresponse response)
throws servletexception, ioexception {
httpmethod httpmethod = httpmethod.resolve(request.getmethod());
if (httpmethod == httpmethod.patch || httpmethod == null) {
processrequest(request, response);
}
else {
super.service(request, response);
}
}
@override
protected final void doget(httpservletrequest request, httpservletresponse response)
throws servletexception, ioexception {
processrequest(request, response);
}
@override
protected final void dopost(httpservletrequest request, httpservletresponse response)
throws servletexception, ioexception {
processrequest(request, response);
}
@override
protected final void doput(httpservletrequest request, httpservletresponse response)
throws servletexception, ioexception {
processrequest(request, response);
}
@override
protected final void dodelete(httpservletrequest request, httpservletresponse response)
throws servletexception, ioexception {
processrequest(request, response);
}
protected final void processrequest(httpservletrequest request, httpservletresponse response)
throws servletexception, ioexception {
long starttime = system.currenttimemillis();
throwable failurecause = null;
localecontext previouslocalecontext = localecontextholder.getlocalecontext();
localecontext localecontext = buildlocalecontext(request);
requestattributes previousattributes = requestcontextholder.getrequestattributes();
servletrequestattributes requestattributes = buildrequestattributes(request, response, previousattributes);
webasyncmanager asyncmanager = webasyncutils.getasyncmanager(request);
asyncmanager.registercallableinterceptor(frameworkservlet.class.getname(), new requestbindinginterceptor());
//把新构造的localecontext对象和servletrequestattributes对象和当前请求线程绑定（后面要解除绑定）
initcontextholders(request, localecontext, requestattributes);
try {
//抽象方法，交给dispatcherservlet方法实现
doservice(request, response);
}
catch (servletexception | ioexception ex) {
failurecause = ex;
throw ex;
}
catch (throwable ex) {
failurecause = ex;
throw new nestedservletexception("request processing failed", ex);
}
finally {
//重置localecontext和requestattributes对象，也就是解除localecontext对象和servletrequestattributes对象和当前请求线程的绑定
resetcontextholders(request, previouslocalecontext, previousattributes);
if (requestattributes != null) {
requestattributes.requestcompleted();
}
//发布servletrequesthandledevent事件
publishrequesthandledevent(request, response, starttime, failurecause);
}
}
//dispatcherservlet.java
@override
protected void doservice(httpservletrequest request, httpservletresponse response) throws exception {
map<string, object> attributessnapshot = null;
if (webutils.isincluderequest(request)) {
attributessnapshot = new hashmap<>();
enumeration<?> attrnames = request.getattributenames();
while (attrnames.hasmoreelements()) {
string attrname = (string) attrnames.nextelement();
if (this.cleanupafterinclude || attrname.startswith(default_strategies_prefix)) {
attributessnapshot.put(attrname, request.getattribute(attrname));
}
}
}
//在当前request对象中填充4个属性
request.setattribute(web_application_context_attribute, getwebapplicationcontext());
request.setattribute(locale_resolver_attribute, this.localeresolver);
request.setattribute(theme_resolver_attribute, this.themeresolver);
request.setattribute(theme_source_attribute, getthemesource());
if (this.flashmapmanager != null) {
flashmap inputflashmap = this.flashmapmanager.retrieveandupdate(request, response);
if (inputflashmap != null) {
request.setattribute(input_flash_map_attribute, collections.unmodifiablemap(inputflashmap));
}
request.setattribute(output_flash_map_attribute, new flashmap());
request.setattribute(flash_map_manager_attribute, this.flashmapmanager);
}
try {
//主要处理分发请求
dodispatch(request, response);
}
finally {
if (!webasyncutils.getasyncmanager(request).isconcurrenthandlingstarted()) {
if (attributessnapshot != null) {
restoreattributesafterinclude(request, attributessnapshot);
}
}
}
}
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);
//调用handlermapping获取handlerchain
mappedhandler = gethandler(processedrequest);
if (mappedhandler == null) {
nohandlerfound(processedrequest, response);
return;
}
//获取支持该handler解析的handleradapter
handleradapter ha = gethandleradapter(mappedhandler.gethandler());
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;
}
//使用handleradapter完成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) {
dispatchexception = new nestedservletexception("handler dispatch failed", err);
}
processdispatchresult(processedrequest, response, mappedhandler, mv, dispatchexception);
}
catch (exception ex) {
triggeraftercompletion(processedrequest, response, mappedhandler, ex);
}
catch (throwable err) {
triggeraftercompletion(processedrequest, response, mappedhandler,new nestedservletexception("handler processing failed", err));
}
finally {
if (asyncmanager.isconcurrenthandlingstarted()) {
if (mappedhandler != null) {
mappedhandler.applyafterconcurrenthandlingstarted(processedrequest, response);
}
}
else {
if (multipartrequestparsed) {
cleanupmultipart(processedrequest);
}
}
}
}
dispatcherservlet的dodispatch方法概括起来大致就是以下几点：首先根据当前请求路径找到对应的handlermethod，一个handlermethod和若干个拦截器构造一个handlerexecutionchain.通过handlerexecutionchain得到handleradapter对象，通过执行handleradapter的handle方法得到modelandview对象，调用modelandview解析视图，渲染视图，response结束。
参考
https://www.cnblogs.com/fangjian0423/p/springmvc-dispatcherservlet.html
