ObjectMapper (Red Hat JBoss Enterprise Application Platform 7.1.0.Beta1 public API)

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

All Implemented Interfaces:

Versioned, Serializable
```
public class ObjectMapper
extends ObjectCodec
implements Versioned, Serializable
```
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. It is also highly customizable to work both with different styles of JSON content, and to support more advanced Object concepts such as polymorphism and Object identity. ObjectMapper also acts as a factory for more advanced ObjectReader and ObjectWriter classes. Mapper (and ObjectReaders, ObjectWriters it constructs) will use instances of JsonParser and JsonGenerator for implementing actual reading/writing of JSON. Note that although most read and write methods are exposed through this class, some of the functionality is only exposed via ObjectReader and ObjectWriter: specifically, reading/writing of longer sequences of values is only available through ObjectReader.readValues(InputStream) and ObjectWriter.writeValues(OutputStream).
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(); 
```
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. Usage via ObjectCodec is, however, usually only for cases where dependency to ObjectMapper is either not possible (from Streaming API), or undesireable (when only relying on Streaming API).
Mapper instances are fully thread-safe provided that ALL configuration of the instance occurs before ANY read or write calls. If configuration of a mapper is modified after first usage, changes may or may not take effect, and configuration calls themselves may fail. If you need to use different configuration, you have two main possibilities:
- Construct and use ObjectReader for reading, ObjectWriter for writing. Both types are fully immutable and you can freely create new instances with different configuration using either factory methods of ObjectMapper, or readers/writers themselves. Construction of new ObjectReaders and ObjectWriters is a very light-weight operation so it is usually appropriate to create these on per-call basis, as needed, for configuring things like optional indentation of JSON.
- If the specific kind of configurability is not available via ObjectReader and ObjectWriter, you may need to use multiple ObjectMapper instead (for example: you can not change mix-in annotations on-the-fly; or, set of custom (de)serializers). To help with this usage, you may want to use method copy() which creates a clone of the mapper with specific configuration, and allows configuration of the copied instance before it gets used. Note that copy() operation is as expensive as constructing a new ObjectMapper instance: if possible, you should still pool and reuse mappers if you intend to use them for multiple operations.
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

Nested Classes
Modifier and Type	Class and Description
`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

