* Note that in addition to being only mutable via {@link ObjectMapper}, * changes only take effect when done before any serialization or * deserialization calls -- that is, caller must follow * "configure-then-use" pattern. */ public enum MapperFeature implements ConfigFeature { /* /****************************************************** /* General introspection features /****************************************************** */ /** * Feature that determines whether annotation introspection * is used for configuration; if enabled, configured * {@link AnnotationIntrospector} will be used: if disabled, * no annotations are considered. *
* Feature is enabled by default. */ USE_ANNOTATIONS(true), /** * Feature that determines whether otherwise regular "getter" * methods (but only ones that handle Collections and Maps, * not getters of other type) * can be used for purpose of getting a reference to a Collection * and Map to modify the property, without requiring a setter * method. * This is similar to how JAXB framework sets Collections and * Maps: no setter is involved, just setter. *
* Note that such getters-as-setters methods have lower * precedence than setters, so they are only used if no * setter is found for the Map/Collection property. *
* Feature is enabled by default.
*/
USE_GETTERS_AS_SETTERS(true),
/**
* Feature that determines how transient modifier for fields
* is handled: if disabled, it is only taken to mean exclusion of the field
* as accessor; if true, it is taken to imply removal of the whole property.
*
* Feature is disabled by default, meaning that existence of `transient` * for a field does not necessarily lead to ignoral of getters or setters * but just ignoring the use of field for access. * * @since 2.6 */ PROPAGATE_TRANSIENT_MARKER(false), /* /****************************************************** /* Introspection-based property auto-detection /****************************************************** */ /** * Feature that determines whether "creator" methods are * automatically detected by consider public constructors, * and static single argument methods with name "valueOf". * If disabled, only methods explicitly annotated are considered * creator methods (except for the no-arg default constructor which * is always considered a factory method). *
* Note that this feature has lower precedence than per-class * annotations, and is only used if there isn't more granular * configuration available. *
* Feature is enabled by default. */ AUTO_DETECT_CREATORS(true), /** * Feature that determines whether non-static fields are recognized as * properties. * If yes, then all public member fields * are considered as properties. If disabled, only fields explicitly * annotated are considered property fields. *
* Note that this feature has lower precedence than per-class * annotations, and is only used if there isn't more granular * configuration available. *
* Feature is enabled by default. */ AUTO_DETECT_FIELDS(true), /** * Feature that determines whether regular "getter" methods are * automatically detected based on standard Bean naming convention * or not. If yes, then all public zero-argument methods that * start with prefix "get" * are considered as getters. * If disabled, only methods explicitly annotated are considered getters. *
* Note that since version 1.3, this does NOT include * "is getters" (see {@link #AUTO_DETECT_IS_GETTERS} for details) *
* Note that this feature has lower precedence than per-class * annotations, and is only used if there isn't more granular * configuration available. *
* Feature is enabled by default. */ AUTO_DETECT_GETTERS(true), /** * Feature that determines whether "is getter" methods are * automatically detected based on standard Bean naming convention * or not. If yes, then all public zero-argument methods that * start with prefix "is", and whose return type is boolean * are considered as "is getters". * If disabled, only methods explicitly annotated are considered getters. *
* Note that this feature has lower precedence than per-class * annotations, and is only used if there isn't more granular * configuration available. *
* Feature is enabled by default. */ AUTO_DETECT_IS_GETTERS(true), /** * Feature that determines whether "setter" methods are * automatically detected based on standard Bean naming convention * or not. If yes, then all public one-argument methods that * start with prefix "set" * are considered setters. If disabled, only methods explicitly * annotated are considered setters. *
* Note that this feature has lower precedence than per-class * annotations, and is only used if there isn't more granular * configuration available. *
* Feature is enabled by default. */ AUTO_DETECT_SETTERS(true), /** * Feature that determines whether getters (getter methods) * can be auto-detected if there is no matching mutator (setter, * constructor parameter or field) or not: if set to true, * only getters that match a mutator are auto-discovered; if * false, all auto-detectable getters can be discovered. *
* Feature is disabled by default. */ REQUIRE_SETTERS_FOR_GETTERS(false), /** * Feature that determines whether member fields declared as 'final' may * be auto-detected to be used mutators (used to change value of the logical * property) or not. If enabled, 'final' access modifier has no effect, and * such fields may be detected according to usual visibility and inference * rules; if disabled, such fields are NOT used as mutators except if * explicitly annotated for such use. *
* Feature is enabled by default, for backwards compatibility reasons. * * @since 2.2 */ ALLOW_FINAL_FIELDS_AS_MUTATORS(true), /** * Feature that determines whether member mutators (fields and * setters) may be "pulled in" even if they are not visible, * as long as there is a visible accessor (getter or field) with same name. * For example: field "value" may be inferred as mutator, * if there is visible or explicitly marked getter "getValue()". * If enabled, inferring is enabled; otherwise (disabled) only visible and * explicitly annotated accessors are ever used. *
* Note that 'getters' are never inferred and need to be either visible (including * bean-style naming) or explicitly annotated. *
* Feature is enabled by default. * * @since 2.2 */ INFER_PROPERTY_MUTATORS(true), /** * Feature that determines handling of {@code java.beans.ConstructorProperties} * annotation: when enabled, it is considered as alias of * {@link com.fasterxml.jackson.annotation.JsonCreator}, to mean that constructor * should be considered a property-based Creator; when disabled, only constructor * parameter name information is used, but constructor is NOT considered an explicit * Creator (although may be discovered as one using other annotations or heuristics). *
* Feature is mostly used to help inter-operability with frameworks like Lombok * that may automatically generate {@code ConstructorProperties} annotation * but without necessarily meaning that constructor should be used as Creator * for deserialization. *
* Feature is enabled by default. * * @since 2.9 */ INFER_CREATOR_FROM_CONSTRUCTOR_PROPERTIES(true), /** * Feature that determines whether nominal property type of {@link Void} is * allowed for Getter methods to indicate {@code null} valued pseudo-property * or not. If enabled, such properties are recognized (see [databind#2675] for * reasons -- mostly things related to frameworks, code generation); if disabled, * such property accessors (or at least getters) are ignored. *
* Feature is disabled by default (in 2.12) for backwards compatibility. * * @since 2.12 */ ALLOW_VOID_VALUED_PROPERTIES(false), /* /****************************************************** /* Access modifier handling /****************************************************** */ /** * Feature that determines whether method and field access * modifier settings can be overridden when accessing * properties. If enabled, method * {@link java.lang.reflect.AccessibleObject#setAccessible} * may be called to enable access to otherwise unaccessible objects. *
* Note that this setting may have significant performance implications, * since access override helps remove costly access checks on each * and every Reflection access. If you are considering disabling * this feature, be sure to verify performance consequences if usage * is performance sensitive. * Also note that performance effects vary between Java platforms * (JavaSE vs Android, for example), as well as JDK versions: older * versions seemed to have more significant performance difference. *
* Conversely, on some platforms, it may be necessary to disable this feature * as platform does not allow such calls. For example, when developing * Applets (or other Java code that runs on tightly restricted sandbox), * it may be necessary to disable the feature regardless of performance effects. *
* Feature is enabled by default.
*/
CAN_OVERRIDE_ACCESS_MODIFIERS(true),
/**
* Feature that determines that forces call to
* {@link java.lang.reflect.AccessibleObject#setAccessible} even for
* public accessors -- that is, even if no such call is
* needed from functionality perspective -- if call is allowed
* (that is, {@link #CAN_OVERRIDE_ACCESS_MODIFIERS} is set to true).
* The main reason to enable this feature is possible performance
* improvement as JDK does not have to perform access checks; these
* checks are otherwise made for all accessors, including public ones,
* and may result in slower Reflection calls. Exact impact (if any)
* depends on Java platform (Java SE, Android) as well as JDK version.
*
* Feature is enabled by default, for legacy reasons (it was the behavior * until 2.6) * * @since 2.7 */ OVERRIDE_PUBLIC_ACCESS_MODIFIERS(true), /* /****************************************************** /* Type-handling features /****************************************************** */ /** * Feature that determines whether the type detection for * serialization should be using actual dynamic runtime type, * or declared static type. * Note that deserialization always uses declared static types * since no runtime types are available (as we are creating * instances after using type information). *
* This global default value can be overridden at class, method * or field level by using {@link JsonSerialize#typing} annotation * property. *
* Feature is disabled by default which means that dynamic runtime types * are used (instead of declared static types) for serialization. */ USE_STATIC_TYPING(false), /** * Feature that specifies whether the declared base type of a polymorphic value * is to be used as the "default" implementation, if no explicit default class * is specified via {@code @JsonTypeInfo.defaultImpl} annotation. *
* Note that feature only has effect on deserialization of regular polymorphic properties: * it does NOT affect non-polymorphic cases, and is unlikely to work with Default Typing. *
* Feature is disabled by default for backwards compatibility. * * @since 2.10 */ USE_BASE_TYPE_AS_DEFAULT_IMPL(false), /** * Feature that enables inferring builder type bindings from the value type * being deserialized. This requires that the generic type declaration on * the value type match that on the builder exactly: mismatched type declarations * are not necessarily detected by databind. *
* Feature is enabled by default which means that deserialization does * support deserializing types via builders with type parameters (generic types). *
* See: https://github.com/FasterXML/jackson-databind/issues/921 * * @since 2.12 */ INFER_BUILDER_TYPE_BINDINGS(true), /* /****************************************************** /* View-related features /****************************************************** */ /** * Feature that determines whether properties that have no view * annotations are included in JSON serialization views (see * {@link com.fasterxml.jackson.annotation.JsonView} for more * details on JSON Views). * If enabled, non-annotated properties will be included; * when disabled, they will be excluded. So this feature * changes between "opt-in" (feature disabled) and * "opt-out" (feature enabled) modes. *
* Default value is enabled, meaning that non-annotated * properties are included in all views if there is no * {@link com.fasterxml.jackson.annotation.JsonView} annotation. *
* Feature is enabled by default. */ DEFAULT_VIEW_INCLUSION(true), /* /****************************************************** /* Generic output features /****************************************************** */ /** * Feature that defines default property serialization order used * for POJO fields (note: does not apply to {@link java.util.Map} * serialization!): * if enabled, default ordering is alphabetic (similar to * how {@link com.fasterxml.jackson.annotation.JsonPropertyOrder#alphabetic()} * works); if disabled, order is unspecified (based on what JDK gives * us, which may be declaration order, but is not guaranteed). *
* Note that this is just the default behavior, and can be overridden by * explicit overrides in classes (for example with * {@link com.fasterxml.jackson.annotation.JsonPropertyOrder} annotation) *
* Feature is disabled by default. */ SORT_PROPERTIES_ALPHABETICALLY(false), /* /****************************************************** /* Name-related features /****************************************************** */ /** * Feature that will allow for more forgiving deserialization of incoming JSON. * If enabled, the bean properties will be matched using their lower-case equivalents, * meaning that any case-combination (incoming and matching names are canonicalized * by lower-casing) should work. *
* Note that there is additional performance overhead since incoming property * names need to be lower-cased before comparison, for cases where there are upper-case * letters. Overhead for names that are already lower-case should be negligible. *
* Feature is disabled by default. * * @since 2.5 */ ACCEPT_CASE_INSENSITIVE_PROPERTIES(false), /** * Feature that determines if Enum deserialization should be case sensitive or not. * If enabled, Enum deserialization will ignore case, that is, case of incoming String * value and enum id (depending on other settings, either `name()`, `toString()`, or * explicit override) do not need to match. *
* Feature is disabled by default. * * @since 2.9 */ ACCEPT_CASE_INSENSITIVE_ENUMS(false), /** * Feature that permits parsing some enumerated text-based value types but ignoring the case * of the values on deserialization: for example, date/time type deserializers. * Support for this feature depends on deserializer implementations using it. *
* Note, however, that regular {@code Enum} types follow {@link #ACCEPT_CASE_INSENSITIVE_ENUMS} * setting instead. *
* Feature is disabled by default. * * @since 2.10 */ ACCEPT_CASE_INSENSITIVE_VALUES(false), /** * Feature that can be enabled to make property names be * overridden by wrapper name (usually detected with annotations * as defined by {@link AnnotationIntrospector#findWrapperName}. * If enabled, all properties that have associated non-empty Wrapper * name will use that wrapper name instead of property name. * If disabled, wrapper name is only used for wrapping (if anything). *
* Feature is disabled by default. * * @since 2.1 */ USE_WRAPPER_NAME_AS_PROPERTY_NAME(false), /** * Feature that may be enabled to enforce strict compatibility with * Bean name introspection, instead of slightly different mechanism * Jackson defaults to. * Specific difference is that Jackson always lower cases leading upper-case * letters, so "getURL()" becomes "url" property; whereas standard Bean * naming only lower-cases the first letter if it is NOT followed by * another upper-case letter (so "getURL()" would result in "URL" property). *
* Feature is disabled by default for backwards compatibility purposes: earlier * Jackson versions used Jackson's own mechanism. * * @since 2.5 */ USE_STD_BEAN_NAMING(false), /** * Feature that when enabled will allow explicitly named properties (i.e., fields or methods * annotated with {@link com.fasterxml.jackson.annotation.JsonProperty}("explicitName")) to * be re-named by a {@link PropertyNamingStrategy}, if one is configured. *
* Feature is disabled by default. * * @since 2.7 */ ALLOW_EXPLICIT_PROPERTY_RENAMING(false), /* /****************************************************** /* Coercion features /****************************************************** */ /** * Feature that determines whether coercions from secondary representations are allowed * for simple non-textual scalar types: numbers and booleans. This includes `primitive` * types and their wrappers, but excludes `java.lang.String` and date/time types. *
* When feature is disabled, only strictly compatible input may be bound: numbers for * numbers, boolean values for booleans. When feature is enabled, conversions from * JSON String are allowed, as long as textual value matches (for example, String * "true" is allowed as equivalent of JSON boolean token `true`; or String "1.0" * for `double`). *
* Note that it is possible that other configurability options can override this * in closer scope (like on per-type or per-property basis); this is just the global * default. *
* Feature is enabled by default (for backwards compatibility since this was the * default behavior) * * @since 2.9 */ ALLOW_COERCION_OF_SCALARS(true), /* /****************************************************** /* Other features /****************************************************** */ /** * Feature that determines whether multiple registrations of same module * should be ignored or not; if enabled, only the first registration call * results in module being called, and possible duplicate calls are silently * ignored; if disabled, no checking is done and all registration calls are * dispatched to module. *
* Definition of "same module" is based on using {@link Module#getTypeId()};
* modules with same non-null type id are considered same for
* purposes of duplicate registration. This also avoids having to keep track
* of actual module instances; only ids will be kept track of (and only if
* this feature is enabled).
*
* Feature is enabled by default.
*
* @since 2.5
*/
IGNORE_DUPLICATE_MODULE_REGISTRATIONS(true),
/**
* Setting that determines what happens if an attempt is made to explicitly
* "merge" value of a property, where value does not support merging; either
* merging is skipped and new value is created (true) or
* an exception is thrown (false).
*
* Feature is enabled by default, to allow use of merge defaults even in presence * of some unmergeable properties. * * @since 2.9 */ IGNORE_MERGE_FOR_UNMERGEABLE(true), /** * Setting that may be enabled to reconfigure default * {@link com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator} * used by legacy {@code ObjectMapper.enableDefaultTyping()} methods as well as default used * for annotation-based polymorphic handling so that it uses * {@link com.fasterxml.jackson.databind.jsontype.DefaultBaseTypeLimitingValidator}. * This will block use of a set of "unsafe" base types such as {@link java.lang.Object} * through methods that do not require passing of explicit {@link com.fasterxml.jackson.databind.jsontype.PolymorphicTypeValidator}. * It is still possible to override one used; this only affects default settings. *
* Enabling of this setting is strongly recommended. *
* Feature is disabled by default in 2.x for backwards compatibility reasons: it will become * default setting (and feature likely removed) in 3.0. * * @since 2.11 */ BLOCK_UNSAFE_POLYMORPHIC_BASE_TYPES(false) ; private final boolean _defaultState; private final int _mask; private MapperFeature(boolean defaultState) { _defaultState = defaultState; _mask = (1 << ordinal()); } @Override public boolean enabledByDefault() { return _defaultState; } @Override public int getMask() { return _mask; } @Override public boolean enabledIn(int flags) { return (flags & _mask) != 0; } }