HandlerMapping 组件，请求的处理器匹配器，负责为请求找到合适的 HandlerExecutionChain 处理器执行链，包含处理器（handler）和拦截器们（interceptors）

handler 处理器是 Object 类型，可以将其理解成 HandlerMethod 对象（例如我们使用最多的 @RequestMapping 注解所标注的方法会解析成该对象），包含了方法的所有信息，通过该对象能够执行该方法

HandlerInterceptor 拦截器对处理请求进行增强处理，可用于在执行方法前、成功执行方法后、处理完成后进行一些逻辑处理

由于 HandlerMapping 组件涉及到的内容比较多，考虑到内容的排版，所以将这部分内容拆分成了四个模块，依次进行分析：

《HandlerMapping 组件（一）之 AbstractHandlerMapping》
《HandlerMapping 组件（二）之 HandlerInterceptor 拦截器》
《HandlerMapping 组件（三）之 AbstractHandlerMethodMapping》
《HandlerMapping 组件（四）之 AbstractUrlHandlerMapping》
HandlerMapping 组件（四）之 AbstractUrlHandlerMapping
先来回顾一下HandlerMapping 接口体系的结构：

在《HandlerMapping 组件（一）之 AbstractHandlerMapping》文档中已经分析了 HandlerMapping 组件的 AbstractHandlerMapping 抽象类基类

在《HandlerMapping 组件（三）之 AbstractHandlerMethodMapping》文档中也已经分析了图中红色框部分的 AbstractHandlerMethodMapping 系，基于 Method 进行匹配。例如，我们所熟知的 @RequestMapping 等注解的方式。

那么本文就接着来分析图中黄色框部分的 AbstractUrlHandlerMapping 系，基于 URL 进行匹配。例如 《基于 XML 配置的 Spring MVC 简单的 HelloWorld 实例应用》 ，当然，目前这种方式已经基本不用了，被 @RequestMapping 等注解的方式所取代。不过，Spring MVC 内置的一些路径匹配，还是使用这种方式。

因为 AbstractUrlHandlerMapping 在实际开发基本不会涉及到，所以本文选读，可以直接查看总结部分

一共有五个子类，分成两条线：

AbstractUrlHandlerMapping <= SimpleUrlHandlerMapping <= WebSocketHandlerMapping
AbstractUrlHandlerMapping <= AbstractDetectingUrlHandlerMapping <= BeanNameUrlHandlerMapping
其中，WebSocketHandlerMapping 是 spring-websocket 项目中的类，本文会无视它

所以，本文按照 AbstractUrlHandlerMapping、SimpleUrlHandlerMapping、AbstractDetectingUrlHandlerMapping、BeanNameUrlHandlerMapping 顺序进行分析

回顾
先来回顾一下在 DispatcherServlet 中处理请求的过程中通过 HandlerMapping 组件，获取到 HandlerExecutionChain 处理器执行链的方法，是通过AbstractHandlerMapping 的 getHandler 方法来获取的，如下：

@Override
@Nullable
public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
// <1> 获得处理器（HandlerMethod 或者 HandlerExecutionChain），该方法是抽象方法，由子类实现
Object handler = getHandlerInternal(request);
// <2> 获得不到，则使用默认处理器
// <3> 还是获得不到，则返回 null
// <4> 如果找到的处理器是 String 类型，则从 Spring 容器中找到对应的 Bean 作为处理器
// <5> 创建 HandlerExecutionChain 对象（包含处理器和拦截器）
// … 省略相关代码
return executionChain;
}
在 AbstractHandlerMapping 获取 HandlerExecutionChain 处理器执行链的方法中，需要先调用 getHandlerInternal(HttpServletRequest request) 抽象方法，获取请求对应的处理器，该方法由子类去实现，也就上图中黄色框和红色框两类子类，本文分析黄色框部分内容

