目录
  1. WIKI教程
  2. 学习jackson
  3. Jackson - 快速指南

Jackson - 快速指南

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库是开源的，可以免费使用。

处理JSON的三种方法

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

  • Streaming API - 将JSON内容作为离散事件读取和写入。 JsonParser读取数据，而JsonGenerator写入数据。 它是三者中最强大的方法，具有最低的开销和最快的读/写操作。 对于XML，它是Analogus to Stax解析器。

  • Tree Model - 准备JSON文档的内存树表示。 ObjectMapper构建JsonNode节点的树。 这是最灵活的方法。 它类似于XML的DOM解析器。

  • Data Binding - 使用属性访问器或使用注释将JSON转换为POJO（普通旧Java对象）和从POJO转换。 它有两种类型。

    • Simple Data Binding - 将JSON转换为Java地图，列表，字符串，数字，布尔值和空对象。

    • Full Data Binding - 将JSON转换为任何JAVA类型。

    ObjectMapper为两种类型的数据绑定读取/写入JSON。 数据绑定是最方便的方式，类似于XML的JAXB parer。

Environment Setup

Try it Option Online

您真的不需要设置自己的环境来开始学习基于JAVA的库Guava。 原因很简单，我们已经在线设置Java编程环境，这样您就可以在进行理论工作的同时在线编译和执行所有可用的示例。 这使您对正在阅读的内容充满信心，并使用不同的选项检查结果。 随意修改任何示例并在线执行。

请尝试使用以下示例代码框右上角的“ Try it选项示例: 

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

对于本教程中给出的大多数示例，您将找到Try it选项，因此只需使用它并享受您的学习。

本地环境设置 (Local Environment Setup)

如果您仍然愿意为Java编程语言设置环境，那么本节将指导您如何在计算机上下载和设置Java。 请按照以下步骤设置环境。

Java SE可从链接Download Java免费获得。 因此，您下载基于您的操作系统的版本。

按照说明下载java并运行.exe以在您的计算机上安装Java。 在计算机上安装Java后，需要设置环境变量以指向正确的安装目录:

设置Windows 2000/XP的路径:

假设您已在c:\Program Files\java\jdk目录中安装了Java:

  • 右键单击“我的电脑”，然后选择“属性”。

  • 单击“高级”选项卡下的“环境变量”按钮。

  • 现在，更改'Path'变量，使其也包含Java可执行文件的路径。 例如，如果路径当前设置为“C:\WINDOWS\SYSTEM32”，则将路径更改为“C:\WINDOWS\SYSTEM32; c:\Program Files\java\jdk\bin”。

设置Windows 95/98/ME的路径:

假设您已在c:\Program Files\java\jdk目录中安装了Java:

  • 编辑'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。 但就目前而言，您可以考虑以下其中一项:

  • Notepad:在Windows机器上，您可以使用任何简单的文本编辑器，如记事本（本教程推荐），TextPad。

  • Netbeans:是一个开源和免费的Java IDE，可以从http://www.netbeans.org/index.html下载。

  • Eclipse:也是eclipse开源社区开发的Java IDE，可以从http://www.eclipse.org/下载。

下载jackson档案

从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文件夹中。

OS 存档名称
Windowsjackson-xxx-2.8.9.jar
Linuxjackson-xxx-2.8.9.jar
Macjackson-xxx-2.8.9.jar

设置Jackson环境

将jackson_HOME环境变量设置为指向Guava jar存储在计算机上的基目录位置。 假设我们在各种操作系统的jackson文件夹中提取了jackson-core-2.8.9.jar，jackson-annotations-2.8.9.jar和jackson-databind-2.8.9.jar，如下所示。

OS Output
Windows 将环境变量jackson_HOME设置为C:\jackson
Linux export jackson_HOME =/usr/local/jackson
Mac export jackson_HOME =/Library/jackson

设置CLASSPATH变量

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