Fields
Modifier and Type	Field and Description
`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 SimpleMixInResolver`	`_mixIns` 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 ConfigOverrides`	`_propertyOverrides` Currently active per-type configuration overrides, accessed by declared type of property.
`protected Set<Object>`	`_registeredModuleTypes` Set of module types (as per `Module.getTypeId()` that have been registered; kept track of iff `MapperFeature.IGNORE_DUPLICATE_MODULE_REGISTRATIONS` is enabled, so that duplicate registration calls can be ignored (to avoid adding same handlers multiple times, mostly).
`protected ConcurrentHashMap<JavaType,JsonDeserializer<Object>>`	`_rootDeserializers` We will use a separate main-level Map for keeping track of root-level deserializers.
`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 VisibilityChecker<?>`	`STD_VISIBILITY_CHECKER`

Constructor Summary

Constructors
Modifier	Constructor and Description
	`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

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`protected void`	`_checkInvalidCopy(Class<?> exp)`
`protected void`	`_configAndWriteValue(JsonGenerator g, Object value)` Method called to configure the generator as necessary and then call write functionality
`protected Object`	`_convert(Object fromValue, JavaType toValueType)` Actual conversion implementation: instead of using existing read and write methods, much of code is inlined.
`protected JsonDeserializer<Object>`	`_findRootDeserializer(DeserializationContext ctxt, JavaType valueType)` Method called to locate deserializer for the passed root-level value.
`protected JsonToken`	`_initForReading(JsonParser p)` Method called to ensure that given parser is ready for reading content for data binding.
`protected ObjectReader`	`_newReader(DeserializationConfig config)` Factory method sub-classes must override, to produce `ObjectReader` instances of proper sub-type
`protected ObjectReader`	`_newReader(DeserializationConfig config, JavaType valueType, Object valueToUpdate, FormatSchema schema, InjectableValues injectableValues)` Factory method sub-classes must override, to produce `ObjectReader` instances of proper sub-type
`protected ObjectWriter`	`_newWriter(SerializationConfig config)` Factory method sub-classes must override, to produce `ObjectWriter` instances of proper sub-type
`protected ObjectWriter`	`_newWriter(SerializationConfig config, FormatSchema schema)` Factory method sub-classes must override, to produce `ObjectWriter` instances of proper sub-type
`protected ObjectWriter`	`_newWriter(SerializationConfig config, JavaType rootType, PrettyPrinter pp)` Factory method sub-classes must override, to produce `ObjectWriter` instances of proper sub-type
`protected Object`	`_readMapAndClose(JsonParser p0, JavaType valueType)`
`protected Object`	`_readValue(DeserializationConfig cfg, JsonParser p, 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 p, DeserializationContext ctxt, DeserializationConfig config, JavaType rootType, JsonDeserializer<Object> deser)`
`protected void`	`_verifySchemaType(FormatSchema schema)`
`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.
`ObjectMapper`	`addMixIn(Class<?> target, Class<?> mixinSource)` Method to use for adding mix-in annotations to use for augmenting specified class or interface.
`void`	`addMixInAnnotations(Class<?> target, Class<?> mixinSource)` Deprecated. Since 2.5: replaced by a fluent form of the method; `addMixIn(Class, Class)`.
`boolean`	`canDeserialize(JavaType type)` Method that can be called to check whether mapper thinks it could deserialize an Object of given type.
`boolean`	`canDeserialize(JavaType type, AtomicReference<Throwable> cause)` Method similar to `canDeserialize(JavaType)` but that can return actual `Throwable` that was thrown when trying to construct serializer: this may be useful in figuring out what the actual problem is.
`boolean`	`canSerialize(Class<?> type)` Method that can be called to check whether mapper thinks it could serialize an instance of given Class.
`boolean`	`canSerialize(Class<?> type, AtomicReference<Throwable> cause)` Method similar to `canSerialize(Class)` but that can return actual `Throwable` that was thrown when trying to construct serializer: this may be useful in figuring out what the actual problem is.
`ObjectMapper`	`clearProblemHandlers()` Method for removing all registered `DeserializationProblemHandler`s instances from this mapper.
`MutableConfigOverride`	`configOverride(Class<?> type)` Accessor for getting a mutable configuration override object for given type, needed to add or change per-type overrides applied to properties of given type.
`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 generator instances this object mapper creates.
`ObjectMapper`	`configure(JsonParser.Feature f, boolean state)` Method for changing state of specified `JsonParser.Feature`s for parser instances this object mapper creates.
`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, if (but only if!) conversion is needed.
`<T> T`	`convertValue(Object fromValue, JavaType toValueType)` See `convertValue(Object, Class)`
`<T> T`	`convertValue(Object fromValue, TypeReference<?> toValueTypeRef)` See `convertValue(Object, Class)`
`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 p, 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)
`protected ClassIntrospector`	`defaultClassIntrospector()` Overridable helper method used to construct default `ClassIntrospector` to use.
`ObjectMapper`	`disable(DeserializationFeature feature)` Method for enabling specified `DeserializationConfig` features.
`ObjectMapper`	`disable(DeserializationFeature first, DeserializationFeature... f)` Method for enabling specified `DeserializationConfig` features.
`ObjectMapper`	`disable(JsonGenerator.Feature... features)` Method for disabling specified `JsonGenerator.Feature`s for parser instances this object mapper creates.
`ObjectMapper`	`disable(JsonParser.Feature... features)` Method for disabling specified `JsonParser.Feature`s for parser instances this object mapper creates.
`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(JsonGenerator.Feature... features)` Method for enabling specified `JsonGenerator.Feature`s for parser instances this object mapper creates.
`ObjectMapper`	`enable(JsonParser.Feature... features)` Method for enabling specified `JsonParser.Feature`s for parser instances this object mapper creates.
`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)
`ObjectMapper`	`findAndRegisterModules()` Convenience method that is functionally equivalent to: `mapper.registerModules(mapper.findModules());`
`Class<?>`	`findMixInClassFor(Class<?> cls)`
`static List<Module>`	`findModules()` Method for locating available methods, using JDK `ServiceLoader` facility, along with module-provided SPI.
`static List<Module>`	`findModules(ClassLoader classLoader)` Method for locating available methods, using JDK `ServiceLoader` facility, along with module-provided SPI.
`JsonSchema`	`generateJsonSchema(Class<?> t)` Deprecated. Since 2.6 use external JSON Schema generator (https://github.com/FasterXML/jackson-module-jsonSchema) (which under the hood calls `acceptJsonFormatVisitor(JavaType, JsonFormatVisitorWrapper)`)
`DateFormat`	`getDateFormat()`
`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 `JsonParser`s and/or `JsonGenerator`s.
`InjectableValues`	`getInjectableValues()`
`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.
`PropertyNamingStrategy`	`getPropertyNamingStrategy()`
`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()` Accessor for the "blueprint" (or, factory) instance, from which instances are created by calling `DefaultSerializerProvider.createInstance(com.fasterxml.jackson.databind.SerializationConfig, com.fasterxml.jackson.databind.ser.SerializerFactory)`.
`SerializerProvider`	`getSerializerProviderInstance()` Accessor for constructing and returning a `SerializerProvider` instance that may be used for accessing serializers.
`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)`
`boolean`	`isEnabled(JsonParser.Feature f)`
`boolean`	`isEnabled(MapperFeature f)` Method for checking whether given `MapperFeature` 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)` Deprecated. Since 2.5, use `readerFor(Class)` instead
`ObjectReader`	`reader(ContextAttributes attrs)` Factory method for constructing `ObjectReader` that will use specified default attributes.
`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)` Deprecated. Since 2.5, use `readerFor(JavaType)` instead
`ObjectReader`	`reader(JsonNodeFactory f)` Factory method for constructing `ObjectReader` that will use specified `JsonNodeFactory` for constructing JSON trees.
`ObjectReader`	`reader(TypeReference<?> type)` Deprecated. Since 2.5, use `readerFor(TypeReference)` instead
`ObjectReader`	`readerFor(Class<?> type)` Factory method for constructing `ObjectReader` that will read or update instances of specified type
`ObjectReader`	`readerFor(JavaType type)` Factory method for constructing `ObjectReader` that will read or update instances of specified type
`ObjectReader`	`readerFor(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 p)` 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(DataInput src, Class<T> valueType)`
`<T> T`	`readValue(DataInput src, JavaType valueType)`
`<T> T`	`readValue(File src, Class<T> valueType)` Method to deserialize JSON content from given file into given Java type.
`<T> T`	`readValue(File src, JavaType valueType)` Method to deserialize JSON content from given file into given Java type.
`<T> T`	`readValue(File src, TypeReference valueTypeRef)` Method to deserialize JSON content from given file into given Java type.
`<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 p, 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 p, JavaType valueType)` Type-safe overloaded method, basically alias for `readValue(JsonParser, Class)`.
`<T> T`	`readValue(JsonParser p, ResolvedType valueType)` Method to deserialize JSON content into a Java type, reference to which is passed as argument.
`<T> T`	`readValue(JsonParser p, 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)` Method to deserialize JSON content from given JSON content String.
`<T> T`	`readValue(String content, JavaType valueType)` Method to deserialize JSON content from given JSON content String.
`<T> T`	`readValue(String content, TypeReference valueTypeRef)` Method to deserialize JSON content from given JSON content String.
`<T> T`	`readValue(URL src, Class<T> valueType)` Method to deserialize JSON content from given resource into given Java type.
`<T> T`	`readValue(URL src, JavaType valueType)`
`<T> T`	`readValue(URL src, TypeReference valueTypeRef)` Method to deserialize JSON content from given resource into given Java type.
`<T> MappingIterator<T>`	`readValues(JsonParser p, Class<T> valueType)` Convenience method, equivalent in function to:
`<T> MappingIterator<T>`	`readValues(JsonParser p, JavaType valueType)` Convenience method, equivalent in function to:
`<T> MappingIterator<T>`	`readValues(JsonParser p, ResolvedType valueType)` Convenience method, equivalent in function to:
`<T> MappingIterator<T>`	`readValues(JsonParser p, 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.
`ObjectMapper`	`registerModules(Iterable<Module> modules)` Convenience method for registering specified modules in order; functionally equivalent to:
`ObjectMapper`	`registerModules(Module... modules)` Convenience method for registering specified modules in order; functionally equivalent to:
`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 setting `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`	`setConfig(DeserializationConfig config)` Method that allows overriding of the underlying `DeserializationConfig` object.
`ObjectMapper`	`setConfig(SerializationConfig config)` Method that allows overriding of the underlying `SerializationConfig` object, which contains serialization-specific configuration settings.
`ObjectMapper`	`setDateFormat(DateFormat dateFormat)` Method for configuring the default `DateFormat` to use when serializing time values as Strings, and deserializing from JSON Strings.
`ObjectMapper`	`setDefaultPrettyPrinter(PrettyPrinter pp)` Method for specifying `PrettyPrinter` to use when "default pretty-printing" is enabled (by enabling `SerializationFeature.INDENT_OUTPUT`)
`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.
`ObjectMapper`	`setFilterProvider(FilterProvider filterProvider)` Method for configuring this mapper to use specified `FilterProvider` for mapping Filter Ids to actual filter instances.
`void`	`setFilters(FilterProvider filterProvider)` Deprecated. Since 2.6, use `setFilterProvider(com.fasterxml.jackson.databind.ser.FilterProvider)` instead (allows chaining)
`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)` Deprecated. Since 2.5: replaced by a fluent form of the method; `setMixIns(java.util.Map<java.lang.Class<?>, java.lang.Class<?>>)`.
`ObjectMapper`	`setMixInResolver(ClassIntrospector.MixInResolver resolver)` Method that can be called to specify given resolver for locating mix-in classes to use, overriding directly added mappings.
`ObjectMapper`	`setMixIns(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`	`setPropertyInclusion(JsonInclude.Value incl)` Method for setting default POJO property inclusion strategy for serialization.
`ObjectMapper`	`setPropertyNamingStrategy(PropertyNamingStrategy s)` Method for setting custom property naming strategy to use.
`ObjectMapper`	`setSerializationInclusion(JsonInclude.Include incl)` Convenience method, equivalent to calling:
`ObjectMapper`	`setSerializerFactory(SerializerFactory f)` Method for setting specific `SerializerFactory` to use for constructing (bean) serializers.
`ObjectMapper`	`setSerializerProvider(DefaultSerializerProvider p)` Method for setting "blueprint" `SerializerProvider` instance to use as the base for actual provider instances 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 `VisibilityChecker`s, to change details of what kinds of properties are auto-detected.
`ObjectMapper`	`setVisibility(VisibilityChecker<?> vc)` Method for setting currently configured `VisibilityChecker`, object used for determining whether given property element (method, field, constructor) can be auto-detected or not.
`void`	`setVisibilityChecker(VisibilityChecker<?> vc)` Deprecated. Since 2.6 use `setVisibility(VisibilityChecker)` instead.
`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<T>)`; 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(CharacterEscapes escapes)` Factory method for constructing `ObjectReader` that will use specified character escaping details for output.
`ObjectWriter`	`writer(ContextAttributes attrs)` Factory method for constructing `ObjectWriter` that will use specified default attributes.
`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`	`writerFor(Class<?> rootType)` Factory method for constructing `ObjectWriter` that will serialize objects using specified root type, instead of actual runtime type of value.
`ObjectWriter`	`writerFor(JavaType rootType)` Factory method for constructing `ObjectWriter` that will serialize objects using specified root type, instead of actual runtime type of value.
`ObjectWriter`	`writerFor(TypeReference<?> rootType)` Factory method for constructing `ObjectWriter` that will serialize objects using specified root type, instead of actual runtime type of value.
`ObjectWriter`	`writerWithDefaultPrettyPrinter()` Factory method for constructing `ObjectWriter` that will serialize objects using the default pretty printer for indentation
`ObjectWriter`	`writerWithType(Class<?> rootType)` Deprecated. Since 2.5, use `writerFor(Class)` instead
`ObjectWriter`	`writerWithType(JavaType rootType)` Deprecated. Since 2.5, use `writerFor(JavaType)` instead
`ObjectWriter`	`writerWithType(TypeReference<?> rootType)` Deprecated. Since 2.5, use `writerFor(TypeReference)` instead
`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`	`writeTree(JsonGenerator jgen, TreeNode rootNode)`
`void`	`writeValue(DataOutput out, Object value)`
`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 g, 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_ANNOTATION_INTROSPECTOR
```
protected static final AnnotationIntrospector DEFAULT_ANNOTATION_INTROSPECTOR
```
  - STD_VISIBILITY_CHECKER
```
protected static final VisibilityChecker<?> STD_VISIBILITY_CHECKER
```
  - 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.
  - _propertyOverrides
```
protected ConfigOverrides _propertyOverrides
```
    Currently active per-type configuration overrides, accessed by declared type of property.
    
    Since:
    
    2.8
  - _mixIns
```
protected SimpleMixInResolver _mixIns
```
    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)
    
    Since:
    
    2.6 (earlier was a simple Map
  - _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).
  - _registeredModuleTypes
