Spring MVC组件之HandlerMapping

HandlerMapping概述

HandlerMapping组件的作用解析一个个Request请求，并找到相应处理这个Request的Handler。Handler一般可以理解为Controller控制器里的一个方法。

HandlerMapping组件主要做了两件事件。

在组件初始化时，会把Request请求和对应的Handler进行注册，其实就是把Request和对应的Handler以键值对的形式存在一个map中。
解析一个个Request请求，在注册的map中找相应的handler。

在SpringMvc的源码中，HandlerMapping定义为一个接口。接口除了定义几个属性字段，只定义了一个getHandler方法。

HandlerMapping类图

从以上类图中可以看出，HandlerMapping组件主要是分了两个系列。一个系列主要继承至AbstractHandlerMethodMapping。另一个系列主要继承至AbstractUrlHandlerMapping。而AbstractHandlerMethodMapping和AbstractUrlHandlerMapping这两个抽象类又都是继承至AbstractHandlerMapping。

AbstractHandlerMapping

AbstractHandlerMapping是一个抽象类，它实现了HandlerMapping接口。AbstractHandlerMapping是一个非常基础的类，HandlerMapping的所有子类系列都是继承自它。AbstractHandlerMapping采用了模板模式进行了整体的设计，各个子类通过覆写模板方法来实现相应功能。

AbstractHandlerMappin抽象类既然继承了HandlerMapping接口，它肯定事要实现getHandler方法。在AbstractHandlerMappin类中，具体代码如下：

    @Override

    @Nullable

    public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {

        Object handler = getHandlerInternal(request);

        if (handler == null) {

           handler = getDefaultHandler();

        }

        if (handler == null) {

           return null;

        }

        // Bean name or resolved handler?

        if (handler instanceof String) {

           String handlerName = (String) handler;

           handler = obtainApplicationContext().getBean(handlerName);

    }

        // Ensure presence of cached lookupPath for interceptors and others

        if (!ServletRequestPathUtils.hasCachedPath(request)) {

           initLookupPath(request);

        }

        HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);

        if (logger.isTraceEnabled()) {

           logger.trace("Mapped to " + handler);

        }

        else if (logger.isDebugEnabled() && !DispatcherType.ASYNC.equals(request.getDispatcherType())) {

           logger.debug("Mapped to " + executionChain.getHandler());

        }

        if (hasCorsConfigurationSource(handler) || CorsUtils.isPreFlightRequest(request)) {

           CorsConfiguration config = getCorsConfiguration(handler, request);

           if (getCorsConfigurationSource() != null) {

               CorsConfiguration globalConfig = getCorsConfigurationSource().getCorsConfiguration(request);

               config = (globalConfig != null ? globalConfig.combine(config) : config);

           }

           if (config != null) {

               config.validateAllowCredentials();

           }

           executionChain = getCorsHandlerExecutionChain(request, executionChain, config);

        }

        return executionChain;

}

getHandler方法中要特别注意getHandlerInternal(request)方法，该方法是一个模板方法。在AbstractHandlerMapping类中，getHandlerInternal(request)方法只是一个抽象的方法，没有做任何的事情。该方法专门预留给AbstractHandlerMapping的子类来覆写，从而实现自己的业务逻辑。

AbstractHandlerMapping还继承自WebApplicationObjectSupport类，并重写了该父类的initApplicationContext方法。

    @Override

    protected void initApplicationContext() throws BeansException {

        extendInterceptors(this.interceptors);

        detectMappedInterceptors(this.adaptedInterceptors);

        initInterceptors();

    }

在initApplicationContext方法，定义了三个方法。

1. extendInterceptors(this.interceptors)

extendInterceptors是一个模板方法，给子类提供了一个修改this.interceptors拦截器的入口。

2.detectMappedInterceptors(this.adaptedInterceptors)

detectMappedInterceptors方法是将Spring MVC中所有MappedInterceptor类型的bean,添加到this.adaptedInterceptors的集合中。

3.initInterceptors()

initInterceptors是初始化拦截器，将所有的this.interceptors集合中的拦截器包装后，添加到this.adaptedInterceptors的集合中。

AbstractHandlerMethodMapping系列

AbstractHandlerMethodMapping

AbstractHandlerMethodMapping是一个非常重要的类，AbstractHandlerMethodMapping除了继承AbstractHandlerMapping抽象类，它还实现了InitializingBean接口。

Handler的注册

在Spring中如果一个类实现了InitializingBean接口，Spring容器就会在实例化该Bean时，会调用Bean的afterPropertiesSet方法。

