Spring GetMapping注解无效原因分析和解决

笔记简述
本学习笔记是由GetMapping注解无效这个问题引起的，最后发现是自己的xml配置错误
调试源码最后发现了spring早已经废弃了默认的URL获取方法，而是采用了最新的方法去实现
并记录下新的URL的获取以及映射的一些细节和过程，最好可以和Spring MVC URL映射学习（上） Spring MVC URL映射学习（下）再结合源码调试了解其中的细节

学习spring的时候，学习GetMapping注解，了解到他是在spring4.3加的新注解，整合了@RequestMapping(method = RequestMethod.GET),让代码能够更加简洁。

如下图圈住的代码，从含义来说是一模一样的，可是在实践的时候，GetMapping却不能传递value值，不知道自己到底哪一步错了。记录在这里，等着明确知道答案了，再补充。

image

查看源码打断点调试发现如下信息

在获取注解信息的时候，GetMapping的属性

image

可是在匹配到RequestMapping的时候，只有method信息，并不包含value信息

image

导致了从GetMapping注解上就没法获取到URL信息，从而就出现了注册handler的时候，URL信息不全，最后的handlerMap信息如下图

image

也就导致了GetMapping注解无效的情况，但是还是没有发现其原因

2018年03月17日00:17:08 更新已经发现了问题所在并解决了
先说解决方案，在xml文件中加入<mvc:annotation-driven />，就可以正常使用GetMapping注解了

无效的原因

在起初使用GetMapping的时候，查看源码发现是由DefaultAnnotationHandlerMapping类调用实现的，而在文档中明确说明了@deprecated as of Spring 3.2，意味着从spring3.2开始就不再推荐使用该类了，而与此同时GetMapping是从spring4.3才加入的产物，那么必然存在着使用了GetMapping的同时又使用老的类完成URL属性获取操作的问题。

直接的问题就是使用了GetMapping之后，参数无法重新拷贝到RequestMapping中，从而使得数据丢失。

AnnotationUtils 类

static <A extends Annotation> A synthesizeAnnotation(A annotation, Object annotatedElement) {
    if (annotation == null) {
        return null;
    }
    if (annotation instanceof SynthesizedAnnotation) {
        return annotation;
    }

    Class<? extends Annotation> annotationType = annotation.annotationType();
    if (!isSynthesizable(annotationType)) {
        return annotation;
    }

    DefaultAnnotationAttributeExtractor attributeExtractor =
            new DefaultAnnotationAttributeExtractor(annotation, annotatedElement);
    InvocationHandler handler = new SynthesizedAnnotationInvocationHandler(attributeExtractor);
    
    Class<?>[] exposedInterfaces = new Class<?>[] {annotationType, SynthesizedAnnotation.class};
    return (A) Proxy.newProxyInstance(annotation.getClass().getClassLoader(), exposedInterfaces, handler);
}

public static <A extends Annotation> A synthesizeAnnotation(Map<String, Object> attributes,
        Class<A> annotationType, AnnotatedElement annotatedElement) {

    Assert.notNull(annotationType, "'annotationType' must not be null");
    if (attributes == null) {
        return null;
    }

    MapAnnotationAttributeExtractor attributeExtractor =
            new MapAnnotationAttributeExtractor(attributes, annotationType, annotatedElement);
    InvocationHandler handler = new SynthesizedAnnotationInvocationHandler(attributeExtractor);
    Class<?>[] exposedInterfaces = (canExposeSynthesizedMarker(annotationType) ?
            new Class<?>[] {annotationType, SynthesizedAnnotation.class} : new Class<?>[] {annotationType});
    return (A) Proxy.newProxyInstance(annotationType.getClassLoader(), exposedInterfaces, handler);
}

细看上面两个函数，方法参数中一个带着属性字段，另一个没有，其实这两个函数就是新旧的生成RequestMapping注解的方法，其中带有属性字段的是新的执行函数，传递着GetMapping注解的属性，确保数据的连贯性。

源码分析

URL映射获取

