public final Enum DeserializationFeature

Feature that can be enabled to allow empty JSON Array value (that is, [ ] to be bound to POJOs null. If disabled, standard POJOs can only be bound from JSON null or JSON Object (standard meaning that no custom deserializers or constructors are defined; both of which can add support for other kinds of JSON values); if enabled, empty JSON Array will be taken to be equivalent of JSON null.

Feature is disabled by default.

Feature that can be enabled to allow JSON empty String value ("") to be bound as null for POJOs and other structured values (java.util.Maps, java.util.Collections). If disabled, standard POJOs can only be bound from JSON null or JSON Object (standard meaning that no custom deserializers or constructors are defined; both of which can add support for other kinds of JSON values); if enabled, empty JSON String can be taken to be equivalent of JSON null.

Feature is disabled by default.

Feature that determines whether coercion from JSON floating point number (anything with command (`.`) or exponent portion (`e` / `E')) to an expected integral number (`int`, `long`, `java.lang.Integer`, `java.lang.Long`, `java.math.BigDecimal`) is allowed or not. If enabled, coercion truncates value; if disabled, a DatabindException will be thrown.

Feature is enabled by default.

Feature that determines whether it is acceptable to coerce non-array (in JSON) values to work with Java collection (arrays, java.util.Collection) types. If enabled, collection deserializers will try to handle non-array values as if they had "implicit" surrounding JSON array. This feature is meant to be used for compatibility/interoperability reasons, to work with packages (such as XML-to-JSON converters) that leave out JSON array in cases where there is just a single element in array.

Feature is disabled by default.

Feature that determines whether ObjectReader should try to eagerly fetch necessary ValueDeserializer when possible. This improves performance in cases where similarly configured ObjectReader instance is used multiple times; and should not significantly affect single-use cases.

Note that there should not be any need to normally disable this feature: only consider that if there are actual perceived problems.

Feature is enabled by default.

Feature that determines what happens when a property that has been explicitly marked as ignorable is encountered in input: if feature is enabled, DatabindException is thrown; if false, property is quietly skipped.

Feature is disabled by default so that no exception is thrown.

Feature that determines what happens when type of a polymorphic value (indicated for example by com.fasterxml.jackson.annotation.JsonTypeInfo) cannot be found (missing) or resolved (invalid class name, non-mappable id); if enabled, an exception is thrown; if false, null value is used instead.

Feature is enabled by default so that exception is thrown for missing or invalid type information.

Feature that determines what happens if one or more Creator properties (properties bound to parameters of Creator method (constructor or static factory method)) are missing value to bind to from content. If enabled, such missing values result in a DatabindException being thrown with information on the first one (by index) of missing properties. If disabled, and if property is NOT marked as required, missing Creator properties are filled with null values provided by deserializer for the type of parameter (usually null for Object types, and default value for primitives; but redefinable via custom deserializers).

Note that having an injectable value counts as "not missing".

Feature is disabled by default, so that no exception is thrown for missing creator property values, unless they are explicitly marked as `required`.

Feature that determines what happens when a property annotated with com.fasterxml.jackson.annotation.JsonTypeInfo.As#EXTERNAL_PROPERTY is missing, but associated type id is available. If enabled, a DatabindException is always thrown when property value is missing (if type id does exist); if disabled, exception is only thrown if property is marked as required.

Feature is enabled by default, so that exception is thrown when a subtype property is missing.

Feature that determines what happens if one or more Creator properties (properties bound to parameters of Creator method (constructor or static factory method)) are bound to null values - either from the JSON or as a default value. This is useful if you want to avoid nulls in your codebase, and particularly useful if you are using Java or Scala Optionals for non-mandatory fields. Feature is disabled by default, so that no exception is thrown for missing creator property values, unless they are explicitly marked as `required`.

Feature that determines whether encountering of JSON null is an error when deserializing into Java primitive types (like 'int' or 'double'). If it is, a DatabindException is thrown to indicate this; if not, default value is used (0 for 'int', 0.0 for double, same defaulting as what JVM uses).

Feature is enabled by default as of Jackson 3.0 (in 2.x it was disabled).

Feature that determines what happens when reading JSON content into tree (tools.jackson.core.TreeNode) and a duplicate key is encountered (property name that was already seen for the JSON Object). If enabled, DatabindException will be thrown; if disabled, no exception is thrown and the new (later) value overwrites the earlier value.

Note that this property does NOT affect other aspects of data-binding; that is, no detection is done with respect to POJO properties or java.util.Map keys. New features may be added to control additional cases.

Feature is disabled by default so that no exception is thrown.

Feature that determines behavior when deserializing polymorphic types that use Class-based Type Id mechanism (either JsonTypeInfo.Id.CLASS or JsonTypeInfo.Id.MINIMAL_CLASS): If enabled, an exception will be thrown if a subtype (Class) is encountered that has not been explicitly registered (by calling MapperBuilder#registerSubtypes or using annotation com.fasterxml.jackson.annotation.JsonSubTypes).

Note that for Type Name - based Type Id mechanism (JsonTypeInfo.Id.NAME) you already need to register the subtypes but with so this feature has no effect.

Feature is disabled by default.

Feature that determines behavior for data-binding after binding the root value. If feature is enabled, one more call to tools.jackson.core.JsonParser#nextToken is made to ensure that no more tokens are found (and if any is found, tools.jackson.databind.exc.MismatchedInputException is thrown); if disabled, no further checks are made.

Feature could alternatively be called READ_FULL_STREAM, since it effectively verifies that input stream contains only as much data as is needed for binding the full value, and nothing more (except for possible ignorable white space or comments, if supported by data format).

Feature is enabled by default as of Jackson 3.0 (in 2.x it was disabled).

Feature that determines the handling of properties not included in the active JSON view during deserialization.

When enabled, if a property is encountered during deserialization that is not part of the active view (as defined by com.fasterxml.jackson.annotation.JsonView), an exception is thrown. If disabled, the property is simply ignored.

This feature is particularly useful in scenarios where strict adherence to the specified view is required and any deviation, such as the presence of properties not belonging to the view, should be reported as an error. It can enhance the robustness of data binding by ensuring that only the properties relevant to the active view are considered during deserialization, thereby preventing unintended data from being processed.

Feature is disabled by default to maintain backward compatibility.

Feature that determines the handling of injected properties during deserialization.

When enabled, if an injected property without matching value is encountered during deserialization, an exception is thrown. When disabled, no exception is thrown. See JacksonInject#optional() for per-property override of this setting.

This feature is enabled by default to maintain backwards-compatibility.

See Also

JacksonInject#optional()

Feature that determines whether encountering of unknown properties (ones that do not map to a property, and there is no "any setter" or handler that can handle it) should result in a failure (by throwing a DatabindException) or not. This setting only takes effect after all other handling methods for unknown properties have been tried, and property remains unhandled. Enabling this feature means that a DatabindException will be thrown if an unknown property is encountered.

Feature is disabled by default as of Jackson 3.0 (in 2.x it was enabled).

Feature that determines what happens if an Object Id reference is encountered that does not refer to an actual Object with that id ("unresolved Object Id"): either an exception tools.jackson.databind.deser.UnresolvedForwardReference containing information about tools.jackson.databind.deser.UnresolvedId is thrown (true), or a null object is used instead (false). Note that if this is set to false, no further processing is done; specifically, if reference is defined via setter method, that method will NOT be called.

Feature is enabled by default, so that unknown Object Ids will result in an exception being thrown, at the end of deserialization.

Feature to allow "unwrapping" root-level JSON value, to match setting of SerializationFeature#WRAP_ROOT_VALUE used for serialization. Will verify that the root JSON value is a JSON Object, and that it has a single property with expected root name. If not, a DatabindException is thrown; otherwise value of the wrapped property will be deserialized as if it was the root value.

Feature is disabled by default.

Feature that determines whether it is acceptable to coerce single value array (in JSON) values to the corresponding value type. This is basically the opposite of the ACCEPT_SINGLE_VALUE_AS_ARRAY feature. If more than one value is found in the array, a DatabindException is thrown.

Feature is disabled by default.

Feature that determines whether JSON floating point numbers are to be deserialized into java.math.BigDecimals if only generic type description (either Object or Number, or within untyped java.util.Map or java.util.Collection context) is available. If enabled such values will be deserialized as java.math.BigDecimals; if disabled, will be deserialized as Doubles.

Feature is disabled by default, meaning that "untyped" floating point numbers will by default be deserialized as Doubles (choice is for performance reason -- BigDecimals are slower than Doubles).

Feature that determines whether JSON integral (non-floating-point) numbers are to be deserialized into java.math.BigIntegers if only generic type description (either Object or Number, or within untyped java.util.Map or java.util.Collection context) is available. If enabled such values will be deserialized as java.math.BigIntegers; if disabled, will be deserialized as "smallest" available type, which is either Integer, Long or java.math.BigInteger, depending on number of digits.

Feature is disabled by default, meaning that "untyped" integral numbers will by default be deserialized using whatever is the most compact integral type, to optimize efficiency.

Feature that determines whether JSON Array is mapped to Object[] or List<Object> when binding "untyped" objects (ones with nominal type of java.lang.Object). If true, binds as Object[]; if false, as List<Object>.

Feature is disabled by default, meaning that JSON arrays are bound as java.util.Lists.

Feature that determines how "small" JSON integral (non-floating-point) numbers -- ones that fit in 32-bit signed integer (`int`) -- are bound when target type is loosely typed as Object or Number (or within untyped java.util.Map or java.util.Collection context). If enabled, such values will be deserialized as java.lang.Long; if disabled, they will be deserialized as "smallest" available type, Integer.

Feature is disabled by default, meaning that "untyped" integral numbers will by default be deserialized using java.lang.Integer if value fits.

Feature that determines whether Jackson code should catch and wrap non-Jackson Exceptions (but never Errors!) to add additional information about location (within input) of problem or not. If enabled, most exceptions will be caught and re-thrown; this can be convenient both in that all exceptions will be checked and declared, and so there is more contextual information. However, sometimes calling application may just want "raw" unchecked exceptions passed as is.

Disabling this feature will mean that you will need to adjust your try/catch blocks to properly handle RuntimeExceptions. Failing to do so, may cause your application to crash due to unhandled exceptions.

Feature is enabled by default.