OS 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。罐;。;
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创建名为C:\》Jackson_WORKSPACE的java类文件。

File: 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
}

要记住的步骤

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

第1步:创建ObjectMapper对象。

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

ObjectMapper mapper = new ObjectMapper();

第2步:将JSON DeSerialize为Object。

使用readValue（）方法从JSON获取Object。 将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 Class

ObjectMapper是Jackson库的主要actor类。 ObjectMapper类ObjectMapper提供了从基本POJO（普通旧Java对象）或从通用JSON树模型（JsonNode）读取和写入JSON的功能，以及执行转换的相关功能。 它还可以高度自定义，可以使用不同样式的JSON内容，并支持更高级的Object概念，如多态和对象标识。 ObjectMapper还充当更高级的ObjectReader和ObjectWriter类的工厂。

Class 声明 (Class Declaration)

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

public class ObjectMapper
   extends ObjectCodec
      implements Versioned, Serializable

嵌套类 (Nested Classes)

S.No. 类和描述
1 static class ObjectMapper.DefaultTypeResolverBuilder

自定义TypeResolverBuilder，提供与所谓的“默认类型”一起使用的类型解析器构建器（有关详细信息，请参阅enableDefaultTyping（））。

2 static class ObjectMapper.DefaultTyping

与enableDefaultTyping（）一起使用的枚举，用于指定应使用哪种类型（类）的默认类型。

字段 (Fields)

  • protected DeserializationConfig _deserializationConfig - 定义序列化过程的基本全局设置的配置对象。

  • protected DefaultDeserializationContext _deserializationContext - 蓝图上下文对象; 存储在这里以允许自定义子类。

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

  • protected JsonFactory _jsonFactory - 用于根据需要创建JsonParser和JsonGenerator实例的工厂。

  • protected SimpleMixInResolver _mixIns - 定义如何应用混合注释的映射:key是接收附加注释的类型，value是具有“混入”注释的类型。

  • protected ConfigOverrides _propertyOverrides - 当前活动的每类型配置覆盖，由声明的属性类型访问。

  • protected Set《Object》 _registeredModuleTypes - 模块类型集（根据Module.getTypeId（）已注册;保持跟踪iff MapperFeature.IGNORE_DUPLICATE_MODULE_REGISTRATIONS，以便可以忽略重复的注册调用（以避免多次添加相同的处理程序） ，主要是）。

  • protected ConcurrentHashMap《JavaType,JsonDeserializer《Object》》 _rootDeserializers - 我们将使用一个单独的主级别Map来跟踪根级别的反序列化器。

  • protected SerializationConfig _serializationConfig - 定义序列化过程的基本全局设置的配置对象。

  • protected SerializerFactory _serializerFactory - 用于构造序列protected SerializerFactory _serializerFactory Serializer工厂。

  • 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. 构造函数和描述
1 ObjectMapper()

默认构造函数，它将根据需要构造默认的JsonFactory，使用SerializerProvider作为其SerializerProvider，使用BeanSerializerFactory作为其SerializerFactory。

2 ObjectMapper(JsonFactory jf)

构造使用指定的JsonFactory构造必要的JsonParsers和/或JsonGenerator的实例。

3 ObjectMapper(JsonFactory jf, SerializerProvider sp, DeserializerProvider dp)

构造使用指定的JsonFactory构造必要的JsonParsers和/或JsonGenerator的实例，并使用给定的提供程序来访问序列化程序和反序列化程序。

4 protected ObjectMapper(ObjectMapper src)

复制构造函数，主要用于支持copy（）。

方法 (Methods)

