SpringMVC常见组件之HandlerMapping分析

原创

程序员小默 2022-06-13 10:31:20 ©著作权

文章标签 请求映射处理 ide spring 子类 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者程序员小默的原创作品，请联系作者获取转载授权，否则将追究法律责任

在Spring MVC 3.1 之前的版本中，Spring默认使用 DefaultAnnotationHandlerMapping，AnnotationMethodHandlerAdapter来处理 @RequestMapping注解和请求方法调用，而从3.1开始提供了一组新的API，RequestMappingHandlerMapping和RequestMappingHandlerAdapter完成这些工作。

HandlerMapping 叫做处理器映射器，它的作用就是根据当前 request 找到对应的 Handler 和 Interceptor，然后封装成一个 HandlerExecutionChain 对象返回。

其提供了一个方法HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;供子类实现。 我们这里先看下关于请求映射处理的家族树图示：
SpringMVC常见组件之HandlerMapping分析_子类
从上图可以看到，请求映射的家族从该类主要分为三支：根据方法进行匹配的AbstractHandlerMethodMapping、RouterFunctionMapping以及根据请求URL进行批的AbstractUrlHandlerMapping。其中RouterFunctionMapping是5.2版本后引入的，这里暂不分析。

【1】 AbstractHandlerMapping

AbstractHandlerMapping如下所示，其提供了系列模板方法以及抽象方法。

//  返回HandlerInterceptor数组
protected final HandlerInterceptor[] getAdaptedInterceptors() {}

// 返回 HandlerExecutionChain 其包括handler HandlerInterceptor
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {}

// 返回所有配置的MappedInterceptor
protected final MappedInterceptor[] getMappedInterceptors() {}

// 抽象方法供子类实现 ，返回一个handler
protected abstract Object getHandlerInternal(HttpServletRequest request) throws Exception;

AbstractHandlerMapping 间接继承自 ApplicationObjectSupport，并重写了 initApplicationContext 方法（其实该方法也是一个模版方法），这也是 AbstractHandlerMapping 的初始化入口方法，该方法主要就是扫描容器中的拦截器然后放到全局的private final List<HandlerInterceptor> adaptedInterceptors = new ArrayList<>();变量中。

因为ApplicationObjectSupport实现了ApplicationContextAware接口，故而在bean的实例化过程中，凡是实现了ApplicationContextAware接口的类都会被调用其setApplicationContext方法。ApplicationObjectSupport的setApplicationContext又提供了initApplicationContext方法供子类实现。也就是说ApplicationObjectSupport的子类实例化时会被调用initApplicationContext方法。

如下方法会在AbstractHandlerMapping的子类如SimpleUrlHandlerMapping、BeanNameUrlHandlerMapping、RequestMappingHandlerMapping等实例化时被调用。

@Override
protected void initApplicationContext() throws BeansException {
  extendInterceptors(this.interceptors);
  detectMappedInterceptors(this.adaptedInterceptors);
  initInterceptors();
}

① 核心方法getHandler

再看下核心方法public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {}

@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);
  }
  // 根据handler request获取HandlerExecutionChain 
  HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);

  if (logger.isTraceEnabled()) {
    logger.trace("Mapped to " + handler);
  }
  else if (logger.isDebugEnabled() && !request.getDispatcherType().equals(DispatcherType.ASYNC)) {
    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;
}

方法解释如下：

① 获取handler ；
② 如果① 获取的handler为null，则获取一个默认的handler也就是defaultHandler；
③ 如果②仍旧没有获取到handler，则返回null；
④ 根据handler获取HandlerExecutionChain，其包括了handler和拦截器；
⑤ 如果进行了跨域配置，则获取CorsHandlerExecutionChain

② 核心方法getHandlerExecutionChain

我们看内部的核心方法getHandlerExecutionChain

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

方法解释如下：

① 处理获取一个HandlerExecutionChain ；
② 遍历adaptedInterceptors
③ 如果interceptor 是 MappedInterceptor则判断是否匹配当前请求，匹配则添加到当前处理器链中
④ 如果interceptor 是普通拦截器(没有指定映射URL则默认拦截所有)，则直接添加到当前处理器链中

【2】 AbstractUrlHandlerMapping

该分支下是根据URL进行处理器映射匹配查找。常见实现子类有SimpleUrlHandlerMapping和BeanNameUrlHandlerMapping。其覆盖了父类AbstractHandlerMapping的getHandlerInternal方法。

如下所示，其内部维护了两个final map：handlerMap 维护了一个URL与handler的映射关系；pathPatternHandlerMap 维护了一个PathPattern与handler的映射关系。当获取handler时就从这两个map中进行遍历查找。

// URL模式--handler
private final Map<String, Object> handlerMap = new LinkedHashMap<>();

// PathPattern模式--handler
private final Map<PathPattern, Object> pathPatternHandlerMap = new LinkedHashMap<>();

① 核心方法getHandlerInternal

getHandlerInternal方法会根据request获取一个handler。

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

方法解释如下：

① 根据request获取lookupPath；
② 如果patternParser不为null，调用lookupHandler(path, lookupPath, request)也就是从pathPatternHandlerMap寻找handler；
③ 如果patternParser为null,则调用lookupHandler(lookupPath, request)也就是从handlerMap进行查找；
④ 如果②③之后handler还为null，则尝试获取RootHandler、DefaultHandler。

⑤ 如果找到的 Handler 是一个 String，则去 Spring 容器中查找该 String 对应的 Bean；
⑥ 调用 validateHandler 方法来校验找到的 handler 和 request 是否匹配，这是一个空方法，可以忽略。
⑦ 通过buildPathExposingHandler 方法将找到的handler包装为HandlerExecutionChain然后添加PathExposingHandlerInterceptor拦截器，并根据uriTemplateVariables是否为空添加UriTemplateVariablesHandlerInterceptor拦截器。

② 核心方法`lookupHandler(String lookupPath, HttpServletRequest request)`

也就是根据URL获取一个handler。

