上一篇写到文件上传请求的原理。接下来就是获取Handler的原理了

mappedHandler = getHandler(processedRequest)：返回HandlerExecutionChain对象（包含目标方法、拦截器链）

getHandler()

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    if (this.handlerMappings != null) {
        for (HandlerMapping mapping : this.handlerMappings) {
            HandlerExecutionChain handler = mapping.getHandler(request);
            if (handler != null) {
                return handler;
            }
        }
    }
    return null;
}

遍历所有的HandlerMapping调用其getHandler()来拿到HandlerExecutionChain对象

5个HandlerMapping

HandlerMapping的作用就是根据请求找到对应的Handler

我们都是在controller接口中然后声明方法来做请求处理的，所以会由这个类处理 RequestMappingHandlerMapping（AbstractHandlerMapping 是它的父类）：

private Object defaultHandler;
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    // 根据当前请求拿到对应的 Handler 
    Object handler = getHandlerInternal(request);
    // 没拿到就给一个默认的 Handler
    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 和 当前请求得到一个 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 = (this.corsConfigurationSource != null ? this.corsConfigurationSource.getCorsConfiguration(request) : null);
        CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
        config = (config != null ? config.combine(handlerConfig) : handlerConfig);
        executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
    }
    return executionChain;
}

获取处理器对象-getHandlerInternal()

拿到目标方法

最终会来到AbstractHandlerMethodMapping#getHandlerInternal

// 路径帮助器
private UrlPathHelper urlPathHelper = new UrlPathHelper();
String LOOKUP_PATH = HandlerMapping.class.getName() + ".lookupPath";
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
    // 1、使用路径帮助器拿到请求中的请求路径
    String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
    request.setAttribute(LOOKUP_PATH, lookupPath);
    this.mappingRegistry.acquireReadLock();
    try {
        // 2、通过请求路径拿到 HandlerMethod （核心）
        HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
        return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
    }
    finally {
        this.mappingRegistry.releaseReadLock();
    }
}

根据请求路径找到对应处理器-lookupHandlerMethod()

AbstractHandlerMethodMapping#lookupHandlerMethod

// RequestMappingInfo 集合 k:路径 v:RequestMappingInfo
private final MultiValueMap<String, T> urlLookup = new LinkedMultiValueMap<>();
// HandlerMethod 集合 k:RequestMappingInfo v:HandlerMethod
private final Map<T, HandlerMethod> mappingLookup = new LinkedHashMap<>();
protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
    // 根据路径匹配到的集合
    List<Match> matches = new ArrayList<>();
    // 1，根据路径找到对应的 RequestMappingInfo 集合
    List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
    if (directPathMatches != null) {
        // 2，匹配到的集合  这里面有 HandlerMethod 对象
        addMatchingMappings(directPathMatches, matches, request);
    }
    if (matches.isEmpty()) {
        // No choice but to go through all mappings...
        addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
    }
    if (!matches.isEmpty()) {
        // 3，从匹配到的集合中拿到第一个
        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.getMappings().keySet(), lookupPath, request);
    }
}

流程分析：

getMappingsByUrl()：去MappingRegistry（注册中心）中根据当前路径找到对应的RequestMappingInfo对象
addMatchingMappings()：再根据找到的RequestMappingInfo去MappingRegistry（注册中心）找HandlerMethod然后封装为Match对象，添加到matches集合中
如果匹配到了多个，会根据规则拿到最佳匹配的

1、getMappingsByUrl()

去MappingRegistry（注册中心）中根据当前路径找到对应的RequestMappingInfo对象

// RequestMappingInfo 集合 k:路径 v:RequestMappingInfo
private final MultiValueMap<String, T> urlLookup = new LinkedMultiValueMap<>();
public List<T> getMappingsByUrl(String urlPath) {
    return this.urlLookup.get(urlPath);
}

注意： PathVariable类型是不会加到这个集合里的，具体逻辑在这里，有兴趣可以去看这两个方法： org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.MappingRegistry#register()、org.springframework.web.servlet.handler.AbstractHandlerMethodMapping.MappingRegistry#getDirectUrls()