用于构造SerializerProvider以用于序列化的可覆盖辅助方法。 void addMixInAnnotations（Class target，Class mixinSource） - 已弃用。 从2.5开始:用流利的方法代替; addMixIn（Class，Class）。 protected DefaultDeserializationContext createDeserializationContext（JsonParser p，DeserializationConfig cfg） - 调用内部帮助器方法，用于创建DeserializationContext实例以反序列化单个根值。 JsonSchema generateJsonSchema（Class t） - 已弃用。 从2.6开始使用外部JSON Schema生成器（https://github.com/FasterXML/jackson-module-jsonSchema）（在引擎盖下调用acceptJsonFormatVisitor（JavaType，JsonFormatVisitorWrapper））void registerSubtypes（Class ... classes） - 将指定类注册为子类型的方法，以便基于类型的解析可以将超类型链接到子类型（作为使用注释的替代方法）。 void setFilters（FilterProvider filterProvider） - 已过时。 从2.6开始，使用setFilterProvider（com.fasterxml.jackson.databind.ser.FilterProvider）代替（允许链接）Factory方法，用于构造ObjectReader，它将使用指定的字符转义细节进行输出。
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) - 可以调用以检查mapper是否认为它可以反序列化给定类型的Object的方法。
21 boolean canDeserialize(JavaType type, AtomicReference<Throwable> cause) - 类似于canDeserialize（JavaType）但可以返回在尝试构造序列化程序时抛出的实际Throwable的方法:这可能有助于确定实际问题是什么。
22 boolean canSerialize(Class<?> type) - 可以调用的方法，用于检查mapper是否认为它可以序列化给定Class的实例。
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) - 用于从给定类型（通常是java.lang.Class）构造JavaType但没有显式上下文的便捷方法。
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抽象不能引用具体的节点类型（因为它是核心包的一部分，而impls是mapper包的一部分）
37 ObjectNode createObjectNode() - 注意:返回类型是共变体，因为基本的ObjectCodec抽象不能引用具体的节点类型（因为它是核心包的一部分，而impls是mapper包的一部分）
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) - 启用自动包含类型信息的方法 - 正确反序列化多态类型所需的方法（除非使用JsonTypeInfo注释类型） - 使用“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() - 可用于获取此映射器在直接构造树的根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) - 构造ObjectReader的工厂方法，它将使用指定的JsonNodeFactory构造JSON树。
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) - 构造ObjectReader的工厂方法，它将使用JSON数据更新给定的Object（通常是Bean，但也可以是Collection或Map，但不是数组）。
99 ObjectReader readerWithView(Class<?> view) - 构造ObjectReader的工厂方法，它将使用指定的JSON View（过滤器）反序列化对象。
100 JsonNode readTree(byte[] content) - 将JSON内容反序列化为使用JsonNode实例集表示的树的方法。
101 JsonNode readTree(File file) - 将JSON内容反序列化为使用JsonNode实例集表示的树的方法。
102 JsonNode readTree(InputStream in) - 将JSON内容反序列化为使用JsonNode实例集表示的树的方法。
103 <T extends TreeNode> T readTree(JsonParser p) - 将JSON内容反序列化为使用JsonNode实例集表示的树的方法。
104 JsonNode readTree(Reader r) - 将JSON内容反序列化为使用JsonNode实例集表示的树的方法。
105 JsonNode readTree(String content) - 将JSON内容反序列化为使用JsonNode实例集表示的树的方法。
106 JsonNode readTree(URL source) - 将JSON内容反序列化为使用JsonNode实例集表示的树的方法。
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) - 将指定类注册为子类型的方法，以便基于类型的解析可以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) - 配置在将时间值序列化为字符串时使用的默认DateFormat以及从JSON字符串反序列化的方法。
147 ObjectMapper setDefaultPrettyPrinter(PrettyPrinter pp) - 指定在启用“默认漂亮打印”时使用的PrettyPrinter的方法（通过启用SerializationFeature.INDENT_OUTPUT）
148 ObjectMapper setDefaultTyping(TypeResolverBuilder<?> typer) - 使用指定的处理程序对象来确定自动包含类型信息的方法，用于确定影响哪些类型，以及如何嵌入信息的详细信息。
149 ObjectMapper setFilterProvider(FilterProvider filterProvider) - 配置此映射器以使用指定的FilterProvider将Filter Ids映射到实际过滤器实例的方法。
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开始:用流利的方法代替; setMixIns（java.util.Map ，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) - 设置用于构造（bean）序列化程序的特定SerializerFactory的方法。
161 ObjectMapper setSerializerProvider(DefaultSerializerProvider p) - 用于设置“blueprint”SerializerProvider实例的方法，该实例用作实际提供程序实例的基础，用于处理JsonSerializer实例的缓存。
162 ObjectMapper setSubtypeResolver(SubtypeResolver str) - 设置要使用的自定义子类型解析器的方法。
163 ObjectMapper setTimeZone(TimeZone tz) - 覆盖用于格式化的默认TimeZone的方法。
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 Tree表示。
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序列化对象; 或者，如果为null，则使用时间戳（64位数字）。
177 ObjectWriter writer(FilterProvider filterProvider) - 用于构造ObjectWriter的工厂方法，它将使用指定的过滤器提供程序序列化对象。
178 ObjectWriter writer(FormatSchema schema) - 用于构造ObjectWriter的工厂方法，该方法将特定的模式对象传递给用于编写内容的JsonGenerator。
179 ObjectWriter writer(PrettyPrinter pp) - 构造ObjectWriter的工厂方法，它将使用指定的漂亮打印机序列化对象以进行缩进（或者如果为null，则没有漂亮的打印机）
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 View（过滤器）序列化对象。
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输出的方法，写入提供的File。
194 void writeValue(JsonGenerator g, Object value) - 可以使用提供的JsonGenerator将任何Java值序列化为JSON输出的方法。
195 void writeValue(OutputStream out, Object value) - 可以使用提供的输出流（使用编码JsonEncoding.UTF8）将任何Java值序列化为JSON输出的方法。
196 void writeValue(Writer w, Object value) - 使用Writer提供的可用于将任何Java值序列化为JSON输出的方法。
197 byte[] writeValueAsBytes(Object value) - 可用于将任何Java值序列化为字节数组的方法。
198 String writeValueAsString(Object value) - Method that can be used to serialize any Java value as a String.