AbstractHandlerMethodMapping类中，在覆写InitializingBean接口的afterPropertiesSet方法时，完成了初始化注册的工作。这也是HandlerMapping组件的第一步工作，把Request请求和对应的Handler先进行注册。

AbstractHandlerMethodMapping类的afterPropertiesSet方法具体代码如下图所示。

    @Override

    public void afterPropertiesSet() {

        initHandlerMethods();

    }

可以看出在AbstractHandlerMethodMapping类的afterPropertiesSet方法中，调用了initHandlerMethods()方法。看initHandlerMethods()方法的名称，就知道它其实是完成了初始化的工作。

    protected void initHandlerMethods() {

        for (String beanName : getCandidateBeanNames()) {

           if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {

               processCandidateBean(beanName);

           }

        }

        handlerMethodsInitialized(getHandlerMethods());

    }

在initHandlerMethods()方法中，通过getCandidateBeanNames方法，先获取Spring容器中所有的Bean的名称。过滤掉名称以” scopedTarget.”打头的Bean。通过循环再把Bean的名称传入processCandidateBean(beanName)方法。

processCandidateBean(beanName)方法主要做了三件事情。

通过Bean的名称找到Bean对应的类型。
通过isHandler方法，过滤掉不符合条件的Bean。isHandler方法是一个模板方法，具体逻辑是在子类RequestMappingHandlerMapping中实现的。isHandler方法只会选择含有@Controller和@RequestMapping注解的bean。
通过detectHandlerMethods方法，建立request请求和handler之间的对应映射关系。

detectHandlerMethods方法

detectHandlerMethods方法主要做了两件事情。

1．使用getMappingForMethod方法，通过handler找到有@RequestMapping注解的方法。在AbstractHandlerMethodMapping类中，getMappingForMethod方法在只是一个抽象方法，具体实现是在子类RequestMappingHandlerMapping类中，实现具体的业务逻辑。

2．使用registerHandlerMethod方法，将找到的方法进行注册。所谓注册其实就是将找到的HandlerMothed放到一个Map中。如果同一个HandlerMothed进行第二次注册，就会抛出异常。

Handler的查找

在AbstractHandlerMethodMapping类中，覆写了父类AbstractHandlerMapping的模板方法getHandlerInternal方法。

    protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {

        String lookupPath = initLookupPath(request);

        this.mappingRegistry.acquireReadLock();

        try {

           HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);

           return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);

        }

        finally {

           this.mappingRegistry.releaseReadLock();

        }

    }

在getHandlerInternal方法中，主要做了三件事件。

在initLookupPath方法中，把一个request转换成一个url.
再通过request和lookupPath 这两个参数,使用lookupHandlerMethod方法，找到相应的HandlerMethod。
在找到HandlerMethod对象的情况下，会调用HandlerMethod的createWithResolvedBean方法。该方法会判断这个HandlerMethod对象。是不是String 类型的。如果是String 类型则说明他只是一个Bean的名称，会根据这个Bean的名称在Spring容器中找到该Bean。根据这个Bean，会创建一个新的HandlerMethod对像返回。

RequestMappingInfoHandlerMapping

RequestMappingInfoHandlerMapping类主要是重写了父类的getMatchingMapping方法。getMatchingMapping方法会根据当前的请求，返回一个匹配了各种RequestCondition的RequestMappingInfo对象。

SpringMVC会根据这个RequestMappingInfo对象来获取对应的Handler。

RequestMappingHandlerMapping

Spring MVC容器在初始化HandlerMapping类型的组件时，最终初始化的AbstractHandlerMethodMapping系列组件，就是RequestMappingHandlerMapping。

RequestMappingHandlerMapping主要是重写了父类的三个方法。

afterPropertiesSet方法

重写了父类的初始化方法，在afterPropertiesSet方法中，创建了一个BuilderConfiguration类型的对象。然后对BuilderConfiguration对象，进行了属性的设置。

isHandler方法

主要是用于判断获取何种类型的Handler。对Handler起到一个过滤的作用，只取@Controller和@RequestMapping两种注解类型的Handler。

getMappingForMethod方法

getMappingForMethod方法主要是通过method来创建相应的RequestMappingInfo对象。程序先从method对象上获取RequestMapping注解。再从RequestMapping注解的信息，来创建“路径匹配”， ”头部匹配”， ”请求参数匹配”， ”可产生MIME匹配”， ”可消费MIME匹配”， ”请求方法匹配”,等RequestCondition接口的实例。最后组合这些RequestCondition接口实例，来创建一个RequestMappingInfo对象。SpringMVC会根据RequestMappingInfo对象来注册请求和Handler的映射关系。

