Spring MVC的handlermapping之请求分发如何找到正确的Handler(RequestMappingHandlerMapping)

这个思路同样是通过在AbstractHandlerMethodMapping里面来实现getHandlerInternal()实现自己的方法来处理寻找正确的处理器，不懂得请看上一篇。

    protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
        String lookupPath = this.getUrlPathHelper().getLookupPathForRequest(request); //同样从请求中获取url
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Looking up handler method for path " + lookupPath);
        }

        HandlerMethod handlerMethod = this.lookupHandlerMethod(lookupPath, request);//查找handler
        if (this.logger.isDebugEnabled()) {
            if (handlerMethod != null) {
                this.logger.debug("Returning handler method [" + handlerMethod + "]");
            } else {
                this.logger.debug("Did not find handler method for [" + lookupPath + "]");
            }
        }

        return handlerMethod != null ? handlerMethod.createWithResolvedBean() : null; //这块应该是为handler添加一些东西，参数等，
    }

    protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
        List<AbstractHandlerMethodMapping<T>.Match> matches = new ArrayList();
        List<T> directPathMatches = (List)this.urlMap.get(lookupPath); //找到匹配url的匹配条件List
        if (directPathMatches != null) {
            this.addMatchingMappings(directPathMatches, matches, request); //添加匹配对象 Match实际上是匹配条件，和处理器的封装对象
        }

        if (matches.isEmpty()) {
            this.addMatchingMappings(this.handlerMethods.keySet(), matches, request);
        }

        if (!matches.isEmpty()) {
            Comparator<AbstractHandlerMethodMapping<T>.Match> comparator = new AbstractHandlerMethodMapping.MatchComparator(this.getMappingComparator(request));
            Collections.sort(matches, comparator);
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Found " + matches.size() + " matching mapping(s) for [" + lookupPath + "] : " + matches);
            }
　　　　　　　//如果多个匹配条件，进行排序，子类自己实现比较方法，然后取第一个
            AbstractHandlerMethodMapping<T>.Match bestMatch = (AbstractHandlerMethodMapping.Match)matches.get(0);
            if (matches.size() > 1) { //如果存在两个复核条件的一样的处理器，则报错
                AbstractHandlerMethodMapping<T>.Match secondBestMatch = (AbstractHandlerMethodMapping.Match)matches.get(1);
                if (comparator.compare(bestMatch, secondBestMatch) == 0) {
                    Method m1 = bestMatch.handlerMethod.getMethod();
                    Method m2 = secondBestMatch.handlerMethod.getMethod();
                    throw new IllegalStateException("Ambiguous handler methods mapped for HTTP path '" + request.getRequestURL() + "': {" + m1 + ", " + m2 + "}");
                }
            }

            this.handleMatch(bestMatch.mapping, lookupPath, request); //实际上缓存到request域中 //这块子类也复写了，应该是多缓存了些东西
            return bestMatch.handlerMethod;
        } else {
            return this.handleNoMatch(this.handlerMethods.keySet(), lookupPath, request); //没找到子类已进行了复写
        }
    }

 RequestMappingInfoHandlerMapping 中 handleNoMatch 的实现

    protected HandlerMethod handleNoMatch(Set<RequestMappingInfo> requestMappingInfos, String lookupPath, HttpServletRequest request) throws ServletException {
        Set<String> allowedMethods = new HashSet(6);
        Set<RequestMappingInfo> patternMatches = new HashSet();
        Set<RequestMappingInfo> patternAndMethodMatches = new HashSet();
        Iterator i$ = requestMappingInfos.iterator();

        while(true) {
            while(true) {
                RequestMappingInfo info;
                do {
                    if (!i$.hasNext()) {
                        if (patternMatches.isEmpty()) {
                            return null;
                        }

                        if (patternAndMethodMatches.isEmpty() && !allowedMethods.isEmpty()) {
                            throw new HttpRequestMethodNotSupportedException(request.getMethod(), allowedMethods);
                        }

                        Set consumableMediaTypes;
                        Set producibleMediaTypes;
                        if (patternAndMethodMatches.isEmpty()) {
                            consumableMediaTypes = this.getConsumableMediaTypes(request, patternMatches);
                            producibleMediaTypes = this.getProdicubleMediaTypes(request, patternMatches);
                        } else {
                            consumableMediaTypes = this.getConsumableMediaTypes(request, patternAndMethodMatches);
                            producibleMediaTypes = this.getProdicubleMediaTypes(request, patternAndMethodMatches);
                        }

                        if (!consumableMediaTypes.isEmpty()) {
                            MediaType contentType = null;
                            if (StringUtils.hasLength(request.getContentType())) {
                                contentType = MediaType.parseMediaType(request.getContentType());
                            }

                            throw new HttpMediaTypeNotSupportedException(contentType, new ArrayList(consumableMediaTypes));
                        }

                        if (!producibleMediaTypes.isEmpty()) {
                            throw new HttpMediaTypeNotAcceptableException(new ArrayList(producibleMediaTypes));
                        }

                        return null;
                    }

                    info = (RequestMappingInfo)i$.next();
                } while(info.getPatternsCondition().getMatchingCondition(request) == null);

                patternMatches.add(info);
                if (info.getMethodsCondition().getMatchingCondition(request) != null) {
                    patternAndMethodMatches.add(info);
                } else {
                    Iterator i$ = info.getMethodsCondition().getMethods().iterator();

                    while(i$.hasNext()) {
                        RequestMethod method = (RequestMethod)i$.next();
                        allowedMethods.add(method.name());
                    }
                }
            }
        }
    }

实际上这一步是又匹配了一遍，没有在返回空， 有的话 就报异常