开始
假设已经云配好了web.xml
web服务器在启动的时候会加载web.xml文件，则会调用配置在web.xml里的DispatcherServlet.init()，前提load-on-startup为正整数。
初始化
GenericServlet的init
public void init(ServletConfig config) throws ServletException {
this.config = config;
//空方法，由HttpServletBean实现
this.init();
}
public void init() throws ServletException {}
HttpServletBean的init
public final void init() throws ServletException {
PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
if (!pvs.isEmpty()) {
try {
//将DispatcherServlet构造成BeanWrapper以便后续操作参数
BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
ResourceLoader resourceLoader = ...;
bw.registerCustomEditor(...);
//空方法，由子类实现
initBeanWrapper(bw);
bw.setPropertyValues(pvs, true);
}
catch (BeansException ex) {
...
}
}
//空方法，由FrameworkServlet实现
initServletBean();
}
这里稍微看下PropertyAccessorFactory，其中有两个静态方法：
public static BeanWrapper forBeanPropertyAccess(Object target) {
//基于java自审机制
//在BeanWrapperImpl定义了BeanPropertyHandler内部类，持有PropertyDescriptor
return new BeanWrapperImpl(target);
}
public static ConfigurablePropertyAccessor forDirectFieldAccess(Object target) {
//直接操作Field
//在DirectFieldAccessor定义了FieldPropertyHandler内部类，持有一个Field
return new DirectFieldAccessor(target);
}
FrameworkServlet的initServletBean
protected final void initServletBean() throws ServletException {
...
try {
//初始化springMVC的ioc容器(子容器)
//spring ioc根容器已经在ContextLoadListener中创建并初始化完毕
this.webApplicationContext = initWebApplicationContext();
//空方法
initFrameworkServlet();
} catch (ServletException | RuntimeException ex) {
...
}
...
}
FrameworkServlet的initWebApplicationContext
protected WebApplicationContext initWebApplicationContext() {
//从名称就知道，获取跟上下文，即ContextLoadListener创建初始化的ioc容器上下文
WebApplicationContext rootContext =
WebApplicationContextUtils.getWebApplicationContext(getServletContext());
//springMVC的上下文引用
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) {
//将spring的根容器设置为mvc容器的父容器
cwac.setParent(rootContext);
}
//配置刷新mvc容器
configureAndRefreshWebApplicationContext(cwac);
}
}
}
if (wac == null) {
//从servletContext中查找mvc容器
wac = findWebApplicationContext();
}
if (wac == null) {
//创建一个mvc容器并且调用configureAndRefreshWebApplicationContext进行初始化
wac = createWebApplicationContext(rootContext);
}
if (!this.refreshEventReceived) {
synchronized (this.onRefreshMonitor) {
//模板方法，调用DispatcherServlet的onRefresh
onRefresh(wac);
}
}
if (this.publishContext) {
String attrName = getServletContextAttributeName();
//将mvc容器设置到servlet上下文中
getServletContext().setAttribute(attrName, wac);
}
return wac;
}
FrameworkServlet的configureAndRefreshWebApplicationContext
protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
...
}
wac.setServletContext(getServletContext());
wac.setServletConfig(getServletConfig());
wac.setNamespace(getNamespace());
//添加监听器，容器会在某个事件完成时，发布一个Event，之后会执行已注册的监听器的方法
//观察者模式
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);
//ioc容器的创建初始化
wac.refresh();
}
DispatcherServlet的onRefresh实际调用的initStrategies
protected void initStrategies(ApplicationContext context) {
//逻辑都差不多，从context中获取，没有则创建一个默认的，这里不讨论各组件的创建过程
initMultipartResolver(context);
initLocaleResolver(context);
initThemeResolver(context);
initHandlerMappings(context);
initHandlerAdapters(context);
initHandlerExceptionResolvers(context);
initRequestToViewNameTranslator(context);
initViewResolvers(context);
initFlashMapManager(context);
}
处理请求
DispatcherServlet在web.xml中一般配置了拦截所有请求，会走doGet或doPost，最终调用FrameworkServlet的processRequest.
protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
long startTime = System.currentTimeMillis();
Throwable failureCause = null;
//从ThreadLocal中获取LocaleContext
LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
//创建一个新的LocaleContext
LocaleContext localeContext = buildLocaleContext(request);
//从ThreadLocal中获取RequestAttributes
RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
//创建一个新的ServletRequestAttributes
ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
//从ServletRequest中获取WebAsyncManager，如果为null，则创建一个并且设置进ServletRequest
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
//注册RequestBindingInterceptor
//在异步调用之前，在ThreadLocal中设置LocaleContext和RequestAttributes
//在异步调用之后，调用ThreadLoca.remove()
asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
//将之前创建的LocaleContext和RequestAttributes设置到ThreadLocal中
initContextHolders(request, localeContext, requestAttributes);
try {
//执行DispatcherServlet的doService
doService(request, response);
}
catch (ServletException | IOException ex) {
...
}
finally {
//重置 LocaleContext和requestAttributes，解除关联
resetContextHolders(request, previousLocaleContext, previousAttributes);
if (requestAttributes != null) {
requestAttributes.requestCompleted();
}
logResult(request, response, failureCause, asyncManager);
//发布ServletRequestHandledEvent事件
publishRequestHandledEvent(request, response, startTime, failureCause);
}
}
DispatcherServlet.doService()主要是设置一些request属性，并调用doDispatch()方法进行请求分发处理
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
HttpServletRequest processedRequest = request;
HandlerExecutionChain mappedHandler = null;
boolean multipartRequestParsed = false;
//从ServletRequest中获取WebAsyncManager，如果为null，则创建一个并且设置进ServletRequest
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
try {
ModelAndView mv = null;
Exception dispatchException = null;
try {
//检查是否有Multipart(文件上传)，如果有则将请求包转换为MultipartHttpServletRequest请求
processedRequest = checkMultipart(request);
multipartRequestParsed = (processedRequest != request);
//迭代所有HandlerMapping，找到HandlerMapping并与HandlerInterceptor封装成HandlerExecutionChain
//有一个返回HandlerExecutionChain就结束查找，否则直到返回null
mappedHandler = getHandler(processedRequest);
if (mappedHandler == null) {
noHandlerFound(processedRequest, response);
return;
}
//迭代所有HandlerAdapter，通过HandlerMapping找到HandlerAdapter
//主要调用HandlerAdpater.supports(HandlerMapping)
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;
}
}
//执行所有拦截器的preHandle方法，interceptorIndex(拦截器数组的下标)递增记录执行到哪个拦截器的下标
//如果有任意一个返回false，则调用执行过(interceptorIndex递减)的拦截器的afterCompletion方法，并且直接返回
if (!mappedHandler.applyPreHandle(processedRequest, response)) {
return;
}
//执行HandlerAdapter处理请求，并且返回一个ModelAndView
mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
//判断当前请求是否开启了异步请求，如果开启，则直接返回，之后调用finally里的方法
//故不执行接下来的拦截器的postHandle和afterCompletion方法
if (asyncManager.isConcurrentHandlingStarted()) {
return;
}
//没有视图名称则配置一个默认的
applyDefaultViewName(processedRequest, mv);
//执行所有拦截器的postHandle，因为到这一步说明所有拦截器的返回的true
mappedHandler.applyPostHandle(processedRequest, response, mv);
}
catch (Exception ex) {
...
}
//调用DispatcherServlet的processDispatchResult
processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
}
catch (Exception ex) {
//出任何异常，都回执行拦截器的afterCompletion方法
triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
}
finally {
if (asyncManager.isConcurrentHandlingStarted()) {
if (mappedHandler != null) {
//迭代执行所有AsyncHandlerInterceptor的afterConcurrentHandlingStarted方法
mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
}
}
else {
if (multipartRequestParsed) {
cleanupMultipart(processedRequest);
}
}
}
}
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
@Nullable Exception exception) throws Exception {
boolean errorView = false;
if (exception != null) {
if (exception instanceof ModelAndViewDefiningException) {
logger.debug("ModelAndViewDefiningException encountered", exception);
mv = ((ModelAndViewDefiningException) exception).getModelAndView();
} else {
//如果异常不是ModelAndViewDefiningException类型，则用异常解析器解析获取ModelAndView
Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
mv = processHandlerException(request, response, handler, exception);
errorView = (mv != null);
}
}
if (mv != null && !mv.wasCleared()) {
//视图渲染
render(mv, request, response);
if (errorView) {
WebUtils.clearErrorRequestAttributes(request);
}
} else {
if (logger.isTraceEnabled()) {
logger.trace("No view rendering, null ModelAndView returned.");
}
}
//判断当前请求是否开启了异步请求，如果是则直接返回，不执行下面的逻辑
if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
return;
}
//执行所有拦截器的afterCompletion方法
if (mappedHandler != null) {
mappedHandler.triggerAfterCompletion(request, response, null);
}
}