全面掌握 Jackson 序列化工具：原理、使用与高级配置详解

全面掌握 Jackson 序列化工具：原理、使用与高级配置详解

Jackson 是一个功能强大的 JSON 处理库，广泛应用于 Java 项目中。它提供了丰富的功能和灵活的配置选项，可以轻松地在 Java 对象和 JSON 数据之间进行转换。本文将详细介绍 Jackson 的核心概念、基本用法、高级配置及处理集合类型的数据，旨在帮助你全面掌握 Jackson 的使用方法。

一、Jackson 的核心概念

1. ObjectMapper

ObjectMapper 是 Jackson 的核心类，负责将 Java 对象转换为 JSON 以及将 JSON 转换为 Java 对象。它提供了许多方法来处理这些操作，例如 writeValue、readValue 等。

2. JsonParser 和 JsonGenerator

• JsonParser：低级别的 JSON 解析器，用于逐步解析 JSON 内容。
• JsonGenerator：低级别的 JSON 生成器，用于逐步生成 JSON 内容。

3. Annotations

Jackson 提供了许多注解来定制序列化和反序列化过程，包括但不限于：

• @JsonProperty：指定字段的 JSON 名称。
• @JsonIgnore：忽略字段。
• @JsonFormat：格式化日期和时间。
• @JsonInclude：指定包含的条件。

二、添加依赖

在你的项目中添加 Jackson 依赖。以 Maven 为例：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.12.3</version>
</dependency>

对于 Gradle 项目：

implementation 'com.fasterxml.jackson.core:jackson-databind:2.12.3'

三、基本用法

1. 序列化和反序列化

以下示例展示了如何使用 ObjectMapper 序列化和反序列化 Java 对象：

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    public static void main(String[] args) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();

            // 创建一个对象
            User user = new User();
            user.setName("John");
            user.setAge(30);

            // 序列化：Java 对象 -> JSON 字符串
            String jsonString = objectMapper.writeValueAsString(user);
            System.out.println("JSON String: " + jsonString);

            // 反序列化：JSON 字符串 -> Java 对象
            User deserializedUser = objectMapper.readValue(jsonString, User.class);
            System.out.println("Deserialized User: " + deserializedUser);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class User {
    private String name;
    private int age;

    // getters and setters
    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;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + '}';
    }
}

2. 使用注解定制序列化和反序列化

Jackson 提供了许多注解来定制序列化和反序列化过程。例如：

• @JsonProperty：用于指定 JSON 字段名。
• @JsonIgnore：用于忽略某个字段。
• @JsonFormat：用于指定日期格式。

import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonFormat;

import java.util.Date;

class User {
    @JsonProperty("full_name")
    private String name;

    @JsonIgnore
    private int age;

    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy")
    private Date birthDate;

    // getters and setters
    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 Date getBirthDate() {
        return birthDate;
    }

    public void setBirthDate(Date birthDate) {
        this.birthDate = birthDate;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + "', birthDate=" + birthDate + '}';
    }
}

使用上述类，生成的 JSON 将如下所示：

{
  "full_name": "John",
  "birthDate": "25-12-1990"
}

3. 高级配置

可以通过配置 ObjectMapper 来自定义其行为。例如：

ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(SerializationFeature.INDENT_OUTPUT, true); // 格式化输出
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); // 忽略未知属性

这些配置允许你格式化输出 JSON 和忽略未知属性。

四、处理复杂对象

Jackson 还可以处理复杂对象和集合类型。

1. 处理嵌套对象

class Address {
    private String street;
    private String city;

    // getters and setters
    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;
    }
}

class User {
    private String name;
    private int age;
    private Address address;

    // getters and setters
    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 Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{name='" + name + "', age=" + age + ", address=" + address + '}';
    }
}

2. 处理集合类型

以下示例展示了如何处理包含复杂对象的集合类型（List、Map 等）。

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.ArrayList;
import java.util.List;

public class JacksonCollectionExample {
    public static void main(String[] args) {
        try {
            ObjectMapper objectMapper = new ObjectMapper();

            // 创建用户列表
            List<User> userList = new ArrayList<>();
            userList.add(new User("John Doe", 30));
            userList.add(new User("Jane Doe", 25));

            // 序列化用户列表：Java 对象 -> JSON 字符串
            String userListJson = objectMapper.writeValueAsString(userList);
            System.out.println("User List JSON:\n" + userListJson);

            // 反序列化用户列表：JSON 字符串 -> Java 对象
            List<User> deserializedUserList = objectMapper.readValue(userListJson, new TypeReference<List<User>>(){});
            System.out.println("Deserialized User List:\n" + deserializedUserList);

            // 创建组对象
            Group group = new Group("Admins", userList);

            // 序列化组对象：Java 对象 -> JSON 字符串
            String groupJson = objectMapper.writeValueAsString(group);
            System.out.println("Group JSON:\n" + groupJson);

            // 反序列化组对象：JSON 字符串 -> Java 对象
            Group deserializedGroup = objectMapper.readValue(groupJson, Group.class);
            System.out.println("Deserialized Group:\n" + deserializedGroup);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Group {
    private String groupName;
    private List<User> users;

    // Constructors
    public Group() {}

    public Group(String groupName, List<User> users) {
        this.groupName = groupName;
        this.users = users;
    }

    // Getters and Setters
    public String getGroupName() {
        return groupName;
    }

    public void setGroupName(String groupName) {
        this.groupName = groupName;
    }

    public List<User> getUsers() {
        return users;
    }

    public void setUsers(List<User> users) {
        this.users = users;
    }

    @Override
    public String toString() {
        return "Group{groupName='" + groupName + "', users=" + users + '}';
    }
}

代码解析

1. 创建用户列表

List<User> userList = new ArrayList<>();
userList.add(new User("John Doe", 30));
userList.add(new User("Jane Doe", 25));

创建一个包含两个 User 对象的 ArrayList。

2. 序列化用户列表

String userListJson = objectMapper.writeValueAsString(userList);
System.out.println("User List JSON:\n" + userListJson);

使用 ObjectMapper 将用户列表序列化为 JSON 字符串。

3. 反序列化用户列表

List<User> deserializedUserList = objectMapper.readValue(userListJson, new TypeReference<List<User>>(){});
System.out.println("Deserialized User List:\n" + deserializedUserList);

使用 ObjectMapper 将 JSON 字符串反序列化为 List。注意 TypeReference 用于处理泛型类型。

4. 创建组对象

Group group = new Group("Admins", userList);

创建一个 Group 对象，其中包含一个组名和用户列表。

5. 序列化组对象

String groupJson = objectMapper.writeValueAsString(group);
System.out.println("Group JSON:\n" + groupJson);

使用 ObjectMapper 将组对象序列化为 JSON 字符串。

6. 反序列化组对象

Group deserializedGroup = objectMapper.readValue(groupJson, Group.class);
System.out.println("Deserialized Group:\n" + deserializedGroup);

使用 ObjectMapper 将 JSON 字符串反序列化为 Group 对象。

五、总结

通过上述内容，我们详细介绍了 Jackson 的基本概念、用法、高级配置以及处理复杂对象和集合类型的示例。掌握这些技术，可以在实际项目中高效地使用 Jackson 处理 JSON 数据。

Jackson 是一个强大且灵活的工具，能够满足各种 JSON 处理需求。希望本教程能够帮助你更好地理解和使用 Jackson。