SpringMVC【二】HandlerMapping

• 版本说明：5.1.3-RELEASE

上节我们对DispatcherServlet如何串起请求的流程进行了梳理，本文将针对其中的HandlerMapping进行研究。

HandlerMapping

我们知道HandlerMapping是一个接口，只有一个getHandler(HttpServletRequest request)接口方法需要子类实现，返回HandlerExecutionChain对象，HandlerExecutionChain具体包含Handler对象以及Interceptors集合；如下是具体代码：

public interface HandlerMapping {
    /**省略部分常量**/
    @Nullable
    HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;
}

-----------------------------------------分割线------------------------------------
public class HandlerExecutionChain {
    /**handler对象**/
    private final Object handler;

    @Nullable
    private HandlerInterceptor[] interceptors;
    /**拦截器集合**/
    @Nullable
    private List<HandlerInterceptor> interceptorList;
}

我们再通过如下类图了解HandlerMapping的继承实现结构：

HandlerMapping

AbstractHandlerMapping

我们先看HandlerMapping的抽象子类AbstractHandlerMapping是如何实现getHandler接口的：

getHandler 抽象方法以及包装过程

那么getHandlerInternal具体是如何实现的呢，我们来看看AbstractHandlerMapping的两个子类；

AbstractHandlerMapping子类

AbstractHandlerMapping子类AbstractHandlerMethodMapping

获取HandlerMethod过程

AbstractHandlerMethodMapping实现getHandlerInternal方法

getHandlerInternal

我们一起来梳理一下获取getHandlerInternal的过程：
1.先根据请求获取lookupPath
2.根据lookupPath以及request调用lookupHandlerMethod
3.Match是抽象类的一个内部类，用于记录Mapping跟HandlerMethod对应关系
4.具体的是否匹配在调用addMatchingMappings时由子类实现getMatchingMapping方法来确定
5.如果匹配的match不唯一，由子类利用getMappingComparator方法返回comparator来决定。
6.返回bestMatch.handlerMethod

HandlerMethod初始化过程

我们通过以上代码了解到如何HandlerMethod，那么mappingRegistry是如何初始化的呢？

AbstractHandlerMethodMapping实现了InitializingBean接口，初始化时会调用afterPropertiesSet方法，此方法便是入口，以下是代码流程：

@Override
public void afterPropertiesSet() {
/**1.调用初始化方法**/
initHandlerMethods();
}

/**初始化HandlerMethod**/
protected void initHandlerMethods() {
/**2.getCandidateBeanNames获取候选的BeanName**/
/**遍历所有候选beanName**/
for (String beanName : getCandidateBeanNames()) {
    if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
          /**3.处理候选的Beans**/            
          processCandidateBean(beanName);
    }
}

handlerMethodsInitialized(getHandlerMethods());
}

/**获取候选的BeanName**/
protected String[] getCandidateBeanNames() {
return (this.detectHandlerMethodsInAncestorContexts ?
        BeanFactoryUtils.beanNamesForTypeIncludingAncestors(obtainApplicationContext(), Object.class) :
        obtainApplicationContext().getBeanNamesForType(Object.class));
}

/**处理候选的Beans**/
protected void processCandidateBean(String beanName) {
Class<?> beanType = null;
try {
    beanType = obtainApplicationContext().getType(beanName);
}
catch (Throwable ex) {
    if (logger.isTraceEnabled()) {
        logger.trace("Could not resolve type for bean '" + beanName + "'", ex);
    }
}
 /**4.isHandler抽象方法由子类实现**/
if (beanType != null && isHandler(beanType)) {
     /**5.探测HandlerMethod**/
      detectHandlerMethods(beanName);
}
}

/**抽象方法由子类实现，被Controller或RequestMapping注解标注**/
protected abstract boolean isHandler(Class<?> beanType);

