JsonNode
), as well as
writing Java Objects and trees as JSON.See: Description
Interface | Description |
---|---|
BeanProperty |
Bean properties are logical entities that represent data
that Java objects (POJOs (Plain Old Java Objects), sometimes also called "beans")
contain; and that are accessed using accessors (methods like getters
and setters, fields, constructor parameters).
|
JsonSerializable |
Interface that can be implemented by objects that know how to
serialize themselves to JSON, using
JsonGenerator
(and SerializerProvider if necessary). |
Module.SetupContext |
Interface Jackson exposes to modules for purpose of registering
extended functionality.
|
Class | Description |
---|---|
AbstractTypeResolver |
Defines interface for resolvers that can resolve abstract types into concrete
ones; either by using static mappings, or possibly by materializing
implementations dynamically.
|
AnnotationIntrospector |
Abstract class that defines API used for introspecting annotation-based
configuration for serialization and deserialization.
|
AnnotationIntrospector.ReferenceProperty |
Value type used with managed and back references; contains type and
logic name, used to link related references
|
BeanDescription |
Basic container for information gathered by
ClassIntrospector to
help in constructing serializers and deserializers. |
BeanProperty.Bogus |
Alternative "Null" implementation that can be used in cases where a non-null
BeanProperty is needed |
BeanProperty.Std |
Simple stand-alone implementation, useful as a placeholder
or base class for more complex implementations.
|
DatabindContext |
Shared base class for
DeserializationContext and
SerializerProvider , context objects passed through data-binding
process. |
DeserializationConfig |
Object that contains baseline configuration for deserialization
process.
|
DeserializationContext |
Context for the process of deserialization a single root-level value.
|
InjectableValues |
Abstract class that defines API for objects that provide value to
"inject" during deserialization.
|
InjectableValues.Std |
Simple standard implementation which uses a simple Map to
store values to inject, identified by simple String keys.
|
JavaType |
Base class for type token classes used both to contain information
and as keys for deserializers.
|
JsonDeserializer<T> |
Abstract class that defines API used by
ObjectMapper (and
other chained JsonDeserializer s too) to deserialize Objects of
arbitrary types from JSON, using provided JsonParser . |
JsonDeserializer.None |
This marker class is only to be used with annotations, to
indicate that no deserializer is configured.
|
JsonMappingException.Reference |
Simple bean class used to contain references.
|
JsonNode |
Base class for all JSON nodes, which form the basis of JSON
Tree Model that Jackson implements.
|
JsonSerializable.Base |
Base class with minimal implementation, as well as couple of extension methods
that core Jackson databinding makes use of.
|
JsonSerializer<T> |
Abstract class that defines API used by
ObjectMapper (and
other chained JsonSerializer s too) to serialize Objects of
arbitrary types into JSON, using provided JsonGenerator . |
JsonSerializer.None |
This marker class is only to be used with annotations, to
indicate that no serializer is configured.
|
KeyDeserializer |
Abstract class that defines API used for deserializing JSON content
field names into Java Map keys.
|
KeyDeserializer.None |
This marker class is only to be used with annotations, to
indicate that no deserializer is configured.
|
MappingIterator<T> |
Iterator exposed by
ObjectMapper when binding sequence of
objects. |
MappingJsonFactory |
Sub-class of
JsonFactory that will create a proper
ObjectCodec to allow seam-less conversions between
JSON content and Java objects (POJOs). |
Module |
Simple interface for extensions that can be registered with
ObjectMapper
to provide a well-defined set of extensions to default functionality; such as
support for new data types. |
ObjectMapper |
ObjectMapper provides functionality for reading and writing JSON,
either to and from basic POJOs (Plain Old Java Objects), or to and from
a general-purpose JSON Tree Model (
JsonNode ), as well as
related functionality for performing conversions. |
ObjectMapper.DefaultTypeResolverBuilder |
Customized
TypeResolverBuilder that provides type resolver builders
used with so-called "default typing"
(see ObjectMapper.activateDefaultTyping(PolymorphicTypeValidator) for details). |
ObjectReader |
Builder object that can be used for per-serialization configuration of
deserialization parameters, such as root type to use or object
to update (instead of constructing new instance).
|
ObjectWriter |
Builder object that can be used for per-serialization configuration of
serialization parameters, such as JSON View and root type to use.
|
ObjectWriter.GeneratorSettings |
Helper class used for containing settings specifically related
to (re)configuring
JsonGenerator constructed for
writing output. |
ObjectWriter.Prefetch |
As a minor optimization, we will make an effort to pre-fetch a serializer,
or at least relevant
TypeSerializer , if given enough
information. |
PropertyMetadata |
Simple container class used for storing "additional" metadata about
properties.
|
PropertyMetadata.MergeInfo |
Helper class used for containing information about expected merge
information for this property, if merging is expected.
|
PropertyName |
Simple value class used for containing names of properties as defined
by annotations (and possibly other configuration sources).
|
PropertyNamingStrategies |
Container for standard
PropertyNamingStrategy implementations
and singleton instances. |
PropertyNamingStrategies.KebabCaseStrategy |
Naming strategy similar to
PropertyNamingStrategies.SnakeCaseStrategy ,
but instead of underscores
as separators, uses hyphens. |
PropertyNamingStrategies.LowerCamelCaseStrategy |
"No-operation" strategy that is equivalent to not specifying any
strategy: will simply return suggested standard bean naming as-is.
|
PropertyNamingStrategies.LowerCaseStrategy |
Simple strategy where external name simply only uses lower-case characters,
and no separators.
|
PropertyNamingStrategies.LowerDotCaseStrategy |
Naming strategy similar to
PropertyNamingStrategies.KebabCaseStrategy ,
but instead of hyphens
as separators, uses dots. |
PropertyNamingStrategies.NamingBase |
Intermediate base class for simple implementations
|
PropertyNamingStrategies.SnakeCaseStrategy |
A
PropertyNamingStrategy that translates typical camel case Java
property names to lower case JSON element names, separated by
underscores. |
PropertyNamingStrategies.UpperCamelCaseStrategy |
A
PropertyNamingStrategy that translates typical camelCase Java
property names to PascalCase JSON element names (i.e., with a capital
first letter). |
PropertyNamingStrategy |
Class that defines how names of JSON properties ("external names")
are derived from names of POJO methods and fields ("internal names"),
in cases where no explicit annotations exist for naming.
|
PropertyNamingStrategy.KebabCaseStrategy | Deprecated
Since 2.12 use
PropertyNamingStrategies.KebabCaseStrategy instead
(see
databind#2715
for reason for deprecation) |
PropertyNamingStrategy.LowerCaseStrategy | Deprecated
Since 2.12 use
PropertyNamingStrategies.LowerCaseStrategy instead
(see
databind#2715
for reason for deprecation) |
PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy | Deprecated
In 2.7 use
PropertyNamingStrategies.SnakeCaseStrategy instead |
PropertyNamingStrategy.LowerDotCaseStrategy | Deprecated
Since 2.12 use
PropertyNamingStrategies.LowerDotCaseStrategy instead
(see
databind#2715
for reason for deprecation) |
PropertyNamingStrategy.PascalCaseStrategy | Deprecated
In 2.7 use
PropertyNamingStrategies.UpperCamelCaseStrategy instead |
PropertyNamingStrategy.PropertyNamingStrategyBase | Deprecated
Since 2.12 deprecated.
|
PropertyNamingStrategy.SnakeCaseStrategy | Deprecated
Since 2.12 use
PropertyNamingStrategies.SnakeCaseStrategy instead
(see
databind#2715
for reason for deprecation) |
PropertyNamingStrategy.UpperCamelCaseStrategy | Deprecated
Since 2.12 use
PropertyNamingStrategies.UpperCamelCaseStrategy instead
(see
databind#2715
for reason for deprecation) |
SequenceWriter |
Writer class similar to
ObjectWriter , except that it can be used
for writing sequences of values, not just a single value. |
SerializationConfig |
Object that contains baseline configuration for serialization
process.
|
SerializerProvider |
Class that defines API used by
ObjectMapper and
JsonSerializer s to obtain serializers capable of serializing
instances of specific types; as well as the default implementation
of the functionality. |
Enum | Description |
---|---|
AnnotationIntrospector.ReferenceProperty.Type | |
DeserializationFeature |
Enumeration that defines simple on/off features that affect
the way Java objects are deserialized from JSON
|
MapperFeature |
Enumeration that defines simple on/off features to set
for
ObjectMapper , and accessible (but not changeable)
via ObjectReader and ObjectWriter (as well as
through various convenience methods through context objects). |
ObjectMapper.DefaultTyping |
Enumeration used with
ObjectMapper.activateDefaultTyping(PolymorphicTypeValidator)
to specify what kind of types (classes) default typing should
be used for. |
SerializationFeature |
Enumeration that defines simple on/off features that affect
the way Java objects are serialized.
|
Exception | Description |
---|---|
JsonMappingException |
Checked exception used to signal fatal problems with mapping of
content, distinct from low-level I/O problems (signaled using
simple
IOException s) or data encoding/decoding
problems (signaled with JsonParseException ,
JsonGenerationException ). |
RuntimeJsonMappingException |
Wrapper used when interface does not allow throwing a checked
JsonMappingException |
JsonNode
), as well as
writing Java Objects and trees as JSON.
Reading and writing (as well as related additional functionality) is accessed through
ObjectMapper
,
ObjectReader
and
ObjectWriter
classes.
In addition to reading and writing JSON content, it is also possible to use the
general databinding functionality for many other data formats, using
Jackson extension modules that provide such support: if so, you typically
simply construct an ObjectMapper
with
different underlying streaming parser, generator implementation.
The main starting point for operations is ObjectMapper
,
which can be used either directly (via multiple overloaded
readValue
,
readTree
,
writeValue
and
writeTree
methods, or it can be used as a configurable factory for constructing
fully immutable, thread-safe and reusable ObjectReader
and ObjectWriter
objects.
In addition to simple reading and writing of JSON as POJOs or JSON trees (represented as
JsonNode
, and configurability needed to change aspects
of reading/writing, mapper contains additional functionality such as:
ObjectMapper.convertValue(Object, Class)
,
ObjectMapper.valueToTree(Object)
and
ObjectMapper.treeToValue(com.fasterxml.jackson.core.TreeNode, Class)
methods.
ObjectMapper.acceptJsonFormatVisitor(Class, com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper)
(note: actual handles are usually provided by various Jackson modules: mapper simply initiates calling of
callbacks, based on serializers registered)
Simplest usage is of form:
final ObjectMapper mapper = new ObjectMapper(); // can use static singleton, inject: just make sure to reuse!
MyValue value = new MyValue();
// ... and configure
File newState = new File("my-stuff.json");
mapper.writeValue(newState, value); // writes JSON serialization of MyValue instance
// or, read
MyValue older = mapper.readValue(new File("my-older-stuff.json"), MyValue.class);
// Or if you prefer JSON Tree representation:
JsonNode root = mapper.readTree(newState);
// and find values by, for example, using a JsonPointer
expression:
int age = root.at("/personal/age").getValueAsInt();
For more usage, refer to
ObjectMapper
,
ObjectReader
and
ObjectWriter
Javadocs.
Copyright © 2021 JBoss by Red Hat. All rights reserved.