Spring Boot：在动态父对象中包装JSON响应

Question

我有一个REST API规范，与后端微服务进行通信，返回以下值：

关于“集合”响应（例如GET /用户）：

{
    users: [
        {
            ... // single user object data
        }
    ],
    links: [
        {
            ... // single HATEOAS link object
        }
    ]
}

关于“单个对象”响应（例如GET /users/{userUuid} ）：

{
    user: {
        ... // {userUuid} user object}
    }
}

选择这种方法是为了使单个响应是可扩展的（例如，如果GET /users/{userUuid}获得一个额外的查询参数，那么在?detailedView=true我们将有额外的请求信息）。

从根本上说，我认为这是一种可以最大限度地减少API更新之间的重大变化的方法。 但是，将此模型转换为代码证明是非常艰巨的。

假设对于单个响应，我为单个用户提供了以下API模型对象：

public class SingleUserResource {
    private MicroserviceUserModel user;

    public SingleUserResource(MicroserviceUserModel user) {
        this.user = user;
    }

    public String getName() {
        return user.getName();
    }

    // other getters for fields we wish to expose
}

这种方法的好处是，我们可以公开只能从我们掌握的公共干将内部使用的模型的领域，而不是其他。 然后，对于集合响应，我将有以下包装类：

public class UsersResource extends ResourceSupport {

    @JsonProperty("users")
    public final List<SingleUserResource> users;

    public UsersResource(List<MicroserviceUserModel> users) {
        // add each user as a SingleUserResource
    }
}

对于单个对象响应，我们将具有以下内容：

public class UserResource {

    @JsonProperty("user")
    public final SingleUserResource user;

    public UserResource(SingleUserResource user) {
        this.user = user;
    }
}

这会产生JSON响应，这些响应的格式符合本文顶部的API规范。 这种方法的优点是我们只公开那些我们想要公开的字段。 重要的缺点是我有大量的包装类飞来飞去，除了被杰克逊读取以产生正确格式化的响应之外，没有任何明显的逻辑任务。

我的问题如下：

• 我怎么可能推广这种方法？ 理想情况下，我想有一个BaseSingularResponse类（可能是一个BaseCollectionsResponse extends ResourceSupport类），我的模型可以扩展，但看看Jackson似乎从对象定义派生出JSON密钥，我将不得不使用像Javaassist这样的Javaassist在运行时向基本响应类添加字段 - 这是一个我希望尽可能远离人类的肮脏黑客。

• 有没有更简单的方法来实现这一目标？ 不幸的是，我可能在一年后的响应中有可变数量的顶级JSON对象，所以我不能使用像Jackson的SerializationConfig.Feature.WRAP_ROOT_VALUE这样的东西，因为它将所有内容包装到一个根级对象中（就我而言）我知道）。

• 是否有类似@JsonProperty的类级别（而不仅仅是方法和字段级别）？

Answer 1

有几种可能性。

您可以使用java.util.Map ：

List<UserResource> userResources = new ArrayList<>();
userResources.add(new UserResource("John"));
userResources.add(new UserResource("Jane"));
userResources.add(new UserResource("Martin"));
Map<String, List<UserResource>> usersMap = new HashMap<String, List<UserResource>>();
usersMap.put("users", userResources);
ObjectMapper mapper = new ObjectMapper();
System.out.println(mapper.writeValueAsString(usersMap));

---

您可以使用ObjectWriter来包装您可以使用的响应，如下所示：

ObjectMapper mapper = new ObjectMapper();
ObjectWriter writer = mapper.writer().withRootName(root);
result = writer.writeValueAsString(object);

这是一个推广这个序列化的命题。

处理简单对象的类 ：

public abstract class BaseSingularResponse {

    private String root;

    protected BaseSingularResponse(String rootName) {
        this.root = rootName;
    }

    public String serialize() {
        ObjectMapper mapper = new ObjectMapper();
        ObjectWriter writer = mapper.writer().withRootName(root);
        String result = null;
        try {
            result = writer.writeValueAsString(this);
        } catch (JsonProcessingException e) {
            result = e.getMessage();
        }
        return result;
    }
}

一个处理集合的类 ：

public abstract class BaseCollectionsResponse<T extends Collection<?>> {
    private String root;
    private T collection;

    protected BaseCollectionsResponse(String rootName, T aCollection) {
        this.root = rootName;
        this.collection = aCollection;
    }