@Nullable
protected Object lookupHandler(String lookupPath, HttpServletRequest request) throws Exception {
  Object handler = getDirectMatch(lookupPath, request);
  if (handler != null) {
    return handler;
  }

  // Pattern match? 也就是通配符匹配
  List<String> matchingPatterns = new ArrayList<>();
  for (String registeredPattern : this.handlerMap.keySet()) {
    if (getPathMatcher().match(registeredPattern, lookupPath)) {
      matchingPatterns.add(registeredPattern);
    }
    else if (useTrailingSlashMatch()) {
      if (!registeredPattern.endsWith("/") && getPathMatcher().match(registeredPattern + "/", lookupPath)) {
        matchingPatterns.add(registeredPattern + "/");
      }
    }
  }

  String bestMatch = null;
  // AntPathMatcher.AntPatternComparator
  Comparator<String> patternComparator = getPathMatcher().getPatternComparator(lookupPath);
  if (!matchingPatterns.isEmpty()) {
    matchingPatterns.sort(patternComparator);
    if (logger.isTraceEnabled() && matchingPatterns.size() > 1) {
      logger.trace("Matching patterns " + matchingPatterns);
    }
    bestMatch = matchingPatterns.get(0);
  }
  if (bestMatch != null) {
    handler = this.handlerMap.get(bestMatch);
    if (handler == null) {
      if (bestMatch.endsWith("/")) {
        handler = this.handlerMap.get(bestMatch.substring(0, bestMatch.length() - 1));
      }
      if (handler == null) {
        throw new IllegalStateException(
            "Could not find handler for best pattern match [" + bestMatch + "]");
      }
    }
    // Bean name or resolved handler?
    if (handler instanceof String) {
      String handlerName = (String) handler;
      handler = obtainApplicationContext().getBean(handlerName);
    }
    validateHandler(handler, request);
    String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestMatch, lookupPath);

    // There might be multiple 'best patterns', let's make sure we have the correct URI template variables
    // for all of them
    Map<String, String> uriTemplateVariables = new LinkedHashMap<>();
    for (String matchingPattern : matchingPatterns) {
      if (patternComparator.compare(bestMatch, matchingPattern) == 0) {
        Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(matchingPattern, lookupPath);
        Map<String, String> decodedVars = getUrlPathHelper().decodePathVariables(request, vars);
        uriTemplateVariables.putAll(decodedVars);
      }
    }
    if (logger.isTraceEnabled() && uriTemplateVariables.size() > 0) {
      logger.trace("URI variables " + uriTemplateVariables);
    }
    return buildPathExposingHandler(handler, bestMatch, pathWithinMapping, uriTemplateVariables);
  }

  // No handler found...
  return null;
}

方法解释如下：

① 根据lookupPath从handlerMap中获取对应的handler，如果存在则直接返回。注意，这里是直接匹配，也就是没有通配符。
② 遍历handlerMap：

③ 如果当前key与lookupPath匹配(由AntPathMatcher决定)，则添加当前key到List<String> matchingPatterns中；
④ 如果当前key+"/" 与lookupPath匹配(由AntPathMatcher决定),则添加当前key+"/"到List<String> matchingPatterns中；

⑤ 根据PathMatcher获取PatternComparator，默认是AntPatternComparator；
⑥ 如果matchingPatterns不为空，则根据PatternComparator进行排序然后获取第一个元素赋予bestMatch；
⑦ 如果获取的bestMatch不为空则从handlerMap中获取对应的handler；