注意：这里key是路径，value是RequestMappingInfo对象

2、addMatchingMappings()

再根据找到的RequestMappingInfo去MappingRegistry（注册中心）找HandlerMethod然后封装为Match对象，添加到matches集合中

// HandlerMethod 集合 k:RequestMappingInfo v:HandlerMethod
private final Map<T, HandlerMethod> mappingLookup = new LinkedHashMap<>();
private void addMatchingMappings(Collection<T> mappings, List<Match> matches, HttpServletRequest request) {
    for (T mapping : mappings) {
        // 封装为 RequestMappingInfo
        T match = getMatchingMapping(mapping, request);
        if (match != null) {
            // 找到的集合，又会封装为 Match 对象
            matches.add(new Match(match, this.mappingRegistry.getMappings().get(mapping)));
        }
    }
}
// 封装 RequestMappingInfo
return new RequestMappingInfo(this.name, pathPatterns, patterns,
      methods, params, headers, consumes, produces, custom, this.options);

注意：这里的key是RequestMappingInfo对象，value是HandlerMethod

Match对象：

3、得到最佳匹配

最后如果找到了多个，会根据规则拿到最佳匹配的HandlerMethod对象返回给我们

HandlerMethod对象：

目标方法： HandlerMethod对象

获取处理器执行链对象-getHandlerExecutionChain()

protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
    // 1、封装 HandlerExecutionChain 对象
    HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
                                   (HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
    // 2、利用路径帮助器拿到当前路径
    String lookupPath = this.urlPathHelper.getLookupPathForRequest(request, LOOKUP_PATH);
    // 3、遍历所有的拦截器
    for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
        if (interceptor instanceof MappedInterceptor) {
            MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
            // 3、判断当前拦截器是否拦截此请求
            if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
                // 添加到目标对象中
                chain.addInterceptor(mappedInterceptor.getInterceptor());
            }
        }
        else {
            chain.addInterceptor(interceptor);
        }
    }
    return chain;
}

流程：

先把HandlerMethod封装到HandlerExecutionChain中
利用路径帮助器拿到当前请求路径
遍历所有的拦截器并判断当前拦截器是否拦截当前请求，拦截的话就添加到我们的HandlerExecutionChain 对象中，然后返回

这两个拦截器是默认的拦截器，不用管

里面就3个东西：处理器、拦截器集合、当前执行到第几个拦截器的索引

到这一步也就拿到了HandlerExecutionChain对象，最后还会有跨域的处理，就把这个对象返回出去了。

跨域放在下一篇说。

public boolean matches(String lookupPath, PathMatcher pathMatcher) {
    PathMatcher pathMatcherToUse = (this.pathMatcher != null ? this.pathMatcher : pathMatcher);
    // 当前路径是否在排除路径的列表中
    if (!ObjectUtils.isEmpty(this.excludePatterns)) {
        for (String pattern : this.excludePatterns) {
            if (pathMatcherToUse.match(pattern, lookupPath)) {
                return false;
            }
        }
    }
    if (ObjectUtils.isEmpty(this.includePatterns)) {
        return true;
    }
    // 当前路径是否在要拦截器的路径列表中
    for (String pattern : this.includePatterns) {
        if (pathMatcherToUse.match(pattern, lookupPath)) {
            return true;
        }
    }
    return false;
}

总结

HandlerMethod

目标方法。我们通过 @xxxMapping 修饰的Controller中接口就是目标方法。

会通过 RequestMappingHanderMapping 处理器适配器找到它。

会通过 RequestMappingHandlerAdapter 处理器适配器执行。

MappingRegistry

MappingRegistry：映射的注册中心

路径会映射为RequestMappingInfo对象，RequestMappingInfo又和HandlerMethod所映射

所以流程就是先根据路径找到对应的RequestMappingInfo，再根据RequestMappingInfo找到对应的HandlerMethod（目标方法）

HandlerMapping

HandlerMapping：处理器映射

public interface HandlerMapping {
   // 返回此请求的 HandlerExecutionChain 对象（Handler、Interceptor）
   @Nullable
   HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;
}