# 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
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, constructor 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.
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.
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
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, 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.