⑧ 如果⑦获取的handler为空且bestMatch.endsWith("/")，则bestMatch去掉"/"再次从handlerMap获取handler；
⑨ 如果⑧获取的handler仍旧为null，则抛出异常。
(10) 如果找到的 handler 是 String 类型的，则再去 Spring 容器中查找对应的 Bean，接下来再调用 validateHandler 方法进行验证;
(11) extractPathWithinPattern 方法提取出匹配部分pattern-matched路径。例如定义的接口规则是myroot/*.html，请求路径是myroot/myfile.html，那么最终获取到的就是myfile.html。
(12) 遍历matchingPatterns，然后patternComparator.compare(bestMatch, matchingPattern) == 0 也就是判断当前matchingPattern是否与bestMatch等价。然后根据每一个matchingPattern与lookupPath尝试解析path里面变量放入Map<String, String> uriTemplateVariables；
(13) 调用buildPathExposingHandler，这里不再赘述。

(14) 如果获取的bestMatch为空，则直接返回null。

由于一个请求可能会和定义的多个接口匹配上(接口定义的URL带有通配符)，所以 matchingPatterns 变量是一个数组。接下来就要对 matchingPatterns 进行排序，排序完成后，选择排序后的第一项作为最佳选项赋值给 bestMatch 变量。默认的排序规则是 AntPatternComparator，当然开发者也可以自定义。AntPatternComparator 中定义的优先级如下：

URL	优先级
不含任何特殊符号的路径，如：`/a/b/c`	第一优先级
带有`{}`的路径，如：`/a/{b}/c`	第二优先级
带有正则的路径，如：`/a/{regex:\d{3}}/c`	第三优先级
带有``的路径，如：`/a/b/`	第四优先级
带有``的路径，如：`/a/b/`	第五优先级
最模糊的匹配：`/**`	最低优先级

③ 核心方法registerHandler

该方法就是扫描并注册handler，在bean实例化时被调用，如下所示。其中detectHandlers会调用registerHandler(urls, beanName)进行遍历循环注册。

@Override
public void initApplicationContext() throws ApplicationContextException {
  super.initApplicationContext();
  detectHandlers();
}

这里我们直接看registerHandler(urlPath, beanName)方法，其尝试将urlPath = resolvedHandler放入handlerMap中。

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

方法源码解释如下：

①Object resolvedHandler = handler，如果!this.lazyInitHandlers && handler instanceof String，则尝试从Spring容器中获取resolvedHandler；
② 根据urlPath尝试从handlerMap获取handler，如果handler不为空且不等于入参中的handler则抛出异常。如果不为空且等于入参中的handler，则表示已经存在不做处理。
③ 如果从handlerMap获取不到handler：

④ 如果urlPath.equals("/")，则将resolvedHandler设置为RootHandler；
⑤urlPath.equals("/*")，则将resolvedHandler设置为DefaultHandler；
⑥this.handlerMap.put(urlPath, resolvedHandler);将其放入handlerMap。

【3】SimpleUrlHandlerMapping

顾名思义，就是在URL与实例bean(或bean 名称)维护映射关系。其内部维护了一个final mapprivate final Map<String, Object> urlMap = new LinkedHashMap<>();。

其构造方法如下所示：

private final Map<String, Object> urlMap = new LinkedHashMap<>();

// 空的构造函数
public SimpleUrlHandlerMapping() {
}
//根据urlMap 初始化  final Map<String, Object> urlMap
public SimpleUrlHandlerMapping(Map<String, ?> urlMap) {
  setUrlMap(urlMap);
}
// 在前者的基础上并设置当前handleMapping的order
public SimpleUrlHandlerMapping(Map<String, ?> urlMap, int order) {
  setUrlMap(urlMap);
  setOrder(order);
}

其重写了父类的initApplicationContext方法，在该方法中调用了父类initApplicationContext方法，并调用了registerHandlers(this.urlMap);。

@Override
public void initApplicationContext() throws BeansException {
  super.initApplicationContext();
  registerHandlers(this.urlMap);
}

① 核心方法registerHandlers

protected void registerHandlers(Map<String, Object> urlMap) throws BeansException {
  if (urlMap.isEmpty()) {
    logger.trace("No patterns in " + formatMappingName());
  }
  else {
    urlMap.forEach((url, handler) -> {
      // Prepend with slash if not already present.
      if (!url.startsWith("/")) {
        url = "/" + url;
      }
      // Remove whitespace from handler bean name.
      if (handler instanceof String) {
        handler = ((String) handler).trim();
      }
      registerHandler(url, handler);
    });
    if (logger.isDebugEnabled()) {
      List<String> patterns = new ArrayList<>();
      if (getRootHandler() != null) {
        patterns.add("/");
      }
      if (getDefaultHandler() != null) {
        patterns.add("/**");
      }
      patterns.addAll(getHandlerMap().keySet());
      logger.debug("Patterns " + patterns + " in " + formatMappingName());
    }
  }
}

方法解释如下：

① 如果urlMap为空，则直接返回；
② 遍历循环urlMap，如果当前URL不是以"/"开头，则拼接前缀"/";如果handler是string，则进行trim;然后调用父类AbstractUrlHandlerMapping的registerHandler方法。

② SimpleUrlHandlerMapping的使用

一个应用实例是如下配置，则这里urlMap就维护了映射关系。

<mvc:view-controller path="/" view-name="index"></mvc:view-controller>

SpringMVC常见组件之HandlerMapping分析_spring_02
也就是说，如果你想使用SimpleUrlHandlerMapping，那么请自行配置映射关系。如下xml配置：

<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
     <property name="urlMap">
         <map>
             <entry key="/hello" value="helloController"/>
         </map>
     </property>
     <!--或者如下配置-->
     <property name="mappings">
        <props>
             <prop key="/hello">helloController</prop>
         </props>
     </property>
     <!--或者如下配置-->
     <property name="mappings">
        <value>
       /hello=helloController
    </value>
     </property>
 </bean>

helloController是controller的名字，需要实现Controller接口，如下所示：

@org.springframework.stereotype.Controller
public class HelloController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.out.println(request.getRequestURI());
        System.out.println(this.getClass().getName());
        ModelAndView modelAndView=new ModelAndView();
        modelAndView.setViewName("success");
        return modelAndView;
    }
}

如果启用了defaultServletHandler那么SimpleUrlHandlerMapping的urlMap中还有如下配置：

/**=org.springframework.web.servlet.resource.DefaultServletHttpRequestHandler#0

SpringMVC常见组件之HandlerMapping分析_请求映射处理_03

【4】AbstractDetectingUrlHandlerMapping

这个简单来讲，就是扫描spring容器中注册的bean。如果bean name或bean的别名是以"/"开头，那么就将bean name或bean的别名作为URL，调用父类AbstractUrlHandlerMapping的registerHandler(String[] urlPaths, String beanName)方法最后注册到handlerMap中。

我们同样从initApplicationContext方法看起,其调用了父类的AbstractHandlerMapping的initApplicationContext方法并调用detectHandlers来检测handler。

@Override
public void initApplicationContext() throws ApplicationContextException {
  super.initApplicationContext();
  detectHandlers();
}

① 核心方法detectHandlers

protected void detectHandlers() throws BeansException {
  ApplicationContext applicationContext = obtainApplicationContext();
  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);
    }
  }
// ... 这里是无需关注的日志打印
}

方法解释如下：

① 获取ApplicationContext；
② 获取容器中的beanNames ，这里得到一个数组；
③ 遍历beanNames ，检测其URL。如果URL不为空则注册到handlerMap。

SpringMVC常见组件之HandlerMapping分析_子类_04

这里determineUrlsForHandler是个抽象方法，供子类实现。其只有一个子类BeanNameUrlHandlerMapping，我们看下其实现determineUrlsForHandler方法。

@Override
protected String[] determineUrlsForHandler(String beanName) {
  List<String> urls = new ArrayList<>();
  if (beanName.startsWith("/")) {
    urls.add(beanName);
  }
  String[] aliases = obtainApplicationContext().getAliases(beanName);
  for (String alias : aliases) {
    if (alias.startsWith("/")) {
      urls.add(alias);
    }
  }
  return StringUtils.toStringArray(urls);
}

方法很简单，判断beanName是否以"/"开头，是的话放入urls数组中。然后获取beanName的别名，对别名数组进行遍历判断是否以否以"/"开头，是的话放入urls数组中。

也就是说，上面我们的HelloController可以指定名字如下所示：

@org.springframework.stereotype.Controller("/helloController")
public class HelloController implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.out.println(request.getRequestURI());
        System.out.println(this.getClass().getName());
        ModelAndView modelAndView=new ModelAndView();
        modelAndView.setViewName("success");
        return modelAndView;
    }
}

【5】AbstractHandlerMethodMapping

在前面 AbstractUrlHandlerMapping 体系下，一个 Handler 一般就是一个类(显示Controller如HelloController或者隐式controller如ParameterizableViewController)。但是在 AbstractHandlerMethodMapping 体系下，一个 Handler 通常指的是一个 Mehtod，是HandlerMethod类型。

AbstractHandlerMethodMapping主要维护了请求和handlerMethod之间的映射关系。其覆盖了父类AbstractHandlerMapping如下三个方法：

// 核心方法，获取内部handler。该体系下返回handlerMethod
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {}

//如下两个方法和跨域配置有关
protected CorsConfiguration getCorsConfiguration(Object handler, HttpServletRequest request) {}
protected boolean hasCorsConfigurationSource(Object handler) {}

其提供了如下抽象方法供子类实现

//RequestMappingInfoHandlerMapping实现
protected abstract T getMatchingMapping(T mapping, HttpServletRequest request);

//RequestMappingInfoHandlerMapping实现
protected abstract Comparator<T> getMappingComparator(HttpServletRequest request);

//RequestMappingHandlerMapping实现
protected abstract boolean isHandler(Class<?> beanType);

//RequestMappingHandlerMapping实现
protected abstract T getMappingForMethod(Method method, Class<?> handlerType);

核心变量private final MappingRegistry mappingRegistry = new MappingRegistry(); 为什么说是核心变量？我们可以看下mappingRegistry究竟是个什么？如下所示其registry 维护了所有的RequestMappingInfo实例与MappingRegistration映射关系。pathLookup 维护了directPath与List<RequestMappingInfo>实例关系。当处理请求获取handlerMethod时，qi

private final Map<T, MappingRegistration<T>> registry = new HashMap<>();

private final MultiValueMap<String, T> pathLookup = new LinkedMultiValueMap<>();

private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();

private final Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();

private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

我们看一下该体系下的家族树图示

SpringMVC常见组件之HandlerMapping分析_请求映射处理_05

需要注意的是AbstractHandlerMethodMapping其实现了InitializingBean接口，重写了afterPropertiesSet方法。为什么这里特意提一下实现了InitializingBean接口，那是因为这个接口定义了其实现Bean在容器完成属性设置后可以执行自定义初始化操作，我们的AbstractHandlerMethodMapping便实现了这个接口，并且定义了一组自定义操作，就是用来检测处理我们的@RequestMapping注解。

① afterPropertiesSet

如下图所示，如何bean实现了InitializingBean接口，那么在初始化过程中一定会调用其afterPropertiesSet方法。
SpringMVC常见组件之HandlerMapping分析_ide_06
这里我们看一下RequestMappingHandlerMapping.afterPropertiesSet方法。

@Override
@SuppressWarnings("deprecation")
public void afterPropertiesSet() {

  this.config = new RequestMappingInfo.BuilderConfiguration();
  this.config.setTrailingSlashMatch(useTrailingSlashMatch());
  this.config.setContentNegotiationManager(getContentNegotiationManager());

  if (getPatternParser() != null) {
    this.config.setPatternParser(getPatternParser());
    Assert.isTrue(!this.useSuffixPatternMatch && !this.useRegisteredSuffixPatternMatch,
        "Suffix pattern matching not supported with PathPatternParser.");
  }
  else {
    this.config.setSuffixPatternMatch(useSuffixPatternMatch());
    this.config.setRegisteredSuffixPatternMatch(useRegisteredSuffixPatternMatch());
    this.config.setPathMatcher(getPathMatcher());
  }

  super.afterPropertiesSet();
}

可以看到其主要做了一些配置如后缀模式匹配，然后调用父类AbstractHandlerMethodMapping的afterPropertiesSet方法。其源码如下所示-在初始化过程中检测处理器方法。

@Override
public void afterPropertiesSet() {
  initHandlerMethods();
}

简单直接调用了AbstractHandlerMethodMapping#initHandlerMethods方法。如下所示父类直接调用initHandlerMethods方法进行handlerMethod的初始化注册。

@Override
public void afterPropertiesSet() {
  initHandlerMethods();
}

① initHandlerMethods

initHandlerMethods方法源码如下：

// 在ApplicationContext中扫描bean，检测并注册 handler methods
protected void initHandlerMethods() {
  for (String beanName : getCandidateBeanNames()) {
      // 如果beanName不是以scopedTarget开头，就执行processCandidateBean
    if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
      processCandidateBean(beanName);
    }
  }
  handlerMethodsInitialized(getHandlerMethods());
}

这里我们着重分析processCandidateBean(beanName);和getHandlerMethods()方法。

② processCandidateBean

processCandidateBean(beanName);方法的作用是什么呢？判断其是否为一个handler(也就是是否拥有@Controller注解或@RequestMapping注解)。如果是一个handler，则检测并注册其内部方法。

protected void processCandidateBean(String beanName) {
Class<?> beanType = null;
  try {
    beanType = obtainApplicationContext().getType(beanName);
  }
  catch (Throwable ex) {
    // An unresolvable bean type, probably from a lazy bean - let's ignore it.
    if (logger.isTraceEnabled()) {
      logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
    }
  }
  if (beanType != null && isHandler(beanType)) {
      // 注意，这里是核心
    detectHandlerMethods(beanName);
  }
}

isHandler(beanType)是一个抽象方法，在子类RequestMappingHandlerMapping中实现。

我们看下isHandler(beanType)是如何判断当前bean是否为一个handler的？

@Override
protected boolean isHandler(Class<?> beanType) {
  return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
      AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
}

判断类上面的注解是否是(或拥有)@Controller或者@RequestMapping(或者复合注解如@RestController、@PostMapping)。OK，我们继续看detectHandlerMethods方法如何扫描并注册。

③ detectHandlerMethods

扫描handler内部的handler method然后注册到AbstractHandlerMethodMapping内部的常量private final MappingRegistry mappingRegistry = new MappingRegistry();中。

protected void detectHandlerMethods(Object handler) {
Class<?> handlerType = (handler instanceof String ?
      obtainApplicationContext().getType((String) handler) : handler.getClass());

  if (handlerType != null) {
    Class<?> userType = ClassUtils.getUserClass(handlerType);
    Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
        (MethodIntrospector.MetadataLookup<T>) method -> {
          try {
            return getMappingForMethod(method, userType);
          }
          catch (Throwable ex) {
            throw new IllegalStateException("Invalid mapping on handler class [" +
                userType.getName() + "]: " + method, ex);
          }
        });
    if (logger.isTraceEnabled()) {
      logger.trace(formatMappings(userType, methods));
    }
    methods.forEach((method, mapping) -> {
      Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
      registerHandlerMethod(handler, invocableMethod, mapping);
    });
  }
}

这里我们暂不展开分析，放在第三部分中展开。我们只需要知道在RequestMappingHandlerMapping 初始化过程中，该方法将会扫描容器中那些Controller及内部method。获取handler、method、mapping，也就是处理器、处理器方法与请求映射信息(包括@RequestMapping标注的那些参数)。

扫描并注册完之后，到了handlerMethodsInitialized(getHandlerMethods());。这里我们看下getHandlerMethods。

④ getHandlerMethods

AbstractHandlerMethodMapping#getHandlerMethods方法如下：

// 返回只读的map  mapping ：HandlerMethod
public Map<T, HandlerMethod> getHandlerMethods() {
 // private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  this.mappingRegistry.acquireReadLock();
  try {
    return Collections.unmodifiableMap(
        this.mappingRegistry.getRegistrations().entrySet().stream()
            .collect(Collectors.toMap(Map.Entry::getKey, entry -> entry.getValue().handlerMethod)));
  }
  finally {
    this.mappingRegistry.releaseReadLock();
  }
}

方法源码解释如下：

获取mappingRegistry中的读锁然后加锁；
遍历MappingRegistry.registry,返回一个只读Map；
释放锁

handlerMethodsInitialized(getHandlerMethods());方法则更简单，只是简单打印告诉系统已经已经有多少个mappings被扫描注册。

【6】detectHandlerMethods详细分析

detectHandlerMethods方法是该组件的核心方法，将会扫描@RequestMapping注解的方法并创建RequestMappingInfo实例。然后将将RequestMappingInfo实例以及处理器方法注册到AbstractHandlerMethodMapping的内部类MappingRegistry中常量Mapprivate final Map<T, MappingRegistration<T>> registry = new HashMap<>();。

protected void detectHandlerMethods(Object handler) {
  Class<?> handlerType = (handler instanceof String ?
      obtainApplicationContext().getType((String) handler) : handler.getClass());

  if (handlerType != null) {
    Class<?> userType = ClassUtils.getUserClass(handlerType);
    Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
        (MethodIntrospector.MetadataLookup<T>) method -> {
          try {
            return getMappingForMethod(method, userType);
          }
          catch (Throwable ex) {
            throw new IllegalStateException("Invalid mapping on handler class [" +
                userType.getName() + "]: " + method, ex);
          }
        });
    if (logger.isTraceEnabled()) {
      logger.trace(formatMappings(userType, methods));
    }
    methods.forEach((method, mapping) -> {
      Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
      registerHandlerMethod(handler, invocableMethod, mapping);
    });
  }
}

代码解释如下：

getMappingForMethod方法创建RequestMappingInfo实例；
methods.forEach方法循环遍历并注册handler、invocableMethod、mapping到内存中。

这里我们可以先看下method、mapping的实例
SpringMVC常见组件之HandlerMapping分析_ide_07
如上图所示，method记录了方法详细信息诸如声明类、名字、返回结果类型、参数类型、异常类型、修饰符、注解、参数、是否覆盖等等。mapping则记录了@RequestMapping注解里面的信息如URL、请求方法、参数限制、header、consume、produce以及自定义限制条件等。

① getMappingForMethod

@Override
@Nullable
protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
  RequestMappingInfo info = createRequestMappingInfo(method);
  if (info != null) {
    RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
    if (typeInfo != null) {
      info = typeInfo.combine(info);
    }
    String prefix = getPathPrefix(handlerType);
    if (prefix != null) {
      info = RequestMappingInfo.paths(prefix).options(this.config).build().combine(info);
    }
  }
  return info;
}

代码解释如下：

① 根据method创建RequestMappingInfo 实例info ；
② 根据handlerType创建RequestMappingInfo 实例实例typeInfo ；
③ 如果②中创建的实例typeInfo 不为null，则info = typeInfo.combine(info)进行合并；
④ 根据handlerType获取类上面定义的路径前缀，如果前缀不为空则对info进行合并。

② 创建RequestMappingInfo实例

RequestMappingHandlerMapping#createRequestMappingInfo源码如下所示：

@Nullable
private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
// //获取方法method上的@RequestMapping实例。
  RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(element, RequestMapping.class);
// 这里始终为null  
  RequestCondition<?> condition = (element instanceof Class ?
      getCustomTypeCondition((Class<?>) element) : getCustomMethodCondition((Method) element));
  return (requestMapping != null ? createRequestMappingInfo(requestMapping, condition) : null);
}

然后我们继续看createRequestMappingInfo(requestMapping, condition)方法。

protected RequestMappingInfo createRequestMappingInfo(
    RequestMapping requestMapping, @Nullable RequestCondition<?> customCondition) {

  RequestMappingInfo.Builder builder = RequestMappingInfo
      .paths(resolveEmbeddedValuesInPatterns(requestMapping.path()))
      .methods(requestMapping.method())
      .params(requestMapping.params())
      .headers(requestMapping.headers())
      .consumes(requestMapping.consumes())
      .produces(requestMapping.produces())
      .mappingName(requestMapping.name());
  if (customCondition != null) {
    builder.customCondition(customCondition);
  }
  return builder.options(this.config).build();
}

看着是不是会熟悉？其实就是获取@RequestMapping注解的url、params、headers、consumes、produces以及name最后进行创建RequestMappingInfo实例。

关于@RequestMapping注解的url、params、headers、consumes、produces以及name这些本文不做赘述，更多信息参考博文SpringMVC-@RequestMapping的参数和用法

@RequestMapping注解信息实例

@org.springframework.web.bind.annotation.RequestMapping(consumes=[], headers=[], method=[], name=, params=[], path=[/**/testInterceptor], produces=[], value=[/**/testInterceptor])

