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