All Classes and Interfaces
Class
Description
Deserializer only used as placeholder for abstract types during polymorphic
type handling deserialization.
Defines interface for resolvers that can resolve abstract types into concrete
ones; either by using static mappings, or possibly by materializing
implementations dynamically.
Shared base class used for anything on which annotations (included
within a
AnnotationMap).Object that represents non-static (and usually non-transient/volatile)
fields of a class.
Intermediate base class for annotated entities that are members of
a class; fields, methods and constructors.
Simple helper class used to keep track of collection of
AnnotatedMethods, accessible by lookup.Object that represents method parameters, mostly so that associated
annotations can be processed conveniently.
Intermediate base class that encapsulates features that
constructors and methods share.
Abstract class that defines API used for introspecting annotation-based
configuration for serialization and deserialization.
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.
Value type used with managed and back references; contains type and
logic name, used to link related references
Simple helper class used to keep track of collection of
Jackson Annotations associated with annotatable things
(methods, constructors, classes).
Enumeration that defines standard annotation sets available for configuring
data binding aspects.
Interface that defines interface for collection of annotations.
Class similar to
BeanPropertyWriter, but that will be used
for serializing JsonAnyGetter annotated
(Map) propertiesHelper class that contains set of distinct builders for different
arrays of primitive values.
Deprecated.
Deprecated.
Since 1.9, use
PrimitiveArrayDeserializers instead.Node class that represents Arrays mapped from Json content.
Deprecated.
Since 1.9 use
StdArraySerializersArray types represent Java arrays, both primitive and object valued.
Base class for serializers that will output contents as JSON
arrays; typically serializers used for
Collection
and array types.Type deserializer used with
JsonTypeInfo.As.WRAPPER_ARRAY
inclusion mechanism.Type serializer that will embed type information in an array,
as the first element, and actual value as the second element.
Type deserializer used with
JsonTypeInfo.As.EXTERNAL_PROPERTY inclusion mechanism.Type serializer that preferably embeds type information as an "external"
type property; embedded in enclosing JSON object.
Type deserializer used with
JsonTypeInfo.As.PROPERTY
inclusion mechanism.Type serializer that preferably embeds type information as an additional
JSON Object property, if possible (when resulting serialization would
use JSON Object).
Type deserializer used with
JsonTypeInfo.As.WRAPPER_OBJECT
inclusion mechanism.Type wrapper that tries to use an extra JSON Object, with a single
entry that has type name as key, to serialize type information.
Abstract base class used to define specific details of which
variant of Base64 encoding/decoding is to be used.
Container for commonly used Base64 variants.
Abstract base class common to all standard
JsonNode
implementations.Default
BeanDescription implementation.Deprecated.
Since 1.9 just don't use
Deprecated.
Since 1.9 just don't use
Deprecated.
Since 1.9 just don't use
Abstract factory base class that can provide deserializers for standard
JDK classes, including collection classes and simple heuristics for
"upcasting" commmon collection interface types
(such as
Collection).Factory class that can provide serializers for standard JDK classes,
as well as custom classes that extend standard classes or implement
one of "well-known" interfaces (such as
Collection).Basic container for information gathered by
ClassIntrospector to
help in constructing serializers and deserializers.Deserializer class that can deserialize instances of
arbitrary bean objects, usually from JSON Object structs,
but possibly also from simple types like String values.
Builder class used for aggregating deserialization information about
a POJO, in order to build a
JsonDeserializer for deserializing
intances.Concrete deserializer factory class that adds full Bean deserializer
construction logic using class introspection.
Standard configuration settings container class implementation.
Abstract class that defines API for objects that can be registered (for
BeanDeserializerFactory
to participate in constructing BeanDeserializer instances.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.
Simple value classes that contain definitions of properties,
used during introspection of properties to use for
serialization and deserialization purposes.
Interface that defines API for filter objects use (as configured
using
JsonFilter)
for filtering bean properties to serialize.Helper class used for storing mapping from property name to
SettableBeanProperty instances.Base bean property handler class, which implements common parts of
reflection-based functionality for accessing a property value
and serializing it.
Serializer class that can serialize arbitrary bean objects
Base class both for the standard bean serializer, and couple
of variants that only differ in small details.
Builder class used for aggregating deserialization information about
a POJO, in order to build a
JsonSerializer for serializing
intances.Factory class that can provide serializers for any regular Java beans
(as defined by "having at least one get method recognizable as bean
accessor" -- where
Object.getClass() does not count);
as well as for "standard" JDK types.Configuration settings container class for bean serializer factory
Abstract class that defines API for objects that can be registered (for
BeanSerializerFactory
to participate in constructing BeanSerializer instances.Helper class that contains functionality needed by both serialization
and deserialization side.
Numeric node that contains simple 64-bit integer values.
Value node that contains Base64 encoded binary value, which will be
output and stored as Json String value.
This concrete value class is used to contain boolean (true / false)
values.
This is a small utility class, whose main functionality is to allow
simple reuse of raw byte/char buffers.
Helper class that is similar to
ByteArrayOutputStream
in usage, but more geared to Jackson use cases internally.This class is used to determine the encoding of byte stream
that is to contain JSON content.
A caching symbol table implementation used for canonicalizing JSON field
names (as
Names which are constructed directly from a byte-based
input source).Standard serializer for
Calendar.Abstract base class that defines interface for customizing character
escaping aspects for String values, for formats that use escaping.
This class is a kind of specialized type-safe Map, from char array to
String value.
Helper class used to introspect features of POJO value classes
used with Jackson.
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)
Key class, used as an efficient and accurate key
for locating per-class values, such as
JsonSerializers.TypeIdResolver implementation
that converts between fully-qualified
Java class names and (JSON) Strings.Deprecated.
Since 1.9, use
ContainerDeserializerBase instead.Basic serializer that can take JSON "Array" structure and
construct a
Collection instance, with typed contents.Type that represents things that act similar to
Collection;
but may or may not be instances of that interface.Fallback serializer for cases where Collection is not known to be
of type for which more specializer serializer exists (such as
index-accessible List).
Type that represents Java Collection types (Lists, Sets).
Helper class for constructing objects for comparing content values
Deprecated.
Since 1.9, use
ContainerDeserializerBase instead.Intermediate base deserializer class that adds more shared accessor
so that other classes can access information about contained (value)
types
This intermediate base class is used for all container nodes,
specifically, array and object nodes.
Intermediate base class for types that contain element(s) of
other types.
Deprecated.
Since 1.9 use
StdContainerSerializers insteadAdd-on interface that
JsonDeserializers can implement to get a callback
that can be used to create contextual instances of deserializer to use for
handling properties of supported type.Add-on interface that
KeyDeserializers 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.Add-on interface that
JsonSerializers can implement to get a callback
that can be used to create contextual instances of serializer to use for
handling properties of supported type.Container deserializers that handle "core" XML types: ones included in standard
JDK 1.5.
Provider for serializers of XML types that are part of full JDK 1.5, but
that some alleged 1.5 platforms are missing (Android, GAE).
Container class for storing information on creators (based on annotations,
visibility), to be able to build actual instantiator later on.
This concrete sub-class implements property that is passed
via Creator (constructor or static factory method).
Deprecated.
Starting with 1.7, functionality of this class has been
implemented both in base
SerializerFactory (see methods
like SerializerFactory.withAdditionalSerializers(Serializers))
and through new Module API.Serializer factory implementation that allows for configuring
mapping between types (classes) and serializers to use, by using
multiple types of overrides.
Simple helper class that allows data format (content type) auto-detection,
given an ordered set of
JsonFactory instances to use for actual low-level
detection.Result object constructed by
DataFormatDetector when requested
to detect format of given input data.Deprecated.
Since 1.9, use
JsonNodeDeserializer instead.Simple deserializer for handling
Date values.For efficiency, we will serialize Dates as longs, instead of
potentially more readable Strings.
Numeric node that contains values that do not fit in simple
integer (int, long) or floating point (double) values.
Deprecated.
Moved to
DefaultPrettyPrinter; will be removed in Jackson 2.0Default
PrettyPrinter implementation that uses 2-space
indentation with platform-default linefeeds.This is a very simple indenter that only every adds a
single space for indentation.
Default linefeed-based indenter uses system-specific linefeeds and
2 spaces for indentation per level.
Dummy implementation that adds no indentation whatsoever
Object that contains baseline configuration for deserialization
process.
Enumeration that defines togglable features that guide
the serialization feature.
Context for deserialization process.
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.Abstract class that defines API used by
DeserializerProvider
to obtain actual
JsonDeserializer instances from multiple distinct factories.Configuration settings container class for bean deserializer factory
Abstract class that defines API used by
ObjectMapper and
JsonDeserializers to obtain deserializers capable of
re-constructing instances of handled type from JSON content.Interface that defines API for simple extensions that can provide additional deserializers
for various types.
Basic
Deserializers implementation that implements all methods but provides
no deserializers.Deprecated.
As of 1.9, use
Deserializers.Base insteadBase for serializers that allows parsing DOM Documents from JSON Strings.
Numeric node that contains 64-bit ("double precision")
floating point values simple 32-bit integer values.
Deprecated.
Since 1.9, use
EnumDeserializer instead.Deserializer class that can deserialize instances of
specified Enum class from Strings and Integers.
Deserializer that uses a single-String static factory method
for locating Enum values by String id.
Note: casting within this class is all messed up -- just could not figure out a way
to properly deal with recursive definition of "EnumMap<K extends Enum, V>
Specialized serializer for
EnumMaps.Deprecated.
Since 1.9, use
EnumResolver instead.Helper class used to resolve String values (either JSON Object field
names or regular String values) into Java Enum instances.
Deprecated.
Since 1.9 use
EnumSerializerStandard serializer used for
Enum types.
Note: casting within this class is all messed up -- just could not figure out a way
to properly deal with recursive definition of "EnumSet<K extends Enum, V>
Helper class used for storing String serializations of
enumerations.
Helper class that is used to flatten JSON structure when using
"external type id" (see
JsonTypeInfo.As.EXTERNAL_PROPERTY).Special bogus "serializer" that will throw
JsonGenerationException if its FailingSerializer.serialize(java.lang.Object, org.codehaus.jackson.JsonGenerator, org.codehaus.jackson.map.SerializerProvider)
gets invoked.Decorated
BeanPropertyWriter that will filter out
properties that are not to be included in currently active
JsonView.Interface for objects that providers instances of
BeanPropertyFilter
that match given ids.Simple tag interface used to mark schema objects that are used by some
JsonParser and JsonGenerator implementations to further
specify structure of expected format.Deprecated.
Since 1.9, use
FromStringDeserializer instead.Base class for simple deserializer which only accept JSON String
values as the source.
As per [JACKSON-484], also need special handling for InetAddress...
Kept protected as it's not meant to be extensible at this point
As per [JACKSON-522], also need special handling for InetAddress...
Helper class used for handling details of creating handler instances (things
like
JsonSerializers, JsonDeserializers, various type
handlers) of specific types.Simple replacement for
Class (and/or various Type subtypes)
that is used as part of single-path extends/implements chain to express
specific relationship between one subtype and one supertype.Interface that defines objects that can produce indentation used
to separate object entries and array values.
Efficient implementation for serializing
Lists that contains Strings and are random-accessible.Simple serializer for
InetAddress.Abstract class that defines API for objects that provide value to
"inject" during deserialization.
Simple standard implementation which uses a simple Map to
store values to inject, identified by simple String keys.
Interface used to expose beginning of a data file to data format
detection code.
Basic implementation that reads data from given
InputStream and buffers it as necessary.Handler class that can be used to decorate input sources.
Singleton class that adds a simple first-level cache in front of
regular String.intern() functionality.
Numeric node that contains simple 32-bit integer values.
To limit number of configuration and state objects to pass, all
contextual objects that need to be passed by the factory to
readers and writers are combined under this object.
Provide a fast thread-safe formatter/parser DateFormat for ISO8601 dates ONLY.
Utilities methods for manipulating dates in iso8601 format.
Meta-annotation (annotations used on other annotations)
used for marking all annotations that are
part of Jackson package.
AnnotationIntrospector implementation that handles standard
Jackson annotations.Jackson-specific annotation used for indicating that value of
annotated property will be "injected", i.e.
JSON content type provider automatically configured to use both Jackson
and JAXB annotations (in that order of priority).
Basic implementation of JAX-RS abstractions (
MessageBodyReader,
MessageBodyWriter) needed for binding
JSON ("application/json") content to and from Java Objects ("POJO"s).Marker interface used to indicate implementation classes
(serializers, deserializers etc) that are standard ones Jackson
uses; not custom ones that application has added.
Base class for type token classes used both to contain information
and as keys for deserializers.
Annotation introspector that leverages JAXB annotations where applicable to JSON mapping.
Deprecated.
Since 1.9 use
StdJdkSerializersProvider for deserializers that handle some basic data types
for Joda date/time library.
JodaDeserializers.DateTimeDeserializer<T extends ReadableInstant>
Basic deserializer for
DateTime.Provider for serializers that handle some basic data types
for Joda date/time library.
Marker annotation that can be used to define a non-static,
no-argument method or member field as something of a reverse of
JsonAnySetter method; basically being used like a
getter but such that contents of the returned Map (type must be
Map) are serialized as if they were actual properties
of the bean that contains method/field with this annotations.Marker annotation that can be used to define a non-static,
single-argument method, to be used as a "fallback" handler
for all otherwise unrecognized properties found from Json content.
Class annotation that can be used to define which kinds of Methods
are to be detected by auto-detection.
Enumeration for possible visibility thresholds (minimum visibility)
that can be used to limit which methods (and fields) are
auto-detected.
Annotation used to indicate that associated property is part of
two-way linkage between fields; and that its role is "child" (or "back") link.
Marker annotation used to denote whether given instance
(currently only used with
JsonDeserializer)
can be cached.Marker annotation that can be used to define constructors and factory
methods as one to use for instantiating new instances of the associated
class.
Annotation use for configuring deserialization aspects, by attaching
to "setter" methods or fields, or to value classes.
Abstract class that defines API used by
ObjectMapper (and
other chained JsonDeserializers too) to deserialize Objects of
arbitrary types from JSON, using provided JsonParser.This marker class is only to be used with annotations, to
indicate that no deserializer is configured.
Enumeration that defines legal encodings that can be used
for JSON content, based on list of allowed encodings from
JSON specification.
The main factory class of Jackson package, used to configure and
construct reader (aka parser,
JsonParser)
and writer (aka generator, JsonGenerator)
instances.Annotation used to indicate which logical filter is to be used
for filtering out properties of type (class) annotated;
association made by this annotation declaring ids of filters,
and
ObjectMapper (or objects
it delegates to) providing matching filters by id.Exception type for exceptions during JSON writing, such as trying
to output content in wrong context (non-matching end-array or end-object,
for example).
Base class that defines public API for writing JSON content.
Enumeration that defines all togglable features for generators.
This base class implements part of API that a JSON generator exposes
to applications, adds shared internal methods that sub-classes
can use and adds some abstract methods sub-classes must implement.
Deprecated.
Use
JsonProperty instead (deprecated since version 1.5)Marker annotation that indicates that the annotated method or field is to be
ignored by introspection-based
serialization and deserialization functionality.
Annotation that can be used to either suppress serialization of
properties (during serialization), or ignore processing of
JSON properties read (during deserialization).
Marker annotation that indicates that all properties of annotated
type are to be ignored during serialization and deserialization.
Object that encapsulates Location information used for reporting
parsing (or potentially generation) errors, as well as current location
within input streams.
Annotation used to indicate that annotated property is part of
two-way linkage between fields; and that its role is "parent" (or "forward") link.
Checked exception used to signal fatal problems with mapping of
content.
Simple bean class used to contain references.
Implementation if
ExceptionMapper to send down a "400 Bad Request"
response in the event that unmappable JSON is received.Enumeration used to define kinds of methods that annotations like
JsonAutoDetect apply to.Base class for all JSON nodes, which form the basis of JSON
Tree Model that Jackson implements.
Deprecated.
Since 1.9, use
JsonNodeDeserializer instead.Base class that specifies methods for getting access to
Node instances (newly constructed, or shared, depending
on type), as well as basic implementation of the methods.
Deprecated.
Since 1.9.0: functionality demoted down to JsonParserBase
Exception type for parsing problems, used when non-well-formed content
(content that does not conform to JSON syntax as per specification)
is encountered.
Implementation of
ExceptionMapper to send down a "400 Bad Request"
in the event unparsable JSON is received.Base class that defines public API for reading JSON content.
Enumeration that defines all togglable features for parsers.
Enumeration of possible "native" (optimal) types that can be
used for numbers.
Intermediate base class used by all Jackson
JsonParser
implementations.Helper class that implements
delegation pattern for
JsonParser,
to allow for simple overridability of basic parsing functionality.Intermediate base class used by all Jackson
JsonParser
implementations, but does not add any additional fields that depend
on particular method of obtaining input.Helper class that can be used to sequence multiple physical
JsonParsers to create a single logical sequence of
tokens, as a single JsonParser.Container class that can be used to wrap any Object instances (including
nulls), and will serialize embedded in
JSONP wrapping.
Intermediate base class for all problems encountered when
processing (parsing, generating) JSON content
that are not pure I/O problems.
Marker annotation that can be used to define a non-static
method as a "setter" or "getter" for a logical property
(depending on its signature),
or non-static object field to be used (serialized, deserialized) as
a logical property.
Annotation that can be used to define ordering (possibly partial) to use
when serializing object properties.
Marker annotation that indicates that the annotated method
or field should be serialized by including literal String value
of the property as is, without quoting of characters.
Extension of
JsonStreamContext, which implements
core methods needed, and also exposes
more complete API to parser implementation classes.Annotation similar to
XmlRootElement,
used to indicate name to use for root-level wrapping, if wrapping is
enabled.A
JsonNode that represents a JSON-Schema instance.Deprecated.
Annotation that can be used to define JSON Schema definition for
the annotated class.
Interface that is to replace
JsonSerializable to
allow for dynamic type information embedding.Annotation used for configuring serialization aspects, by attaching
to "getter" methods or fields, or to value classes.
Enumeration used with
JsonSerialize.include() property
to define which properties
of Java Beans are to be included in serializationEnumeration used with
JsonSerialize.typing() property
to define whether type detection is based on dynamic runtime
type (DYNAMIC) or declared type (STATIC).Abstract class that defines API used by
ObjectMapper (and
other chained JsonSerializers too) to serialize Objects of
arbitrary types into JSON, using provided JsonGenerator.This marker class is only to be used with annotations, to
indicate that no serializer is configured.
Specialized read-only map used for storing and accessing serializers by type.
Marker annotation that can be used to define a non-static,
single-argument method to be used as a "setter" for a logical property
as an alternative to recommended
JsonProperty annotation (which was introduced in version 1.1).Shared base class for streaming processing contexts used during
reading and writing of Json content using Streaming API.
Helper class used for efficient encoding of JSON String values (including
JSON field names) into Strings or UTF-8 byte arrays.
Annotation used with
JsonTypeInfo to indicate sub types of serializable
polymorphic types, and to associate logical names used within JSON content
(which is more portable than using physical Java class names).Definition of a subtype, along with optional name.
Enumeration for basic token types used for returning results
of parsing JSON content.
Annotation that can be used to plug a custom type identifier handler
(
TypeIdResolver)
to be used by
TypeSerializers
and TypeDeserializers
for converting between java types and type id included in JSON content.Annotation used for configuring details of if and how type information is
used with JSON serialization and deserialization, to preserve information
about actual class of Object instances.
Definition of standard type inclusion mechanisms for type metadata.
Definition of different type identifiers that can be included in JSON
during serialization, and used for deserialization.
This marker class that is only to be used with
defaultImpl
annotation property, to indicate that there is no default implementation
specified.Annotation used for binding logical name that the annotated class
has.
Annotation that can be used to explicitly define custom resolver
used for handling serialization and deserialization of type information,
needed for handling of polymorphic types (or sometimes just for linking
abstract types to concrete types)
Annotation used to indicate that a property should be serialized
"unwrapped"; that is, if it would be serialized as JSON Object, its
properties are instead included as properties of its containing
Object.
Marker annotation similar to
XmlValue
that indicates that results of the annotated "getter" method
(which means signature must be that of getters; non-void return
type, no args) is to be used as the single value to serialize
for the instance.Annotation that can be used to indicate a
ValueInstantiator to use
for creating instances of specified type.Serializer class that can serialize Object that have a
JsonValue annotation to
indicate that serialization should be done by calling the method
annotated, and serializing result it returns.Annotation used for indicating view(s) that the property
that is defined by method or field annotated is part of.
General-purpose wrapper class that can be used to decorate serialized
value with arbitrary literal prefix and suffix.
Extension of
JsonStreamContext, which implements
core methods needed, and also exposes
more complete API to generator implementation classes.Deprecated.
(since 1.6) Currently recommended annotation to use is
JsonSerialize.include()
(with values ALWAYS or NON_NULL)Abstract class that defines API used for deserializing JSON content
field names into Java Map keys.
This marker class is only to be used with annotations, to
indicate that no deserializer is configured.
Interface that defines API for simple extensions that can provide additional deserializers
for deserializer Map keys of various types, from JSON property names.
Node of a forward-only linked list.
Numeric node that contains simple 64-bit integer values.
Helper for simple bounded LRU maps used for reusing lookup values.
Deprecated.
Since 1.9, use
MapDeserializer instead.Basic serializer that can take Json "Object" structure and
construct a
Map instance, with typed contents.Type that represents Map-like types; things that consist of key/value pairs but that
do not necessarily implement
Map, but that do not have enough
introspection functionality to allow for some level of generic handling.Interface that defines functionality accessible through both
serialization and deserialization configuration objects;
accessors to mode-independent configuration settings
and such.
Immutable container class used to store simple configuration
settings.
Interface that actual Feature enumerations used by
MapperConfig implementations must implement.Helper class used to encapsulate details of configuring an
ObjectMapper instance to be used for data binding, as
well as accessing it.Iterator exposed by
ObjectMapper when binding sequence of
objects.Sub-class of
JsonFactory that will create a proper
ObjectCodec to allow seamless conversions between
Json content and Java objects (POJOs).Deprecated.
Since 1.9 use
MapSerializerStandard serializer implementation for serializing {link java.util.Map} types.
Type that represents "true" Java Map types.
Enumeration used to indicate strength of match between data format
and piece of data (typically beginning of a data file).
Helper class needed to be able to efficiently access class
member functions (
Methods and Constructors)
in Maps.Simple
InputStream implementation that is used to "unwind" some
data previously read from an input stream; so that as long as some of
that data remains, it's returned; but as long as it's read, we'll
just use data from the underlying original stream.Simple interface that defines API used to filter out irrelevant
methods
PrettyPrinter implementation that adds no indentation,
just implements everything necessary for value output to work
as expected, and provide simpler extension points to allow
for creating simple custom implementations that add specific
decoration or overrides.This singleton node class is generated to denote "missing nodes"
along paths that do not exist.
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.Interface Jackson exposes to modules for purpose of registering
extended functionality.
Base class for tokenized names (key strings in objects) that have
been tokenized from byte-based input sources (like
InputStream.Specialized implementation of PName: can be used for short Strings
that consists of at most 4 bytes.
Specialized implementation of PName: can be used for short Strings
that consists of 5 to 8 bytes.
Specialized implementation of PName: can be used for short Strings
that consists of 9 to 12 bytes.
Simple tag interface mostly to allow sorting by name
Simple container class for types with optional logical name, used
as external identifier
Generic implementation of PName used for "long" names, where long
means that its byte (UTF-8) representation is 13 bytes or more.
Marker class used with annotations to indicate "no class".
Intermediate base class for limited number of scalar types
that should never include type information.
Dummy, "no-operation" implementation of
AnnotationIntrospector.This singleton value class is used to contain explicit JSON null
value.
This is a simple dummy serializer that will just output literal
JSON null value whenever serialization is requested.
Intermediate value node used for numeric nodes.
Basic serializer that can serialize non-primitive arrays.
Generic serializer for Object arrays (
Object[]).Helper class to use for constructing Object arrays by appending entries
to create arrays of various lengths (length that is not known a priori).
Abstract class that defines the interface that
JsonParser and
JsonGenerator use to serialize and deserialize regular
Java objects (POJOs aka Beans).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.
Customized
TypeResolverBuilder that provides type resolver builders
used with so-called "default typing"
(see ObjectMapper.enableDefaultTyping() for details).Enumeration used with
ObjectMapper.enableDefaultTyping()
to specify what kind of types (classes) default typing should
be used for.Node that maps to JSON Object structures in JSON content.
For efficiency, let's share the "no fields" iterator...
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).
Builder object that can be used for per-serialization configuration of
serialization parameters, such as JSON View and root type to use.
Helper class used for isolating details of handling optional+external types (Joda datetime,
javax.xml classes) from standard factories that offer them.
Handler class that can be used to decorate output destinations.
Value node that contains a wrapped POJO, to be serialized as
a JSON constructed through data mapping (usually done by
calling
ObjectMapper).Helper class used for aggregating information about all possible
properties of a POJO.
Helper class used for aggregating information about a single
potential POJO property.
Interface for objects that implement pretty printer functionality, such
as indentation.
Base class for specialized primitive array builders.
Container for deserializers used for instantiating "primitive arrays",
arrays that contain non-object java primitive types.
Object that is used to collect arguments for non-default creator
(non-default-constructor, or argument-taking factory method)
before creator can be called.
Helper class for
BeanSerializerFactory that is used to
construct BeanPropertyWriter instances.Helper object used to check if given array object is null or empty
Helper object used to check if given Collection object is null or empty
Helper object used to check if given Map object is null or empty
Helper object used to check if given String object is null or empty
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.
A
PropertyNamingStrategy that translates typical camel case Java
property names to lower case JSON element names, separated by
underscores.Helper container used for resolving serializers for dynamic (possibly but not
necessarily polymorphic) properties: properties whose type is not forced
to use dynamic (declared) type and that are not final.
Value class used for returning tuple that has both serializer
that was retrieved and new map instance
Base class for property values that need to be buffered during
deserialization.
Simple container used for temporarily buffering a set of
PropertyValues.Simple helper class used for decoupling instantiation of
optionally loaded handlers, like deserializers and deserializers
for libraries that are only present on some platforms.
This is a simple dummy serializer that will just output raw values by calling toString()
on value to serialize.
This is a concrete implementation of
JsonParser, which is
based on a Reader to handle low-level character
conversion tasks.Deprecated.
Since 1.9 sub-classes should just include code
from here as is.
Optimized lookup table for accessing two types of serializers; typed
and non-typed.
Interface used to indicate deserializers that want to do post-processing
after construction and being added to
DeserializerProvider,
but before being used.Interface used to indicate serializers that want to do post-processing
after construction and being added to
SerializerProvider,
but before being used.Helper class for caching resolved root names.
Wrapper used when interface does not allow throwing a checked
JsonMappingExceptionDeprecated.
Since 1.9 use
SerializerBase instead.Marker interface for schema-aware serializers.
Efficient alternative to
StringWriter, based on using segmented
internal buffer.Generic handler for types that implement
JsonSerializable.Interface that defines how Jackson package can interact with efficient
pre-serialized or lazily-serialized and reused String representations.
Generic handler for types that implement
JsonSerializableWithType.Object that contains baseline configuration for serialization
process.
Enumeration that defines togglable features that guide
the serialization feature.
String token that can lazily serialize String contained and then reuse that
serialization later on.
Deprecated.
Since 1.9 use
SerializerBaseBase class used by all standard serializers.
Simple cache object that allows for doing 2-level lookups: first level is
by "local" read-only lookup Map (used without locking)
and second backup level is by a shared modifiable HashMap.
Key that offers two "modes"; one with raw class, as used for
cases were raw class type is available (for example, when using
runtime type); and one with full generics-including.
Abstract class that defines API used by
SerializerProvider
to obtain actual
JsonSerializer instances from multiple distinct factories.Configuration settings container class for bean serializer factory.
Abstract class that defines API used by
ObjectMapper and
JsonSerializers to obtain serializers capable of serializing
instances of specific types.Interface that defines API for simple extensions that can provide additional serializers
for various types.
Basic
Serializers implementation that implements all methods but provides
no serializers.Deprecated.
As of 1.9, use
Serializers.Base insteadClass that represents a "wildcard" set method which can be used
to generically set values of otherwise unmapped (aka "unknown")
properties read from Json content.
Base class for settable properties of a bean: contains
both type and name definitions, and reflection-based set functionality.
This concrete sub-class implements property that is set
directly assigning to a Field.
This sub-class is used to handle special case of value being a
non-static inner class.
Wrapper property that is used to handle managed (forward) properties
(see [JACKSON-235] for more information).
This concrete sub-class implements property that is set
using regular "setter" method.
To support [JACKSON-420] we need bit more indirection; this is used to produce
artificial failure for primitives that don't accept JSON null as value.
This concrete sub-class implements Collection or Map property that is
indirectly by getting the property value and directly modifying it.
Simple
AbstractTypeResolver implementation, which is
based on static mapping from abstract super types into
sub types (concrete or abstract), but retaining generic
parameterization.Simple
BeanPropertyFilter implementation that only uses property name
to determine whether to serialize property as is, or to filter it out.Filter implementation which defaults to filtering out unknown
properties and only serializes ones explicitly listed.
Filter implementation which defaults to serializing all
properties, except for ones explicitly listed to be filtered out.
Simple implementation
Deserializers which allows registration of
deserializers based on raw (type erased class).Simple
FilterProvider implementation that just stores
direct id-to-filter mapping.Simple implementation
KeyDeserializers which allows registration of
deserializers based on raw (type erased class).Simple
Module implementation that allows registration
of serializers and deserializers, and bean serializer
and deserializer modifiers.Simple implementation
Serializers which allows registration of
serializers based on raw (type erased class).Simple types are defined as anything other than one of recognized
container types (arrays, Collections, Maps).
Intermediate base class for Lists, Collections and Arrays
that contain static (non-dynamic) value types.
Dummy container class to group standard homogenous array serializer implementations
(primitive arrays and String array).
Base class for serializers that will output contents as JSON
arrays.
Unlike other integral number array serializers, we do not just print out byte values
as numbers.
Character arrays are different from other integral number arrays in that
they are most likely to be textual data, and should be written as
Strings, not arrays of entries.
Standard serializer used for
String[] values.This is an optimized serializer for Lists that can be efficiently
traversed by index (as opposed to others, such as
LinkedList
that can not}.Default
DateFormat implementation used by standard Date
serializers and deserializers.Default implementation of
DeserializationContext.Base class for common deserializers.
Deprecated.
Since 1.9, use
StdDeserializer instead.This is bit trickier to implement efficiently, while avoiding
overflow problems.
For type
Number.class, we can just rely on type
mappings that plain JsonParser.getNumberValue() returns.Compared to plain old
Date, SQL version is easier
to deal with: mostly because it is more limited.Deprecated.
Since 1.9 use
StringDeserializer instead.Default
DeserializerProvider implementation.Simple deserializer that will call configured type deserializer, passing
in configured data deserializer, and exposing it all as a simple
deserializer.
Class that providers access to serializers user for non-structured JDK types that
are serializer as scalars; some using basic
ToStringSerializer,
others explicit serializers.Also: default bean access will not do much good with Class.class.
For now, File objects get serialized by just outputting
absolute (but not canonical) name as String value
Base class for simple key deserializers.
Deprecated.
Since 1.9, use
StdKeyDeserializer instead.Helper class used to contain simple/well-known key deserializers.
Specialized serializer that can be used as the generic key
serializer, when serializing
Maps to JSON
Objects.Deprecated.
Since 1.9 use
StdKeySerializer insteadBase class for deserializers that handle types that are serialized
as JSON scalars (non-structured, i.e.
Deprecated.
Since 1.9, use
StdScalarDeserializer instead.Default
SerializerProvider implementation.Container class for serializers used for handling standard JDK-provided types.
Serializer used for primitive boolean, as well as java.util.Boolean
wrapper type.
Deprecated.
Since 1.9, use
DateSerializer insteadThis is the special serializer for regular
Doubles
(and primitive doubles)This is the special serializer for regular
Integers
(and primitive ints)Similar to
StdSerializers.IntegerSerializer, but will not cast to Integer:
instead, cast is to Number, and conversion is
by calling Number.intValue().As a fallback, we may need to use this serializer for other
types of
Numbers (custom types).Deprecated.
Since 1.9, use
DateSerializer insteadDeprecated.
Since 1.9, use
DateSerializer insteadCompared to regular
StdSerializers.UtilDateSerializer, we do use String
representation here.Deprecated.
Since 1.9, use
StringSerializer insteadDeprecated.
Since 1.9, use
DateSerializer insteadDefault
TypeResolverBuilder implementation.Basic
ValueInstantiator implementation, which only
supports use of default constructor.Deprecated.
Since 1.9, sub-classes should just embed code from here
Efficient implement for serializing
Collections that contain Strings.This is the special serializer for regular
Strings.Helper object used for handling registration on resolving of supertypes
to subtypes.
Helper class used to encapsulate rules that determine subtypes that
are invalid to use, even with default typing, mostly due to security
concerns.
TextBuffer is a class similar to
StringBuffer, with
following differences:
TextBuffer uses segments character arrays, to avoid having
to do additional array copies when array is not big enough.Value node that contains a text value.
Deserializer that builds on basic
BeanDeserializer but
override some aspects like instance construction.Deprecated.
Since 1.9, use
ThrowableDeserializer instead.Simple deserializer for handling
Timestamp values.Utility class used for efficient storage of
JsonToken
sequences, needed for temporary buffering.Individual segment of TokenBuffer that can store up to 16 tokens
(limited by 4 bits per token type marker requirement).
We also want to directly support deserialization of
TokenBuffer.We also want to directly support serialization of
TokenBuffer;
and since it is part of core package, it can not implement
JsonSerializable
(which is only included in the mapper package)Simple general purpose serializer, useful for any
type for which
Object.toString() returns the desired JSON
value.Deprecated.
Since 1.9 use
ToStringSerializerFacade over
JsonNode that implements JsonParser to allow
accessing contents of JSON tree in alternate form (stream of tokens).Helper class used for resolving type parameters for given class
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).
Class used for creating concrete
JavaType instances,
given various inputs.Interface that defines standard API for converting types
to type identifiers and vice versa.
Class that defines API that can be used to modify details of
JavaType instances constructed using TypeFactory.Simple recursive-descent parser for parsing canonical
JavaType
representations and constructing type instances.This class is used to pass full generics type information, and
avoid problems with type erasure (that basically removes most
usable type references from runtime Class objects).
Interface that defines builders that are configured based on
annotations (like
JsonTypeInfo or JAXB annotations),
and produce type serializers and deserializers used for
handling type information embedded in JSON to allow for safe
polymorphic type handling.Interface for serializing type information regarding instances of specified
base type (super class), so that exact subtype can be properly deserialized
later on.
Specialized
JsonMappingException sub-class specifically used
to indicate problems due to encountering a JSON property that could
not be mapped to an Object property (via getter, constructor argument
or field).Deserializer implementation that is used if it is necessary to bind content of
"unknown" type; something declared as basic
Object
(either explicitly, or due to type erasure).Deprecated.
Since 1.9, use
UntypedObjectDeserializer instead.Object that is responsible for handling acrobatics related to
deserializing "unwrapped" values; sets of properties that are
embedded (inlined) as properties of parent JSON object.
Variant of
BeanPropertyWriter which will handle unwrapping
of JSON Object (including of properties of Object within surrounding
JSON object, and not as sub-object).Since JDK does not come with UTF-32/UCS-4, let's implement a simple
decoder to use.
This is a concrete implementation of
JsonParser, which is
based on a InputStream as the input source.Class that encapsulates details of value injection that occurs before
deserialization of a POJO.
Class that defines simple API implemented by objects that create value
instances.
Interface for providers of
ValueInstantiator instances.Basic "NOP" implementation that can be used as the base class for custom implementations.
This intermediate base class is used for all leaf nodes, that is,
all non-container (array or object) nodes, except for the
"missing node".
Object that encapsulates version information of a component,
and is return by
Versioned.version().Interface that those Jackson components that are explicitly versioned will implement.
Functionality for supporting exposing of component
Versions.Interface for object used for determine which property elements
(methods, fields, constructors) can be auto-detected, with respect
to their visibility modifiers.
Default standard implementation is purely based on visibility
modifier of given class members, and its configured minimum
levels.
JsonGenerator that outputs JSON content using a Writer
which handles character encoding.
ObjectArrayDeserializerinstead.