RequestMappingInfo实例
SpringMVC常见组件之HandlerMapping分析_ide_08

③ 类与方法上面的请求映射实例合并typeInfo.combine(info)

这里我们着重看一下根据类创建的RequestMappingInfo实例与根据方法创建的RequestMappingInfo实例合并过程。

@Override
public RequestMappingInfo combine(RequestMappingInfo other) {
  String name = combineNames(other);

  PathPatternsRequestCondition pathPatterns =
      (this.pathPatternsCondition != null && other.pathPatternsCondition != null ?
          this.pathPatternsCondition.combine(other.pathPatternsCondition) : null);

  PatternsRequestCondition patterns =
      (this.patternsCondition != null && other.patternsCondition != null ?
          this.patternsCondition.combine(other.patternsCondition) : null);

  RequestMethodsRequestCondition methods = this.methodsCondition.combine(other.methodsCondition);
  ParamsRequestCondition params = this.paramsCondition.combine(other.paramsCondition);
  HeadersRequestCondition headers = this.headersCondition.combine(other.headersCondition);
  ConsumesRequestCondition consumes = this.consumesCondition.combine(other.consumesCondition);
  ProducesRequestCondition produces = this.producesCondition.combine(other.producesCondition);
  RequestConditionHolder custom = this.customConditionHolder.combine(other.customConditionHolder);

  return new RequestMappingInfo(
      name, pathPatterns, patterns, methods, params, headers, consumes, produces, custom);
}

