ObjectMapper
class, as well
as convenience methods included in
JsonParser
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 parametrers).
|
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.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.
|
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 |
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.
|
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.
|
PropertyName |
Simple value class used for containing names of properties as defined
by annotations (and possibly other configuration sources).
|
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.LowerCaseStrategy |
Simple strategy where external name simply only uses lower-case characters,
and no separators.
|
PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy |
A
PropertyNamingStrategy that translates typical camel case Java
property names to lower case JSON element names, separated by
underscores. |
PropertyNamingStrategy.PascalCaseStrategy |
A
PropertyNamingStrategy that translates typical camelCase Java
property names to PascalCase JSON element names (i.e., with a capital
first letter). |
PropertyNamingStrategy.PropertyNamingStrategyBase | |
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.enableDefaultTyping()
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.
|
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:
JsonNode
class, and when "incompatible" method (such as Array
element access on, say, Boolean node) is used, returned node is
virtual "missing" node.
Copyright © 2014-2015 FasterXML. All Rights Reserved.