SpringMVC执行流程（面试题）

SpringMVC是Spring框架中的组成成员之一，是一个针对于Web开发的一个类似于Servlet技术的一个web应用框架，它包含了MVC架构的特点，让Web变得更加简单。在SpringMVC框架中，一个比较核心的组件就是他的前端控制器，这个前端控制器就是SpringMVC开发的核心部分。前端控制器负责接收客户端的全部请求，用户把请求给了前端控制器之后，前端控制器把请求转发给我们Controller处理器对象，最后COntroller处理请求。

一、Web开发的MVC架构

二、SpringMVC执行流程

1. 用户发送请求到前端控制器DispatcherServlet

2. 前端控制器请求处理映射器去查找处理器Handler

3. 找到处理器以后处理器映射器向前端控制器返回一个执行链HandlerExecuteChina

4. 前端控制器请求处理器适配器HandlerAdapter

5. 处理器适配器执行处理器（Handler）

6. 处理器执行完后给处理器适配器返回ModelAndView

7. 处理器适配器向前端控制器返回ModelAndView

8. 前端控制器请求视图解析器（ViewResolver）去进行视图解析

9. 视图解析器向前端控制器返回View

10. 前端控制器对视图进行渲染

11. 视图将渲染结果返回给前端控制器

12. 前端控制器向用户响应

三、SpringMVC源码分析

1. SpringMVC初始化过程

1) DispatcherServlet 继承关系
   - DispatcherServlet extends FrameworkServlet
     //FrameworkServlet主要用于初始化和框架相关的工作
     //DispatcherServlet主要用于和当前项目相关的工作
   - FrameworkServlet extends HttpServletBean
   - HttpServletBean extends HttpServlet
2) HttpServlet生命周期：实例化、初始化、服务、销毁
   HttpServlet继承GenericServlet.
   在GenericServlet中有两个初始化方法： init(config) , init()
- 查看GenericServlet的初始化方法：
public void init(ServletConfig config) throws ServletException {
   this.config = config;
   this.init();
}
- 无参的init()方法是一个空实现方法
public void init() throws ServletException {
}
3) 在HttpServlet中，我们发现并没有覆盖init方法。
   而是在HttpServletBean中重写的init方法：
   public final void init() throws ServletException {
        //约169行
          // Let subclasses do whatever initialization they like.
          initServletBean();
       }
   当前HttpServletBean中的initServletBean是一个空实现:
   protected void initServletBean() throws ServletException {}
4) HttpServletBean的子类FrameworkServlet重写了initServletBean方法：
    protected final void initServletBean() throws ServletException {
        this.webApplicationContext = initWebApplicationContext();//初始化springMVC的IOC容器
        initFrameworkServlet();//此方法目前是一个空实现
   }
5) 查看initWebApplicationContext():
    protected WebApplicationContext initWebApplicationContext() {
      onRefresh(wac); //这句话上面有很多代码，完成的工作就是初始化springMVC的IOC容器的过程。那么容器创建好了之后需要"刷新"
      return wac;
   }
6) 查看onRefresh方法：
    protected void onRefresh(ApplicationContext context) {
      // For subclasses: do nothing by default.
   }
   我们发现FrameworkServlet中的onRefresh方法是空实现。
   因此，我们需要去查看子类：DispatcherServlet中的onRefresh方法

7) 查看DispatcherServlet中的onRefresh()：

   protected void onRefresh(ApplicationContext context) {
      initStrategies(context);//初始化策略方法
   }

8) 查看initStrategies(context)方法：

   protected void initStrategies(ApplicationContext context) {
          initMultipartResolver(context);
          initLocaleResolver(context);
          initThemeResolver(context);
          initHandlerMappings(context);   //一个请求如何映射到一个controller的一个方法上去
          initHandlerAdapters(context);   //请求处理前，需要各种准备工作：请求参数设置，pathVariable设置自，各种ServletApi设置等等。视图的统一处理：逻辑视图渲染？转发？重定向？JSON？
          initHandlerExceptionResolvers(context);
          initRequestToViewNameTranslator(context);
          initViewResolvers(context);
          initFlashMapManager(context);
   }

2. 当一个请求到来时，springMVC经历了哪些过程?

1. 一个请求如何对应一个Controller，以及如何找到对应的响应方法
   2. 一个请求如何去获取请求参数、路径参数、ServletAPI、请求体参数等等
   3. 控制器方法处理完成之后，视图如何解析并返回
1) 查看initHandlerMappings()方法：
private void initHandlerMappings(ApplicationContext context) {
    //获取默认的映射策略
    this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
}
2) 查看getDefaultStrategies()方法：
protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
    //获取默认的handler映射策略
    //从常量DEFAULT_STRATEGIES_PATH指定的文件中加载默认的映射策略配置类（有三个)
    ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
    defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
    //DEFAULT_STRATEGIES_PATH常量的值如下：
    //private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties";