方法继承

该类继承以下类中的方法:

  • java.lang.Object

ObjectMapper Example

Create the following java program using any editor of your choice in say C:/》 Jackson_WORKSPACE

File: 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创建名为C:\》Jackson_WORKSPACE的java类文件。

File: 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

Data Binding API用于使用属性访问器或使用注释将JSON转换为POJO（Plain Old Java Object）和从POJO（Plain Old Java Object）转换JSON。 它有两种类型。

  • Simple Data Binding - 将JSON转换为Java地图，列表，字符串，数字，布尔值和空对象。

  • Full Data Binding - 将JSON转换为任何JAVA类型。

ObjectMapper为两种类型的数据绑定读取/写入JSON。 数据绑定是最方便的方式，类似于XML的JAXB parer。

简单的数据绑定

简单数据绑定是指将JSON映射到JAVA Core数据类型。 下表说明了JSON类型与Java类型之间的关系。

Sr. No. JSON类型 Java类型
1objectLinkedHashMap<String,Object>
2arrayArrayList<Object>
3stringString
4complete numberInteger, Long or BigInteger
5fractional number Double/BigDecimal
6true | falseBoolean
7nullnull

让我们看看简单的数据绑定。 在这里，我们将JAVA基本类型直接映射到JSON，反之亦然。

在C:\》Jackson_WORKSPACE创建名为C:\》Jackson_WORKSPACE的java类文件。

File: 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

完整数据绑定是指将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 Object直接映射到JSON，反之亦然。

在C:\》Jackson_WORKSPACE创建名为C:\》Jackson_WORKSPACE的java类文件。

File: 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类，它使用String作为键，Object作为值对象。 相反，我们可以使用具体的java对象并将其类型转换为在JSON绑定中使用。

