Jackson 简明教程

Jackson - Quick Guide

Overview

Jackson 是一个简单的基于 Java 的库，用于将 Java 对象序列化为 JSON，反之亦然。

Features

Easy to use. - Jackson API 提供了一个高级外观，以便简化常用的用例。
No need to create mapping. - Jackson API 为大多数要序列化的对象提供了默认的映射。
Performance. - Jackson 十分快速，并且占用较少的内存空间，非常适合大型对象图或系统。
Clean JSON. - Jackson 创建干净紧凑的 JSON 结果，非常容易读取。
No Dependency. - Jackson 库无需除 JDK 之外的任何其他库。
Open Source - Jackson 库是开源的，并且可以免费使用。

Three ways of processing JSON

Jackson 提供了三种处理 JSON 的替代方法。

Streaming API - 将 JSON 内容读写为离散事件。JsonParser 读取数据，而 JsonGenerator 写入数据。这是三种方法中最强大的，开销最低，读/写操作最快。它类似于 XML 的 Stax 解析器。
Tree Model - 准备 JSON 文档的内存中树表示形式。ObjectMapper 构建 JsonNode 节点的树。这是最灵活的方法。它类似于 XML 的 DOM 解析器。
Data Binding * - converts JSON to and from POJO (Plain Old Java Object) using property accessor or using annotations. It is of two type. *Simple Data Binding - 将 JSON 转换为 Java 地图、列表、字符串、数字、布尔值和空对象，反之亦然。 Full Data Binding - 将 JSON 转换为任何 JAVA 类型，反之亦然。ObjectMapper 针对两种类型的数据绑定读写 JSON。数据绑定是最便利的方法，类似于 XML 的 JAXB 分析器。

Environment Setup

Local Environment Setup

如果您仍希望为 Java 编程语言设置环境，那么本部分将指导您如何在机器上下载并设置 Java。请按照以下步骤设置环境。

Java SE 可以从链接 Download Java 中免费获得。所以你可以根据你的操作系统下载一个版本。

按照说明下载 Java 并运行 .exe 以在你的计算机上安装 Java。一旦在计算机上安装了 Java，就需要设置环境变量以指向正确的安装目录：

Setting up the path for windows 2000/XP:

假设你已将 Java 安装在 c:\Program Files\java\jdk 目录中：

右键单击“我的电脑”，然后选择“属性”。
单击“高级”选项卡下的“环境变量”按钮。
现在，更改“路径”变量，使其也包含指向 Java 可执行文件的路径。例如，如果路径目前设置为“C:\WINDOWS\SYSTEM32”，那么将您的路径更改为“C:\WINDOWS\SYSTEM32;c:\Program Files\java\jdk\bin”。

Setting up the path for windows 95/98/ME:

假设你已将 Java 安装在 c:\Program Files\java\jdk 目录中：

编辑 'C:\autoexec.bat' 文件并在末尾添加以下行：'SET PATH=%PATH%;C:\Program Files\java\jdk\bin'

Setting up the path for Linux, UNIX, Solaris, FreeBSD:

环境变量 PATH 应设置为指向已安装 Java 二进制文件的位置。如果你在这方面遇到问题，请参阅 shell 文档。

例如，如果您用 bash 作为您的 shell，则您将向您 '.bashrc: export PATH=/path/to/java:$PATH' 的末尾添加以下行

Popular Java Editors:

要编写 Java 程序，您需要一个文本编辑器。市面上还有更加复杂的 IDE 可供使用。但是就目前而言，您可以考虑以下几个选择：

Notepad: 在 Windows 系统机器上，您可以使用任何一款简单的文本编辑器，比如记事本（推荐用于本教程）、TextPad。
*NetBeans:*是一个开源且免费的 Java IDE，可以从 http://www.netbeans.org/index.html 下载。
Eclipse: 也是由 Eclipse 开源社区开发的 Java IDE，可以从 http://www.eclipse.org/ 下载。

Download jackson archive

从 Maven Repository - Jackson 下载最新版本的 Jackson jar 文件。在本教程中，jackson-core-2.8.9.jar、jackson-annotations-2.8.9.jar 和 jackson-databind-2.8.9.jar 已下载并复制到 C:\> jackson 文件夹中。

Archive name

Windows

jackson-xxx-2.8.9.jar

Linux

jackson-xxx-2.8.9.jar

Mac

jackson-xxx-2.8.9.jar

Set jackson environment

设置 jackson_HOME 环境变量以指向 Guava jar 存储在计算机中的基本目录位置。假设我们在各个操作系统上的 jackson 文件夹中已解压缩 jackson-core-2.8.9.jar、jackson-annotations-2.8.9.jar 和 jackson-databind-2.8.9.jar，如下所示。

Output

Windows

将环境变量 jackson_HOME 设置为 C:\jackson

Linux

export jackson_HOME=/usr/local/jackson

Mac

export jackson_HOME=/Library/jackson

Set CLASSPATH variable

设置 CLASSPATH 环境变量以指向 jackson jar 位置。假设我们在各个操作系统的 jackson 文件夹中已将 jackson-core-2.8.9.jar、jackson-annotations-2.8.9.jar 和 jackson-databind-2.8.9.jar 存储在 jackson 文件夹中，如下所示。

Output

Windows

将环境变量 CLASSPATH 设置为 %CLASSPATH%;%jackson_HOME%\jackson-core-2.8.9.jar;%jackson_HOME%\jackson-databind-2.8.9.jar;%jackson_HOME%\jackson-annotations-2.8.9.jar;.;

Linux

export CLASSPATH=$CLASSPATH:$jackson_HOME/jackson-core-2.8.9.jar:$jackson_HOME/jackson-databind-2.8.9.jar:$jackson_HOME/jackson-annotations-2.8.9.jar:.

Mac

export CLASSPATH=$CLASSPATH:$jackson_HOME/jackson-core-2.8.9.jar:$jackson_HOME/jackson-databind-2.8.9.jar:$jackson_HOME/jackson-annotations-2.8.9.jar:.

First Application

在开始了解 jackson 库的详细信息之前，让我们先在实际应用中看看它。在这个例子中，我们创建了 Student 类。我们将使用学生的详细信息创建一个 JSON 字符串，并将其反序列化为 student 对象，然后将其序列化为 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+ " ]";
   }
}

Verify the result

使用 javac 编译器编译类，如下所示：

C:\Jackson_WORKSPACE>javac JacksonTester.java

现在运行 jacksonTester 查看结果：

C:\Jackson_WORKSPACE>java JacksonTester

验证输出

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

Steps to remember

以下是需要考虑的重要步骤。

Step 1: Create ObjectMapper object.

创建 ObjectMapper 对象。这是一个可重用的对象。

ObjectMapper mapper = new ObjectMapper();

Step 2: DeSerialize JSON to Object.

使用 readValue() 方法从 JSON 中获取对象。将 json 字符串/json 字符串的源和对象类型作为参数传递。

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

Step 3: Serialize Object to JSON.

使用 writeValueAsString() 方法获取对象的 JSON 字符串表示形式。

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

ObjectMapper Class

ObjectMapper 是 Jackson 库的主体类。ObjectMapper 类 ObjectMapper 提供了从基本 POJO（普通旧 Java 对象）或从通用 JSON 树模型（JsonNode）中读取和写入 JSON 的功能，以及执行转换的相关功能。它还可以高度定制化，以便处理不同形式的 JSON 内容，并支持更高级的对象概念，例如多态和对象标识。ObjectMapper 还作为更高级的 ObjectReader 和 ObjectWriter 类的工厂。

Class Declaration

以下是 com.fasterxml.jackson.databind.ObjectMapper 类的声明 -

public class ObjectMapper
   extends ObjectCodec
      implements Versioned, Serializable

Nested Classes

S.No.

Class & Description

*static class ObjectMapper.DefaultTypeResolverBuilder*提供类型解析器生成器的定制类型解析器生成器，这些生成器与所谓的“默认类型化”一起使用（有关详细信息，请参阅 enableDefaultTyping()）。

*static class ObjectMapper.DefaultTyping*与 enableDefaultTyping() 一起使用，用于指定应将哪种类型的类型（类）用于默认类型化。

Fields

protected DeserializationConfig _deserializationConfig - 配置对象，用于定义序列化过程的基本全局设置。
protected DefaultDeserializationContext _deserializationContext - 蓝图上下文对象；存储在此处以允许自定义子类。
protected InjectableValues _injectableValues - 提供用于反序列化 POJO 中注入的值。
protected JsonFactory _jsonFactory - 根据需要用于创建 JsonParser 和 JsonGenerator 实例的工厂。
protected SimpleMixInResolver _mixIns - 映射定义如何应用混合注释：键是接收附加注释的类型，值是具有“混合”注释的类型。
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 *

Constructors