    public T getCollection() {
        return collection;
    }

    public String serialize() {
        ObjectMapper mapper = new ObjectMapper();
        ObjectWriter writer = mapper.writer().withRootName(root);
        String result = null;
        try {
            result = writer.writeValueAsString(collection);
        } catch (JsonProcessingException e) {
            result = e.getMessage();
        }
        return result;
    }
}

一个示例应用程序 ：

public class Main {

    private static class UsersResource extends BaseCollectionsResponse<ArrayList<UserResource>> {
        public UsersResource() {
            super("users", new ArrayList<UserResource>());
        }
    }

    private static class UserResource extends BaseSingularResponse {

        private String name;
        private String id = UUID.randomUUID().toString();

        public UserResource(String userName) {
            super("user");
            this.name = userName;
        }

        public String getUserName() {
            return this.name;
        }

        public String getUserId() {
            return this.id;
        }
    }

    public static void main(String[] args) throws JsonProcessingException {
        UsersResource userCollection = new UsersResource();
        UserResource user1 = new UserResource("John");
        UserResource user2 = new UserResource("Jane");
        UserResource user3 = new UserResource("Martin");

        System.out.println(user1.serialize());

        userCollection.getCollection().add(user1);
        userCollection.getCollection().add(user2);
        userCollection.getCollection().add(user3);

        System.out.println(userCollection.serialize());
    }
}

---

您还可以在类级别中使用Jackson注释@JsonTypeInfo

@JsonTypeInfo(include=As.WRAPPER_OBJECT, use=JsonTypeInfo.Id.NAME)

Answer 2

就个人而言，我不介意额外的Dto类，你只需要创建一次，并且几乎没有维护成本。 如果您需要进行MockMVC测试，您很可能需要这些类来反序列化您的JSON响应以验证结果。

您可能知道Spring框架处理HttpMessageConverter层中对象的序列化/反序列化，因此这是更改对象序列化方式的正确位置。

如果您不需要反序列化响应，则可以创建通用包装器和自定义HttpMessageConverter（并将其放在消息转换器列表中的MappingJackson2HttpMessageConverter之前）。 像这样：

public class JSONWrapper {

    public final String name;
    public final Object object;

    public JSONWrapper(String name, Object object) {
        this.name = name;
        this.object = object;
    }
}


public class JSONWrapperHttpMessageConverter extends MappingJackson2HttpMessageConverter {

    @Override
    protected void writeInternal(Object object, Type type, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
        // cast is safe because this is only called when supports return true.
        JSONWrapper wrapper = (JSONWrapper) object;
        Map<String, Object> map = new HashMap<>();
        map.put(wrapper.name, wrapper.object);
        super.writeInternal(map, type, outputMessage);
    }

    @Override
    protected boolean supports(Class<?> clazz) {
        return clazz.equals(JSONWrapper.class);
    }
}

然后，您需要在spring配置中注册自定义HttpMessageConverter，它通过覆盖configureMessageConverters()来扩展WebMvcConfigurerAdapter 。 请注意，执行此操作会禁用转换器的默认自动检测，因此您可能必须自己添加默认值（查看Spring源代码以获取WebMvcConfigurationSupport#addDefaultHttpMessageConverters()以查看默认值。如果您扩展WebMvcConfigurationSupport而不是WebMvcConfigurerAdapter ，则可以直接调用addDefaultHttpMessageConverters （我个人WebMvcConfigurationSupport在WebMvcConfigurerAdapter使用WebMvcConfigurationSupport ，如果我需要自定义任何东西，但这样做会有一些小问题，你可以在其他文章中读到这些内容。

Answer 3

Jackson对动态/变量JSON结构没有很多支持，所以任何完成这样的事情的解决方案都会像你提到的那样非常hacky。 据我所知，从我所看到的，标准和最常见的方法是使用像你一样的包装类。 包装类确实会加起来，但是如果你有创造力，那么你可以在类之间找到一些共性，从而减少包装类的数量。 否则，您可能正在考虑编写自定义框架。

Answer 4

我想你正在寻找Custom Jackson Serializer 。 通过简单的代码实现，可以在不同的结构中序列化相同的对象

一些例子： https ： //stackoverflow.com/a/10835504/814304 http://www.davismol.net/2015/05/18/jackson-create-and-register-a-custom-json-serializer-with- stdserializer和- simplemodule类/