ObjectMapper
class, as well
as convenience methods included in
JsonParser
See: Description
Interface | Description |
---|---|
BeanProperty |
Bean properties are logical entities that represent data
Java objects ("beans", although more accurately POJOs)
contain; and that are accessed using some combination
of methods (getter, setter), field and constructor
parameter.
|
ClassIntrospector.MixInResolver |
Interface used for decoupling details of how mix-in annotation
definitions are accessed (via this interface), and how
they are stored (defined by classes that implement the interface)
|
ContextualDeserializer<T> |
Add-on interface that
JsonDeserializer s can implement to get a callback
that can be used to create contextual instances of deserializer to use for
handling properties of supported type. |
ContextualKeyDeserializer |
Add-on interface that
KeyDeserializer s can implement to get a callback
that can be used to create contextual instances of key deserializer to use for
handling Map keys of supported type. |
ContextualSerializer<T> |
Add-on interface that
JsonSerializer s can implement to get a callback
that can be used to create contextual instances of serializer to use for
handling properties of supported type. |
Deserializers |
Interface that defines API for simple extensions that can provide additional deserializers
for various types.
|
JsonSerializable | Deprecated |
JsonSerializableWithType |
Interface that is to replace
JsonSerializable to
allow for dynamic type information embedding. |
KeyDeserializers |
Interface that defines API for simple extensions that can provide additional deserializers
for deserializer Map keys of various types, from JSON property names.
|
MapperConfig.ConfigFeature |
Interface that actual Feature enumerations used by
MapperConfig implementations must implement. |
Module.SetupContext |
Interface Jackson exposes to modules for purpose of registering
extended functionality.
|
ResolvableDeserializer |
Interface used to indicate deserializers that want to do post-processing
after construction and being added to
DeserializerProvider ,
but before being used. |
ResolvableSerializer |
Interface used to indicate serializers that want to do post-processing
after construction and being added to
SerializerProvider ,
but before being used. |
Serializers |
Interface that defines API for simple extensions that can provide additional serializers
for various types.
|
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.Pair |
Helper class that allows using 2 introspectors such that one
introspector acts as the primary one to use; and second one
as a fallback used if the primary does not provide conclusive
or useful result for a method.
|
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.Std | |
BeanPropertyDefinition |
Simple value classes that contain definitions of properties,
used during introspection of properties to use for
serialization and deserialization purposes.
|
ClassIntrospector<T extends BeanDescription> |
Helper class used to introspect features of POJO value classes
used with Jackson.
|
DeserializationConfig |
Object that contains baseline configuration for deserialization
process.
|
DeserializationContext |
Context for deserialization process.
|
DeserializationProblemHandler |
This is the class that can be registered (via
DeserializationConfig object owner by
ObjectMapper ) to get calledn when a potentially
recoverable problem is encountered during deserialization
process. |
DeserializerFactory |
Abstract class that defines API used by
DeserializerProvider
to obtain actual
JsonDeserializer instances from multiple distinct factories. |
DeserializerFactory.Config |
Configuration settings container class for bean deserializer factory
|
DeserializerProvider |
Abstract class that defines API used by
ObjectMapper and
JsonDeserializer s to obtain deserializers capable of
re-constructing instances of handled type from JSON content. |
Deserializers.Base |
Basic
Deserializers implementation that implements all methods but provides
no deserializers. |
Deserializers.None | Deprecated
As of 1.9, use
Deserializers.Base instead |
HandlerInstantiator |
Helper class used for handling details of creating handler instances (things
like
JsonSerializer s, JsonDeserializer s, various type
handlers) of specific types. |
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.
|
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.
|
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.
|
MapperConfig<T extends MapperConfig<T>> |
Interface that defines functionality accessible through both
serialization and deserialization configuration objects;
accessors to mode-independent configuration settings
and such.
|
MapperConfig.Base |
Immutable container class used to store simple configuration
settings.
|
MappingIterator<T> |
Iterator exposed by
ObjectMapper when binding sequence of
objects. |
MappingJsonFactory |
Sub-class of
JsonFactory that will create a proper
ObjectCodec to allow seamless 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 |
This mapper (or, data binder, or codec) provides functionality for
converting between Java objects (instances of JDK provided core classes,
beans), and matching JSON constructs.
|
ObjectMapper.DefaultTypeResolverBuilder |
Customized
TypeResolverBuilder that provides type resolver builders
used with so-called "default typing"
(see ObjectMapper.enableDefaultTyping() 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.
|
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 they are not
auto-detected and no explicit annotations exist for naming.
|
PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy |
A
PropertyNamingStrategy that translates typical camel case Java
property names to lower case JSON element names, separated by
underscores. |
PropertyNamingStrategy.PropertyNamingStrategyBase | |
SerializationConfig |
Object that contains baseline configuration for serialization
process.
|
SerializerFactory |
Abstract class that defines API used by
SerializerProvider
to obtain actual
JsonSerializer instances from multiple distinct factories. |
SerializerFactory.Config |
Configuration settings container class for bean serializer factory.
|
SerializerProvider |
Abstract class that defines API used by
ObjectMapper and
JsonSerializer s to obtain serializers capable of serializing
instances of specific types. |
Serializers.Base |
Basic
Serializers implementation that implements all methods but provides
no serializers. |
Serializers.None | Deprecated
As of 1.9, use
Serializers.Base instead |
TypeDeserializer |
Interface for deserializing type information from JSON content, to
type-safely deserialize data into correct polymorphic instance
(when type inclusion has been enabled for type handled).
|
TypeSerializer |
Interface for serializing type information regarding instances of specified
base type (super class), so that exact subtype can be properly deserialized
later on.
|
Enum | Description |
---|---|
AnnotationIntrospector.ReferenceProperty.Type | |
DeserializationConfig.Feature |
Enumeration that defines togglable features that guide
the serialization feature.
|
ObjectMapper.DefaultTyping |
Enumeration used with
ObjectMapper.enableDefaultTyping()
to specify what kind of types (classes) default typing should
be used for. |
SerializationConfig.Feature |
Enumeration that defines togglable features that guide
the serialization feature.
|
Exception | Description |
---|---|
JsonMappingException |
Checked exception used to signal fatal problems with mapping of
content.
|
RuntimeJsonMappingException |
Wrapper used when interface does not allow throwing a checked
JsonMappingException |
ObjectMapper
class, as well
as convenience methods included in
JsonParser
Object mapper will convert Json content to ant from basic Java wrapper types (Integer, Boolean, Double), Collection types (List, Map), Java Beans, Strings and nulls.
Tree mapper builds dynamically typed tree of JsonNode
s
from Json content (and writes such trees as Json),
similar to how DOM model works with xml.
Main benefits over Object mapping are: