# Package com.fasterxml.jackson.databind

Basic data binding (mapping) functionality that allows for reading JSON content into Java Objects (POJOs) and JSON Trees (`JsonNode`), as well as writing Java Objects and trees as JSON.

See: Description

Interface Summary
AnnotationIntrospector.XmlExtensions: Add-on extension used for XML-specific configuration, needed to decouple format module functionality from pluggable introspection functionality (especially JAXB-annotation related one).
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 parameters).
EnumNamingStrategy: Defines how the string representation of an enum is converted into an external property name for mapping during deserialization.
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
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.Bogus: Alternative "Null" implementation that can be used in cases where a non-null `BeanProperty` is needed
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.
EnumNamingStrategies: A container class for implementations of the `EnumNamingStrategy` interface.
EnumNamingStrategies.CamelCaseStrategy: An implementation of `EnumNamingStrategy` that converts enum names in the typical upper snake case format to camel case format.
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.
JsonSerializable.Base: Base class with minimal implementation, as well as couple of extension methods that core Jackson databinding makes use of.
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: ObjectMapper provides functionality for reading and writing JSON, either to and from basic POJOs (Plain Old Java Objects), or to and from a general-purpose JSON Tree Model (`JsonNode`), as well as related functionality for performing conversions.
ObjectMapper.DefaultTypeResolverBuilder: Customized `TypeResolverBuilder` that provides type resolver builders used with so-called "default typing" (see `ObjectMapper.activateDefaultTyping(PolymorphicTypeValidator)` 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.
PropertyMetadata.MergeInfo: Helper class used for containing information about expected merge information for this property, if merging is expected.
PropertyName: Simple value class used for containing names of properties as defined by annotations (and possibly other configuration sources).
PropertyNamingStrategies: Container for standard `PropertyNamingStrategy` implementations and singleton instances.
PropertyNamingStrategies.KebabCaseStrategy: Naming strategy similar to `PropertyNamingStrategies.SnakeCaseStrategy`, but instead of underscores as separators, uses hyphens.
PropertyNamingStrategies.LowerCamelCaseStrategy: "No-operation" strategy that is equivalent to not specifying any strategy: will simply return suggested standard bean naming as-is.
PropertyNamingStrategies.LowerCaseStrategy: Simple strategy where external name simply only uses lower-case characters, and no separators.
PropertyNamingStrategies.LowerDotCaseStrategy: Naming strategy similar to `PropertyNamingStrategies.KebabCaseStrategy`, but instead of hyphens as separators, uses dots.
PropertyNamingStrategies.NamingBase: Intermediate base class for simple implementations
PropertyNamingStrategies.SnakeCaseStrategy: A `PropertyNamingStrategy` that translates typical camel case Java property names to lower case JSON element names, separated by underscores.
PropertyNamingStrategies.UpperCamelCaseStrategy: A `PropertyNamingStrategy` that translates typical camelCase Java property names to PascalCase JSON element names (i.e., with a capital first letter).
PropertyNamingStrategies.UpperSnakeCaseStrategy: A `PropertyNamingStrategy` that translates an input to the equivalent upper case snake case.
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 no explicit annotations exist for naming.
PropertyNamingStrategy.KebabCaseStrategy: Deprecated Since 2.12 use `PropertyNamingStrategies.KebabCaseStrategy` instead (see databind#2715 for reason for deprecation)
PropertyNamingStrategy.LowerCaseStrategy: Deprecated Since 2.12 use `PropertyNamingStrategies.LowerCaseStrategy` instead (see databind#2715 for reason for deprecation)
PropertyNamingStrategy.LowerDotCaseStrategy: Deprecated Since 2.12 use `PropertyNamingStrategies.LowerDotCaseStrategy` instead (see databind#2715 for reason for deprecation)
PropertyNamingStrategy.PropertyNamingStrategyBase: Deprecated Since 2.12 deprecated.
PropertyNamingStrategy.SnakeCaseStrategy: Deprecated Since 2.12 use `PropertyNamingStrategies.SnakeCaseStrategy` instead (see databind#2715 for reason for deprecation)
PropertyNamingStrategy.UpperCamelCaseStrategy: Deprecated Since 2.12 use `PropertyNamingStrategies.UpperCamelCaseStrategy` instead (see databind#2715 for reason for deprecation)
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 Summary
AnnotationIntrospector.ReferenceProperty.Type
DeserializationFeature: Enumeration that defines simple on/off features that affect the way Java objects are deserialized from JSON Note that features can be set both through `ObjectMapper` (as sort of defaults) and through `ObjectReader`.
JsonNode.OverwriteMode: Configuration setting used with `JsonNode.withObject(JsonPointer)` method overrides, to indicate which overwrites are acceptable if the path pointer indicates has incompatible nodes (for example, instead of Object node a Null node is encountered).
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.activateDefaultTyping(PolymorphicTypeValidator)` 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
DatabindException: Intermediate base class for all databind level processing problems, as distinct from stream-level problems or I/O issues below.
JsonMappingException: Checked exception used to signal fatal problems with mapping of content, distinct from low-level I/O problems (signaled using simple `IOException`s) or data encoding/decoding problems (signaled with `StreamReadException`, `StreamWriteException`).
RuntimeJsonMappingException: Wrapper used when interface does not allow throwing a checked `JsonMappingException`

## Package com.fasterxml.jackson.databind Description

Basic data binding (mapping) functionality that allows for reading JSON content into Java Objects (POJOs) and JSON Trees (`JsonNode`), as well as writing Java Objects and trees as JSON. Reading and writing (as well as related additional functionality) is accessed through `ObjectMapper`, `ObjectReader` and `ObjectWriter` classes. In addition to reading and writing JSON content, it is also possible to use the general databinding functionality for many other data formats, using Jackson extension modules that provide such support: if so, you typically simply construct an `ObjectMapper` with different underlying streaming parser, generator implementation.

The main starting point for operations is `ObjectMapper`, which can be used either directly (via multiple overloaded `readValue`, `readTree`, `writeValue` and `writeTree` methods, or it can be used as a configurable factory for constructing fully immutable, thread-safe and reusable `ObjectReader` and `ObjectWriter` objects.

In addition to simple reading and writing of JSON as POJOs or JSON trees (represented as `JsonNode`, and configurability needed to change aspects of reading/writing, mapper contains additional functionality such as:

- Value conversions using `ObjectMapper.convertValue(Object, Class)`, `ObjectMapper.valueToTree(Object)` and `ObjectMapper.treeToValue(com.fasterxml.jackson.core.TreeNode, Class)` methods.
- Type introspection needed for things like generation of Schemas (like JSON Schema, Avro Schema, or protoc definitions), using `ObjectMapper.acceptJsonFormatVisitor(Class, com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper)` (note: actual handles are usually provided by various Jackson modules: mapper simply initiates calling of callbacks, based on serializers registered)

Simplest usage is of form:

      final ObjectMapper mapper = new ObjectMapper(); // can use static singleton, inject: just make sure to reuse!
      MyValue value = new MyValue();
      // ... and configure
      File newState = new File("my-stuff.json");
      mapper.writeValue(newState, value); // writes JSON serialization of MyValue instance
      // or, read
      MyValue older = mapper.readValue(new File("my-older-stuff.json"), MyValue.class);

      // Or if you prefer JSON Tree representation:
      JsonNode root = mapper.readTree(newState);
      // and find values by, for example, using a JsonPointer expression:
      int age = root.at("/personal/age").getValueAsInt();

For more usage, refer to `ObjectMapper`, `ObjectReader` and `ObjectWriter` Javadocs.