Jackson - 快速指南

概述

Jackson 是一個基於 Java 的簡單庫，用於將 Java 物件序列化為 JSON，反之亦然。

特性

• 易於使用。 - Jackson API 提供了一個高階外觀來簡化常用的用例。

• 無需建立對映。 - Jackson API 為大多數要序列化的物件提供了預設對映。

• 效能。 - Jackson 非常快，記憶體佔用少，適用於大型物件圖或系統。

• 乾淨的 JSON。 - Jackson 建立乾淨簡潔的 JSON 結果，易於閱讀。

• 無依賴性。 - Jackson 庫除了 JDK 外不需要任何其他庫。

• 開源 - Jackson 庫是開源的，可以免費使用。

三種處理 JSON 的方法

Jackson 提供三種替代方法來處理 JSON

• 流式 API - 將 JSON 內容讀取和寫入為離散事件。JsonParser 讀取資料，而 JsonGenerator 寫入資料。它是三種方法中最強大的方法，開銷最低，讀寫操作最快。它類似於 XML 的 Stax 解析器。

• 樹模型 - 準備 JSON 文件的記憶體樹表示。ObjectMapper 構建 JsonNode 節點的樹。這是最靈活的方法。它類似於 XML 的 DOM 解析器。

• 資料繫結 - 使用屬性訪問器或註解將 JSON 轉換為 POJO（普通舊 Java 物件），反之亦然。它有兩種型別。

  • 簡單資料繫結 - 將 JSON 轉換為 Java Maps、Lists、Strings、Numbers、Booleans 和 null 物件，反之亦然。

  • 完整資料繫結 - 將 JSON 轉換為任何 JAVA 型別，反之亦然。

  ObjectMapper 讀取/寫入這兩種型別的資料繫結的 JSON。資料繫結是最方便的方法，類似於 XML 的 JAXB 解析器。

環境設定

線上嘗試選項

您真的不需要設定自己的環境來開始學習 Guava，一個基於 JAVA 的庫。原因很簡單，我們已經線上設定了 Java 程式設計環境，以便您可以在進行理論工作的同時，線上編譯和執行所有可用的示例。這使您對正在閱讀的內容充滿信心，並可以使用不同的選項檢查結果。隨意修改任何示例並在線上執行。

使用以下示例，在下面示例程式碼框的右上角使用嘗試選項。

public class MyFirstJavaProgram {

    public static void main(String []args) {
       System.out.println("Hello World");
    }
} 

對於本教程中給出的大多數示例，您都會找到嘗試選項，因此只需使用它並享受您的學習。

本地環境設定

如果您仍然希望為 Java 程式語言設定環境，則本節將指導您如何在機器上下載和設定 Java。請按照以下步驟設定環境。

Java SE 可從以下連結免費獲得 下載 Java。因此，您可以根據您的作業系統下載一個版本。

按照說明下載 java 並執行.exe 在您的機器上安裝 Java。在您的機器上安裝 Java 後，您需要設定環境變數以指向正確的安裝目錄

為 Windows 2000/XP 設定路徑

假設您已將 Java 安裝在c:\Program Files\java\jdk目錄中

• 右鍵單擊“我的電腦”，然後選擇“屬性”。

• 在“高階”選項卡下單擊“環境變數”按鈕。

• 現在，更改“Path”變數，使其還包含 Java 可執行檔案的路徑。例如，如果路徑當前設定為“C:\WINDOWS\SYSTEM32”，則將您的路徑更改為“C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin”。

為 Windows 95/98/ME 設定路徑

假設您已將 Java 安裝在c:\Program Files\java\jdk目錄中

• 編輯“C:\autoexec.bat”檔案，並在末尾新增以下行
  “SET PATH=%PATH%;C:\Program Files\java\jdk\bin”

為 Linux、UNIX、Solaris、FreeBSD 設定路徑

環境變數 PATH 應設定為指向已安裝 Java 二進位制檔案的目錄。如果您在執行此操作時遇到問題，請參閱您的 shell 文件。

例如，如果您使用bash作為您的 shell，那麼您將在“.bashrc”的末尾新增以下行：export PATH=/path/to/java:$PATH'

流行的 Java 編輯器

要編寫 Java 程式，您需要一個文字編輯器。市場上甚至還有更復雜的 IDE 可用。但就目前而言，您可以考慮以下之一

• 記事本：在 Windows 機器上，您可以使用任何簡單的文字編輯器，如記事本（推薦用於本教程）、TextPad。

