# Package com.fasterxml.jackson.databind

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`

See: Description

Interface Summary
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, contstructor 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 Summary
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.
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.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 |
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 Summary
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 Summary
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`

## Package com.fasterxml.jackson.databind Description

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 `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:

- 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.