3) 因此查看DispatcherServlet.properties文件：
org.springframework.web.servlet.HandlerMapping=
    org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping
  org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping
   org.springframework.web.servlet.function.support.RouterFunctionMapping
4) 查看BeanNameUrlHandlerMapping
   我们发现当前类中只有一个方法。我们需要去寻找它的抽象父类：AbstractDetectingUrlHandlerMapping
   protected String[] determineUrlsForHandler(String beanName)
   因此，查看AbstractDetectingUrlHandlerMapping:
   其中有一个方法：detectHandlers():
   protected void detectHandlers() throws BeansException {
        //SpringMVC的IOC容器
          ApplicationContext applicationContext = obtainApplicationContext();
          //获取所有的beanName
          String[] beanNames = (this.detectHandlersInAncestorContexts ?
                BeanFactoryUtils.beanNamesForTypeIncludingAncestors(applicationContext, Object.class) :
                applicationContext.getBeanNamesForType(Object.class));

          //通过迭代，尽可能的让url和beanName进行绑定
          for (String beanName : beanNames) {
             String[] urls = determineUrlsForHandler(beanName);
             if (!ObjectUtils.isEmpty(urls)) {
                // URL paths found: Let's consider it a handler.
                registerHandler(urls, beanName);
             }
          }
       }

5) 查看RequestMappingHandlerMapping
- 首先搞清楚继承关系：
AbstractHandlerMethodMapping<T> extends ... implements InitializingBean
此处实现了InitializingBean，那么必须要实现其中的唯一的一个方法：afterPropertiesSet()
代码如下：
public void afterPropertiesSet() {
    initHandlerMethods();
}
因此，需要去查看initHandlerMethods():
protected void initHandlerMethods() {
    for (String beanName : getCandidateBeanNames()) {
        if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
            processCandidateBean(beanName);
        }
    }
    handlerMethodsInitialized(getHandlerMethods());
}
继续查看processCandidateBean(beanName):
protected void processCandidateBean(String beanName) {
    beanType = obtainApplicationContext().getType(beanName);
    if (beanType != null && isHandler(beanType)) {
        detectHandlerMethods(beanName);
    }
}
继续查看detectHandlerMethods(beanName):
protected void detectHandlerMethods(Object handler) {
        Class<?> userType = ClassUtils.getUserClass(handlerType);
        Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
                (MethodIntrospector.MetadataLookup<T>) method -> {
                    try {
                        return getMappingForMethod(method, userType);
                    }
                    catch (Throwable ex) {
                        //我们自定义的Controller经常报如下异常信息：
                        throw new IllegalStateException("Invalid mapping on handler class [" +
                                userType.getName() + "]: " + method, ex);
                    }
                });
        methods.forEach((method, mapping) -> {
            Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
            //将一个请求和特定的bean的特定的method绑定，springmvc提供了一个MappingRegistry进行存放
            registerHandlerMethod(handler, invocableMethod, mapping);
        });
    }
}

3. 当initHandlerMapping完成之后，那么请求到来了，找到对应的handler了。

接下来我们需要去做一些准备工作：请求参数、请求体参数、属性域、路径参数等等
1) 再次回到initHandlerAdapters(context):
- HandlerAdapter 我们称之为Handler的适配器。就是在原始的Handler上面附加了一些功能，这些功能就是参数绑定等
- 当一个请求发送给Servlet时，servlet的服务方法(也就是service方法)会被调用
① HttpServlet中有service方法；它的子类HttpServletBean中并没有service方法。
② HttpServlet除了有service方法，还有各种do方法。
③ HttpServletBean的子类：FrameworkServlet中并没有实现service，而是实现了各种do开头的方法，例如：doGet,doPost,doTrace等等
而这些方法都有一个共同的特点：他们都调用了处理请求方法processRequest：
以doDelete为例：
protected final void doDelete(HttpServletRequest request, HttpServletResponse response)
         throws ServletException, IOException {
      processRequest(request, response);
}
④ 因此，查看processRequest方法：
protected final void processRequest(){
    doService(request, response);
}
⑤ 查看doService方法，我们发现是抽象的：
protected abstract void doService(...) throws Exception;
⑥ 因此，去它的子类DispatcherServlet中查看doservice的实现：
protected void doService(HttpServletRequest request, HttpServletResponse response) {
    doDispatch(request, response);
}
⑦ 查看doDispatch(request, response)方法:
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
   //大约1033行
    processedRequest = checkMultipart(request);//判断是否需要进行文件上传处理
