问题描述

有个自己的项目，以前使用JSON作为全局返回内容的，但是后面因为项目需求，需要同时使用XML来返回数据，但是在引入XML过后，通过浏览器访问以前所有返回JSON的接口都返回成XML了。
网上搜到了几篇文章，但是都没有解决问题，于是决定自己分析一波：
- SpringBoot-引入jackson-dataformat-xml之后，本返回json的接口返回xml
- jackson-dataformat-xml 将默认响应内容类型从“application/json”更改为“application/xml”

代码分析

经过以前的代码分析，我们知道，在SpringBoot取调用Controller之前，会分别调用两个接口的实现类，来分别对接口的参数和返回值做处理HandlerMethodArgumentResolver 和 HandlerMethodReturnValueHandler。那很明显，SpringBoot去对返回值做解析的时候就是通过后者来实现的。
通过断点一路跟进，我们走到了：RequestResponseBodyMethodProcessor#handleReturnValue方法。我们注意到这个方法里面调用了一个writeWithMessageConverters。熟悉SpringBoot的同学应该知道，SpringBoot消息的转化是通过HttpMessageConverter来实现的，所以很明显，我们定位到了目标位置。

protected <T> void writeWithMessageConverters(@Nullable T value, MethodParameter returnType,
                                              ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage)
    throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {

    Object body;
    Class<?> valueType;
    Type targetType;

    if (value instanceof CharSequence) {
        body = value.toString();
        valueType = String.class;
        targetType = String.class;
    }
    else {
        body = value;
        // 当前返回值的类型
        valueType = getReturnValueType(body, returnType);
        // 实际需要返回的类型
        targetType = GenericTypeResolver.resolveType(getGenericType(returnType), returnType.getContainingClass());
    }

    if (isResourceType(value, returnType)) {
		// 非ResourceType，忽略部分代码
    }

    MediaType selectedMediaType = null;
    MediaType contentType = outputMessage.getHeaders().getContentType();
    boolean isContentTypePreset = contentType != null && contentType.isConcrete();
    if (isContentTypePreset) {
        // 检查MimeType是否具体，说白了就是根据返回值的Header上的ContentType是否有通配符之类的东西
        if (logger.isDebugEnabled()) {
            logger.debug("Found 'Content-Type:" + contentType + "' in response");
        }
        selectedMediaType = contentType;
    }
    else {
        HttpServletRequest request = inputMessage.getServletRequest();
        List<MediaType> acceptableTypes;
        try {
            // 如果不具体的话，根据请求获取浏览器接收的ContentType
            acceptableTypes = getAcceptableMediaTypes(request);
        }
        catch (HttpMediaTypeNotAcceptableException ex) {
			// 忽略异常处理的代码
        }
		// 这个地方是个重点，可以点进去看看，这个地方就是根据你配置的HttpMessageConverter看支持那些MediaType
        List<MediaType> producibleTypes = getProducibleMediaTypes(request, valueType, targetType);
        if (body != null && producibleTypes.isEmpty()) {
            throw new HttpMessageNotWritableException(
                "No converter found for return value of type: " + valueType);
        }

        List<MediaType> compatibleMediaTypes = new ArrayList<>();
        // 决定使用那些MediaType（这个影响了后面使用那个HttpMessageConverter）
        determineCompatibleMediaTypes(acceptableTypes, producibleTypes, compatibleMediaTypes);

        // For ProblemDetail, fall back on RFC 7807 format
        if (compatibleMediaTypes.isEmpty() && ProblemDetail.class.isAssignableFrom(valueType)) {
            determineCompatibleMediaTypes(this.problemMediaTypes, producibleTypes, compatibleMediaTypes);
        }

        if (compatibleMediaTypes.isEmpty()) {
            if (logger.isDebugEnabled()) {
                logger.debug("No match for " + acceptableTypes + ", supported: " + producibleTypes);
            }
            if (body != null) {
                throw new HttpMediaTypeNotAcceptableException(producibleTypes);
            }
            return;
        }
		// 排序上面决定要使用的MediaType，从名字可以知道，这个是使用的更为具体的MediaType
        MimeTypeUtils.sortBySpecificity(compatibleMediaTypes);

        // 决定一个最终的MediaType
        for (MediaType mediaType : compatibleMediaTypes) {
            if (mediaType.isConcrete()) {
                selectedMediaType = mediaType;
                break;
            }
            else if (mediaType.isPresentIn(ALL_APPLICATION_MEDIA_TYPES)) {
                selectedMediaType = MediaType.APPLICATION_OCTET_STREAM;
                break;
            }
        }

        if (logger.isDebugEnabled()) {
            logger.debug("Using '" + selectedMediaType + "', given " +
                         acceptableTypes + " and supported " + producibleTypes);
        }
    }

    if (selectedMediaType != null) {
        // 这个地方就是在最终决定使用那个HttpMessageConverter进行转换了
        selectedMediaType = selectedMediaType.removeQualityValue();
        for (HttpMessageConverter<?> converter : this.messageConverters) {
            GenericHttpMessageConverter genericConverter =
                (converter instanceof GenericHttpMessageConverter ghmc ? ghmc : null);
            if (genericConverter != null ?
                ((GenericHttpMessageConverter) converter).canWrite(targetType, valueType, selectedMediaType) :
                converter.canWrite(valueType, selectedMediaType)) {
                body = getAdvice().beforeBodyWrite(body, returnType, selectedMediaType,
                                                   (Class<? extends HttpMessageConverter<?>>) converter.getClass(),
                                                   inputMessage, outputMessage);
                if (body != null) {
                    Object theBody = body;
                    LogFormatUtils.traceDebug(logger, traceOn ->
                                              "Writing [" + LogFormatUtils.formatValue(theBody, !traceOn) + "]");
                    addContentDispositionHeader(inputMessage, outputMessage);
                    if (genericConverter != null) {
                        // 最终进行转换
                        genericConverter.write(body, targetType, selectedMediaType, outputMessage);
                    }
                    else {
                        ((HttpMessageConverter) converter).write(body, selectedMediaType, outputMessage);
                    }
                }
                else {
                    if (logger.isDebugEnabled()) {
                        logger.debug("Nothing to write: null body");
                    }
                }
                return;
            }
        }
    }

    if (body != null) {
        Set<MediaType> producibleMediaTypes =
            (Set<MediaType>) inputMessage.getServletRequest()
            .getAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE);

        if (isContentTypePreset || !CollectionUtils.isEmpty(producibleMediaTypes)) {
            throw new HttpMessageNotWritableException(
                "No converter for [" + valueType + "] with preset Content-Type '" + contentType + "'");
        }
        throw new HttpMediaTypeNotAcceptableException(getSupportedMediaTypes(body.getClass()));
    }
}

