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

實際上這一步是又匹配了一遍，沒有在返回空， 有的話 就報異常