JSON Support in Jakarta EE: Present and Future

COPYRIGHT (C) 2019, ECLIPSE FOUNDATION, INC. | MADE AVAILABLE UNDER THE ECLIPSE PUBLIC LICENSE 2.0 (EPL-2.0) 1
JSON Support in Jakarta EE:
Present and Future
Dmitry Kornilov / Andy Guibert
10 Sep 2019

2COPYRIGHT (C) 2019, ECLIPSE FOUNDATION, INC. | MADE AVAILABLE UNDER THE ECLIPSE PUBLIC LICENSE 2.0 (EPL-2.0) 2
About Us
• Jakarta JSON Processing Project Lead
• Jakarta JSON Binding Project Lead
• Eclipse EE4J PMC Member
Dmitry Kornilov
(Oracle)
• Jakarta JSON Binding Project Lead
Andy Guibert
(IBM)

COPYRIGHT (C) 2019, ECLIPSE FOUNDATION, INC. | MADE AVAILABLE UNDER THE ECLIPSE PUBLIC LICENSE 2.0 (EPL-2.0)
AGENDA
3
Introduction
Jakarta JSON Processing
Jakarta JSON Binding
Plans

Safe Harbor Statement
The following is intended to outline our general product direction. It
is intended for information purposes only, and may not be
incorporated into any contract. It is not a commitment to deliver any
material, code, or functionality, and should not be relied upon in
making purchasing decisions. The development, release, and timing
of any features or functionality described for Oracle’s products
remains at the sole discretion of Oracle.

Introduction

What is JSON?
● JavaScript Object Notation
● Open standard (RFC 7159, 8259)
● Text based
● Language independent
● Nicely readable by humans
● Supported in most of languages
● Lightweight data interchange format
{
"firstName": "John",
"lastName": "Doe",
"age": 42,
"contacts": [
{
"type": "home",
"number": "123-456-789"
}
]
}

What is JSON?
● Primitive types:
○ String
○ Number
○ Boolean
● Structured types:
○ Array
○ Object
● Null
{
"lastName": "Doe",
"age": 42,
"registered": true,
"tags": null,
"contacts": [
{
"type": "home",
"number": "123-456-789"
}
]
}

JSON Support in Jakarta EE 8
● Jakarta JSON Processing API
○ Standard API to parse, generate, transform and query JSON
○ Object Model and Streaming API
■ similar to DOM and StAX
● Jakarta JSON Binding API
○ Binding JSON documents to Java objects
■ similar to JAXB

● Web Site
○ https://eclipse-ee4j.github.io/jsonp/
● Repository
○ https://github.com/eclipse-ee4j/jsonp
● Eclipse Project
○ https://projects.eclipse.org/projects/ee4j.jsonp
● Mailing List
○ https://accounts.eclipse.org/mailing-list/jsonp-dev

● Streaming API
○ Event based
○ Access to one element
○ Efficient for high volume of data
○ Small memory footprint
● Object Model API
○ In-memory tree
○ Random access to elements
○ Efficient for smaller documents
○ Big memory footprint

● Streaming API
○ JsonParser
○ JsonGenerator
● Object Model API
○ JsonReader
○ JsonWriter
○ JsonPointer
○ JsonPatch
○ JsonMergePatch

Streaming API

JsonParser
● JsonParser
○ Parses JSON in a streaming way from input sources
○ Similar to StAX’s XMLStreamReader
● Created using:
■ Json.createParser(…)
■ Json.createParserFactory().createParser(…)
● Optionally, configured with features
● Parser state events:
○ START_ARRAY, START_OBJECT, KEY_NAME, VALUE_STRING, VALUE_NUMBER,
VALUE_TRUE, VALUE_FALSE, VALUE_NULL, END_OBJECT, END_ARRAY