请考虑以下示例，其中包含UserData类，这是一个用于保存用户特定数据的类。

在C:\》Jackson_WORKSPACE创建名为C:\》Jackson_WORKSPACE的java类文件。

File: 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后提供指向树的根节点的指针。 Root Node can be used to traverse the complete tree. 请考虑以下代码段以获取提供的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();

例子 (Example)

在C:\》Jackson_WORKSPACE创建名为C:\》Jackson_WORKSPACE的java类文件。

File: 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创建了一个Tree，并将其写入json文件并回读。

在C:\》Jackson_WORKSPACE创建名为C:\》Jackson_WORKSPACE的java类文件。

File: 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创建了一个Tree，并将其写入json文件并读回树，然后将其转换为Student对象。

在C:\》Jackson_WORKSPACE创建名为C:\》Jackson_WORKSPACE的java类文件。

File: 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

Streaming API将JSON内容作为离散事件进行读写。 JsonParser读取数据，而JsonGenerator写入数据。 它是三者中最强大的方法，具有最低的开销和最快的读/写操作。 对于XML，它是Analogus to Stax解析器。

在本文中，我们将展示使用Jackson流API来读写JSON数据。 Streaming API与令牌的概念一起使用，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创建名为C:\》Jackson_WORKSPACE的java类文件。

File: 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]

使用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创建名为C:\》Jackson_WORKSPACE的java类文件。

File: 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实例的工厂方法创建实例。

类声明

Following is the declaration for org.codehaus.jackson.JsonParser class: 

public abstract class JsonParser
   extends Object
      implements Closeable, Versioned

嵌套类 (Nested Classes)

SN 类和描述
1 static class JsonParser.Feature枚举，定义解析器的所有可切换功能。
2 static class JsonParser.NumberType可用于数字的可能“本机”（最佳）类型的枚举。

字段 (Fields)

  • protected PrettyPrinter _cfgPrettyPrinter - 在输出期间处理漂亮打印（通常是额外的空格以使结果更易于阅读）的对象。

  • protected JsonToken _currToken - Last token retrieved via nextToken(), if any.

  • protected int _features - 位标志，由指示启用了哪些JsonParser.Features的位组成。

  • protected JsonToken _lastClearedToken - Last cleared token, if any: that is, value that was in effect when clearCurrentToken() was called.

构造函数 (Constructors)

SN 构造函数和描述
1 protected JsonParser() Default constructor
2 protected JsonParser(int features)

Class Methods