• Netbeans：是一個開源且免費的 Java IDE，可以從http://www.netbeans.org/index.html下載。

• Eclipse：也是一個由 Eclipse 開源社群開發的 Java IDE，可以從http://www.eclipse.org/下載。

下載 Jackson 歸檔檔案

從Maven 儲存庫 - Jackson下載最新版本的 Jackson jar 檔案。在本教程中，jackson-core-2.8.9.jar、jackson-annotations-2.8.9.jar 和 jackson-databind-2.8.9.jar 已下載並複製到 C:\> jackson 資料夾中。

設定 Jackson 環境

設定jackson_HOME環境變數以指向 Guava jar 儲存在您機器上的基本目錄位置。假設，我們已將 jackson-core-2.8.9.jar、jackson-annotations-2.8.9.jar 和 jackson-databind-2.8.9.jar 解壓到各個作業系統的 jackson 資料夾中，如下所示。

設定 CLASSPATH 變數

設定CLASSPATH環境變數以指向 jackson jar 的位置。假設，我們已將 jackson-core-2.8.9.jar、jackson-annotations-2.8.9.jar 和 jackson-databind-2.8.9.jar 儲存在各個作業系統的 jackson 資料夾中，如下所示。

第一個應用

在深入瞭解 jackson 庫的細節之前，讓我們看看一個實際應用。在此示例中，我們建立了 Student 類。我們將使用學生詳細資訊建立一個 JSON 字串，並將其反序列化為學生物件，然後將其序列化為 JSON 字串。

在C:\>Jackson_WORKSPACE中建立一個名為 JacksonTester 的 Java 類檔案。

檔案：JacksonTester.java

import java.io.IOException;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
   
      ObjectMapper mapper = new ObjectMapper();
      String jsonString = "{\"name\":\"Mahesh\", \"age\":21}";
      
      //map json to student
      try{
         Student student = mapper.readValue(jsonString, Student.class);
         
         System.out.println(student);
         
         jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(student);
         
         System.out.println(jsonString);
      }
      catch (JsonParseException e) { e.printStackTrace();}
      catch (JsonMappingException e) { e.printStackTrace(); }
      catch (IOException e) { e.printStackTrace(); }
   }
}

class Student {
   private String name;
   private int age;
   public Student(){}
   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 toString(){
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }
}

驗證結果

使用javac編譯器編譯類，如下所示

C:\Jackson_WORKSPACE>javac JacksonTester.java

現在執行 jacksonTester 以檢視結果

C:\Jackson_WORKSPACE>java JacksonTester

驗證輸出

Student [ name: Mahesh, age: 21 ]
{
  "name" : "Mahesh",
  "age" : 21
}

需要記住的步驟

以下是此處需要考慮的重要步驟。

步驟 1：建立 ObjectMapper 物件。

建立 ObjectMapper 物件。它是一個可重用的物件。

ObjectMapper mapper = new ObjectMapper();

步驟 2：將 JSON 反序列化為物件。

使用 readValue() 方法從 JSON 獲取物件。將 json 字串/json 字串的源和物件型別作為引數傳遞。

//Object to JSON Conversion
Student student = mapper.readValue(jsonString, Student.class);

步驟 3：將物件序列化為 JSON。

使用 writeValueAsString() 方法獲取物件的 JSON 字串表示形式。

//Object to JSON Conversion		
jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(student);

ObjectMapper 類

ObjectMapper 是 Jackson 庫的主要參與者類。ObjectMapper 類 ObjectMapper 提供了讀取和寫入 JSON 的功能，可以從基本 POJO（普通舊 Java 物件）或從通用 JSON 樹模型 (JsonNode) 讀取和寫入，以及執行轉換的相關功能。它也高度可定製，可以與不同風格的 JSON 內容一起使用，並支援更高階的物件概念，例如多型性和物件標識。ObjectMapper 還可以充當更高階的 ObjectReader 和 ObjectWriter 類的工廠。

類宣告

以下是com.fasterxml.jackson.databind.ObjectMapper類的宣告：

public class ObjectMapper
   extends ObjectCodec
      implements Versioned, Serializable

巢狀類

欄位

• protected DeserializationConfig _deserializationConfig - 定義序列化過程基本全域性設定的配置物件。

• protected DefaultDeserializationContext _deserializationContext - 藍圖上下文物件；儲存在此處以允許自定義子類。

• protected InjectableValues _injectableValues - 反序列化 POJO 中要注入的值的提供程式。

• protected JsonFactory _jsonFactory - 用於根據需要建立 JsonParser 和 JsonGenerator 例項的工廠。

