Spring MVC 源码 - HandlerMapping 组件（四）之 AbstractUrlHandlerMapping

news2024/10/7 16:19:22

HandlerMapping 组件

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

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

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

HandlerMapping 组件（四）之 AbstractUrlHandlerMapping

先来回顾一下HandlerMapping 接口体系的结构：

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

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

那么本文就接着来分析图中黄色框部分的 AbstractUrlHandlerMapping 系，基于 URL 进行匹配，当然，目前这种方式已经基本不用了，被 @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，依次注册处理器

  1. 如果非延迟加载，并且 handler 为 String 类型，并且还是单例，则去获取 String 对应的 Bean 对象，resolvedHandler

  1. 从handlerMap中获得 urlPath 对应的处理器

  1. 如果该路径已存在对应的处理器，但是不是当前 resolvedHandler 对象，则抛出异常

  1. 否则，该路径不存在对应的处理器，则将当前 resolvedHandler 处理器保存

  1. 如果是 / 根路径，则设置 resolvedHandler 为 rootHandler

  1. 否则，如果是 /* 路径，则设置为默认处理器 defaultHandler（在父类中）

  1. 否则，添加到 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;
        // <3.1> 如果是根路径，则使用 rootHandler 处理器
        if ("/".equals(lookupPath)) {
            rawHandler = getRootHandler();
        }
        // <3.2> 使用默认处理器
        if (rawHandler == null) {
            rawHandler = getDefaultHandler();
        }
        if (rawHandler != null) {
            // Bean name or resolved handler?
            // <3.3> 如果找到的处理器是 String 类型，则从容器中找到该 beanName 对应的 Bean 作为处理器
            if (rawHandler instanceof String) {
                String handlerName = (String) rawHandler;
                rawHandler = obtainApplicationContext().getBean(handlerName);
            }
            // <3.4> 空方法，校验处理器。目前暂无子类实现该方法
            validateHandler(rawHandler, request);
            // <3.5> 创建处理器（HandlerExecutionChain 对象）
            handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
        }
    }
    return handler;
}

  1. 获得请求路径

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

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

  1. 如果是/根路径，则使用 rootHandler 处理器

  1. 否则，使用 defaultHandler 默认处理器

  1. 如果找到的处理器是 String 类型，则从容器中找到该 beanName 对应的 Bean 作为处理器

  1. 调用validateHandler(Object handler, HttpServletRequest request)，对处理器进行校验，空方法，暂无子类实现该方法

  1. 调用 buildPathExposingHandler方法，创建 HandlerExecutionChain 处理器执行链，赋值给handler处理器，详情见下文

  1. 返回请求对应的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;
}

  1. 情况一

  1. 从 handlerMap 中，直接匹配处理器

  1. 如果找到的处理器是 String 类型，则从容器中找到该 beanName 对应的 Bean 作为处理器

  1. 校验处理器，空方法，暂无子类实现，暂时忽略

  1. 创建处理器，直接返回，这里是 HandlerExecutionChain 类型，调用 buildPathExposingHandler 方法，详情见下文

  1. 情况二

  1. Pattern 匹配合适的，并添加到 matchingPatterns 中

  1. 获得首个匹配（最优）的结果 bestMatch

  1. 获得 bestMatch 对应的处理器，如果获得不到，抛出异常

  1. 如果找到的处理器是 String 类型，则从容器中找到该 beanName 对应的 Bean 作为处理器

  1. 校验处理器，空方法，暂无子类实现，暂时忽略

  1. 获得请求最匹配的路径pathWithinMapping

  1. 获得匹配的路径参数集合uriTemplateVariables

  1. 创建处理器，直接返回，这里是 HandlerExecutionChain 类型，调用 buildPathExposingHandler 方法，详情见下文

  1. 都不匹配则返回 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;
}

  1. 创建 HandlerExecutionChain 类型的处理器对象

  1. 添加 PathExposingHandlerInterceptor 拦截器，用于暴露 bestMatchingPattern 属性到请求中

  1. 添加 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;
}

  1. 获得请求路径

  1. 模式匹配，若匹配，则返回 RequestMatchResult 对象

SimpleUrlHandlerMapping

org.springframework.web.servlet.handler.SimpleUrlHandlerMapping，继承 AbstractUrlHandlerMapping 抽象类，简单的就 URL 匹配的 HandlerMapping 实现类

使用示例

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

<!-- 定义一个 helloController Bean，实现了 Controller 接口 -->
<bean id="helloController" class="com.tiger.study.controller.HelloController"/>

<!-- 定义请求处理映射 HandlerMapping -->
<bean class="org.springframework.web.servlet.handler. SimpleUrlHandlerMapping">
    <property name="mappings" ref="urlMappings" />
</bean>

<!-- 定义请求映射表 map -->
<util:properties id="urlMappings">
    <prop key="/hello.form">helloController</prop>
</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<String> 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());
    }
}

  1. 从 Spring 上下文获取所有 Object 类型的 Bean 的名称们

  1. 遍历所有的 Bean ，逐个注册

  1. 获得 Bean 对应的 URL 们，调用determineUrlsForHandler(String beanName)抽象方法，交由子类实现，详情见 BeanNameUrlHandlerMapping

  1. 如果该 Bean 存在对应的 URL，则添加该处理器，调用父类的方法，往 handlerMap 中添加注册器

BeanNameUrlHandlerMapping

org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping，继承 AbstractDetectingUrlHandlerMapping 抽象类，基于 Bean 的名字来自动探测的 HandlerMapping 实现类

使用示例

<!-- 定义一个 helloController Bean，实现了 Controller 接口 -->
<bean id="/hello.form" class="com.tiger.study.controller.HelloController"/>

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

determineUrlsForHandler

public class BeanNameUrlHandlerMapping extends AbstractDetectingUrlHandlerMapping {
    @Override
    protected String[] determineUrlsForHandler(String beanName) {
        List<String> 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 注解来标注某个方法处理对应的请求

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/362827.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【GO】k8s 管理系统项目[前端部分–Header]

【GO】k8s 管理系统项目[前端部分–Header]

【GO】k8s 管理系统项目[前端部分–Header] 1. 实现功能 面包屑展开关闭按钮用户信息(退出按钮) 2. 代码部分 src/layout/Layout.vue 在之前预留header位置补上 <!-- header --><el-header class"header"><el-row :gutter"20"><e…
阅读更多...
python基于vue健身房课程预约平台

python基于vue健身房课程预约平台

可定制框架:ssm/Springboot/vue/python/PHP/小程序/安卓均可开发 目录 1 绪论 1 1.1课题背景 1 1.2课题研究现状 1 1.3初步设计方法与实施方案 2 1.4本文研究内容 2 2 系统开发3 2.2MyEclipse环境配置 4 2.3 B/S结构简介 4 2.4MySQL数据库 5 2.5 django框架 5 3 系统分析 6 3.1…
阅读更多...
Sqoop利用Sql将mysql表_导入数据到Hive---大数据之Apache Sqoop工作笔记004

Sqoop利用Sql将mysql表_导入数据到Hive---大数据之Apache Sqoop工作笔记004

然后来看一下把数据导入到hive中去 可以去官网去看看文档,有什么参数 这里用的是hive-import对吧,然后 这里hive-overwrite是覆盖 这个hive-table staff_hive 是创建 一个hive的表是 staff_hive 然后我们先去启动一下hive 启动以后,然后我们去查一下,shot tables 可以看到 里…
阅读更多...
Ubuntu 22.04.2 LTS安装Apollo8.0

Ubuntu 22.04.2 LTS安装Apollo8.0

本人硬件环境&#xff1a; CPU&#xff1a;Intel Core i7 6700 显卡&#xff08;GPU&#xff09;&#xff1a;NVIDIA GTX 3080 10G 内存&#xff1a;SAMSUNG DDR4 32GB 硬盘&#xff1a;双SSD系统盘 2T,双系统&#xff08;windows,ubuntu&#xff09; 一、安装Ubuntu 22.04…
阅读更多...
【极海APM32替代笔记】HAL库中的SPI传输（可利用中断或DMA进行连续传输）

【极海APM32替代笔记】HAL库中的SPI传输（可利用中断或DMA进行连续传输）

【极海APM32替代笔记】HAL库中的SPI传输&#xff08;可利用中断或DMA进行连续传输&#xff09; SPI 是英语Serial Peripheral interface的缩写&#xff0c;顾名思义就是串行外围设备接口。是Motorola(摩托罗拉)首先在其MC68HCXX系列处理器上定义的。 SPI&#xff0c;是一种高…
阅读更多...
Ssh协议绑定Git服务器

Ssh协议绑定Git服务器

1、起因在公司开发一般使用gitlab部署公司git代码管理&#xff0c;个人的代码存储在公司gitlab上就显得不合时宜了&#xff0c;所以找了gitee上来存储代码。2、经过搜索了下github.com,gitee.com 其他当然有阿里云的云效等&#xff0c;个人使用优先国内git服务器&#xff0c;理…
阅读更多...
【Netty系列・扫盲篇】Netty从入门到学废

【Netty系列・扫盲篇】Netty从入门到学废

文章目录1. 概述1.1 Netty 的地位1.2 Netty 的优势2. Hello World2.1 目标2.2 服务器端2.3 客户端2.4 流程梳理&#x1f4a1; 提示3. 组件3.1 EventLoop&#x1f4a1; 优雅关闭演示 NioEventLoop 处理 io 事件&#x1f4a1; handler 执行中如何换人&#xff1f;演示 NioEventLo…
阅读更多...
C# 业务单据号生成器（定义规则、获取编号、流水号）

C# 业务单据号生成器（定义规则、获取编号、流水号）

系列文章 C#底层库–数据库访问帮助类&#xff08;MySQL版&#xff09; 本文链接&#xff1a;https://blog.csdn.net/youcheng_ge/article/details/126886379 C#底层库–JSON帮助类_详细&#xff08;序列化、反序列化、list、datatable&#xff09; 本文链接&#xff1a;htt…
阅读更多...
GEE学习笔记 六十：GEE中生成GIF动画

GEE学习笔记 六十：GEE中生成GIF动画

生成GIF动画这个是GEE新增加的功能之一&#xff0c;这一篇文章我会简单介绍一下如何使用GEE来制作GIF动画。 相关API如下&#xff1a; 参数含义&#xff1a; params&#xff1a;设置GIF动画显示参数&#xff0c;详细的参数可以参考ee.data.getMapId() callback&#xff1a;回调…
阅读更多...
基于RK3399地面测试台多参数记录仪测试平台软件设计

基于RK3399地面测试台多参数记录仪测试平台软件设计

随着高科技技术在现代化战争中日益重要作用&#xff0c;飞行装备的研制亦从单元体制发展 到多元体制。航空装置系统在设计过程中&#xff0c;需要大量测试工作&#xff0c;尤其是需要把系统研制 和飞行试验中各部分工作状态参数实时记录&#xff0c;用以分析、改进设计。记录仪…
阅读更多...
uniApp使用uni.chooseAddress()获取微信收货地址

uniApp使用uni.chooseAddress()获取微信收货地址

获取微信收货地址 使用uniapp或者原生微信小程序获取微信的收货地址 1、需要在开发平台申请权限 在【开发】-【开发管理】-【接口设置】-【获取用户收货地址】–申请该权限&#xff0c;审核通过后方可使用。 2、在源码上添加配置 2.1 在uniapp上开发配置 打开manifest.js…
阅读更多...
ECharts在vue中使用 与 图表自适应

ECharts在vue中使用 与 图表自适应

目录 使用思路&#xff1a; Echarts在vue中使用 引入 ECharts 绘制图表实例&#xff08;复杂&#xff09; 实例效果&#xff1a; 官方入门实例&#xff08;简单&#xff09; 官方入门实例效果 ​编辑 图表自适应 ECharts 的功能十分强大,可以生成多种形式的图表,配置…
阅读更多...
xilinx FPGA在线调试方法总结（vivado+ila+vio）

xilinx FPGA在线调试方法总结（vivado+ila+vio）

本文主要介绍xilinx FPGA开发过程中常用的调试方法&#xff0c;包括ILA、VIO和TCL命令等等&#xff0c;详细介绍了如何使用。一、FPGA调试基本原则根据实际的输出结果表现&#xff0c;来推测可能的原因&#xff0c;再在模块中加ILA信号&#xff0c;设置抓信号条件&#xff0c;逐…
阅读更多...
Java 比较器Comparable与Comparator的List集合排序使用

Java 比较器Comparable与Comparator的List集合排序使用

一、Collections类 Collections则是集合类的一个工具类/帮助类&#xff0c;其中提供了一系列静态方法&#xff0c;用于对集合中元素进行排序、搜索以及线程安全等各种操作。 用于集合排序的sort方法&#xff0c;此方法主要是通过Comparable或Comparator来实现排序。 (1) 根据其…
阅读更多...
如何30天零基础入门网络安全？自学网络安全有哪些缺点？

如何30天零基础入门网络安全？自学网络安全有哪些缺点？

网络安全的前景如何&#xff0c;盾叔已经说过很多遍了&#xff0c;今天专题是替一些想入门网络安全&#xff0c;但还迷茫不知所措的同学解一解惑。想30天零基础入门网络安全&#xff0c;这些你一定要搞清楚。 一、学习网络安全容易造成的误区 1、把编程当作目的&#xff0c;忽…
阅读更多...
AI生成图像竟如此真实了？Stable Diffusion Model本地部署教程

AI生成图像竟如此真实了？Stable Diffusion Model本地部署教程

✅作者简介&#xff1a;人工智能专业本科在读&#xff0c;喜欢计算机与编程&#xff0c;写博客记录自己的学习历程。 &#x1f34e;个人主页&#xff1a;小嗷犬的个人主页 &#x1f34a;个人网站&#xff1a;小嗷犬的技术小站 &#x1f96d;个人信条&#xff1a;为天地立心&…
阅读更多...
什么运动耳机好用性价比高、值得入手的五款运动耳机

什么运动耳机好用性价比高、值得入手的五款运动耳机

在各类耳机当中&#xff0c;运动耳机可以说是使用场景针对性比较强的一类。毕竟运动场景对于耳机某些方面性能要求比较高&#xff0c;比如防水能力、佩戴稳定性等等&#xff0c;一般的非运动耳机是很难应用在运动场景中的。这时候一款好的运动耳机就很重要了&#xff0c;那么我…
阅读更多...
I/O多路复用模型实现——epoll

I/O多路复用模型实现——epoll

epoll IO多路复用模型实现机制I/O多路复用epollepoll_create(int size)epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout)epoll eventepoll流程I/O多路复用 I/O 多路复用的本质…
阅读更多...
悲观锁实现一人一单+jmeter并发测试

悲观锁实现一人一单+jmeter并发测试

项目工程代码来自&#xff1a;https://mp.weixin.qq.com/s/nDhkmDHU_kqY-geDZrIOtw 核心代码 Service public class GoodsOrderServiceImpl extends ServiceImpl<GoodsOrderMapper, GoodsOrder> implements GoodsOrderService {Autowiredprivate IGoodsService goodsSe…
阅读更多...
怎样从零基础学黑客

怎样从零基础学黑客

可以说想学黑客技术&#xff0c;要求你首先是一个“T”字型人才&#xff0c;也就是说电脑的所有领域你都能做的来&#xff0c;而且有一项是精通的。因此作为一个零基础的黑客爱好者来说&#xff0c;没有良好的基础是绝对不行的&#xff0c;下面我就针对想真正学习黑客的零基础朋…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023