ObjectMapper (jackson-databind 2.1.0 API)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.fasterxml.jackson.databind
Class ObjectMapper

java.lang.Object
  com.fasterxml.jackson.core.ObjectCodec
      com.fasterxml.jackson.databind.ObjectMapper

All Implemented Interfaces:: Versioned, Serializable

public class ObjectMapper
extends ObjectCodec
implements Versioned, Serializable
extends ObjectCodec
implements Versioned, Serializable

This mapper (or, data binder, or codec) provides functionality for converting between Java objects (instances of JDK provided core classes, beans), and matching JSON constructs. It will use instances of JsonParser and JsonGenerator for implementing actual reading/writing of JSON.

The main conversion API is defined in ObjectCodec, so that implementation details of this class need not be exposed to streaming parser and generator classes.

Note on caching: root-level deserializers are always cached, and accessed using full (generics-aware) type information. This is different from caching of referenced types, which is more limited and is done only for a subset of all deserializer types. The main reason for difference is that at root-level there is no incoming reference (and hence no referencing property, no referral information or annotations to produce differing deserializers), and that the performance impact greatest at root level (since it'll essentially cache the full graph of deserializers involved).

See Also:: Serialized Form

Nested Class Summary
`static class`	`ObjectMapper.DefaultTypeResolverBuilder` Customized `TypeResolverBuilder` that provides type resolver builders used with so-called "default typing" (see `enableDefaultTyping()` for details).
`static class`	`ObjectMapper.DefaultTyping` Enumeration used with `enableDefaultTyping()` to specify what kind of types (classes) default typing should be used for.

Field Summary
`protected static PrettyPrinter`	`_defaultPrettyPrinter`
`protected DeserializationConfig`	`_deserializationConfig` Configuration object that defines basic global settings for the serialization process
`protected DefaultDeserializationContext`	`_deserializationContext` Blueprint context object; stored here to allow custom sub-classes.
`protected InjectableValues`	`_injectableValues` Provider for values to inject in deserialized POJOs.
`protected JsonFactory`	`_jsonFactory` Factory used to create `JsonParser` and `JsonGenerator` instances as necessary.
`protected HashMap<ClassKey,Class<?>>`	`_mixInAnnotations` Mapping that defines how to apply mix-in annotations: key is the type to received additional annotations, and value is the type that has annotations to "mix in".
`protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>>`	`_rootDeserializers` We will use a separate main-level Map for keeping track of root-level deserializers.
`protected RootNameLookup`	`_rootNames` Cache for root names used when root-wrapping is enabled.
`protected SerializationConfig`	`_serializationConfig` Configuration object that defines basic global settings for the serialization process
`protected SerializerFactory`	`_serializerFactory` Serializer factory used for constructing serializers.
`protected DefaultSerializerProvider`	`_serializerProvider` Object that manages access to serializers used for serialization, including caching.
`protected SubtypeResolver`	`_subtypeResolver` Thing used for registering sub-types, resolving them to super/sub-types as needed.
`protected TypeFactory`	`_typeFactory` Specific factory used for creating `JavaType` instances; needed to allow modules to add more custom type handling (mostly to support types of non-Java JVM languages)
`protected static AnnotationIntrospector`	`DEFAULT_ANNOTATION_INTROSPECTOR`
`protected static BaseSettings`	`DEFAULT_BASE` Base settings contain defaults used for all `ObjectMapper` instances.
`protected static ClassIntrospector`	`DEFAULT_INTROSPECTOR`
`protected static VisibilityChecker<?>`	`STD_VISIBILITY_CHECKER`

Constructor Summary
	`ObjectMapper()` Default constructor, which will construct the default `JsonFactory` as necessary, use `SerializerProvider` as its `SerializerProvider`, and `BeanSerializerFactory` as its `SerializerFactory`.
	`ObjectMapper(JsonFactory jf)` Constructs instance that uses specified `JsonFactory` for constructing necessary `JsonParser`s and/or `JsonGenerator`s.
	`ObjectMapper(JsonFactory jf, DefaultSerializerProvider sp, DefaultDeserializationContext dc)` Constructs instance that uses specified `JsonFactory` for constructing necessary `JsonParser`s and/or `JsonGenerator`s, and uses given providers for accessing serializers and deserializers.
`protected`	`ObjectMapper(ObjectMapper src)` Copy-constructor, mostly used to support `copy()`.

Method Summary

protected void _checkInvalidCopy(Class<?> exp)

protected void _configAndWriteValue(JsonGenerator jgen, Object value)
Method called to configure the generator as necessary and then call write functionality

protected void _configAndWriteValue(JsonGenerator jgen, Object value, Class<?> viewClass)

protected Object _convert(Object fromValue, JavaType toValueType)
Actual conversion implementation: instead of using existing read and write methods, much of code is inlined.

protected PrettyPrinter _defaultPrettyPrinter()
Helper method that should return default pretty-printer to use for generators constructed by this mapper, when instructed to use default pretty printer.

protected JsonDeserializer<Object> _findRootDeserializer(DeserializationContext ctxt, JavaType valueType)
Method called to locate deserializer for the passed root-level value.

protected JsonToken _initForReading(JsonParser jp)
Method called to ensure that given parser is ready for reading content for data binding.

protected Object _readMapAndClose(JsonParser jp, JavaType valueType)

protected Object _readValue(DeserializationConfig cfg, JsonParser jp, JavaType valueType)
Actual implementation of value reading+binding operation.

protected DefaultSerializerProvider _serializerProvider(SerializationConfig config)
Overridable helper method used for constructing SerializerProvider to use for serialization.

protected Object _unwrapAndDeserialize(JsonParser jp, DeserializationContext ctxt, DeserializationConfig config, JavaType rootType, JsonDeserializer<Object> deser)

void acceptJsonFormatVisitor(Class<?> type, JsonFormatVisitorWrapper visitor)
Method for visiting type hierarchy for given type, using specified visitor.

void acceptJsonFormatVisitor(JavaType type, JsonFormatVisitorWrapper visitor)
Method for visiting type hierarchy for given type, using specified visitor.

ObjectMapper addHandler(DeserializationProblemHandler h)
Method for adding specified DeserializationProblemHandler to be used for handling specific problems during deserialization.

void addMixInAnnotations(Class<?> target, Class<?> mixinSource)
Method to use for adding mix-in annotations to use for augmenting specified class or interface.

boolean canDeserialize(JavaType type)
Method that can be called to check whether mapper thinks it could deserialize an Object of given type.

boolean canSerialize(Class<?> type)
Method that can be called to check whether mapper thinks it could serialize an instance of given Class.

ObjectMapper clearProblemHandlers()
Method for removing all registered DeserializationProblemHandlers instances from this mapper.

ObjectMapper configure(DeserializationFeature f, boolean state)
Method for changing state of an on/off deserialization feature for this object mapper.

ObjectMapper configure(JsonGenerator.Feature f, boolean state)
Method for changing state of an on/off JsonGenerator feature for JsonFactory instance this object mapper uses.

ObjectMapper configure(JsonParser.Feature f, boolean state)
Method for changing state of an on/off JsonParser feature for JsonFactory instance this object mapper uses.

ObjectMapper configure(MapperFeature f, boolean state)
Method for changing state of an on/off mapper feature for this mapper instance.

ObjectMapper configure(SerializationFeature f, boolean state)
Method for changing state of an on/off serialization feature for this object mapper.

JavaType constructType(Type t)
Convenience method for constructing JavaType out of given type (typically java.lang.Class), but without explicit context.





<T> T

convertValue(Object fromValue,
             Class<T> toValueType)

Convenience method for doing two-step conversion from given value, into instance of given value type.





<T> T

convertValue(Object fromValue,
             JavaType toValueType)





<T> T

convertValue(Object fromValue,
             TypeReference<?> toValueTypeRef)

ObjectMapper copy()
Method for creating a new ObjectMapper instance that has same initial configuration as this instance.

ArrayNode createArrayNode()
Note: return type is co-variant, as basic ObjectCodec abstraction can not refer to concrete node types (as it's part of core package, whereas impls are part of mapper package)

protected DefaultDeserializationContext createDeserializationContext(JsonParser jp, DeserializationConfig cfg)
Internal helper method called to create an instance of DeserializationContext for deserializing a single root value.

ObjectNode createObjectNode()
Note: return type is co-variant, as basic ObjectCodec abstraction can not refer to concrete node types (as it's part of core package, whereas impls are part of mapper package)

ObjectMapper disable(DeserializationFeature feature)
Method for enabling specified DeserializationConfig features.

ObjectMapper disable(DeserializationFeature first, DeserializationFeature... f)
Method for enabling specified DeserializationConfig features.

ObjectMapper disable(MapperFeature... f)
Method for enabling specified DeserializationConfig features.

ObjectMapper disable(SerializationFeature f)
Method for enabling specified DeserializationConfig features.

ObjectMapper disable(SerializationFeature first, SerializationFeature... f)
Method for enabling specified DeserializationConfig features.

ObjectMapper disableDefaultTyping()
Method for disabling automatic inclusion of type information; if so, only explicitly annotated types (ones with JsonTypeInfo) will have additional embedded type information.

ObjectMapper enable(DeserializationFeature feature)
Method for enabling specified DeserializationConfig features.

ObjectMapper enable(DeserializationFeature first, DeserializationFeature... f)
Method for enabling specified DeserializationConfig features.

ObjectMapper enable(MapperFeature... f)
Method for enabling specified MapperConfig features.

ObjectMapper enable(SerializationFeature f)
Method for enabling specified DeserializationConfig feature.

ObjectMapper enable(SerializationFeature first, SerializationFeature... f)
Method for enabling specified DeserializationConfig features.

ObjectMapper enableDefaultTyping()
Convenience method that is equivalent to calling

ObjectMapper enableDefaultTyping(ObjectMapper.DefaultTyping dti)
Convenience method that is equivalent to calling

ObjectMapper enableDefaultTyping(ObjectMapper.DefaultTyping applicability, JsonTypeInfo.As includeAs)
Method for enabling automatic inclusion of type information, needed for proper deserialization of polymorphic types (unless types have been annotated with JsonTypeInfo).

ObjectMapper enableDefaultTypingAsProperty(ObjectMapper.DefaultTyping applicability, String propertyName)
Method for enabling automatic inclusion of type information -- needed for proper deserialization of polymorphic types (unless types have been annotated with JsonTypeInfo) -- using "As.PROPERTY" inclusion mechanism and specified property name to use for inclusion (default being "@class" since default type information always uses class name as type identifier)

Class<?> findMixInClassFor(Class<?> cls)

JsonSchema generateJsonSchema(Class<?> t)
Generate Json-schema instance for specified class.

DeserializationConfig getDeserializationConfig()
Method that returns the shared default DeserializationConfig object that defines configuration settings for deserialization.

DeserializationContext getDeserializationContext()
Method for getting current DeserializationContext.

JsonFactory getFactory()
Method that can be used to get hold of JsonFactory that this mapper uses if it needs to construct JsonParsers and/or JsonGenerators.

JsonFactory getJsonFactory()
Deprecated. Since 2.1: Use getFactory() instead

JsonNodeFactory getNodeFactory()
Method that can be used to get hold of JsonNodeFactory that this mapper will use when directly constructing root JsonNode instances for Trees.

SerializationConfig getSerializationConfig()
Method that returns the shared default SerializationConfig object that defines configuration settings for serialization.

SerializerFactory getSerializerFactory()
Method for getting current SerializerFactory.

SerializerProvider getSerializerProvider()

SubtypeResolver getSubtypeResolver()
Method for accessing subtype resolver in use.

TypeFactory getTypeFactory()
Accessor for getting currently configured TypeFactory instance.

VisibilityChecker<?> getVisibilityChecker()
Method for accessing currently configured visibility checker; object used for determining whether given property element (method, field, constructor) can be auto-detected or not.

boolean isEnabled(DeserializationFeature f)
Method for checking whether given deserialization-specific feature is enabled.

boolean isEnabled(JsonFactory.Feature f)
Convenience method, equivalent to:

boolean isEnabled(JsonGenerator.Feature f)
Convenience method, equivalent to:

boolean isEnabled(JsonParser.Feature f)
Convenience method, equivalent to:

boolean isEnabled(MapperFeature f)
Method for checking whether given Mapper feature is enabled.

boolean isEnabled(SerializationFeature f)
Method for checking whether given serialization-specific feature is enabled.

int mixInCount()

ObjectReader reader()
Factory method for constructing ObjectReader with default settings.

ObjectReader reader(Base64Variant defaultBase64)
Factory method for constructing ObjectReader that will use specified Base64 encoding variant for Base64-encoded binary data.

ObjectReader reader(Class<?> type)
Factory method for constructing ObjectReader that will read or update instances of specified type

ObjectReader reader(DeserializationFeature feature)
Factory method for constructing ObjectReader with specified feature enabled (compared to settings that this mapper instance has).

ObjectReader reader(DeserializationFeature first, DeserializationFeature... other)
Factory method for constructing ObjectReader with specified features enabled (compared to settings that this mapper instance has).

ObjectReader reader(FormatSchema schema)
Factory method for constructing ObjectReader that will pass specific schema object to JsonParser used for reading content.

ObjectReader reader(InjectableValues injectableValues)
Factory method for constructing ObjectReader that will use specified injectable values.

ObjectReader reader(JavaType type)
Factory method for constructing ObjectReader that will read or update instances of specified type

ObjectReader reader(JsonNodeFactory f)
Factory method for constructing ObjectReader that will use specified JsonNodeFactory for constructing JSON trees.

ObjectReader reader(TypeReference<?> type)
Factory method for constructing ObjectReader that will read or update instances of specified type

ObjectReader readerForUpdating(Object valueToUpdate)
Factory method for constructing ObjectReader that will update given Object (usually Bean, but can be a Collection or Map as well, but NOT an array) with JSON data.

ObjectReader readerWithView(Class<?> view)
Factory method for constructing ObjectReader that will deserialize objects using specified JSON View (filter).

JsonNode readTree(byte[] content)
Method to deserialize JSON content as tree expressed using set of JsonNode instances.

JsonNode readTree(File file)
Method to deserialize JSON content as tree expressed using set of JsonNode instances.

JsonNode readTree(InputStream in)
Method to deserialize JSON content as tree expressed using set of JsonNode instances.





<T extends TreeNode> 


T

readTree(JsonParser jp)
Method to deserialize JSON content as tree expressed using set of JsonNode instances.

JsonNode readTree(Reader r)
Method to deserialize JSON content as tree expressed using set of JsonNode instances.

JsonNode readTree(String content)
Method to deserialize JSON content as tree expressed using set of JsonNode instances.

JsonNode readTree(URL source)
Method to deserialize JSON content as tree expressed using set of JsonNode instances.





<T> T

readValue(byte[] src,
          Class<T> valueType)





<T> T

readValue(byte[] src,
          int offset,
          int len,
          Class<T> valueType)





<T> T

readValue(byte[] src,
          int offset,
          int len,
          JavaType valueType)





<T> T

readValue(byte[] src,
          int offset,
          int len,
          TypeReference valueTypeRef)





<T> T

readValue(byte[] src,
          JavaType valueType)





<T> T

readValue(byte[] src,
          TypeReference valueTypeRef)





<T> T

readValue(File src,
          Class<T> valueType)





<T> T

readValue(File src,
          JavaType valueType)





<T> T

readValue(File src,
          TypeReference valueTypeRef)





<T> T

readValue(InputStream src,
          Class<T> valueType)





<T> T

readValue(InputStream src,
          JavaType valueType)





<T> T

readValue(InputStream src,
          TypeReference valueTypeRef)





<T> T

readValue(JsonParser jp,
          Class<T> valueType)

Method to deserialize JSON content into a non-container type (it can be an array type, however): typically a bean, array or a wrapper type (like Boolean).





<T> T

readValue(JsonParser jp,
          JavaType valueType)

Type-safe overloaded method, basically alias for readValue(JsonParser, ResolvedType).





<T> T

readValue(JsonParser jp,
          ResolvedType valueType)

Method to deserialize JSON content into a Java type, reference to which is passed as argument.





<T> T

readValue(JsonParser jp,
          TypeReference<?> valueTypeRef)

Method to deserialize JSON content into a Java type, reference to which is passed as argument.





<T> T

readValue(Reader src,
          Class<T> valueType)





<T> T

readValue(Reader src,
          JavaType valueType)





<T> T

readValue(Reader src,
          TypeReference valueTypeRef)





<T> T

readValue(String content,
          Class<T> valueType)





<T> T

readValue(String content,
          JavaType valueType)





<T> T

readValue(String content,
          TypeReference valueTypeRef)





<T> T

readValue(URL src,
          Class<T> valueType)





<T> T

readValue(URL src,
          JavaType valueType)





<T> T

readValue(URL src,
          TypeReference valueTypeRef)





<T> MappingIterator<T>

readValues(JsonParser jp,
           Class<T> valueType)

Type-safe overloaded method, basically alias for readValues(JsonParser, ResolvedType).





<T> MappingIterator<T>

readValues(JsonParser jp,
           JavaType valueType)

Type-safe overloaded method, basically alias for readValues(JsonParser, ResolvedType).





<T> MappingIterator<T>

readValues(JsonParser jp,
           ResolvedType valueType)

Method for reading sequence of Objects from parser stream.





<T> MappingIterator<T>

readValues(JsonParser jp,
           TypeReference<?> valueTypeRef)

Method for reading sequence of Objects from parser stream.

ObjectMapper registerModule(Module module)
Method for registering a module that can extend functionality provided by this mapper; for example, by adding providers for custom serializers and deserializers.

void registerSubtypes(Class<?>... classes)
Method for registering specified class as a subtype, so that typename-based resolution can link supertypes to subtypes (as an alternative to using annotations).

void registerSubtypes(NamedType... types)
Method for registering specified class as a subtype, so that typename-based resolution can link supertypes to subtypes (as an alternative to using annotations).

ObjectMapper setAnnotationIntrospector(AnnotationIntrospector ai)
Method for changing AnnotationIntrospector used by this mapper instance for both serialization and deserialization

ObjectMapper setAnnotationIntrospectors(AnnotationIntrospector serializerAI, AnnotationIntrospector deserializerAI)
Method for changing AnnotationIntrospector instances used by this mapper instance for serialization and deserialization, specifying them separately so that different introspection can be used for different aspects

ObjectMapper setBase64Variant(Base64Variant v)
Method that will configure default Base64Variant that byte[] serializers and deserializers will use.

ObjectMapper setDateFormat(DateFormat dateFormat)
Method for configuring the default DateFormat to use when serializing time values as Strings, and deserializing from JSON Strings.

ObjectMapper setDefaultTyping(TypeResolverBuilder<?> typer)
Method for enabling automatic inclusion of type information, using specified handler object for determining which types this affects, as well as details of how information is embedded.

void setFilters(FilterProvider filterProvider)
Convenience method that is equivalent to:

Object setHandlerInstantiator(HandlerInstantiator hi)
Method for configuring HandlerInstantiator to use for creating instances of handlers (such as serializers, deserializers, type and type id resolvers), given a class.

ObjectMapper setInjectableValues(InjectableValues injectableValues)
Method for configuring InjectableValues which used to find values to inject.

ObjectMapper setLocale(Locale l)
Method for overriding default locale to use for formatting.

void setMixInAnnotations(Map<Class<?>,Class<?>> sourceMixins)
Method to use for defining mix-in annotations to use for augmenting annotations that processable (serializable / deserializable) classes have.

ObjectMapper setNodeFactory(JsonNodeFactory f)
Method for specifying JsonNodeFactory to use for constructing root level tree nodes (via method createObjectNode()

ObjectMapper setPropertyNamingStrategy(PropertyNamingStrategy s)
Method for setting custom property naming strategy to use.

ObjectMapper setSerializationInclusion(JsonInclude.Include incl)
Method for setting defalt POJO property inclusion strategy for serialization.

ObjectMapper setSerializerFactory(SerializerFactory f)
Method for setting specific SerializerFactory to use for constructing (bean) serializers.

ObjectMapper setSerializerProvider(DefaultSerializerProvider p)
Method for setting specific SerializerProvider to use for handling caching of JsonSerializer instances.

ObjectMapper setSubtypeResolver(SubtypeResolver str)
Method for setting custom subtype resolver to use.

ObjectMapper setTimeZone(TimeZone tz)
Method for overriding default TimeZone to use for formatting.

ObjectMapper setTypeFactory(TypeFactory f)
Method that can be used to override TypeFactory instance used by this mapper.

ObjectMapper setVisibility(PropertyAccessor forMethod, JsonAutoDetect.Visibility visibility)
Convenience method that allows changing configuration for underlying VisibilityCheckers, to change details of what kinds of properties are auto-detected.

void setVisibilityChecker(VisibilityChecker<?> vc)
Method for setting currently configured visibility checker; object used for determining whether given property element (method, field, constructor) can be auto-detected or not.

JsonParser treeAsTokens(TreeNode n)
Method for constructing a JsonParser out of JSON tree representation.





<T> T

treeToValue(TreeNode n,
            Class<T> valueType)

Convenience conversion method that will bind data given JSON tree contains into specific value (usually bean) type.





<T extends JsonNode> 


T

valueToTree(Object fromValue)
Reverse of treeToValue(com.fasterxml.jackson.core.TreeNode, java.lang.Class); given a value (usually bean), will construct equivalent JSON Tree representation.

Version version()
Method that will return version information stored in and read from jar that contains this class.

ObjectWriter writer()
Convenience method for constructing ObjectWriter with default settings.

ObjectWriter writer(Base64Variant defaultBase64)
Factory method for constructing ObjectWriter that will use specified Base64 encoding variant for Base64-encoded binary data.

ObjectWriter writer(DateFormat df)
Factory method for constructing ObjectWriter that will serialize objects using specified DateFormat; or, if null passed, using timestamp (64-bit number.

ObjectWriter writer(FilterProvider filterProvider)
Factory method for constructing ObjectWriter that will serialize objects using specified filter provider.

ObjectWriter writer(FormatSchema schema)
Factory method for constructing ObjectWriter that will pass specific schema object to JsonGenerator used for writing content.

ObjectWriter writer(PrettyPrinter pp)
Factory method for constructing ObjectWriter that will serialize objects using specified pretty printer for indentation (or if null, no pretty printer)

ObjectWriter writer(SerializationFeature feature)
Factory method for constructing ObjectWriter with specified feature enabled (compared to settings that this mapper instance has).

ObjectWriter writer(SerializationFeature first, SerializationFeature... other)
Factory method for constructing ObjectWriter with specified features enabled (compared to settings that this mapper instance has).

ObjectWriter writerWithDefaultPrettyPrinter()
Factory method for constructing ObjectWriter that will serialize objects using the default pretty printer for indentation

ObjectWriter writerWithType(Class<?> rootType)
Factory method for constructing ObjectWriter that will serialize objects using specified root type, instead of actual runtime type of value.

ObjectWriter writerWithType(JavaType rootType)
Factory method for constructing ObjectWriter that will serialize objects using specified root type, instead of actual runtime type of value.

ObjectWriter writerWithType(TypeReference<?> rootType)
Factory method for constructing ObjectWriter that will serialize objects using specified root type, instead of actual runtime type of value.

ObjectWriter writerWithView(Class<?> serializationView)
Factory method for constructing ObjectWriter that will serialize objects using specified JSON View (filter).

void writeTree(JsonGenerator jgen, JsonNode rootNode)
Method to serialize given JSON Tree, using generator provided.

void writeValue(File resultFile, Object value)
Method that can be used to serialize any Java value as JSON output, written to File provided.

void writeValue(JsonGenerator jgen, Object value)
Method that can be used to serialize any Java value as JSON output, using provided JsonGenerator.

void writeValue(OutputStream out, Object value)
Method that can be used to serialize any Java value as JSON output, using output stream provided (using encoding JsonEncoding.UTF8).

void writeValue(Writer w, Object value)
Method that can be used to serialize any Java value as JSON output, using Writer provided.

byte[] writeValueAsBytes(Object value)
Method that can be used to serialize any Java value as a byte array.

String writeValueAsString(Object value)
Method that can be used to serialize any Java value as a String.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

DEFAULT_INTROSPECTOR

protected static final ClassIntrospector DEFAULT_INTROSPECTOR

DEFAULT_ANNOTATION_INTROSPECTOR

protected static final AnnotationIntrospector DEFAULT_ANNOTATION_INTROSPECTOR

STD_VISIBILITY_CHECKER

protected static final VisibilityChecker<?> STD_VISIBILITY_CHECKER

_defaultPrettyPrinter

protected static final PrettyPrinter _defaultPrettyPrinter

DEFAULT_BASE

protected static final BaseSettings DEFAULT_BASE

Base settings contain defaults used for all ObjectMapper instances.

_jsonFactory

protected final JsonFactory _jsonFactory

Factory used to create JsonParser and JsonGenerator instances as necessary.

_typeFactory

protected TypeFactory _typeFactory

Specific factory used for creating JavaType instances; needed to allow modules to add more custom type handling (mostly to support types of non-Java JVM languages)

_injectableValues

protected InjectableValues _injectableValues

Provider for values to inject in deserialized POJOs.

_subtypeResolver

protected SubtypeResolver _subtypeResolver

Thing used for registering sub-types, resolving them to super/sub-types as needed.

_rootNames

protected final RootNameLookup _rootNames

Cache for root names used when root-wrapping is enabled.

_mixInAnnotations

protected final HashMap<ClassKey,Class<?>> _mixInAnnotations

Mapping that defines how to apply mix-in annotations: key is the type to received additional annotations, and value is the type that has annotations to "mix in".

Annotations associated with the value classes will be used to override annotations of the key class, associated with the same field or method. They can be further masked by sub-classes: you can think of it as injecting annotations between the target class and its sub-classes (or interfaces)

_serializationConfig

protected SerializationConfig _serializationConfig

Configuration object that defines basic global settings for the serialization process

_serializerProvider

protected DefaultSerializerProvider _serializerProvider

Object that manages access to serializers used for serialization, including caching. It is configured with _serializerFactory to allow for constructing custom serializers.

Note: while serializers are only exposed SerializerProvider, mappers and readers need to access additional API defined by DefaultSerializerProvider

_serializerFactory

protected SerializerFactory _serializerFactory

Serializer factory used for constructing serializers.

_deserializationConfig

protected DeserializationConfig _deserializationConfig

Configuration object that defines basic global settings for the serialization process

_deserializationContext

protected DefaultDeserializationContext _deserializationContext

Blueprint context object; stored here to allow custom sub-classes. Contains references to objects needed for deserialization construction (cache, factory).

_rootDeserializers

protected final ConcurrentHashMap<JavaType,JsonDeserializer<Object>> _rootDeserializers

We will use a separate main-level Map for keeping track of root-level deserializers. This is where most succesful cache lookups get resolved. Map will contain resolvers for all kinds of types, including container types: this is different from the component cache which will only cache bean deserializers.

Given that we don't expect much concurrency for additions (should very quickly converge to zero after startup), let's explicitly define a low concurrency setting.

Since version 1.5, these may are either "raw" deserializers (when no type information is needed for base type), or type-wrapped deserializers (if it is needed)

Constructor Detail

ObjectMapper

public ObjectMapper()

Default constructor, which will construct the default JsonFactory as necessary, use SerializerProvider as its SerializerProvider, and BeanSerializerFactory as its SerializerFactory. This means that it can serialize all standard JDK types, as well as regular Java Beans (based on method names and Jackson-specific annotations), but does not support JAXB annotations.

ObjectMapper

public ObjectMapper(JsonFactory jf)

Constructs instance that uses specified JsonFactory for constructing necessary JsonParsers and/or JsonGenerators.

ObjectMapper

protected ObjectMapper(ObjectMapper src)

Copy-constructor, mostly used to support copy().

Since:: 2.1

ObjectMapper

public ObjectMapper(JsonFactory jf,
                    DefaultSerializerProvider sp,
                    DefaultDeserializationContext dc)

Constructs instance that uses specified JsonFactory for constructing necessary JsonParsers and/or JsonGenerators, and uses given providers for accessing serializers and deserializers.

Parameters:: jf - JsonFactory to use: if null, a new MappingJsonFactory will be constructed; sp - SerializerProvider to use: if null, a SerializerProvider will be constructed; dc - Blueprint deserialization context instance to use for creating actual context objects; if null, will construct standard DeserializationContext

Method Detail

copy

public ObjectMapper copy()

Method for creating a new ObjectMapper instance that has same initial configuration as this instance. Note that this also requires making a copy of the underlying JsonFactory instance.

Method is typically used when multiple, differently configured mappers are needed. Although configuration is shared, cached serializers and deserializers are NOT shared, which means that the new instance may be re-configured before use; meaning that it behaves the same way as if an instance was constructed from scratch.

Since:: 2.1

_checkInvalidCopy

protected void _checkInvalidCopy(Class<?> exp)

Parameters:: exp -
Since:: 2.1

version

public Version version()

Method that will return version information stored in and read from jar that contains this class.

Specified by:: version in interface Versioned

registerModule

public ObjectMapper registerModule(Module module)

Method for registering a module that can extend functionality provided by this mapper; for example, by adding providers for custom serializers and deserializers.

Parameters:: module - Module to register

getSerializationConfig

public SerializationConfig getSerializationConfig()

Method that returns the shared default SerializationConfig object that defines configuration settings for serialization.

Note that since instances are immutable, you can NOT change settings by accessing an instance and calling methods: this will simply create new instance of config object.

getDeserializationConfig

public DeserializationConfig getDeserializationConfig()

Method that returns the shared default DeserializationConfig object that defines configuration settings for deserialization.

Note that since instances are immutable, you can NOT change settings by accessing an instance and calling methods: this will simply create new instance of config object.

getDeserializationContext

public DeserializationContext getDeserializationContext()

Method for getting current DeserializationContext.

Note that since instances are immutable, you can NOT change settings by accessing an instance and calling methods: this will simply create new instance of context object.

setSerializerFactory

public ObjectMapper setSerializerFactory(SerializerFactory f)

Method for setting specific SerializerFactory to use for constructing (bean) serializers.

getSerializerFactory

public SerializerFactory getSerializerFactory()

Method for getting current SerializerFactory.

Note that since instances are immutable, you can NOT change settings by accessing an instance and calling methods: this will simply create new instance of factory object.

setSerializerProvider

public ObjectMapper setSerializerProvider(DefaultSerializerProvider p)

Method for setting specific SerializerProvider to use for handling caching of JsonSerializer instances.

getSerializerProvider

public SerializerProvider getSerializerProvider()

setMixInAnnotations

public final void setMixInAnnotations(Map<Class<?>,Class<?>> sourceMixins)

Method to use for defining mix-in annotations to use for augmenting annotations that processable (serializable / deserializable) classes have. Mixing in is done when introspecting class annotations and properties. Map passed contains keys that are target classes (ones to augment with new annotation overrides), and values that are source classes (have annotations to use for augmentation). Annotations from source classes (and their supertypes) will override annotations that target classes (and their super-types) have.

addMixInAnnotations

public final void addMixInAnnotations(Class<?> target,
                                      Class<?> mixinSource)

Method to use for adding mix-in annotations to use for augmenting specified class or interface. All annotations from mixinSource are taken to override annotations that target (or its supertypes) has.

Parameters:: target - Class (or interface) whose annotations to effectively override; mixinSource - Class (or interface) whose annotations are to be "added" to target's annotations, overriding as necessary

findMixInClassFor

public final Class<?> findMixInClassFor(Class<?> cls)

mixInCount

public final int mixInCount()

getVisibilityChecker

public VisibilityChecker<?> getVisibilityChecker()

Method for accessing currently configured visibility checker; object used for determining whether given property element (method, field, constructor) can be auto-detected or not.

setVisibilityChecker

public void setVisibilityChecker(VisibilityChecker<?> vc)

Method for setting currently configured visibility checker; object used for determining whether given property element (method, field, constructor) can be auto-detected or not. This default checker is used if no per-class overrides are defined.

setVisibility

public ObjectMapper setVisibility(PropertyAccessor forMethod,
                                  JsonAutoDetect.Visibility visibility)

Convenience method that allows changing configuration for underlying VisibilityCheckers, to change details of what kinds of properties are auto-detected. Basically short cut for doing:

  mapper.setVisibilityChecker(
     mapper.getVisibilityChecker().withVisibility(forMethod, visibility)
  );

one common use case would be to do:

  mapper.setVisibility(JsonMethod.FIELD, Visibility.ANY);

which would make all member fields serializable without further annotations, instead of just public fields (default setting).

Parameters:: forMethod - Type of property descriptor affected (field, getter/isGetter, setter, creator); visibility - Minimum visibility to require for the property descriptors of type
Returns:: Modified mapper instance (that is, "this"), to allow chaining of configuration calls

getSubtypeResolver

public SubtypeResolver getSubtypeResolver()

Method for accessing subtype resolver in use.

setSubtypeResolver

public ObjectMapper setSubtypeResolver(SubtypeResolver str)

Method for setting custom subtype resolver to use.

setAnnotationIntrospector

public ObjectMapper setAnnotationIntrospector(AnnotationIntrospector ai)

Method for changing AnnotationIntrospector used by this mapper instance for both serialization and deserialization

setAnnotationIntrospectors

public ObjectMapper setAnnotationIntrospectors(AnnotationIntrospector serializerAI,
                                               AnnotationIntrospector deserializerAI)

Method for changing AnnotationIntrospector instances used by this mapper instance for serialization and deserialization, specifying them separately so that different introspection can be used for different aspects

Parameters:: serializerAI - AnnotationIntrospector to use for configuring serialization; deserializerAI - AnnotationIntrospector to use for configuring deserialization
Since:: 2.1

setPropertyNamingStrategy

public ObjectMapper setPropertyNamingStrategy(PropertyNamingStrategy s)

Method for setting custom property naming strategy to use.

setSerializationInclusion

public ObjectMapper setSerializationInclusion(JsonInclude.Include incl)

Method for setting defalt POJO property inclusion strategy for serialization.

enableDefaultTyping

public ObjectMapper enableDefaultTyping()

Convenience method that is equivalent to calling

  enableObjectTyping(DefaultTyping.OBJECT_AND_NON_CONCRETE);

enableDefaultTyping

public ObjectMapper enableDefaultTyping(ObjectMapper.DefaultTyping dti)

Convenience method that is equivalent to calling

  enableObjectTyping(dti, JsonTypeInfo.As.WRAPPER_ARRAY);

enableDefaultTyping

public ObjectMapper enableDefaultTyping(ObjectMapper.DefaultTyping applicability,
                                        JsonTypeInfo.As includeAs)

Method for enabling automatic inclusion of type information, needed for proper deserialization of polymorphic types (unless types have been annotated with JsonTypeInfo).

Parameters:: applicability - Defines kinds of types for which additional type information is added; see ObjectMapper.DefaultTyping for more information.

enableDefaultTypingAsProperty

public ObjectMapper enableDefaultTypingAsProperty(ObjectMapper.DefaultTyping applicability,
                                                  String propertyName)

Method for enabling automatic inclusion of type information -- needed for proper deserialization of polymorphic types (unless types have been annotated with JsonTypeInfo) -- using "As.PROPERTY" inclusion mechanism and specified property name to use for inclusion (default being "@class" since default type information always uses class name as type identifier)

disableDefaultTyping

public ObjectMapper disableDefaultTyping()

Method for disabling automatic inclusion of type information; if so, only explicitly annotated types (ones with JsonTypeInfo) will have additional embedded type information.

setDefaultTyping

public ObjectMapper setDefaultTyping(TypeResolverBuilder<?> typer)

Method for enabling automatic inclusion of type information, using specified handler object for determining which types this affects, as well as details of how information is embedded.

Parameters:: typer - Type information inclusion handler

registerSubtypes

public void registerSubtypes(Class<?>... classes)

Method for registering specified class as a subtype, so that typename-based resolution can link supertypes to subtypes (as an alternative to using annotations). Type for given class is determined from appropriate annotation; or if missing, default name (unqualified class name)

registerSubtypes

public void registerSubtypes(NamedType... types)

Method for registering specified class as a subtype, so that typename-based resolution can link supertypes to subtypes (as an alternative to using annotations). Name may be provided as part of argument, but if not will be based on annotations or use default name (unqualified class name).

getTypeFactory

public TypeFactory getTypeFactory()

Accessor for getting currently configured TypeFactory instance.

setTypeFactory

public ObjectMapper setTypeFactory(TypeFactory f)

Method that can be used to override TypeFactory instance used by this mapper.

Note: will also set TypeFactory that deserialization and serialization config objects use.

constructType

public JavaType constructType(Type t)

Convenience method for constructing JavaType out of given type (typically java.lang.Class), but without explicit context.

setNodeFactory

public ObjectMapper setNodeFactory(JsonNodeFactory f)

Method for specifying JsonNodeFactory to use for constructing root level tree nodes (via method createObjectNode()

addHandler

public ObjectMapper addHandler(DeserializationProblemHandler h)

Method for adding specified DeserializationProblemHandler to be used for handling specific problems during deserialization.

clearProblemHandlers

public ObjectMapper clearProblemHandlers()

Method for removing all registered DeserializationProblemHandlers instances from this mapper.

setFilters

public void setFilters(FilterProvider filterProvider)

Convenience method that is equivalent to:

  mapper.setFilters(mapper.getSerializationConfig().withFilters(filterProvider));

Note that usually it is better to use method writer(FilterProvider); however, sometimes this method is more convenient. For example, some frameworks only allow configuring of ObjectMapper instances and not ObjectWriters.

setBase64Variant

public ObjectMapper setBase64Variant(Base64Variant v)

Method that will configure default Base64Variant that byte[] serializers and deserializers will use.

Parameters:: v - Base64 variant to use
Since:: 2.1

getFactory

public JsonFactory getFactory()

Method that can be used to get hold of JsonFactory that this mapper uses if it needs to construct JsonParsers and/or JsonGenerators.

Overrides:: getFactory in class ObjectCodec

Returns:: JsonFactory that this mapper uses when it needs to construct Json parser and generators

getJsonFactory

@Deprecated
public JsonFactory getJsonFactory()

Deprecated. Since 2.1: Use getFactory() instead

Specified by:: getJsonFactory in class ObjectCodec

setDateFormat

public ObjectMapper setDateFormat(DateFormat dateFormat)

Method for configuring the default DateFormat to use when serializing time values as Strings, and deserializing from JSON Strings. This is preferably to directly modifying SerializationConfig and DeserializationConfig instances. If you need per-request configuration, use writer(DateFormat) to create properly configured ObjectWriter and use that; this because ObjectWriters are thread-safe whereas ObjectMapper itself is only thread-safe when configuring methods (such as this one) are NOT called.

setHandlerInstantiator

public Object setHandlerInstantiator(HandlerInstantiator hi)

Method for configuring HandlerInstantiator to use for creating instances of handlers (such as serializers, deserializers, type and type id resolvers), given a class.

Parameters:: hi - Instantiator to use; if null, use the default implementation

setInjectableValues

public ObjectMapper setInjectableValues(InjectableValues injectableValues)

Method for configuring InjectableValues which used to find values to inject.

setLocale

public ObjectMapper setLocale(Locale l)

Method for overriding default locale to use for formatting. Default value used is Locale.getDefault().

setTimeZone

public ObjectMapper setTimeZone(TimeZone tz)

Method for overriding default TimeZone to use for formatting. Default value used is TimeZone.getDefault().

configure

public ObjectMapper configure(MapperFeature f,
                              boolean state)

Method for changing state of an on/off mapper feature for this mapper instance.

configure

public ObjectMapper configure(SerializationFeature f,
                              boolean state)

Method for changing state of an on/off serialization feature for this object mapper.

configure

public ObjectMapper configure(DeserializationFeature f,
                              boolean state)

Method for changing state of an on/off deserialization feature for this object mapper.

configure

public ObjectMapper configure(JsonParser.Feature f,
                              boolean state)

Method for changing state of an on/off JsonParser feature for JsonFactory instance this object mapper uses.

This is method is basically a shortcut method for calling JsonFactory.enable(com.fasterxml.jackson.core.JsonFactory.Feature) on the shared JsonFactory this mapper uses (which is accessible using getJsonFactory()).

configure

public ObjectMapper configure(JsonGenerator.Feature f,
                              boolean state)

Method for changing state of an on/off JsonGenerator feature for JsonFactory instance this object mapper uses.

enable

public ObjectMapper enable(MapperFeature... f)

Method for enabling specified MapperConfig features. Modifies and returns this instance; no new object is created.