• protected SimpleMixInResolver _mixIns - 定義如何應用 mix-in 註解的對映：鍵是要接收附加註解的型別，值是要“混合”的註解的型別。

• protected ConfigOverrides _propertyOverrides - 當前活動的每型別配置覆蓋，透過屬性的宣告型別訪問。

• protected Set<Object> _registeredModuleTypes - 已註冊的模組型別集（根據 Module.getTypeId()）；僅在 MapperFeature.IGNORE_DUPLICATE_MODULE_REGISTRATIONS 啟用時跟蹤，以便可以忽略重複的註冊呼叫（以避免多次新增相同的處理程式，主要是）。

• protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>> _rootDeserializers - 我們將使用單獨的主級 Map 來跟蹤根級反序列化器。

• protected SerializationConfig _serializationConfig - 定義序列化過程基本全域性設定的配置物件。

• protected SerializerFactory _serializerFactory - 用於構造序列化器的序列化器工廠。

• protected DefaultSerializerProvider _serializerProvider - 管理對用於序列化的序列化器訪問的物件，包括快取。

• protected SubtypeResolver _subtypeResolver - 用於註冊子型別、根據需要將它們解析為超型別/子型別的事物。

• protected TypeFactory _typeFactory - 用於建立 JavaType 例項的特定工廠；需要允許模組新增更多自定義型別處理（主要用於支援非 Java JVM 語言的型別）。

• protected static AnnotationIntrospector DEFAULT_ANNOTATION_INTROSPECTOR

• protected static BaseSettings DEFAULT_BASE - 基本設定包含所有 ObjectMapper 例項使用的預設值。

• protected static VisibilityChecker<?> STD_VISIBILITY_CHECKER

建構函式

方法

繼承的方法

此類繼承自以下類的方法

• java.lang.Object

ObjectMapper 示例

使用您選擇的任何編輯器建立以下 Java 程式，例如在 C:/> Jackson_WORKSPACE 中。

檔案：JacksonTester.java

import java.io.IOException;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
   
      ObjectMapper mapper = new ObjectMapper();
      String jsonString = "{\"name\":\"Mahesh\", \"age\":21}";
      
      //map json to student
      try{
         Student student = mapper.readValue(jsonString, Student.class);
         
         System.out.println(student);
         
         jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(student);
         
         System.out.println(jsonString);
      }
      catch (JsonParseException e) { e.printStackTrace();}
      catch (JsonMappingException e) { e.printStackTrace(); }
      catch (IOException e) { e.printStackTrace(); }
   }
}

class Student {
   private String name;
   private int age;
   public Student(){}
   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 toString(){
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }
}

驗證結果

使用javac編譯器編譯類，如下所示

C:\Jackson_WORKSPACE>javac JacksonTester.java

現在執行 jacksonTester 以檢視結果

C:\Jackson_WORKSPACE>java JacksonTester

驗證輸出

Student [ name: Mahesh, age: 21 ]
{
  "name" : "Mahesh",
  "age" : 21
}

物件序列化

讓我們將一個 Java 物件序列化到一個 json 檔案中，然後讀取該 json 檔案以獲取該物件。在此示例中，我們建立了 Student 類。我們將建立一個 student.json 檔案，其中將包含 Student 物件的 json 表示形式。

在C:\>Jackson_WORKSPACE中建立一個名為 JacksonTester 的 Java 類檔案。

檔案：JacksonTester.java

import java.io.File;
import java.io.IOException;

import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
      try {
         Student student = new Student();
         student.setAge(10);
         student.setName("Mahesh");
         tester.writeJSON(student);

         Student student1 = tester.readJSON();
         System.out.println(student1);

      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }

   private void writeJSON(Student student) throws JsonGenerationException, JsonMappingException, IOException{
      ObjectMapper mapper = new ObjectMapper();	
      mapper.writeValue(new File("student.json"), student);
   }

   private Student readJSON() throws JsonParseException, JsonMappingException, IOException{
      ObjectMapper mapper = new ObjectMapper();
      Student student = mapper.readValue(new File("student.json"), Student.class);
      return student;
   }
}

class Student {
   private String name;
   private int age;
   public Student(){}
   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 toString(){
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }	
}

驗證結果

使用javac編譯器編譯類，如下所示

C:\Jackson_WORKSPACE>javac JacksonTester.java

現在執行 jacksonTester 以檢視結果

C:\Jackson_WORKSPACE>java JacksonTester

驗證輸出

Student [ name: Mahesh, age: 10 ]