AbstractUrlHandlerMapping
org.springframework.web.servlet.handler.AbstractUrlHandlerMapping，实现 MatchableHandlerMapping 接口，继承 AbstractHandlerMapping 抽象类，以 URL 作为 Handler 处理器 的 HandlerMapping 抽象类，提供 Handler 的获取、注册等等通用的骨架方法。

构造方法
public abstract class AbstractUrlHandlerMapping extends AbstractHandlerMapping implements MatchableHandlerMapping {
/**
* 根路径（"/"）的处理器
*/
@Nullable
private Object rootHandler;

/**
 * 使用后置的 / 匹配
 */
private boolean useTrailingSlashMatch = false;

/**
 * 是否延迟加载处理器，默认关闭
 */
private boolean lazyInitHandlers = false;

/**
 * 路径和处理器的映射
 *
 * KEY：路径 {@link #lookupHandler(String, HttpServletRequest)}
 */
private final Map<String, Object> handlerMap = new LinkedHashMap<>();

}
registerHandler
registerHandler(String[] urlPaths, String beanName) 方法，注册多个 URL 的处理器，方法如下：

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

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.
// <1> 如果非延迟加载，并且 handler 为 String 类型，并且还是单例，则去获取 String 对应的 Bean 对象
if (!this.lazyInitHandlers && handler instanceof String) {
    String handlerName = (String) handler;
    ApplicationContext applicationContext = obtainApplicationContext();
    if (applicationContext.isSingleton(handlerName)) {
        resolvedHandler = applicationContext.getBean(handlerName);
    }
}

// <2> 获得 urlPath 对应的处理器
Object mappedHandler = this.handlerMap.get(urlPath);
// <3> 检验 mappedHandler 是否已存在，如果已存在，并且不是当前 resolvedHandler 对象，则抛出异常
if (mappedHandler != null) {
    if (mappedHandler != resolvedHandler) {
        throw new IllegalStateException(
                "Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
                "]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
    }
}
else {
    // <4.1> 如果是 / 根路径，则设置为 rootHandler
    if (urlPath.equals("/")) {
        if (logger.isTraceEnabled()) {
            logger.trace("Root mapping to " + getHandlerDescription(handler));
        }
        setRootHandler(resolvedHandler);
    }
    // <4.2> 如果是 /* 路径，则设置为默认处理器
    else if (urlPath.equals("/*")) {
        if (logger.isTraceEnabled()) {
            logger.trace("Default mapping to " + getHandlerDescription(handler));
        }
        setDefaultHandler(resolvedHandler);
    }
    // <4.3> 添加到 handlerMap 中
    else {
        this.handlerMap.put(urlPath, resolvedHandler);
        if (logger.isTraceEnabled()) {
            logger.trace("Mapped [" + urlPath + "] onto " + getHandlerDescription(handler));
        }
    }
}

}
遍历 URL，依次注册处理器

