Spring MVC的handlermapping之BeanNameUrlHandlerMapping初始化

先介绍一下：

　　BeanNameUrlHandlerMapping是基于配置文件的方式; 所有处理器需要在XML文件中，以Bean的形式配置。

　　缺点：配置繁琐; 如果多个URL对应同一个处理器，那么需要配置多条，同时也会实例化多个对象等等。。。

　　因为springmvc 是基于spring的，所以他的初始化肯定是在spring容器初始化之后才进行的。

先上类图：

　　

可以看到BeanNameUrlHandlerMapping父类最终实现了ApplicationContextAware接口,所以Spring容器会自动注入ApplicationContext，方法为：

     public final void setApplicationContext(ApplicationContext context) throws BeansException {
         if (context == null && !this.isContextRequired()) {
             this.applicationContext = null;
             this.messageSourceAccessor = null;
         } else if (this.applicationContext == null) {
             if (!this.requiredContextClass().isInstance(context)) {
                 throw new ApplicationContextException("Invalid application context: needs to be of type [" + this.requiredContextClass().getName() + "]");
             }

             this.applicationContext = context;
             this.messageSourceAccessor = new MessageSourceAccessor(context);
             this.initApplicationContext(context);  //这块实际上是一个钩子方法，供子类去覆盖! 进行初始化工作
         } else if (this.applicationContext != context) {
             throw new ApplicationContextException("Cannot reinitialize with different application context: current one is [" + this.applicationContext + "], passed-in one is [" + context + "]");
         }

     }

AbstractHandlerMapping： 这个类就是复写了这个方法 进行了拦截器的初始化

    protected void initApplicationContext() throws BeansException {
        this.extendInterceptors(this.interceptors); //供子类扩展拦截器
        this.detectMappedInterceptors(this.mappedInterceptors);//扫描应用下的MappedInterceptor,并添加到mappedInterceptors
        this.initInterceptors();//归集MappedInterceptor,并适配HandlerInterceptor和WebRequestInterceptor
    }

AbstractDetectingUrlHandlerMapping ：同样重写这个方法，实现自己的逻辑

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

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

         for(int i$ = ; i$ < len$; ++i$) { //遍历每一个扫描出来的类
             String beanName = arr$[i$];
             String[] urls = this.determineUrlsForHandler(beanName); //钩子方法，让子类去实现，通过handler解析url
             if (!ObjectUtils.isEmpty(urls)) {
                 this.registerHandler(urls, beanName); //返回的URL进行注册，实际上就是放到AbstractUrlHandlerMapping的一个map中
             } else if (this.logger.isDebugEnabled()) {
                 this.logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");
             }
         }

     }

BeanNameUrlHandlerMapping：实际上就实现了determineUrlsForHandler这个方法：

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package org.springframework.web.servlet.handler;

import java.util.ArrayList;
import java.util.List;
import org.springframework.util.StringUtils;

public class BeanNameUrlHandlerMapping extends AbstractDetectingUrlHandlerMapping {
    public BeanNameUrlHandlerMapping() {
    }

    protected String[] determineUrlsForHandler(String beanName) {
        List<String> urls = new ArrayList();
        if (beanName.startsWith("/")) { //只有一点需要注意 就是bean id 必须是以'/'开头
            urls.add(beanName);
        }

        String[] aliases = this.getApplicationContext().getAliases(beanName);
        String[] arr$ = aliases;
        int len$ = aliases.length;

        for(int i$ = ; i$ < len$; ++i$) {
            String alias = arr$[i$];
            if (alias.startsWith("/")) {
                urls.add(alias);
            }
        }

        return StringUtils.toStringArray(urls);
    }
}

AbstractUrlHandlerMappin：中注册处理器的方法：

     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;
         if (!this.lazyInitHandlers && handler instanceof String) {
             String handlerName = (String)handler;
             if (this.getApplicationContext().isSingleton(handlerName)) {
                 resolvedHandler = this.getApplicationContext().getBean(handlerName);
             }
         }

         Object mappedHandler = this.handlerMap.get(urlPath);
         if (mappedHandler != null) {
             if (mappedHandler != resolvedHandler) { //不允许存在相同url不同handler，否则抛异常
                 throw new IllegalStateException("Cannot map " + this.getHandlerDescription(handler) + " to URL path [" + urlPath + "]: There is already " + this.getHandlerDescription(mappedHandler) + " mapped.");
             }
         } else if (urlPath.equals("/")) {
             if (this.logger.isInfoEnabled()) {
                 this.logger.info("Root mapping to " + this.getHandlerDescription(handler));
             }

             this.setRootHandler(resolvedHandler);
         } else if (urlPath.equals("/*")) {
             if (this.logger.isInfoEnabled()) {
                 this.logger.info("Default mapping to " + this.getHandlerDescription(handler));
             }

             this.setDefaultHandler(resolvedHandler);
         } else { //这才是正常的存储逻辑
             this.handlerMap.put(urlPath, resolvedHandler);
             if (this.logger.isInfoEnabled()) {
                 this.logger.info("Mapped URL path [" + urlPath + "] onto " + this.getHandlerDescription(handler));
             }
         }

     }

到这里实际上处理器映射器的保存工作就算完事了。

实际上handlerMapping这一块，主要思路就是 写一个模板类，来处理公共的方法，如初始化拦截器，然后留下钩子方法，让子类去实现自己的逻辑就好了。