資料繫結

資料繫結 API 用於使用屬性訪問器或使用註解將 JSON 轉換為 POJO（普通舊 Java 物件）以及從 POJO 轉換 JSON。它分為兩種型別。

• 簡單資料繫結 - 將 JSON 轉換為 Java Maps、Lists、Strings、Numbers、Booleans 和 null 物件，反之亦然。

• 完整資料繫結 - 將 JSON 轉換為任何 JAVA 型別，反之亦然。

ObjectMapper 讀取/寫入這兩種型別的資料繫結的 JSON。資料繫結是最方便的方法，類似於 XML 的 JAXB 解析器。

簡單資料繫結

簡單資料繫結是指將 JSON 對映到 JAVA 核心資料型別。下表說明了 JSON 型別與 Java 型別之間的關係。

讓我們看看簡單資料繫結的實際應用。在這裡，我們將 JAVA 基本型別直接對映到 JSON，反之亦然。

在C:\>Jackson_WORKSPACE中建立一個名為 JacksonTester 的 Java 類檔案。

檔案：JacksonTester.java

import java.io.File;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
         try {
            ObjectMapper mapper = new ObjectMapper();

            Map<String,Object> studentDataMap = new HashMap<String,Object>(); 
            int[] marks = {1,2,3};

            Student student = new Student();
            student.setAge(10);
            student.setName("Mahesh");
            // JAVA Object
            studentDataMap.put("student", student);
            // JAVA String
            studentDataMap.put("name", "Mahesh Kumar");   		
            // JAVA Boolean
            studentDataMap.put("verified", Boolean.FALSE);
            // Array
            studentDataMap.put("marks", marks);

            mapper.writeValue(new File("student.json"), studentDataMap);
            //result student.json
			//{ 
            //   "student":{"name":"Mahesh","age":10},
            //   "marks":[1,2,3],
            //   "verified":false,
            //   "name":"Mahesh Kumar"
            //}
            studentDataMap = mapper.readValue(new File("student.json"), Map.class);

            System.out.println(studentDataMap.get("student"));
            System.out.println(studentDataMap.get("name"));
            System.out.println(studentDataMap.get("verified"));
            System.out.println(studentDataMap.get("marks"));
      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
            e.printStackTrace();
      }
   }
}

class Student {
   private String name;
   private int age;
   public Student(){}
   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 toString(){
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }	
}

驗證結果

使用javac編譯器編譯類，如下所示

C:\Jackson_WORKSPACE>javac JacksonTester.java

現在執行 jacksonTester 以檢視結果

C:\Jackson_WORKSPACE>java JacksonTester

驗證輸出

{name=Mahesh, age=10}
Mahesh Kumar
false
[1, 2, 3]

完整資料繫結

完整資料繫結是指將 JSON 對映到任何 JAVA 物件。

//Create an ObjectMapper instance
ObjectMapper mapper = new ObjectMapper();	
//map JSON content to Student object
Student student = mapper.readValue(new File("student.json"), Student.class);
//map Student object to JSON content
mapper.writeValue(new File("student.json"), student);

讓我們看看簡單資料繫結的實際應用。在這裡，我們將 JAVA 物件直接對映到 JSON，反之亦然。

在C:\>Jackson_WORKSPACE中建立一個名為 JacksonTester 的 Java 類檔案。

檔案：JacksonTester.java

import java.io.File;
import java.io.IOException;

import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
      try {
         Student student = new Student();
         student.setAge(10);
         student.setName("Mahesh");
         tester.writeJSON(student);

         Student student1 = tester.readJSON();
         System.out.println(student1);

      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }

   private void writeJSON(Student student) throws JsonGenerationException, JsonMappingException, IOException{
      ObjectMapper mapper = new ObjectMapper();	
      mapper.writeValue(new File("student.json"), student);
   }

   private Student readJSON() throws JsonParseException, JsonMappingException, IOException{
      ObjectMapper mapper = new ObjectMapper();
      Student student = mapper.readValue(new File("student.json"), Student.class);
      return student;
   }
}

class Student {
   private String name;
   private int age;
   public Student(){}
   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 toString(){
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }	
}

驗證結果

使用javac編譯器編譯類，如下所示

C:\Jackson_WORKSPACE>javac JacksonTester.java

現在執行 jacksonTester 以檢視結果

C:\Jackson_WORKSPACE>java JacksonTester

驗證輸出

Student [ name: Mahesh, age: 10 ]

使用泛型的資料繫結