⑧ 顺便查看一下springmvc如何能够做到文件上传的：
   查看checkMultipart方法：
   protected HttpServletRequest checkMultipart(HttpServletRequest request) throws MultipartException {
          //判断当前支持文件上传(也就是说有文件上传的处理器，并且当前的请求确实是一个文件上传的请求)
          if (this.multipartResolver != null && this.multipartResolver.isMultipart(request)) {
            processedRequest = checkMultipart(request);
          }
          //大约1199行：
          //处理文件上传功能:
          return this.multipartResolver.resolveMultipart(request);
⑨ 查看resolveMultipart(request)方法:
   此时定位到文件上传的顶层接口：MultipartResolver上了：
   public interface MultipartResolver {
       MultipartHttpServletRequest resolveMultipart(HttpServletRequest request);
   }
   我们需要查看它的实现类：CommonsMultipartResolver的resolveMultipart方法实现：
⑩ 查看CommonsMultipartResolver的resolveMultipart方法实现:
    public MultipartHttpServletRequest resolveMultipart(...){
        MultipartParsingResult parsingResult = parseRequest(request);
    }
⑩① 查看parseRequest：
   springmvc底层使用的是apache的commons-fileupload组件完成文件上传。
   因此，可以说springmvc的文件上传功能其实是commons-fileupload的封装
   protected MultipartParsingResult parseRequest(HttpServletRequest request) throws MultipartException {
          String encoding = determineEncoding(request);
          FileUpload fileUpload = prepareFileUpload(encoding);
          try {
              //在commons-fileupload组件中，每一个请求项都被封装成一个FileItem
              //如果是普通的表单项，那么fileitem的isFormField()返回true
             List<FileItem> fileItems = ((ServletFileUpload) fileUpload).parseRequest(request);
             //解析每一个FileItem
             return parseFileItems(fileItems, encoding);
          }
⑩② 查看parseFileItems():
   protected MultipartParsingResult parseFileItems(List<FileItem> fileItems){
        for (FileItem fileItem : fileItems) {
             if (fileItem.isFormField()) {//普通的请求域，例如昵称文本框发送过来的数据
                 value = fileItem.getString(partEncoding);
             }else{//文件域，例如上传的头像的组件 <input type="file" ../>
                 //如果是文件域，那么需要分两个步骤完成：1.拿到真实的上传文件数据 2.封装成springmvc提供的Multipart
                 CommonsMultipartFile file = createMultipartFile(fileItem);
             }
        }
   }
⑩③ 查看createMultipartFile():
protected CommonsMultipartFile createMultipartFile(FileItem fileItem) {
    CommonsMultipartFile multipartFile = new CommonsMultipartFile(fileItem);
    return multipartFile;
}

2) 刚刚在1)中顺便查看了文件上传的实现流程。现在我们重新回到doDispatch方法:
protected void doDispatch(HttpServletRequest request, HttpServletResponse response){
    //约1036行
    // Determine handler for the current request.
    // 当前的请求由哪个handler处理
    mappedHandler = getHandler(processedRequest);
    if (mappedHandler == null) {
        noHandlerFound(processedRequest, response);//No Mapping for .....
        return;
    }
}
① 查看getHandler方法：
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    //handlerMappings在initHandlerMapping()方法中已经完成的映射
    if (this.handlerMappings != null) {
        for (HandlerMapping mapping : this.handlerMappings) {
            HandlerExecutionChain handler = mapping.getHandler(request);
            if (handler != null) {
                return handler;
            }
        }
    }
    return null;
}
② 再次回到doDispatch方法：
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
   //大约1043行
    // Determine handler adapter for the current request.
    // 根据当前请求获取adapter
    HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    //大约1056行：执行当前handler上的拦截器链的preHandle方法：
    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
        return;
    }
    //大约1060行，是handler的响应方法被执行的真实代码
    // Actually invoke the handler.
    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    //大约1068行，拦截器链的postHandle方法被执行：
    mappedHandler.applyPostHandle(processedRequest, response, mv);
    //视图统一处理 1078行
    processDispatchResult(processedRequest, response, mappedHandler, mv, dis...
③ 快速回顾拦截器的执行过程：
   在doDispatch方法中，首先preHandle：
   if (!mappedHandler.applyPreHandle(processedRequest, response)) {
       return;
   }
   如果拦截器链上的某一个拦截器的preHandle方法执行返回了false，那么取反之后，变成true，那么上一步的if成立，直接return。
   boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
          for (int i = 0; i < this.interceptorList.size(); i++) {
             HandlerInterceptor interceptor = this.interceptorList.get(i);
             //如果拦截器链上的某一个拦截器的preHandle方法执行返回了false,那么取反此处的if为true
             //那么直接触发afterCompletion
             if (!interceptor.preHandle(request, response, this.handler)) {
                triggerAfterCompletion(request, response, null);
                return false;
             }
             this.interceptorIndex = i;
          }
          return true;
       }

   反之，继续往下执行postHandle方法：
   mappedHandler.applyPostHandle(processedRequest, response, mv); //1068行
   最后进行视图处理：
   processDispatchResult(processedRequest, response, mappedHandle   //1078行
   查看processDispatchResult方法：
   //首先进行视图渲染
   render(mv, request, response);//1139行
   //然后倒序执行拦截器链的afterCompletion方法：
   mappedHandler.triggerAfterCompletion(....) //1157行
④ 再次回到DispatcherServlet的doDispatcher方法：
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
   //获取当前请求对应的handler(实际上获取到的并不是handler，而是封装了handler的一个执行路径，我们把这个执行路径称之为HandlerExecutionChain)
   HandlerExecutionChain mappedHandler = getHandler(processedRequest);
   //获取当前请求对应的Adapter
   HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
   // Actually invoke the handler.
    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    //视图处理
    processDispatchResult(processedRequest, r...);
}
⑤ 查看mv = ha.handle(processedRequest, response, mappedHandler.getHandler()):
   结果定位到顶层接口HandlerAdapter handle方法：
   public interface HandlerAdapter{
      ModelAndView handle(request....);
   }
   那么其实我们需要查看HandlerAdapter的实现类：AbstractHandlerMethodAdapter的handle方法:
⑥ 查看AbstractHandlerMethodAdapter的handle方法
public final ModelAndView handle(HttpServletRequest...){
    return handleInternal(request, response, (HandlerMethod) handler);
}
⑦ 查看handleInternal方法：我们发现AbstractHandlerMethodAdapter的这个方法是抽象的，不过还好它目前只有一个实现：
   也就是RequestMappingHandlerAdapter中的实现：
public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter{
    //大约785行：
    protected ModelAndView handleInternal(HttpServletRequest request..){
        //大约797行：
        mav = invokeHandlerMethod(request, response, handlerMethod);
    }
}
⑧ 查看invokeHandlerMethod()方法:
protected ModelAndView invokeHandlerMethod(){
    //大约893行
    invocableMethod.invokeAndHandle(webRequest, mavContainer);
}
⑨ 查看invokeAndHandle方法:
public void invokeAndHandle(Servl...){
   invocableMethod.invokeAndHandle(webRequest, mavContainer);
}
⑩ 查看invocableMethod.invokeAndHandle方法：
public void invokeAndHandle(Servl...){
    Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
}
⑩① 查看invokeForRequest方法：
public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
         Object... providedArgs) throws Exception {
    Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
    if (logger.isTraceEnabled()) {
        logger.trace("Arguments: " + Arrays.toString(args));
    }
    return doInvoke(args);
}
⑩② 查看doInvoke方法：
protected Object doInvoke(Object... args) throws Exception {
    Method method = getBridgedMethod();
    return method.invoke(getBean(), args);//通过反射技术执行getBean的method方法，传入args参数
}

4. 一个请求如何去获取请求参数、路径参数、ServletAPI、请求体参数等等

回到RequestMappingHandlerAdapter的invokeHandlerMethod方法：
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,...){
    if (this.argumentResolvers != null) {
        invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
    }
    if (this.returnValueHandlers != null) {
        invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
    }
    //方法调用之前的两个if完成了参数处理以及视图处理的处理器设置
    invocableMethod.invokeAndHandle(webRequest, mavContainer);
}
1) 查看 this.argumentResolvers -> private HandlerMethodArgumentResolverComposite argumentResolvers;
   -> HandlerMethodArgumentResolverComposite中封装了各种参数的处理：请求参数,@CookieValue,@PathVariable等
   public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgumentResolver {
       private final List<HandlerMethodArgumentResolver> argumentResolvers = new ArrayList<>();
2) 因此，查看HandlerMethodArgumentResolver的具体每一个实现：
   public interface HandlerMethodArgumentResolver
   它的实现非常多：
   AbstractCookieValueMethodArgumentResolver
   PathVariableMethodArgumentResolver
   RequestParamMethodArgumentResolver
   .....
3) 以RequestParamMethodArgumentResolver为例，获取请求参数:
   protected Object resolveName(String name, MethodParameter parameter,...){
        if (arg == null) {
             String[] paramValues = request.getParameterValues(name);
             if (paramValues != null) {
                arg = (paramValues.length == 1 ? paramValues[0] : paramValues);
             }
          }
   }