Spring MVC执行流程解析

爱被打了一巴掌 2023-10-01 09:53 19阅读 0赞

### 一、Spring MVC的执行流程 ###

上面介绍了Spring MVC的使用，配置了一个DispatcherServlet作为所有请求的入口，DispatcherServlet继承自抽象类FrameworkServlet，而FrameworkServlet又继承自HttpServlet，所有当有请求进来时，会先进入到FrameworkServlet的service()方法中，而在该方法中又会去调用父类HttpServlet的service()方法，该类的方法在[《从Servlet到Spring MVC》][Servlet_Spring MVC]中已经介绍过了，它会根据不同的请求去调用doGet()、doPost()等方法

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);
       }
    }

而FrameworkServlet中全部实现了这些doXxx()方法，而在这些doXxx()方法中，又都会去调用processRequest()方法

protected final void doGet(HttpServletRequest request, HttpServletResponse response)
          throws ServletException, IOException {
        
    
       processRequest(request, response);
    }
    
    /**
     * Delegate POST requests to {@link #processRequest}.
     * @see #doService
     */
    @Override
    protected final void doPost(HttpServletRequest request, HttpServletResponse response)
          throws ServletException, IOException {
        
    
       processRequest(request, response);
    }

在processRequest()方法中，除了加载一些上下文信息、绑定参数之后，最核心的就是去调用DispatcherServlet的doService()方法

protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
        
        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());
    
        initContextHolders(request, localeContext, requestAttributes);
    
        doService(request, response);
    }

在doService()方法中，会设置一些请求的参数，但最核心的是去调用doDispatch()方法，而doDispatch()才是SpringMVC处理请求最核心的方法，下面介绍一下doDispatch()方法的执行流程，以@RequestMapping注解为例，这个也是我们开发中用的最多的

#### 1.1 获取处理器执行链 ####

在doDispatch()方法中，首先会去解析请求，得到一个处理器执行链，包含了拦截器集合和处理方法，而在映射的时候，就会用得到HandlerMapping，在[《从Servlet到Spring MVC》][Servlet_Spring MVC]中，介绍了如何配置HandlerMapping，如果没有配置，SpringMVC提供了四个默认的配置

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        
        HttpServletRequest processedRequest = request;
        HandlerExecutionChain mappedHandler = null;
    
        // 进行映射
        mappedHandler = getHandler(processedRequest);
        if (mappedHandler == null) {
        
            noHandlerFound(processedRequest, response);
            return;
        }
    
    }

调用getHandler()方法就是去遍历所有的映射器处理器，看哪个能根据请求的url匹配到处理器方法

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        
        if (this.handlerMappings != null) {
        
            /** 拿到所有handlerMappings （容器启动阶段初始化：拿到所有实现了HandlerMapping的Bean）
           * @see DispatcherServlet#initHandlerMappings
           * 测试发现： 不同的HandlerMapping可以有相同path, 谁先解析到就用哪个
           * */
            for (HandlerMapping mapping : this.handlerMappings) {
        
                HandlerExecutionChain handler = mapping.getHandler(request);
                if (handler != null) {
        
                    return handler;
                }
            }
        }
        return null;
    }

##### 1.1.1 获取处理器 #####

调用getHandlerInternal()方法来获取处理器

public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        
        Object handler = getHandlerInternal(request);
        if (handler == null) {
        
            handler = getDefaultHandler();
        }
        if (handler == null) {
        
            return null;
        }
    	……
    }

首先获取request请求中的url，然后调用lookupHandlerMethod()去匹配

protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
        
        // 通过UrlPathHelper对象，用于来解析从们的request中解析出请求映射路径
        String lookupPath = initLookupPath(request);
        this.mappingRegistry.acquireReadLock();
        try {
        
            // 通过lookupPath解析最终的handler——HandlerMethod对象
            HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
            return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
        }
        finally {
        
            this.mappingRegistry.releaseReadLock();
        }
    }

在lookupHandlerMethod()中，根据url来匹配mappingRegistry.pathLookup，pathLookup是一个MultiValueMap，它最大的特点是value可以重复，所以同一个url可能会匹配到多个RequestMappingInfo

**pathLookup的数据，是在SpringMVC容器启动的时候，就回去加载解析的，以@RequestMapping注解为例，在Bean实例化的过程中，就回去解析类中的方法是否有@RequestMapping注解，然后拼接url作为pathLookup的key，将类以及方法封装成RequestMappingInfo**

如果通过pathLookup找到了url相匹配的处理器，这个时候还是不够，还需要去解析@RequestMapping注解中的mthod、header等属性是否匹配，RequestMappingInfo中包含了@RequestMapping注解所有配置的条件匹配器，比如ParamsRequestCondition、HeadersRequestCondition等

protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
        
        List<Match> matches = new ArrayList<>();
        // pathLookup<path,RequestMappingInfo>会在初始化阶段解析好
        List<T> directPathMatches = this.mappingRegistry.getMappingsByDirectPath(lookupPath);
        if (directPathMatches != null) {
        
            // 如果根据path能直接匹配的RequestMappingInfo 则用该mapping进行匹配其他条件(method、header等）
            addMatchingMappings(directPathMatches, matches, request);
        }
        if (matches.isEmpty()) {
        
            // 如果无path匹配，用所有的RequestMappingInfo  通过AntPathMatcher匹配
            addMatchingMappings(this.mappingRegistry.getRegistrations().keySet(), matches, request);
        }
        ……
    }