在簡單資料繫結中，我們使用了 Map 類，該類使用 String 作為鍵，使用 Object 作為值物件。相反，我們可以擁有具體的 Java 物件並將其型別轉換以用於 JSON 繫結。

考慮以下使用 UserData 類的示例，UserData 類用於儲存使用者特定資料。

在C:\>Jackson_WORKSPACE中建立一個名為 JacksonTester 的 Java 類檔案。

檔案：JacksonTester.java

import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

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

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
         try {
            ObjectMapper mapper = new ObjectMapper();

            Map<String, UserData> userDataMap = new HashMap<String, UserData>();
            UserData studentData = new UserData(); 
            int[] marks = {1,2,3};

            Student student = new Student();
            student.setAge(10);
            student.setName("Mahesh");
            // JAVA Object
            studentData.setStudent(student);
            // JAVA String
            studentData.setName("Mahesh Kumar");
            // JAVA Boolean
            studentData.setVerified(Boolean.FALSE);
            // Array
            studentData.setMarks(marks);
            TypeReference ref = new TypeReference<Map<String,UserData>>() { };
            userDataMap.put("studentData1", studentData);
            mapper.writeValue(new File("student.json"), userDataMap);
            //{
            //   "studentData1":
            //	 {
            //		"student":
            //		{
            //			"name":"Mahesh",
            //			"age":10
            //      },
            //      "name":"Mahesh Kumar",
            //      "verified":false,
            //      "marks":[1,2,3]
            //   }
            //}
            userDataMap = mapper.readValue(new File("student.json"), ref);

            System.out.println(userDataMap.get("studentData1").getStudent());
            System.out.println(userDataMap.get("studentData1").getName());
            System.out.println(userDataMap.get("studentData1").getVerified());
            System.out.println(Arrays.toString(userDataMap.get("studentData1").getMarks()));
      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
            e.printStackTrace();
      }
   }
}

class Student {
   private String name;
   private int age;
   public Student(){}
   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 toString(){
      return "Student [ name: "+name+", age: "+ age+ " ]";
   }	
}

class UserData {
   private Student student;
   private String name;
   private Boolean verified;
   private int[] marks;

   public UserData(){}

   public Student getStudent() {
      return student;
   }
   public void setStudent(Student student) {
      this.student = student;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
   public Boolean getVerified() {
      return verified;
   }
   public void setVerified(Boolean verified) {
      this.verified = verified;
   }
   public int[] getMarks() {
      return marks;
   }
   public void setMarks(int[] marks) {
      this.marks = marks;
   }		
}

驗證結果

使用javac編譯器編譯類，如下所示

C:\Jackson_WORKSPACE>javac JacksonTester.java

現在執行 jacksonTester 以檢視結果

C:\Jackson_WORKSPACE>java JacksonTester

驗證輸出

Student [ name: Mahesh, age: 10 ]
Mahesh Kumar
false
[1, 2, 3]

樹模型

樹模型準備 JSON 文件的記憶體中樹表示。ObjectMapper 構建 JsonNode 節點的樹。這是最靈活的方法。它類似於 XML 的 DOM 解析器。

從 JSON 建立樹

ObjectMapper 在讀取 JSON 後提供指向樹的根節點的指標。根節點可用於遍歷整棵樹。請考慮以下程式碼片段以獲取提供的 JSON 字串的根節點。

//Create an ObjectMapper instance
ObjectMapper mapper = new ObjectMapper();	
String jsonString = "{\"name\":\"Mahesh Kumar\", \"age\":21,\"verified\":false,\"marks\": [100,90,85]}";
//create tree from JSON
JsonNode rootNode = mapper.readTree(jsonString);

遍歷樹模型

在遍歷樹時，使用相對於根節點的相對路徑獲取每個節點並處理資料。請考慮以下程式碼片段，該片段在提供根節點的情況下遍歷樹。

JsonNode nameNode = rootNode.path("name");
System.out.println("Name: "+ nameNode.textValue());
 
JsonNode marksNode = rootNode.path("marks");
Iterator<JsonNode> iterator = marksNode.elements();

示例

在C:\>Jackson_WORKSPACE中建立一個名為 JacksonTester 的 Java 類檔案。

檔案：JacksonTester.java

import java.io.IOException;
import java.util.Iterator;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){

      try {
         ObjectMapper mapper = new ObjectMapper();
         String jsonString = "{\"name\":\"Mahesh Kumar\",  \"age\":21,\"verified\":false,\"marks\": [100,90,85]}";
         JsonNode rootNode = mapper.readTree(jsonString);

         JsonNode nameNode = rootNode.path("name");
         System.out.println("Name: "+ nameNode.textValue());

         JsonNode ageNode = rootNode.path("age");
         System.out.println("Age: " + ageNode.intValue());

         JsonNode verifiedNode = rootNode.path("verified");
         System.out.println("Verified: " + (verifiedNode.booleanValue() ? "Yes":"No"));

         JsonNode marksNode = rootNode.path("marks");
         Iterator<JsonNode> iterator = marksNode.elements();
         System.out.print("Marks: [ ");

         while (iterator.hasNext()) {
            JsonNode marks = iterator.next();
            System.out.print(marks.intValue() + " "); 
         }

         System.out.println("]");
      }
      catch (JsonParseException e) { e.printStackTrace(); }
      catch (JsonMappingException e) { e.printStackTrace(); }
      catch (IOException e) { e.printStackTrace(); }
   }
}

