Processing JSON With Jackson

CHAPTER 11
Processing JSON
with Jackson
Jackson is a popular suite of APIs for parsing and creating JSON objects (and more).
Chapter 11 explores the latest version of this “best JSON parser for Java.”
What Is Jackson?
Jackson is a suite of data-processing tools for Java. These tools include a streaming JSON
parser/generator library, a matching data-binding library (for converting Plain Old Java
Objects [POJOs] to and from JSON), and additional data format modules for processing
data encoded in XML and other formats.
Note Jackson was created and is being maintained by Tatu Saloranta (www.
linkedin.com/in/tatu-saloranta-b2b36/), who was inspired by the
quality and variety of XML tooling available for the Java platform and decided
to create something similar for JSON. In 2008, Saloranta founded the company
FasterXML (http://fasterxml.com), which distributed Jackson along with
other key XML-oriented products. Jackson is currently distributed on GitHub
(http://github.com/FasterXML/jackson).
Jackson consists of a core package and two other packages that depend on the core
package:
• Jackson Core: The core package supports a StAX-like streaming API for
reading and writing JSON via sequences of discrete events. This package’s
name is com.fasterxml.jackson.core. Key classes are JsonParser for
reading JSON content and JsonGenerator for writing JSON content.
323
© Jeff Friesen 2019
J. Friesen, Java XML and JSON, https://doi.org/10.1007/978-1-4842-4330-5_11
Chapter 11 Processing JSON with Jackson
• Jackson Databind: The databind package supports a DOM-like tree

model that provides a mutable in-memory tree representation of
a JSON document. It also supports reading/writing JSON from/to
POJOs. This package’s name is com.fasterxml.jackson.databind.
Key classes are ObjectMapper for reading/writing JSON content
from/to tree models or POJOs and JsonNode, which is the base class
for all tree model nodes.
• Jackson Annotations: The annotations package provides public core

annotation types, most of which are used to configure how data
binding (mapping) works. This package’s name is com.fasterxml.
jackson.annotation. Jackson Databind also depends on Jackson
Annotations.
Simple and full POJO-oriented data binding are supported. Simple data binding
focuses on converting to and from java.util.Maps, java.util.Lists, java.lang.
Strings, java.lang.Numbers, java.lang.Booleans, and the null reference. Full data
binding includes simple data binding but also supports converting to and from any Java
Beans (http://en.wikipedia.org/wiki/JavaBeans) bean type. Conversions are based
on property accessor conventions or annotations.
The streaming API performs better than the tree model or POJO-oriented data
binding—both APIs leverage the streaming API. However, data binding is the most
convenient and the tree model offers the most flexibility.
Obtaining and Using Jackson

The Jackson Core, Jackson Databind, and Jackson Annotations packages can be obtained
from Maven (https://search.maven.org/search?q=jackson-core). Version 2.9.7 is the
latest version at the time of writing.
For each of the jackson-core, jackson-databind, and jackson-annotations artifact IDs,
click the “jar” and “javadoc.jar” menu items in the associated drop-down Download
menu, and download their referenced JAR files. You should end up with the following
JAR file collection:
• jackson-annotations-2.9.7.jar
• jackson-annotations-2.9.7-javadoc.jar
324
• jackson-core-2.9.7.jar
• jackson-core-2.9.7-javadoc.jar
• jackson-databind-2.9.7.jar
• jackson-databind-2.9.7-javadoc.jar
I’ve found it convenient to add all three nonJavadoc JAR files to my CLASSPATH
when compiling and running code that uses a combination of Java Core, Java Databind,
and Java Annotations:
javac -cp jackson-core-2.9.7.jar;jackson-databind-2.9.7.jar;jackson-

annotations-2.9.7.jar source file
java -cp jackson-core-2.9.7.jar;jackson-databind-2.9.7.jar;jackson-

annotations-2.9.7.jar;. main classfile
Working with Jackson’s Basic Features

The Jackson Core and Jackson Databind APIs support the consumption and creation of
JSON documents. This section introduces various types related to streaming, the tree
model, and POJO-oriented data binding.
Streaming
Streaming (also known as Incremental Processing) deserializes (reads) and serializes
(writes) JSON content as discrete events. Reading is performed by a parser that tokenizes
JSON content into tokens and associated data; writing is performed by a generator that
constructs JSON content based on a sequence of calls that output JSON tokens.
Note Streaming has the lowest memory and processing overhead, making it the
most efficient way to process JSON content. It’s used mainly by middleware and
frameworks because it’s harder to use than the tree model or data binding.
325
Streaming methods throw java.io.IOException when an I/O error occurs. When

a non-I/O problem is encountered while parsing or generating JSON content, a method
throws JsonProcessingException (an IOException subclass in the com.fasterxml.
jackson.core package) or one of its subclasses:
• com.fasterxml.jackson.core.JsonParseException
• com.fasterxml.jackson.core.JsonGenerationException
Stream-Based Parsing
The abstract com.fasterxml.jackson.core.JsonParser class describes a low-level
JSON parser. It’s obtained by calling one of the com.fasterxml.jackson.core.
JsonFactory class’s overloaded createParser() methods, which take the JSON
content’s origin into account.
Note Parsers can be created to parse content from external sources (such as

files or HTTP request streams) or buffered data (such as strings or byte arrays/
buffers).
For example, JsonFactory’s JsonParser createParser(String content) method

creates a parser for parsing the JSON content from the string passed to content. This
method is demonstrated as follows:
String truckJSON = "{ \"brand\" : \"Ford F-150\",

\"doors\" : 4 }";
JsonFactory factory = new JsonFactory();
JsonParser parser = factory.createParser(truckJSON);
After creating a factory and obtaining a parser from the factory, a Java program
typically enters a loop that returns a token and does something with it per iteration. This
activity continues until the parser is closed:
while (!parser.isClosed())
{
JsonToken token = parser.nextToken();
System.out.printf("token = %s%n", token);
}
326
JsonParser’s boolean isClosed() method returns true when the parser has been
closed, perhaps by invoking JsonParser’s void close() method.
JsonParser’s JsonToken nextToken() method advances the stream enough to
determine the type of the next token, returning it as a com.fasterxml.jackson.core.
JsonToken instance. When no tokens remain, null is returned.
JsonToken is an enum that identifies the basic token types used for returning the
results of parsing JSON content. Examples of its various constants are START_OBJECT ({
was seen) and END_ARRAY (] was seen).
JsonToken also provides various token classification and conversion methods.
For example, boolean isBoolean() returns true when the token describes a Boolean
value, and boolean isNumeric() returns true when the token describes a number.
Also, String asString() returns a string representation of the token (e.g., { for START_
OBJECT) or null when there is no representation (e.g., null for FIELD_NAME—an object’s
field name has been encountered).
JsonParser provides various getValueAs methods for converting a token’s value to
the method’s return type and returning that value. If conversion fails, null is returned.
For example, String getValueAsString() tries to convert the current token’s value to a
Java String, returning null when the conversion isn’t possible. The companion String
getValueAsString(String def) method returns a more meaningful default value when
conversion fails.
Listing 11-1 presents the source code to an application that demonstrates
JsonParser and JsonToken.
Listing 11-1. Learning How to Use JsonParser and JsonToken
import java.io.File;
import com.fasterxml.jackson.core.JsonFactory;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import static java.lang.System.*;
public class JacksonDemo

{
public static void main(String[] args) throws Exception
{
327
JsonParser parser =
factory.createParser(new File("person.json"));
while (!parser.isClosed())
{
JsonToken jsonToken = parser.nextToken();
if (jsonToken == null)
break;
out.printf("jsonToken = %s [%s] [%b] [%s]%n",
jsonToken, jsonToken.asString(),
jsonToken.isNumeric(),
parser.getValueAsString());
}
}
}
Listing 11-1’s main() method first creates a factory and then uses it to create a parser
for parsing a file named person.json. It then enters the previously described loop to
obtain and output tokens.
Listing 11-2 presents the JSON document that’s stored in person.json.
Listing 11-2. Describing a Person in JSON
{
"firstName": "John",
"lastName": "Doe",
"age": 42,
"address":
{
"street": "400 Some Street",
"city": "Beverly Hills",
"state": "CA",
"zipcode": 90210
},
"phoneNumbers":
[
{
"type": "home",
328
"number": "310 555-1234"

},
{
"type": "fax",
"number": "310 555-4567"
}
]
}
Compile Listing 11-1 as follows:
javac -cp jackson-core-2.9.7.jar;jackson-databind-2.9.7.jar;jackson-

annotations-2.9.7.jar JacksonDemo.java
Run the resulting application as follows:
java -cp jackson-core-2.9.7.jar;jackson-databind-2.9.7.jar;jackson-

annotations-2.9.7.jar;. JacksonDemo
You should observe the following output:
jsonToken = START_OBJECT [{] [false] [null]

jsonToken = FIELD_NAME [null] [false] [firstName]
jsonToken = VALUE_STRING [null] [false] [John]
jsonToken = FIELD_NAME [null] [false] [lastName]
jsonToken = VALUE_STRING [null] [false] [Doe]
jsonToken = FIELD_NAME [null] [false] [age]
jsonToken = VALUE_NUMBER_INT [null] [true] [42]
jsonToken = FIELD_NAME [null] [false] [address]
jsonToken = FIELD_NAME [null] [false] [street]
jsonToken = VALUE_STRING [null] [false] [400 Some Street]
jsonToken = FIELD_NAME [null] [false] [city]
jsonToken = VALUE_STRING [null] [false] [Beverly Hills]
jsonToken = FIELD_NAME [null] [false] [state]
jsonToken = VALUE_STRING [null] [false] [CA]
jsonToken = FIELD_NAME [null] [false] [zipcode]
jsonToken = VALUE_NUMBER_INT [null] [true] [90210]
329
jsonToken = END_OBJECT [}] [false] [null]

jsonToken = FIELD_NAME [null] [false] [phoneNumbers]
jsonToken = START_ARRAY [[] [false] [null]
jsonToken = FIELD_NAME [null] [false] [type]
jsonToken = VALUE_STRING [null] [false] [home]
jsonToken = FIELD_NAME [null] [false] [number]
jsonToken = VALUE_STRING [null] [false] [310 555-1234]
jsonToken = FIELD_NAME [null] [false] [type]
jsonToken = VALUE_STRING [null] [false] [fax]
jsonToken = FIELD_NAME [null] [false] [number]
jsonToken = VALUE_STRING [null] [false] [310 555-4567]
jsonToken = END_ARRAY []] [false] [null]
Stream-Based Generation
The abstract com.fasterxml.jackson.core.JsonGenerator class describes a low-
level JSON generator. It’s obtained by calling one of the JsonFactory class’s overloaded
createGenerator() methods, which take the JSON content’s destination into account.
Note Generators can be created to generate content to external destinations,

such as files or networks. Content is sent via output streams or writers.
For example, JsonFactory’s JsonGenerator createGenerator(File file,

JsonEncoding enc) method creates a generator for writing JSON content to the specified
file, overwriting any existing content (or creating the file when it doesn’t exist). The
value passed to enc determines how the written JSON content is encoded and is one of
the constants defined by the com.fasterxml.jackson.core.JsonEncoding enum; for
example, JsonEncoding.UTF8. This method is demonstrated as follows:
330

JsonGenerator generator =
factory.createGenerator(new File("out.json"),
JsonEncoding.UTF8);
JsonGenerator declares various methods for writing JSON content. For example,
void writeStartObject() writes the starting marker ({) for an object.
JsonGenerator and methods for writing JSON content.
Listing 11-3. Learning How to Use JsonGenerator and Its Methods
import com.fasterxml.jackson.core.JsonEncoding;
import com.fasterxml.jackson.core.JsonGenerator;

{
{
factory.createGenerator(new File("person.json"),
JsonEncoding.UTF8);
generator.writeStartObject();
generator.writeStringField("firstname", "John");
generator.writeStringField("lastName", "Doe");
generator.writeNumberField("age", 42);
generator.writeFieldName("address");
generator.writeStringField("street",
"400 Some Street");
generator.writeStringField("city", "Beverly Hills");
generator.writeStringField("state", "CA");
331
generator.writeNumberField("zipcode", 90210);
generator.writeEndObject();
generator.writeFieldName("phoneNumbers");
generator.writeStartArray();
generator.writeStringField("type", "home");
generator.writeStringField("number", "310 555-1234");
generator.writeStringField("type", "fax");
generator.writeEndArray();
generator.close();
out.println("person.json successfully generated");
}
}
writeStartObject() is paired with writeEndObject(), which writes the end-of-

object marker (}).
The void writeStringField(String fieldName, String value) method
writes the specified fieldName and its value. It’s equivalent to calling the void
writeFieldName(String value) method followed by the void writeString(String
text) method. The writeNumberField(String fileName, int value) method is
similar to writeStringField(String fieldName, String value), but writes an integer
value instead. It’s equivalent to calling writeFieldName(String value) followed by the
void writeNumber(int value) method.
The void writeStartArray() method writes the start-of-array marker ([). Its
companion void writeEndArray() method writes the end-of-array marker (]).
When no more content needs to be written, the generator is closed by calling its void
close() method. The underlying destination is also closed when only the generator has
access to the destination.
332
Compile Listing 11-3 and run the application. You should observe the following
output:
person.json successfully generated
The generated person.json file contains the following content:
{"firstname":"John","lastName":"Doe","age":42,"address":{"street":"400 Some
Street","city":"Beverly Hills","state":"CA","zipcode":90210},"phoneNumbers"
:[{"type":"home","number":"310 555-1234"},{"type":"fax","number":"310 555-
4567"}]}
The output is hard to read but can be improved by installing a pretty printer on the
generator. A pretty printer is an instance of a class that implements the com.fasterxml.
jackson.core.PrettyPrinter interface and that formats output to make it easier to
read. One such class is com.fasterxml.jackson.core.util.DefaultPrettyPrinter,
which employs 2-space indentation with platform-default line feeds. An instance of
this class is installed on the generator by invoking JsonGenerator’s JsonGenerator
useDefaultPrettyPrinter() method, as follows:
generator.useDefaultPrettyPrinter();
I excerpted this code fragment from a third version of the JacksonDemo application,
included in this book’s code archive. When run, that application generates a person.
json file with the following content:
{
"firstname" : "John",
"lastName" : "Doe",
"age" : 42,
"address" : {
"street" : "400 Some Street",
"city" : "Beverly Hills",
"state" : "CA",
"zipcode" : 90210
},
"phoneNumbers" : [ {
"type" : "home",
"number" : "310 555-1234"
333
}, {
"type" : "fax",
"number" : "310 555-4567"
} ]
}
Tree Model
The tree model provides a mutable in-memory tree representation of a JSON document.
The com.fasterxml.jackson.databind.ObjectMapper class is used to build a tree,
whose nodes are instances of classes that descend from the abstract com.fasterxml.
jackson.databind.JsonNode class.
ObjectMapper declares several constructors for initializing an object mapper. The
noargument ObjectMapper() constructor is the easiest to use:
ObjectMapper mapper = new ObjectMapper();
Once you have an object mapper, you can use it to read a JSON document into a tree,
or create a tree and write it to a JSON document.
Reading a JSON Document into a Tree

After obtaining an ObjectMapper instance, an application can invoke one of its
overloaded readTree() methods to read a JSON document into an in-memory tree:
JsonNode rootNode = mapper.readTree(new File("person.json"));
The JsonNode readTree(File file) method deserializes JSON content from the
specified file into a tree expressed as set of JsonNode instances. The root node of this
tree is returned.
JsonNode provides various methods for accessing tree nodes. Separate methods exist
for basic traversal of JSON objects and arrays. Objects are indexed by field name and
arrays are indexed by element index. Additionally, it’s possible to use “safe” methods
that return dummy com.fasterxml.jackson.databind.node.MissingNode instances
instead of the null reference when an object or array doesn’t contain an indicated value.
Traversal methods include the following:
334
• JsonNode get(int index): for arrays, returns child element at

index (which is 0-based) when the child element exists. If index is
less than 0 or greater than or equal to the array size, or if the node
is not a com.fasterxml.jackson.databind.node.ArrayNode, null
is returned. Note that JSON null values are of type com.fasterxml.
jackson.databind.node.NullNode and are not represented as the
null reference because null indicates that a value doesn’t exist.
• JsonNode get(String fieldName): for objects, returns fieldName’s

value when it exists. If no such field exists or the node is not a com.
fasterxml.jackson.databind.node.ObjectNode, null is returned.
Note that JSON null values are of type NullNode and are not
represented as the null reference because null indicates that a value
doesn’t exist.
• JsonNode path(int index) and JsonNode path(String fieldName):

These methods are similar to the get(int) and get(String)
methods. However, instead of returning a Java null reference for
missing values, they return a MissingNode reference. MissingNode is
beneficial in that it implements all JsonNode methods as expected: it
never has any value but can be further traversed (resulting always in
a MissingNode). It’s very useful for safe traversal: if data is there, it will
be traversed; if not, it will eventually result in missing data. This can
be considered similar to the SQL NULL value.
• JsonNode with(String propertyName) and JsonNode

withArray(String propertyName): The first method is called on
object nodes to access a property that has an object value or, when
no such property exists, to create, add, and return the created object
node. The second method is called on object nodes to access a
property that has an array value or, when no such property exists, to
create, add, and return the created array node. These methods are
very useful for safe modifications: subtrees can be materialized as
necessary.
335
Note ArrayNode provides an int size() method that returns the number of
elements in an array. ObjectNode provides an int size() method that returns
the number of properties in an object.

readTree() and associated methods.
Listing 11-4. Reading a JSON Document into a Tree and Traversing the Tree
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

{
{
JsonNode rootNode =
mapper.readTree(new File("person.json"));
out.printf("firstName = %s%n",
rootNode.get("firstName"));
out.printf("lastName = %s%n",
rootNode.get("lastName"));
out.printf("age = %s%n", rootNode.get("age"));
JsonNode address = rootNode.get("address");
out.println("address");
out.printf(" street = %s%n", address.get("street"));
out.printf(" city = %s%n", address.get("city"));
out.printf(" state = %s%n", address.get("state"));
out.printf(" zipcode = %s%n",
address.get("zipcode"));
336
JsonNode phoneNumbers = rootNode.get("phoneNumbers");

out.println("phoneNumbers");
for (int i = 0; i < phoneNumbers.size(); i++)
{
out.printf(" %d: ", i);
JsonNode phoneNumber = phoneNumbers.get(i);
out.printf("type = %s, number = %s%n",
phoneNumber.get("type"),
phoneNumber.get("number"));
}
out.println();
out.printf("%s%n", rootNode.with("address").
get("street"));
out.printf("%s%n", rootNode.withArray("phoneNumbers").
get(1).get("type"));
}
}
Compile Listing 11-4 and run the application. Assuming that the current directory
also contains Listing 11-2’s person.json file, you should observe the following output:
firstName = "John"
lastName = "Doe"
age = 42
address
street = "400 Some Street"
city = "Beverly Hills"
state = "CA"
zipcode = 90210
phoneNumbers
0: type = "home", number = "310 555-1234"
1: type = "fax", number = "310 555-4567"
"400 Some Street"

"fax"
337
Creating a Tree and Writing It to a JSON Document

An application can invoke the following ObjectMapper methods to begin construction
of a tree:
ArrayNode createArrayNode()
ObjectNode createObjectNode()
JsonNode’s ArrayNode and ObjectNode descendants also provide methods for

constructing a tree:
• ArrayNode provides several overloaded add() methods for appending

data to an array. For example, ArrayNode add(int v) appends an
object containing v to an array. It also provides several overloaded
insert() methods for inserting data into an array. For example,
ArrayNode insert(int index, int v) inserts an object containing
v at the specified index position in the array.
• ObjectNode provides several overloaded put() methods for updating

a property. For example, ObjectNode put(String fieldName,
int v) sets fieldName’s value to an object containing v.
Once the tree has been constructed, it can be written to a JSON document by
invoking one of ObjectMapper’s overloaded writeTree() methods:
mapper.writeTree(generator, rootNode);
The void writeTree(JsonGenerator gen, JsonNode rootNode) method serializes

the rootNode-anchored tree to a destination via generator gen.
writeTree() and associated methods.
Listing 11-5. Creating a Tree and Writing Its Nodes to a JSON Document
import com.fasterxml.jackson.databind.JsonNode;
338
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

{
{
JsonNode rootNode = mapper.createObjectNode();
ObjectNode objectNode = (ObjectNode) rootNode;
objectNode.put("firstName", "John");
objectNode.put("lastName", "Doe");
objectNode.put("age", 42);
ObjectNode addressNode = mapper.createObjectNode();
addressNode.put("street", "400 Some Street");
addressNode.put("city", "Beverly Hills");
addressNode.put("state", "CA");
addressNode.put("zipcode", 90210);
objectNode.set("address", addressNode);
ArrayNode phoneNumbersNode = mapper.createArrayNode();
ObjectNode phoneNumberNode =
mapper.createObjectNode();
phoneNumberNode.put("type", "home");
phoneNumberNode.put("number", "310 555-1234");
phoneNumbersNode.add(phoneNumberNode);
phoneNumberNode = mapper.createObjectNode();
phoneNumberNode.put("type", "fax");
phoneNumberNode.put("number", "310 555-4567");
phoneNumbersNode.add(phoneNumberNode);
objectNode.set("phoneNumbers", phoneNumbersNode);
factory.createGenerator(new File("person.json"),
339
JsonEncoding.UTF8);
generator.useDefaultPrettyPrinter();
mapper.writeTree(generator, rootNode);
out.println("person.json successfully generated");
}
}
output, along with a generated person.json file containing pretty-printed content:
person.json successfully generated
D
ata Binding
The ObjectMapper class supports data binding in which JSON content is parsed to and
from Java objects such as POJOs. JSON content is deserialized into Java objects, and Java
objects are serialized into JSON content.
Deserialization is achieved by calling one of ObjectMapper’s overloaded
readValue() generic methods, which support deserialization from different sources.
For example, the following method deserializes from a file into the given Java type:
<T> T readValue(File src, Class<T> valueType)
This method doesn’t support generic types because of type erasure (http://
en.wikipedia.org/wiki/Type_erasure). In contrast, the following method uses the
com.fasterxml.jackson.core.type.TypeReference<T> type to support generic types:
<T> T readValue(File src, TypeReference valueTypeRef)
TypeReference is a generic abstract class that’s used to obtain full generic type
information via subclassing. I’ll show an example shortly.
Serialization is achieved by calling one of ObjectMapper’s overloaded writeValue()
methods, which support serialization to different destinations. For example, the
following method serializes a Java object to a file:
writeValue(File resultFile, Object value)
Jackson supports simple data binding and full data binding.
340
Simple Data Binding

Simple data binding converts to and from a limited number of core JDK types. Table 11-1
reveals the JSON types and the core JDK types to which they are mapped.
Table 11-1. Mapping JSON Types to Java Types

JSON Type Java Type
object java.util.LinkedHashMap<String,Object>
array java.util.ArrayList<Object>
string java.lang.String
number (no fraction) java.lang.Integer, java.lang.Long, or java.math.
BigInteger (smallest applicable)
number (fraction) java.lang.Double (configurable to use java.math.BigDecimal)
true|false java.lang.Boolean
null null reference
The following example invokes readValue() to read a JSON object into a Java map:
Map<?,?> rootAsMap = mapper.readValue(src, Map.class);
The <?,?> syntax indicates an untyped map. To bind data into a generic map, such as
Map<String,User>, I would need to specify TypeReference as follows:
Map<String,User> rootAsMap =
mapper.readValue(src,
new TypeReference<Map<String,User>>(){});
TypeReference is needed only to pass a generic type definition (via an anonymous

inner class in this case). What’s important is <Map<String,User>>, which defines the
type to bind to.
Because the range of value types is limited to a few core JDK types, the
deserialization type (at the root or lower level) can be defined as Object.class. Any
value declared to be of java.lang.Object type uses simple data binding:
Object root = mapper.readValue(src, Object.class);
341
After creating the Java object, it can be serialized to a file or other destination by
invoking writeValue(), which is demonstrated as follows:
mapper.writeValue(new File("file.json"), rootAsMap);
Listing 11-6 presents the source code to an application that demonstrates simple
data binding via these code fragments.
Listing 11-6. A Simple Data-Binding Demonstration
import java.util.List;
import java.util.Map;
import com.fasterxml.jackson.core.type.TypeReference;

{
{
String ageJson = "65";
out.println(mapper.readValue(ageJson, Integer.class));
String planetsJson = "[\"Mercury\", \"Venus\", " +
"\"Earth\", \"Mars\"]";
List<?> list1 = mapper.readValue(planetsJson,
List.class);
out.println(list1);
// list1.add("Jupiter");
List<String> list2 =
mapper.readValue(planetsJson,
new
TypeReference<List<String>>(){});
out.println(list2);
list2.add("Jupiter");
342
out.println(list2);
String gradesJson = "{\"John\": 86, \"Jane\": 92}";
Map<?,?> map = mapper.readValue(gradesJson,
Map.class);
out.println(map);
mapper.writeValue(new File("grades.json"), map);
}
}
After creating an ObjectMapper instance, Listing 11-6’s main() method maps a JSON
number to a Java Integer, which is output.
main() now maps a string-based JSON array to a List. Because the resulting list1
object has List<?> type, the compiler will not compile list1.add("Jupiter");. There’s
no add(String) method when the unbounded wildcard type is specified. Although this
problem could be solved by specifying List list1 (giving list1 the raw List type), any
Java object could be stored in the List, which would violate type safety. Generics must
be used to solve this problem.
The main() method next creates a list of strings and uses TypeReference to pass
String to readValue(). The compiler is able to compile list1.add("Jupiter");
because List<String> has an add(String) method.
main() now switches focus to working with Map. After creating a grades-oriented
map, it outputs the map and uses writeValue() to write the map’s content to a file
named grades.json.
output:
65
[Mercury, Venus, Earth, Mars]
[Mercury, Venus, Earth, Mars]
[Mercury, Venus, Earth, Mars, Jupiter]
{John=86, Jane=92}
Furthermore, you should observe a grades.json file in the current directory. This
file should contain the following content:
{"John":86,"Jane":92}
343
Full Data Binding

Full data binding converts to and from any Java bean type in addition to Maps, Lists,
Strings, Numbers, Booleans, and the null reference. Consider Listing 11-7.
Listing 11-7. A Person Bean
/*
{
"firstName": "John",
"lastName": "Doe",
"age": 42,
"address":
{
"street": "400 Some Street",
"city": "Beverly Hills",
"state": "CA",
"zipcode": 90210
},
"phoneNumbers":
[
{
"type": "home",
"number": "310 555-1234"
},
{
"type": "fax",
"number": "310 555-4567"
}
]
}
*/
public class Person
{
private String firstName;
private String lastName;
private int age;
344
public static class Address

{
private String street, city, state;
private int zipcode;
public String getStreet()

{
return street;
}
public String getCity()

{
return city;
}
public String getState()

{
return state;
}
public int getZipcode()

{
return zipcode;
}
public void setStreet(String street)

{
this.street = street;
}
public void setCity(String city)

{
this.city = city;
}
public void setState(String state)

{
this.state = state;
}
}
345
private Address address;
public static class PhoneNumber

{
private String type, number;
public String getType()

{
return type;
}
public String getNumber()

{
return number;
}
public void setType(String type)

{
this.type = type;
}
public void setNumber(String number)

{
this.number = number;
}
}
private PhoneNumber[] phoneNumbers;
public String getFirstName()

{
return firstName;
}
public String getLastName()

{
return lastName;
}
346
public int getAge()

{
return age;
}
public Address getAddress()

{
return address;
}
public PhoneNumber[] getPhoneNumbers()

{
return phoneNumbers;
}
public void setFirstName(String firstName)

{
this.firstName = firstName;
}
public void setLastName(String lastName)

{
this.lastName = lastName;
}
public void setAge(int age)

{
this.age = age;
}
public void setAddress(Address address)

{
this.address = address;
}
public void setPhoneNumbers(PhoneNumber[] phoneNumbers)

{
this.phoneNumbers = phoneNumbers;
}
347
@Override
public String toString()
{
StringBuffer sb = new StringBuffer();
sb.append("firstName = " + firstName + "\n");
sb.append("lastName = " + lastName + "\n");
sb.append("age = " + age + "\n");
sb.append("address\n");
sb.append(" street = " + address.getStreet() +
"\n");
sb.append(" city = " + address.getCity() + "\n");
sb.append(" state = " + address.getState() + "\n");
sb.append(" zipcode = " + address.getZipcode() +
"\n");
sb.append("phoneNumbers\n");
for (int i = 0; i < phoneNumbers.length; i++)
{
sb.append(" type = " +
phoneNumbers[i].getType() + "\n");
sb.append(" number = " +
phoneNumbers[i].getNumber() + "\n");
}
return sb.toString();
}
}
Listing 11-7 describes a Person class that corresponds to Listing 11-2’s person.json
content. This class adheres to the Java Beans getter/setter method naming conventions.
By default, Jackson maps the fields of a JSON object to fields in a Java object by
matching the names of the JSON fields to the getter and setter methods in the Java
object. Jackson removes the get and set parts of the names of the getter and setter
methods and converts the first character of the remaining name to lowercase. For
example, in Listing 11-7, the JSON firstName field matches the Java getFirstName()
and setFirstName() getter and setter methods.
348
Note A getter method makes a non-public field serializable and deserializable

(once a field has a getter method, it’s considered to be a property). In contrast,
a setter method makes a non-public field deserializable only. For example, in
Listing 11-7, commenting out setAge() only doesn’t affect age’s serializability/
deserializability. However, commenting out getAge() only prevents age from
being serialized (e.g., via one of ObjectMapper’s writeValue() methods).
Listing 11-8 presents the source code to an application that demonstrates full data
binding with assistance from the Person class.
Listing 11-8. A Full Data-Binding Demonstration
import static java.lang.System.* ;

{
{
Person person =
mapper.readValue(new File("person.json"),
Person.class);
out.println(person);
}
}
Listing 11-8’s main() method first instantiates ObjectMapper. Next, it invokes the
mapper’s readValue() method to read the contents of person.json into a Person object,
which is then printed.
349
Note When using full data binding, the deserialization type must be fully
specified as something other than Object.class, which implies simple data
binding. In Listing 11-8, Person.class is passed to readValue() as the
deserialization type.
Compile Listings 11-7 and 11-8 and run the application. Assuming that the current
directory also contains Listing 11-2’s person.json file, you should observe the following
output:
firstName = John
lastName = Doe
age = 42
address
street = 400 Some Street
city = Beverly Hills
state = CA
zipcode = 90210
phoneNumbers
type = home
number = 310 555-1234
type = fax
number = 310 555-4567
Working with Jackson’s Advanced Features

Jackson provides various advanced features, which focus largely on customization. This
section introduces annotation types; custom pretty printers; and factory, parser, and
generator features.
A
nnotation Types
The Jackson Annotations and Jackson Databind packages provide annotation types
for influencing how JSON is read into Java objects or what JSON is generated from Java
objects. Annotation types are read-only, write-only, or read-write.
350
Read-Only Annotation Types

Read-only annotation types affect how Jackson deserializes (parses) JSON content into
Java objects (i.e., they affect how Jackson reads JSON content). Jackson supports the
following read-only annotation types:
• JsonSetter
• JsonAnySetter
• JsonCreator and JsonProperty
• JacksonInject
• JsonDeserialize
JsonSetter
Match the annotated setter method’s name to a JSON property name when reading
JSON content into Java objects. This annotation type is useful when a Java class’s internal
property names don’t match the JSON document’s property names.
Listing 11-9 shows JsonSetter annotating a setter method in a Person class. Because
this method isn’t present in Person2, JsonSetter annotates the field instead.
Listing 11-9. Using JsonSetter to Match Java Class and JSON Document
Property Names
import com.fasterxml.jackson.annotation.JsonSetter;

{
{
String jsonContent =
"{" +
" \"id\": 820787," +
" \"firstName\": \"Pierre\"" +
"}";
351

Person person = mapper.readValue(jsonContent,
Person.class);
Person2 person2 = mapper.readValue(jsonContent,
Person2.class);
out.println(person2);
}
}
class Person
{
private int personID = 0;
private String firstName = null;
public int getPersonID()

{
return personID;
}
@JsonSetter("id")
public void setPersonID(int personID)
{
this.personID = personID;
}

{
return firstName;
}

{
}
352
@Override
{
return personID + ": " + firstName;
}
}
class Person2
{
@JsonSetter("id")
public int getPersonID()

{
return personID;
}

{
return firstName;
}

{
}
@Override
{
}
}
The value passed to the @JsonSetter annotation is the name of the JSON field to
match to this setter method. Here, the name is id because that’s the name of the field in
the JSON object to be mapped to the setPersonID() setter method.
353
Person2 doesn’t have a setPersonID() setter, but this isn’t a problem because
Person2 contains a getPersonID() getter, making personID deserializable (via an
implicit setter) and serializable (via getPersonID()).
output:
820787: Pierre
820787: Pierre
JsonAnySetter
Call the same setter method for all unrecognized fields in the JSON object. An
unrecognized field is one that isn’t already mapped to a property or setter method in the
Java object.
Listing 11-10 shows JsonAnySetter annotating a setter method in a PropContainer
class. Without the annotation, the code would fail at runtime.
Listing 11-10. Using JsonAnySetter to Install a Setter Method for Unrecognized

JSON Object Fields
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import com.fasterxml.jackson.annotation.JsonAnySetter;

{
{
"{" +
" \"id\": 820787," +
" \"firstName\": \"Pierre\"," +
354
" \"lastName\": \"Francois\"" +
"}";
PropContainer pc =
mapper.readValue(jsonContent, PropContainer.class);
Iterator<Map.Entry<String, Object>> iter =
pc.iterator();
while (iter.hasNext())
{
Map.Entry<String, Object> entry = iter.next();
out.printf("Key: %s, Value: %s%n", entry.getKey(),
entry.getValue());
}
}
}
class PropContainer
{
// public String lastName;
private Map<String, Object> properties;
PropContainer()
{
properties = new HashMap<>();
}
@JsonAnySetter
void addProperty(String fieldName, Object value)
{
properties.put(fieldName, value);
}
Iterator<Map.Entry<String, Object>> iterator()

{
return properties.entrySet().iterator();
}
}
355
Listing 11-10 introduces a small JSON object with id, firstName, and lastName
fields. It also introduces a PropContainer class for storing these property names and
their values.
While parsing these fields from the JSON object into the PropContainer object,
Jackson would look for setID(), setFirstName(), and setLastName() methods. Because
these methods don’t exist and there are no public id, firstName, and lastName fields,
Jackson would normally output an error message at runtime. However, the presence
of addProperty() with its @JsonAnySetter annotation causes Jackson to invoke this
method for all three fields.
output:
Key: firstName, Value: Pierre

Key: lastName, Value: Francois
Key: id, Value: 820787
Uncomment the line public String lastName;, recompile Listing 11-10, and rerun
the application. You should now observe the following output:

This time, Key: lastName, Value: Francois doesn’t appear, because lastName is
no longer an unrecognized property—it now exists as a property in PropContainer.
JsonCreator and JsonProperty
JsonCreator tells Jackson that the Java object has a constructor (a “creator”) that can
match, with help from JsonProperty, the JSON object’s fields to the fields of the Java
object. These annotation types are useful where it’s not possible to use the @JsonSetter
annotation. For example, immutable objects cannot have setter methods, so their initial
values must be specified in the constructor, which Listing 11-11 demonstrates.
Listing 11-11. Using JsonCreator and JsonProperty to Call a Constructor When

Parsing JSON Text
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
356

{
{
"{" +
" \"make\": \"Ford\"," +
" \"model\": \"F150\"," +
" \"year\": 2008" +
"}";
Vehicle vehicle = mapper.readValue(jsonContent,
Vehicle.class);
out.printf("Make %s, Model %s, Year %d%n",
vehicle.getMake(), vehicle.getModel(),
vehicle.getYear());
}
}
class Vehicle
{
private String make, model;
private int year;
@JsonCreator
Vehicle(@JsonProperty("make") String make,
@JsonProperty("model") String model,
@JsonProperty("year") int year)
{
this.make = make;
this.model = model;
this.year = year;
}
357
String getMake()
{
return make;
}
String getModel()
{
return model;
}
int getYear()
{
return year;
}
}
Vehicle’s constructor is annotated @JsonCreator to tell Jackson that it should

call the constructor when parsing JSON content into a Java object. Furthermore, the
constructor’s parameters are annotated @JsonProperty to tell Jackson which JSON
object fields to pass to which constructor parameters. Note that @JsonProperty receives
a single string argument that identifies the JSON object field name.
output:
Make Ford, Model F150, Year 2008
JacksonInject
Inject (i.e., set based on an ObjectMapper-configured value) values into the parsed
objects instead of reading those values from the JSON content. For example, suppose
I add a String webURL field to the previous example’s Vehicle class. I can tell Jackson
to inject the URL of the vehicle’s manufacturer’s website into a Vehicle object by
performing the following steps:
1. Annotate webURL @JacksonInject.
2. Instantiate com.fasterxml.jackson.databind.
InjectableValues.Std() and invoke its addValue(Class<?>
classKey, Object value) method to add the string-based URL
to an injectable values object.
358
3. Instantiate ObjectMapper.
4. On the ObjectMapper instance, invoke ObjectMapper’s

ObjectReader reader(InjectableValues injectableValues)
method to construct a com.fasterxml.jackson.databind.
ObjectReader object that will use the specified injectable values.
5. On the ObjectReader instance, invoke ObjectReader’s

ObjectReader forType(Class<?> valueType) method to
construct a new reader instance that’s configured to data bind into
the specified valueType.
6. On the ObjectReader instance that forType() returns, invoke

ObjectReader’s readValue(String src) method (or a similar
readValue() method) to read the source and perform the
injection.
Listing 11-12 presents the source code to an application that accomplishes these tasks.
Listing 11-12. Using JsonInject to Inject a URL into a Parsed Vehicle Object
import com.fasterxml.jackson.annotation.JacksonInject;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.databind.InjectableValues;

{
{
"{" +
" \"make\": \"Ford\"," +
" \"model\": \"F150\"," +
" \"year\": 2008" +
"}";
359
InjectableValues inject =
new InjectableValues.Std()
.addValue(String.class,
"ford.com");
Vehicle vehicle =
new ObjectMapper().reader(inject)
.forType(Vehicle.class)
.readValue(jsonContent);
out.printf("Make %s, Model %s, Year %d, URL %s%n",
vehicle.getMake(), vehicle.getModel(),
vehicle.getYear(), vehicle.webURL);
}
}
class Vehicle
{
private String make, model;
private int year;
@JsonCreator
Vehicle(@JsonProperty("make") String make,
@JsonProperty("model") String model,
@JsonProperty("year") int year)
{
this.make = make;
this.model = model;
this.year = year;
}
String getMake()
{
return make;
}
360
String getModel()
{
return model;
}
int getYear()
{
return year;
}
@JacksonInject
String webURL;
}
output:
Make Ford, Model F150, Year 2008, URL ford.com
JsonDeserialize
Specify a custom deserializer class for a given field in a Java object. For example, suppose
a JSON document contains a color field with a string-based value such as black or red.
This document is to be deserialized into a Canvas class that declares a color field of a
Color enum type. Jackson cannot deserialize this value without help, because it cannot
convert a string to an enum instance.
The “help” that Jackson requires starts by adding annotation @JsonDeserialize
to the color field. This annotation type’s using parameter is assigned the java.
lang.Class object of the class being used to perform the custom deserialization.
Furthermore, that class must subclass the abstract com.fasterxml.jackson.databind.
JsonDeserializer<T> class, where T is the type of the annotated field.
JsonDeserializer declares an abstract T deserialize(JsonParser p,
DeserializationContext ctxt) method that Jackson calls to deserialize JSON
content into the value type that this deserializer handles. The JsonParser argument
identifies the parser of the JSON content, and the com.fasterxml.jackson.databind.
DeserializationContext argument is used to pass in configuration settings.
Listing 11-13 presents the source code to an application that implements and
demonstrates this custom deserialization example.
361
Listing 11-13. Using JsonDeserialize to Deserialize a Color String into a Color

Enum Constant
import java.io.IOException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.annotation.
JsonDeserialize;
import com.fasterxml.jackson.databind.
DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;

{
{
"{" +
" \"color\": \"black\"" +
"}";
Canvas canvas =
new ObjectMapper().readerFor(Canvas.class)
System.out.printf("Color = %s%n", canvas.color);
}
}
enum Color
{
BLACK, UNKNOWN
}
class Canvas
362
{
@JsonDeserialize(using = ColorDeserializer.class)
public Color color;
}
class ColorDeserializer extends JsonDeserializer<Color>

{
@Override
public Color deserialize(JsonParser jsonParser,
DeserializationContext
deserializationContext)
throws IOException, JsonProcessingException
{
switch (jsonParser.getText().toLowerCase())
{
case "black":
return Color.BLACK;
default:
return Color.UNKNOWN;
}
}
}
output:
Color = BLACK
Write-Only Annotation Types

Write-only annotation types affect how Jackson serializes (generates) Java objects into
JSON content (i.e., they affect how Jackson writes JSON content). Jackson supports the
following write-only annotation types:
• JsonInclude
• JsonGetter
• JsonAnyGetter
363
• JsonPropertyOrder
• JsonRawValue
• JsonValue
• JsonSerialize
JsonInclude
Include properties for serialization only under certain circumstances. For example, a
String property may be included only if its value isn’t the null reference.
JsonInclude can be used to annotate a field, a method parameter, a constructor
parameter, or an entire class. When a class is annotated, all properties are checked
against the annotation’s value to see if they can be serialized or not.
JsonInclude’s value is specified by assigning one of the JsonInclude.Include
enum’s constants to its value parameter. Here are three examples:
• ALWAYS: The property is to be included independent of its value.

Jackson includes all properties by default (i.e., when JsonInclude
isn’t used).
• NON_EMPTY: Properties with null values or what are otherwise

considered to be empty (e.g., a string has zero length or a Map’s
isEmpty() method returns true) are not included.
• NON_NULL: Properties with null values are not included.

JsonInclude with these three enum constants.
Listing 11-14. Using JsonInclude to Skip or Serialize Empty or Null Properties
import java.util.ArrayList;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonInclude;
364

{
{
mapper.disable(JsonGenerator.Feature.
AUTO_CLOSE_TARGET);
Person1 person1 = new Person1();
mapper.writeValue(out, person1) ;
out.println();
mapper.writeValue(out, person2);
out.println();
out.println();
}
}
class Person1
{
public int personID = 0;
public String firstName = null;
public String lastName = "Doe";
public List<String> phoneNumbers = new ArrayList<>();
}
@JsonInclude(JsonInclude.Include.ALWAYS)
class Person2
{
}
365
@JsonInclude(JsonInclude.Include.NON_EMPTY)
class Person3
{
}
@JsonInclude(JsonInclude.Include.NON_NULL)
class Person4
{
}
mapper.disable(JsonGenerator.Feature.AUTO_CLOSE_TARGET); prevents the

System.out stream from being closed after mapper.writeValue().
output:
{"personID":0,"firstName":null,"lastName":"Doe","phoneNumbers":[]}
{"personID":0,"firstName":null,"lastName":"Doe","phoneNumbers":[]}
{"personID":0,"lastName":"Doe"}
{"personID":0,"lastName":"Doe","phoneNumbers":[]}
JsonGetter
When serializing a class instance, call the @JsonGetter-annotated method and serialize
the return value as the property’s value.
This annotation type is useful for Java classes that follow the jQuery (http://
en.wikipedia.org/wiki/JQuery) style for getter and setter names (such as numDoors()
instead of getNumDoors()). Consider Listing 11-15.
366
Listing 11-15. Using JSonGetter to Serialize jQuery-Style Properties
import com.fasterxml.jackson.annotation.JsonGetter;
import com.fasterxml.jackson.annotation.JsonSetter;

{
{
"{" +
" \"id\": 820787," +
" \"firstName\": \"Pierre\"" +
"}";
Person person = mapper.readValue(jsonContent,
Person.class);
mapper.writeValue(new File("pierre.json"), person);
}
}
class Person
{
@JsonGetter("id")
public int personID()
{
return personID;
}
367
public void setPersonID(int personID)

{
this.personID = personID;
}
@JsonGetter("firstName")
public String firstName()
{
return firstName;
}

{
}
@Override
{
}
}
The personId() and firstName() jQuery-style methods are annotated @JsonGetter.

The value set on each @JsonGetter annotation is the property name that Jackson will
write to the JSON document.
If @JsonGetter("id") is removed from personID(), Jackson will throw a runtime
exception. It will do so because it cannot map the JSON id property to the Java personID
property—personID would have to be renamed getId, and setPersonID would have to
be renamed setId to remove the exception. If @JsonGetter("firstName") is removed
from firstName(), Jackson won’t serialize the Java firstName property to JSON.
It isn’t necessary to annotate setPersonID() @JsonSetter("id"), which was
done in Listing 11-9, because the presence of personID() with its @JsonGetter("id")
annotation makes personID deserializable and serializable.
output:
820787: Pierre
368
Furthermore, you should observe a pierre.json file with the following content:
{"id":820787,"firstName":"Pierre"}
JsonAnyGetter
Identify a non-static, noargument method that returns a map of properties to be
serialized to JSON. Each of the map’s key/value pairs is serialized along with regular
properties. This annotation type is the counterpart to JsonAnySetter.
Listing 11-16 presents an application that demonstrates JsonAnyGetter. This
application extends Listing 11-10, which also demonstrates JsonAnySetter.
Listing 11-16. Using JSonAnyGetter to Serialize a Map of Properties
import java.util.Iterator;
import java.util.Map.Entry;
import com.fasterxml.jackson.annotation.JsonAnyGetter;
import com.fasterxml.jackson.annotation.JsonAnySetter;

{
{
"{" +
" \"id\": 820787," +
" \"firstName\": \"Pierre\"," +
" \"lastName\": \"Francois\"" +
"}";
369

PropContainer pc =
mapper.readValue(jsonContent, PropContainer.class);
Iterator<Map.Entry<String, Object>> iter =
pc.iterator();
while (iter.hasNext())
{
Map.Entry<String, Object> entry = iter.next();
out.printf("Key: %s, Value: %s%n", entry.getKey(),
entry.getValue());
}
mapper.writeValue(new File("pierre.json"), pc) ;
}
}
class PropContainer
{
public String lastName;
private Map<String, Object> properties;
PropContainer()
{
properties = new HashMap<>();
}
@JsonAnySetter
void addProperty(String fieldName, Object value)
{
properties.put(fieldName, value);
}
Iterator<Map.Entry<String, Object>> iterator()

{
return properties.entrySet().iterator();
}
@JsonAnyGetter
370
public Map<String, Object> properties()

{
return properties;
}
}
output:

Jackson’s deserialization mechanism doesn’t add JSON’s lastName property to

the map because it detects a lastName property of the PropContainer class. It updates
lastName instead.
You should also observe a pierre.json file with the following content:
{"lastName":"Francois","firstName":"Pierre","id":820787}
Jackson’s serialization mechanism first writes PropContainer’s regular properties

(only lastName in this case) and then outputs the properties that are stored in the map.
JsonPropertyOrder
Specify the order in which a Java object’s fields should be serialized to JSON content.
This annotation type makes it possible to override the default top-down order with a
different order. Consider Listing 11-17.
Listing 11-17. Using JSonPropertyOrder to Serialize SomeClass2’s Properties in

Reverse Order
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
371

{
{
SomeClass1 sc1 = new SomeClass1();
mapper.writeValue(new File("order1.json"), sc1);
SomeClass2 sc2 = new SomeClass2();
mapper.writeValue(new File("order2.json"), sc2);
out.println("serialization successful");
}
}
class SomeClass1
{
public int a = 1, b = 2, c = 3, d = 4;
public String e = "e";
}
@JsonPropertyOrder({"e","d","c","b","a"})
class SomeClass2
{
public int a = 1, b = 2, c = 3, d = 4;
public String e = "e";
}
Listing 11-17 declares SomeClass1, which isn’t annotated with JsonPropertyOrder.

Therefore, its fields are serialized in top-down order. In contrast, SomeClass2 is
annotated so that its fields are serialized in reverse order.
Note The @JsonProperty annotation receives an array of quoted field names

whose left-to-right order corresponds to the serialized top-to-bottom order.
372
output:
serialization successful
The generated order1.json file contains the following content:
{"a":1,"b":2,"c":3,"d":4,"e":"e"}
The generated order2.json file contains the following content:
{"e":"e","d":4,"c":3,"b":2,"a":1}
JsonRawValue
Tell Jackson that the annotated Java method or field should be serialized as is. A string
property’s value is serialized without the surrounding quote characters. Consider
Listing 11-18.
Listing 11-18. Using JSonRawValue to Serialize a Vehicle Field As Is
import com.fasterxml.jackson.annotation.JsonRawValue;

{
{
Driver1 d1 = new Driver1();
mapper.writeValue(new File("driver1.json"), d1);
Driver2 d2 = new Driver2();
mapper.writeValue(new File("driver2.json"), d2);
}
}
373
class Driver1
{
public String name = "John Doe";
public String vehicle = "{ \"make\": \"Ford\", " +
"\"model\": \"F150\", " +
"\"year\": 2008";
}
class Driver2
{
public String name = "John Doe";
@JsonRawValue
public String vehicle = "{ \"make\": \"Ford\", " +
"\"model\": \"F150\", " +
"\"year\": 2008";
}
output:
The generated driver1.json file contains the following content:
{"name":"John Doe","vehicle":"{ \"make\": \"Ford\", \"model\": \"F150\",

\"year\": 2008"}
The generated driver2.json file contains the following content:
{"name":"John Doe","vehicle":{ "make": "Ford", "model": "F150",

"year": 2008}
Unlike the previous output, this output reveals that the value of Driver2’s vehicle
property is serialized as part of the JSON object structure. It’s not serialized to a string in
the JSON object’s vehicle field, as the previous output shows.
374
JsonValue
Delegate the serialization of a Java object to one of its methods, which must take no
arguments and which must return a value of a scalar type (such as String or java.lang.
Number) or any serializable type (such as java.util.Collection or Map).
For a noargument method with a String return type, Jackson escapes any double
quotation marks inside the returned String, making it impossible to return a full JSON
object. However, that task can be accomplished by using @JsonRawValue.
Listing 11-19 demonstrates JsonValue.
Listing 11-19. Using JSonValue to Serialize Props1 and Props2 Objects via Their
toJson() Methods
import com.fasterxml.jackson.annotation.JsonValue;

{
{
Props1 p1 = new Props1();
mapper.writeValue(new File("props1.json"), p1);
Props2 p2 = new Props2();
mapper.writeValue(new File("props2.json"), p2);
}
}
375
class Props1
{
public String a = "A";
public String b = "B";
@JsonValue
public String toJSON()
{
return a + "\"-\"" + b;
}
}
class Props2
{
private Map<String, String> props = new HashMap<>();
Props2()
{
props.put("a", "A'A'\"A\"");
props.put("b", "B'B'\"B\"");
}
@JsonValue
public Map<String, String> toJSON()
{
return props;
}
}
output:
The generated props1.json file contains the following content:
"A\"-\"B"
The generated props2.json file contains the following content:
{"a":"A'A'\"A\"","b":"B'B'\"B\""}
376
This output reveals that double quotation marks are escaped even in noargument
methods with return types other than String.
JsonSerialize
Specify a custom serializer class for a given field in a Java object. For example, suppose a
Java object contains a color field whose value is an enum instance such as Color.BLACK.
This object is to be serialized to a JSON document whose color field is associated with a
string-based value such as black or red. Jackson cannot serialize this value without help,
because it cannot convert an enum instance to a string.
The “help” that Jackson requires starts by adding a @JsonSerialize annotation to
the color field. This annotation type’s using parameter is assigned the Class object of
the class being used to perform the custom serialization. Furthermore, that class must
subclass the abstract com.fasterxml.jackson.databind.JsonSerializer<T> class,
where T is the type of the annotated field.
JsonSerializer declares an abstract void serialize(T value, JsonGenerator
gen, SerializerProvider serializers) method that Jackson calls to serialize the
value type that this serializer handles to JSON content. The JsonGenerator argument
identifies the generator of the JSON content, and the com.fasterxml.jackson.
databind.SerializerProvider argument is used when serializing complex object
graphs.
Listing 11-20 presents the source code to an application that refactors Listing 11-13
to implement and demonstrate this custom serialization example.
Listing 11-20. Using JsonSerialize to Serialize a Color Enum Constant to a

Color String
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
377
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;

{
{
"{" +
" \"color\": \"black\"" +
"}";
Canvas canvas =
new ObjectMapper().readerFor(Canvas.class)
out.printf("Color = %s%n", canvas.color);
new ObjectMapper().writeValue(new File("color.json"),
canvas);
}
}
enum Color
{
BLACK, UNKNOWN
}
class Canvas
{
@JsonDeserialize(using = ColorDeserializer.class)
@JsonSerialize(using = ColorSerializer.class)
public Color color;
}
378
class ColorDeserializer extends JsonDeserializer<Color>

{
@Override
public Color deserialize(JsonParser jsonParser,
DeserializationContext
deserializationContext)
{
switch (jsonParser.getText().toLowerCase())
{
case "black":
return Color.BLACK;
default:
return Color.UNKNOWN;
}
}
}
class ColorSerializer extends JsonSerializer<Color>

{
@Override
public void serialize(Color color,
JsonGenerator jsonGenerator,
SerializerProvider
serializerProvider)
{
switch (color)
{
case BLACK:
jsonGenerator.writeString("black");
break;
379
default:
jsonGenerator.writeString("unknown");
}
}
}
output:
Color = BLACK
Furthermore, you should observe a generated color.json file with the following
content:
{"color":"black"}
Read-Write Annotation Types

Read-write annotation types affect the reading of Java objects from JSON content, as well
as the writing of Java objects to JSON content. The following read-write annotation types
are supported by Jackson:
• JsonIgnore and JsonIgnoreProperties
• JsonIgnoreType
• JsonAutoDetect
JsonIgnore and JsonIgnoreProperties
JsonIgnore tells Jackson to ignore a certain property (field) of a Java object. The property
is ignored when reading JSON content to Java objects and when writing Java objects to
JSON content. JsonIgnoreProperties tells Jackson to ignore a list of properties of a Java
class. The @JsonIgnoreProperties annotation is placed above the class declaration
instead of above each property (field) to be ignored. These closely related annotation
types are demonstrated in Listing 11-21.
380
Listing 11-21. Using JsonIgnore and JsonIgnoreProperties to Ignore One or

More Properties
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.
JsonIgnoreProperties;

{
{
SavingsAccount1 sa1 =
new SavingsAccount1("101", "John Doe", 50000);
mapper.writeValue(new File("sa1.json"), sa1);
sa1 = mapper.readValue(new File("sa1.json"),
SavingsAccount1.class);
out.printf("bankID = %s%n", sa1.bankID);
out.printf("accountOwnerName = %s%n",
sa1.accountOwnerName);
out.printf("balanceInCents = %d%n",
sa1.balanceInCents);
381
}
}
class SavingsAccount1
{
public String bankID;
public String accountOwnerName;
public long balanceInCents;
SavingsAccount1()
{
}
SavingsAccount1(String bankID, String accountOwnerName,

long balanceInCents)
{
this.bankID = bankID;
this.accountOwnerName = accountOwnerName;
this.balanceInCents = balanceInCents;
}
}
{
@JsonIgnore
382
SavingsAccount2()
{
}

{
}
}
@JsonIgnoreProperties({"bankID", "accountOwnerName"})
{
SavingsAccount3()
{
}

{
}
}
The noargument and empty constructors in SavingsAccount1, SavingsAccount2,

and SavingsAccount3 are needed to avoid a runtime exception during deserialization.
383
output:
bankID = 101
accountOwnerName = John Doe
balanceInCents = 50000
bankID = null
accountOwnerName = John Doe
bankID = null
accountOwnerName = null
The null values are the result of bankID and accountOwnerName being set to null
because of @JsonIgnore and @jsonIgnoreProperties, even though this information is
stored in sa1.json.
The generated sa1.json file contains the following content:
{"bankID":"101","accountOwnerName":"John Doe","balanceInCents":50000}
{"accountOwnerName":"John Doe","balanceInCents":50000}
{"balanceInCents":50000}
JsonIgnoreType
All properties of an annotated type are to be ignored during serialization and
deserialization. This annotation type is demonstrated in Listing 11-22, where it’s used to
prevent Address properties from being serialized/deserialized.
Listing 11-22. Using JsonIgnoreType to Ignore Address Properties
import com.fasterxml.jackson.annotation.JsonIgnoreType;
384

{
{
person1.name = "John Doe";
person1.address = new Person1.Address();
person1.address.street = "100 Smith Street";
person1.address.city = "SomeCity";
mapper.writeValue(new File("person1.json"), person1);
person2.name = "John Doe";
person2.address = new Person2.Address();
person2.address.street = "100 Smith Street";
person2.address.city = "SomeCity";
mapper.writeValue(new File("person2.json"), person2);
person1 = mapper.readValue(new File("person1.json"),
Person1.class);
out.printf("name = %s%n", person1.name);
out.printf("street = %s%n", person1.address.street);
out.printf("city = %s%n", person1.address.city);
person2 = mapper.readValue(new File("person1.json"),
Person2.class);
out.printf("name = %s%n", person2.name);
out.printf("street = %s%n", person2.address.street);
out.printf("city = %s%n", person2.address.city);
}
}
class Person1
{
public String name;

{
385
public String street;

public String city;
}
public Address address;

}
class Person2
{
public String name;
@JsonIgnoreType
{
public String street;
public String city;
}
public Address address;

}
output:
name = John Doe

street = 100 Smith Street
city = SomeCity
name = John Doe
Exception in thread "main" java.lang.NullPointerException
at JacksonDemo.main(JacksonDemo.java:34)
The exception is the result of address being set to null because of @JsonIgnoreType,
even though the address information is stored in person1.json.
The generated person1.json file contains the following content:
{"name":"John Doe","address":{"street":"100 Smith

Street","city":"SomeCity"}}
The generated person2.json file contains the following content:
{"name":"John Doe"}
386
JsonAutoDetect
Tell Jackson to include non-public properties when reading and writing Java objects.
This annotation type declares various visibility elements for determining the
minimum visibility level (such as public or protected) for auto-detection. For example,
fieldVisibility specifies the minimum visibility required for auto-detecting member
fields. One of the JsonAutoDetect.Visibility enum constants is assigned to this
element. This enum enumerates possible visibility thresholds (minimum visibility) that
can be used to limit which methods (and fields) are auto-detected.
Listing 11-23 demonstrates JsonAutoDetect and its nested Visibility enum.
Listing 11-23. Using JsonAutoDetect to Auto-Detect Various Fields
import com.fasterxml.jackson.annotation.JsonAutoDetect;

{
{
SomeClass1 sc1 = new SomeClass1(1, 2, 3);
mapper.writeValue(new File("sc1.json"), sc1);
sc1 = mapper.readValue(new File("sc1.json"),
SomeClass1.class);
sc1.print();
SomeClass2.class);
sc2.print();
SomeClass3.class);
387
sc3.print();
}
}
class SomeClass1
{
public int a;
private int b;
protected int c;
SomeClass1()
{
}
SomeClass1(int a, int b, int c)

{
this.a = a;
this.b = b;
this.c = c;
}
public void print()

{
out.printf("a = %d, b = %d, c = %d%n", a, b, c);
}
}
@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility
.PROTECTED_AND_PUBLIC)
class SomeClass2
{
public int a;
private int b;
protected int c;
SomeClass2()
{
}
388

{
this.a = a;
this.b = b;
this.c = c;
}
public void print()

{
}
}
@JsonAutoDetect(fieldVisibility = JsonAutoDetect.Visibility
.ANY)
class SomeClass3
{
public int a;
private int b;
protected int c;
SomeClass3()
{
}

{
this.a = a;
this.b = b;
this.c = c;
}
public void print()

{
}
}
389
With Visiblity.PROTECTED_AND_PUBLIC, only access modifiers protected and

public are auto-detectable. With Visibility.ANY, protected, public, private, and
package access are auto-detectable.
output:
a = 1, b = 0, c = 0
a = 1, b = 0, c = 3
a = 1, b = 2, c = 3
The generated sc1.json file contains the following content:
{"a":1}
{"a":1,"c":3}
{"a":1,"b":2,"c":3}
Custom Pretty Printers

Jackson supports pretty printers to improve the appearance of generated output (making
it easier to read). A pretty printer class must implement the PrettyPrinter interface in
terms of the following methods:
• void beforeArrayValues(JsonGenerator gen)
• void beforeObjectEntries(JsonGenerator gen)
• void writeArrayValueSeparator(JsonGenerator gen)
• void writeEndArray(JsonGenerator gen, int nrOfValues)
• void writeEndObject(JsonGenerator gen, int nrOfEntries)
• void writeObjectEntrySeparator(JsonGenerator gen)
• void writeObjectFieldValueSeparator(JsonGenerator gen)
390
• void writeRootValueSeparator(JsonGenerator gen)
• void writeStartArray(JsonGenerator gen)
• void writeStartObject(JsonGenerator gen)
Furthermore, since Jackson 2.1, a stateful implementation of PrettyPrinter must

implement the com.fasterxml.jackson.core.util.Instantiatable<T> interface, to
allow for the construction of per-generation instances in order to avoid state corruption
when sharing the pretty printer instance among threads. Instantiatable declares a T
createInstance() method that returns a newly created stateful pretty printer object.
Note A stateless pretty printer class doesn’t need to implement

Instantiatable. However, if it implements this interface, its
createInstance() method should return this to signify the current object.
Earlier in this chapter, I showed the following pretty-printed output:
{
"lastName" : "Doe",
"age" : 42,
"address" : {
"state" : "CA",
"zipcode" : 90210
},
"phoneNumbers" : [ {
"type" : "home",
"number" : "310 555-1234"
}, {
"type" : "fax",
"number" : "310 555-4567"
} ]
}
391
I’d like to reformat the output to look like this:
{
"lastName" : "Doe",
"age" : 42,
"address" :
{
"state" : "CA",
"zipcode" : 90210
},
"phoneNumbers" :
[
{
"type" : "home",
"number" : "310 555-1234"
},
{
"type" : "fax",
"number" : "310 555-4567"
}
]
}
Listing 11-24 provides the source code to an application with a custom

MyPrettyPrinter class that formats the output as shown in the preceding text.
Listing 11-24. Reformatting Output with a Pretty Printer
import com.fasterxml.jackson.core.PrettyPrinter;
392
import com.fasterxml.jackson.core.util.Instantiatable;

{
{
factory.createGenerator(out, JsonEncoding.UTF8);
generator.setPrettyPrinter(new MyPrettyPrinter());
generator.writeStringField("firstname", "John");
generator.writeStringField("lastName", "Doe");
generator.writeNumberField("age", 42);
generator.writeFieldName("address");
generator.writeStringField("street",
"400 Some Street");
generator.writeStringField("city", "Beverly Hills");
generator.writeStringField("state", "CA");
generator.writeNumberField("zipcode", 90210);
generator.writeFieldName("phoneNumbers");
generator.writeStartArray();
generator.writeStringField("type", "home");
generator.writeStringField("type", "fax");
generator.writeEndArray();
393
generator.close();
}
}
class MyPrettyPrinter
implements PrettyPrinter, Instantiatable<MyPrettyPrinter>
{
private final String LINE_SEP =
getProperty("line.separator");
private int indent = 0;

private boolean isNewline = true;
@Override
public MyPrettyPrinter createInstance()
{
return new MyPrettyPrinter();
}
@Override
public void writeStartObject(JsonGenerator jg)
throws IOException
{
if (!isNewline)
newline(jg);
jg.writeRaw('{');
++indent;
isNewline = false;
}
@Override
public void beforeObjectEntries(JsonGenerator jg)
throws IOException
{
newline(jg) ;
}
394
@Override
public void
writeObjectFieldValueSeparator(JsonGenerator jg)
throws IOException
{
jg.writeRaw(" : ");
isNewline = false;
}
@Override
public void writeObjectEntrySeparator(JsonGenerator jg)
throws IOException
{
jg.writeRaw(",");
newline(jg);
}
@Override
public void writeEndObject(JsonGenerator jg,
int nrOfEntries)
throws IOException
{
--indent;
newline(jg);
jg.writeRaw('}');
isNewline = indent == 0;
}
@Override
public void writeStartArray(JsonGenerator jg)
throws IOException
{
newline(jg);
jg.writeRaw("[");
++indent;
isNewline = false;
}
395
@Override
public void beforeArrayValues(JsonGenerator jg)
throws IOException
{
newline(jg);
}
@Override
public void writeArrayValueSeparator(JsonGenerator jg)
throws IOException
{
jg.writeRaw(", ");
isNewline = false;
}
@Override
public void writeEndArray(JsonGenerator jg,
int nrOfValues)
throws IOException
{
--indent;
newline(jg);
jg.writeRaw(']');
isNewline = false;
}
@Override
public void writeRootValueSeparator(JsonGenerator jg)
throws IOException
{
jg.writeRaw(' ');
}
private void newline(JsonGenerator jg) throws IOException

{
jg.writeRaw(LINE_SEP);
for (int i = 0; i < indent; ++i)
396
jg.writeRaw(" ");
isNewline = true;
}
}
DefaultPrettyPrinter is paired with JsonGenerator’s useDefaultPrettyPrinter()

method, which instantiates DefaultPrettyPrinter and installs the instance on the
generator. All other pretty printer classes must be instantiated explicitly, and these
instances must be installed on their generators by using JsonGenerator’s JsonGenerator
setPrettyPrinter(PrettyPrinter pp) method, which Listing 11-24 accomplishes as
follows:
generator.setPrettyPrinter(new MyPrettyPrinter());
Although there’s no need to do so, it’s possible to explicitly instantiate

DefaultPrettyPrinter and pass the instance to JsonGenerator by calling
setPrettyPrinter().
Note MyPrettyPrinter’s content is based on code found in GitHub issue

“PrettyPrinter Indenter: Ability to insert eol before object and array entries #724”
(http://github.com/FasterXML/jackson-databind/issues/724).
output:
{
"lastName" : "Doe",
"age" : 42,
"address" :
{
"state" : "CA",
"zipcode" : 90210
},
397
"phoneNumbers" :
[
{
"type" : "home",
"number" : "310 555-1234"
},
{
"type" : "fax",
"number" : "310 555-4567"
}
]
}
For some custom pretty printers, Jackson’s com.fasterxml.jackson.core.util.

MinimalPrettyPrinter class, which adds no indentation but implements everything
necessary for value output to work as expected, might be easier to use.
Factory, Parser, and Generator Features

JsonFactory, JsonFactory, and JsonGenerator instances can be customized by
enabling various features, which are constants declared by nested Feature enums.
JsonFactory.Feature offers the following factory-oriented features (check out the
Javadoc for descriptions):
• CANONICALIZE_FIELD_NAMES
• FAIL_ON_SYMBOL_HASH_OVERFLOW
• INTERN_FIELD_NAMES
• USE_THREAD_LOCAL_FOR_BUFFER_RECYCLING
JsonFactory provides four methods to enable, disable, and interrogate the state of
these features:
• JsonFactory configure(JsonFactory.Feature f, boolean state)

• JsonFactory disable(JsonFactory.Feature f)
• JsonFactory enable(JsonFactory.Feature f)
• boolean isEnabled(JsonFactory.Feature f)
398
JsonParser.Feature offers the following parser-oriented features (check out the

Javadoc for descriptions):
• ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER
• ALLOW_COMMENTS
• ALLOW_MISSING_VALUES
• ALLOW_NON_NUMERIC_NUMBERS
• ALLOW_NUMERIC_LEADING_ZEROS
• ALLOW_SINGLE_QUOTES
• ALLOW_TRAILING_COMMA
• ALLOW_UNQUOTED_CONTROL_CHARS
• ALLOW_UNQUOTED_FIELD_NAMES
• ALLOW_YAML_COMMENTS
• AUTO_CLOSE_SOURCE
• IGNORE_UNDEFINED
• INCLUDE_SOURCE_IN_LOCATION
• STRICT_DUPLICATE_DETECTION
JsonParser provides four methods to enable, disable, and interrogate the state of
these features:
• JsonParser configure(JsonParser.Feature f, boolean state)
• JsonParser disable(JsonParser.Feature f)
• JsonParser enable(JsonParser.Feature f)
• boolean isEnabled(JsonParser.Feature f)
JsonGenerator.Feature offers the following generator-oriented features (check out

the Javadoc for descriptions):
• AUTO_CLOSE_JSON_CONTENT
• AUTO_CLOSE_TARGET
• ESCAPE_NON_ASCII
399
• FLUSH_PASSED_TO_STREAM
• IGNORE_UNKNOWN
• QUOTE_FIELD_NAMES
• QUOTE_NON_NUMERIC_NUMBERS
• STRICT_DUPLICATE_DETECTION
• WRITE_BIGDECIMAL_AS_PLAIN
• WRITE_NUMBERS_AS_STRINGS
JsonGenerator provides four methods to enable, disable, and interrogate the state of
these features:
• JsonGenerator configure(JsonGenerator.Feature f, boolean

state)
• JsonGenerator disable(JsonGenerator.Feature f)
• JsonGenerator enable(JsonGenerator.Feature f)
• boolean isEnabled(JsonGenerator.Feature f)
Note For convenience, JsonFactory duplicates JsonParser’s and

JsonGenerator’s feature methods, which return, where applicable,
JsonFactory instead of JsonParser or JsonGenerator.
Finally, ObjectMapper supports the customization of its JsonParser and

JsonGenerator objects by providing the following convenience methods:
• ObjectMapper configure(JsonGenerator.Feature f, boolean

state)
• ObjectMapper configure(JsonParser.Feature f, boolean state)
• ObjectMapper disable(JsonGenerator.Feature... features)
• ObjectMapper disable(JsonParser.Feature... features)

• ObjectMapper enable(JsonGenerator.Feature... features)
• ObjectMapper enable(JsonParser.Feature... features)
400
• boolean isEnabled(JsonFactory.Feature f)
• boolean isEnabled(JsonGenerator.Feature f)
• boolean isEnabled(JsonParser.Feature f)
In Listing 11-14, I disabled JsonGenerator's AUTO_CLOSE_TARGET feature via an

ObjectMapper instance by using the following code fragment:
mapper.disable(JsonGenerator.Feature.AUTO_CLOSE_TARGET);
If you recall, I disabled this feature to prevent mapper.writeValue() from closing the
System.out stream.
EXERCISES
The following exercises are designed to test your understanding of Chapter 11’s content:
1. Define Jackson.
2. Identify Jackson’s packages.
3. True or false: Jackson supports only full data binding and POJO data binding.
4. How does streaming in Jackson work?
5. True or false: Streaming is the least efficient way to process JSON content.
6. How do you create a stream-based parser?
7. After you obtain a parser, how do use the parser to parse JSON content?
8. How do you create a stream-based generator?
9. After you obtain a generator, how do you use the generator to generate JSON
content?
10. True or false: The tree model provides a mutable in-memory tree representation
of a JSON document.
11. What class is used to start building a tree?
12. How do you read a JSON document into an in-memory tree?
13. What is the difference between JsonNode get(int index) and JsonNode
path(int index)?
401
14. How do you write a tree to a JSON document?
15. Define data binding in Jackson.
16. What is the purpose of the TypeReference class?
17. How does simple data binding differ from full data binding?
18. By default, how does Jackson map the fields of a JSON object to fields in a
Java object?
19. True or false: A getter method makes a non-public field serializable only.
20. List Jackson’s read-only annotation types.
21. What does the JsonPropertyOrder annotation type accomplish?
22. What’s the difference between a stateful and a stateless pretty printer class?
23. How do you prevent ObjectMapper’s writeValue() methods from closing

the System.out stream?
24. Modify Listing 11-3 so that numbers are written out as strings.
S
ummary
Jackson is a suite of data-processing tools for Java. These tools include a streaming
JSON parser/generator library, a matching data-binding library (for converting Plain
Old Java Objects—POJOs—to and from JSON), and additional data format modules for
processing data encoded in XML and other formats.
Jackson consists of core, databind, and annotations packages. The core package
supports a StAX-like streaming API for reading and writing JSON via sequences of
discrete events. The databind package supports a DOM-like tree model that provides a
mutable in-memory tree representation of a JSON document. The annotations package
provides public core annotation types, most of which are used to configure how data
binding (mapping) works.
The Jackson Core and Jackson Databind packages support the consumption and
creation of JSON documents. They offer various types related to streaming, the tree
model, and POJO-oriented data binding.
402
Jackson provides various advanced features, which focus largely on customization

in terms of annotation types; custom pretty printers; and factory, parser, and generator
features.
The annotation types influence how JSON is read into Java objects or what JSON is
generated from Java objects. Annotation types are read-only, write-only, or read-write.
Jackson supports pretty printers to improve the appearance of generated output
(making it easier to read). A custom pretty printer class implements the PrettyPrinter
interface.
JsonFactory, JsonParser, and JsonGenerator instances can be customized by
enabling various features, which are constants declared by nested Feature enums. Each
class provides configure(), enable(), disable(), and isEnabled() methods to enable/
disable a feature or learn if a feature is enabled.
Chapter 12 introduces JSON-P for parsing and generating JSON content.
403

Processing JSON With Jackson

Uploaded by

Copyright:

Available Formats

Processing JSON With Jackson

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Processing JSON With Jackson

Uploaded by

Copyright:

Available Formats

CHAPTER 11

• Jackson Databind: The databind package supports a DOM-like tree

• Jackson Annotations: The annotations package provides public core

Obtaining and Using Jackson

javac -cp jackson-core-2.9.7.jar;jackson-databind-2.9.7.jar;jackson-­

java -cp jackson-core-2.9.7.jar;jackson-databind-2.9.7.jar;jackson-­

Working with Jackson’s Basic Features

Streaming methods throw java.io.IOException when an I/O error occurs. When

Note Parsers can be created to parse content from external sources (such as

For example, JsonFactory’s JsonParser createParser(String content) method

String truckJSON = "{ \"brand\" : \"Ford F-150\",

Listing 11-1. Learning How to Use JsonParser and JsonToken

import static java.lang.System.*;

public class JacksonDemo

Listing 11-2. Describing a Person in JSON

"number": "310 555-1234"

Compile Listing 11-1 as follows:

javac -cp jackson-core-2.9.7.jar;jackson-databind-2.9.7.jar;jackson-­

Run the resulting application as follows:

java -cp jackson-core-2.9.7.jar;jackson-databind-2.9.7.jar;jackson-­

You should observe the following output:

jsonToken = START_OBJECT [{] [false] [null]

jsonToken = END_OBJECT [}] [false] [null]

Note Generators can be created to generate content to external destinations,

For example, JsonFactory’s JsonGenerator createGenerator(File file,

JsonFactory factory = new JsonFactory();

Listing 11-3. Learning How to Use JsonGenerator and Its Methods

import static java.lang.System.*;

public class JacksonDemo

writeStartObject() is paired with writeEndObject(), which writes the end-of-­

person.json successfully generated

The generated person.json file contains the following content:

ObjectMapper mapper = new ObjectMapper();

Reading a JSON Document into a Tree

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

• JsonNode get(int index): for arrays, returns child element at

• JsonNode get(String fieldName): for objects, returns fieldName’s

• JsonNode path(int index) and JsonNode path(String fieldName):

• JsonNode with(String propertyName) and JsonNode

Listing 11-4 presents the source code to an application that demonstrates

import static java.lang.System.*;

public class JacksonDemo

JsonNode phoneNumbers = rootNode.get("phoneNumbers");

"400 Some Street"

Creating a Tree and Writing It to a JSON Document

JsonNode’s ArrayNode and ObjectNode descendants also provide methods for

• ArrayNode provides several overloaded add() methods for appending

• ObjectNode provides several overloaded put() methods for updating

The void writeTree(JsonGenerator gen, JsonNode rootNode) method serializes

import static java.lang.System.*;

public class JacksonDemo

person.json successfully generated

<T> T readValue(File src, Class<T> valueType)

<T> T readValue(File src, TypeReference valueTypeRef)

writeValue(File resultFile, Object value)

Jackson supports simple data binding and full data binding.

Simple Data Binding

Table 11-1. Mapping JSON Types to Java Types

Obtaining and Using Jackson

javac -cp jackson-core-2.9.7.jar;jackson-databind-2.9.7.jar;jackson-

java -cp jackson-core-2.9.7.jar;jackson-databind-2.9.7.jar;jackson-

Working with Jackson’s Basic Features

javac -cp jackson-core-2.9.7.jar;jackson-databind-2.9.7.jar;jackson-

java -cp jackson-core-2.9.7.jar;jackson-databind-2.9.7.jar;jackson-

writeStartObject() is paired with writeEndObject(), which writes the end-of-

Reading a JSON Document into a Tree

Creating a Tree and Writing It to a JSON Document

Simple Data Binding

Full Data Binding

Working with Jackson’s Advanced Features

Read-Only Annotation Types