接下来就来学习下xml配置<mvc:annotation-driven />的执行过程，老套路直接定位到AnnotationDrivenBeanDefinitionParser类(PS:如果这点存在疑问可以看看[dfgdfg](fff

如果查看这个类的parse过程，大概可以发现就是注册和添加了RequestMappingHandlerMapping、RequestMappingHandlerAdapter 适配器等操作，以及额外的cors、aop等操作。

执行RequestMappingHandlerMapping的afterPropertiesSet去实现实例化的步骤中完成对URL属性的读取和拼接、存储的过程

image

如图，最后RequestMappingHandlerMapping实例化完成后，就去执行了initHandlerMethod的方法，和spring mvc获取URL信息一样的操作，遍历所有的类，得到每个类的方法，再解析每个可行的方法的注解。

最后执行到了RequestMappingHandlerMapping类的getMappingForMethod方法

protected RequestMappingInfo getMappingForMethod(Method method, Class<?> handlerType) {
    RequestMappingInfo info = createRequestMappingInfo(method);
    // 获取方法的注解信息
    if (info != null) {
        RequestMappingInfo typeInfo = createRequestMappingInfo(handlerType);
        // 再获取类的注解信息
        if (typeInfo != null) {
            info = typeInfo.combine(info);
            // 合并类的注解信息和方法注解信息
        }
    }
    return info;
}

private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
    RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(element, RequestMapping.class);
    // 获取RequestMapping注解信息
    RequestCondition<?> condition = (element instanceof Class ?
            getCustomTypeCondition((Class<?>) element) : getCustomMethodCondition((Method) element));
    return (requestMapping != null ? createRequestMappingInfo(requestMapping, condition) : null);
}

上述代码中对每个handlerType都进行了createRequestMappingInfo处理，我感觉没必要啊，毕竟是属于类层级的，类的注解信息获取一次就好了，然后和各类自身的方法合并即可，大不了加入缓存也行，而不是每次都实际解析操作，这点感觉怪怪的

AnnotatedElementUtils 类

public static <A extends Annotation> A findMergedAnnotation(AnnotatedElement element, Class<A> annotationType) {
    if (!(element instanceof Class)) {
        // 如果元素不是类
        A annotation = element.getAnnotation(annotationType);
        // 直接获取期望类型的注解
        if (annotation != null) {
           // 如果存在，就同步下，返回注解信息
            return AnnotationUtils.synthesizeAnnotation(annotation, element);
        }
    }
    AnnotationAttributes attributes = findMergedAnnotationAttributes(element, annotationType, false, false);
   // 其他情况，先发现注解可能有用的属性信息
    return AnnotationUtils.synthesizeAnnotation(attributes, annotationType, element);
}

获取GetMapping的属性得到的数据

image

获得了方法的注解信息得到的URL信息

image

合并处理函数和方法的URL信息得到的完整的URL信息

image

URL处理

先获取方法的URL信息，如果有了再获取类的URL信息，进行合并操作
如果方法没有有效的URL信息，则直接返回null
如果类没有URL信息，则返回方法的URL信息

最后实例化完成，该bean中的mappingRegistry存储的URL信息，然后该数据成功的在initHandlerMappings完成赋值到dispatchservice中，并且包含了适配器的赋值

image

URL信息合并

类URL属性和方法URL信息如何拼接成完整的URL信息

public RequestMappingInfo combine(RequestMappingInfo other) {
    String name = combineNames(other);
    // 此name会组合成类的简写名称+方法名称
    PatternsRequestCondition patterns = this.patternsCondition.combine(other.patternsCondition);
    // 这就是URL信息拼接最关键的地方
 .....
}

public PatternsRequestCondition combine(PatternsRequestCondition other) {
    Set<String> result = new LinkedHashSet<String>();
    if (!this.patterns.isEmpty() && !other.patterns.isEmpty()) {
        for (String pattern1 : this.patterns) {
            for (String pattern2 : other.patterns) {
                result.add(this.pathMatcher.combine(pattern1, pattern2));
                // 类的URL信息和方法URL信息拼接
            }
        }
    }
    else if (!this.patterns.isEmpty()) {
        result.addAll(this.patterns);
        // 只有类的URL信息
    }
    else if (!other.patterns.isEmpty()) {
        result.addAll(other.patterns);
        // 只有方法的URL信息
    }
    else {
        result.add("");
    }
    return new PatternsRequestCondition(result, this.pathHelper, this.pathMatcher, this.useSuffixPatternMatch,
            this.useTrailingSlashMatch, this.fileExtensions);
}

URL映射处理

和Spring MVC URL映射学习（下）描述的不同的是，在执行getHandlerInternal方法是，进入了AbstractHandlerMethodMapping类中，而不是之前说的AbstractUrlHandlerMapping类，这就是因为具体的RequestMapping的不同而跳转到不同的子类执行而已。

AbstractHandlerMethodMapping 类

protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
    String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
    // 获取请求的URL信息
    this.mappingRegistry.acquireReadLock();
    try {
        HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
        // 查找到合适的执行方法
        return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
    }
    finally {
        this.mappingRegistry.releaseReadLock();
    }
}

protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request) throws Exception {
    List<Match> matches = new ArrayList<Match>();
    List<T> directPathMatches = this.mappingRegistry.getMappingsByUrl(lookupPath);
    // 从urlLookUp集合中完全匹配URL信息
    if (directPathMatches != null) {
       // 对筛选的全局匹配的URL属性进行匹配操作
        addMatchingMappings(directPathMatches, matches, request);
    }
    if (matches.isEmpty()) {
        // 把所有的URL信息添加到需要对比的集合中，进行匹配操作
        // 注意，这里面是个很耗时的操作
        addMatchingMappings(this.mappingRegistry.getMappings().keySet(), matches, request);
    }

    if (!matches.isEmpty()) {
        Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));
        Collections.sort(matches, comparator);
        // 对匹配到的URL集合进行排序，意味着相似的URL会被排到一起
        
        Match bestMatch = matches.get(0);
        if (matches.size() > 1) {
            if (CorsUtils.isPreFlightRequest(request)) {
               // 符合 CORS pre-flight的请求，就返回一个EmptyHandler对象，
               // 同时会抛出UnsupportedOperationException异常
                return PREFLIGHT_AMBIGUOUS_MATCH;
            }
            Match secondBestMatch = matches.get(1);
            if (comparator.compare(bestMatch, secondBestMatch) == 0) {
               // 存在两个同等层级的URL匹配信息，然后spring就懵逼了，不知道选择哪个了
               // 抛出IllegalStateException异常
               // 这点可以写一个demo确实验证下
                Method m1 = bestMatch.handlerMethod.getMethod();
                Method m2 = secondBestMatch.handlerMethod.getMethod();
                throw new IllegalStateException("Ambiguous handler methods mapped for HTTP path '" +
                        request.getRequestURL() + "': {" + m1 + ", " + m2 + "}");
            }
        }
        handleMatch(bestMatch.mapping, lookupPath, request);
        return bestMatch.handlerMethod;
    }
    else {
        return handleNoMatch(this.mappingRegistry.getMappings().keySet(), lookupPath, request);
    }
}

private void addMatchingMappings(Collection<T> mappings, List<Match> matches, HttpServletRequest request) {
    for (T mapping : mappings) {
        T match = getMatchingMapping(mapping, request);
        // 其实这个时候的mapping是RequestMappingInfo对象（一般情况）
        // 匹配出合适的URL信息
        if (match != null) {
            matches.add(new Match(match, this.mappingRegistry.getMappings().get(mapping)));
        }
    }
}

RequestMappingInfo 类

public RequestMappingInfo getMatchingCondition(HttpServletRequest request) {
    RequestMethodsRequestCondition methods = this.methodsCondition.getMatchingCondition(request);
    // 匹配方法名称，
    ParamsRequestCondition params = this.paramsCondition.getMatchingCondition(request);
    // 匹配参数
    HeadersRequestCondition headers = this.headersCondition.getMatchingCondition(request);
    // 匹配头部信息
    ConsumesRequestCondition consumes = this.consumesCondition.getMatchingCondition(request);
    // 匹配处理请求的类型，也就是Content-Type
    ProducesRequestCondition produces = this.producesCondition.getMatchingCondition(request);
    // 匹配相应请求的类型，从request的Accept参数中获取

    if (methods == null || params == null || headers == null || consumes == null || produces == null) {
       // 有一个没有匹配上就认为没有合适的映射对象
        return null;
    }

    PatternsRequestCondition patterns = this.patternsCondition.getMatchingCondition(request);
    // 使用了Apache Ant的匹配规则去匹配path
    if (patterns == null) {
        return null;
    }

    RequestConditionHolder custom = this.customConditionHolder.getMatchingCondition(request);
    // 这个没有具体获取
    if (custom == null) {
        return null;
    }

    return new RequestMappingInfo(this.name, patterns,
            methods, params, headers, consumes, produces, custom.getCondition());
}

关于上述的Apache Ant 在spring mvc的具体匹配是AntPathMatcher 类的 doMatch 方法

URL匹配总结

URL匹配流程图

image

Spring GetMapping注解无效 原因分析和解决

无效的原因

源码分析

URL映射 获取

URL信息合并

URL映射 处理

URL匹配总结

Spring GetMapping注解无效原因分析和解决

URL映射获取

URL映射处理