S.No.	Constructor & Description
1	ObjectMapper()默认构造函数，将根据需要构造默认 JsonFactory，使用 SerializerProvider 作为其 SerializerProvider，将 BeanSerializerFactory 作为其 SerializerFactory。
2	ObjectMapper(JsonFactory jf)构造使用指定的 JsonFactory 来构造必需的 JsonParsers 和/或 JsonGenerators 的实例。
3	ObjectMapper(JsonFactory jf, SerializerProvider sp, DeserializerProvider dp)构造使用指定的 JsonFactory 来构造必需的 JsonParsers 和/或 JsonGenerators，并使用给定的提供程序访问序列化器和反序列化器。
4	protected ObjectMapper(ObjectMapper src)拷贝构造函数，主要用于支持 copy()。

Methods

1	protected void _checkInvalidCopy(Class<?> exp)
2	protected void _configAndWriteValue(JsonGenerator g, Object value) - 调用该方法以根据需要配置生成器，然后调用编写功能
3	protected Object _convert(Object fromValue, JavaType toValueType) - 实际转换实现：代码大部分内联，而不是使用现有的读取和写入方法。
4	protected JsonDeserializer<Object> _findRootDeserializer(DeserializationContext ctxt, JavaType valueType) - 调用该方法来为已通过的根级别值找到反序列化器。
5	protected JsonToken _initForReading(JsonParser p) - 调用该方法来确保给定的解析器已准备好读取数据绑定的内容。
6	protected ObjectReader _newReader(DeserializationConfig config) - 工厂方法子类必须重写，以生成正确子类型的 ObjectReader 实例
7	protected ObjectReader _newReader(DeserializationConfig config, JavaType valueType, Object valueToUpdate, FormatSchema schema, InjectableValues injectableValues) - 工厂方法子类必须覆盖，以生成适当子类型的 ObjectReader 实例
8	protected ObjectWriter _newWriter(SerializationConfig config) - 工厂方法子类必须覆盖，以生成适当子类型的 ObjectWriter 实例
9	protected ObjectWriter _newWriter(SerializationConfig config, FormatSchema schema) - 工厂方法子类必须覆盖，以生成适当子类型的 ObjectWriter 实例
10	protected ObjectWriter _newWriter(SerializationConfig config, JavaType rootType, PrettyPrinter pp) - 工厂方法子类必须覆盖，以生成适当子类型的 ObjectWriter 实例。
11	protected Object _readMapAndClose(JsonParser p0, JavaType valueType)
12	protected Object _readValue(DeserializationConfig cfg, JsonParser p, JavaType valueType) - 值读取+绑定操作的实际实现。
13	protected DefaultSerializerProvider _serializerProvider(SerializationConfig config)
14	protected Object _unwrapAndDeserialize(JsonParser p, DeserializationContext ctxt, DeserializationConfig config, JavaType rootType, JsonDeserializer<Object> deser)
15	protected void _verifySchemaType(FormatSchema schema)
16	void acceptJsonFormatVisitor(Class<?> type, JsonFormatVisitorWrapper visitor) - 用于使用指定访问者访问给定类型层次结构的方式。
17	void acceptJsonFormatVisitor(JavaType type, JsonFormatVisitorWrapper visitor) - 用于使用指定访问者访问给定类型层次结构的方式。
18	ObjectMapper addHandler(DeserializationProblemHandler h) - 用于添加指定的 DeserializationProblemHandler 的方式，以便在反序列化期间用来处理特定问题。
19	ObjectMapper addMixIn(Class<?> target, Class<?> mixinSource) - 用于添加补全注释的方式，以便用来增强指定的类或接口。
20	boolean canDeserialize(JavaType type) - 可以调用的方式，用来检查映射器是否认为可以反序列化给定类型的一个对象。
21	boolean canDeserialize(JavaType type, AtomicReference<Throwable> cause) - 与 canDeserialize(JavaType) 相似的方式，但可能会返回试图构造序列化器时抛出的实际 Throwable：这可能有助于解决实际问题。
22	boolean canSerialize(Class<?> type) - 可以调用的方式，用来检查映射器是否认为可以序列化给定类的实例。
23	boolean canSerialize(Class<?> type, AtomicReference<Throwable> cause) - 与 canSerialize(Class) 相似的方式，但可能会返回试图构造序列化器时抛出的实际 Throwable：这可能有助于解决实际问题。
24	ObjectMapper clearProblemHandlers() - 从此映射器中移除所有已注册的 DeserializationProblemHandlers 实例的方式。
25	MutableConfigOverride configOverride(Classlt;?> type) - 针对给定类型获取可变配置覆盖对象，需要添加或更改适用于给定类型属性的按类型覆盖。
26	ObjectMapper configure(DeserializationFeature f, boolean state) - 更改此对象映射程序的开启/关闭反序列化功能的状态。
27	ObjectMapper configure(JsonGenerator.Feature f, boolean state) - 此对象映射器创建的生成器实例的开关特性 JsonGenerator 状态的方法。
28	ObjectMapper configure(JsonParser.Feature f, boolean state) - 此对象映射器创建的解析器实例的指定 JsonParser.Features 状态的方法。
29	ObjectMapper configure(MapperFeature f, boolean state) - 此映射器实例的开关映射器状态的方法。
30	ObjectMapper configure(SerializationFeature f, boolean state) - 此对象映射器的开关序列化状态的方法。
31	JavaType constructType(Type t) - 构造 JavaType 的便捷方法，从给定类型（通常为 java.lang.Class）中构造，但没有显式上下文。
32	<T> T convertValue(Object fromValue, Class<T> toValueType) - 如果（但仅当！）需要转换时，执行两步转换从给定值到指定值类型的实例的便捷方法。
33	<T> T convertValue(Object fromValue, JavaType toValueType) - 查看 convertValue(Object, Class)
34	<T> T convertValue(Object fromValue, TypeReference<?> toValueTypeRef) - 查看 convertValue(Object, Class)
35	ObjectMapper copy() - 创建具有与此实例相同初始配置的新 ObjectMapper 实例的方法。
36	ArrayNode createArrayNode() - 注意：返回类型是协变的，因为基本 ObjectCodec 抽象不能引用具体的节点类型（因为它是核心包的一部分，而实现是映射包的一部分）
37	ObjectNode createObjectNode() - 注意：返回类型是协变的，因为基本 ObjectCodec 抽象不能引用具体的节点类型（因为它是核心包的一部分，而实现是映射包的一部分）
38	protected ClassIntrospector defaultClassIntrospector() - 可覆盖的助手方法，用于构造要使用的默认 ClassIntrospector。
39	ObjectMapper disable(DeserializationFeature feature) - 启用指定 DeserializationConfig 特性方法。
40	ObjectMapper disable(DeserializationFeature first, DeserializationFeature… f) - 启用指定 DeserializationConfig 特性方法。
41	ObjectMapper disable(JsonGenerator.Feature… features) - 禁用特定 JsonGenerator.Features 的方法，用于此对象映射器创建的解析器实例。
42	ObjectMapper disable(JsonParser.Feature… features) - 禁用特定 JsonParser.Features 的方法，用于此对象映射器创建的解析器实例。
43	ObjectMapper disable(MapperFeature… f) - 启用指定 DeserializationConfig 特性方法。
44	ObjectMapper disable(SerializationFeature f) - 启用指定 DeserializationConfig 特性方法。
45	ObjectMapper disable(SerializationFeature first, SerializationFeature… f) - 启用指定 DeserializationConfig 特性方法。
46	ObjectMapper disableDefaultTyping() - 禁用自动包含类型信息的方法；如果启用，仅显式注释的类型（带有 JsonTypeInfo 的类型）将具有附加的嵌入式类型信息。
47	ObjectMapper enable(DeserializationFeature feature) - 启用指定 DeserializationConfig 特性的方法。
48	ObjectMapper enable(DeserializationFeature first, DeserializationFeature… f) - 启用指定 DeserializationConfig 特性的方法。
49	ObjectMapper enable(JsonGenerator.Feature… features) - 此对象映射器创建的分析器实例中启用指定 JsonGenerator.Features 的方法。
50	ObjectMapper enable(JsonParser.Feature… features) - 此对象映射器创建的分析器实例中启用指定 JsonParser.Features 的方法。
51	ObjectMapper enable(MapperFeature… f) - 启用指定 MapperConfig 特性的方法。
52	ObjectMapper enable(SerializationFeature f) - 启用指定 DeserializationConfig 特性的方法。
53	ObjectMapper enable(SerializationFeature first, SerializationFeature… f) - 启用指定 DeserializationConfig 特性的方法。
54	ObjectMapper enableDefaultTyping() - 等效于调用以下内容的便捷方法：
55	ObjectMapper enableDefaultTyping(ObjectMapper.DefaultTyping dti) - 等效于调用以下内容的便捷方法：
56	ObjectMapper enableDefaultTyping(ObjectMapper.DefaultTyping applicability, JsonTypeInfo.As includeAs) - 启用自动包含类型信息的方法，这是正确反序列化多态类型所必需的（除非类型已用 JsonTypeInfo 进行注释）。
57	ObjectMapper enableDefaultTypingAsProperty(ObjectMapper.DefaultTyping applicability, String propertyName) - 启用自动包含类型信息（这是正确反序列化多态类型所必需的）的方法——使用“As.PROPERTY”包含机制和指定的属性名称用于包含（默认值为“@class”因为默认类型信息始终使用类名作为类型标识符）
58	ObjectMapper findAndRegisterModules() - 在功能上等效于以下内容的便捷方法：mapper.registerModules(mapper.findModules());
59	Class<?> findMixInClassFor(Class<?> cls)
60	static List<Module> findModules() - 使用 JDK ServiceLoader 工具及模块提供的 SPI 定位可用方法的方法。
61	static List<Module> findModules(ClassLoader classLoader) - 使用 JDK ServiceLoader 工具及模块提供的 SPI 定位可用方法的方法。
62	DateFormat getDateFormat()
63	DeserializationConfig getDeserializationConfig() - 返回定义反序列化配置设置的共享默认 DeserializationConfig 对象的方法。
64	DeserializationContext getDeserializationContext() - 获取当前 DeserializationContext 的方法。
65	JsonFactory getFactory() - 如果此映射器需要构造 JsonParsers 和/或 JsonGenerators，则可用于获取此映射器使用的 JsonFactory 的方法。
66	InjectableValues getInjectableValues()
67	JsonFactory getJsonFactory() - 已弃用。自 2.1 起：改用 getFactory()
68	JsonNodeFactory getNodeFactory() - 可用于获取当对 Tree 直接构造根 JsonNode 实例时，此映射器将使用的 JsonNodeFactory 的方法。
69	PropertyNamingStrategy getPropertyNamingStrategy()
70	SerializationConfig getSerializationConfig() - 返回定义用于序列化的配置设置的共享默认 SerializationConfig 对象的方法。
71	SerializerFactory getSerializerFactory() - 获取当前 SerializerFactory 的方法。
72	SerializerProvider getSerializerProvider() - “蓝图”（或工厂）实例的访问器，可通过调用 DefaultSerializerProvider.createInstance(com.fasterxml.jackson.databind.SerializationConfig, com.fasterxml.jackson.databind.ser.SerializerFactory) 来从中创建实例。
73	SerializerProvider getSerializerProviderInstance() - 用于构造和返回可用于访问序列化器的 SerializerProvider 实例的访问器。
74	SubtypeResolver getSubtypeResolver() - 用于访问正在使用的子类型解析器的方法。
75	TypeFactory getTypeFactory() - 用于获取当前配置的 TypeFactory 实例的访问器。
76	VisibilityChecker<?> getVisibilityChecker() - 用于访问当前配置的可见性检查器的方法；用于确定是否可以自动检测给定的属性元素（方法、字段、构造函数）的对象。
77	boolean isEnabled(DeserializationFeature f) - 用于检查是否启用了给定与反序列化特定的功能的方法。
78	boolean isEnabled(JsonFactory.Feature f) - 等效于以下内容的便捷方法：
79	boolean isEnabled(JsonGenerator.Feature f)
80	boolean isEnabled(JsonParser.Feature f)
81	boolean isEnabled(MapperFeature f) - 用于检查是否启用了给定的 MapperFeature 的方法。
82	boolean isEnabled(SerializationFeature f) - 用于检查是否启用了给定与序列化特定的功能的方法。
83	int mixInCount()
84	ObjectReader reader() - 具有默认设置的 ObjectReader 的工厂方法。
85	ObjectReader reader(Base64Variant defaultBase64) - ObjectReader 的工厂方法，此方法将对 Base64 编码的二进制数据使用指定的 Base64 编码变体。
86	ObjectReader reader(Class<?> type) - 不推荐使用。从 2.5 版开始，改为使用 readerFor(Class)
87	ObjectReader reader(ContextAttributes attrs) - ObjectReader 的工厂方法，此方法将使用指定的默认属性。
88	ObjectReader reader(DeserializationFeature feature) - ObjectReader 的工厂方法，此方法启用了指定的功能（与该映射器实例的设置相比）。
89	ObjectReader reader(DeserializationFeature first, DeserializationFeature… other) - ObjectReader 的工厂方法，此方法启用了指定的功能（与该映射器实例的设置相比）。
90	ObjectReader reader(FormatSchema schema) - ObjectReader 的工厂方法，此方法将特定的模式对象传递给用于读取内容的 JsonParser。
91	ObjectReader reader(InjectableValues injectableValues) - 用于构造将使用指定的可注入值的 ObjectReader 的工厂方法。
92	ObjectReader reader(JavaType type) - 已弃用。从 2.5 开始，请使用 readerFor(JavaType) 代替
93	ObjectReader reader(JsonNodeFactory f) - 用于构造将使用指定的 JsonNodeFactory 构建 JSON 树的 ObjectReader 的工厂方法。
94	ObjectReader reader(TypeReference<?> type) - 已弃用。从 2.5 开始，请使用 readerFor(TypeReference) 代替
95	ObjectReader readerFor(Class<?> type) - 用于构造将读取或更新指定类型实例的 ObjectReader 的工厂方法
96	ObjectReader readerFor(JavaType type) - 用于构造将读取或更新指定类型实例的 ObjectReader 的工厂方法
97	ObjectReader readerFor(TypeReference<?> type) - 用于构造将读取或更新指定类型实例的 ObjectReader 的工厂方法
98	ObjectReader readerForUpdating(Object valueToUpdate) - 用于构造将使用 JSON 数据更新给定对象（通常是 Bean，但也可以是 Collection 或 Map，但不是数组）的 ObjectReader 的工厂方法。
99	ObjectReader readerWithView(Class<?> view) - 用于构造将使用指定的 JSON 视图（筛选器）反序列化对象的 ObjectReader 的工厂方法。
100	JsonNode readTree(byte[] content) - 用于使用一组 JsonNode 实例表示的反序列化 JSON 内容为树的方法。
101	JsonNode readTree(File file) - 用于使用一组 JsonNode 实例表示的反序列化 JSON 内容为树的方法。
102	JsonNode readTree(InputStream in) - 用于使用一组 JsonNode 实例表示的反序列化 JSON 内容为树的方法。
103	<T extends TreeNode> T readTree(JsonParser p) - 用于使用一组 JsonNode 实例表示的反序列化 JSON 内容为树的方法。
104	JsonNode readTree(Reader r) - 用于使用一组 JsonNode 实例表示的反序列化 JSON 内容为树的方法。
105	JsonNode readTree(String content) - 用于使用一组 JsonNode 实例表示的反序列化 JSON 内容为树的方法。
106	JsonNode readTree(URL source) - 用于使用一组 JsonNode 实例表示的反序列化 JSON 内容为树的方法。
107	<T> T readValue(byte[] src, Class<T> valueType)
108	<T> T readValue(byte[] src, int offset, int len, Class<T> valueType)
109	<T> T readValue(byte[] src, int offset, int len, JavaType valueType)
110	<T> T readValue(byte[] src, int offset, int len, TypeReference valueTypeRef)
111	<T> T readValue(byte[] src, JavaType valueType)
112	<T> T readValue(byte[] src, TypeReference valueTypeRef)
113	<T> T readValue(DataInput src, Class<T> valueType)
114	<T> T readValue(DataInput src, JavaType valueType)
115	<T> T readValue(File src, Class<T> valueType) - 从给定文件中反序列化 JSON 内容到给定 Java 类型的函数。
116	<T> T readValue(File src, JavaType valueType) - 从给定文件中反序列化 JSON 内容到给定 Java 类型的函数。
117	<T> T readValue(File src, TypeReference valueTypeRef) - 从给定文件中反序列化 JSON 内容到给定 Java 类型的函数。
118	<T> T readValue(InputStream src, Class<T> valueType)
119	<T> T readValue(InputStream src, JavaType valueType)
120	<T> T readValue(InputStream src, TypeReference valueTypeRef)
121	<T> T readValue(JsonParser p, Class<T> valueType) * - Method to deserialize JSON content into a non-container type (it can be an array type, however): typically a bean, array or a wrapper type (like Boolean). *
122	<T> T readValue(JsonParser p, JavaType valueType) - 类型安全的重载函数，本质上是 readValue(JsonParser, Class) 的别名。
123	<T> T readValue(JsonParser p, ResolvedType valueType) - 将 JSON 内容反序列化到 Java 类型的函数，类型引用作为参数传递。
124	<T> T readValue(JsonParser p, TypeReference<?> valueTypeRef) - 将 JSON 内容反序列化为 Java 类型，其引用作为参数传递。
125	<T> T readValue(Reader src, Class<T> valueType) -
1	<T> T readValue(Reader src, JavaType valueType)
126	<T> T readValue(Reader src, TypeReference valueTypeRef)
127	<T> T readValue(String content, Class<T> valueType) - 从给定的 JSON 内容字符串反序列化 JSON 内容的方法。
128	<T> T readValue(String content, JavaType valueType) - 从给定的 JSON 内容字符串反序列化 JSON 内容的方法。
129	<T> T readValue(String content, TypeReference valueTypeRef) - 从给定的 JSON 内容字符串反序列化 JSON 内容的方法。
130	<T> T readValue(URL src, Class<T> valueType) - 将 JSON 内容从给定的资源反序列化成给定的 Java 类型的方法。
131	<T> T readValue(URL src, JavaType valueType)
132	<T> T readValue(URL src, TypeReference valueTypeRef) - 将 JSON 内容从给定的资源反序列化成给定的 Java 类型的方法。
133	<T> MappingIterator<T> readValues(JsonParser p, Class<T> valueType) - 便捷方法，在其功能上等效于：
134	<T> MappingIterator<T> readValues(JsonParser p, JavaType valueType) - 便捷方法，在其功能上等效于：
135	<T> MappingIterator<T> readValues(JsonParser p, ResolvedType valueType) - 便捷方法，在其功能上等效于：
136	<T> MappingIterator<T> readValues(JsonParser p, TypeReference<?>valueTypeRef) - 从解析器流中读取对象序列的方法。
137	ObjectMapper registerModule(Module module) - 注册可以扩展此映射器提供的功能的模块的方法；比如，通过添加自定义序列化器和反序列化器的提供者。
138	ObjectMapper registerModules(Iterable<Module> modules) - 按顺序注册指定模块的便捷方法；在其功能上等效于：
139	ObjectMapper registerModules(Module… modules) - 按顺序注册指定模块的便捷方法；在其功能上等效于：
140	void registerSubtypes(NamedType… types) - 将指定类注册为子类型的方法，以便基于类型名称解析可以将父类型链接到子类型（作为使用注解的替代）。
141	ObjectMapper setAnnotationIntrospector(AnnotationIntrospector ai) - 设置此映射器实例用于序列化和反序列化的 AnnotationIntrospector 的方法。
142	ObjectMapper setAnnotationIntrospectors(AnnotationIntrospector serializerAI, AnnotationIntrospector deserializerAI) - 更改此映射器实例用于序列化和反序列化的 AnnotationIntrospector 实例的方法，分别指定它们以便不同的方面可以使用不同的自省。
143	ObjectMapper setBase64Variant(Base64Variant v) - 将配置 byte[] 序列化器和反序列化器要使用的默认 Base64Variant 的方法。
144	ObjectMapper setConfig(DeserializationConfig config) - 允许覆盖基础 DeserializationConfig 对象的方法。
145	ObjectMapper setConfig(SerializationConfig config) - 允许覆盖基础 SerializationConfig 对象的方法，其中包含特定序列化配置设置。
146	ObjectMapper setDateFormat(DateFormat dateFormat) - 配置在将时间值序列化为字符串和从 JSON 字符串反序列化时使用的默认 DateFormat 的方法。
147	ObjectMapper setDefaultPrettyPrinter(PrettyPrinter pp) - 启用“默认漂亮打印”（通过启用 SerializationFeature.INDENT_OUTPUT）时，用于指定要使用的 PrettyPrinter 的方法
148	ObjectMapper setDefaultTyping(TypeResolverBuilder<?> typer) - 用于启用自动包含类型信息的方法，其中要使用的指定处理程序对象用于确定此信息影响哪些类型以及信息嵌入的详细信息。
149	ObjectMapper setFilterProvider(FilterProvider filterProvider) - 用于配置此映射程序以使用指定的 FilterProvider 将 Filter ID 映射到实际的过滤器实例的方法。
150	Object setHandlerInstantiator(HandlerInstantiator hi) - 用于配置 HandlerInstantiator 以供给定类创建处理程序（如序列化程序、反序列化程序、类型和类型 ID 解析器）实例的方法。
151	ObjectMapper setInjectableValues(InjectableValues injectableValues) - 用于配置 InjectableValues 的方法，用于查找要注入的值。
152	ObjectMapper setLocale(Locale l) - 用于覆盖要用于格式化的默认区域设置的方法。
153	void setMixInAnnotations(Map<Class<?>,Class<?>> sourceMixins) - 弃用。自 2.5 起：已替换为方法的 fluent 形式；setMixIns(java.util.Map<java.lang.Class<?>, java.lang.Class<?>>).
154	ObjectMapper setMixInResolver(ClassIntrospector.MixInResolver resolver) - 可以被调用以指定给定解析器用于查找要使用的混合类的方法，覆盖直接添加的映射。
155	ObjectMapper setMixIns(Map<Class<?>,Class<?>> sourceMixins) - 用于定义要使用的混合注释的方法，以增强可处理（可序列化/可反序列化的）类拥有的注释。
156	ObjectMapper setNodeFactory(JsonNodeFactory f) - 用于指定 JsonNodeFactory，以用于构造根级树节点（通过方法 createObjectNode()）
157	ObjectMapper setPropertyInclusion(JsonInclude.Value incl) - 用于设置默认 POJO 属性包含策略以进行序列化的方法。
158	ObjectMapper setPropertyNamingStrategy(PropertyNamingStrategy s) - 用于设置要使用的自定义属性命名策略的方法。
159	ObjectMapper setSerializationInclusion(JsonInclude.Include incl) - 便利方法，等同于调用：
160	ObjectMapper setSerializerFactory(SerializerFactory f) - 用于设置特定的 SerializerFactory，以用于构造（bean）序列化程序的方法。
161	ObjectMapper setSerializerProvider(DefaultSerializerProvider p) - 用于设置“蓝图”SerializerProvider 实例，以用作实际提供程序实例的基础，用于处理 JsonSerializer 实例的缓存。
162	ObjectMapper setSubtypeResolver(SubtypeResolver str) - 用于设置要使用的自定义子类型解析器的方法。
163	ObjectMapper setTimeZone(TimeZone tz) - 用于覆盖要用于格式化的默认时区的方法。
164	ObjectMapper setTypeFactory(TypeFactory f) - 可以用于覆盖此映射程序使用的 TypeFactory 实例的方法。
165	ObjectMapper setVisibility(PropertyAccessor forMethod, JsonAutoDetect.Visibility visibility) - 便利方法，允许更改底层 VisibilityCheckers 的配置，以更改自动检测哪些类型的属性的细节。
166	ObjectMapper setVisibility(VisibilityChecker<?> vc) - 用于设置当前配置的 VisibilityChecker 的方法，用于确定给定的属性元素（方法、字段、构造函数）是否可以自动检测。
167	void setVisibilityChecker(VisibilityChecker<?> vc) - 已弃用。从 2.6 版开始，改用 setVisibility(VisibilityChecker)。
168	JsonParser treeAsTokens(TreeNode n) - 根据 JSON 树形结构创建 JsonParser 的方法。
169	<T> T treeToValue(TreeNode n, Class<T> valueType) - 将给定的 JSON 树形结构中的数据绑定到特定值（通常为 bean）类型的便捷转换方法。
170	<T extends JsonNode> T valueToTree(Object fromValue) - treeToValue(com.fasterxml.jackson.core.TreeNode, java.lang.Class<T>) 的反向操作；给定一个值（通常为 bean），将构建等效的 JSON 树形结构。
171	Version version() - 将从包含此类别的 JAR 中存储和读取版本信息的方法。
172	ObjectWriter writer() - 用于构建具有默认设置的 ObjectWriter 的便捷方法。
173	ObjectWriter writer(Base64Variant defaultBase64) - 用于构建工厂方法的 ObjectWriter，此方法将使用指定的 Base64 编码变量处理 Base64 编码的二进制数据。
174	ObjectWriter writer(CharacterEscapes escapes) -
175	ObjectWriter writer(ContextAttributes attrs) - 用于构建工厂方法的 ObjectWriter，此方法将使用指定的默认属性。
176	ObjectWriter writer(DateFormat df) - 用于构建工厂方法的 ObjectWriter，此方法将使用指定的 DateFormat 序列化对象；或者，如果传入空值，则使用时间戳（64 位数字）。
177	ObjectWriter writer(FilterProvider filterProvider) - 用于构建工厂方法的 ObjectWriter，此方法将使用指定的过滤器提供程序序列化对象。
178	ObjectWriter writer(FormatSchema schema) - 用于构建工厂方法的 ObjectWriter，此方法会将特定架构对象传递给用于编写内容的 JsonGenerator。
179	ObjectWriter writer(PrettyPrinter pp) - 用于构建使用指定的漂亮打印机进行缩进（或如果为空，则没有漂亮打印机）序列化对象的工厂方法的 ObjectWriter。
180	ObjectWriter writer(SerializationFeature feature) - 用于构建启用指定要素的工厂方法的 ObjectWriter（与本映射器实例的设置进行比较）。
181	ObjectWriter writer(SerializationFeature first, SerializationFeature… other) - 用于构建启用指定要素的工厂方法的 ObjectWriter（与本映射器实例的设置进行比较）。
182	ObjectWriter writerFor(Class<?> rootType) - 用于构建工厂方法的 ObjectWriter，此方法将使用指定的根类型序列化对象，而不是值的实际运行时类型。
183	ObjectWriter writerFor(JavaType rootType) - 用于构建工厂方法的 ObjectWriter，此方法将使用指定的根类型序列化对象，而不是值的实际运行时类型。
184	ObjectWriter writerFor(TypeReference<?> rootType) - 用于构建工厂方法的 ObjectWriter，此方法将使用指定的根类型序列化对象，而不是值的实际运行时类型。
185	ObjectWriter writerWithDefaultPrettyPrinter() - 用于构建使用默认缩进漂亮打印机序列化对象的工厂方法的 ObjectWriter。
186	ObjectWriter writerWithType(Class<?> rootType) - 已弃用。自 2.5 起，改为使用 writerFor(Class)。
187	ObjectWriter writerWithType(JavaType rootType) - 已弃用。自 2.5 起，改为使用 writerFor(JavaType)。
188	ObjectWriter writerWithType(TypeReference<?> rootType) - 已弃用。自 2.5 起，改为使用 writerFor(TypeReference)。
189	ObjectWriter writerWithView(Class<?> serializationView) - 用于构造 ObjectWriter 的工厂方法，该方法将使用指定的 JSON 视图（过滤器）序列化对象。
190	void writeTree(JsonGenerator jgen, JsonNode rootNode) - 使用提供的生成器序列化给定 JSON 树的方法。
191	void writeTree(JsonGenerator jgen, TreeNode rootNode)
192	＊void writeValue(DataOutput out, Object value) *
193	void writeValue(File resultFile, Object value) - 任何 Java 值都可以序列出为 JSON 输出的方法，写入到提供中，方法如下。
194	void writeValue(JsonGenerator g, Object value) - 任何 Java 值都可以序列出为 JSON 输出的方法，使用方法是使用提供的 JsonGenerator)。
195	void writeValue(OutputStream out, Object value) - 任何 Java 值都可以序列出为 JSON 输出的方法，使用提供中输出流（使用编码 JsonEncoding.UTF8）。
196	void writeValue(Writer w, Object value) - 任何 Java 值都可以序列出为 JSON 输出的方法，使用提供中写入器（编码方法是 JsonEncoding.UTF8）。
197	byte[] writeValueAsBytes(Object value) - 任何 Java 值都可以序列出为一个字节数组的方法。
198	String writeValueAsString(Object value) - 任何 Java 值序列出为一个字符串的方法。