如果非延迟加载，并且 handler 为 String 类型，并且还是单例，则去获取 String 对应的 Bean 对象，resolvedHandler
从handlerMap中获得 urlPath 对应的处理器
如果该路径已存在对应的处理器，但是不是当前 resolvedHandler 对象，则抛出异常
否则，该路径不存在对应的处理器，则将当前 resolvedHandler 处理器保存
如果是 / 根路径，则设置 resolvedHandler 为 rootHandler
否则，如果是 /* 路径，则设置为默认处理器 defaultHandler（在父类中）
否则，添加到 handlerMap 中
getHandlerInternal
实现父类的 getHandlerInternal(HttpServletRequest request) 方法，获得处理器，方法如下：

@Override
@Nullable
protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
// <1> 获得请求的路径
String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
// <2> 获得处理器
Object handler = lookupHandler(lookupPath, request);
// <3> 如果找不到处理器，则使用 rootHandler 或 defaultHandler 处理器
if (handler == null) {
// We need to care for the default handler directly, since we need to
// expose the PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE for it as well.
Object rawHandler = null;
// ️.1> 如果是根路径，则使用 rootHandler 处理器
if ("/".equals(lookupPath)) {
rawHandler = getRootHandler();
}
// ️.2> 使用默认处理器
if (rawHandler == null) {
rawHandler = getDefaultHandler();
}
if (rawHandler != null) {
// Bean name or resolved handler?
// ️.3> 如果找到的处理器是 String 类型，则从容器中找到该 beanName 对应的 Bean 作为处理器
if (rawHandler instanceof String) {
String handlerName = (String) rawHandler;
rawHandler = obtainApplicationContext().getBean(handlerName);
}
// ️.4> 空方法，校验处理器。目前暂无子类实现该方法
validateHandler(rawHandler, request);
// ️.5> 创建处理器（HandlerExecutionChain 对象）
handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
}
}
return handler;
}
获得请求路径

调用 lookupHandler(String urlPath, HttpServletRequest request) 方法，获得处理器，详情见下文

如果找不到处理器，则使用 rootHandler 或 defaultHandler 处理器

如果是/根路径，则使用 rootHandler 处理器
否则，使用 defaultHandler 默认处理器
如果找到的处理器是 String 类型，则从容器中找到该 beanName 对应的 Bean 作为处理器
调用validateHandler(Object handler, HttpServletRequest request)，对处理器进行校验，空方法，暂无子类实现该方法
调用 buildPathExposingHandler方法，创建 HandlerExecutionChain 处理器执行链，赋值给handler处理器，详情见下文
返回请求对应的handler处理器

所以说这里但会的处理器对象可能是一个 HandlerExecutionChain 对象，用途目前不清楚 先继续往下看

lookupHandler
lookupHandler(String urlPath, HttpServletRequest request) 方法，获得请求对应的处理器，方法如下：

@Nullable
protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
// Direct match?
// <1.1> 情况一，从 handlerMap 中，直接匹配处理器
Object handler = this.handlerMap.get(urlPath);
if (handler != null) {
// Bean name or resolved handler?
// <1.2> 如果找到的处理器是 String 类型，则从容器中找到该 beanName 对应的 Bean 作为处理器
if (handler instanceof String) {
String handlerName = (String) handler;
handler = obtainApplicationContext().getBean(handlerName);
}
// <1.3> 空方法，校验处理器。目前暂无子类实现该方法
validateHandler(handler, request);
// <1.4> 创建处理器
return buildPathExposingHandler(handler, urlPath, urlPath, null);
}

// Pattern match?
List<String> matchingPatterns = new ArrayList<>();
// <2.1> 情况二，Pattern 匹配合适的，并添加到 matchingPatterns 中
for (String registeredPattern : this.handlerMap.keySet()) {
    if (getPathMatcher().match(registeredPattern, urlPath)) { // 路径通过Pattern匹配成功
        matchingPatterns.add(registeredPattern);
    }
    else if (useTrailingSlashMatch()) {
        if (!registeredPattern.endsWith("/") && getPathMatcher().match(registeredPattern + "/", urlPath)) {
            matchingPatterns.add(registeredPattern + "/");
        }
    }
}

// <2.2> 获得首个匹配（最优）的结果
String bestMatch = null;
Comparator<String> patternComparator = getPathMatcher().getPatternComparator(urlPath);
if (!matchingPatterns.isEmpty()) {
    // 排序
    matchingPatterns.sort(patternComparator);
    if (logger.isTraceEnabled() && matchingPatterns.size() > 1) {
        logger.trace("Matching patterns " + matchingPatterns);
    }
    bestMatch = matchingPatterns.get(0);
}
if (bestMatch != null) {
    // <2.3> 获得 bestMatch 对应的处理器
    handler = this.handlerMap.get(bestMatch);
    if (handler == null) {
        if (bestMatch.endsWith("/")) {
            handler = this.handlerMap.get(bestMatch.substring(0, bestMatch.length() - 1));
        }
        if (handler == null) { // 如果获得不到，抛出 IllegalStateException 异常
            throw new IllegalStateException(
                    "Could not find handler for best pattern match [" + bestMatch + "]");
        }
    }
    // <2.4> 如果找到的处理器是 String 类型，则从容器中找到该 beanName 对应的 Bean 作为处理器
    // Bean name or resolved handler?
    if (handler instanceof String) {
        String handlerName = (String) handler;
        handler = obtainApplicationContext().getBean(handlerName);
    }
    // <2.5> 空方法，校验处理器。目前暂无子类实现该方法
    validateHandler(handler, request);
    // <2.6> 获得匹配的路径
    String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestMatch, urlPath);

    // There might be multiple 'best patterns', let's make sure we have the correct URI template variables
    // for all of them
    // <2.7> 获得路径参数集合
    Map<String, String> uriTemplateVariables = new LinkedHashMap<>();
    for (String matchingPattern : matchingPatterns) {
        if (patternComparator.compare(bestMatch, matchingPattern) == 0) {
            Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(matchingPattern, urlPath);
            Map<String, String> decodedVars = getUrlPathHelper().decodePathVariables(request, vars);
            uriTemplateVariables.putAll(decodedVars);
        }
    }
    if (logger.isTraceEnabled() && uriTemplateVariables.size() > 0) {
        logger.trace("URI variables " + uriTemplateVariables);
    }
    // <2.8> 创建处理器
    return buildPathExposingHandler(handler, bestMatch, pathWithinMapping, uriTemplateVariables);
}

// No handler found...
return null;

}
情况一

从 handlerMap 中，直接匹配处理器
如果找到的处理器是 String 类型，则从容器中找到该 beanName 对应的 Bean 作为处理器
校验处理器，空方法，暂无子类实现，暂时忽略
创建处理器，直接返回，这里是 HandlerExecutionChain 类型，调用 buildPathExposingHandler 方法，详情见下文
情况二

Pattern 匹配合适的，并添加到 matchingPatterns 中
获得首个匹配（最优）的结果 bestMatch
获得 bestMatch 对应的处理器，如果获得不到，抛出异常
如果找到的处理器是 String 类型，则从容器中找到该 beanName 对应的 Bean 作为处理器
校验处理器，空方法，暂无子类实现，暂时忽略
获得请求最匹配的路径pathWithinMapping
获得匹配的路径参数集合uriTemplateVariables
创建处理器，直接返回，这里是 HandlerExecutionChain 类型，调用 buildPathExposingHandler 方法，详情见下文
都不匹配则返回 null

buildPathExposingHandler
buildPathExposingHandler(Object rawHandler, String bestMatchingPattern, String pathWithinMapping, @Nullable Map<String, String> uriTemplateVariables) 方法

构建一个 HandlerExecutionChain 类型的处理器，添加两个拦截器，方法如下：

protected Object buildPathExposingHandler(Object rawHandler, String bestMatchingPattern,
String pathWithinMapping, @Nullable Map<String, String> uriTemplateVariables) {

// <1> 创建 HandlerExecutionChain 对象
HandlerExecutionChain chain = new HandlerExecutionChain(rawHandler);
// <2> 添加 PathExposingHandlerInterceptor 拦截器，到 chain 中
chain.addInterceptor(new PathExposingHandlerInterceptor(bestMatchingPattern, pathWithinMapping));
if (!CollectionUtils.isEmpty(uriTemplateVariables)) {
    // <3> 添加 UriTemplateVariablesHandlerInterceptor 拦截器，到 chain 中
    chain.addInterceptor(new UriTemplateVariablesHandlerInterceptor(uriTemplateVariables));
}
return chain;

}
创建 HandlerExecutionChain 类型的处理器对象
添加 PathExposingHandlerInterceptor 拦截器，用于暴露 bestMatchingPattern 属性到请求中
添加 UriTemplateVariablesHandlerInterceptor 拦截器，用于暴露 uriTemplateVariables 属性到请求中
两个拦截器如下：

private class PathExposingHandlerInterceptor extends HandlerInterceptorAdapter {
/** 最佳匹配的路径 /
private final String bestMatchingPattern;
/* 被匹配的路径 */
private final String pathWithinMapping;

