Spring Jackson：在响应对象中包装响应体

Question

这可能是一个奇怪的问题，尽管我想知道为什么以前没有人提出过这个问题。。。因此，如果有任何无知，请纠正我。

首先，我将Jackson与Spring和@ResponseBody注释结合使用。目前，对于每个请求处理程序，我都返回一个“Response”包装器对象，这是客户机所期望的。这个包装非常简单：

{ "response": { "data" : ACTUAL_DATA } }

问题是，我不喜欢显式地包装所有请求处理程序的每个返回值。我也不喜欢在单元测试中打开这些响应包装。

相反，我想知道是否有可能返回实际的_数据，并在其他地方截取和包装这些数据。

如果这实际上是可能的，那么是否有可能读取附加到截获请求处理程序的注释？通过这种方式，我可以使用自定义注释来决定如何包装数据。

例如，像这样的东西将是惊人的（请注意，@FetchReport和@响应Wrapper是由建议的注释组成的）：

@RequestMapping(...)
@FetchResponse
@ResponseBody
public List<User> getUsers() {
    ...
}

@ResponseWrapper(FetchResponse.class)
public Object wrap(Object value) {
    ResponseWrapper rw = new ResponseWrapper();
    rw.setData(value);
    return rw;
}

有人熟悉这个地区吗？或者，为什么这可能是不好的做法？

Answer 1

我知道答案被接受已经有一段时间了，但最近我偶然发现了与Jackson的一个问题，这让我发现了使用ResponseBodyAdvice的问题。

Jackson不会正确序列化使用@JsonTypeInfo/@JsonSubTypes的多态类型，如果在运行时类型的值未知：例如，如果您有一个类似类响应包装器的通用容器类型

如果您只是实现ResponseBodyAdvice并从beforeBodyWrite（）返回一个新的包装值，那么Spring将不再知道您的完整泛型类型及其专门化，它将把您的响应序列化为ResponseWrapper

解决此问题的唯一方法是从AbstractJackson2HttpMessageConverter扩展并重写writeInternal（）。请参见此处的方法如何处理类型：https://github.com/spring-projects/spring-framework/blob/master/spring-web/src/main/java/org/springframework/http/converter/json/AbstractJackson2HttpMessageConverter.java#L437
您还需要使用AbstractMappingJacksonResponseBodyAdvice和您自己的自定义MappingJacksonValue实现控制器建议，其中包括自定义HttpMessageConverter将使用的类型targetType。

响应包装器

public class ResponseWrapper<T> {
    @Nullable Error error;
    T result;

    public ResponseWrapper(T result) {
        this.result = result;
    }
}

包装用具

@Component
public class WrappingAdvice extends AbstractMappingJacksonResponseBodyAdvice {
    

    @Override
    protected MappingJacksonValue getOrCreateContainer(Object body) {
        MappingJacksonValue cnt = super.getOrCreateContainer(body);
        if (cnt instanceof MyMappingJacksonValue) {
            return cnt;
        }

        return new MyMappingJacksonValue(cnt);
    }

    @Override
    protected void beforeBodyWriteInternal(
            MappingJacksonValue bodyContainer, MediaType contentType,
            MethodParameter returnType, ServerHttpRequest request, ServerHttpResponse response) {

        MyMappingJacksonValue cnt = (MyMappingJacksonValue) bodyContainer;

        Type targetType = getTargetType(bodyContainer.getValue(), returnType);

        cnt.setValue(new ResponseWrapper(cnt.getValue()));
        cnt.setTargetType(TypeUtils.parameterize(
                ResponseWrapper.class,
                targetType));
    }

    /**
     * This is derived from AbstractMessageConverterMethodProcessor
     */
    private Type getTargetType(Object value, MethodParameter returnType) {
        if (value instanceof CharSequence) {
            return String.class;
        }

        Type genericType;
        if (HttpEntity.class.isAssignableFrom(returnType.getParameterType())) {
            genericType = ResolvableType.forType(returnType.getGenericParameterType()).getGeneric().getType();
        } else {
            genericType = returnType.getGenericParameterType();
        }

        return GenericTypeResolver.resolveType(genericType, returnType.getContainingClass());
    }

    public static class MyMappingJacksonValue extends MappingJacksonValue {
        private Type targetType;

        public MyMappingJacksonValue(MappingJacksonValue other) {
            super(other.getValue());
            setFilters(other.getFilters());
            setSerializationView(other.getSerializationView());
        }

        public Type getTargetType() {
            return targetType;
        }

        public void setTargetType(Type targetType) {
            this.targetType = targetType;
        }
    }
}

JsonHttpMessageBodyConzer

@Component
public class JsonHttpMessageBodyConverter extends AbstractJackson2HttpMessageConverter {

    // omitted all constructors

    @Override
    protected void writeInternal(Object object, Type type, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
        if (object instanceof WrapAPIResponseAdvice.MyMappingJacksonValue) {
            type = ((WrapAPIResponseAdvice.MyMappingJacksonValue) object).getTargetType();
        }

        super.writeInternal(object, type, outputMessage);
    }
}

Answer 2

对于任何想了解更多关于这个话题的信息的人：我也面临着同样的问题，多亏了kennyg的提示，我想出了以下解决方案：

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

@ControllerAdvice
public class JSendAdvice implements ResponseBodyAdvice<Object> {

    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
        if (body instanceof JSendResponse) {
            return body;
        }

        return new JSendResponse<>().success(body);
    }
}

此解决方案将控制器中返回的所有对象包装在一个（本例中）JSend响应类中，这为您节省了在所有控制器方法中返回JSend响应的麻烦。

Answer 3

嗯，看起来我在找Spring的“响应身体建议”和“抽象映射杰克逊响应身体建议”。