Methods inherited

该类继承以下类的各种方法：

java.lang.Object

ObjectMapper Example

在 C:/> Jackson_WORKSPACE 选择的任何编辑器中创建以下 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+ " ]";
   }
}

Verify the result

使用 javac 编译器编译类，如下所示：

C:\Jackson_WORKSPACE>javac JacksonTester.java

现在运行 jacksonTester 查看结果：

C:\Jackson_WORKSPACE>java JacksonTester

验证输出

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

Object Serialization

现在我们将某个 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+ " ]";
   }
}

Verify the result

使用 javac 编译器编译类，如下所示：

C:\Jackson_WORKSPACE>javac JacksonTester.java

现在运行 jacksonTester 查看结果：

C:\Jackson_WORKSPACE>java JacksonTester

验证输出

Student [ name: Mahesh, age: 10 ]

Data Binding

数据绑定 API 用于使用属性访问器或者批注将 JSON 转换为 POJO (Plain Old Java Object) 或者从 POJO 转换为 JSON。它分为两种类型。

Simple Data Binding - 将 JSON 转换为 Java Maps、Lists、Strings、Numbers、Booleans 和空对象，反之亦然。
Full Data Binding - 将 JSON 转换为任何 JAVA 类型，反之亦然。

ObjectMapper 为这两种数据绑定读取/写入 JSON。数据绑定是最方便的方法，并且类似于 XML 的 JAXB 解析器。