public PathExposingHandlerInterceptor(String bestMatchingPattern, String pathWithinMapping) {
    this.bestMatchingPattern = bestMatchingPattern;
    this.pathWithinMapping = pathWithinMapping;
}

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
    exposePathWithinMapping(this.bestMatchingPattern, this.pathWithinMapping, request);
    request.setAttribute(BEST_MATCHING_HANDLER_ATTRIBUTE, handler);
    request.setAttribute(INTROSPECT_TYPE_LEVEL_MAPPING, supportsTypeLevelMappings());
    return true;
}

}
protected void exposePathWithinMapping(String bestMatchingPattern, String pathWithinMapping,
HttpServletRequest request) {
request.setAttribute(BEST_MATCHING_PATTERN_ATTRIBUTE, bestMatchingPattern);
request.setAttribute(PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, pathWithinMapping);
}

private class UriTemplateVariablesHandlerInterceptor extends HandlerInterceptorAdapter {

private final Map<String, String> uriTemplateVariables;

public UriTemplateVariablesHandlerInterceptor(Map<String, String> uriTemplateVariables) {
    this.uriTemplateVariables = uriTemplateVariables;
}

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
    exposeUriTemplateVariables(this.uriTemplateVariables, request);
    return true;
}

}
protected void exposeUriTemplateVariables(Map<String, String> uriTemplateVariables, HttpServletRequest request) {
request.setAttribute(URI_TEMPLATE_VARIABLES_ATTRIBUTE, uriTemplateVariables);
}
都是往请求中设置相关属性，用途目前不清楚 先继续往下看