```
protected Set<Object> _registeredModuleTypes
```
    Set of module types (as per Module.getTypeId() that have been registered; kept track of iff MapperFeature.IGNORE_DUPLICATE_MODULE_REGISTRATIONS is enabled, so that duplicate registration calls can be ignored (to avoid adding same handlers multiple times, mostly).
    
    Since:
    
    2.5
  - _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 successful 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
  - defaultClassIntrospector
```
protected ClassIntrospector defaultClassIntrospector()
```
    Overridable helper method used to construct default ClassIntrospector to use.
    
    Since:
    
    2.5
  - 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)
```
    Since:
    
    2.1
  - _newReader
```
protected ObjectReader _newReader(DeserializationConfig config)
```
    Factory method sub-classes must override, to produce ObjectReader instances of proper sub-type
    
    Since:
    
    2.5
  - _newReader
```
protected ObjectReader _newReader(DeserializationConfig config,
                                  JavaType valueType,
                                  Object valueToUpdate,
                                  FormatSchema schema,
                                  InjectableValues injectableValues)
```
    Factory method sub-classes must override, to produce ObjectReader instances of proper sub-type
    
    Since:
    
    2.5
  - _newWriter
```
protected ObjectWriter _newWriter(SerializationConfig config)
```
    Factory method sub-classes must override, to produce ObjectWriter instances of proper sub-type
    
    Since:
    
    2.5
  - _newWriter
```
protected ObjectWriter _newWriter(SerializationConfig config,
                                  FormatSchema schema)
```
    Factory method sub-classes must override, to produce ObjectWriter instances of proper sub-type
    
    Since:
    
    2.5
  - _newWriter
```
protected ObjectWriter _newWriter(SerializationConfig config,
                                  JavaType rootType,
                                  PrettyPrinter pp)
```
    Factory method sub-classes must override, to produce ObjectWriter instances of proper sub-type
    
    Since:
    
    2.5
  - 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
    
    Specified by:
    
    version in class ObjectCodec
  - 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
  - registerModules
```
public ObjectMapper registerModules(Module... modules)
```
    Convenience method for registering specified modules in order; functionally equivalent to:
```
   for (Module module : modules) {
      registerModule(module);
   }
```
    Since:
    
    2.2
  - registerModules
```
public ObjectMapper registerModules(Iterable<Module> modules)
```
    Convenience method for registering specified modules in order; functionally equivalent to:
```
   for (Module module : modules) {
      registerModule(module);
   }