RequestMappingInfo对象实现了RequestCondition接口。接口RequestCondition是Spring MVC对一个请求匹配条件的概念建模。

AbstractUrlHandlerMapping系列

AbstractUrlHandlerMapping系列从名字就可以看出，主要是处理url和handler的关系。AbstractUrlHandlerMapping类先将url和handler的映射关系存在一个Map。再通过url来获取相应的handler。

AbstractUrlHandlerMapping

AbstractUrlHandlerMapping类跟AbstractHandlerMethodMapping类一样，也继承了AbstractHandlerMapping这个抽象类。所有url跟HandlerMapping相关系列的子类，都是继承至AbstractUrlHandlerMapping这个父类。

AbstractUrlHandlerMapping同时也实现了MatchableHandlerMapping的接口。MatchableHandlerMapping接口定义了一个用于匹配的match方法。

HandlerMap的注册

在AbstractUrlHandlerMapping类中，registerHandler这个方法是专门负责对handler进行注册的。Handler的注册，其实就是把url和对应的handler存储到handlerMap这个哈希map中。

    protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {

        Assert.notNull(urlPath, "URL path must not be null");

        Assert.notNull(handler, "Handler object must not be null");

        Object resolvedHandler = handler;

        // Eagerly resolve handler if referencing singleton via name.

        if (!this.lazyInitHandlers && handler instanceof String) {

           String handlerName = (String) handler;

           ApplicationContext applicationContext = obtainApplicationContext();

           if (applicationContext.isSingleton(handlerName)) {

               resolvedHandler = applicationContext.getBean(handlerName);

           }

        }

        Object mappedHandler = this.handlerMap.get(urlPath);

        if (mappedHandler != null) {

           if (mappedHandler != resolvedHandler) {

               throw new IllegalStateException(

                       "Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +

                       "]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");

           }

        }

        else {

           if (urlPath.equals("/")) {

               if (logger.isTraceEnabled()) {

                   logger.trace("Root mapping to " + getHandlerDescription(handler));

               }

               setRootHandler(resolvedHandler);

           }

           else if (urlPath.equals("/*")) {

               if (logger.isTraceEnabled()) {

                   logger.trace("Default mapping to " + getHandlerDescription(handler));

               }

               setDefaultHandler(resolvedHandler);

           }

           else {

               this.handlerMap.put(urlPath, resolvedHandler);

               if (getPatternParser() != null) {

                  this.pathPatternHandlerMap.put(getPatternParser().parse(urlPath), resolvedHandler);

               }

               if (logger.isTraceEnabled()) {

                   logger.trace("Mapped [" + urlPath + "] onto " + getHandlerDescription(handler));

               }

           }

        }

    }

在registerHandler方法中，主要做了4件事情。

