# 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
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).
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.
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.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.
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).
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.KebabCaseStrategy: Naming strategy similar to `PropertyNamingStrategy.SnakeCaseStrategy`, but instead of underscores as separators, uses hyphens.
PropertyNamingStrategy.LowerCaseStrategy: Simple strategy where external name simply only uses lower-case characters, and no separators.
PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy: Deprecated In 2.7 use `PropertyNamingStrategy.SnakeCaseStrategy` instead
PropertyNamingStrategy.PascalCaseStrategy: Deprecated In 2.7 use `PropertyNamingStrategy.UpperCamelCaseStrategy` instead
PropertyNamingStrategy.PropertyNamingStrategyBase
PropertyNamingStrategy.SnakeCaseStrategy: A `PropertyNamingStrategy` that translates typical camel case Java property names to lower case JSON element names, separated by underscores.
PropertyNamingStrategy.UpperCamelCaseStrategy: A `PropertyNamingStrategy` that translates typical camelCase Java property names to PascalCase JSON element names (i.e., with a capital first letter).
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
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
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 `JsonParseException`, `JsonGenerationException`).
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.