根据上面的调试，getProducibleMediaTypes这个方法返回了5条数据（因为我同时配置了Json和XML的序列化器）
1
2
3
4
5
application/json application/*+json application/xml;charset=UTF-8 text/xml;charset=UTF-8 application/*+xml;charset=UTF-8

但是因为我是浏览器直接访问的，Accept的是：

text/html
application/xhtml+xml
image/webp
image/apng
application/xml;q=0.9
application/signed-exchange;v=b3;q=0.9
*/*;q=0.8

返回的compatibleMediaTypes为：

application/xhtml+xml
application/xml;charset=UTF-8;q=0.9
application/xml;q=0.9
application/json;q=0.8
application/*+json;q=0.8
application/xml;charset=UTF-8;q=0.8
text/xml;charset=UTF-8;q=0.8
application/*+xml;charset=UTF-8;q=0.8

所以很明显了，会使用XML来序列化。
那为什么不引入的时候就会返回JSON了呢？至少我们浏览器的Accept肯定也是和上面的一样的。因为即使去掉XML依赖过后，compatibleMediaTypes仍然会返回JSON这个MedaType。那为什么会返回JSON呢？这就得看determineCompatibleMediaTypes的源码了。

private void determineCompatibleMediaTypes(
    List<MediaType> acceptableTypes, List<MediaType> producibleTypes, List<MediaType> mediaTypesToUse) {
	// 这里我们也可以发现是通过acceptableTypes做外层producibleTypes做内层来判断的。所以accept在前的在mediaTypesToUse也会在前。虽然外层有MimeTypeUtils.sortBySpecificity，但是这个只是排那个更为具体，所以在这个地方基本上决定了走那个HttpMessageConverter了。
    for (MediaType requestedType : acceptableTypes) {
        for (MediaType producibleType : producibleTypes) {
            if (requestedType.isCompatibleWith(producibleType)) {
                mediaTypesToUse.add(getMostSpecificMediaType(requestedType, producibleType));
            }
        }
    }
}

我们着重看isCompatibleWith这个方法上的注释。

/**
	 * Indicate whether this {@code MediaType} is compatible with the given media type.
	 * <p>For instance, {@code text/*} is compatible with {@code text/plain},
	 * {@code text/html}, and vice versa. In effect, this method is similar to
	 * {@link #includes}, except that it <b>is</b> symmetric.
	 * <p>Simply calls {@link MimeType#isCompatibleWith(MimeType)} but declared with a
	 * {@code MediaType} parameter for binary backwards compatibility.
	 * @param other the reference media type with which to compare
	 * @return {@code true} if this media type is compatible with the given media type;
	 * {@code false} otherwise
	 */
public boolean isCompatibleWith(@Nullable MediaType other) {
    return super.isCompatibleWith(other);
}

注释上说了其推断的逻辑，比如：text/*可以匹配text/plain，所以最后我们能发现application/json实际上匹配了*/*;q=0.8。所以可以通过JSON来转换。

以上文章配置无用原因

以上两篇文章中的解决方案，其实和这块无关，这个配置的其实是Spring的内容协商机制（[文档地址](Content Negotiation using Spring MVC)）
内容协商(Content Negotiation)是HTTP协议中的一个特性，它允许客户端和服务器在传输数据时协商使用的表示方式。例如，客户端可以在请求头Accept中指定希望接收的数据格式，如格式。

在Spring MVC中，可以通过configureContentNegotiation方法来自定义内容协商的行为。如下：

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void configureContentNegotiation(ContentNegotiationConfigurer configurer) {
        configurer.defaultContentType(MediaType.APPLICATION_JSON)
            .favorPathExtension(true);
    }
}

其中设置了默认的内容类型为application/json，并且启用了路径扩展名策略。这意味着，如果请求没有明确指定Accept头，或者服务器无法提供Accept头中指定的媒体类型，那么服务器会返回application/json格式的数据。另外，如果请求的URL路径包含文件扩展名，如.json或.xml，那么服务器会优先考虑这个扩展名来决定返回数据的格式。
所以其实以上文章的解决方案，和我们实际的场景有关系，但是并不大，并不能解决我们现在的这个问题。

总结

因为SpringBoot决定使用那个HttpMessageConverter来转换的时候，优先级很大程度上依赖于Accept中的MediaType。所以需要确保Accept中的内容正确。

SpringBoot引入XML过后所有接口都返回JSON引发的代码分析

Gloduck 发布于 2023-08-16

文章访问量

问题描述

代码分析

以上文章配置无用原因

总结

Gloduck