驗證結果

使用javac編譯器編譯類，如下所示

C:\Jackson_WORKSPACE>javac JacksonTester.java

現在執行 jacksonTester 以檢視結果

C:\Jackson_WORKSPACE>java JacksonTester

驗證輸出

Name: Mahesh Kumar
Age: 21
Verified: No
Marks: [ 100 90 85 ]

樹到 JSON

在此示例中，我們使用 JsonNode 建立了一棵樹，並將其寫入 json 檔案並讀回。

在C:\>Jackson_WORKSPACE中建立一個名為 JacksonTester 的 Java 類檔案。

檔案：JacksonTester.java

import java.io.IOException;
import java.util.Iterator;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){

      try {
         ObjectMapper mapper = new ObjectMapper();
         String jsonString = "{\"name\":\"Mahesh Kumar\",  \"age\":21,\"verified\":false,\"marks\": [100,90,85]}";
         JsonNode rootNode = mapper.readTree(jsonString);

         JsonNode nameNode = rootNode.path("name");
         System.out.println("Name: "+ nameNode.textValue());

         JsonNode ageNode = rootNode.path("age");
         System.out.println("Age: " + ageNode.intValue());

         JsonNode verifiedNode = rootNode.path("verified");
         System.out.println("Verified: " + (verifiedNode.booleanValue() ? "Yes":"No"));

         JsonNode marksNode = rootNode.path("marks");
         Iterator<JsonNode> iterator = marksNode.elements();
         System.out.print("Marks: [ ");

         while (iterator.hasNext()) {
            JsonNode marks = iterator.next();
            System.out.print(marks.intValue() + " "); 
         }

         System.out.println("]");
      }
      catch (JsonParseException e) { e.printStackTrace(); }
      catch (JsonMappingException e) { e.printStackTrace(); }
      catch (IOException e) { e.printStackTrace(); }
   }
}

驗證結果

使用javac編譯器編譯類，如下所示

C:\Jackson_WORKSPACE>javac JacksonTester.java

現在執行 jacksonTester 以檢視結果

C:\Jackson_WORKSPACE>java JacksonTester

驗證輸出

Name: Mahesh Kumar
Age: 21
Verified: No
Marks: [ 100 90 85 ]

樹到 Java 物件

在此示例中，我們使用 JsonNode 建立了一棵樹，並將其寫入 json 檔案並讀回樹，然後將其轉換為 Student 物件。

在C:\>Jackson_WORKSPACE中建立一個名為 JacksonTester 的 Java 類檔案。

檔案：JacksonTester.java

import java.io.File;
import java.io.IOException;
import java.util.Iterator;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
      try {
         ObjectMapper mapper = new ObjectMapper();

         JsonNode rootNode = mapper.createObjectNode();
         JsonNode marksNode = mapper.createArrayNode();
         ((ArrayNode)marksNode).add(100);
         ((ArrayNode)marksNode).add(90);
         ((ArrayNode)marksNode).add(85);
         ((ObjectNode) rootNode).put("name", "Mahesh Kumar");
         ((ObjectNode) rootNode).put("age", 21);
         ((ObjectNode) rootNode).put("verified", false);
         ((ObjectNode) rootNode).put("marks",marksNode);

         mapper.writeValue(new File("student.json"), rootNode);

         rootNode = mapper.readTree(new File("student.json"));

         Student student = mapper.treeToValue(rootNode, Student.class);

         System.out.println("Name: "+ student.getName());
         System.out.println("Age: " + student.getAge());
         System.out.println("Verified: " + (student.isVerified() ? "Yes":"No"));
         System.out.println("Marks: "+Arrays.toString(student.getMarks()));
      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}