JsonParser
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT
KEY_NAME
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT
KEY_NAME
VALUE_STRING
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_NUMBER
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_NUMBER
KEY_NAME
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_NUMBER
KEY_NAME
START_ARRAY
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_NUMBER
KEY_NAME
START_ARRAY
START_OBJECT
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_NUMBER
KEY_NAME
START_ARRAY
START_OBJECT
KEY_NAME
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_NUMBER
KEY_NAME
START_ARRAY
START_OBJECT
KEY_NAME
VALUE_STRING
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_NUMBER
KEY_NAME
START_ARRAY
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_NUMBER
KEY_NAME
START_ARRAY
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_STRING
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_NUMBER
KEY_NAME
START_ARRAY
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_STRING
END_OBJECT
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_NUMBER
KEY_NAME
START_ARRAY
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_STRING
END_OBJECT
END_ARRAY
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_NUMBER
KEY_NAME
START_ARRAY
START_OBJECT
KEY_NAME
VALUE_STRING
KEY_NAME
VALUE_STRING
END_OBJECT
END_ARRAY
END_OBJECT
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonParser
JsonParser parser = Json.createParser(...);
Event e = parser.next(); // START_OBJECT
parser.next(); // KEY_NAME
parser.getString(); // name
parser.next(); // VALUE_STRING
parser.getString(); // John Doe
parser.next(); // KEY_NAME
parser.getString(); // age
parser.next(); // VALUE_NUMBER
parser.getInt(); // 42
{
"name":
”John Doe",
"age":
42,
”contacts":
[
{
"type":
"home",
"number":
"123-456-789"
}
]
}

JsonGenerator
● Generates JSON in a streaming way to output sources
● Similar to StAX’s XMLStreamWriter
● Created using:
○ Json.createGenerator(…)
○ Json.createGeneratorFactory().createGenerator(…)
● Optionally, configured with features
○ e.g. pretty printing
● Uses builder pattern