这里涉及到了几个类，我们大致了解下含义：

PatternRequestCondition 它其实就是URL模式的封装，它包含了一个URL模式的Set集合。其实就是@RequestMapping注解中的value值得封装。
RequestMethodRequestCondition 它是@RequestMapping 注解中method属性的封装
ParamsRequestCondition 它是@RequestMapping注解中params属性的封装

等等，依次类推。因此RequestMappingInfo其实就是对@RquestMapping 的封装。这里关于method、params、heade等的合并我们暂时不理会(其实你对框架应用熟悉就应该能想到这些合并就是做条件与)，着重看下patternsCondition的合并。

@Override
public PatternsRequestCondition combine(PatternsRequestCondition other) {
  if (isEmptyPathMapping() && other.isEmptyPathMapping()) {
    return this;
  }
  else if (other.isEmptyPathMapping()) {
    return this;
  }
  else if (isEmptyPathMapping()) {
    return other;
  }
  Set<String> result = new LinkedHashSet<>();
  if (!this.patterns.isEmpty() && !other.patterns.isEmpty()) {
    for (String pattern1 : this.patterns) {
      for (String pattern2 : other.patterns) {
        result.add(this.pathMatcher.combine(pattern1, pattern2));
      }
    }
  }
  return new PatternsRequestCondition(result, this);
}

