Spring 源码解析之HandlerMapping源码解析

Posted 2023-01-15 夜宿山寺

Spring 源码解析之HandlerMapping源码解析(一)

前言

这个是spring源码解析的第一篇，全文围绕着DispatcherServlet进行展开，Spring 的初始化基本都是通过DispatcherServlet进行初始化的，Spring boot除外，Spring boot是先初始化一个容器之后再初始化的DispatcherServlet，本文首先介绍Spring的HandlerMapping,本文的主要流程围绕着请求流程展开，而不是初始化流程，后续会按照流程的形式对源码进行解读，个人感觉这种方式比较容易理解。阅读源码的原因就是想了解Spring每个流程的实现，以及学习到更深层次的东西。

1.HandlerMapping功能分析

HandlerMapping是spring中最重要的一个类,主要功能就是为请求找到合适的处理器，现在Controller只是处理器的一种，目前我们自己公司自己实现了一套框架，前端js可以直接调用后端 soa service，忽略controller的存在，适合一些无用户状态的场景,比如说rest接口。

先来介绍下目前spring 已经提供的handlermapping

1.BeanNameUrlHandlerMapping

请求路径到bean name的映射

2.SimpleUrlHandlerMapping

最原始的spring使用方式，根struts差不多，通过配置请求路径对应处理的controller类，如下面例子

<bean id="simpleUrlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="mappings">
<props>
    <prop key="/listCourses.go">listCoursesController</prop>
    <prop key="/login.go">loginController</prop>
<props>
<property>
<bean>

3.ControllerBeanNameHandlerMapping

This is similar to BeanNameUrlHandlerMapping but doesn’t expect bean names to follow the URL convention: It turns plain bean names into URLs by prepending a slash and optionally applying a specified prefix and/or suffix. However, it only does so for well-known controller types, as listed above (analogous to ControllerClassNameHandlerMapping).

4.ControllerClassNameHandlerMapping

这个主要是类名映射，看看下面就知道了
* WelcomeController -> /welcome*
* HomeController -> /home*
这种方式通常搭配着MultiActionController ，比如/abc/to_add.do 这个表示调用AbcController.java下的to_add的方法。前提是AbcController.java继承MultiActionController

5.RequestMappingHandlerMapping（3.2之前是使用DefaultAnnotationHandlerMapping 这个去处理，但是后来弃用了）

这个就是现在默认的请求匹配方式，通过@RequestMapping 注解来决定调用方法和具体的类，也是最常用的一种。

DispatcherServlet初始化的时候会调用initHandlerMappings()进行初始化

protected void initStrategies(ApplicationContext context) 
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        initHandlerMappings(context);
        initHandlerAdapters(context);
        initHandlerExceptionResolvers(context);
        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    
  //初始化handlermapping
  private void initHandlerMappings(ApplicationContext context) 
        this.handlerMappings = null;
        //判断是否默认添加所有的HandlerMappings,初始值是默认添加的
        if (this.detectAllHandlerMappings) 
            // Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
            Map<String, HandlerMapping> matchingBeans =
                    BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
            if (!matchingBeans.isEmpty()) 
                this.handlerMappings = new ArrayList<HandlerMapping>(matchingBeans.values());
                // We keep HandlerMappings in sorted order.
                //通过@order注解去排序
                AnnotationAwareOrderComparator.sort(this.handlerMappings);
            
        
        //如果不是默认添加所有的，那么就去context中找一个声明的bean
        else 
            try 
                HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
                this.handlerMappings = Collections.singletonList(hm);
            
            catch (NoSuchBeanDefinitionException ex) 
                // Ignore, we'll add a default HandlerMapping later.
            
        

        // Ensure we have at least one HandlerMapping, by registering
        // a default HandlerMapping if no other mappings are found.
        //如果上面两步没有找到可以使用的handlerMapping，那么就采用默认的handlerMapping
        //默认的HandlerMapping都定义在了DispatcherServlet.properties中，大致定义了如下两个
        //org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\\
    //org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping
        if (this.handlerMappings == null) 
            this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
            if (logger.isDebugEnabled()) 
                logger.debug("No HandlerMappings found in servlet '" + getServletName() + "': using default");
            
        
    

下面是初始化之后的一个状态，我这边使用的是spring boot启动，大致会初始化10个handlermapping，如下图所示：

下图可以看到，默认的RequestMappingHandlerMapping已经把所有路径映射进去,相关的spring拦截器也放到了RequestMappingHandlerMapping中，由此说来，拦截器其实是跟RequestMappingHandlerMapping进行关联的。

2. HandlerMapping流程分析

HandlerMapping流程需要弄清楚几个类的定义:

1. HandlerExecutionChain

