Jackson处理带有动态属性键的JSON数据：序列化与反序列化教程-java教程-PHP中文网

Jackson处理带有动态属性键的JSON数据：序列化与反序列化教程

本教程详细介绍了如何使用Jackson库处理JSON数据中包含动态或随机生成属性键的场景。我们将探讨当标准POJO映射失效时，如何通过TypeReference直接将JSON反序列化为Map结构，以及在特定JSON结构下如何利用包装POJO进行处理，并提供相应的序列化方法和示例代码，帮助开发者高效、灵活地解析和生成复杂JSON。

引言与问题背景

在与外部服务进行数据交互时，我们经常会遇到json数据结构不完全固定的情况。尤其当json的顶级属性键是动态生成或随机变化的，例如"random1"、"nextrandom500"等，而其对应的值结构却是固定的对象时，使用jackson进行标准pojo（plain old java object）映射会遇到挑战。jackson默认期望json的键与pojo的属性名严格对应，一旦遇到未知属性，便会抛出com.fasterxml.jackson.databind.exc.unrecognizedpropertyexception异常。

例如，以下JSON结构中，random1、nextRandom500、random100500都是动态键：

{
    "random1" : {
        "name" : "john",
        "lastName" : "johnson"
    },
    "nextRandom500" : {
        "name" : "jack",
        "lastName" : "jackson"
    },
    "random100500" : {
        "name" : "jack",
        "lastName" : "johnson"
    }   
}

登录后复制

当尝试将上述JSON直接反序列化到一个包含Map<String, User>属性的UserResponse POJO时，如果JSON本身没有一个固定的包装键（如"users"），Jackson将无法识别"random1"等顶级键，从而导致反序列化失败。

问题分析：为何会抛出UnrecognizedPropertyException？

Jackson在进行对象反序列化时，会尝试将JSON中的每个键映射到目标POJO类中的一个属性。如果JSON中存在POJO类中未定义的顶级键，且没有特殊配置（如@JsonIgnoreProperties(ignoreUnknown = true)），Jackson就会认为这是一个“无法识别的属性”，并抛出UnrecognizedPropertyException。

在上述示例中，如果我们的UserResponse POJO定义如下：

import com.fasterxml.jackson.annotation.JsonInclude;
import java.util.Map;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;

@Data
@SuperBuilder(toBuilder=true)
@NoArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public class UserResponse {
    private Map<String,User> users; // Jackson会寻找名为"users"的键

    @Data
    @SuperBuilder(toBuilder=true)
    @NoArgsConstructor
    @JsonInclude(JsonInclude.Include.NON_NULL)
    public static class User {
        private String name;
        private String lastName;
    }
}

登录后复制

而实际的JSON数据是：

{
    "random1" : { /* ... */ },
    "nextRandom500" : { /* ... */ }
}

登录后复制

Jackson会尝试将"random1"映射到UserResponse的某个属性，但UserResponse中只有一个users属性。由于"random1"与"users"不匹配，Jackson便会抛出异常。

解决方案一：直接映射到Map结构

当JSON的顶级键是动态的，但其值结构是固定的对象时，最直接有效的方法是将整个JSON反序列化为一个Map<String, T>类型。Jackson的TypeReference提供了一种在运行时保留泛型类型信息的方式，非常适合这种场景。

1. POJO定义

首先，我们需要定义动态键所对应的值对象User：

import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;

@Data
@SuperBuilder(toBuilder=true)
@NoArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public class User {
    private String name;
    private String lastName;
}

登录后复制

注意：这里不再需要一个外部的UserResponse类来包装这个Map，因为我们将直接把整个JSON看作一个Map。

2. 反序列化

使用ObjectMapper结合TypeReference将JSON字符串反序列化为Map<String, User>：

序列猴子开放平台

具有长序列、多模态、单模型、大数据等特点的超大规模语言模型

查看详情

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.io.IOException;
import java.util.Map;

public class JsonDeserializationExample {

    public static void main(String[] args) throws IOException {
        String jsonString = "{\n" +
                "    \"random1\" : {\n" +
                "        \"name\" : \"john\",\n" +
                "        \"lastName\" : \"johnson\"\n" +
                "    },\n" +
                "    \"nextRandom500\" : {\n" +
                "        \"name\" : \"jack\",\n" +
                "        \"lastName\" : \"jackson\"\n" +
                "    },\n" +
                "    \"random100500\" : {\n" +
                "        \"name\" : \"jack\",\n" +
                "        \"lastName\" : \"johnson\"\n" +
                "    }   \n" +
                "}";

        ObjectMapper objectMapper = new ObjectMapper();
        // 配置以美化输出，非必需
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);

        // 使用TypeReference进行反序列化
        Map<String, User> usersMap = objectMapper.readValue(jsonString, new TypeReference<Map<String, User>>(){});

        System.out.println("反序列化成功，Map内容：");
        usersMap.forEach((key, user) -> 
            System.out.println("  Key: " + key + ", User: " + user.getName() + " " + user.getLastName())
        );
    }
}

登录后复制

解释： new TypeReference<Map<String, User>>(){}是一个匿名内部类，它允许Jackson在运行时获取到Map<String, User>的完整泛型类型信息，从而正确地将JSON中的每个顶级键值对映射到Map中的相应条目。

3. 序列化