match
match(HttpServletRequest request, String pattern) 方法，执行匹配，代码如下：

@Override
@Nullable
public RequestMatchResult match(HttpServletRequest request, String pattern) {
// <1> 获得请求路径
String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
// <2> 模式匹配，若匹配，则返回 RequestMatchResult 对象
if (getPathMatcher().match(pattern, lookupPath)) {
return new RequestMatchResult(pattern, lookupPath, getPathMatcher());
}
else if (useTrailingSlashMatch()) {
if (!pattern.endsWith("/") && getPathMatcher().match(pattern + “/”, lookupPath)) {
return new RequestMatchResult(pattern + “/”, lookupPath, getPathMatcher());
}
}
return null;
}
获得请求路径
模式匹配，若匹配，则返回 RequestMatchResult 对象
SimpleUrlHandlerMapping
org.springframework.web.servlet.handler.SimpleUrlHandlerMapping，继承 AbstractUrlHandlerMapping 抽象类，简单的就 URL 匹配的 HandlerMapping 实现类

使用示例
在接触 Spring MVC 比较早，你也许见过这样配置

<util:properties id=“urlMappings”>
helloController
</util:properties>
当然，上述这种配置基本已经不存在了，因为被 @RequestMapping 注解这样的方式所取代。更多的是 Spring MVC 自己内部的组件可能在使用这种类型的 HandlerMapping ，例如下图：

构造方法
public class SimpleUrlHandlerMapping extends AbstractUrlHandlerMapping {
/**
* 配置的 URL 与处理器的映射
*
* 最终，会调用 {@link #registerHandlers(Map)} 进行注册到 {@link AbstractUrlHandlerMapping#handlerMap} 中
*/
private final Map<String, Object> urlMap = new LinkedHashMap<>();

public void setMappings(Properties mappings) {
	CollectionUtils.mergePropertiesIntoMap(mappings, this.urlMap);
}

public void setUrlMap(Map<String, ?> urlMap) {
	this.urlMap.putAll(urlMap);
}

}
例如上面的配置示例就会通过 setMappings(Properties mappings) 方法，将 /hello.form 与 HelloController 设置到 urlMap 中

所以说处理器也可能是一个 Controller 接口