(Handler execution chain, consisting of handler object and any handler interceptors. Returned by HandlerMapping’s)根据英文的翻译来说HandlerExecutionChain是 handler的执行链，由一些handler object 和 handler interceptors组成,这个里面包含了interceptor的所有执行，包括这个请求是否通过preHandle，大致逻辑如下

         boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception 
             //获取所有拦截器进行遍历
            HandlerInterceptor[] interceptors = getInterceptors();
            if (!ObjectUtils.isEmpty(interceptors)) 
                for (int i = 0; i < interceptors.length; i++) 
                    HandlerInterceptor interceptor = interceptors[i];
                    //判断拦截器是否可以继续执行
                    if (!interceptor.preHandle(request, response, this.handler)) 
                        triggerAfterCompletion(request, response, null);
                        return false;
                    
                    this.interceptorIndex = i;
                
            
            return true;
        

2. HandlerAdapter

HandlerAdapter 这个是spring的核心功能，所有的请求对应Controller方法都是通过HandlerAdapter 大该作用就是进行方法映射和调用并且返回结果，对应spring中正常用法实现类是HttpRequestHandlerAdapter,一般基本的http请求都是通过这个进行处理的。

请求处理流程分析

先来看看这段代码，spring的核心。所有请求调用都是通过这里进行的，可以说是关键路径

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 
                //优先判断一下是不是文件上传的request
                processedRequest = checkMultipart(request);
                multipartRequestParsed = (processedRequest != request);
                //获取到相应处理该request的HandlerExecutionChain，
                //静态资源一般都是由ResourceHttpRequestHandler进行处理的
                // Determine handler for the current request.
                mappedHandler = getHandler(processedRequest);
                //如果没有找到相应的handler，这里就是大家经常从日志里面看到的这段英文No mapping found for HTTP request with URI
                //这个地方没有找到相应的处理handler有两种处理方式，一种（默认）返回404的状态码，一种是直接抛出异常，第二种方式需要设置初始化参数的
                //throwExceptionIfNoHandlerFound 这个参数设置成ture即可
                if (mappedHandler == null || mappedHandler.getHandler() == null) 
                    noHandlerFound(processedRequest, response);
                    return;
                
                //通过handler找到对应处理的handlerAdapter
                // Determine handler adapter for the current request.
                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 (logger.isDebugEnabled()) 
                        logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                    
                    if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) 
                        return;
                    
                
                //执行HandlerExecutionChain所有Interceptor中的preHandle方法，一旦有一个返回了false那么请求就不进行继续处理
                //这也是为什么preHandle 返回了false就可以拦截用户继续执行了
                if (!mappedHandler.applyPreHandle(processedRequest, response)) 
                    return;
                
                //实际调用的handler，如果是http请求会调用相应的HandlerMethod 这里里面包含了具体的方法，通过反射调用，如果有返回的视图，那么ModelAndView会返回相应的视图对象，如果只是普通请求或者json请求会返回null
                // Actually invoke the handler.
                mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

                if (asyncManager.isConcurrentHandlingStarted()) 
                    return;
                
                //这块会校验是否添加了视图，如果没有视图就会添加一个默认的视图，通过url的规则来拼凑
                applyDefaultViewName(processedRequest, mv);
                //这块逻辑是执行HandlerExecutionChain所有Interceptor中的postHandle方法，从这块代码看来，postHandle的执行时机是在执行完方法后没有把响应写入到response中执行的
                mappedHandler.applyPostHandle(processedRequest, response, mv);
            
            catch (Exception ex) 
                dispatchException = ex;
            
            //处理请求，把参数都写入到request里面
            processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
        
        catch (Exception ex) 
            triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
        
        catch (Error err) 
            triggerAfterCompletionWithError(processedRequest, response, mappedHandler, err);
        
        finally 
            if (asyncManager.isConcurrentHandlingStarted()) 
                // Instead of postHandle and afterCompletion
                if (mappedHandler != null) 
                    //最后调用HandlerExecutionChain所有Interceptor中的postHandle方法
                    mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
                
            
            else 
                // Clean up any resources used by a multipart request.
                if (multipartRequestParsed) 
                    cleanupMultipart(processedRequest);
                
            
        
    

下图是上述代码的一个大致流程

总结

遗留问题如下：
1. getHandler(processedRequest) 这个方法是如何查找到对应处理的HandlerExecutionChain和HandlerMapping的，比如说静态资源的处理和请求的处理肯定是不同的HandlerMapping
2. getHandlerAdapter(mappedHandler.getHandler());如果取到对应的HandlerAdapter

这个是解析的第一篇，如果在流程活着代码描述上不准确的，望大家多多指教