代码解释如下：

如果两个path都为空，则返回this；
如果其中一个为空，返回不为空的那个；
如果两个都不为空，则进行笛卡尔积合并；

两个pattern如何合并的呢？url拼接是由PathMatcher来完成的,我们看下实例

pattern1	pattern2	结果
`/*`	/hotel	/hotel
`/.`	`/*.html`	`/*.html`
/usr	/user	/usr/user
/{foo}	/bar	/{foo}/bar
`/hotels/*`	/booking	/hotels/booking
`/hotels/*`	booking	/hotels/booking
/hotels	/booking	/hotels/booking
/hotels	booking	/hotels/booking
`/*.html`	/hotel	/hotel.html
`/*.html`	`/hotel.*`	/hotel.html

④ 注册HandlerMethod

从上面看到这里会进行循环然后进行注册，如下所示：

methods.forEach((method, mapping) -> {
  Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
  registerHandlerMethod(handler, invocableMethod, mapping);
});

AbstractHandlerMethodMapping#registerHandlerMethod方法如下：

protected void registerHandlerMethod(Object handler, Method method, T mapping) {
  this.mappingRegistry.register(mapping, handler, method);
}

继续跟进AbstractHandlerMethodMapping.MappingRegistry#register：

public void register(T mapping, Object handler, Method method) {
  this.readWriteLock.writeLock().lock();
  try {
    HandlerMethod handlerMethod = createHandlerMethod(handler, method);
    // 这里mapping就是RequestMappingInfo实例 
    validateMethodMapping(handlerMethod, mapping);
    // 获取请求URL  ，然后往pathLookup放入path与mapping
    Set<String> directPaths = AbstractHandlerMethodMapping.this.getDirectPaths(mapping);
    for (String path : directPaths) {
      this.pathLookup.add(path, mapping);
    }
    // 获取name，然后往nameLookup中放入name=List<HandlerMethod>
    String name = null;
    if (getNamingStrategy() != null) {
      name = getNamingStrategy().getName(handlerMethod, mapping);
      addMappingName(name, handlerMethod);
    }

    CorsConfiguration config = initCorsConfiguration(handler, method, mapping);
    if (config != null) {
      config.validateAllowCredentials();
      this.corsLookup.put(handlerMethod, config);
    }

    this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directPaths, name));
  }
  finally {
    this.readWriteLock.writeLock().unlock();
  }
}

代码解释如下：

① 获取写锁进行加锁；
② 获取HandlerMethod；
③ 校验是否存在不同的HandlerMethod对应同一个RequestMappingInfo实例。简单来说就是同样的@RequestMapping注解在不同的类或者方法上。
④ 获取映射URL，然后放到AbstractHandlerMethodMapping内部类MappingRegistry的private final MultiValueMap<String, T> pathLookup中，path=RequestMappingInfo。这里放的URL是不带通配符*和?的，也就是所谓的directPath。
⑤ 获取handler method的name，然后往nameLookup中放入name=List<HandlerMethod>。这里类似于一个彩蛋，如URL/test访问也可以使用方法TC#test访问。TC就是TestController的缩写。
⑥ 判断是否设置了跨域也就是类或者方法上是否有@CrossOrigin注解。如果设置了跨域则初始化CorsConfiguration：

校验是否满足跨域条件：allowCredentials为true时allowedOrigins不能为*，不满足则会抛出异常；
如果满足条件则往corsLookup放入handlerMethod=config：this.corsLookup.put(handlerMethod, config);

⑦this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directPaths, name));往AbstractHandlerMethodMapping的内部类MappingRegistry的private final Map<T, MappingRegistration<T>> registry = new HashMap<>();放入mapping=new MappingRegistration<>(mapping, handlerMethod, directPaths, name)
⑧ 获取写锁，进行锁的释放。

【7】查找lookupHandlerMethod

AbstractHandlerMethodMapping#lookupHandlerMethod方法主要是根据lookupPath来获取一个HandlerMethod 。

① lookupHandlerMethod