JsonGenerator
JsonGenerator g = Json.createGenerator(…);
g.writeStartArray()
.writeStartObject()
.write("type", "home”)
.write("number", "123-456-789")
.writeEnd()
.writeStartObject()
.write("type", "fax”)
.write("number", "123-456-790")
.writeEnd()
.writeEnd()
.close();
[
{
"type": "home”,
"number": "123-456-789"
},
{
"type": "fax”,
"number": "123-456-790"
}
]

Object Model API

Object Model API
● Builder to build JsonObject and JsonArray from scratch
● Type-safe (cannot mix array and object building methods)
● Can also use existing JsonObject and JsonArray in a builder

Object Model API
JsonArray value = Json.createArrayBuilder()
.add(Json.createObjectBuilder()
.add("type", "home")
.add("number", "123-456-789")
)
.add(Json.createObjectBuilder()
.add("type", "fax")
.add("number", "123-456-790")
)
.build();
[
{
"type": "home”,
"number": "123-456-789"
},
{
"type": "fax”,
"number": "123-456-790"
}
]

JsonPointer
● IETF RFC 6901
● String syntax for identifying a specific value
○ /phone/mobile
○ /parents/0
● Special characters
○ "/" —> "~1"
○ "~" —> "~0"

JsonPointer Sample
JsonArray customers = . . .;
JsonPointer pointer =
Json.createPointer("/1/lastName");
// Set new value
pointer.replace(customers,
Json.createValue(”Doe"));
// Get the value
JsonValue lastName =
pointer.getValue(customers); // Doe
[
{
"lastName": "Doe",
"age": 42
},
{
"firstName": "Jane",
"lastName": " ",
"age": 35
}
]

JsonPatch
● IETF RFC 6902
● Modify Parts of JSON document
● Patch is a JSON document itself
● Operations:
○ Add, replace, remove, move, copy, test
● HTTP PATCH method (application/json-patch+json)
[
{ "op": "replace",
"path": "/1/lastName",
"value": ”Doe" },
{ "op": "remove",
"path": "/2" }
]

JsonPatch Sample
[
{
"lastName": "Doe",
"age": 42
},
{
"lastName": "Doe",
"age": 35
},
{
"lastName": "Doe",
"age": 42
}
]
[
{ "op": "replace",
"value": ”Doe" },
{ "op": "remove",
"path": "/2" }
]

JsonPatch Sample
[
{ "op": "replace",
"value": "Doe" },
{ "op": "remove",
"path": "/2" }
]
// Create JsonPatch
JsonPatch patch = Json.createPatchBuilder()
.replace("/1/lastName", "Doe")
.remove("/2")
.build();
// Apply patch
patch.apply(list);
// Read patch JSON
JsonArray patchData =
Json.createReader(…).readArray();
// Create patch
JsonPatch patch = Json.createPatch(patchData);
// Apply patch
patch.apply(list);
or

JsonMergePatch
● IETF RFC 7396
● HTTP PATCH
"application/merge-patch+json"
● Patch is a JSON document itself
● Syntax closely mimics the document
○ Git like merge experience
// Read patch JSON
JsonObject patchData =
Json.createReader(…).readArray();
// Create patch
JsonMergePatch mergePatch =
Json.createMergePatch(patchData);
// Apply patch
mergePatch.apply(applyTo);

JsonMergePatch
{
"lastName": "Doe",
"age": 42
}
{
"lastName": " ",
"address": " "
}
{
"lastName": ”Doe",
"age": 42,
"address": null
}
Source
Patch
Result

● API to serialize/deserialize Java objects to/from JSON documents
○ Similar to JAX-B, except with JSON instead of XML
○ Standardizes features of the current technologies (Jackson, Genson, Gson)
● Easily convert between Java classes and JSON data with convenient default settings
● Customization APIs
○ Annotations (@JsonbProperty, @JsonbNillable)
○ Runtime configuration builder
● Natural follow on to JSON-P
○ Closes the JSON support gap
○ Allows to use different JSONP providers

● Web Site
○ https://eclipse-ee4j.github.io/jsonb-api/
● Repository
○ https://github.com/eclipse-ee4j/jsonb-api
● Eclipse Project
○ https://projects.eclipse.org/projects/ee4j.jsonb
● Mailing List
○ https://accounts.eclipse.org/mailing-list/jsonb-dev

Default Mapping

Default Mapping
● No configuration, no annotations
● The scope:
○ Basic Types
○ Specific JDK Types
○ Dates
○ Classes
○ Collections/Arrays
○ Enumerations
○ JSON-P model classes
import javax.json.bind.Jsonb;
import javax.json.bind.JsonbBuilder;
// Create with default config
// Cache it!
Jsonb jsonb = JsonbBuilder.create();

JSON-B Engine
public interface Jsonb extends AutoCloseable {
<T> T fromJson(String str, Class<T> type);
<T> T fromJson(String str, Type runtimeType);
<T> T fromJson(Reader reader, Class<T> type);
<T> T fromJson(Reader reader, Type runtimeType);
<T> T fromJson(InputStream stream, Class<T> type);
<T> T fromJson(InputStream stream, Type runtimeType);
String toJson(Object object);
String toJson(Object object, Type runtimeType);
void toJson(Object object, Writer writer);
void toJson(Object object, Type runtimeType, Writer writer);
void toJson(Object object, OutputStream stream);
void toJson(Object object, Type runtimeType, OutputStream stream);
}

JSON-B Sample
Person person1 = new Person();
person1.setFirstName("John");
person1.setLastName(”Doe");
person1.setAge(42);
Person person2 = new Person();
person2.setFirstName("Jane");
person2.setLastName(”Doe");
person2.setAge(35);
List<Person> persons = new ArrayList<>();
persons.add(person1);
persons.add(person2);
Jsonb jsonb = JsonbBuilder.create();
jsonb.toJson(persons);
[
{
"lastName": "Doe",
"age": 42
},
{
"lastName": "Doe",
"age": 35
}
]

Basic and Specific Types
Basic Types
○ java.lang.String
○ java.lang.Character
○ java.lang.Byte (byte)
○ java.lang.Short (short)
○ java.lang.Integer (int)
○ java.lang.Long (long)
○ java.lang.Float (float)
○ java.lang.Double (double)
○ java.lang.Boolean (boolean)
Specific Types
○ java.math.BigInteger
○ java.math.BigDecimal
○ java.net.URL
○ java.net.URI
○ java.util.Optional
○ java.util.OptionalInt
○ java.util.OptionalLong
○ java.util.OptionalDouble

53COPYRIGHT (C) 2019, ECLIPSE FOUNDATION, INC. | MADE AVAILABLE UNDER THE ECLIPSE PUBLIC LICENSE 2.0 (EPL-2.0)
java.util.Date ISO_DATE_TIME
java.util.Calendar, java.util.GregorianCalendar ISO_DATE if to time information present, otherwise ISO_DATE_TIME
Java.util.TimeZone, java.util.SimpleTimeZone NormalizedCustomId (see TimeZone javadoc)
java.time.Instant ISO_INSTANT
java.time.LocalDate ISO_LOCAL_DATE
java.time.LocalTime ISO_LOCAL_TIME
java.time.LocalDateTime ISO_LOCAL_DATE_TIME
java.time.ZonedDateTime ISO_ZONED_DATE_TIME
java.time.OffsetDateTime ISO_OFFSET_DATE_TIME
java.time.OffsetTime ISO_OFFSET_TIME
java.time.ZoneId NormalizedZoneId as specified in ZoneId javadoc
java.time.ZoneOffset NormalizedZoneId as specified in ZoneOffset javadoc
java.time.Duration ISO 8601 seconds based representation
java.time.Period ISO 8601 period representation
53
Date / Time

Data / Time Samples
// java.util.Date
SimpleDateFormat sdf = new SimpleDateFormat("dd.MM.yyyy");
Date parsedDate = sdf.parse("10.09.2019");
jsonb.toJson(parsedDate)); // ”2019-09-10T00:00:00"
// java.util.Calendar
Calendar dateCalendar = Calendar.getInstance();
dateCalendar.clear();
dateCalendar.set(2019, 9, 10);
jsonb.toJson(dateCalendar); // ”2019-09-10”
// java.time.Instant
jsonb.toJson(Instant.parse("2019-09-10T23:00:00Z")); // ”2019-09-10T23:00:00Z”
// java.time.Duration
jsonb.toJson(Duration.ofHours(5).plusMinutes(4)); // “PT5H4M"
// java.time.Period
jsonb.toJson(Period.between(
LocalDate.of(1960, Month.JANUARY, 1),
LocalDate.of(1970, Month.JANUARY, 1))); // "P10Y"

Arrays / Collections
● Collection
● Map
● Set
● HashSet
● NavigableSet
● SortedSet
● TreeSet
● LinkedHashSet
● TreeHashSet
● HashMap
● NavigableMap
● SortedMap
● TreeMap
● LinkedHashMap
● TreeHashMap
● List
● ArrayList
● LinkedList
● Deque
● ArrayDeque
● Queue
● PriorityQueue
● EnumSet (JSONB.next)
● EnumMap (JSONB.next)

JSON-P Types
● JsonValue
● JsonPointer
● JsonString
● JsonNumber
● JsonObject
● JsonArray
● JsonStructure
// JsonObject
JsonBuilderFactory f =
Json.createBuilderFactory(null);
JsonObject jsonObject =
f.createObjectBuilder()
.add(“firstName", "John")
.add(“lastName", "Doe")
.build();
String json = jsonb.toJson(jsonObject);

Classes
● Public and protected nested and static nested classes
● Anonymous classes (serialization only)
● Inheritance is supported
● Default no-argument constructor is required for default deserialization

Fields
● Final fields are serialized
● Static fields are skipped
● Transient fields are skipped
● Null fields are skipped
● Fields order
○ Lexicographical (A-Z) order
○ Parent class fields are serialized before child class fields

Field Order Sample
public class Parent {
public int parentB;
public int parentA;
}
{
"parentA": 1,
"parentB": 2
}

Field Order Sample
public class Parent {
public int parentB;
public int parentA;
}
public class Child extends Parent {
public int childB;
public int childA;
}
{
"parentA": 1,
"parentB": 2
}
{
"parentA": 1,
"parentB": 2,
"childA": 3,
"childB": 4
}

Scope and Field Access Strategy
Serialization
● Existing fields with public getters
● Public fields with no getters
● Public getter/setter pair without a
corresponding field
Deserialization
● Existing fields with public setters
● Public fields with no setters
● Public getter/setter pair without a
corresponding field

Scope and Field Access Strategy
{
"publicFinalField": 1,
"publicWithNoGetter": 1,
"privateWithPublicGetter": 1,
"noField": 1
}
public class Foo {
public final int publicFinalField;
private final int privateFinalField;
public static int publicStaticField;
public int publicWithNoGetter;
public int publicWithPrivateGetter;
public Integer publicNullField = null;
private int privateWithNoGetter;
private int privateWithPublicGetter;
public int getNoField() {};
public void setNoField(int value) {};
}

Customized Mapping

JSON-B Engine Configuration
● Annotations
● Runtime configuration
○ JsonbConfig
○ JsonbBuilder
JsonbConfig config = new JsonbConfig()
.withFormatting(…)
.withNullValues(…)
.withEncoding(…)
.withStrictIJSON(…)
.withPropertyNamingStrategy(…)
.withPropertyOrderStrategy(…)
.withPropertyVisibilityStrategy(…)
.withAdapters(…)
.withBinaryDataStrategy(…);
Jsonb jsonb = JsonbBuilder.newBuilder()
.withConfig(…)
.withProvider(…)
.build();

Customizations
● Property names
● Property order
● Ignoring properties
● Null handling
● Custom instantiation
● Property visibility
● Date/Number Formats
● Binary Encoding
● Adapters
● Serializers/Deserializers

Property Names
● Annotation
○ @JsonbProperty
● Scope:
○ Field
○ Getter/Setter
○ Parameter
public class Customer {
public int id;
@JsonbProperty("name")
public String firstName;
}
public int id;
private String firstName;
@JsonbProperty("name")
public String getFirstName() {
return firstName;
}
}

Property Naming Strategy
● Globally changes the way of naming properties
● Supported a set of predefined strategies (see next slide)
○ JsonbConfig. withPropertyNamingStrategy(String strategyName)
● Ability to write your own strategy
○ Implement PropertyNamingStrategy interface
○ JsonbConfig. withPropertyNamingStrategy(PropertyNamingStrategy name);

Predefined Property Naming Strategies
Strategy Name Sample
IDENTITY (default) myProperty → myProperty
LOWER_CASE_WITH_DASHES myProperty → my-property
LOWER_CASE_WITH_UNDERSCORES myProperty → my_property
UPPER_CAMEL_CASE myProperty → MyProperty
UPPER_CAMEL_CASE_WITH_SPACES myProperty → "My Property"
CASE_INSENSITIVE the same as IDENTITY but ignores case on
deserialization
Custom Strategy Custom case conversion login

Property Order Strategy
● Strategies:
○ LEXICOGRAPHICAL (A-Z)
○ ANY
○ REVERSE (Z-A)
● Annotation
○ @JsonbPropertyOrder on class
● JsonbConfig
○ withPropertyOrderStrategy(…)
@JsonbPropertyOrder(ANY)
public class Foo {
public int bar2;
public int bar1;
}

Ignoring Properties
● Annotation
○ @JsonbTransient
public class Foo {
public int bar2;
@JsonbTransient
public int bar1;
}

Property Visibility
● PropertyVisibilityStrategy interface
● Annotation
○ @JsonbVisibility
● JsonbConfig
○ withPropertyVisibilityStrategy(…)
public interface PropertyVisibilityStrategy {
boolean isVisible(Field field);
boolean isVisible(Method method);
}
public class MyStrategy implements
PropertyVisibilityStrategy {
/* ... */
}
@JsonbVisibility(MyStrategy.class)
public class Bar {
private int field1;
private int field2;
}

Null Handling
● Null fields are skipped by default
● Annotation
○ @JsonbNillable
● JsonbConfig
○ withNullValues(true)
public int id = 1;
@JsonbProperty(nillable=true)
public String name = null;
}
@JsonbNillable
public int id = 1;
public String name = null;
}

Custom Instantiation
public class Order {
public int id;
public Customer customer;
}
...
@JsonbCreator
public static Customer getFromDb(
@JsonbProperty int id) {
return CustomerDao.getByPrimaryKey(id);
}
}
{
"id": 123,
"customer": {
"id": 562,
}
}
● Use @JsonbCreator when a class does
not have a default (no-args) constructor
● At most one @JsonbCreator can be used
per class
● Can be used on a constructor or static
creator method

Date / Number Format
● Annotations
○ @JsonbDateFormat
○ @JsonbNumberFormat
● JsonbConfig
○ withDateFormat(…)
○ withLocale(…)
public class FormatSample {
public Date defaultDate;
@JsonbDateFormat("dd.MM.yyyy")
public Date formattedDate;
public BigDecimal defaultNumber;
@JsonbNumberFormat(“#0.00")
public BigDecimal formattedNumber;
}

Binary Data Encoding
● Supported encodings
○ BYTE (default)
○ BASE_64
○ BASE_64_URL
● JsonbConfig
○ withBinaryDataStrategy(…)
.withBinaryDataStrategy(
BinaryDataStrategy.BASE_64);
Jsonb jsonb = JsonbBuilder.create(config);
String json = jsonb.toJson(obj);

I-JSON
● I-JSON (”Internet JSON”) is a restricted profile of JSON
○ https://tools.ietf.org/html/draft-ietf-json-i-json-06
● JSON-B fully supports I-JSON by default with three exceptions:
○ JSON Binding does not restrict the serialization of top-level JSON texts that are
neither objects nor arrays. The restriction should happen at application level.
○ JSON Binding does not serialize binary data with base64url encoding.
○ JSON Binding does not enforce additional restrictions on dates/times/duration.
● JsonbConfig
○ withStrictIJSON(true)

Adapters
● Inspired by JAXB
● Annotations
○ @JsonbTypeAdapter annotation
● JsonbConfig
○ withAdapters(…)
public interface
JsonbAdapter<Original, Adapted> {
Adapted adaptToJson(Original obj);
Original adaptFromJson(Adapted obj);
}
@JsonbTypeAdapter(AnimalAdapter.class)
public Animal animal;
.withAdapters(new AnimalAdapter());

Adapters
● Inspired by JAXB
● Annotations
○ @JsonbTypeAdapter annotation
● JsonbConfig
○ withAdapters(…)
public interface
JsonbAdapter<Original, Adapted> {
Adapted adaptToJson(Original obj);
Original adaptFromJson(Adapted obj);
}
@JsonbTypeAdapter(AnimalAdapter.class)
.withAdapters(new AnimalAdapter());

Serializers / Deserializers
● Low level control on
serialization/deserialization
● Annotations
○ @JsonbTypeSerializer
○ @JsonbTypeDeserializer
● JsonbConfig
○ withSerializers(…)
○ withDeserializers(…)
public interface JsonbSerializer<T> {
void serialize(T obj,
JsonGenerator generator,
SerializationContext ctx);
public interface JsonbDeserializer<T> {
T deserialize(JsonParser parser,
DeserializationContext ctx,
Type rtType);
}
@JsonbTypeSerializer(AnimalSerializer.class)
@JsonbTypeDeserializer(AnimalDeserializer.class)
.withSerializers(new AnimalSerializer())
.withDeserializers(new AnimalDeserializer());

Plans

Future JSON-B Plans
● Larger features
○ Customize 3rd party classes (jsonb-api #88)
○ Polymorphic [De]serialization (jsonb-api #147)
○ Map directly to/from JsonGenerator and JsonParser (jsonb-api #122)
● Smaller features
○ Using @JsonbCreator with absent/optional fields (jsonb-api #121)
○ Configurable interface  impl mappings (jsonb-api #65)
○ Automatically register Adapters/[De]Serializers (jsonb-api #35)
○ Opt out of the “must ignore” policy (jsonb-api #56)
○ Customize date formats of different types (jsonb-api #87)

Customizing 3rd party classes
● Be able to customize classes you cannot modify
● Similar use-case as Jackson mix-ins
// Cannot modify this class
// Comes from 3rd party dependency
public class Dog {
// @JsonbProperty(“dogName”)
public String name;
public int age;
// @JsonbTransient
public Owner owner;
}
ClassCustomization c = ClassCustomization.for(Dog.class)
.property(”name”, ”dogName”)
.transient(”owner”)
// The ”age” property not mentioned, so it is left as-is
.build();
.withClassCustomization(c);

Polymorphic [de]serialization
● Allows for properties in the JSON data to be
used to determine the Java deserialization class
● Highly requested feature, but security sensitive
PolymorphicConfig poly = PolymorphicConfig.builder()
.withClasses(Dog.class, Cat.class)
.withTypeAttribute(”jsonb_class”); // optional
.withPolymorphicConfig(poly);
{
”jsonb_class": ”com.foo.Dog”
”name": ”Spot”
”bites": false
}
{
”jsonb_class": ”com.foo.Cat”
”name": ”Princess”
”meows": true
}

Custom constructors with absent parameters
● JSON-B classes can have at most 1
@JsonbCreator annotated constructor
● Object might need to be constructed without
some properties present
● Particularly useful for immutable data objects
public class Person {
public final String firstName;
public final String middleName;
public final String lastName;
@JsonbCreator
public Person(
@JsonbCreator(”firstName”) String first,
@JsonbCreator(”middleName”) String mid,
@JsonbCreator(”lastName”) String last) {
this.firstName = first;
this.middleName = mid;
this.lastName = last;
}
}{
"lastName": "Doe"
}

Automatically register Adapters and [De]Serializers
● Add new annotations to automatically
register JsonbAdapter, JsonbSerializer, and
JsonbDeserializer when CDI is present
● No need to manually register objects with
JsonbConfig
@RegisterJsonbAdapter
public class PersonAdapter implements
JsonbAdapter<Person, Map<String,Object>> {
// ...
}
.withAdapters(new PersonAdapter());

Opt-out of the ”Must-Ignore” policy
● By default JSON-B will ignore unrecognized
properties on deserialization
● Provide way to opt-out so an error is raised
if unrecognized properties are encountered
{
”first": "Jane",
”last": "Doe"
}
.withAllowUnrecognized(false);
// ...
// Fails with JsonbException because
// ‘first’ and ‘last’ properties not recognized
Person p = jsonb.fromJson(json, Person.class)
public class Person {
public String firstName;
public String middleName;
public String lastName;
}

Future JSON-B Plans
● See Github project board for complete overview and up-to-date information
https://github.com/eclipse-ee4j/jsonb-api/projects/1

Thank you!

JSON Support in Jakarta EE: Present and Future

Recommended

Recommended

More Related Content

Similar to JSON Support in Jakarta EE: Present and Future

Similar to JSON Support in Jakarta EE: Present and Future (20)

More from Dmitry Kornilov

More from Dmitry Kornilov (16)

Recently uploaded

Recently uploaded (20)

JSON Support in Jakarta EE: Present and Future