Package com.fasterxml.jackson.databind

Contains basic mapper (conversion) functionality thatallows for converting between regular streaming json content andJava objects (beans or Tree Model: support for both is via
ObjectMapper class, as wellas convenience methods included inJsonParser

See:
          Description

Interface Summary
BeanPropertyBean 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).
JsonSerializableInterface that can be implemented by objects that know how to serialize themselves to JSON, using JsonGenerator (and SerializerProvider if necessary).
Module.SetupContextInterface Jackson exposes to modules for purpose of registering extended functionality.
 

Class Summary
AbstractTypeResolverDefines interface for resolvers that can resolve abstract types into concrete ones; either by using static mappings, or possibly by materializing implementations dynamically.
AnnotationIntrospectorAbstract class that defines API used for introspecting annotation-based configuration for serialization and deserialization.
AnnotationIntrospector.PairHelper class that allows using 2 introspectors such that one introspector acts as the primary one to use; and second one as a fallback used if the primary does not provide conclusive or useful result for a method.
AnnotationIntrospector.ReferencePropertyValue type used with managed and back references; contains type and logic name, used to link related references
BeanDescriptionBasic container for information gathered by ClassIntrospector to help in constructing serializers and deserializers.
BeanProperty.StdSimple stand-alone implementation, useful as a placeholder or base class for more complex implementations.
DeserializationConfigObject that contains baseline configuration for deserialization process.
DeserializationContextContext for the process of deserialization a single root-level value.
InjectableValuesAbstract class that defines API for objects that provide value to "inject" during deserialization.
InjectableValues.StdSimple standard implementation which uses a simple Map to store values to inject, identified by simple String keys.
JavaTypeBase 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.NoneThis marker class is only to be used with annotations, to indicate that no deserializer is configured.
JsonMappingException.ReferenceSimple bean class used to contain references.
JsonNodeBase 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 JsonSerializers too) to serialize Objects of arbitrary types into JSON, using provided JsonGenerator.
JsonSerializer.NoneThis marker class is only to be used with annotations, to indicate that no serializer is configured.
KeyDeserializerAbstract class that defines API used for deserializing JSON content field names into Java Map keys.
KeyDeserializer.NoneThis 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.
MappingJsonFactorySub-class of JsonFactory that will create a proper ObjectCodec to allow seamless conversions between Json content and Java objects (POJOs).
ModuleSimple 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.
ObjectMapperThis 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.DefaultTypeResolverBuilderCustomized TypeResolverBuilder that provides type resolver builders used with so-called "default typing" (see ObjectMapper.enableDefaultTyping() for details).
ObjectReaderBuilder 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).
ObjectWriterBuilder object that can be used for per-serialization configuration of serialization parameters, such as JSON View and root type to use.
PropertyNamingStrategyClass 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.LowerCaseWithUnderscoresStrategyA PropertyNamingStrategy that translates typical camel case Java property names to lower case JSON element names, separated by underscores.
PropertyNamingStrategy.PropertyNamingStrategyBase 
SerializationConfigObject that contains baseline configuration for serialization process.
SerializerProviderClass 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
AnnotationIntrospector.ReferenceProperty.Type 
DeserializationFeatureEnumeration that defines simple on/off features that affect the way Java objects are deserialized from JSON
MapperFeatureEnumeration 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.DefaultTypingEnumeration used with ObjectMapper.enableDefaultTyping() to specify what kind of types (classes) default typing should be used for.
SerializationFeatureEnumeration that defines simple on/off features that affect the way Java objects are serialized.
 

Exception Summary
JsonMappingExceptionChecked exception used to signal fatal problems with mapping of content.
RuntimeJsonMappingExceptionWrapper used when interface does not allow throwing a checked JsonMappingException
 

Package com.fasterxml.jackson.databind Description

Contains basic mapper (conversion) functionality thatallows for converting between regular streaming json content andJava objects (beans or Tree Model: support for both is viaObjectMapper class, as wellas convenience methods included inJsonParser

Object mapper will convert Json content to ant frombasic Java wrapper types (Integer, Boolean, Double),Collection types (List, Map), Java Beans,Strings and nulls.

Tree mapper builds dynamically typed tree of JsonNodesfrom 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 (dummynodes are created as necessary to represent "missing" Object fieldsand Array elements)
  • No type casts are usually needed: all public access methods are definedin basic JsonNode class, and when "incompatible" method (such as Arrayelement access on, say, Boolean node) is used, returned node isvirtual "missing" node.
Because of its dynamic nature, Tree mapping is often convenientfor basic path access and tree navigation, where structure ofthe resulting tree is known in advance.



Copyright © 2012
fasterxml.com. All Rights Reserved.


NOTHING
NOTHING
Add the Maven Dependecy to your project: maven dependecy for com.amazonaws : aws-java-sdk : 1.3.14