@Nullable
protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
  List<Match> matches = new ArrayList<>();
  // 从 MappingRegistry.pathLookup中获取 RequestMappingInfo实例集合
  List<T> directPathMatches = this.mappingRegistry.getMappingsByDirectPath(lookupPath);
  if (directPathMatches != null) {
    addMatchingMappings(directPathMatches, matches, request);
  }
  if (matches.isEmpty()) {
    addMatchingMappings(this.mappingRegistry.getRegistrations().keySet(), matches, request);
  }
  if (!matches.isEmpty()) {
    Match bestMatch = matches.get(0);
    if (matches.size() > 1) {
      Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
      matches.sort(comparator);
      bestMatch = matches.get(0);
      if (logger.isTraceEnabled()) {
        logger.trace(matches.size() + " matching mappings: " + matches);
      }
      if (CorsUtils.isPreFlightRequest(request)) {
        return PREFLIGHT_AMBIGUOUS_MATCH;
      }
      Match secondBestMatch = matches.get(1);
      if (comparator.compare(bestMatch, secondBestMatch) == 0) {
        Method m1 = bestMatch.handlerMethod.getMethod();
        Method m2 = secondBestMatch.handlerMethod.getMethod();
        String uri = request.getRequestURI();
        throw new IllegalStateException(
            "Ambiguous handler methods mapped for '" + uri + "': {" + m1 + ", " + m2 + "}");
      }
    }
    request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.handlerMethod);
    handleMatch(bestMatch.mapping, lookupPath, request);
    return bestMatch.handlerMethod;
  }
  else {
    return handleNoMatch(this.mappingRegistry.getRegistrations().keySet(), lookupPath, request);
  }
}

mappingRegistry实例图示

SpringMVC常见组件之HandlerMapping分析_子类_13

方法解释如下：

① 根据lookupPath从MappingRegistry的MultiValueMap<String, T> pathLookup获取List<T> directPathMatches。如果获取到结果不为空，则找出匹配当前请求的RequestMappingInfo实例，根据RequestMappingInfo实例实例和HandlerMethod组装Match，最后放到List<Match> matches中。这里我们可以再回顾一下pathLookup实例：
② 如果①操作后的matches为空，则尝试从MappingRegistry.registry中获取所有匹配当前请求的数据集，然后封装为Match实例对象放到matches中。
③ 如果② 之后matches不为空，则判断是否只有一条。如果数据集大于一条进行排序，bestMatch = matches.get(0);。这里会额外对第一、二条数据进行比较，如果相等则抛出异常。如果数据集只有一条，则bestMatch = matches.get(0);，继续往下处理。

④ 往request中放入两个属性：

request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, bestMatch.handlerMethod);
.request.setAttribute(HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, lookupPath);

⑤ 返回bestMatch中的handlerMethod.

⑥ 如果② 之后matches为空，则走handleNoMatch方法。该方法为空，返回null，在子类RequestMappingInfoHandlerMapping中重写了该方法可能会抛出诸如HttpRequestMethodNotSupportedException、HttpMediaTypeNotSupportedException、HttpMediaTypeNotAcceptableException、UnsatisfiedServletRequestParameterException异常。

request中放的两个属性键是：

// org.springframework.web.servlet.HandlerMapping.bestMatchingHandler
String BEST_MATCHING_HANDLER_ATTRIBUTE = HandlerMapping.class.getName() + ".bestMatchingHandler";

// org.springframework.web.servlet.HandlerMapping.pathWithinHandlerMapping
String PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE = HandlerMapping.class.getName() + ".pathWithinHandlerMapping";

上面我们看到了如果matches数据集大于一条会获取比较器然后进行排序，其会调用RequestMappingInfo#compareTo方法进行比较。

Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
matches.sort(comparator);

② addMatchingMappings

这里我们再看下addMatchingMappings方法。方法如下所示，会遍历mappings集合(RequestMappingInfo实例集合)，从中找到匹配当前request的RequestMappingInfo，然后封装为Match对象放到List<Match> matches中。

private void addMatchingMappings(Collection<T> mappings, List<Match> matches, HttpServletRequest request) {
  for (T mapping : mappings) {
    T match = getMatchingMapping(mapping, request);
    if (match != null) {
      matches.add(new Match(match,
          this.mappingRegistry.getRegistrations().get(mapping).getHandlerMethod()));
    }
  }
}

③ getMatchingMapping&&getMatchingCondition

那么如何判断RequestMappingInfo与request是否匹配呢？ 我们继续看下getMatchingMapping方法。该方法在RequestMappingInfoHandlerMapping子类中进行了实现。

protected RequestMappingInfo getMatchingMapping(RequestMappingInfo info, HttpServletRequest request) {
  return info.getMatchingCondition(request);
}

//RequestMappingInfo#getMatchingCondition
public RequestMappingInfo getMatchingCondition(HttpServletRequest request) {
RequestMethodsRequestCondition methods = this.methodsCondition.getMatchingCondition(request);
  if (methods == null) {
    return null;
  }
  ParamsRequestCondition params = this.paramsCondition.getMatchingCondition(request);
  if (params == null) {
    return null;
  }
  HeadersRequestCondition headers = this.headersCondition.getMatchingCondition(request);
  if (headers == null) {
    return null;
  }
  ConsumesRequestCondition consumes = this.consumesCondition.getMatchingCondition(request);
  if (consumes == null) {
    return null;
  }
  ProducesRequestCondition produces = this.producesCondition.getMatchingCondition(request);
  if (produces == null) {
    return null;
  }
  PathPatternsRequestCondition pathPatterns = null;
  if (this.pathPatternsCondition != null) {
    pathPatterns = this.pathPatternsCondition.getMatchingCondition(request);
    if (pathPatterns == null) {
      return null;
    }
  }
  PatternsRequestCondition patterns = null;
  if (this.patternsCondition != null) {
    patterns = this.patternsCondition.getMatchingCondition(request);
    if (patterns == null) {
      return null;
    }
  }
  RequestConditionHolder custom = this.customConditionHolder.getMatchingCondition(request);
  if (custom == null) {
    return null;
  }
  return new RequestMappingInfo(
      this.name, pathPatterns, patterns, methods, params, headers, consumes, produces, custom);
}