如果handler不是懒加载的，且handler是字符串类型的。此时就把handler作为一个BeanName,在Spring 容器中获取这个handler的bean对象。
对urlPath进行了校验，如果一个urlPath对应了多个不同的handler，代码就会抛出异常。
对特殊的urlPath进行了单独的处理，对”/”,”/*”分别调用了setRootHandler方法和setDefaultHandler方法进行了特殊的处理。
在handlerMap中记录url和handler的对应关系。通过this.handlerMap.put(urlPath, resolvedHandler)这句代码，把url和handler通过键值对的方式存储到hash散列中。

Handler的查找

在AbstractUrlHandlerMapping类中，具体实现了如何从一个url来获取相应的的handler。AbstractUrlHandlerMapping类中，重写了getHandlerInternal方法。通过url来获取handler的逻辑，就写在getHandlerInternal方法中。

    protected Object getHandlerInternal(HttpServletRequest request) throws Exception {

        String lookupPath = initLookupPath(request);

        Object handler;

        if (usesPathPatterns()) {

           RequestPath path = ServletRequestPathUtils.getParsedRequestPath(request);

           handler = lookupHandler(path, lookupPath, request);

        }

        else {

           handler = lookupHandler(lookupPath, request);

        }

        if (handler == null) {

           // We need to care for the default handler directly, since we need to

           // expose the PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE for it as well.

           Object rawHandler = null;

           if (StringUtils.matchesCharacter(lookupPath, '/')) {

               rawHandler = getRootHandler();

           }

           if (rawHandler == null) {

               rawHandler = getDefaultHandler();

           }

           if (rawHandler != null) {

               // Bean name or resolved handler?

               if (rawHandler instanceof String) {

                   String handlerName = (String) rawHandler;

                   rawHandler = obtainApplicationContext().getBean(handlerName);

               }

               validateHandler(rawHandler, request);

               handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);

           }

        }

        return handler;

}

在getHandlerInternal方法中，程序会先根据request获取到一个url。再通过lookupHandler方法来获取相应的Handler。

lookupHandler方法

lookupHandler从方法名称就可以知道，就是通过url来查找对应的Handler。lookupHandler首先会从handlerMap中直接获取。若找到了Handler，则会直接返回。

若不能直接从handlerMap中获取，则会使用PathPattern进行模式匹配。如果一个url匹配了多个PathPattern，会对多个PathPattern进行排序，取最优的一个。

获取到了PathPattern后，通过PathPattern从pathPatternHandlerMap获取Handler。如果Handler为String类型，那么这个Handler是Handle Bean的名称。再根据这个BeanName在Spring容器中找到相应的Bean。

获取到Handler后，会使用validateHandler对这个Handler进行校验。validateHandler是一个模板方法，主要留给子类进行扩展实现。

最后会使用buildPathExposingHandler方法，为这个Handler增加一些拦截器。

buildPathExposingHandler

buildPathExposingHandler方法主要是给Handler注册了两个内部的拦截器。他们分别是PathExposingHandlerInterceptor和UriTemplateVariablesHandlerInterceptor拦截器。

AbstractDetectingUrlHandlerMapping

在AbstractDetectingUrlHandlerMapping类中，主要是重写了父类的initApplicationContext()方法。在initApplicationContext()方法中，调用了detectHandlers()方法。

protected void detectHandlers() throws BeansException {

        ApplicationContext applicationContext = obtainApplicationContext();

        if (logger.isDebugEnabled()) {

           logger.debug("Looking for URL mappings in application context: " + applicationContext);

        }

        String[] beanNames = (this.detectHandlersInAncestorContexts ?

           BeanFactoryUtils.beanNamesForTypeIncludingAncestors(applicationContext, Object.class) :

               applicationContext.getBeanNamesForType(Object.class));

        // Take any bean name that we can determine URLs for.

        for (String beanName : beanNames) {

           String[] urls = determineUrlsForHandler(beanName);

           if (!ObjectUtils.isEmpty(urls)) {

               // URL paths found: Let's consider it a handler.

               registerHandler(urls, beanName);

           }

           else {

               if (logger.isDebugEnabled()) {

                   logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");

               }

           }

        }

}

在调用了detectHandlers()方法中，主要做了以下几个步骤。

获取Spring 容器中所有bean的名称。
循环遍历所有bean的名称，对每一个beanName调用determineUrlsForHandler方法，获取这个beanName对应的url。
再调用父类的registerHandler(urls, beanName)方法，对url和handler进行注册。

determineUrlsForHandler(beanName)方法在AbstractDetectingUrlHandlerMapping类中，只是一个虚方法，专门留给子类来具体实现。

BeanNameUrlHandlerMapping

Spring MVC容器在初始化HandlerMapping类型的组件时，默认初始化AbstractUrlHandlerMapping系列的组件时，初始化的就是BeanNameUrlHandlerMapping组件。

BeanNameUrlHandlerMapping类继承至AbstractDetectingUrlHandlerMapping这个父类，子类中主要是重写了determineUrlsForHandler方法。determineUrlsForHandler方法中，主要是筛选了Bean的名称或者Bean的别名以“/”斜杠开头的Bean。最后会把Bean的名称和对应的Bean对象注册到handlerMap这个HashMap对象中。

SimpleUrlHandlerMapping

SimpleUrlHandlerMapping类继承至AbstractUrlHandlerMapping这个父类。SimpleUrlHandlerMapping类中有一个Map<String, Object>类型的urlMap属性。我们可以把url和对应的HandlerMapping的放到这个属性中。SimpleUrlHandlerMapping类会在registerHandlers(Map<String, Object> urlMap)方法中，遍历这个urlMap，再调用AbstractUrlHandlerMapping父类的registerHandler(String urlPath, Object handler)方法，对url和HandlerMapping进行注册。

除了Map<String, Object>类型的urlMap属性。SimpleUrlHandlerMapping类中也提供了使用Properties来进行url的注册。通过setMappings(Properties mappings)方法，SimpleUrlHandlerMapping会把mappings合并到urlMap属性中。再走urlMap属性的注册逻辑。