如果直接通过url没有在pathLookup找到，则会去调用getMatchingMapping()方法，通过pathMatcher来匹配，pathMatcher是一个AntPathMatcher类的实例，提供了按照通配符`? * {`匹配的逻辑

如果匹配到多个按照`? > * > {} >**`进行排序，然后取最匹配的那一个

protected String getMatchingMapping(String pattern, HttpServletRequest request) {
        
       String lookupPath = this.pathHelper.getLookupPathForRequest(request);
       String match = (this.pathMatcher.match(pattern, lookupPath) ? pattern : null);
       if (match != null) {
        
          this.matches.add(match);
       }
       return match;
    }

##### 1.1.2 封装处理器链 #####

得到处理器之后，还需要取获取配置的拦截器，然后封装成一个执行器链

调用getHandlerExecutionChain()，首先将处理器封装成一个HandlerExecutionChain，然后遍历配置的所有拦截器，只有与当前处理器匹配的，就加入到HandlerExecutionChain的interceptorList中，在执行执行器的方法前后，会调用拦截器的方法

protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
        
        HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
                                       (HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
    
        for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
        
            if (interceptor instanceof MappedInterceptor) {
        
                MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
                if (mappedInterceptor.matches(request)) {
        
                    chain.addInterceptor(mappedInterceptor.getInterceptor());
                }
            }
            else {
        
                chain.addInterceptor(interceptor);
            }
        }
        return chain;
    }

#### 1.2 获取处理器适配器 ####

获取完处理器之后，就要为处理器匹配最合适的适配器，那么适配器是干嘛的，简单的来说就是解析参数的。

以@RequestMapping为例，它的方法参数，可以通过@RequestBody、@RequestParam等注解来获取参数，那么肯定就要有能够解析这些注解的适配器

如果没有通过Spring MVC的配置文件进行配置，默认有HttpRequestHandlerAdapter、SimpleControllerHandlerAdapter、RequestMappingHandlerAdapter和HandlerFunctionAdapter四种

寻找最合适的处理器适配器也很简单，遍历所有的是适配器，然后调用它们的support()方法进行匹配

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
        
       if (this.handlerAdapters != null) {
        
          for (HandlerAdapter adapter : this.handlerAdapters) {
        
             if (adapter.supports(handler)) {
        
                return adapter;
             }
          }
       }
    }

supports()的方法也很简单，以HttpRequestHandlerAdapter为例：

只需要判断当前处理器是不是HttpRequestHandler的实现类即可，而RequestMappingHandlerAdapter的supports()方法永远返回true

public boolean supports(Object handler) {
        
       return (handler instanceof HttpRequestHandler);
    }

#### 1.3 执行处理器方法 ####

在执行处理器的方法前，首先会去执行拦截器的前置方法

// 前置拦截器
    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
        
        // 返回false就不进行后续处理了
        return;
    }
    
    boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
        
        for (int i = 0; i < this.interceptorList.size(); i++) {
        
            HandlerInterceptor interceptor = this.interceptorList.get(i);
            if (!interceptor.preHandle(request, response, this.handler)) {
        
                triggerAfterCompletion(request, response, null);
                return false;
            }
            this.interceptorIndex = i;
        }
        return true;
    }
    
    void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) {
        
        for (int i = this.interceptorIndex; i >= 0; i--) {
        
            HandlerInterceptor interceptor = this.interceptorList.get(i);
            interceptor.afterCompletion(request, response, this.handler, ex);
        }
    }

调用处理器的handle()方法，然后调用invokeHandlerMethod()方法设置一些常用的配置，比如：请求参数解析器、返回参数解析器、数据绑定器等，然后调用ServletInvocableHandlerMethod的invokeAndHandle()方法，执行处理器方法

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
        
        ModelAndView mv = null;
        mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
        ……
    }
    
    protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
                                               HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
        
        // 把我们的请求req resp包装成 ServletWebRequest
        ServletWebRequest webRequest = new ServletWebRequest(request, response);
        // 获取容器中全局配置的InitBinder和当前HandlerMethod所对应的Controller中
        // 配置的InitBinder，用于进行参数的绑定
        WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
    
        // 获取容器中全局配置的ModelAttribute和当前HandlerMethod所对应的Controller 中配置的ModelAttribute，
        // 这些配置的方法将会在目标方法调用之前进行调用
        ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
    
        // 封装handlerMethod，会在调用前解析参数、调用后对返回值进行处理
        ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
        if (this.argumentResolvers != null) {
        
            // 让invocableMethod拥有参数解析能力
            invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
        }
        if (this.returnValueHandlers != null) {
        
            // 让invocableMethod拥有返回值处理能力
            invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
        }
        // 让invocableMethod拥有InitBinder解析能力
        invocableMethod.setDataBinderFactory(binderFactory);
        // 设置ParameterNameDiscoverer，该对象将按照一定的规则获取当前参数的名称
        invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
        // ModelAndView处理容器
        ModelAndViewContainer mavContainer = new ModelAndViewContainer();
        // 将request的Attribute复制一份到ModelMap
        mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
        // *调用我们标注了@ModelAttribute的方法,主要是为我们的目标方法预加载
        modelFactory.initModel(webRequest, mavContainer, invocableMethod);
        // 重定向的时候，忽略model中的数据 默认false
        mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
    
        // *对请求参数进行处理，调用目标HandlerMethod，并且将返回值封装为一个ModelAndView对象
        invocableMethod.invokeAndHandle(webRequest, mavContainer);
    
        // 对封装的ModelAndView进行处理，主要是判断当前请求是否进行了重定向，如果进行了重定向，
        // 还会判断是否需要将FlashAttributes封装到新的请求中
        return getModelAndView(mavContainer, modelFactory, webRequest);
    }

