发布于 由admin

Spring Boot JSON反序列化字段丢失的坑点与ObjectMapper配置技巧

Spring Boot JSON反序列化字段丢失的坑点与ObjectMapper配置技巧

大家好！今天我们来聊聊Spring Boot应用中JSON反序列化时字段丢失的问题，以及如何通过 ObjectMapper 进行配置来避免这些坑。这是一个常见但容易被忽略的问题，尤其是在处理复杂的数据结构或者与外部系统集成时。希望通过今天的讲解，大家能够更深入地理解JSON反序列化的原理，并掌握一些实用的技巧。

1. 问题的根源：Jackson 默认行为

Spring Boot 默认使用 Jackson 作为 JSON 序列化和反序列化的工具。Jackson 提供了强大的功能，但其默认行为也可能导致一些意想不到的问题，比如字段丢失。

1.1 缺少对应的 setter/getter 方法

这是最常见的原因。Jackson 默认情况下依赖于 JavaBean 规范，即类中的每个字段都需要有对应的 getter 和 setter 方法才能被正确地序列化和反序列化。 如果一个字段只有 getter 而没有 setter，那么在反序列化时，Jackson 无法将 JSON 中的值设置到该字段上，导致字段丢失。

示例：

public class User {
    private String name;
    private int age;
    private String address; // 假设没有 setter 方法

    public User(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    // 没有 setAddress 方法
}

如果我们将以下 JSON 反序列化为 User 对象，address 字段将会丢失：

{
  "name": "Alice",
  "age": 30,
  "address": "123 Main St"
}

解决办法： 为 address 字段添加 setAddress 方法。

1.2 字段名不匹配

JSON 字段名与 Java 类的字段名不匹配也会导致反序列化失败。Jackson 默认情况下使用字段的名称进行匹配。

示例：

public class Product {
    private String productName;
    private double price;

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

如果 JSON 数据如下：

{
  "product_name": "Laptop",
  "price": 1200.00
}

productName 字段将无法被正确反序列化，因为 JSON 中的字段名是 product_name。

解决办法： 使用 @JsonProperty 注解来指定 JSON 字段名与 Java 字段名的映射关系。

public class Product {
    @JsonProperty("product_name")
    private String productName;
    private double price;

    // ...
}

1.3 忽略未知字段

默认情况下，如果 JSON 中包含 Java 类中没有对应的字段，Jackson 会抛出异常。 但是，如果设置了 DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES 为 false，Jackson 将会忽略这些未知字段，这可能导致我们没有意识到 JSON 数据中存在问题。

示例：

{
  "name": "Bob",
  "age": 25,
  "extraField": "This will be ignored"
}

如果 User 类中没有 extraField 字段，且 DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES 设置为 false，则 extraField 字段会被忽略，而不会抛出异常。

1.4 访问权限问题

如果字段的访问权限设置为 private 且没有对应的 getter 和 setter 方法，Jackson 无法访问该字段。虽然可以通过反射来解决这个问题，但通常不建议这样做，因为它会降低性能并增加代码的复杂性。 最好是提供 getter 和 setter 方法。

1.5 数据类型不匹配

如果 JSON 中的数据类型与 Java 类中的字段类型不匹配，Jackson 会尝试进行类型转换。如果转换失败，则会导致反序列化失败，或者字段丢失。

示例：

public class Item {
    private int quantity;

    public int getQuantity() {
        return quantity;
    }

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }
}

如果 JSON 数据如下：

{
  "quantity": "abc"
}

由于 "abc" 无法转换为整数，quantity 字段的反序列化将会失败。

2. ObjectMapper 配置技巧

ObjectMapper 是 Jackson 的核心类，用于执行序列化和反序列化操作。 通过配置 ObjectMapper，我们可以控制 Jackson 的行为，解决字段丢失问题。

2.1 创建和配置 ObjectMapper

在 Spring Boot 应用中，通常不需要手动创建 ObjectMapper，Spring Boot 会自动配置一个默认的 ObjectMapper 实例。 但是，我们可以通过自定义 ObjectMapper 来覆盖默认配置。

方法一：使用 application.properties 或 application.yml

spring:
  jackson:
    property-naming-strategy: SNAKE_CASE
    deserialization:
      fail-on-unknown-properties: false
    serialization:
      indent-output: true
  • property-naming-strategy: 设置属性命名策略，例如将驼峰命名转换为蛇形命名。
  • deserialization.fail-on-unknown-properties: 设置是否在遇到未知属性时抛出异常。
  • serialization.indent-output: 设置是否格式化输出 JSON。

方法二：创建 @Configuration 类并注入 ObjectMapper

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.PropertyNamingStrategies;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class JacksonConfig {

    @Bean
    public ObjectMapper objectMapper() {
        ObjectMapper objectMapper = new ObjectMapper();

        // 设置属性命名策略
        objectMapper.setPropertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE);

        // 设置在遇到未知属性时不要抛出异常
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        // 设置格式化输出 JSON
        objectMapper.enable(com.fasterxml.jackson.databind.SerializationFeature.INDENT_OUTPUT);

        return objectMapper;
    }
}

