Package org.codehaus.jackson.map

package org.codehaus.jackson.map

Contains basic mapper (conversion) functionality that allows for converting between regular streaming json content and Java objects (beans or Tree Model: support for both is via 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 JsonNodes from Json content (and writes such trees as Json), similar to how DOM model works with xml. Main benefits over Object mapping are:

• No null checks are needed (dummy nodes are created as necessary to represent "missing" Object fields and Array elements)
• No type casts are usually needed: all public access methods are defined in basic JsonNode class, and when "incompatible" method (such as Array element access on, say, Boolean node) is used, returned node is virtual "missing" node.

Because of its dynamic nature, Tree mapping is often convenient for basic path access and tree navigation, where structure of the resulting tree is known in advance.

Related Packages

Package	Description
org.codehaus.jackson	Main public API classes of the core streaming JSON processor: most importantly JsonFactory used for constructing JSON parser (JsonParser) and generator (JsonParser) instances.
org.codehaus.jackson.map.annotate	Annotations that directly depend on Mapper classes (not just Jackson core) and are used for configuring Data Mapping functionality.
org.codehaus.jackson.map.deser	Contains implementation classes of deserialization part of data binding.
org.codehaus.jackson.map.exc
org.codehaus.jackson.map.ext	Contains extended support for "external" packages: things that may or may not be present in runtime environment, but that are commonly enough used so that explicit support can be added.
org.codehaus.jackson.map.introspect	Functionality needed for Bean introspection, required for detecting accessors and mutators for Beans, as well as locating and handling method annotations.
org.codehaus.jackson.map.jsontype	Package that contains interfaces that define how to implement functionality for dynamically resolving type during deserialization.
org.codehaus.jackson.map.module	Package that contains classes and interfaces to help implement custom extension Modules (which are registered using ObjectMapper.registerModule(Module).
org.codehaus.jackson.map.ser	Contains implementation classes of serialization part of data binding.
org.codehaus.jackson.map.type	Package that contains concrete implementations of JavaType, as well as the factory (TypeFactory) for constructing instances from various input data types (like Class, Type) and programmatically (for structured types, arrays, Lists and Maps).
org.codehaus.jackson.map.util	Utility classes for Mapper package.

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
AnnotationIntrospector.ReferenceProperty.Type
BeanDescription	Basic container for information gathered by ClassIntrospector to help in constructing serializers and deserializers.
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.
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.
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 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.
ContextualKeyDeserializer	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.
ContextualSerializer<T>	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.
DeserializationConfig	Object that contains baseline configuration for deserialization process.
DeserializationConfig.Feature	Enumeration that defines togglable features that guide the serialization feature.
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 JsonDeserializers to obtain deserializers capable of re-constructing instances of handled type from JSON content.
Deserializers	Interface that defines API for simple extensions that can provide additional deserializers for various types.
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 JsonSerializers, JsonDeserializers, 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 JsonDeserializers 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	Checked exception used to signal fatal problems with mapping of content.
JsonMappingException.Reference	Simple bean class used to contain references.
JsonSerializable	Deprecated.
JsonSerializableWithType	Interface that is to replace JsonSerializable to allow for dynamic type information embedding.
JsonSerializer<T>	Abstract class that defines API used by ObjectMapper (and other chained JsonSerializers 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.
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<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.
MapperConfig.ConfigFeature	Interface that actual Feature enumerations used by MapperConfig implementations must implement.
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.
Module.SetupContext	Interface Jackson exposes to modules for purpose of registering extended functionality.
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).
ObjectMapper.DefaultTyping	Enumeration used with ObjectMapper.enableDefaultTyping() to specify what kind of types (classes) default typing should be used for.
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
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.
RuntimeJsonMappingException	Wrapper used when interface does not allow throwing a checked JsonMappingException
SerializationConfig	Object that contains baseline configuration for serialization process.
SerializationConfig.Feature	Enumeration that defines togglable features that guide the serialization feature.
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 JsonSerializers to obtain serializers capable of serializing instances of specific types.
Serializers	Interface that defines API for simple extensions that can provide additional serializers for various 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.