Package com.fasterxml.jackson.databind

• Interface Summary 

  Interface	Description
  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 

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

  Exception	Description
  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 IOExceptions) 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

  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();