将Map<String, User>对象序列化回原始JSON格式同样简单，只需直接调用ObjectMapper的writeValueAsString方法：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class JsonSerializationExample {

    public static void main(String[] args) throws IOException {
        // 创建一个Map<String, User>对象
        Map<String, User> usersMap = new HashMap<>();
        usersMap.put("randomA", new User("Alice", "Smith"));
        usersMap.put("randomB", new User("Bob", "Johnson"));

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT); // 美化输出

        // 序列化Map到JSON字符串
        String serializedJson = objectMapper.writeValueAsString(usersMap);

        System.out.println("序列化后的JSON：");
        System.out.println(serializedJson);
    }
}

登录后复制

解决方案二：使用包装POJO（适用于特定JSON结构）

如果JSON的结构并非直接由动态键构成，而是包含一个固定的顶级键，该键的值是一个由动态键组成的Map，那么使用一个包装POJO是更合适的选择。

例如，如果你的JSON数据实际上是这样的：

{
  "users": {
    "random1" : {
      "name" : "john",
      "lastName" : "johnson"
    },
    "nextRandom500" : {
      "name" : "jack",
      "lastName" : "jackson"
    },
    "random100500" : {
      "name" : "jack",
      "lastName" : "johnson"
    }
  }
}

登录后复制

在这种情况下，"users"是一个固定的顶级键，其值是一个Map<String, User>。

1. POJO定义

此时，你最初定义的UserResponse POJO是完全适用的：

import com.fasterxml.jackson.annotation.JsonInclude;
import java.util.Map;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;

@Data
@SuperBuilder(toBuilder=true)
@NoArgsConstructor
@JsonInclude(JsonInclude.Include.NON_NULL)
public class UserResponse {
    private Map<String,User> users; // Jackson会寻找名为"users"的键

    @Data
    @SuperBuilder(toBuilder=true)
    @NoArgsConstructor
    @JsonInclude(JsonInclude.Include.NON_NULL)
    public static class User {
        private String name;
        private String lastName;
    }
}

登录后复制

2. 反序列化与序列化

直接使用ObjectMapper对UserResponse.class进行反序列化和序列化：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class WrappedPojoExample {

    public static void main(String[] args) throws IOException {
        String wrappedJsonString = "{\n" +
                "  \"users\": {\n" +
                "    \"random1\" : {\n" +
                "      \"name\" : \"john\",\n" +
                "      \"lastName\" : \"johnson\"\n" +
                "    },\n" +
                "    \"nextRandom500\" : {\n" +
                "      \"name\" : \"jack\",\n" +
                "      \"lastName\" : \"jackson\"\n" +
                "    },\n" +
                "    \"random100500\" : {\n" +
                "      \"name\" : \"jack\",\n" +
                "      \"lastName\" : \"johnson\"\n" +
                "    }\n" +
                "  }\n" +
                "}";

        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.enable(SerializationFeature.INDENT_OUTPUT);

        // 反序列化
        UserResponse userResponse = objectMapper.readValue(wrappedJsonString, UserResponse.class);
        System.out.println("反序列化成功，UserResponse内容：");
        userResponse.getUsers().forEach((key, user) -> 
            System.out.println("  Key: " + key + ", User: " + user.getName() + " " + user.getLastName())
        );

        // 序列化
        UserResponse newResponse = new UserResponse();
        Map<String, User> newUsers = new HashMap<>();
        newUsers.put("newRandomX", new User("Charlie", "Brown"));
        newResponse.setUsers(newUsers);

        String serializedWrappedJson = objectMapper.writeValueAsString(newResponse);
        System.out.println("\n序列化后的JSON：");
        System.out.println(serializedWrappedJson);
    }
}

登录后复制

总结与注意事项

理解JSON结构是关键： 在选择反序列化策略之前，务必清晰地了解你所处理的JSON数据的确切结构。
- 如果整个JSON的顶级键都是动态的，且其值是结构化对象，请使用解决方案一（直接映射到Map）。
- 如果JSON包含一个固定的顶级键，该键的值是一个动态键的Map，请使用解决方案二（使用包装POJO）。
TypeReference的用途： TypeReference是Jackson处理泛型类型（如List<T>、Map<K, V>）时获取完整类型信息的强大工具，尤其在编译时无法确定具体泛型参数时非常有用。
Lombok简化POJO： 示例中使用了Lombok注解（@Data, @SuperBuilder, @NoArgsConstructor）来简化POJO的编写，减少了样板代码。在实际项目中，可以根据需要选择使用。
@JsonInclude(JsonInclude.Include.NON_NULL)： 这个Jackson注解在序列化时会忽略值为null的属性，使得生成的JSON更加简洁。
异常处理： 在实际应用中，objectMapper.readValue()和objectMapper.writeValueAsString()方法可能会抛出JsonProcessingException（或其子类IOException），因此需要进行适当的异常捕获和处理。

依赖管理： 确保项目中已正确引入Jackson库的依赖，例如jackson-databind和jackson-annotations。

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.4</version> <!-- 或更高版本 -->
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.13.4</version> <!-- 或更高版本 -->
</dependency>
<!-- 如果使用Lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.24</version> <!-- 或更高版本 -->
    <scope>provided</scope>
</dependency>

登录后复制

通过掌握这些技巧，开发者可以灵活应对各种复杂的JSON数据结构，高效地进行序列化和反序列化操作。

以上就是Jackson处理带有动态属性键的JSON数据：序列化与反序列化教程的详细内容，更多请关注php中文网其它相关文章！