SN 方法和描述
1 protected void _reportError(String msg) - 用于构造和抛出给定基本消息的JsonGenerationException的Helper方法。
2 protected void _reportUnsupportedOperation()
3 protected void _throwInternal()
4 protected void _writeSimpleObject(Object value) - 尝试为给定的无类型Object调用适当的write方法的Helper方法。
5 boolean canOmitFields() - 调用的Introspection方法，检查是否可以省略Object字段的写入。
6 boolean canUseSchema(FormatSchema schema) - 可用于验证给定模式是否可与此生成器一起使用的方法（使用setSchema（com.fasterxml.jackson.core.FormatSchema））。
7 boolean canWriteBinaryNatively() - 可以调用的内省方法，以查看底层数据格式是否支持“本机”二进制数据; 也就是说，没有编码的二进制内容的有效输出。
8 boolean canWriteObjectId() - 可以被调用以查看底层数据格式是否本身支持某种Object Ids的Introspection方法（很多都没有;例如，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() - 访问自定义转义的工厂方法，用于它创建的JsonGenerators。
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的访问器; 如果是，则返回它，如果没有配置则返回null。
24 FormatSchema getSchema() - 访问此解析器使用的Schema的方法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) -Bulk set方法，用于（重新）设置所有标准JsonGenerator.Features的状态
30 JsonGenerator setHighestNonEscapedChar(int charCode) - Method that can be called to request that generator escapes all character codes above specified code point (if positive value); or, to not escape any characters except for ones that must be escaped for the data format (if -1).
31 JsonGenerator setPrettyPrinter(PrettyPrinter pp) - 设置自定义漂亮打印机的方法，通常用于添加缩进以提高人类可读性。
32 JsonGenerator setRootValueSeparator(SerializableString sep) - 允许覆盖用于分隔根级JSON值的String的方法（默认为单个空格字符）
33 void setSchema(FormatSchema schema) - 调用以使此生成器使用指定模式的方法。
33 abstract JsonGenerator useDefaultPrettyPrinter() - 使用默认漂亮打印机（DefaultPrettyPrinter）启用漂亮打印的便捷方法。
34 abstract Version version() - 用于查找提供此生成器实例的bundle的版本的访问器。
35 void writeArrayFieldStart(String fieldName) - 输出字段条目（“成员”）（包含JSON数组值）和START_ARRAY标记的便捷方法。
36 abstract void writeBinary(Base64Variant b64variant, byte[] data, int offset, int len) - 将给定的二进制数据块作为base64编码输出的方法，作为完整的String值（由双引号括起）。
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编码形式的指定数据的字段条目（“member”）的便捷方法。
42 abstract void writeBoolean(boolean state) - 输出文字Json布尔值的方法（字符串'true'和'false'之一）。
43 void writeBooleanField(String fieldName, boolean value) - 输出具有void writeBooleanField(String fieldName, boolean value)的字段条目（“member”）的便捷方法。
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的字段条目（“member”）的便捷方法。
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) - 用于输出具有指定数值的字段条目（“member”）的便捷方法。
59 void writeNumberField(String fieldName, double value) - 输出具有指定数值的字段条目（“member”）的便捷方法。
60 void writeNumberField(String fieldName, float value) - 输出具有指定数值的字段条目（“member”）的便捷方法。
61 void writeNumberField(String fieldName, int value) - 输出具有指定数值的字段条目（“member”）的便捷方法。
62 void writeNumberField(String fieldName, long value) - 输出具有指定数值的字段条目（“member”）的便捷方法。
63 abstract void writeObject(Object pojo) - 将给定Java对象（PO​​JO）编写为Json的方法。
64 void writeObjectField(String fieldName, Object pojo) - 用于输出具有特定Java对象的内容作为其值的字段条目（“member”）的便捷方法。
65 void writeObjectFieldStart(String fieldName) - 输出字段条目（“成员”）（包含JSON对象值）和START_OBJECT标记的便捷方法。
66 void writeObjectId(Object id) - 可以调用以输出所谓的本机Object Id的方法。
67 void writeObjectRef(Object id) - 可以调用以输出对本机Object ID的引用的方法。
68 void writeOmittedField(String fieldName) Method called to indicate that a property in this position was skipped.
69 abstract void writeRaw(char c) - 强制生成器逐字复制输入文本而不进行任何修改的方法（包括没有进行转义，也不添加分隔符，即使context [array，object]需要这样做）。
70 abstract void writeRaw(char[] text, int offset, int len) - 强制生成器逐字复制输入文本而不进行任何修改的方法（包括没有进行转义并且即使上下文[array，object]也没有添加分隔符）否则需要这样）。
71 void writeRaw(SerializableString raw) - 强制生成器逐字复制输入文本而不进行任何修改的方法（包括没有进行转义，也不添加分隔符，即使context [array，object]需要这样做）。
72 abstract void writeRaw(String text) - 强制生成器逐字复制输入文本而不进行任何修改的方法（包括没有进行转义，也不添加分隔符，即使context [array，object]需要这样做）。
73 abstract void writeRaw(String text, int offset, int len) - 强制生成器逐字复制输入文本而不进行任何修改的方法（包括不进行转义并且不添加分隔符，即使context [array，object]需要这样）。
74 abstract void writeRawUTF8String(byte[] text, int offset, int length) - 类似于writeString（String）的方法，但它将输入一个UTF-8编码的字符串作为其输入，该字符串将按原样输出，不需要额外的转义（类型为这取决于数据格式; JSON的反斜杠）。
75 abstract void writeRawValue(char[] text, int offset, int len)
76 abstract void writeRawValue(String text) - 强制生成器逐字复制输入文本而不进行任何修改的方法，但假设它必须构成一个合法的JSON值（数字，字符串，布尔值，空值，数组或列表）。
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) - 输出具有void writeStringField(String fieldName, String value)的字段条目（“member”）的便捷方法。
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编码的字符串作为其输入，该字符串未使用任何转义方案数据格式进行转义（对于JSON）这是反斜杠 - 为控制字符和双引号转义;对于其他格式的其他东西）。

