Jackson是一個用于處理JSON數據的Java庫，它提供了強大的功能來將Java對象序列化為JSON字符串，以及將JSON字符串反序列化為Java對象。Jackson庫的核心功能包括數據綁定、樹模型處理、流式API等。本文將詳細介紹Jackson的基礎核心用法，幫助開發者快速上手并掌握其基本功能。
Jackson是一個開源的Java庫，由FasterXML公司開發和維護。它主要用于處理JSON數據，支持將Java對象序列化為JSON字符串，以及將JSON字符串反序列化為Java對象。Jackson庫具有高性能、靈活性和易用性，廣泛應用于各種Java項目中。
Jackson庫的核心模塊包括：
在使用Jackson之前，首先需要在項目中添加Jackson庫的依賴。如果使用Maven進行項目管理，可以在pom.xml文件中添加以下依賴：
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.13.3</version>
</dependency>
jackson-databind模塊已經包含了jackson-core和jackson-annotations模塊，因此只需要添加這一個依賴即可。
Jackson的核心功能之一是數據綁定，即將Java對象與JSON數據相互轉換。下面通過一個簡單的例子來演示如何使用Jackson進行數據綁定。
首先，定義一個簡單的Java類Person：
public class Person {
private String name;
private int age;
// 無參構造函數
public Person() {}
// 全參構造函數
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// Getter和Setter方法
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 "Person{name='" + name + "', age=" + age + "}";
}
}
將Java對象序列化為JSON字符串的過程稱為序列化。使用Jackson進行序列化非常簡單，只需創建一個ObjectMapper對象，并調用其writeValueAsString方法即可。
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonExample {
public static void main(String[] args) throws Exception {
// 創建一個Person對象
Person person = new Person("Alice", 30);
// 創建ObjectMapper對象
ObjectMapper objectMapper = new ObjectMapper();
// 將Person對象序列化為JSON字符串
String jsonString = objectMapper.writeValueAsString(person);
// 輸出JSON字符串
System.out.println(jsonString);
}
}
運行上述代碼，輸出結果為：
{"name":"Alice","age":30}
將JSON字符串反序列化為Java對象的過程稱為反序列化。使用Jackson進行反序列化同樣非常簡單，只需調用ObjectMapper對象的readValue方法即可。
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonExample {
public static void main(String[] args) throws Exception {
// JSON字符串
String jsonString = "{\"name\":\"Alice\",\"age\":30}";
// 創建ObjectMapper對象
ObjectMapper objectMapper = new ObjectMapper();
// 將JSON字符串反序列化為Person對象
Person person = objectMapper.readValue(jsonString, Person.class);
// 輸出Person對象
System.out.println(person);
}
}
運行上述代碼，輸出結果為：
Person{name='Alice', age=30}
在實際開發中，我們經常需要處理包含嵌套對象或集合的復雜對象。Jackson同樣可以輕松處理這些情況。
定義一個包含嵌套對象和集合的復雜Java類Company：
import java.util.List;
public class Company {
private String name;
private List<Person> employees;
// 無參構造函數
public Company() {}
// 全參構造函數
public Company(String name, List<Person> employees) {
this.name = name;
this.employees = employees;
}
// Getter和Setter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<Person> getEmployees() {
return employees;
}
public void setEmployees(List<Person> employees) {
this.employees = employees;
}
@Override
public String toString() {
return "Company{name='" + name + "', employees=" + employees + "}";
}
}
將包含嵌套對象和集合的復雜對象序列化為JSON字符串：
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Arrays;
import java.util.List;
public class JacksonExample {
public static void main(String[] args) throws Exception {
// 創建Person對象
Person person1 = new Person("Alice", 30);
Person person2 = new Person("Bob", 25);
// 創建Company對象
Company company = new Company("Tech Corp", Arrays.asList(person1, person2));
// 創建ObjectMapper對象
ObjectMapper objectMapper = new ObjectMapper();
// 將Company對象序列化為JSON字符串
String jsonString = objectMapper.writeValueAsString(company);
// 輸出JSON字符串
System.out.println(jsonString);
}
}
運行上述代碼，輸出結果為：
{"name":"Tech Corp","employees":[{"name":"Alice","age":30},{"name":"Bob","age":25}]}
將包含嵌套對象和集合的JSON字符串反序列化為復雜對象：
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonExample {
public static void main(String[] args) throws Exception {
// JSON字符串
String jsonString = "{\"name\":\"Tech Corp\",\"employees\":[{\"name\":\"Alice\",\"age\":30},{\"name\":\"Bob\",\"age\":25}]}";
// 創建ObjectMapper對象
ObjectMapper objectMapper = new ObjectMapper();
// 將JSON字符串反序列化為Company對象
Company company = objectMapper.readValue(jsonString, Company.class);
// 輸出Company對象
System.out.println(company);
}
}
運行上述代碼，輸出結果為：
Company{name='Tech Corp', employees=[Person{name='Alice', age=30}, Person{name='Bob', age=25}]}
在實際開發中，日期和時間的處理是一個常見的需求。Jackson提供了多種方式來處理日期和時間。
默認情況下，Jackson會將java.util.Date對象序列化為時間戳（毫秒數）。例如：
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Date;
public class JacksonExample {
public static void main(String[] args) throws Exception {
// 創建一個包含日期的對象
Event event = new Event("Meeting", new Date());
// 創建ObjectMapper對象
ObjectMapper objectMapper = new ObjectMapper();
// 將Event對象序列化為JSON字符串
String jsonString = objectMapper.writeValueAsString(event);
// 輸出JSON字符串
System.out.println(jsonString);
}
}
class Event {
private String name;
private Date eventDate;
// 無參構造函數
public Event() {}
// 全參構造函數
public Event(String name, Date eventDate) {
this.name = name;
this.eventDate = eventDate;
}
// Getter和Setter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getEventDate() {
return eventDate;
}
public void setEventDate(Date eventDate) {
this.eventDate = eventDate;
}
@Override
public String toString() {
return "Event{name='" + name + "', eventDate=" + eventDate + "}";
}
}
運行上述代碼，輸出結果為：
{"name":"Meeting","eventDate":1672502400000}
如果希望使用自定義的日期格式，可以通過@JsonFormat注解來實現。例如：
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Date;
public class JacksonExample {
public static void main(String[] args) throws Exception {
// 創建一個包含日期的對象
Event event = new Event("Meeting", new Date());
// 創建ObjectMapper對象
ObjectMapper objectMapper = new ObjectMapper();
// 將Event對象序列化為JSON字符串
String jsonString = objectMapper.writeValueAsString(event);
// 輸出JSON字符串
System.out.println(jsonString);
}
}
class Event {
private String name;
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
private Date eventDate;
// 無參構造函數
public Event() {}
// 全參構造函數
public Event(String name, Date eventDate) {
this.name = name;
this.eventDate = eventDate;
}
// Getter和Setter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getEventDate() {
return eventDate;
}
public void setEventDate(Date eventDate) {
this.eventDate = eventDate;
}
@Override
public String toString() {
return "Event{name='" + name + "', eventDate=" + eventDate + "}";
}
}
運行上述代碼，輸出結果為：
{"name":"Meeting","eventDate":"2023-01-01 00:00:00"}
Jackson可以輕松處理枚舉類型。默認情況下，Jackson會將枚舉類型序列化為其名稱。例如：
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonExample {
public static void main(String[] args) throws Exception {
// 創建一個包含枚舉類型的對象
Order order = new Order(1, Status.PENDING);
// 創建ObjectMapper對象
ObjectMapper objectMapper = new ObjectMapper();
// 將Order對象序列化為JSON字符串
String jsonString = objectMapper.writeValueAsString(order);
// 輸出JSON字符串
System.out.println(jsonString);
}
}
class Order {
private int id;
private Status status;
// 無參構造函數
public Order() {}
// 全參構造函數
public Order(int id, Status status) {
this.id = id;
this.status = status;
}
// Getter和Setter方法
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public Status getStatus() {
return status;
}
public void setStatus(Status status) {
this.status = status;
}
@Override
public String toString() {
return "Order{id=" + id + ", status=" + status + "}";
}
}
enum Status {
PENDING, PROCESSING, COMPLETED
}
運行上述代碼，輸出結果為：
{"id":1,"status":"PENDING"}
在實際開發中，我們經常需要處理空值和默認值。Jackson提供了多種方式來處理這些情況。
默認情況下，Jackson會序列化所有字段，包括空值。如果希望忽略空值，可以通過@JsonInclude注解來實現。例如：
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonExample {
public static void main(String[] args) throws Exception {
// 創建一個包含空值的對象
Person person = new Person(null, 30);
// 創建ObjectMapper對象
ObjectMapper objectMapper = new ObjectMapper();
// 將Person對象序列化為JSON字符串
String jsonString = objectMapper.writeValueAsString(person);
// 輸出JSON字符串
System.out.println(jsonString);
}
}
@JsonInclude(JsonInclude.Include.NON_NULL)
class Person {
private String name;
private int age;
// 無參構造函數
public Person() {}
// 全參構造函數
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// Getter和Setter方法
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 "Person{name='" + name + "', age=" + age + "}";
}
}
運行上述代碼，輸出結果為：
{"age":30}
如果希望在反序列化時為某些字段設置默認值，可以通過@JsonSetter注解來實現。例如：
import com.fasterxml.jackson.annotation.JsonSetter;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonExample {
public static void main(String[] args) throws Exception {
// JSON字符串
String jsonString = "{\"age\":30}";
// 創建ObjectMapper對象
ObjectMapper objectMapper = new ObjectMapper();
// 將JSON字符串反序列化為Person對象
Person person = objectMapper.readValue(jsonString, Person.class);
// 輸出Person對象
System.out.println(person);
}
}
class Person {
private String name;
private int age;
// 無參構造函數
public Person() {}
// 全參構造函數
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// Getter和Setter方法
public String getName() {
return name;
}
@JsonSetter("name")
public void setName(String name) {
this.name = name == null ? "Unknown" : name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{name='" + name + "', age=" + age + "}";
}
}
運行上述代碼，輸出結果為：
Person{name='Unknown', age=30}
在實際開發中，我們經常需要處理多態類型。Jackson提供了多種方式來處理多態類型。
@JsonTypeInfo注解通過@JsonTypeInfo注解，可以在序列化和反序列化時處理多態類型。例如：
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.databind.ObjectMapper;
public class JacksonExample {
public static void main(String[] args) throws Exception {
// 創建一個Animal對象
Animal animal = new Dog("Buddy", 3);
// 創建ObjectMapper對象
ObjectMapper objectMapper = new ObjectMapper();
// 將Animal對象序列化為JSON字符串
String jsonString = objectMapper.writeValueAsString(animal);
// 輸出JSON字符串
System.out.println(jsonString);
// 將JSON字符串反序列化為Animal對象
Animal deserializedAnimal = objectMapper.readValue(jsonString, Animal.class);
// 輸出反序列化后的Animal對象
System.out.println(deserializedAnimal);
}
}
@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")
})
abstract class Animal {
private String name;
// 無參構造函數
public Animal() {}
// 全參構造函數
public Animal(String name) {
this.name = name;
}
// Getter和Setter方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Animal{name='" + name + "'}";
}
}
class Dog extends Animal {
private int age;
// 無參構造函數
public Dog() {}
// 全參構造函數
public Dog(String name, int age) {
super(name);
this.age = age;
}
// Getter和Setter方法
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Dog{name='" + getName() + "', age=" + age + "}";
}
}
class Cat extends Animal {
private String color;
// 無參構造函數
public Cat() {}
// 全參構造函數
public Cat(String name, String color) {
super(name);
this.color = color;
}
// Getter和Setter方法
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Cat{name='" + getName() + "', color='" + color + "'}";
}
}
運行上述代碼，輸出結果為：
”`json {“type”:“dog”,“name”:“Bud
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