2.2 常用配置选项

以下是一些常用的 ObjectMapper 配置选项：

配置项 作用
FAIL_ON_UNKNOWN_PROPERTIES DeserializationFeature 枚举中的一个值。如果设置为 true (默认值)，则在反序列化时遇到未知属性会抛出异常。如果设置为 false，则忽略未知属性。
ACCEPT_SINGLE_VALUE_AS_ARRAY DeserializationFeature 枚举中的一个值。如果设置为 true，则可以将单个值反序列化为数组。例如，将 "name": "Alice" 反序列化为 List<String> name = ["Alice"]。
READ_ENUMS_USING_TO_STRING DeserializationFeature 枚举中的一个值。如果设置为 true，则使用 toString() 方法来反序列化枚举类型。
WRITE_DATES_AS_TIMESTAMPS SerializationFeature 枚举中的一个值。如果设置为 true (默认值)，则将日期类型序列化为时间戳。如果设置为 false，则将日期类型序列化为 ISO-8601 格式的字符串。
WRITE_ENUMS_USING_TO_STRING SerializationFeature 枚举中的一个值。如果设置为 true，则使用 toString() 方法来序列化枚举类型。
INDENT_OUTPUT SerializationFeature 枚举中的一个值。如果设置为 true，则格式化输出 JSON。
PropertyNamingStrategy 一个抽象类，用于定义属性命名策略。Jackson 提供了几个内置的实现，例如 SNAKE_CASE (将驼峰命名转换为蛇形命名), LOWER_CAMEL_CASE (默认值，使用驼峰命名), UPPER_CAMEL_CASE (将首字母大写) 等。也可以自定义实现该类来满足特定的命名需求。
SerializationInclusion.NON_NULL JsonInclude 注解的一个属性，用于指定在序列化时忽略值为 null 的字段。还有其他选项，例如 NON_EMPTY (忽略值为 null 或空字符串的字段), NON_DEFAULT (忽略值为默认值的字段) 等。
DateFormat 一个抽象类，用于定义日期格式。可以使用 SimpleDateFormat 类来创建一个自定义的日期格式。

2.3 使用注解

除了配置 ObjectMapper 之外，还可以使用 Jackson 提供的注解来控制序列化和反序列化的行为。

  • @JsonProperty: 用于指定 JSON 字段名与 Java 字段名的映射关系。
  • @JsonIgnore: 用于忽略某个字段，使其不参与序列化和反序列化。
  • @JsonInclude: 用于指定在序列化时忽略哪些字段。
  • @JsonFormat: 用于指定日期和时间的格式。
  • @JsonDeserialize: 用于自定义反序列化器。
  • @JsonSerialize: 用于自定义序列化器。

示例：

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.Date;

public class Event {
    @JsonProperty("event_name")
    private String eventName;

    @JsonIgnore
    private String internalData;

    @JsonInclude(JsonInclude.Include.NON_NULL)
    private String description;

    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date eventDate;

    // ... getters and setters
}

3. 解决特定场景下的字段丢失问题

3.1 处理继承关系

在使用继承关系时，可能会遇到字段丢失的问题。 Jackson 默认情况下只会序列化和反序列化当前类的字段，而不会处理父类的字段。

解决办法： 使用 @JsonTypeInfo 和 @JsonSubTypes 注解来指定类的类型信息。

示例：

import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;

@JsonTypeInfo(
    use = JsonTypeInfo.Id.NAME,
    include = JsonTypeInfo.As.PROPERTY,
    property = "type"
)
@JsonSubTypes({
    @JsonSubTypes.Type(value = Dog.class, name = "dog"),
    @JsonSubTypes.Type(value = Cat.class, name = "cat")
})
public abstract class Animal {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Dog extends Animal {
    private String breed;

    public String getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }
}

class Cat extends Animal {
    private int lives;

    public int getLives() {
        return lives;
    }

    public void setLives(int lives) {
        this.lives = lives;
    }
}

在这种情况下，@JsonTypeInfo 注解指定了类型信息将包含在 type 属性中，而 @JsonSubTypes 注解指定了 Dog 和 Cat 是 Animal 的子类型。