方法继承

该类继承以下类中的方法:

  • java.lang.Object

JsonParser Class

介绍 (Introduction)

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

类声明

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

public abstract class JsonParser
   extends Object
      implements Closeable, Versioned

嵌套类 (Nested Classes)

SN 类和描述
1 static class JsonParser.Feature枚举，定义解析器的所有可切换功能。
2 static class JsonParser.NumberType可用于数字的可能“本机”（最佳）类型的枚举。

字段 (Fields)

  • protected int _features - 位标志，由指示启用了哪些JsonParser.Features的位组成。

构造函数 (Constructors)

SN 构造函数和描述
1 protected JsonParser（）默认构造函数
2 protected JsonParser（int features）

Class Methods

SN 方法和描述
1 protected JsonParseException _constructError(String msg) - 基于解析器当前状态构造JsonParseExceptions的Helper方法。
2 protected void _reportUnsupportedOperation() - 调用解析器实现不支持的操作的Helper方法。
3 boolean canReadObjectId() - 可以调用的Introspection方法，以查看底层数据格式是否本身支持某种Object 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长原始类型(Primitive)。
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字节原始类型(Primitive)的值。
16 abstract ObjectCodec getCodec() - 与此解析器关联的abstract ObjectCodec getCodec()如果有）。
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双原始类型(Primitive)。
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() - 访问此解析器使用的Schema的方法FormatSchema getSchema()如果有）。
35 short getShortValue() - 当前标记的类型为JsonToken.VALUE_NUMBER_INT时可以调用的数字访问器，它可以表示为Java短原始类型(Primitive)的值。
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的方法，如果是，则返回它。
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位长的值; 否则返回指定的默认值它在功能上等同于:
61 String nextTextValue() - 获取下一个标记的方法（如调用nextToken（）），如果是JsonToken.VALUE_STRING则返回包含的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，数组或包装类型（如Boolean）。
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) - Method that can be called to push back any content that has been read but not consumed by the parser.
74 boolean requiresCustomCodec() - 可以调用的方法，用于确定是否需要自定义ObjectCodec来绑定使用此工厂构造的JsonParser解析的数据（对于使用JsonGenerator进行序列化，这通常也意味着相同）。
75 abstract void setCodec(ObjectCodec c) - 允许定义与此解析器关联的ObjectCodec的Setter（如果有）。
76 JsonParser setFeatureMask(int mask) - 用于（重新）设置所有标准JsonParser.Features状态的批量设置方法
77 void setSchema(FormatSchema schema) - 调用以使此解析器使用指定模式的方法。
78 abstract JsonParser skipChildren() - Method that will skip all child tokens of an array or object token that the parser currently points to, iff stream points to JsonToken.START_OBJECT or JsonToken.START_ARRAY.
79 abstract Version version() - 在给定解析器实例的情况下获取核心包版本的访问器。

方法继承

该类继承以下类中的方法:

  • java.lang.Object

<上一篇.jackson - 流媒体API( Streaming API)
Jackson - 有用的资源.下一篇>
↑回到顶部↑
WIKI教程 @2018