文档章节

Spring MVC之RequestMappingHandlerMapping匹配

爱宝贝丶
 爱宝贝丶
发布于 09/22 11:59
字数 2441
阅读 264
收藏 4

       对于RequestMappingHandlerMapping,使用Spring的同学基本都不会陌生,该类的作用有两个:

  • 通过request查找对应的HandlerMethod,即当前request具体是由Controller中的哪个方法进行处理;
  • 查找当前系统中的Interceptor,将其与HandlerMethod封装为一个HandlerExecutionChain。

本文主要讲解RequestMappingHandlerMapping是如何获取HandlerMethod和Interceptor,并且将其封装为HandlerExecutionChain的。

1.整体封装结构

       RequestMappingHandlerMapping实现了HandlerMapping接口,该接口的主要方法如下:

public interface HandlerMapping {
    // 通过request获取HandlerExecutionChain对象
	HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception;
}

       这里我们直接看RequestMappingHandlerMapping是如何实现该接口的:

@Override
@Nullable
public final HandlerExecutionChain getHandler(HttpServletRequest request) 
    throws Exception {
    // 通过request获取具体的处理bean,这里handler可能有两种类型:HandlerMethod和String。
    // 如果是String类型,那么就在BeanFactory中查找该String类型的bean,需要注意的是,返回的
    // bean如果是需要使用RequestMappingHandlerAdapter处理,那么也必须是HandlerMethod类型的
    Object handler = getHandlerInternal(request);
    if (handler == null) {
        // 如果找不到处理方法,则获取自定义的默认handler
        handler = getDefaultHandler();
    }
    if (handler == null) {
        return null;
    }
    if (handler instanceof String) {
        // 如果获取的handler是String类型的,则在当前BeanFactory中获取该名称的bean,
        // 并将其作为handler返回
        String handlerName = (String) handler;
        handler = obtainApplicationContext().getBean(handlerName);
    }

    // 获取当前系统中配置的Interceptor,将其与handler一起封装为一个HandlerExecutionChain
    HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
    // 这里CorsUtils.isCorsRequest()方法判断的是当前请求是否为一个跨域的请求,如果是一个跨域的请求,
    // 则将跨域相关的配置也一并封装到HandlerExecutionChain中
    if (CorsUtils.isCorsRequest(request)) {
        CorsConfiguration globalConfig = 
            this.globalCorsConfigSource.getCorsConfiguration(request);
        CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
        CorsConfiguration config = (globalConfig != null ? 
            globalConfig.combine(handlerConfig) : handlerConfig);
        executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
    }
    return executionChain;
}

       从上面的代码可以看出,对于HandlerExecutionChain的获取,RequestMappingHandlerMapping首先会获取当前request对应的handler,然后将其与Interceptor一起封装为一个HandlerExecutionChain对象。这里在进行封装的时候,Spring会对当前request是否为跨域请求进行判断,如果是跨域请求,则将相关的跨域配置封装到HandlerExecutionChain中,关于跨域请求,读者可以阅读跨域资源共享 CORS 详解

2. 获取HandlerMethod

       关于RequestMappingHandlerMapping是如何获取handler的,其主要在getHandlerInternal()方法中,如下是该方法的源码:

@Override
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
    // 获取当前request的URI
    String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
    if (logger.isDebugEnabled()) {
        logger.debug("Looking up handler method for path " + lookupPath);
    }
    // 获取注册的Mapping的读锁
    this.mappingRegistry.acquireReadLock();
    try {
        // 通过path和request查找具体的HandlerMethod
        HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
        if (logger.isDebugEnabled()) {
            if (handlerMethod != null) {
                logger.debug("Returning handler method [" + handlerMethod + "]");
            } else {
                logger.debug("Did not find handler method for [" + lookupPath + "]");
            }
        }
        // 如果获取到的bean是一个String类型的,则在BeanFactory中查找该bean,
        // 并将其封装为一个HandlerMethod对象
        return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
    } finally {
        // 释放当前注册的Mapping的读锁
        this.mappingRegistry.releaseReadLock();
    }
}

       上述方法中,其首先会获取当前request的uri,然后通过uri查找HandlerMethod,并且在最后,会判断获取到的HandlerMethod中的bean是否为String类型的,如果是,则在当前BeanFactory中查找该名称的bean,并且将其封装为HandlerMethod对象。这里我们直接阅读lookupHandlerMethod()方法:

@Nullable
protected HandlerMethod lookupHandlerMethod(String lookupPath, 
      HttpServletRequest request) throws Exception {
    List<Match> matches = new ArrayList<>();
    // 通过uri直接在注册的RequestMapping中获取对应的RequestMappingInfo列表,需要注意的是,
    // 这里进行查找的方式只是通过url进行查找,但是具体哪些RequestMappingInfo是匹配的,还需要进一步过滤
    List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
    if (directPathMatches != null) {
        // 对获取到的RequestMappingInfo进行进一步过滤,并且将过滤结果封装为一个Match列表
        addMatchingMappings(directPathMatches, matches, request);
    }
    if (matches.isEmpty()) {
        // 如果无法通过uri进行直接匹配,则对所有的注册的RequestMapping进行匹配,这里无法通过uri
        // 匹配的情况主要有三种:
        // ①在RequestMapping中定义的是PathVariable,如/user/detail/{id};
        // ②在RequestMapping中定义了问号表达式,如/user/?etail;
        // ③在RequestMapping中定义了*或**匹配,如/user/detail/**
        addMatchingMappings(this.mappingRegistry.getMappings().keySet(), 
            matches, request);
    }

    if (!matches.isEmpty()) {
        // 对匹配的结果进行排序,获取相似度最高的一个作为结果返回,这里对相似度的判断时,
        // 会判断前两个是否相似度是一样的,如果是一样的,则直接抛出异常,如果不相同,
        // 则直接返回最高的一个
        Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
        matches.sort(comparator);
        if (logger.isTraceEnabled()) {
            logger.trace("Found " + matches.size() 
                         + " matching mapping(s) for [" + lookupPath + "] : " + matches);
        }
        // 获取匹配程度最高的一个匹配结果
        Match bestMatch = matches.get(0);
        if (matches.size() > 1) {
            // 如果匹配结果不止一个,首先会判断是否是跨域请求,如果是,
            // 则返回PREFLIGHT_AMBIGUOUS_MATCH,如果不是,则会判断前两个匹配程度是否相同,
            // 如果相同则抛出异常
            if (CorsUtils.isPreFlightRequest(request)) {
                return PREFLIGHT_AMBIGUOUS_MATCH;
            }
            Match secondBestMatch = matches.get(1);
            if (comparator.compare(bestMatch, secondBestMatch) == 0) {
                Method m1 = bestMatch.handlerMethod.getMethod();
                Method m2 = secondBestMatch.handlerMethod.getMethod();
                throw new IllegalStateException("Ambiguous handler methods mapped for" 
                    + " HTTP path '" + request.getRequestURL() + "': {" + m1 
                    + ", " + m2 + "}");
            }
        }
        // 这里主要是对匹配结果的一个处理,主要包含对传入参数和返回的MediaType的处理
        handleMatch(bestMatch.mapping, lookupPath, request);
        return bestMatch.handlerMethod;
    } else {
        // 如果匹配结果是空的,则对所有注册的Mapping进行遍历,判断当前request具体是哪种情况导致
        // 的无法匹配:①RequestMethod无法匹配;②Consumes无法匹配;③Produces无法匹配;
        // ④Params无法匹配
        return handleNoMatch(this.mappingRegistry.getMappings().keySet(), 
            lookupPath, request);
    }
}

       这里对于结果的匹配,首先会通过uri进行直接匹配,如果能匹配到,则在匹配结果中尝试进行RequestMethod,Consumes和Produces等配置的匹配;如果通过uri不能匹配到,则直接对所有定义的RequestMapping进行匹配,这里主要是进行正则匹配,如果能匹配到。如果能够匹配到,则对匹配结果按照相似度进行排序,并且对前两个结果相似度进行比较,如果相似度一样,则抛出异常,如果不一样,则返回相似度最高的一个匹配结果。如果无法获取到匹配结果,则对所有的匹配结果进行遍历,判断当前request具体是哪一部分参数无法匹配到结果。对于匹配结果的获取,主要在addMatchingMappings()方法中,这里我们继续阅读该方法的源码:

private void addMatchingMappings(Collection<T> mappings, List<Match> matches, 
      HttpServletRequest request) {
    for (T mapping : mappings) {
        T match = getMatchingMapping(mapping, request);
        if (match != null) {
            matches.add(new Match(match, 
                this.mappingRegistry.getMappings().get(mapping)));
        }
    }
}

       对于RequestMapping的匹配,这里逻辑比较简单,就是对所有的RequestMappingInfo进行遍历,然后将request分别于每个RequestMappingInfo进行匹配,如果匹配上了,其返回值就不为空,最后将所有的匹配结果返回。如下是getMatchingMapping()方法的源码(其最终调用的是RequestMappingInfo.getMatchingCondition()方法):

@Override
@Nullable
public RequestMappingInfo getMatchingCondition(HttpServletRequest request) {
    // 判断request请求的类型是否与当前RequestMethod匹配
    RequestMethodsRequestCondition methods = 
        this.methodsCondition.getMatchingCondition(request);
    // 判断request请求的参数是否与RequestMapping中params参数配置的一致
    ParamsRequestCondition params = this.paramsCondition.getMatchingCondition(request);
    // 判断request请求的headers是否与RequestMapping中headers参数配置的一致
    HeadersRequestCondition headers = this.headersCondition.getMatchingCondition(request);
    // 判断request的请求体类型是否与RequestMapping中配置的consumes参数配置的一致
    ConsumesRequestCondition consumes = 
        this.consumesCondition.getMatchingCondition(request);
    // 判断当前RequestMapping将要返回的请求体类型是否与request中Accept的header指定的一致
    ProducesRequestCondition produces = 
        this.producesCondition.getMatchingCondition(request);

    // 对于上述几个判断,如果匹配上了,那么其返回值都不会为空,因而这里会对每个返回值都进行判断,
    // 如果有任意一个为空,则说明没匹配上,那么就返回null
    if (methods == null || params == null || headers == null 
        || consumes == null || produces == null) {
        return null;
    }

    // 对于前面的匹配,都是一些静态属性的匹配,其中最重要的uri的匹配,主要是正则匹配,
    // 就是在下面这个方法中进行的
    PatternsRequestCondition patterns = 
        this.patternsCondition.getMatchingCondition(request);
    // 如果URI没匹配上,则返回null
    if (patterns == null) {
        return null;
    }

    // 这里主要是对用户自定义的匹配条件进行匹配
    RequestConditionHolder custom = 
        this.customConditionHolder.getMatchingCondition(request);
    if (custom == null) {
        return null;
    }

    // 如果上述所有条件都匹配上了,那么就将匹配结果封装为一个RequestMappingInfo返回
    return new RequestMappingInfo(this.name, patterns, methods, params, headers, 
        consumes, produces, custom.getCondition());
}

        可以看到,对于一个RequestMapping的匹配,主要包括:RequestMethod,Params,Headers,Consumes,Produces,Uri和自定义条件的匹配,如果这几个条件都匹配上了,才能表明当前RequestMapping与request匹配上了。

3. Interceptor的封装

      关于Inteceptor的封装,由前述第一点可以看出,其主要在getHandlerExecutionChain()方法中,如下是该方法的源码:

protected HandlerExecutionChain getHandlerExecutionChain(Object handler, 
        HttpServletRequest request) {
    // 将当前handler封装到HandlerExecutionChain对象中
    HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
        (HandlerExecutionChain) handler : new HandlerExecutionChain(handler));

    // 获取当前request的URI,用于MappedInterceptor的匹配
    String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
    // 对当前所有注册的Interceptor进行遍历,如果其是MappedInterceptor类型,则调用其matches()
    // 方法,判断当前Interceptor是否能够应用于该request,如果可以,则添加到HandlerExecutionChain中
    for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
        if (interceptor instanceof MappedInterceptor) {
            MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
            if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
                chain.addInterceptor(mappedInterceptor.getInterceptor());
            }
        } else {
            // 如果当前Interceptor不是MappedInterceptor类型,则直接将其添加到
            // HandlerExecutionChain中
            chain.addInterceptor(interceptor);
        }
    }
    return chain;
}

       对于拦截器,理论上,Spring是会将所有的拦截器都进行一次调用,对于是否需要进行拦截,都是用户自定义实现的。这里如果对于URI有特殊的匹配,可以使用MappedInterceptor,然后实现其matches()方法,用于判断当前MappedInterceptor是否能够应用于当前request。