Simple Data Binding

简单数据绑定指向对 JAVA Core 数据类型的 JSON 映射。下表描述了 JSON 类型和 Java 类型之间的关系。

Sr. No.

JSON Type

Java Type

object

LinkedHashMap<String,Object>

array

ArrayList<Object>

string

String

complete number

Integer, Long or BigInteger

fractional number

Double / BigDecimal

true

false

Boolean

null

让我们看看简单数据绑定在操作中。在这里，我们将直接把 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+ " ]";
   }
}

Verify the result

使用 javac 编译器编译类，如下所示：

C:\Jackson_WORKSPACE>javac JacksonTester.java

现在运行 jacksonTester 查看结果：

C:\Jackson_WORKSPACE>java JacksonTester

验证输出

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

Full Data Binding

完全数据绑定指向对任何 JAVA 对象的 JSON 映射。

//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+ " ]";
   }
}

Verify the result

使用 javac 编译器编译类，如下所示：

C:\Jackson_WORKSPACE>javac JacksonTester.java

现在运行 jacksonTester 查看结果：

C:\Jackson_WORKSPACE>java JacksonTester

验证输出

Student [ name: Mahesh, age: 10 ]

Data Binding with Generics

在简单数据绑定中，我们使用了以字符串作为键且以对象作为值对象的 Map 类。相反，我们可以拥有具体的 java 对象，并将类型强制转换为在 JSON 绑定中使用。