```
    Since:
    
    2.2
  - findModules
```
public static List<Module> findModules()
```
    Method for locating available methods, using JDK ServiceLoader facility, along with module-provided SPI.
    Note that method does not do any caching, so calls should be considered potentially expensive.
    
    Since:
    
    2.2
  - findModules
```
public static List<Module> findModules(ClassLoader classLoader)
```
    Method for locating available methods, using JDK ServiceLoader facility, along with module-provided SPI.
    Note that method does not do any caching, so calls should be considered potentially expensive.
    
    Since:
    
    2.2
  - findAndRegisterModules
```
public ObjectMapper findAndRegisterModules()
```
    Convenience method that is functionally equivalent to: mapper.registerModules(mapper.findModules());
    As with findModules(), no caching is done for modules, so care needs to be taken to either create and share a single mapper instance; or to cache introspected set of modules.
    
    Since:
    
    2.2
  - 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 "blueprint" SerializerProvider instance to use as the base for actual provider instances to use for handling caching of JsonSerializer instances.
  - getSerializerProvider
```
public SerializerProvider getSerializerProvider()
```
    Accessor for the "blueprint" (or, factory) instance, from which instances are created by calling DefaultSerializerProvider.createInstance(com.fasterxml.jackson.databind.SerializationConfig, com.fasterxml.jackson.databind.ser.SerializerFactory). Note that returned instance can not be directly used as it is not properly configured: to get a properly configured instance to call, use getSerializerProviderInstance() instead.
  - getSerializerProviderInstance
```
public SerializerProvider getSerializerProviderInstance()
```
    Accessor for constructing and returning a SerializerProvider instance that may be used for accessing serializers. This is same as calling getSerializerProvider(), and calling createInstance on it.
    
    Since:
    
    2.7
  - setMixIns
```
public ObjectMapper setMixIns(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.
    Note that this method will CLEAR any previously defined mix-ins for this mapper.
    
    Since:
    
    2.5
  - addMixIn
```
public ObjectMapper addMixIn(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
    
    Since:
    
    2.5
  - setMixInResolver
```
public ObjectMapper setMixInResolver(ClassIntrospector.MixInResolver resolver)
```
    Method that can be called to specify given resolver for locating mix-in classes to use, overriding directly added mappings. Note that direct mappings are not cleared, but they are only applied if resolver does not provide mix-in matches.
    
    Since:
    
    2.6
  - findMixInClassFor
```
public Class<?> findMixInClassFor(Class<?> cls)
```
  - mixInCount
```
public int mixInCount()
```
  - setMixInAnnotations
```
@Deprecated
public void setMixInAnnotations(Map<Class<?>,Class<?>> sourceMixins)
```
    Deprecated. Since 2.5: replaced by a fluent form of the method; setMixIns(java.util.Map<java.lang.Class<?>, java.lang.Class<?>>).
  - addMixInAnnotations
```
@Deprecated
public final void addMixInAnnotations(Class<?> target,
                                                  Class<?> mixinSource)
```
    Deprecated. Since 2.5: replaced by a fluent form of the method; addMixIn(Class, Class).
  - 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
```
@Deprecated
public void setVisibilityChecker(VisibilityChecker<?> vc)
```
    Deprecated. Since 2.6 use setVisibility(VisibilityChecker) instead.
  - setVisibility
```
public ObjectMapper setVisibility(VisibilityChecker<?> vc)
```
    Method for setting currently configured VisibilityChecker, 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.
    
    Since:
    
    2.6
  - 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 setting AnnotationIntrospector used by this mapper instance for both serialization and deserialization. Note that doing this will replace the current introspector, which may lead to unavailability of core Jackson annotations. If you want to combine handling of multiple introspectors, have a look at AnnotationIntrospectorPair.
    
    See Also:
    
    AnnotationIntrospectorPair
  - 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
    
    See Also:
    
    AnnotationIntrospectorPair
  - setPropertyNamingStrategy
```
public ObjectMapper setPropertyNamingStrategy(PropertyNamingStrategy s)
```
    Method for setting custom property naming strategy to use.
  - getPropertyNamingStrategy
```
public PropertyNamingStrategy getPropertyNamingStrategy()
```
    Since:
    
    2.5
  - setSerializationInclusion
```
public ObjectMapper setSerializationInclusion(JsonInclude.Include incl)
```
    Convenience method, equivalent to calling:
```
  setPropertyInclusion(JsonInclude.Value.construct(incl, Include.ALWAYS));
```
  - setPropertyInclusion
```
public ObjectMapper setPropertyInclusion(JsonInclude.Value incl)
```
    Method for setting default POJO property inclusion strategy for serialization.
    
    Since:
    
    2.7
  - setDefaultPrettyPrinter
```
public ObjectMapper setDefaultPrettyPrinter(PrettyPrinter pp)
```
    Method for specifying PrettyPrinter to use when "default pretty-printing" is enabled (by enabling SerializationFeature.INDENT_OUTPUT)
    
    Parameters:
    
    pp - Pretty printer to use by default.
    
    Returns:
    
    This mapper, useful for call-chaining
    
    Since:
    
    2.6
  - 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).
    NOTE: use of JsonTypeInfo.As#EXTERNAL_PROPERTY NOT SUPPORTED; and attempts of do so will throw an IllegalArgumentException to make this limitation explicit.
    
    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).
  - configOverride
```
public MutableConfigOverride configOverride(Class<?> type)
```
    Accessor for getting a mutable configuration override object for given type, needed to add or change per-type overrides applied to properties of given type. Usage is through returned object by colling "setter" methods, which directly modify override object and take effect directly. For example you can do
```
   mapper.configOverride(java.util.Date.class)
       .setFormat(JsonFormat.Value.forPattern("yyyy-MM-dd"));
 to change the default format to use for properties of type
 Date (possibly further overridden by per-property
 annotations)
```
    Since:
    
    2.8
  - 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.
  - getNodeFactory
```
public 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.
    Note: this is just a shortcut for calling
```
   getDeserializationConfig().getNodeFactory()
```
  - 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.
  - setConfig
```
public ObjectMapper setConfig(DeserializationConfig config)
```
    Method that allows overriding of the underlying DeserializationConfig object. It is added as a fallback method that may be used if no other configuration modifier method works: it should not be used if there are alternatives, and its use is generally discouraged.
    NOTE: only use this method if you know what you are doing -- it allows by-passing some of checks applied to other configuration methods. Also keep in mind that as with all configuration of ObjectMapper, this is only thread-safe if done before calling any deserialization methods.
    
    Since:
    
    2.4
  - setFilters
```
@Deprecated
public void setFilters(FilterProvider filterProvider)
```
    Deprecated. Since 2.6, use setFilterProvider(com.fasterxml.jackson.databind.ser.FilterProvider) instead (allows chaining)
  - setFilterProvider
```
public ObjectMapper setFilterProvider(FilterProvider filterProvider)
```
    Method for configuring this mapper to use specified FilterProvider for mapping Filter Ids to actual filter instances.
    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.
    
    Since:
    
    2.6
  - 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
    
    Returns:
    
    This mapper, for convenience to allow chaining
    
    Since:
    
    2.1
  - setConfig
```
public ObjectMapper setConfig(SerializationConfig config)
```
    Method that allows overriding of the underlying SerializationConfig object, which contains serialization-specific configuration settings. It is added as a fallback method that may be used if no other configuration modifier method works: it should not be used if there are alternatives, and its use is generally discouraged.
    NOTE: only use this method if you know what you are doing -- it allows by-passing some of checks applied to other configuration methods. Also keep in mind that as with all configuration of ObjectMapper, this is only thread-safe if done before calling any serialization methods.
    
    Since:
    
    2.4
  - 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
    
    Overrides:
    
    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.
  - getDateFormat
```
public DateFormat getDateFormat()
```
    Since:
    
    2.5
  - 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.
  - getInjectableValues
```
public InjectableValues getInjectableValues()
```
    Since:
    
    2.6
  - 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 UTC (NOT default TimeZone of JVM).
  - isEnabled
```
public boolean isEnabled(MapperFeature f)
```
    Method for checking whether given MapperFeature is enabled.
  - configure
```
public ObjectMapper configure(MapperFeature f,
                              boolean state)
```
    Method for changing state of an on/off mapper feature for this mapper instance.
  - enable
```
public ObjectMapper enable(MapperFeature... f)
```
    Method for enabling specified MapperConfig features. Modifies and returns this instance; no new object is created.
  - disable
```
public ObjectMapper disable(MapperFeature... f)
```
    Method for enabling specified DeserializationConfig features. Modifies and returns this instance; no new object is created.
  - isEnabled
```
public boolean isEnabled(SerializationFeature f)
```
    Method for checking whether given serialization-specific feature is enabled.
  - configure
```
public ObjectMapper configure(SerializationFeature f,
                              boolean state)
```
    Method for changing state of an on/off serialization feature for this object mapper.
  - enable
```
public ObjectMapper enable(SerializationFeature f)
```
    Method for enabling specified DeserializationConfig feature. Modifies and returns this instance; no new object is created.
  - enable
```
public ObjectMapper enable(SerializationFeature first,
                           SerializationFeature... f)
```
    Method for enabling specified DeserializationConfig features. Modifies and returns this instance; no new object is created.
  - disable
```
public ObjectMapper disable(SerializationFeature f)
```
    Method for enabling specified DeserializationConfig features. Modifies and returns this instance; no new object is created.
  - disable
```
public ObjectMapper disable(SerializationFeature first,
                            SerializationFeature... f)
```
    Method for enabling specified DeserializationConfig features. Modifies and returns this instance; no new object is created.
  - isEnabled
```
public boolean isEnabled(DeserializationFeature f)
```
    Method for checking whether given deserialization-specific feature is enabled.
  - configure
```
public ObjectMapper configure(DeserializationFeature f,
                              boolean state)
```
    Method for changing state of an on/off deserialization feature for this object mapper.
  - enable
```
public ObjectMapper enable(DeserializationFeature feature)
```
    Method for enabling specified DeserializationConfig features. Modifies and returns this instance; no new object is created.
  - enable
```
public ObjectMapper enable(DeserializationFeature first,
                           DeserializationFeature... f)
```
    Method for enabling specified DeserializationConfig features. Modifies and returns this instance; no new object is created.
  - disable
```
public ObjectMapper disable(DeserializationFeature feature)
```
    Method for enabling specified DeserializationConfig features. Modifies and returns this instance; no new object is created.
  - disable
```
public ObjectMapper disable(DeserializationFeature first,
                            DeserializationFeature... f)
```
    Method for enabling specified DeserializationConfig features. Modifies and returns this instance; no new object is created.
  - isEnabled
```
public boolean isEnabled(JsonParser.Feature f)
```
  - configure
```
public ObjectMapper configure(JsonParser.Feature f,
                              boolean state)
```
    Method for changing state of specified JsonParser.Features for parser instances this object mapper creates.
    Note that this is equivalent to directly calling same method on getFactory().
  - enable
```
public ObjectMapper enable(JsonParser.Feature... features)
```
    Method for enabling specified JsonParser.Features for parser instances this object mapper creates.
    Note that this is equivalent to directly calling same method on getFactory().
    
    Since:
    
    2.5
  - disable
```
public ObjectMapper disable(JsonParser.Feature... features)
```
    Method for disabling specified JsonParser.Features for parser instances this object mapper creates.
    Note that this is equivalent to directly calling same method on getFactory().
    
    Since:
    
    2.5
  - isEnabled
```
public boolean isEnabled(JsonGenerator.Feature f)
```
  - configure
```
public ObjectMapper configure(JsonGenerator.Feature f,
                              boolean state)
```
    Method for changing state of an on/off JsonGenerator feature for generator instances this object mapper creates.
    Note that this is equivalent to directly calling same method on getFactory().
  - enable
```
public ObjectMapper enable(JsonGenerator.Feature... features)
```
    Method for enabling specified JsonGenerator.Features for parser instances this object mapper creates.
    Note that this is equivalent to directly calling same method on getFactory().
    
    Since:
    
    2.5
  - disable
```
public ObjectMapper disable(JsonGenerator.Feature... features)
```
    Method for disabling specified JsonGenerator.Features for parser instances this object mapper creates.
    Note that this is equivalent to directly calling same method on getFactory().
    
    Since:
    
    2.5
  - isEnabled
```
public boolean isEnabled(JsonFactory.Feature f)
```
    Convenience method, equivalent to:
```
  getJsonFactory().isEnabled(f);
```
  - readValue
```
public <T> T readValue(JsonParser p,
                       Class<T> valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    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).
    Note: this method should NOT be used if the result type is a container (Collection or Map. The reason is that due to type erasure, key and value types can not be introspected when using this method.
    
    Specified by:
    
    readValue in class ObjectCodec
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonMappingException - if the input JSON structure does not match structure expected for result type (or has other mismatch issues)
  - readValue
```
public <T> T readValue(JsonParser p,
                       TypeReference<?> valueTypeRef)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Method to deserialize JSON content into a Java type, reference to which is passed as argument. Type is passed using so-called "super type token" (see ) and specifically needs to be used if the root type is a parameterized (generic) container type.
    
    Specified by:
    
    readValue in class ObjectCodec
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonMappingException - if the input JSON structure does not match structure expected for result type (or has other mismatch issues)
  - readValue
```
public final <T> T readValue(JsonParser p,
                             ResolvedType valueType)
                      throws IOException,
                             JsonParseException,
                             JsonMappingException
```
    Method to deserialize JSON content into a Java type, reference to which is passed as argument. Type is passed using Jackson specific type; instance of which can be constructed using TypeFactory.
    
    Specified by:
    
    readValue in class ObjectCodec
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonMappingException - if the input JSON structure does not match structure expected for result type (or has other mismatch issues)
  - readValue
```
public <T> T readValue(JsonParser p,
                       JavaType valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Type-safe overloaded method, basically alias for readValue(JsonParser, Class).
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonMappingException - if the input JSON structure does not match structure expected for result type (or has other mismatch issues)
  - readTree
```
public <T extends TreeNode> T readTree(JsonParser p)
                                throws IOException,
                                       JsonProcessingException
```
    Method to deserialize JSON content as tree expressed using set of JsonNode instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
    
    Specified by:
    
    readTree in class ObjectCodec
    
    Returns:
    
    a JsonNode, if valid JSON content found; null if input has no content to bind -- note, however, that if JSON null token is found, it will be represented as a non-null JsonNode (one that returns true for JsonNode.isNull()
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonProcessingException
  - readValues
```
public <T> MappingIterator<T> readValues(JsonParser p,
                                         ResolvedType valueType)
                                  throws IOException,
                                         JsonProcessingException
```
    Convenience method, equivalent in function to:
```
   readerFor(valueType).readValues(p);
```
    Method for reading sequence of Objects from parser stream. Sequence can be either root-level "unwrapped" sequence (without surrounding JSON array), or a sequence contained in a JSON Array. In either case JsonParser MUST point to the first token of the first element, OR not point to any token (in which case it is advanced to the next token). This means, specifically, that for wrapped sequences, parser MUST NOT point to the surrounding START_ARRAY (one that contains values to read) but rather to the token following it which is the first token of the first value to read.
    Note that ObjectReader has more complete set of variants.
    Specified by:
    
    readValues in class ObjectCodec
    
    Throws:
    
    IOException
    
    JsonProcessingException
  - readValues
```
public <T> MappingIterator<T> readValues(JsonParser p,
                                         JavaType valueType)
                                  throws IOException,
                                         JsonProcessingException
```
    Convenience method, equivalent in function to:
```
   readerFor(valueType).readValues(p);
```
    Type-safe overload of readValues(JsonParser, ResolvedType).
    Throws:
    
    IOException
    
    JsonProcessingException
  - readValues
```
public <T> MappingIterator<T> readValues(JsonParser p,
                                         Class<T> valueType)
                                  throws IOException,
                                         JsonProcessingException
```
    Convenience method, equivalent in function to:
```
   readerFor(valueType).readValues(p);
```
    Type-safe overload of readValues(JsonParser, ResolvedType).
    Specified by:
    
    readValues in class ObjectCodec
    
    Throws:
    
    IOException
    
    JsonProcessingException
  - readValues
```
public <T> MappingIterator<T> readValues(JsonParser p,
                                         TypeReference<?> valueTypeRef)
                                  throws IOException,
                                         JsonProcessingException
```
    Method for reading sequence of Objects from parser stream.
    
    Specified by:
    
    readValues in class ObjectCodec
    
    Throws:
    
    IOException
    
    JsonProcessingException
  - readTree
```
public JsonNode readTree(InputStream in)
                  throws IOException,
                         JsonProcessingException
```
    Method to deserialize JSON content as tree expressed using set of JsonNode instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
    If a low-level I/O problem (missing input, network error) occurs, a IOException will be thrown. If a parsing problem occurs (invalid JSON), JsonParseException will be thrown. If no content is found from input (end-of-input), Java null will be returned.
    
    Parameters:
    
    in - Input stream used to read JSON content for building the JSON tree.
    
    Returns:
    
    a JsonNode, if valid JSON content found; null if input has no content to bind -- note, however, that if JSON null token is found, it will be represented as a non-null JsonNode (one that returns true for JsonNode.isNull()
    
    Throws:
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    IOException
    
    JsonProcessingException
  - readTree
```
public JsonNode readTree(Reader r)
                  throws IOException,
                         JsonProcessingException
```
    Method to deserialize JSON content as tree expressed using set of JsonNode instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
    If a low-level I/O problem (missing input, network error) occurs, a IOException will be thrown. If a parsing problem occurs (invalid JSON), JsonParseException will be thrown. If no content is found from input (end-of-input), Java null will be returned.
    
    Parameters:
    
    r - Reader used to read JSON content for building the JSON tree.
    
    Returns:
    
    a JsonNode, if valid JSON content found; null if input has no content to bind -- note, however, that if JSON null token is found, it will be represented as a non-null JsonNode (one that returns true for JsonNode.isNull()
    
    Throws:
    
    IOException
    
    JsonProcessingException
  - readTree
```
public JsonNode readTree(String content)
                  throws IOException,
                         JsonProcessingException
```
    Method to deserialize JSON content as tree expressed using set of JsonNode instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
    If a low-level I/O problem (missing input, network error) occurs, a IOException will be thrown. If a parsing problem occurs (invalid JSON), JsonParseException will be thrown. If no content is found from input (end-of-input), Java null will be returned.
    
    Parameters:
    
    content - JSON content to parse to build the JSON tree.
    
    Returns:
    
    a JsonNode, if valid JSON content found; null if input has no content to bind -- note, however, that if JSON null token is found, it will be represented as a non-null JsonNode (one that returns true for JsonNode.isNull()
    
    Throws:
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    IOException
    
    JsonProcessingException
  - readTree
```
public JsonNode readTree(byte[] content)
                  throws IOException,
                         JsonProcessingException
```
    Method to deserialize JSON content as tree expressed using set of JsonNode instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
    
    Parameters:
    
    content - JSON content to parse to build the JSON tree.
    
    Returns:
    
    a JsonNode, if valid JSON content found; null if input has no content to bind -- note, however, that if JSON null token is found, it will be represented as a non-null JsonNode (one that returns true for JsonNode.isNull()
    
    Throws:
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    IOException
    
    JsonProcessingException
  - readTree
```
public JsonNode readTree(File file)
                  throws IOException,
                         JsonProcessingException
```
    Method to deserialize JSON content as tree expressed using set of JsonNode instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
    
    Parameters:
    
    file - File of which contents to parse as JSON for building a tree instance
    
    Returns:
    
    a JsonNode, if valid JSON content found; null if input has no content to bind -- note, however, that if JSON null token is found, it will be represented as a non-null JsonNode (one that returns true for JsonNode.isNull()
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonProcessingException
  - readTree
```
public JsonNode readTree(URL source)
                  throws IOException,
                         JsonProcessingException
```
    Method to deserialize JSON content as tree expressed using set of JsonNode instances. Returns root of the resulting tree (where root can consist of just a single node if the current event is a value event, not container).
    
    Parameters:
    
    source - URL to use for fetching contents to parse as JSON for building a tree instance
    
    Returns:
    
    a JsonNode, if valid JSON content found; null if input has no content to bind -- note, however, that if JSON null token is found, it will be represented as a non-null JsonNode (one that returns true for JsonNode.isNull()
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonProcessingException
  - writeValue
```
public void writeValue(JsonGenerator g,
                       Object value)
                throws IOException,
                       JsonGenerationException,
                       JsonMappingException
```
    Method that can be used to serialize any Java value as JSON output, using provided JsonGenerator.
    
    Specified by:
    
    writeValue in class ObjectCodec
    
    Throws:
    
    IOException
    
    JsonGenerationException
    
    JsonMappingException
  - writeTree
```
public void writeTree(JsonGenerator jgen,
                      TreeNode rootNode)
               throws IOException,
                      JsonProcessingException
```
    Specified by:
    
    writeTree in class ObjectCodec
    
    Throws:
    
    IOException
    
    JsonProcessingException
  - writeTree
```
public void writeTree(JsonGenerator jgen,
                      JsonNode rootNode)
               throws IOException,
                      JsonProcessingException
```
    Method to serialize given JSON Tree, using generator provided.
    
    Throws:
    
    IOException
    
    JsonProcessingException
  - createObjectNode
```
public 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)
    
    Specified by:
    
    createObjectNode in class ObjectCodec
  - createArrayNode