4. 小结

       本文首先讲解了Spring是如何通过request进行匹配,从而找到具体处理当前请求的RequestMapping的,然后讲解了Spring是如何封装Interceptor,将HandlerMethod和Interceptor封装为一个HandlerExecutionChain的。

© 著作权归作者所有

共有 人打赏支持
爱宝贝丶
粉丝 162
博文 83
码字总数 277470
作品 0
武汉
程序员
Spring Mvc之定制RequestMappingHandlerMapping

在上文Spring MVC之RequestMappingHandlerMapping匹配中我们讲到,Spring在进行request匹配的时候,不仅会匹配url,method,contentType等条件,还会对用户提供的定制条件进行匹配,用户提供...

爱宝贝丶
09/27
0
0
Spring4 + Spring MVC + MyBatis 整合思路

原文出处:斯武丶风晴 1、Spring框架的搭建 这个很简单,只需要web容器中注册org.springframework.web.context.ContextLoaderListener,并指定spring加载配置文件,那么spring容器搭建完成。...

斯武丶风晴
2017/09/21
0
0
Spring4+SpringMVC+MyBatis整合思路

本文主要简单讲解框架整合的思路。 1、Spring框架的搭建 这个很简单,只需要web容器中注册org.springframework.web.context.ContextLoaderListener,并指定spring加载配置文件,那么spring容...

Java团长17
07/11
0
0
解决Spring @MVC DispatcherServlet绑定多种URL模式时遇到的问题

Spring MVC使用过程中遇到了这样一个问题,web.xml有如下的配置,注意两个url-pattern是两种不同的url模式,.html主要是处理一般的页面请求,而/file/view/主要是用于文件下载,因为通过res...

逝水fox
2014/04/02
0
1
Spring MVC 解读——@RequestMapping (2)

Spring MVC 解读——@RequestMapping 上一篇文章中我们了解了Spring如何处理@RequestMapping注解,并将请求映射信息保存到系统中以处理客户端发送来的请求,但是Spring是怎样接受请求,并根据...

麦壳原野
2014/03/30
0
6

没有更多内容

加载失败,请刷新页面

加载更多

【王阳明心学语录】-001

1.“破山中贼易,破心中贼难。” 2.“夫万事万物之理不外于吾心。” 3.“心即理也。”“心外无理,心外无物,心外无事。” 4.“人心之得其正者即道心;道心之失其正者即人心。” 5.“无...

卯金刀GG
52分钟前
1
0
OSChina 周三乱弹 —— 我们无法成为野兽

Osc乱弹歌单(2018)请戳(这里) 【今日歌曲】 @ _刚刚好: 霸王洗发水这波很骚 手机党少年们想听歌,请使劲儿戳(这里) hahahahahahh @嘻酱:居然忘了喝水。 让你喝可乐的话, 你准忘不了...

小小编辑
今天
4
0
vm GC 日志 配置及查看

-XX:+PrintGCDetails 打印 gc 日志 -XX:+PrintTenuringDistribution 监控晋升分布 -XX:+PrintGCTimeStamps 包含时间戳 -XX:+printGCDateStamps 包含时间 -Xloggc:<filename> 可以将数据保存为......

Canaan_
昨天
0
0
学习设计模式——生成器模式

1. 认识生成器模式 1. 定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示 2. 组成: Builder:生成器接口,定义创建一个Product对象所需要的各个组件的操作,...

江左煤郎
昨天
1
0
C语言精要(第二章:基本数据类型)

2.1 C语言基本数据类型 在计算机术语中,把⼆进制数中的某⼀位数又称为⼀个⽐特(bit)。⽐特这个单位对于计算机⽽⾔,在度量上是最⼩的单位。除了⽐特之外,还有字节(byte)这个术语。⼀个...

ryanliue
昨天
0
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部