##### 1.1.1 请求参数解析 #####

在执行处理器方法之前，需要先解析参数，得到处理器方法参数列表的参数值

参数解析的时候，先获取方法的参数列表，然后遍历这些参数，在遍历这些参数的时候，需要添加ParameterNameDiscoverer对象，才能得到参数的名称

然后获取所有的参数解析器，判断是否可以解析当前参数，以RequestParamMethodArgumentResolver参数解析器为例，就是判断当前参数是否有@RequestParam注解，如果可以解析，就直接调用resolveArgument()进行解析和数据绑定

protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
                                               Object... providedArgs) throws Exception {
        
        // 获取目标方法参数的描述数组对象
        MethodParameter[] parameters = getMethodParameters();
        //用来初始化我们对应参数名称的参数值得数组
        Object[] args = new Object[parameters.length];
        //循环我们得参数名数组
        for (int i = 0; i < parameters.length; i++) {
        
            MethodParameter parameter = parameters[i];
            //为我们得MethodParameter设置参数名称探测器对象
            parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
            args[i] = findProvidedArgument(parameter, providedArgs); // providedArgs
            if (args[i] != null) {
        
                continue;
            }
            // * 获取所有的参数解析器，然后筛选出合适的解析器
            if (!this.resolvers.supportsParameter(parameter)) {
        
                throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
            }
            // 通过上面筛选的 参数解析器来解析我们的参数
            args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
        }
        return args;
    }

##### 1.1.2 执行处理器方法 #####

解析完参数之后，利用反射，调用处理器的方法

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);
    }

##### 1.1.3 返回参数解析 #####

执行完处理器的方法之后，会得到返回值，返回值可能是Json，也可以能是ModelAndView，把返回值封装在ModelAndViewContainer中

public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
                                Object... providedArgs) throws Exception {
        
    
        /*真正的调用我们的目标对象 很重要 很重要*/
        Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
        ……
        // 遍历当前容器中所有ReturnValueHandler，判断哪种handler支持当前返回值的处理，
        // 如果支持，则使用该handler处理该返回值
        this.returnValueHandlers.handleReturnValue(
            returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
    }

最后，调用getModelAndView()处理之前的ModelAndViewContainer，封装成一个ModelAndView对象

// 对封装的ModelAndView进行处理，主要是判断当前请求是否进行了重定向，如果进行了重定向，
    // 还会判断是否需要将FlashAttributes封装到新的请求中
    return getModelAndView(mavContainer, modelFactory, webRequest);

#### 1.4 视图解析 ####

执行完处理器方法之后，接着是去执行所有拦截器的postHandle()方法

mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    
    // 如果mv有  视图没有，给你设置默认视图
    applyDefaultViewName(processedRequest, mv);
    //后置拦截器
    mappedHandler.applyPostHandle(processedRequest, response, mv);
    
    void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
        throws Exception {
        
    
        for (int i = this.interceptorList.size() - 1; i >= 0; i--) {
        
            HandlerInterceptor interceptor = this.interceptorList.get(i);
            interceptor.postHandle(request, response, this.handler, mv);
        }
    }

最后才是去渲染视图，在render()方法中，调用resolveViewName()方法去解析视图，然后返回一个View对象，最后调用View的render()方法去渲染视图

// 渲染视图
    processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    
    private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
                                       @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
                                       @Nullable Exception exception) throws Exception {
        
        if (mv != null && !mv.wasCleared()) {
        
            // 解析、渲染视图
            render(mv, request, response);
            if (errorView) {
        
                WebUtils.clearErrorRequestAttributes(request);
            }
        }
    }
    
    protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
        
        // Determine locale for request and apply it to the response.
        Locale locale =
            (this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale());
        response.setLocale(locale);
        View view;
        String viewName = mv.getViewName();
        if (viewName != null) {
        
            // 解析视图名
            view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
        }
        if (mv.getStatus() != null) {
        
            response.setStatus(mv.getStatus().value());
        }
        view.render(mv.getModelInternal(), request, response);
    }

[Servlet_Spring MVC]: https://blog.csdn.net/sermonlizhi/article/details/121976310