SpringMVC的流程分析（二）—— HandlerMapping组件

1.HandlerMapping的类结构

　　

　　如上图所示，HandlerMapping接口有一个叫做；getHandler()的方法，这个方法是用来回去HandlerMapping对应的处理器的，由此也就可以看出HandlerMapping主要是用来映射请求和处理器的。

AbstractHandlerMapping实现了HandlerMapping接口，还继承了WebApplicationObjectSupport，而WebApplicationObjectSupport最终实现了ApplicationContextAware接口，这个接口使用来扩展

Spring的，ApplicationContextAware可以对应用上下文进行加工，加入自己的逻辑，SpringMVC就是通过它来实现的url和处理器的映射。

　　接下来我们看到AbstractHandlerMethodMapping和AbstractUrlHandlerMapping都继承了AbstractHandlerMapping，这两个类分别从不同的角度来映射请求和处理器。

2.AbstractHandlerMapping具体的实现

　2.1 AbstractUrlHandlerMapping

　　我们分开来看，首先分析AbstractUrlHandlerMapping,这个类是用来映射url和handler的，它维护了一个handlerMap用来存储url相应的处理器，它的实现类AbstractDetectingUrlHandlerMapping重写了

initApplictionContext()方法：

@Override
    public void initApplicationContext() throws ApplicationContextException {
        super.initApplicationContext();
        detectHandlers();
    }

　　可以看到他调用了父类的initApplicationContext方法，然后又调用了detectHandlers()方法来处理请求映射，看detectHandler()源码：

protected void detectHandlers() throws BeansException {

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

　　第一步，获取所有的beanname，第二步，根据这个beanName查询它是不是一个处理器，并取出他的url，

　　determineUrlsForHandler有多种实现，我们拿AbstractControllerUrlHandlerMapping举例说明：

@Override
    protected String[] determineUrlsForHandler(String beanName) {
        Class<?> beanClass = getApplicationContext().getType(beanName);
        if (isEligibleForMapping(beanName, beanClass)) {
            return buildUrlsForHandler(beanName, beanClass);
        }
        else {
            return null;
        }
    }

　　首先从应用上下文中根据beanname获取到bean的class对象，然后判断有没有成为处理器的资格，即判断是否实现了Controller接口。

然后调用buildUrlsForHandler()方法获取处理器的url，然后返回。

　　接下来执行  registerHandler(urls, beanName) ：

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

　　registerHandler(url,beanname)

　　

protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {

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

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

　　　首先从上下文拿到一个处理器实例，然后根据url的不同，将它设置到不同的处理器存储位置，例如，如果url是"/"就将处理器设置为根处理器，

　　如果url是"/*"就将处理器设置为默认处理器。如果都不是就放进handleMap中。

　　通过以上步骤，我们就将上下文中所有的bean循环了一遍，只要是符合HandlerMapping的规则的处理器，就会将他的映射关系存储起来。

　　2.2 AbstractHandlerMethodMapping

　　　　AbstractHandlerMethodMapping和AbstractUrlMethodMapping有所不同,他实现了InitializingBean接口，通过实现afterPropertiesSet()方法来扩展相应的业务

public void afterPropertiesSet() {
        initHandlerMethods();
    }

　　　　调用了initHandlerMethods()

protected void initHandlerMethods() {
        String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ?
                BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
                getApplicationContext().getBeanNamesForType(Object.class));

        for (String beanName : beanNames) {
            if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX) &&
                    isHandler(getApplicationContext().getType(beanName))){
                detectHandlerMethods(beanName);
            }
        }
        handlerMethodsInitialized(getHandlerMethods());
    }

　　首先获取所有的beanname，然后遍历这些bean，判断他是不是处理器，不同的实现有不同的判断方法，那我们最常用的@Controller为例说明

protected boolean isHandler(Class<?> beanType) {
        return ((AnnotationUtils.findAnnotation(beanType, Controller.class) != null) ||
                (AnnotationUtils.findAnnotation(beanType, RequestMapping.class) != null));
    }

