全面掌握 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 setterspublic 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;}@Overridepublic 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;@JsonIgnoreprivate int age;@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd-MM-yyyy")private Date birthDate;// getters and setterspublic 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;}@Overridepublic 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 setterspublic 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 setterspublic 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;}@Overridepublic 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;// Constructorspublic Group() {}public Group(String groupName, List<User> users) {this.groupName = groupName;this.users = users;}// Getters and Setterspublic 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;}@Overridepublic 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。