如上所示，方法会逐个对method、param、header、consume、produce、pathPattern、pattern以及自定义condition进行匹配，只有全部满足则通过新建一个RequestMappingInfo实例返回，否则返回null。

总结

① 在bean实例化时扫描、注册请求URL(或者是RequestMappingInfo实例)与handler；
② 请求处理时，遍历查找。如果不能直接获取或者获取为多个，则会进行比较排序然后选出最优解；
③ 封装为HandlerExecutionChain返回。

【8】几个概念

① RequestMappingInfo

这个类是对请求映射的一个抽象，它包含了请求路径，请求方法，请求头等信息。其实可以看做是@RequestMapping的一个对应类。其内部维护了静态内部类BuilderConfiguration、DefaultBuilder以及一些封装@RequestMapping注解信息的类。

其内部常量如下所示：

// 一个逻辑分离 (' || ') 请求条件，它根据一组 URL 路径模式匹配请求。这里使用已解析的PathPatterns
private static final PathPatternsRequestCondition EMPTY_PATH_PATTERNS = new PathPatternsRequestCondition();
// Patterns 也就是请求URL，PathPatternsRequestCondition 不同，这里使用String 字符串模式
private static final PatternsRequestCondition EMPTY_PATTERNS = new PatternsRequestCondition();
// 请求限制http method
private static final RequestMethodsRequestCondition EMPTY_REQUEST_METHODS = new RequestMethodsRequestCondition();
// @RequestMapping注解中的param
private static final ParamsRequestCondition EMPTY_PARAMS = new ParamsRequestCondition();
// @RequestMapping注解中的header
private static final HeadersRequestCondition EMPTY_HEADERS = new HeadersRequestCondition();
// @RequestMapping注解中的consume
private static final ConsumesRequestCondition EMPTY_CONSUMES = new ConsumesRequestCondition();
// @RequestMapping注解中的produce
private static final ProducesRequestCondition EMPTY_PRODUCES = new ProducesRequestCondition();
// 自定义条件
private static final RequestConditionHolder EMPTY_CUSTOM = new RequestConditionHolder(null);


@Nullable
private final String name;
@Nullable
private final PathPatternsRequestCondition pathPatternsCondition;
@Nullable
private final PatternsRequestCondition patternsCondition;
private final RequestMethodsRequestCondition methodsCondition;
private final ParamsRequestCondition paramsCondition;
private final HeadersRequestCondition headersCondition;
private final ConsumesRequestCondition consumesCondition;
private final ProducesRequestCondition producesCondition;
private final RequestConditionHolder customConditionHolder;
private final int hashCode;

简单实例图示
SpringMVC常见组件之HandlerMapping分析_ide_15

② HandlerMethod

这个类封装了处理器实例（Controller Bean）和处理方法实例（Method）以及方法参数数组（MethodParameter[]）。其内部成员变量为：

private final Object bean;
@Nullable
private final BeanFactory beanFactory;
private final Class<?> beanType;
private final Method method;
private final Method bridgedMethod;
private final MethodParameter[] parameters;
@Nullable
private HttpStatus responseStatus;
@Nullable
private String responseStatusReason;
@Nullable
private HandlerMethod resolvedFromHandlerMethod;
@Nullable
private volatile List<Annotation[][]> interfaceParameterAnnotations;
private final String description;

HandlerMethod实例图示
SpringMVC常见组件之HandlerMapping分析_子类_16
其有用对Method的应用，Method示例图示如下：

③ AbstractHandlerMethodMapping#MappingRegistry

MappingRegistry是AbstractHandlerMethodMapping内部类，内部维护了系列final类型的Map。用来存储"映射与目标"之间的关系，如下所示：

class MappingRegistry {

    private final Map<T, MappingRegistration<T>> registry = new HashMap<>();

    private final MultiValueMap<String, T> pathLookup = new LinkedMultiValueMap<>();

    private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();

    private final Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();

    private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
//...
}

其提供了核心方法register用来向pathLookup、nameLookup、corsLookup以及registry放入数据。unregister方法从pathLookup、nameLookup、corsLookup以及registry移除入数据。

我们可以通过下图直观感受其究竟是一个怎样的实例。

SpringMVC常见组件之HandlerMapping分析_spring_18

④ ApplicationContextAware与ApplicationObjectSupport

ApplicationContextAware接口只提供了一个方法用来为当前上下文设置ApplicationContext 。

void setApplicationContext(ApplicationContext applicationContext) throws BeansException;

当bean实例化后，会遍历BeanPostProcessor调用其postProcessBeforeInitialization进行后置处理。如ApplicationContextAwareProcessor的postProcessBeforeInitialization会判断bean是否是EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware以及ApplicationStartupAware。如果是其中之一，则会调用对应的setXXX方法如setApplicationContext。

ApplicationObjectSupport实现了ApplicationContextAware接口setApplicationContext方法，如下图所示其提供了initApplicationContext方法供子类实现。

@Override
public final void setApplicationContext(@Nullable ApplicationContext context) throws BeansException {
  if (context == null && !isContextRequired()) {
    // Reset internal context state.
    this.applicationContext = null;
    this.messageSourceAccessor = null;
  }
  else if (this.applicationContext == null) {
    // Initialize with passed-in context.
    if (!requiredContextClass().isInstance(context)) {
      throw new ApplicationContextException(
          "Invalid application context: needs to be of type [" + requiredContextClass().getName() + "]");
    }
    this.applicationContext = context;
    this.messageSourceAccessor = new MessageSourceAccessor(context);
    // 这里是核心
    initApplicationContext(context);
  }
  else {
    // Ignore reinitialization if same context passed in.
    if (this.applicationContext != context) {
      throw new ApplicationContextException(
          "Cannot reinitialize with different application context: current one is [" +
          this.applicationContext + "], passed-in one is [" + context + "]");
    }
  }
}

在本文HandlerMapping体系中，AbstractHandlerMapping、AbstractDetectingUrlHandlerMapping以及SimpleUrlHandlerMapping实现了这三个方法

故而当BeanNameUrlHandlerMapping或者SimpleUrlHandlerMapping实例化时，就会触发setApplicationContext方法，然后触发initApplicationContext方法。

上一篇：SpringMVC常见组件之HandlerAdapter分析

下一篇：MyBatis的类型处理器TypeHandler与自定义实现

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