博客

RequestMappingHandlerMapping：这个handlerMapping是基于注解的
同样，先上类图：

通过类图可以看到，同样是继承父类 AbstractHandlerMapping来进行拦截器的初始化工作,实际上处理自己逻辑的只有下面三个类;
需要注意的是RequestMappingHandlerMapping初始化并不是重写initApplicationContext()方法 ,而是通过实现InitializingBean接口来进行初始工作的。

备注：InitializingBean接口为bean提供了初始化方法的方式，它只包括afterPropertiesSet方法，凡是实现该接口的类，在初始化bean的时候会执行该方法。
来看AbstractHandlerMethodMapping 中关键的代码：

    public void afterPropertiesSet() { //实现了InitializingBean接口的方法，进行初始化的入口。
        this.initHandlerMethods();
    }

    protected void initHandlerMethods() {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Looking for request mappings in application context: " + this.getApplicationContext());
        }
　　　　 //扫描应用下所有Object类
        String[] beanNames = this.detectHandlerMethodsInAncestorContexts ? BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.getApplicationContext(), Object.class) : this.getApplicationContext().getBeanNamesForType(Object.class);
        String[] arr$ = beanNames;
        int len$ = beanNames.length;

        for(int i$ = 0; i$ < len$; ++i$) {
            String beanName = arr$[i$];
            if (this.isHandler(this.getApplicationContext().getType(beanName))) { //ishandler由子类实现，是个钩子方法，让子类实现自己的逻辑
                this.detectHandlerMethods(beanName);
            }
        }

        this.handlerMethodsInitialized(this.getHandlerMethods());//初始化处理器对象，目前是钩子方法，但是也没有子类实现这个方法
    }

isHandler方法是在RequestMappingHandlerMapping中实现的

    protected boolean isHandler(Class<?> beanType) { //非常简单， 就是看这个类有没有Controller或者RequestMapping注解，有一个就行
        return AnnotationUtils.findAnnotation(beanType, Controller.class) != null || AnnotationUtils.findAnnotation(beanType, RequestMapping.class) != null;
    }

回到AbstractHandlerMethodMapping看：

    protected void detectHandlerMethods(Object handler) { //开始注册handler
        Class<?> handlerType = handler instanceof String ? this.getApplicationContext().getType((String)handler) : handler.getClass();
        final Class<?> userType = ClassUtils.getUserClass(handlerType);
　　　　　　//这块是获取handelr的所有方法，但是有一个过滤器，就是把有匹配条件的的method获取到
        Set<Method> methods = HandlerMethodSelector.selectMethods(userType, new MethodFilter() {
            public boolean matches(Method method) {
                return AbstractHandlerMethodMapping.this.getMappingForMethod(method, userType) != null;//getMappingForMethod钩子方法，子类实现
            }
        });
        Iterator i$ = methods.iterator();
        //遍历method 进行注册。
        while(i$.hasNext()) {
            Method method = (Method)i$.next();
            T mapping = this.getMappingForMethod(method, userType);
            this.registerHandlerMethod(handler, method, mapping);
        }

    }

来看getMappingForMethod的实现，是在RequestMappingHandlerMapping实现的

    protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) { 
        RequestMappingInfo info = null; //获取方法上的RequestMapping注解信息
        RequestMapping methodAnnotation = (RequestMapping)AnnotationUtils.findAnnotation(method, RequestMapping.class);
        if (methodAnnotation != null) {
            RequestCondition<?> methodCondition = this.getCustomMethodCondition(method);
            info = this.createRequestMappingInfo(methodAnnotation, methodCondition); 构造匹配条件
　　　　　　　　 // 获取类上的面RequestHandlerMapping注解信息
            RequestMapping typeAnnotation = (RequestMapping)AnnotationUtils.findAnnotation(handlerType, RequestMapping.class);
            if (typeAnnotation != null) {
                RequestCondition<?> typeCondition = this.getCustomTypeCondition(handlerType);
                info = this.createRequestMappingInfo(typeAnnotation, typeCondition).combine(info); 构造匹配条件，同方法的进行合并
            }
        }

        return info;
    }

备注下

;RequestMappingInfo 实际上是匹配条件的一个抽象对象，包含了url,method,param,header…等等

来看注册方法前，先看一下处理器是保存在哪的;

public abstract class AbstractHandlerMethodMapping<T> extends AbstractHandlerMapping implements InitializingBean {
    //这块实际上是两个map保存的，泛型实际上就是RequestMappingInfo,这个就是匹配条件 HanlderMethod是封装了处理器全部信息的封装类

    private final Map<T, HandlerMethod> handlerMethods = new LinkedHashMap(); //存的是 key：匹配条件 value: 处理器
    private final MultiValueMap<String, T> urlMap = new LinkedMultiValueMap(); //key: url value: 匹配条件

这块讲一下MultiValueMap

public interface MultiValueMap<K, V> extends Map<K, List<V>> //实际上就是个 value是个list的map

    protected void registerHandlerMethod(Object handler, Method method, T mapping) {
        HandlerMethod handlerMethod;
        if (handler instanceof String) {
            String beanName = (String)handler;
            handlerMethod = new HandlerMethod(beanName, this.getApplicationContext(), method);
        } else {
            handlerMethod = new HandlerMethod(handler, method);
        }

        HandlerMethod oldHandlerMethod = (HandlerMethod)this.handlerMethods.get(mapping);
        if (oldHandlerMethod != null && !oldHandlerMethod.equals(handlerMethod)) { //不允许存在一个mapping对应多个handlerMethod
            throw new IllegalStateException("Ambiguous mapping found. Cannot map '" + handlerMethod.getBean() + "' bean method \n" + handlerMethod + "\nto " + mapping + ": There is already '" + oldHandlerMethod.getBean() + "' bean method\n" + oldHandlerMethod + " mapped.");
        } else {
            this.handlerMethods.put(mapping, handlerMethod); //存放第一个映射集合
            if (this.logger.isInfoEnabled()) {
                this.logger.info("Mapped \"" + mapping + "\" onto " + handlerMethod);
            }

            Set<String> patterns = this.getMappingPathPatterns(mapping); //获取方法的URL
            Iterator i$ = patterns.iterator();

            while(i$.hasNext()) {
                String pattern = (String)i$.next();
                if (!this.getPathMatcher().isPattern(pattern)) { //依次放入第二个映射集合
                    this.urlMap.add(pattern, mapping);
                }
            }

        }
    }

到此为止，RequestMappingHandlerMapping就初始化完成了。

疑问：  为什么非注解映射器都是通过重写initApplication方法，而注解映射器是通过实现iniliazingBean接口来初始化，这样的好处是什么？

欢迎探讨