/**探测HandlerMethod**/   
protected void detectHandlerMethods(Object handler) {
/**获取handler的类类型**/
Class<?> handlerType = (handler instanceof String ?
        obtainApplicationContext().getType((String) handler) : handler.getClass());

if (handlerType != null) {
    /**获取实际类类型，handlerType有可能是由CGLIB代理生成的子类**/
    Class<?> userType = ClassUtils.getUserClass(handlerType);
/**反射获取userType类的方法以及T，T泛型由子类指定**/  
    Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
            (MethodIntrospector.MetadataLookup<T>) method -> {
                try {
                    /**6.抽象方法，由子类实现，返回该方法的Mapping信息**/
                    return getMappingForMethod(method, userType);
                }
                catch (Throwable ex) {
                    throw new IllegalStateException("Invalid mapping on handler class [" +
                            userType.getName() + "]: " + method, ex);
                }
            });
    if (logger.isTraceEnabled()) {
        logger.trace(formatMappings(userType, methods));
    }
    methods.forEach((method, mapping) -> {
        Method invocableMethod = AopUtils.selectInvocableMethod(method, userType);
        /**7.注册Handler，method，mapping到MappingRegistry**/
        registerHandlerMethod(handler, invocableMethod, mapping);
    });
}
}

/**注册Handler，method，mapping到MappingRegistry**/
protected void registerHandlerMethod(Object handler, Method method, T mapping) {
    this.mappingRegistry.register(mapping, handler, method);
}

image.png

我们梳理一下注册的流程：
1.初始化时调用initHandlerMethods方法
2.获取候选beanNames
3.处理候选beanName
4.由子类isHandler方法完成是否handler判断
5.探测HandlerMethods
6.由子类返回getMappingForMethod的Mapping信息
7.注册Handler，method，mapping到MappingRegistry

AbstractHandlerMethodMapping继承关系如下：

AbstractHandlerMethodMapping子类

RequestMappingHandlerMapping中isHandler方法实现

@Override
protected boolean isHandler(Class<?> beanType) {
    return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
            AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));
}

RequestMappingHandlerMapping中根据一个类是否有@Controller或@RequestMapping注解来判断是否是Handler

而AbstractHandlerMethodMapping的另一个子类RequestMappingInfoHandlerMapping则指定了泛型RequestMappingInfo，前文中所讲的T的真身便是RequestMappingInfo了，它具体就是解析了@RequestMapping注解中的值。

// @RequestMapping 中的信息
private final String name;
// @RequestMapping 中 value|path 的解析器,
private final PatternsRequestCondition patternsCondition;
// @RequestMapping 中 RequestMethod 的解析器
private final RequestMethodsRequestCondition methodsCondition;
// @RequestMapping 中 param 的解析器
private final ParamsRequestCondition paramsCondition;
// @RequestMapping 中 headers 的解析器
private final HeadersRequestCondition headersCondition;
// @RequestMapping 中 consumes 的解析器
private final ConsumesRequestCondition consumesCondition;
// @RequestMapping 中 produces 的解析器
private final ProducesRequestCondition producesCondition;
// RequestCondition 的 holder
private final RequestConditionHolder customConditionHolder;

AbstractHandlerMapping子类AbstractUrlHandlerMapping

我们知道AbstractHandlerMapping有两个关键的子类一个是AbstractMethodHandlerMapping，而另一个则是AbstractUrlHandlerMapping，同样的先看getHandlerInternal实现

获取Handler过程

getHandlerInternal lookupHandler buildPathExposingHandler

我们梳理一下获取Handler的过程：
1.调用lookupHandler
2.根据urlPath获取，不为空则构建Handler返回
3.为空则根据pattern获取，获取到最匹配的则构建返回
4.如果没有获取到则处理默认Handler，如：RootHandler，DefaultHandler等
5.返回Handler

Handler初始化过程

同样的我们了解清楚获取的过程以后，一起来学习一下初始化Handler的过程，我们没有找到初始化相关的initXX方法，当时发现了registerHandler方法，我们大胆的猜想，它可能是有子类初始化时调用的，我们先看这个方法具体的内容：

registerHandler

AbstractUrlHandlerMapping继承关系如下

AbstractUrlHandlerMapping继承关系

分支子类AbstractDetectingUrlHandlerMapping

先看AbstractDetectingUrlHandlerMapping 初始化过程

initApplicationContext detectHandlers determineUrlsForHandler

AbstractDetectingUrlHandlerMapping子类BeanNameUrlHandlerMapping实现determineUrlsForHandler方法

BeanNameUrlHandlerMapping

分支子类SimpleUrlHandlerMapping

initApplicationContext registerHandlers

总结

1.了解HandlerMapping的核心子类AbstractHandlerMapping
2.其次了解HandlerExecutionChain的结构Handler对象+ Interceptors
3.了解AbstractHandlerMapping 的两个分支子类AbstractHandlerMethodMapping，AbstractUrlHandlerMapping
4.清楚获取Handler 以及 注册 Handler的过程