考虑使用 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;
   }
}

Verify the result

使用 javac 编译器编译类，如下所示：

C:\Jackson_WORKSPACE>javac JacksonTester.java

现在运行 jacksonTester 查看结果：

C:\Jackson_WORKSPACE>java JacksonTester

验证输出

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

Tree Model

树模型准备 JSON 文档的内存中树表示形式。ObjectMapper 构建 JsonNode 节点的树。这是最灵活的方法。它类似于 XML 的 DOM 解析器。

Create Tree from 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);

Traversing Tree Model

遍历树并获取数据时，使用到达根节点的相对路径获取每个节点。考虑以下代码片段，遍历树并提供根节点。

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

JsonNode marksNode = rootNode.path("marks");
Iterator<JsonNode> iterator = marksNode.elements();

Example

在 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(); }
   }
}

Verify the result

使用 javac 编译器编译类，如下所示：

C:\Jackson_WORKSPACE>javac JacksonTester.java

现在运行 jacksonTester 查看结果：

C:\Jackson_WORKSPACE>java JacksonTester

验证输出

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

Tree to 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(); }
   }
}

Verify the result

使用 javac 编译器编译类，如下所示：

C:\Jackson_WORKSPACE>javac JacksonTester.java

现在运行 jacksonTester 查看结果：

C:\Jackson_WORKSPACE>java JacksonTester

验证输出

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

Tree to Java Objects

在此示例中，我们使用 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;
   }
}

Verify the result

使用 javac 编译器编译类，如下所示：

C:\Jackson_WORKSPACE>javac JacksonTester.java

现在运行 jacksonTester 查看结果：

C:\Jackson_WORKSPACE>java JacksonTester

验证输出

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

Streaming API

流式 API 以分离事件形式读取和写入 JSON 内容。JsonParser 读取数据，而 JsonGenerator 则写入数据。这是三者中功能最强大的方法，也是读取/写入操作中最省时和最快的。它类似于 XML 的 Stax 解析器。

在本文中，我们将展示使用 Jackson 流式 API 来读取和写入 JSON 数据。流式 API 使用令牌的概念，并且每个 Json 细节都必须小心处理。以下是我们将在示例中使用的两个类：

* JsonGenerator* - 写入 JSON 字符串。
* JsonParser* - 解析 JSON 字符串。

Writing JSON using JsonGenerator

使用 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(); }
   }
}

Verify the result

使用 javac 编译器编译类，如下所示：

C:\Jackson_WORKSPACE>javac JacksonTester.java

现在运行 jacksonTester 查看结果：

C:\Jackson_WORKSPACE>java JacksonTester

验证输出

Mahesh Kumar
21
false
[100, 90, 85]

Reading JSON using JsonParser

使用 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();
      }
   }
}

Verify the result

使用 javac 编译器编译类，如下所示：

C:\Jackson_WORKSPACE>javac JacksonTester.java

现在运行 jacksonTester 查看结果：

C:\Jackson_WORKSPACE>java JacksonTester

验证输出

Mahesh Kumar
21
false
[100, 90, 85]

JsonGenerator Class

Introduction

JsonParser 是定义用于读取 Json 内容的公共 API 的基类。实例是使用 JsonFactory 实例的工厂方法创建的。

Class declaration

以下是 org.codehaus.jackson.JsonParser 类的声明：

public abstract class JsonParser
   extends Object
      implements Closeable, Versioned

Nested Classes

S.N.

Class & Description

*static class JsonParser.Feature * 枚举用于为解析器定义所有可切换功能。

*static class JsonParser.NumberType * 可用于数字的可能“本机”（最佳）类型的枚举。

Fields

*protected PrettyPrinter _cfgPrettyPrinter * - 在输出期间处理漂亮打印（通常是增加空白以使结果更加易于阅读）的对象。
protected JsonToken _currToken - 最后通过 nextToken() 检索的标记（如果有）。
protected int _features - 由表明已启用哪个 JsonParser.Features 的位组成的位标志。
protected JsonToken _lastClearedToken - 最后清除的标记（如果有）：即在调用 clearCurrentToken() 时生效的值。

Constructors

S.N.

