全面掌握 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。