class Student {
   String name;
   int age;
   boolean verified;
   int[] marks;
   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 boolean isVerified() {
      return verified;
   }
   public void setVerified(boolean verified) {
      this.verified = verified;
   }
   public int[] getMarks() {
      return marks;
   }
   public void setMarks(int[] marks) {
      this.marks = marks;
   }
}

驗證結果

使用javac編譯器編譯類，如下所示

C:\Jackson_WORKSPACE>javac JacksonTester.java

現在執行 jacksonTester 以檢視結果

C:\Jackson_WORKSPACE>java JacksonTester

驗證輸出

Name: Mahesh Kumar
Age: 21
Verified: No
Marks: [ 100 90 85 ]

流式 API

流式 API 將 JSON 內容讀寫為離散事件。JsonParser 讀取資料，而 JsonGenerator 寫入資料。這三種方法中最強大的一種，開銷最低，讀寫操作速度最快。它類似於 XML 的 Stax 解析器。

在本文中，我們將展示如何使用 Jackson 流式 API 讀取和寫入 JSON 資料。流式 API 使用標記的概念，並且必須仔細處理 Json 的每個細節。以下是我們將在示例中使用的兩個類

• JsonGenerator - 寫入 JSON 字串。

• JsonParser - 解析 JSON 字串。

使用 JsonGenerator 寫入 JSON

使用 JsonGenerator 非常簡單。首先使用 JsonFactory.createJsonGenerator() 方法建立 JsonGenerator，然後使用其 write***() 方法寫入每個 json 值。

JsonFactory jsonFactory = new JsonFactory();
JsonGenerator jsonGenerator = jsonFactory.createGenerator(new File(
   "student.json"), JsonEncoding.UTF8);
// {
jsonGenerator.writeStartObject();
// "name" : "Mahesh Kumar"
jsonGenerator.writeStringField("name", "Mahesh Kumar"); 

讓我們看看 JsonGenerator 的實際應用。在 C:\>Jackson_WORKSPACE 中建立一個名為 JacksonTester 的 Java 類檔案。

檔案：JacksonTester.java

import java.io.File;
import java.io.IOException;
import java.util.Map;

import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){

      try {         
         JsonFactory jsonFactory = new JsonFactory();
         JsonGenerator jsonGenerator = jsonFactory.createGenerator(new File("student.json"), JsonEncoding.UTF8);

         jsonGenerator.writeStartObject();

         // "name" : "Mahesh Kumar"
         jsonGenerator.writeStringField("name", "Mahesh Kumar"); 

         // "age" : 21
         jsonGenerator.writeNumberField("age", 21);

         // "verified" : false
         jsonGenerator.writeBooleanField("verified", false);

         // "marks" : [100, 90, 85]
         jsonGenerator.writeFieldName("marks"); 

         // [
         jsonGenerator.writeStartArray(); 
         // 100, 90, 85
         jsonGenerator.writeNumber(100); 
         jsonGenerator.writeNumber(90); 
         jsonGenerator.writeNumber(85); 
         // ]

         jsonGenerator.writeEndArray(); 

         jsonGenerator.writeEndObject(); 
         jsonGenerator.close();        

         //result student.json
         //{ 
         //   "name":"Mahesh Kumar",
         //   "age":21,
         //   "verified":false,
         //   "marks":[100,90,85]
         //}

         ObjectMapper mapper = new ObjectMapper();
         Map<String,Object> dataMap = mapper.readValue(new File("student.json"), Map.class);

         System.out.println(dataMap.get("name"));
         System.out.println(dataMap.get("age"));
         System.out.println(dataMap.get("verified"));
         System.out.println(dataMap.get("marks"));
      } 
      catch (JsonParseException e) { e.printStackTrace(); } 
      catch (JsonMappingException e) { e.printStackTrace(); } 
      catch (IOException e) { e.printStackTrace(); }
   }
}

驗證結果

使用javac編譯器編譯類，如下所示

C:\Jackson_WORKSPACE>javac JacksonTester.java

現在執行 jacksonTester 以檢視結果

C:\Jackson_WORKSPACE>java JacksonTester

驗證輸出

Mahesh Kumar
21
false
[100, 90, 85]

使用 JsonParser 讀取 JSON

使用 JsonParser 同樣非常簡單。首先使用 JsonFactory.createJsonParser() 方法建立 JsonParser，然後使用其 nextToken() 方法將每個 json 字串讀取為標記。檢查每個標記並相應地進行處理