判断这个类有没有@Controller或者@ReuqestMapping注解就可以了.

　　接下来执行detectHandlerMethods(beanName)

protected void detectHandlerMethods(final Object handler) {
        Class<?> handlerType =
                (handler instanceof String ? getApplicationContext().getType((String) handler) : handler.getClass());

        // Avoid repeated calls to getMappingForMethod which would rebuild RequestMappingInfo instances
        final Map<Method, T> mappings = new IdentityHashMap<Method, T>();
        final Class<?> userType = ClassUtils.getUserClass(handlerType);

        Set<Method> methods = HandlerMethodSelector.selectMethods(userType, new MethodFilter() {
            @Override
            public boolean matches(Method method) {
                T mapping = getMappingForMethod(method, userType);
                if (mapping != null) {
                    mappings.put(method, mapping);
                    return true;
                }
                else {
                    return false;
                }
            }
        });

        for (Method method : methods) {
            registerHandlerMethod(handler, method, mappings.get(method));
        }
    }

可以看到它首先会得到所有的方法，然后对方法进行过滤，调用matches方法，还是拿@Controller举例：　

　　

protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
        RequestMappingInfo info = null;
        RequestMapping methodAnnotation = AnnotationUtils.findAnnotation(method, RequestMapping.class);
        if (methodAnnotation != null) {
            RequestCondition<?> methodCondition = getCustomMethodCondition(method);
            info = createRequestMappingInfo(methodAnnotation, methodCondition);
            RequestMapping typeAnnotation = AnnotationUtils.findAnnotation(handlerType, RequestMapping.class);
            if (typeAnnotation != null) {
                RequestCondition<?> typeCondition = getCustomTypeCondition(handlerType);
                info = createRequestMappingInfo(typeAnnotation, typeCondition).combine(info);
            }
        }
        return info;
    }

　可以看到他是判断方法有没有RequestMapping注解来过滤方法的，所有过滤出来的方法都会生成一个 RequestMappingInfo,（它包含该方法的所有的注解信息），放进maps里面，

接下来就是将所有的方法进行注册：

　　

protected void registerHandlerMethod(Object handler, Method method, T mapping) {
        HandlerMethod newHandlerMethod = createHandlerMethod(handler, method);
        HandlerMethod oldHandlerMethod = this.handlerMethods.get(mapping);
        if (oldHandlerMethod != null && !oldHandlerMethod.equals(newHandlerMethod)) {
            throw new IllegalStateException("Ambiguous mapping found. Cannot map '" + newHandlerMethod.getBean() +
                    "' bean method \n" + newHandlerMethod + "\nto " + mapping + ": There is already '" +
                    oldHandlerMethod.getBean() + "' bean method\n" + oldHandlerMethod + " mapped.");
        }

        this.handlerMethods.put(mapping, newHandlerMethod);
        if (logger.isInfoEnabled()) {
            logger.info("Mapped \"" + mapping + "\" onto " + newHandlerMethod);
        }

        Set<String> patterns = getMappingPathPatterns(mapping);
        for (String pattern : patterns) {
            if (!getPathMatcher().isPattern(pattern)) {
                this.urlMap.add(pattern, mapping);
            }
        }

        if (this.namingStrategy != null) {
            String name = this.namingStrategy.getName(newHandlerMethod, mapping);
            updateNameMap(name, newHandlerMethod);
        }
    }

首先创建一个HandlerMethod对象，用来包装处理器和对应的方法。然后判断是否有重复的handlermethod，然后将映射类和处理类放进handlerMethods中，

可以看到，他还会将url和映射信息放进一个urlMap来记录，这说明多个请求可能对应同一个映射。

以上就是HandlerMapping的大体作用和流程信息，用来呈放web应用的映射信息，关于如何根据request寻找到对应的映射器，将在下一章介绍。