```
public 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)
    
    Specified by:
    
    createArrayNode in class ObjectCodec
  - treeAsTokens
```
public JsonParser treeAsTokens(TreeNode n)
```
    Method for constructing a JsonParser out of JSON tree representation.
    
    Specified by:
    
    treeAsTokens in class ObjectCodec
    
    Parameters:
    
    n - Root node of the tree that resulting parser will read from
  - treeToValue
```
public <T> T treeToValue(TreeNode n,
                         Class<T> valueType)
                  throws JsonProcessingException
```
    Convenience conversion method that will bind data given JSON tree contains into specific value (usually bean) type.
    Functionally equivalent to:
```
   objectMapper.convertValue(n, valueClass);
```
    Specified by:
    
    treeToValue in class ObjectCodec
    
    Throws:
    
    JsonProcessingException
  - valueToTree
```
public <T extends JsonNode> T valueToTree(Object fromValue)
                                   throws IllegalArgumentException
```
    Reverse of treeToValue(com.fasterxml.jackson.core.TreeNode, java.lang.Class<T>); given a value (usually bean), will construct equivalent JSON Tree representation. Functionally similar to serializing value into JSON and parsing JSON as tree, but more efficient.
    NOTE: while results are usually identical to that of serialization followed by deserialization, this is not always the case. In some cases serialization into intermediate representation will retain encapsulation of things like raw value (RawValue) or basic node identity (JsonNode). If so, result is a valid tree, but values are not re-constructed through actual JSON representation. So if transformation requires actual materialization of JSON (or other data format that this mapper produces), it will be necessary to do actual serialization.
    
    Type Parameters:
    
    T - Actual node type; usually either basic JsonNode or ObjectNode
    
    Parameters:
    
    fromValue - Bean value to convert
    
    Returns:
    
    Root node of the resulting JSON tree
    
    Throws:
    
    IllegalArgumentException
  - canSerialize
```
public boolean canSerialize(Class<?> type)
```
    Method that can be called to check whether mapper thinks it could serialize an instance of given Class. Check is done by checking whether a serializer can be found for the type.
    NOTE: since this method does NOT throw exceptions, but internal processing may, caller usually has little information as to why serialization would fail. If you want access to internal Exception, call canSerialize(Class, AtomicReference) instead.
    
    Returns:
    
    True if mapper can find a serializer for instances of given class (potentially serializable), false otherwise (not serializable)
  - canSerialize
```
public boolean canSerialize(Class<?> type,
                            AtomicReference<Throwable> cause)