JsonFactory jasonFactory = new JsonFactory();
JsonParser jsonParser = jasonFactory.createJsonParser(new File("student.json"));
while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
   //get the current token
   String fieldname = jsonParser.getCurrentName();
   if ("name".equals(fieldname)) {
      //move to next token
      jsonParser.nextToken();
      System.out.println(jsonParser.getText());        	 
   }
}

讓我們看看 JsonParser 的實際應用。在 C:\>Jackson_WORKSPACE 中建立一個名為 JacksonTester 的 Java 類檔案。

檔案：JacksonTester.java

import java.io.File;
import java.io.IOException;
import java.util.Map;

import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonTester {
   public static void main(String args[]){
      JacksonTester tester = new JacksonTester();
      try {        	
         JsonFactory jsonFactory = new JsonFactory();

         JsonGenerator jsonGenerator = jsonFactory.createGenerator(new File(
            "student.json"), JsonEncoding.UTF8);
         jsonGenerator.writeStartObject();
         jsonGenerator.writeStringField("name", "Mahesh Kumar"); 
         jsonGenerator.writeNumberField("age", 21);
         jsonGenerator.writeBooleanField("verified", false); 
         jsonGenerator.writeFieldName("marks"); 
         jsonGenerator.writeStartArray(); // [
         jsonGenerator.writeNumber(100); 
         jsonGenerator.writeNumber(90); 
         jsonGenerator.writeNumber(85); 
         jsonGenerator.writeEndArray(); 
         jsonGenerator.writeEndObject(); 
         jsonGenerator.close();       	 

         //result student.json
         //{ 
         //   "name":"Mahesh Kumar",
         //   "age":21,
         //   "verified":false,
         //   "marks":[100,90,85]
         //}

         JsonParser jsonParser = jsonFactory.createParser(new File("student.json"));
         while (jsonParser.nextToken() != JsonToken.END_OBJECT) {
            //get the current token
            String fieldname = jsonParser.getCurrentName();
            if ("name".equals(fieldname)) {
               //move to next token
               jsonParser.nextToken();
               System.out.println(jsonParser.getText());        	 
            }
            if("age".equals(fieldname)){
               //move to next token
               jsonParser.nextToken();
               System.out.println(jsonParser.getNumberValue());        	 
            }
            if("verified".equals(fieldname)){
               //move to next token
               jsonParser.nextToken();
               System.out.println(jsonParser.getBooleanValue());        	 
            }
            if("marks".equals(fieldname)){
               //move to [ 
               jsonParser.nextToken();
               // loop till token equal to "]"
               while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
                  System.out.println(jsonParser.getNumberValue()); 
               }
            }
         }
      } catch (JsonParseException e) {
         e.printStackTrace();
      } catch (JsonMappingException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

驗證結果

使用javac編譯器編譯類，如下所示

C:\Jackson_WORKSPACE>javac JacksonTester.java

現在執行 jacksonTester 以檢視結果

C:\Jackson_WORKSPACE>java JacksonTester

驗證輸出

Mahesh Kumar
21
false
[100, 90, 85]

JsonGenerator 類

簡介

JsonParser 是定義用於讀取 Json 內容的公共 API 的基類。例項是使用 JsonFactory 例項的工廠方法建立的。

類宣告

以下是 org.codehaus.jackson.JsonParser 類的宣告

public abstract class JsonParser
   extends Object
      implements Closeable, Versioned

巢狀類

欄位

• protected PrettyPrinter _cfgPrettyPrinter - 在輸出期間處理漂亮列印（通常是其他空格以使結果更易於人類閱讀）的物件。

• protected JsonToken _currToken - 透過 nextToken() 獲取的最後一個標記（如果有）。

• protected int _features - 由指示哪些 JsonParser.Features 已啟用的位組成的位標誌。

• protected JsonToken _lastClearedToken - 最後一個清除的標記（如果有）：即，呼叫 clearCurrentToken() 時有效的標記。

建構函式

類方法

繼承的方法

此類繼承自以下類的方法

• java.lang.Object

JsonParser 類

簡介

JsonParser 是定義用於讀取 Json 內容的公共 API 的基類。例項是使用 JsonFactory 例項的工廠方法建立的。

類宣告

以下是com.fasterxml.jackson.core.JsonParser類的宣告

public abstract class JsonParser
   extends Object
      implements Closeable, Versioned

巢狀類

欄位

• protected int _features - 由指示哪些 JsonParser.Features 已啟用的位組成的位標誌。

建構函式

類方法

繼承的方法

此類繼承自以下類的方法

• java.lang.Object