Constructor & Description

*protected JsonParser() * Default constructor

*protected JsonParser(int features) *

Class Methods

S.N.	Method & Description
1	protected void _reportError(String msg) - 用于构造和抛出带有给定基本消息的 JsonGenerationException 的帮助方法。
2	protected void _reportUnsupportedOperation()
3	protected void _throwInternal() **
4	protected void _writeSimpleObject(Object value) - 用于尝试为给定的非类型对象调用适当写方法的帮助方法。
5	boolean canOmitFields() - 内省方法，用于调用以检查是否可以省略对对象字段的写入。
6	boolean canUseSchema(FormatSchema schema) - 方法，用于验证给定模式是否可与此生成器一起使用（使用 setSchema(com.fasterxml.jackson.core.FormatSchema)）。
7	boolean canWriteBinaryNatively() - 可能被调用的内省方法，以查看底层数据格式是否支持“本机”二进制数据；即，二进制内容的高效输出而无需编码。
8	boolean canWriteObjectId() - 可能被调用的内省方法，以查看底层数据格式是否原生地支持某种对象 ID（很多不支持；例如，JSON 不支持）。
9	boolean canWriteTypeId() - 可能被调用的内省方法，以查看底层数据格式是否原生地支持某种类型 ID（很多不支持；例如，JSON 不支持）。
10	abstract void close() - 用于关闭此生成器的调用的方法，因此无法再写入更多内容。
11	JsonGenerator configure(JsonGenerator.Feature f, boolean state) - 用于启用或禁用指定功能的方法：检查 JsonGenerator.Feature 以获取可用功能的列表。
12	void copyCurrentEvent(JsonParser jp) - 用于复制给定的解析器实例指向的当前事件内容的方法。
13	void copyCurrentStructure(JsonParser jp) - 用于复制给定的解析器实例指向的当前事件及其所包含的后继事件的内容的方法。
14	*abstract JsonGenerator disable(JsonGenerator.Feature f) - Method for disabling specified features (check JsonGenerator.Feature for list of features)** *
15	abstract JsonGenerator enable(JsonGenerator.Feature f) - 用于启用指定解析器功能的方法：查看 JsonGenerator.Feature 以获取可用功能列表。
16	abstract void flush() - 用于将缓冲的内容刷新到基础目标（输出流、写入器），并同时刷新目标本身的方法。
17	CharacterEscapes getCharacterEscapes() - 用于访问自定义转义工厂为其创建的 JsonGenerator 使用的方法。
18	abstract ObjectCodec getCodec() - 用于访问用于将 Java 对象作为 Json 内容写入的对象（使用 writeObject(java.lang.Object) 方法）的方法。
19	abstract int getFeatureMask() - 用于获取所有标准 JsonGenerator.Features 状态的批量访问方法。
20	int getHighestEscapedChar() - 用于测试为此生成器配置了最高未转义字符的访问器方法。
21	abstract JsonStreamContext getOutputContext()
22	Object getOutputTarget() - 可用于访问用作生成输出的目标的对象的方法；这通常是 OutputStream 或 Writer，具体取决于使用哪个生成器构造的。
23	PrettyPrinter getPrettyPrinter() - 用于检查此生成器是否配置了 PrettyPrinter 的访问器；如果已配置则返回它，如果没有已配置则返回空值。
24	FormatSchema getSchema() - 用于访问此解析器使用的模式（如果有）的方法。
25	abstract boolean isClosed() - 可用于确定此生成器是否已关闭的方法。
26	abstract boolean isEnabled(JsonGenerator.Feature f) - 用于检查给定特性是否已启用。
27	JsonGenerator setCharacterEscapes(CharacterEscapes esc) - 用于定义自定义转义工厂使用此生成器创建 JsonGenerators 的方法。
28	abstract JsonGenerator setCodec(ObjectCodec oc) - 可用于设置或重置用于将 Java 对象写入为 JsonContent（使用 writeObject(java.lang.Object) 方法）的对象的方法。
29	abstract JsonGenerator setFeatureMask(int mask) - 用于（重新）设置所有标准 JsonGenerator.Features 的批量设置方法
30	JsonGenerator setHighestNonEscapedChar(int charCode) - 可用于请求生成器转义高于指定代码点（如果为正值）的所有字符代码的方法；或除必须为数据格式转义的字符以外，不转义任何字符的方法（如果为 -1）。**
31	JsonGenerator setPrettyPrinter(PrettyPrinter pp) - 用于设置自定义漂亮打印机的方法，通常用于添加缩进以提高人类可读性。
32	JsonGenerator setRootValueSeparator(SerializableString sep) - 允许覆盖用于分隔根级别的 JSON 值的字符串的方法（默认值为单个空格字符）
33	void setSchema(FormatSchema schema) - 可用于让此生成器使用指定模式的方法。
33	abstract JsonGenerator useDefaultPrettyPrinter() - 使用默认漂亮的打印机（DefaultPrettyPrinter）启用漂亮打印的便捷方法。
34	abstract Version version() - 用于找出提供此生成器实例的包版本的访问器。
35	void writeArrayFieldStart(String fieldName) - 用于输出字段条目（“成员”）（将包含 JSON 数组值）和 START_ARRAY 标记的便捷方法。
36	abstract void writeBinary(Base64Variant b64variant, byte[] data, int offset, int len) - 将给定的二进制数据块输出为 base64 编码的完整字符串值（用双引号包围）的方法。
37	abstract int writeBinary(Base64Variant b64variant, InputStream data, int dataLength) - 与 writeBinary(Base64Variant、byte[]、int、int) 类似的方法，但输入通过流提供，可以渐进式写入，而无需将整个输入保存在内存中。
38	void writeBinary(byte[] data) - 类似于 writeBinary(Base64Variant、byte[]、int、int)，但假定默认使用 Jackson 默认的 Base64 变体（即 Base64Variants.MIME_NO_LINEFEEDS）。
39	void writeBinary(byte[] data, int offset, int len) - 类似于 writeBinary(Base64Variant、byte[]、int、int)，但默认使用 Jackson 默认的 Base64 变体（即 Base64Variants.MIME_NO_LINEFEEDS）。
40	int writeBinary(InputStream data, int dataLength) - 类似于 writeBinary(Base64Variant、InputStream、int)，但假定默认使用 Jackson 默认的 Base64 变体（即 Base64Variants.MIME_NO_LINEFEEDS）。
41	void writeBinaryField(String fieldName, byte[] data) - 用于输出包含以 base64 编码形式指定数据的成员项（“成员”）的快捷方法。
42	abstract void writeBoolean(boolean state) - 用于输出文字 Json 布尔值（字符串“true”和“false”之一）的方法。
43	void writeBooleanField(String fieldName, boolean value) - 用于输出具有布尔值的字段条目的便捷方法。
44	abstract void writeEndArray() - 用于写入 JSON 数组值（字符“]”）的结束标记的方法；如果启用了漂亮打印，还可能加上空白装饰。
45	abstract void writeEndObject() - 用于写入 JSON 对象值（字符“}”）的结束标记的方法；如果启用了漂亮打印，还可能加上空白装饰。
46	abstract void writeFieldName(SerializableString name) - 与 writeFieldName(String) 类似的方法，主要区别在于它可能执行得更好，因为其中一些处理（例如对某些字符进行引用，或在生成器支持的情况下对外部编码进行编码）可以只执行一次并用于以后的调用。
47	abstract void writeFieldName(String name) - 用于写入字段名称（JSON 字符串，用双引号包围：在语法上与 JSON 字符串值相同）的方法，如果启用了漂亮打印，可能会用空格装饰。
48	abstract void writeNull() - 用于输出文字 Json null 值的方法。
49	void writeNullField(String fieldName) - 用于输出具有 JSON 文本值 null 的字段条目的便捷方法。
50	abstract void writeNumber(BigDecimal dec) - 用于输出指示 Json 数字值的方法。
51	abstract void writeNumber(BigInteger v) - 用于将给定值输出为 Json 数字的方法。
52	abstract void writeNumber(double d) - JSON 数字值的输出方法。
53	abstract void writeNumber(float f) - JSON 数字值的输出方法。
54	abstract void writeNumber(int v) - 给定值作为 JSON 数字输出的方法。
55	abstract void writeNumber(long v) - 给定值作为 JSON 数字输出的方法。
56	void writeNumber(short v) - 给定值作为 JSON 数字输出的方法。
57	abstract void writeNumber(String encodedValue) - 可用于不能（容易地？）转换为“标准”Java 数字类型的自定义数字类型的编写方法。
58	void writeNumberField(String fieldName, BigDecimal value) - 实用方法，用于输出具有指定数字值的字段条目（“成员”）。
59	void writeNumberField(String fieldName, double value) - 实用方法，用于输出具有指定数字值的字段条目（“成员”）。
60	void writeNumberField(String fieldName, float value) - 实用方法，用于输出具有指定数字值的字段条目（“成员”）。
61	void writeNumberField(String fieldName, int value) - 实用方法，用于输出具有指定数字值的字段条目（“成员”）。
62	void writeNumberField(String fieldName, long value) - 实用方法，用于输出具有指定数字值的字段条目（“成员”）。
63	abstract void writeObject(Object pojo) - 给定的 Java 对象（POJO）写成 JSON 的方法。
64	void writeObjectField(String fieldName, Object pojo) - 实用方法，用于输出具有特定 Java 对象内容作为其值的字段条目（“成员”）。
65	void writeObjectFieldStart(String fieldName) - 实用方法，用于输出字段条目（“成员”）（将包含 JSON 对象值）和 START_OBJECT 标记。
66	void writeObjectId(Object id) - 可以调用的用于输出所谓的本机对象 ID 的方法。
67	void writeObjectRef(Object id) - 可以调用的用于输出本机对象 ID 引用信息的方法。
68	void writeOmittedField(String fieldName) Method called to indicate that a property in this position was skipped.
69	abstract void writeRaw(char c) - 方法将强制生成器逐字复制输入文本，不进行任何修改（包括不进行转义，并且不添加分隔符，即使上下文中 [数组、对象] 需要此类内容）。
70	abstract void writeRaw(char[] text, int offset, int len) - 方法将强制生成器逐字复制输入文本，不进行任何修改（包括不进行转义，并且不添加分隔符，即使上下文中 [数组、对象] 需要此类内容）。
71	void writeRaw(SerializableString raw) - 强制生成器逐字复制输入文本而不进行任何修改（包括即使 [数组、对象] 上下文本来需要也不进行转义或添加分隔符）。
72	abstract void writeRaw(String text) - 强制生成器逐字复制输入文本而不进行任何修改（包括即使 [数组、对象] 上下文本来需要也不进行转义或添加分隔符）。
73	abstract void writeRaw(String text, int offset, int len) - 强制生成器逐字复制输入文本而不进行任何修改（包括即使 [数组、对象] 上下文本来需要也不进行转义或添加分隔符）。
74	abstract void writeRawUTF8String(byte[] text, int offset, int length) - 类似于 writeString(String) 的方法，但它以 UTF-8 编码的 String 作为输入，且此 String 将按原样输出，不会进行附加转义（转义类型取决于数据格式，对于 JSON 来说是反斜杠）。
75	abstract void writeRawValue(char[] text, int offset, int len)
76	abstract void writeRawValue(String text) - 强制生成器逐字复制输入文本而不进行任何修改，但假设文本必须构成单个合法的 JSON 值（数字、字符串、布尔值、null、数组或列表）。
77	abstract void writeRawValue(String text, int offset, int len)
78	abstract void writeStartArray() - 用于编写 JSON 数组值起始标记的方法（字符“ [ ”；如果启用了漂亮打印，则加上可能的空格修饰）。
79	abstract void writeStartObject() - 用于编写 JSON 对象值起始标记的方法（字符“ { ”；如果启用了漂亮打印，则加上可能的空格修饰）。
80	abstract void writeString(char[] text, int offset, int len) - 用于输出 String 值的方法。
81	abstract void writeString(SerializableString text) - 类似于 writeString(String) 的方法，但它接受 SerializableString，这可能更有效，因为生成器能够重复使用引号和/或编码表示形式。
82	abstract void writeString(String text) - 用于输出 String 值的方法。
83	void writeStringField(String fieldName, String value) - 用于输出具有 String 值的字段条目（“成员”）的方便方法。
84	abstract void writeTree(TreeNode rootNode) - 用于使用此生成器输出给定的 JSON 树（表示为树，其中给定的 JsonNode 是根节点）的方法。
85	void writeTypeId(Object id) - 可通过该方法调用输出所谓的本机类型 ID。
86	abstract void writeUTF8String(byte[] text, int offset, int length) - 类似于 writeString(String) 的方法，但它以 UTF-8 编码的 String 为输入，并且未使用数据格式所需的任何转义方案进行转义（对于 JSON，用反斜杠转义控制字符和双引号；对于其他格式，则以其他方式进行转义）。

Methods inherited

该类继承以下类的各种方法：

java.lang.Object

JsonParser Class

Introduction

JsonParser 是定义用于读取 Json 内容的公共 API 的基类。实例是使用 JsonFactory 实例的工厂方法创建的。

Class declaration

以下是 com.fasterxml.jackson.core.JsonParser 类的声明：

public abstract class JsonParser
   extends Object
      implements Closeable, Versioned

Nested Classes

S.N.

Class & Description

*static class JsonParser.Feature * 枚举用于为解析器定义所有可切换功能。

*static class JsonParser.NumberType * 可用于数字的可能“本机”（最佳）类型的枚举。

Fields

protected int _features - 由表明已启用哪个 JsonParser.Features 的位组成的位标志。

Constructors

S.N.

Constructor & Description

protected JsonParser() Default constructor

protected JsonParser(int features)

Class Methods

S.N.	Method & Description
1	protected JsonParseException _constructError(String msg) - 根据解析器的当前状态构造 JsonParseExceptions 的辅助方法。
2	protected void _reportUnsupportedOperation() - 调用此辅助方法来执行解析器实现不支持的操作。
3	boolean canReadObjectId() — 自省方法，可以调用它以查看底层数据格式是否本机支持某种对象 ID（很多都不支持；例如，JSON 不支持）。
4	boolean canReadTypeId() — 自省方法，可以调用它以查看底层数据格式是否本机支持某种类型 ID（很多都不支持；例如，JSON 不支持）。
5	boolean canUseSchema(FormatSchema schema) — 可用于验证给定模式是否可以与该解析器一起使用的方法（使用 setSchema(com.fasterxml.jackson.core.FormatSchema)）。
6	abstract void clearCurrentToken() — 调用以“使用”当前令牌的方法，通过有效地移除它，让 hasCurrentToken() 返回 false，而 getCurrentToken() 返回 null）。
7	abstract void close() — 关闭解析器，以至于不能进行进一步的迭代或数据访问；如果解析器拥有输入源，或者启用了函数 JsonParser.Feature.AUTO_CLOSE_SOURCE，还将关闭底层输入源。
8	JsonParser configure(JsonParser.Feature f, boolean state) — 用于启用或禁用指定函数的方法（检查 JsonParser.Feature 以查看函数列表）
9	JsonParser disable(JsonParser.Feature f) — 用于禁用指定函数的方法（检查 JsonParser.Feature 以查看函数列表）
10	JsonParser enable(JsonParser.Feature f) — 用于启用指定解析器函数的方法（检查 JsonParser.Feature 以查看函数列表）
11	abstract BigInteger getBigIntegerValue() — 数值访问器，当当前令牌类型为 JsonToken.VALUE_NUMBER_INT 时可以调用该访问器，而且由于大小原因，该访问器无法用作 Java long 原始类型。
12	byte[] getBinaryValue() — getBinaryValue(Base64Variant) 的便捷选择，它默认为使用 Base64Variants.getDefaultVariant() 作为默认编码。
13	abstract byte[] getBinaryValue(Base64Variant b64variant) — 可用于读取（和使用——调用之后可能无法使用其他方法来访问结果）当前文本 JSON 值中包含的 base64 编码二进制数据的函数。
14	boolean getBooleanValue() — 当前令牌为 JsonToken.VALUE_TRUE 或 JsonToken.VALUE_FALSE 时可以调用的便捷访问器。
15	byte getByteValue() — 数值访问器，当当前令牌类型为 JsonToken.VALUE_NUMBER_INT 时可以调用该访问器，而且该访问器可以用作 Java 原生字节类型的值来表达。
16	abstract ObjectCodec getCodec() — 此解析器关联的 ObjectCodec 访问器（如果存在）。
17	abstract JsonLocation getCurrentLocation() — 返回上次处理的字符位置的函数；通常用于错误报告目的。
18	abstract String getCurrentName() — 可用于获取与当前令牌关联的名称的函数：对于 JsonToken.FIELD_NAME，它会与 getText() 返回的值相同；对于字段值，它将是前一个字段名称；对于其他情况（数组值、根级别值），将返回 null。
19	abstract JsonToken getCurrentToken() — 访问器，找到当前解析器指向的令牌（如果存在）；如果不存在，将返回 null。
20	abstract int getCurrentTokenId() — 与 getCurrentToken() 类似的函数，但返回一个 int，而不是 JsonToken（枚举值）。
21	abstract BigDecimal getDecimalValue() — 数值访问器，当当前令牌类型为 JsonToken.VALUE_NUMBER_FLOAT 或 JsonToken.VALUE_NUMBER_INT 时可以调用该访问器。
22	abstract double getDoubleValue() - 当当前标记的类型为 JsonToken.VALUE_NUMBER_FLOAT 且可以表示为 Java double 原始类型时，可以调用的数值存取器。
23	abstract Object getEmbeddedObject() - 当且仅当当前标记为 JsonToken.VALUE_EMBEDDED_OBJECT 时，可以调用的存取器。
24	int getFeatureMask() - 获取所有标准 JsonParser.Features 状态的批量访问方法。
25	abstract float getFloatValue() - 当当前标记的类型为 JsonToken.VALUE_NUMBER_FLOAT 且可以表示为 Java float 原始类型时，可以调用的数值存取器。
26	Object getInputSource() - 可以用来获取用于访问正在解析的输入的对象，这通常是 InputStream 或 Reader，具体取决于构造的解析器。
27	abstract int getIntValue() - 当当前标记的类型为 JsonToken.VALUE_NUMBER_INT 且可以表示为 Java int 原始类型的值时，可以调用的数值存取器。
28	abstract JsonToken getLastClearedToken() - 可以调用的方法，以获取使用 clearCurrentToken() 清除的最后一个标记。
29	abstract long getLongValue() - 当当前标记的类型为 JsonToken.VALUE_NUMBER_INT 且可以表示为 Java long 原始类型时，可以调用的数值存取器。
30	abstract JsonParser.NumberType getNumberType() - 如果当前标记的类型为 JsonToken.VALUE_NUMBER_INT 或 JsonToken.VALUE_NUMBER_FLOAT，返回一个 JsonParser.NumberType 常量；否则返回 null。
31	abstract Number getNumberValue() - 通用数字值存取器方法，适用于所有类型的数值。
32	Object getObjectId() - 可以调用的方法，以检查当前标记（刚刚读取的标记）是否具有关联的对象 ID，如果与之关联，则返回该对象。
33	abstract JsonStreamContext getParsingContext() - 可以用来访问当前解析上下文读取器所在的位置的方法。
34	FormatSchema getSchema() - 用于访问此解析器使用的模式（如果有）的方法。
35	short getShortValue() - 当当前标记的类型为 JsonToken.VALUE_NUMBER_INT 且可以表示为 Java short 原始类型的值时，可以调用的数值存取器。
36	abstract String getText() - 用于访问当前标记的文本表示形式的方法；如果没有当前标记（在首次调用 nextToken() 之前，或在遇到输入结尾之后），则返回 null。
37	abstract char[] getTextCharacters() - 类似于 getText() 的方法，但它将返回包含文本值的基础（不可修改）字符数组，而不是构建 String 对象包含这些信息。
38	abstract int getTextLength() - 与 getTextCharacters() 一起使用，以了解返回缓冲区中存储的 String 的长度。
39	abstract int getTextOffset() - 与 getTextCharacters() 一起使用，以了解缓冲区内第一个文本内容字符的偏移量。
40	abstract JsonLocation getTokenLocation() - 返回当前标记起始位置的方法，也就是从输入中开始当前标记的第一个字符的位置。
41	Object getTypeId() - 可以调用的方法，以检查当前标记（刚刚读取的标记）是否具有关联的类型 ID，如果与之关联，则返回该 ID。
42	boolean getValueAsBoolean() - 尝试将当前标记的值转换为布尔值的方法。
43	boolean getValueAsBoolean(boolean defaultValue) - 尝试将当前标记的值转换为布尔值的方法。
44	double getValueAsDouble() - 尝试将当前标记的值转换为 Java double 的方法。
45	double getValueAsDouble(double defaultValue) - 尝试将当前标记的值转换为 Java double 的方法。
46	int getValueAsInt() - 尝试将当前标记的值转换为 int 的方法。
47	int getValueAsInt(int defaultValue) - 尝试将当前标记的值转换为 int 的方法。
48	long getValueAsLong() - 尝试将当前标记的值转换为 long 的方法。
49	long getValueAsLong(long defaultValue) - 尝试将当前标记的值转换为 long 的方法。
50	String getValueAsString() - 尝试将当前标记的值转换为 String 的方法。
51	abstract String getValueAsString(String defaultValue) - 尝试将当前标记的值转换为 String 的方法。
52	abstract boolean hasCurrentToken() - 检查解析器是否当前指向标记的方法（并且可以获得该标记的数据）。
53	abstract boolean hasTextCharacters() - 可以用来确定 getTextCharacters() 的调用是否访问事件解析器当前指向的文本内容的最有效方法的方法。
54	abstract boolean isClosed() - 可以用来确定此解析器是否已关闭的方法。
55	boolean isEnabled(JsonParser.Feature f) - 检查指定 JsonParser.Feature 是否已启用的方法。
56	boolean isExpectedStartArrayToken() - 可用于验证当前标记表示开始数组的方法（通常表示当前标记为 JsonToken.START_ARRAY）在预期开始数组时。
57	Boolean nextBooleanValue() - 取回下一个标记（如调用 nextToken()）的方式，如果它为 JsonToken.VALUE_TRUE 或 JsonToken.VALUE_FALSE，则返回匹配的布尔值；否则返回 null。
58	boolean nextFieldName(SerializableString str) - 取回下一个标记（如调用 nextToken()）并验证它的名字是否为指定名称，且其 JsonToken.FIELD_NAME，并返回该比较的结果。
59	int nextIntValue(int defaultValue) - 取回下一个标记（如调用 nextToken()）并返回如果它为 JsonToken.VALUE_NUMBER_INT 则返回 32 位 int 值；否则返回指定默认值。从功能上等同于：
60	long nextLongValue(long defaultValue) - 取回下一个标记（如调用 nextToken()）并返回如果它为 JsonToken.VALUE_NUMBER_INT 则返回 64 位 long 值；否则返回指定默认值。从功能上等同于：
61	String nextTextValue() - 获取下一个标记的方法（如调用 nextToken()），如果为 JsonToken.VALUE_STRING，则返回包含的字符串值；否则返回 null。
62	abstract JsonToken nextToken() - 主要迭代方法, 该方法将推广数据流来确定下一个标记的类型（如果有的话）。
63	abstract JsonToken nextValue() - 迭代方法, 该方法将推广数据流来确定下一个标记的类型，该标记属于值类型（包括 JSON 数组和对象开始/结束标记）。
64	abstract void overrideCurrentName(String name) - 该方法可用于更改当前（字段）名称的考虑因素。
65	int readBinaryValue(Base64Variant b64variant, OutputStream out) - 类似于 readBinaryValue(OutputStream)，但允许明确指定要使用的 base64 变体。
66	int readBinaryValue(OutputStream out) - 该方法可作为 getBigIntegerValue() 的替代方法，尤其是在值较大的情况下。
67	<T> T readValueAs(Class<T> valueType) - 将 JSON 内容反序列化为非容器类型（但可以是数组类型）的方法：通常是 bean、数组或包装器类型（如布尔值）。
68	<T> T readValueAs(TypeReference<?> valueTypeRef) - 将 JSON 内容反序列化为 Java 类型的方法, 通过参数传递引用。
69	<T extends TreeNode> T readValueAsTree() - 将 JSON 内容反序列化为等效“树模型”的方法, 由结果模型的根 TreeNode 表示。
70	<T> Iterator<T> readValuesAs(Class<T> valueType) - 从解析器流中读取对象序列的方法, 所有对象具有相同的指定值类型。
71	<T> Iterator<T> readValuesAs(TypeReference<?> valueTypeRef) - 从解析器流中读取对象序列的方法, 所有对象具有相同的指定值类型。
72	int releaseBuffered(OutputStream out) - 该方法可用于将已读取但未被解析器使用过的任何内容推回。
73	int releaseBuffered(Writer w) - 该方法可用于将已读取但未被解析器使用过的任何内容推回。**
74	boolean requiresCustomCodec() - 可调用该方法以确定是否需要自定义 ObjectCodec 才能绑定使用由该工厂构造的 JsonParser 解析的数据（通常也表示用 JsonGenerator 序列化时需要相同的 ObjectCodec）。
75	abstract void setCodec(ObjectCodec c) - 设置程序, 允许定义与此解析器（如果有）关联的 ObjectCodec。
76	JsonParser setFeatureMask(int mask) - (re)settting 所有标准 JsonParser.Features 状态的批量设置方法
77	void setSchema(FormatSchema schema) - 调用该方法使此解析器使用指定模式。
78	abstract JsonParser skipChildren() - 该方法将跳过解析器当前指向的数组或对象标记的所有子标记, 如果 stream 指向 JsonToken.START_OBJECT 或 JsonToken.START_ARRAY。**
79	abstract Version version() - 给定解析器实例，用于获取核心包版本的访问器。

Methods inherited

该类继承以下类的各种方法：

java.lang.Object

S.No.	Constructor & Description
1	ObjectMapper()默认构造函数，将根据需要构造默认 JsonFactory，使用 SerializerProvider 作为其 SerializerProvider，将 BeanSerializerFactory 作为其 SerializerFactory。
2	ObjectMapper(JsonFactory jf)构造使用指定的 JsonFactory 来构造必需的 JsonParsers 和/或 JsonGenerators 的实例。
3	ObjectMapper(JsonFactory jf, SerializerProvider sp, DeserializerProvider dp)构造使用指定的 JsonFactory 来构造必需的 JsonParsers 和/或 JsonGenerators，并使用给定的提供程序访问序列化器和反序列化器。
4	protected ObjectMapper(ObjectMapper src)拷贝构造函数，主要用于支持 copy()。