3.2 处理多态

多态是指一个接口或类可以有多种实现。 在处理多态时，也可能会遇到字段丢失的问题。

解决办法： 与处理继承关系类似，可以使用 @JsonTypeInfo 和 @JsonSubTypes 注解来指定类的类型信息。

3.3 处理泛型

在处理泛型时，需要特别小心。 Jackson 无法直接获取泛型的类型信息，因此需要使用 TypeReference 类来指定泛型的类型。

示例：

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;

public class GenericExample {

    public static void main(String[] args) throws Exception {
        String json = "[{"name":"Alice", "age":30}, {"name":"Bob", "age":25}]";

        ObjectMapper objectMapper = new ObjectMapper();

        // 使用 TypeReference 来指定泛型的类型
        List<User> users = objectMapper.readValue(json, new TypeReference<List<User>>() {});

        System.out.println(users);
    }
}

4. 一个完整的示例

假设我们有一个订单系统，需要处理以下 JSON 数据：

{
  "order_id": "12345",
  "customer_name": "John Doe",
  "order_date": "2023-10-27",
  "items": [
    {
      "product_id": "A123",
      "product_name": "Laptop",
      "quantity": 1,
      "price": 1200.00
    },
    {
      "product_id": "B456",
      "product_name": "Mouse",
      "quantity": 2,
      "price": 25.00
    }
  ],
  "shipping_address": {
    "street": "123 Main St",
    "city": "Anytown",
    "state": "CA",
    "zip_code": "91234"
  }
}

我们可以定义以下 Java 类来表示订单数据：

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.Date;
import java.util.List;

public class Order {
    @JsonProperty("order_id")
    private String orderId;

    @JsonProperty("customer_name")
    private String customerName;

    @JsonFormat(pattern = "yyyy-MM-dd")
    private Date orderDate;

    private List<OrderItem> items;
    @JsonProperty("shipping_address")
    private Address shippingAddress;

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public String getCustomerName() {
        return customerName;
    }

    public void setCustomerName(String customerName) {
        this.customerName = customerName;
    }

    public Date getOrderDate() {
        return orderDate;
    }

    public void setOrderDate(Date orderDate) {
        this.orderDate = orderDate;
    }

    public List<OrderItem> getItems() {
        return items;
    }

    public void setItems(List<OrderItem> items) {
        this.items = items;
    }

    public Address getShippingAddress() {
        return shippingAddress;
    }

    public void setShippingAddress(Address shippingAddress) {
        this.shippingAddress = shippingAddress;
    }
}

class OrderItem {
    @JsonProperty("product_id")
    private String productId;

    @JsonProperty("product_name")
    private String productName;

    private int quantity;
    private double price;

    public String getProductId() {
        return productId;
    }

    public void setProductId(String productId) {
        this.productId = productId;
    }

    public String getProductName() {
        return productName;
    }

    public void setProductName(String productName) {
        this.productName = productName;
    }

    public int getQuantity() {
        return quantity;
    }

    public void setQuantity(int quantity) {
        this.quantity = quantity;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

class Address {
    private String street;
    private String city;
    private String state;

    @JsonProperty("zip_code")
    private String zipCode;

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getZipCode() {
        return zipCode;
    }

    public void setZipCode(String zipCode) {
        this.zipCode = zipCode;
    }
}

在这个示例中，我们使用了 @JsonProperty 注解来指定 JSON 字段名与 Java 字段名的映射关系，并使用了 @JsonFormat 注解来指定日期格式。

5. 调试技巧

如果在反序列化时遇到字段丢失问题，可以使用以下调试技巧：

  • 启用 debug 日志： 启用 Jackson 的 debug 日志，可以查看 Jackson 的详细日志信息，帮助我们了解反序列化的过程。
  • 使用断点调试： 在反序列化代码中设置断点，可以逐步调试代码，查看每个字段的值。
  • 打印 JSON 数据： 在反序列化之前，打印 JSON 数据，确保 JSON 数据的格式正确。
  • 使用在线 JSON 校验工具： 使用在线 JSON 校验工具，可以检查 JSON 数据是否符合 JSON 规范。

掌握JSON反序列化的正确姿势，才能写出更健壮的代码。

6.总结：配置ObjectMapper 和使用注解是关键

本文深入探讨了Spring Boot中JSON反序列化字段丢失的常见原因，如缺少getter/setter、字段名不匹配等，并提供了详细的 ObjectMapper 配置技巧和使用注解的方法来解决这些问题。 掌握这些技巧，能帮助开发者避免常见错误，提高开发效率，编写更健壮的应用程序。

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注