```
    Method similar to canSerialize(Class) but that can return actual Throwable that was thrown when trying to construct serializer: this may be useful in figuring out what the actual problem is.
    
    Since:
    
    2.3
  - canDeserialize
```
public boolean canDeserialize(JavaType type)
```
    Method that can be called to check whether mapper thinks it could deserialize an Object of given type. Check is done by checking whether a registered deserializer can be found or built for the type; if not (either by no mapping being found, or through an Exception being thrown, false is returned.
    NOTE: in case an exception is thrown during course of trying co construct matching deserializer, it will be effectively swallowed. If you want access to that exception, call canDeserialize(JavaType, AtomicReference) instead.
    
    Returns:
    
    True if mapper can find a serializer for instances of given class (potentially serializable), false otherwise (not serializable)
  - canDeserialize
```
public boolean canDeserialize(JavaType type,
                              AtomicReference<Throwable> cause)
```
    Method similar to canDeserialize(JavaType) but that can return actual Throwable that was thrown when trying to construct serializer: this may be useful in figuring out what the actual problem is.
    
    Since:
    
    2.3
  - readValue
```
public <T> T readValue(File src,
                       Class<T> valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Method to deserialize JSON content from given file into given Java type.
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonMappingException - if the input JSON structure does not match structure expected for result type (or has other mismatch issues)
  - readValue
```
public <T> T readValue(File src,
                       TypeReference valueTypeRef)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Method to deserialize JSON content from given file into given Java type.
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonMappingException - if the input JSON structure does not match structure expected for result type (or has other mismatch issues)
  - readValue
```
public <T> T readValue(File src,
                       JavaType valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Method to deserialize JSON content from given file into given Java type.
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonMappingException - if the input JSON structure does not match structure expected for result type (or has other mismatch issues)
  - readValue
```
public <T> T readValue(URL src,
                       Class<T> valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Method to deserialize JSON content from given resource into given Java type.
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonMappingException - if the input JSON structure does not match structure expected for result type (or has other mismatch issues)
  - readValue
```
public <T> T readValue(URL src,
                       TypeReference valueTypeRef)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Method to deserialize JSON content from given resource into given Java type.
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonMappingException - if the input JSON structure does not match structure expected for result type (or has other mismatch issues)
  - readValue
```
public <T> T readValue(URL src,
                       JavaType valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Throws:
    
    IOException
    
    JsonParseException
    
    JsonMappingException
  - readValue
```
public <T> T readValue(String content,
                       Class<T> valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Method to deserialize JSON content from given JSON content String.
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonMappingException - if the input JSON structure does not match structure expected for result type (or has other mismatch issues)
  - readValue
```
public <T> T readValue(String content,
                       TypeReference valueTypeRef)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Method to deserialize JSON content from given JSON content String.
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonMappingException - if the input JSON structure does not match structure expected for result type (or has other mismatch issues)
  - readValue
```
public <T> T readValue(String content,
                       JavaType valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Method to deserialize JSON content from given JSON content String.
    
    Throws:
    
    IOException - if a low-level I/O problem (unexpected end-of-input, network error) occurs (passed through as-is without additional wrapping -- note that this is one case where DeserializationFeature.WRAP_EXCEPTIONS does NOT result in wrapping of exception even if enabled)
    
    JsonParseException - if underlying input contains invalid content of type JsonParser supports (JSON for default case)
    
    JsonMappingException - if the input JSON structure does not match structure expected for result type (or has other mismatch issues)
  - readValue
```
public <T> T readValue(Reader src,
                       Class<T> valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Throws:
    
    IOException
    
    JsonParseException
    
    JsonMappingException
  - readValue
```
public <T> T readValue(Reader src,
                       TypeReference valueTypeRef)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Throws:
    
    IOException
    
    JsonParseException
    
    JsonMappingException
  - readValue
```
public <T> T readValue(Reader src,
                       JavaType valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Throws:
    
    IOException
    
    JsonParseException
    
    JsonMappingException
  - readValue
```
public <T> T readValue(InputStream src,
                       Class<T> valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Throws:
    
    IOException
    
    JsonParseException
    
    JsonMappingException
  - readValue
```
public <T> T readValue(InputStream src,
                       TypeReference valueTypeRef)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Throws:
    
    IOException
    
    JsonParseException
    
    JsonMappingException
  - readValue
```
public <T> T readValue(InputStream src,
                       JavaType valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Throws:
    
    IOException
    
    JsonParseException
    
    JsonMappingException
  - readValue
```
public <T> T readValue(byte[] src,
                       Class<T> valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Throws:
    
    IOException
    
    JsonParseException
    
    JsonMappingException
  - readValue
```
public <T> T readValue(byte[] src,
                       int offset,
                       int len,
                       Class<T> valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Throws:
    
    IOException
    
    JsonParseException
    
    JsonMappingException
  - readValue
```
public <T> T readValue(byte[] src,
                       TypeReference valueTypeRef)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Throws:
    
    IOException
    
    JsonParseException
    
    JsonMappingException
  - readValue
```
public <T> T readValue(byte[] src,
                       int offset,
                       int len,
                       TypeReference valueTypeRef)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Throws:
    
    IOException
    
    JsonParseException
    
    JsonMappingException
  - readValue
```
public <T> T readValue(byte[] src,
                       JavaType valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Throws:
    
    IOException
    
    JsonParseException
    
    JsonMappingException
  - readValue
```
public <T> T readValue(byte[] src,
                       int offset,
                       int len,
                       JavaType valueType)
                throws IOException,
                       JsonParseException,
                       JsonMappingException
```
    Throws:
    
    IOException
    
    JsonParseException
    
    JsonMappingException
  - readValue
```
public <T> T readValue(DataInput src,
                       Class<T> valueType)
                throws IOException
```
    Throws:
    
    IOException
  - readValue
```
public <T> T readValue(DataInput src,
                       JavaType valueType)
                throws IOException
```
    Throws:
    
    IOException
  - writeValue
```
public void writeValue(File resultFile,
                       Object value)
                throws IOException,
                       JsonGenerationException,
                       JsonMappingException
```
    Method that can be used to serialize any Java value as JSON output, written to File provided.
    
    Throws:
    
    IOException
    
    JsonGenerationException
    
    JsonMappingException
  - writeValue
```
public void writeValue(OutputStream out,
                       Object value)
                throws IOException,
                       JsonGenerationException,
                       JsonMappingException
```
    Method that can be used to serialize any Java value as JSON output, using output stream provided (using encoding JsonEncoding.UTF8).
    Note: method does not close the underlying stream explicitly here; however, JsonFactory this mapper uses may choose to close the stream depending on its settings (by default, it will try to close it when JsonGenerator we construct is closed).
    
    Throws:
    
    IOException
    
    JsonGenerationException
    
    JsonMappingException
  - writeValue
```
public void writeValue(DataOutput out,
                       Object value)
                throws IOException
```
    Throws:
    
    IOException
    
    Since:
    
    2.8
  - writeValue
```
public void writeValue(Writer w,
                       Object value)
                throws IOException,
                       JsonGenerationException,
                       JsonMappingException
```
    Method that can be used to serialize any Java value as JSON output, using Writer provided.
    Note: method does not close the underlying stream explicitly here; however, JsonFactory this mapper uses may choose to close the stream depending on its settings (by default, it will try to close it when JsonGenerator we construct is closed).
    
    Throws:
    
    IOException
    
    JsonGenerationException
    
    JsonMappingException
  - writeValueAsString
```
public String writeValueAsString(Object value)
                          throws JsonProcessingException
```
    Method that can be used to serialize any Java value as a String. Functionally equivalent to calling writeValue(Writer,Object) with StringWriter and constructing String, but more efficient.
    Note: prior to version 2.1, throws clause included IOException; 2.1 removed it.
    
    Throws:
    
    JsonProcessingException
  - writeValueAsBytes
```
public byte[] writeValueAsBytes(Object value)
                         throws JsonProcessingException
```
    Method that can be used to serialize any Java value as a byte array. Functionally equivalent to calling writeValue(Writer,Object) with ByteArrayOutputStream and getting bytes, but more efficient. Encoding used will be UTF-8.
    Note: prior to version 2.1, throws clause included IOException; 2.1 removed it.
    
    Throws:
    
    JsonProcessingException
  - writer
```
public ObjectWriter writer()
```
    Convenience method for constructing ObjectWriter with default settings.
  - writer
```
public ObjectWriter writer(SerializationFeature feature)
```
    Factory method for constructing ObjectWriter with specified feature enabled (compared to settings that this mapper instance has).
  - writer
```
public ObjectWriter writer(SerializationFeature first,
                           SerializationFeature... other)
```
    Factory method for constructing ObjectWriter with specified features enabled (compared to settings that this mapper instance has).
  - writer
```
public 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.
  - writerWithView
```
public ObjectWriter writerWithView(Class<?> serializationView)
```
    Factory method for constructing ObjectWriter that will serialize objects using specified JSON View (filter).
  - writerFor
```
public ObjectWriter writerFor(Class<?> rootType)
```
    Factory method for constructing ObjectWriter that will serialize objects using specified root type, instead of actual runtime type of value. Type must be a super-type of runtime type.
    Main reason for using this method is performance, as writer is able to pre-fetch serializer to use before write, and if writer is used more than once this avoids addition per-value serializer lookups.
    
    Since:
    
    2.5
  - writerFor
```
public ObjectWriter writerFor(TypeReference<?> rootType)
```
    Factory method for constructing ObjectWriter that will serialize objects using specified root type, instead of actual runtime type of value. Type must be a super-type of runtime type.
    Main reason for using this method is performance, as writer is able to pre-fetch serializer to use before write, and if writer is used more than once this avoids addition per-value serializer lookups.
    
    Since:
    
    2.5
  - writerFor
```
public ObjectWriter writerFor(JavaType rootType)
```
    Factory method for constructing ObjectWriter that will serialize objects using specified root type, instead of actual runtime type of value. Type must be a super-type of runtime type.
    Main reason for using this method is performance, as writer is able to pre-fetch serializer to use before write, and if writer is used more than once this avoids addition per-value serializer lookups.
    
    Since:
    
    2.5
  - writer
```
public 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)
  - writerWithDefaultPrettyPrinter
```
public ObjectWriter writerWithDefaultPrettyPrinter()
```
    Factory method for constructing ObjectWriter that will serialize objects using the default pretty printer for indentation
  - writer
```
public ObjectWriter writer(FilterProvider filterProvider)
```
    Factory method for constructing ObjectWriter that will serialize objects using specified filter provider.
  - writer
```
public ObjectWriter writer(FormatSchema schema)
```
    Factory method for constructing ObjectWriter that will pass specific schema object to JsonGenerator used for writing content.
    
    Parameters:
    
    schema - Schema to pass to generator
  - writer
```
public ObjectWriter writer(Base64Variant defaultBase64)
```
    Factory method for constructing ObjectWriter that will use specified Base64 encoding variant for Base64-encoded binary data.
    
    Since:
    
    2.1
  - writer
```
public ObjectWriter writer(CharacterEscapes escapes)
```
    Factory method for constructing ObjectReader that will use specified character escaping details for output.
    
    Since:
    
    2.3
  - writer
```
public ObjectWriter writer(ContextAttributes attrs)
```
    Factory method for constructing ObjectWriter that will use specified default attributes.
    
    Since:
    
    2.3
  - writerWithType
```
@Deprecated
public ObjectWriter writerWithType(Class<?> rootType)
```
    Deprecated. Since 2.5, use writerFor(Class) instead
  - writerWithType
```
@Deprecated
public ObjectWriter writerWithType(TypeReference<?> rootType)
```
    Deprecated. Since 2.5, use writerFor(TypeReference) instead
  - writerWithType
```
@Deprecated
public ObjectWriter writerWithType(JavaType rootType)
```
    Deprecated. Since 2.5, use writerFor(JavaType) instead
  - reader
```
public ObjectReader reader()
```
    Factory method for constructing ObjectReader with default settings. Note that the resulting instance is NOT usable as is, without defining expected value type.
  - reader
```
public ObjectReader reader(DeserializationFeature feature)
```
    Factory method for constructing ObjectReader with specified feature enabled (compared to settings that this mapper instance has). Note that the resulting instance is NOT usable as is, without defining expected value type.
  - reader
```
public ObjectReader reader(DeserializationFeature first,
                           DeserializationFeature... other)
```
    Factory method for constructing ObjectReader with specified features enabled (compared to settings that this mapper instance has). Note that the resulting instance is NOT usable as is, without defining expected value type.
  - readerForUpdating
```
public 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. Deserialization occurs normally except that the root-level value in JSON is not used for instantiating a new object; instead give updateable object is used as root. Runtime type of value object is used for locating deserializer, unless overridden by other factory methods of ObjectReader
  - readerFor
```
public ObjectReader readerFor(JavaType type)
```
    Factory method for constructing ObjectReader that will read or update instances of specified type
    
    Since:
    
    2.6
  - readerFor
```
public ObjectReader readerFor(Class<?> type)
```
    Factory method for constructing ObjectReader that will read or update instances of specified type
    
    Since:
    
    2.6
  - readerFor
```
public ObjectReader readerFor(TypeReference<?> type)
```
    Factory method for constructing ObjectReader that will read or update instances of specified type
    
    Since:
    
    2.6
  - reader
```
public ObjectReader reader(JsonNodeFactory f)
```
    Factory method for constructing ObjectReader that will use specified JsonNodeFactory for constructing JSON trees.
  - reader
```
public ObjectReader reader(FormatSchema schema)
```
    Factory method for constructing ObjectReader that will pass specific schema object to JsonParser used for reading content.
    
    Parameters:
    
    schema - Schema to pass to parser
  - reader
```
public ObjectReader reader(InjectableValues injectableValues)
```
    Factory method for constructing ObjectReader that will use specified injectable values.
    
    Parameters:
    
    injectableValues - Injectable values to use
  - readerWithView
```
public ObjectReader readerWithView(Class<?> view)
```
    Factory method for constructing ObjectReader that will deserialize objects using specified JSON View (filter).
  - reader
```
public ObjectReader reader(Base64Variant defaultBase64)
```
    Factory method for constructing ObjectReader that will use specified Base64 encoding variant for Base64-encoded binary data.
    
    Since:
    
    2.1
  - reader
```
public ObjectReader reader(ContextAttributes attrs)
```
    Factory method for constructing ObjectReader that will use specified default attributes.
    
    Since:
    
    2.3
  - reader
```
@Deprecated
public ObjectReader reader(JavaType type)
```
    Deprecated. Since 2.5, use readerFor(JavaType) instead
  - reader
```
@Deprecated
public ObjectReader reader(Class<?> type)
```
    Deprecated. Since 2.5, use readerFor(Class) instead
  - reader
```
@Deprecated
public ObjectReader reader(TypeReference<?> type)
```
    Deprecated. Since 2.5, use readerFor(TypeReference) instead
  - convertValue
```
public <T> T convertValue(Object fromValue,
                          Class<T> toValueType)
                   throws IllegalArgumentException
```
    Convenience method for doing two-step conversion from given value, into instance of given value type, if (but only if!) conversion is needed. If given value is already of requested type, value is returned as is.
    This method is functionally similar to first serializing given value into JSON, and then binding JSON data into value of given type, but should be more efficient since full serialization does not (need to) occur. However, same converters (serializers, deserializers) will be used as for data binding, meaning same object mapper configuration works.
    Note that it is possible that in some cases behavior does differ from full serialize-then-deserialize cycle: in most case differences are unintentional (that is, flaws to fix) and should be reported. It is not guaranteed, however, that the behavior is 100% the same: the goal is just to allow efficient value conversions for structurally compatible Objects, according to standard Jackson configuration.
    Further note that functianality is not designed to support "advanced" use cases, such as conversion of polymorphic values, or cases where Object Identity is used.
    
    Throws:
    
    IllegalArgumentException - If conversion fails due to incompatible type; if so, root cause will contain underlying checked exception data binding functionality threw
  - convertValue
```
public <T> T convertValue(Object fromValue,
                          TypeReference<?> toValueTypeRef)
                   throws IllegalArgumentException
```
    See convertValue(Object, Class)
    
    Throws:
    
    IllegalArgumentException
  - convertValue
```
public <T> T convertValue(Object fromValue,
                          JavaType toValueType)
                   throws IllegalArgumentException
```
    See convertValue(Object, Class)
    
    Throws:
    
    IllegalArgumentException
  - _convert
```
protected Object _convert(Object fromValue,
                          JavaType toValueType)
                   throws IllegalArgumentException
```
    Actual conversion implementation: instead of using existing read and write methods, much of code is inlined. Reason for this is that we must avoid root value wrapping/unwrapping both for efficiency and for correctness. If root value wrapping/unwrapping is actually desired, caller must use explicit writeValue and readValue methods.
    
    Throws:
    
    IllegalArgumentException
  - generateJsonSchema
```
@Deprecated
public JsonSchema generateJsonSchema(Class<?> t)
                                          throws JsonMappingException
```
    Deprecated. Since 2.6 use external JSON Schema generator (https://github.com/FasterXML/jackson-module-jsonSchema) (which under the hood calls acceptJsonFormatVisitor(JavaType, JsonFormatVisitorWrapper))
    
    Generate Json-schema instance for specified class.
    
    Parameters:
    
    t - The class to generate schema for
    
    Returns:
    
    Constructed JSON schema.
    
    Throws:
    
    JsonMappingException
  - acceptJsonFormatVisitor
```
public void acceptJsonFormatVisitor(Class<?> type,
                                    JsonFormatVisitorWrapper visitor)
                             throws JsonMappingException
```
    Method for visiting type hierarchy for given type, using specified visitor.
    This method can be used for things like generating JSON Schema instance for specified type.
    
    Parameters:
    
    type - Type to generate schema for (possibly with generic signature)
    
    Throws:
    
    JsonMappingException
    
    Since:
    
    2.1
  - acceptJsonFormatVisitor
```
public void acceptJsonFormatVisitor(JavaType type,
                                    JsonFormatVisitorWrapper visitor)
                             throws JsonMappingException
```
    Method for visiting type hierarchy for given type, using specified visitor. Visitation uses Serializer hierarchy and related properties
    This method can be used for things like generating JSON Schema instance for specified type.
    
    Parameters:
    
    type - Type to generate schema for (possibly with generic signature)
    
    Throws:
    
    JsonMappingException
    
    Since:
    
    2.1
  - _serializerProvider
```
protected DefaultSerializerProvider _serializerProvider(SerializationConfig config)
```
    Overridable helper method used for constructing SerializerProvider to use for serialization.
  - _configAndWriteValue
```
protected final void _configAndWriteValue(JsonGenerator g,
                                          Object value)
                                   throws IOException
```
    Method called to configure the generator as necessary and then call write functionality
    
    Throws:
    
    IOException
  - createDeserializationContext
```
protected DefaultDeserializationContext createDeserializationContext(JsonParser p,
                                                                     DeserializationConfig cfg)
```
    Internal helper method called to create an instance of DeserializationContext for deserializing a single root value. Can be overridden if a custom context is needed.
  - _readValue
```
protected Object _readValue(DeserializationConfig cfg,
                            JsonParser p,
                            JavaType valueType)
                     throws IOException
```
    Actual implementation of value reading+binding operation.
    
    Throws:
    
    IOException
  - _readMapAndClose
```
protected Object _readMapAndClose(JsonParser p0,
                                  JavaType valueType)
                           throws IOException
```
    Throws:
    
    IOException
  - _initForReading
```
protected JsonToken _initForReading(JsonParser p)
                             throws IOException
```
    Method called to ensure that given parser is ready for reading content for data binding.
    
    Returns:
    
    First token to be used for data binding after this call: can never be null as exception will be thrown if parser can not provide more tokens.
    
    Throws:
    
    IOException - if the underlying input source has problems during parsing
    
    JsonParseException - if parser has problems parsing content
    
    JsonMappingException - if the parser does not have any more content to map (note: Json "null" value is considered content; enf-of-stream not)
  - _unwrapAndDeserialize
```
protected Object _unwrapAndDeserialize(JsonParser p,
                                       DeserializationContext ctxt,
                                       DeserializationConfig config,
                                       JavaType rootType,
                                       JsonDeserializer<Object> deser)
                                throws IOException
```
    Throws:
    
    IOException
  - _findRootDeserializer
```
protected JsonDeserializer<Object> _findRootDeserializer(DeserializationContext ctxt,
                                                         JavaType valueType)
                                                  throws JsonMappingException
```
    Method called to locate deserializer for the passed root-level value.
    
    Throws:
    
    JsonMappingException
  - _verifySchemaType
```
protected void _verifySchemaType(FormatSchema schema)
```
    Since:
    
    2.2

Class ObjectMapper

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_ANNOTATION_INTROSPECTOR

STD_VISIBILITY_CHECKER

DEFAULT_BASE

_jsonFactory

_typeFactory

_injectableValues

_subtypeResolver

_propertyOverrides

_mixIns

_serializationConfig

_serializerProvider

_serializerFactory

_deserializationConfig

_deserializationContext

_registeredModuleTypes

_rootDeserializers

Constructor Detail

ObjectMapper

ObjectMapper

ObjectMapper

ObjectMapper

Method Detail

defaultClassIntrospector

copy

_checkInvalidCopy

_newReader

_newReader

_newWriter

_newWriter

_newWriter

version

registerModule

registerModules

registerModules

findModules

findModules

findAndRegisterModules

getSerializationConfig

getDeserializationConfig

getDeserializationContext

setSerializerFactory

getSerializerFactory

setSerializerProvider

getSerializerProvider

getSerializerProviderInstance

setMixIns

addMixIn

setMixInResolver

findMixInClassFor

mixInCount

setMixInAnnotations

addMixInAnnotations

getVisibilityChecker

setVisibilityChecker

setVisibility

setVisibility

getSubtypeResolver

setSubtypeResolver

setAnnotationIntrospector

setAnnotationIntrospectors

setPropertyNamingStrategy

getPropertyNamingStrategy

setSerializationInclusion

setPropertyInclusion

setDefaultPrettyPrinter

enableDefaultTyping

enableDefaultTyping

enableDefaultTyping

enableDefaultTypingAsProperty

disableDefaultTyping

setDefaultTyping

registerSubtypes

registerSubtypes