Spring MVC的handlermapping之請求分發如何找到正確的Handler(BeanNameUrlHandlerMapping,SimpleUrlHandlerMapping)

本文講的是Spring MVC如何找到正確的handler, 前面請求具體怎么進入到下面的方法，不再細說。

大概就是Spring mvc通過servlet攔截請求，實現doService方法，然后進入doDispatch()方法，這個是完成請求的方法.

今天我們只分析：mappedHandler = this.getHandler(processedRequest, false); 這一個方法;

    protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        Iterator i$ = this.handlerMappings.iterator();//handlerMapping 是初始化的時候就保存好的,如果多個的話已經排序好了

        HandlerExecutionChain handler; //實際上返回的handler是一個 handler鏈，包含了處理器和攔截器
        do {
            if (!i$.hasNext()) {
                return null;
            }
            //這塊發現實際上就是取第一個就好了
            HandlerMapping hm = (HandlerMapping)i$.next();
            if (this.logger.isTraceEnabled()) {
                this.logger.trace("Testing handler map [" + hm + "] in DispatcherServlet with name '" + this.getServletName() + "'");
            }

            handler = hm.getHandler(request); //然后調用具體處理器的getHandler方法
        } while(handler == null);

        return handler;
    }

現在以BeanNameUrlHandlerMapping為例：

這個類的繼承關系前面幾篇文章已經介紹過了。實際上父類AbstractHandlerMapping實現了gethandler方法，還記得這個類初始化的時候做的是初始化攔截器，然后讓子類重寫方法initApplicationContext進行處理注冊 

    public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
        Object handler = this.getHandlerInternal(request);//鈎子方法，讓子類自己去實現，查找處理器的邏輯
        if (handler == null) {
            handler = this.getDefaultHandler();
        }

        if (handler == null) {
            return null;
        } else {
            if (handler instanceof String) {
                String handlerName = (String)handler;
                handler = this.getApplicationContext().getBean(handlerName);
            }

            return this.getHandlerExecutionChain(handler, request);//封裝 處理器鏈
        }
    }

getHandlerInternal是由AbstractUrlHandlerMapping實現的， 他是BeanNameUrlHandlerMapping和SimpleUrlHandlerMapping的父類，所以，兩個映射器都是通過這個方法查找的，

    protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
        String lookupPath = this.getUrlPathHelper().getLookupPathForRequest(request); //從請求中獲取URL
        Object handler = this.lookupHandler(lookupPath, request); //查找handler
        if (handler == null) { //如果沒找到 給一個默認的處理器
            Object rawHandler = null; 
            if ("/".equals(lookupPath)) {
                rawHandler = this.getRootHandler();
            }

            if (rawHandler == null) {
                rawHandler = this.getDefaultHandler();
            }

            if (rawHandler != null) {
                if (rawHandler instanceof String) {
                    String handlerName = (String)rawHandler;
                    rawHandler = this.getApplicationContext().getBean(handlerName);
                }

                this.validateHandler(rawHandler, request);
                handler = this.buildPathExposingHandler(rawHandler, lookupPath, lookupPath, (Map)null);//添加兩個攔截器，作用？
            }
        }

        if (handler != null && this.logger.isDebugEnabled()) {
            this.logger.debug("Mapping [" + lookupPath + "] to " + handler);
        } else if (handler == null && this.logger.isTraceEnabled()) {
            this.logger.trace("No handler mapping found for [" + lookupPath + "]");
        }

        return handler;
    }

    protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
        Object handler = this.handlerMap.get(urlPath); //直接從map中獲取
        if (handler != null) {
            if (handler instanceof String) {
                String handlerName = (String)handler;
                handler = this.getApplicationContext().getBean(handlerName);
            }

            this.validateHandler(handler, request);
            return this.buildPathExposingHandler(handler, urlPath, urlPath, (Map)null);//添加攔截器
        } else {
            List<String> matchingPatterns = new ArrayList(); //如果沒找到就遍歷所有的map的url，進行匹配
            Iterator i$ = this.handlerMap.keySet().iterator();

            while(i$.hasNext()) {
                String registeredPattern = (String)i$.next();
                if (this.getPathMatcher().match(registeredPattern, urlPath)) {
                    matchingPatterns.add(registeredPattern);
                }
            }

            String bestPatternMatch = null;
            Comparator<String> patternComparator = this.getPathMatcher().getPatternComparator(urlPath);
            if (!matchingPatterns.isEmpty()) {
                Collections.sort(matchingPatterns, patternComparator);
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Matching patterns for request [" + urlPath + "] are " + matchingPatterns);
                }

                bestPatternMatch = (String)matchingPatterns.get(0); //如果有匹配的上的，取第一個
            }

            if (bestPatternMatch != null) {
                handler = this.handlerMap.get(bestPatternMatch);
                String pathWithinMapping;
                if (handler instanceof String) {
                    pathWithinMapping = (String)handler;
                    handler = this.getApplicationContext().getBean(pathWithinMapping);
                }

                this.validateHandler(handler, request);
                pathWithinMapping = this.getPathMatcher().extractPathWithinPattern(bestPatternMatch, urlPath);
                Map<String, String> uriTemplateVariables = new LinkedHashMap();
                Iterator i$ = matchingPatterns.iterator();

                while(i$.hasNext()) {
                    String matchingPattern = (String)i$.next();
                    if (patternComparator.compare(bestPatternMatch, matchingPattern) == 0) {
                        Map<String, String> vars = this.getPathMatcher().extractUriTemplateVariables(matchingPattern, urlPath);
                        Map<String, String> decodedVars = this.getUrlPathHelper().decodePathVariables(request, vars);
                        uriTemplateVariables.putAll(decodedVars);
                    }
                }

                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("URI Template variables for request [" + urlPath + "] are " + uriTemplateVariables);
                }

                return this.buildPathExposingHandler(handler, bestPatternMatch, pathWithinMapping, uriTemplateVariables);
            } else {
                return null;
            }
        }
    }

到此為止就找到了handler,並且添加了攔截器