HandlerMapping的作用

HandlerMapping的主要作用是注册Handler和获取Handler。

注册Handler

HandleMapping注册Handler发生在SpringMVC容器启动的过程中，在注册Handler的同时也初始化拦截器。

BeanNameUrlHandlerMapping类图

注册Handle源码走读

//AbstractDetectingUrlHandlerMapping类中initApplicationContext()方法

public void initApplicationContext() throws ApplicationContextException { 
//初始化拦截器
super.initApplicationContext(); 
//注册处理器
detectHandlers();
}

//AbstractHandlerMapping类中initApplicationContext()实现
protected void initApplicationContext() throws BeansException {  
extendInterceptors(this.interceptors);
detectMappedInterceptors(this.mappedInterceptors);  
initInterceptors();
}

//AbstractDetectingUrlHandlerMapping类中detectHandlers()实现
protected void detectHandlers() throws BeansException {
        if (logger.isDebugEnabled()) {
            logger.debug("Looking for URL mappings in application context: " + getApplicationContext());
        }
        String[] beanNames = (this.detectHandlersInAncestorContexts ?
                BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
                getApplicationContext().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);
            }
            else {
                if (logger.isDebugEnabled()) {
                    logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");
                }
            }
        }
    }


//BeanNameUrlHandlerMapping类中determineUrlsForHandler()实现
//获取以"/"开头的beanName
protected String[] determineUrlsForHandler(String beanName) {
        List<String> urls = new ArrayList<String>();
        if (beanName.startsWith("/")) {
            urls.add(beanName);
        }
        String[] aliases = getApplicationContext().getAliases(beanName);
        for (String alias : aliases) {
            if (alias.startsWith("/")) {
                urls.add(alias);
            }
        }
        return StringUtils.toStringArray(urls);
    }
//AbstractUrlHandlerMapping类中实现
protected void registerHandler(String[] urlPaths, String beanName) throws BeansException, IllegalStateException {
        Assert.notNull(urlPaths, "URL path array must not be null");
        for (String urlPath : urlPaths) {
            //注册处理器
            registerHandler(urlPath, beanName);
        }
    ｝
//AbstractUrlHandlerMapping类中registerHandler()实现

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;
            if (getApplicationContext().isSingleton(handlerName)) {
                resolvedHandler = getApplicationContext().getBean(handlerName);
            }
        }
        //mappedHandler为保存处理器的map,key值为请求地址(/hello)
        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.isInfoEnabled()) {
                    logger.info("Root mapping to " + getHandlerDescription(handler));
                }
                setRootHandler(resolvedHandler);
            }
            else if (urlPath.equals("/*")) {
                if (logger.isInfoEnabled()) {
                    logger.info("Default mapping to " + getHandlerDescription(handler));
                }
                setDefaultHandler(resolvedHandler);
            }
            else {
                this.handlerMap.put(urlPath, resolvedHandler);
                if (logger.isInfoEnabled()) {
                    logger.info("Mapped URL path [" + urlPath + "] onto " + getHandlerDescription(handler));
                }
            }
        }
    }

获取Handler

获取Handler其实获取的是HandlerExecutionChain，HandlerExecutionChain包括一个Handler和一组拦截器。

获取Handler的时序图

获取Handle源码走读

//AbstractHandlerMapping类中getHandler()实现
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 = getApplicationContext().getBean(handlerName);
        }
        //获取HandlerExecutionChain
        return getHandlerExecutionChain(handler, request);
    }

//AbstractHandlerMapping类中getHandlerExecutionChain()实现
protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
        HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
                (HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
        //将<bean <property>>配置的拦截器添加到对应的拦截器List中
        chain.addInterceptors(getAdaptedInterceptors());

        String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
        for (MappedInterceptor mappedInterceptor : this.mappedInterceptors) {
            if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
                //<mvc:interceptors>都会被解析成MappedInterceptor
                chain.addInterceptor(mappedInterceptor.getInterceptor());
            }
        }
        return chain;
    }