initApplicationContext
initApplicationContext()方法，用于初始化，将 urlMap 中的URL与处理器添加到父类的 handlerMap 中

在父类 WebApplicationObjectSupport 的父类 ApplicationObjectSupport 中可以看到，因为实现了 ApplicationContextAware 接口，则在初始化该 Bean 的时候会调用 setApplicationContext(@Nullable ApplicationContext context) 方法，在这个方法中会调用 initApplicationContext() 这个方法

在父类 AbstractHandlerMapping 中，该方法会初始化拦截器们

@Override
public void initApplicationContext() throws BeansException {
super.initApplicationContext();
registerHandlers(this.urlMap);
}

protected void registerHandlers(Map<String, Object> urlMap) throws BeansException {
if (urlMap.isEmpty()) {
logger.trace(“No patterns in " + formatMappingName());
}
else {
urlMap.forEach((url, handler) -> {
// Prepend with slash if not already present.
if (!url.startsWith(”/")) {
url = “/” + url;
}
// Remove whitespace from handler bean name.
if (handler instanceof String) {
handler = ((String) handler).trim();
}
// 【核心代码】注册处理器
registerHandler(url, handler);
});
if (logger.isDebugEnabled()) {
List patterns = new ArrayList<>();
if (getRootHandler() != null) {
patterns.add("/");
}
if (getDefaultHandler() != null) {
patterns.add("/**");
}
patterns.addAll(getHandlerMap().keySet());
logger.debug("Patterns " + patterns + " in " + formatMappingName());
}
}
}
逻辑很简单，调用父类的registerHandler(String urlPath, Object handler)方法，添加注册器

AbstractDetectingUrlHandlerMapping
org.springframework.web.servlet.handler.AbstractDetectingUrlHandlerMapping，继承 AbstractUrlHandlerMapping 抽象类，自动探测的基于 URL 匹配的 HandlerMapping 抽象实现类

构造方法
public abstract class AbstractDetectingUrlHandlerMapping extends AbstractUrlHandlerMapping {

/**
 * 是否只扫描可访问的 Handler 们
 */
private boolean detectHandlersInAncestorContexts = false;

public void setDetectHandlersInAncestorContexts(boolean detectHandlersInAncestorContexts) {
	this.detectHandlersInAncestorContexts = detectHandlersInAncestorContexts;
}

}
initApplicationContext
initApplicationContext()方法，用于初始化，找到符合条件的处理器，添加到父类的 handlerMap 中

在父类 WebApplicationObjectSupport 的父类 ApplicationObjectSupport 中可以看到，因为实现了 ApplicationContextAware 接口，则在初始化该 Bean 的时候会调用 setApplicationContext(@Nullable ApplicationContext context) 方法，在这个方法中会调用 initApplicationContext() 这个方法

在父类 AbstractHandlerMapping 中，该方法会初始化拦截器们

@Override
public void initApplicationContext() throws ApplicationContextException {
super.initApplicationContext();
// 自动探测处理器
detectHandlers();
}

protected void detectHandlers() throws BeansException {
// <1> 从 Spring 上下文获取所有 Object 类型的 Bean 的名称们
ApplicationContext applicationContext = obtainApplicationContext();
String[] beanNames = (this.detectHandlersInAncestorContexts ?
BeanFactoryUtils.beanNamesForTypeIncludingAncestors(applicationContext, Object.class) :
applicationContext.getBeanNamesForType(Object.class));

// Take any bean name that we can determine URLs for.
// <2> 遍历所有的 Bean ，逐个注册
for (String beanName : beanNames) {
    // <2.1> 获得 Bean 对应的 URL 们
    String[] urls = determineUrlsForHandler(beanName);
    // <2.2> 如果该 Bean 存在对应的 URL，则添加该处理器
    if (!ObjectUtils.isEmpty(urls)) {
        // 调用父类的方法，往 `handlerMap` 中添加注册器
        registerHandler(urls, beanName);
    }
}

if ((logger.isDebugEnabled() && !getHandlerMap().isEmpty()) || logger.isTraceEnabled()) {
    logger.debug("Detected " + getHandlerMap().size() + " mappings in " + formatMappingName());
}

}
从 Spring 上下文获取所有 Object 类型的 Bean 的名称们
遍历所有的 Bean ，逐个注册
获得 Bean 对应的 URL 们，调用determineUrlsForHandler(String beanName)抽象方法，交由子类实现，详情见 BeanNameUrlHandlerMapping
如果该 Bean 存在对应的 URL，则添加该处理器，调用父类的方法，往 handlerMap 中添加注册器
BeanNameUrlHandlerMapping
org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping，继承 AbstractDetectingUrlHandlerMapping 抽象类，基于 Bean 的名字来自动探测的 HandlerMapping 实现类

使用示例

和 SimpleUrlHandlerMapping 不同，只需要设置它的 beanName 以 / 开头就好了，会被 BeanNameUrlHandlerMapping 探测到

determineUrlsForHandler
public class BeanNameUrlHandlerMapping extends AbstractDetectingUrlHandlerMapping {
@Override
protected String[] determineUrlsForHandler(String beanName) {
List urls = new ArrayList<>();
// 如果是以 / 开头，添加到 urls
if (beanName.startsWith("/")) {
urls.add(beanName);
}
// 获得 beanName 的别名们，如果以 / 开头，则添加到 urls
String[] aliases = obtainApplicationContext().getAliases(beanName);
for (String alias : aliases) {
if (alias.startsWith("/")) {
urls.add(alias);
}
}
return StringUtils.toStringArray(urls);
}
}
逻辑很简单，如果 Bean 的名称或者别名是以 / 开头，则会作为一个 url 返回，父类则会将该 Bean 作为一个处理器

总结
在 Spring MVC 处理请求的过程中，需要通过 HandlerMapping 组件会为请求找到合适的 HandlerExecutionChain 处理器执行链，包含处理器（handler）和拦截器们（interceptors），该组件体系结构如下：

本文就黄色框中的内容进行了分析，基于 URL 进行匹配。如果你接触 Spring MVC 较早，可能见过 SimpleUrlHandlerMapping 和 BeanNameUrlHandlerMapping 中的使用示例的配置方式。当然，目前这种方式已经基本不用了，被 @RequestMapping 等注解的方式所取代。不过，Spring MVC 内置的一些路径匹配，还是使用这种方式。

相对来说逻辑比较简单，如果你有一个 Controller 或者 HttpRequestHandler 接口的实现类，有以下两种方式将其设置为处理器，可以处理请求

配置 SimpleUrlHandlerMapping 类型的 HandlerMapping 对象，往它的 Map<String, Object> urlMap 中添加 url 与 Controller 实现类的映射就好了
配置 BeanNameUrlHandlerMapping 类型的 HandlerMapping 对象，设置 Controller 实现类 的 beanName 为以 / 开头的名称就好了，它会探测到，将这个 Bean 的 beanName 作为 url，将 Controller 实现类 作为处理器
至此，HandlerMapping 组件就分析到这里了，相信你对 HandlerMapping 组件有了一个深入的了解，更加的清楚 Spring MVC 是如何处理器请求的

HandlerMapping 组件返回的 HandlerExecutionChain 处理器执行链，包含处理器（handler）和拦截器们（interceptors），那么这个处理器是被谁调用的呢？

因为不同的 HandlerMapping 实现类返回的处理器类型可能不一样，如何执行这个处理器，这部分工作都交由 HandlerAdapter 组件（处理器的适配器）来完成

这里我们就把处理器理解为 HandlerMethod 处理器对象吧，因为我们平时使用最多的方式就是通过 @RequestMapping 注解来标注某个方法处理对应的请求

别慌，接下来分析 HandlerAdapter 组件不会特别复杂
龙华大道1号 http://www.kinghill.cn/Dynamics/2106.html