CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-com-fasterxml-jackson-core--jackson-databind

General data-binding functionality for Jackson: works on core streaming API

—

Pending
Overview
Eval results
Files

configuration.mddocs/

Configuration

Jackson Databind provides extensive configuration capabilities through features, settings, and overrides that control serialization and deserialization behavior. The configuration system includes feature enums, configuration classes, and builder patterns for fine-grained control over JSON processing.

Configuration Features

Jackson uses enum-based feature flags for configuration. Features are grouped into different categories based on their scope and purpose.

MapperFeature

MapperFeature defines features that affect general mapper behavior and configuration.

public enum MapperFeature implements ConfigFeature {
    // Annotation processing
    USE_ANNOTATIONS(true),
    
    // Creator detection  
    AUTO_DETECT_CREATORS(true),
    AUTO_DETECT_FIELDS(true),
    AUTO_DETECT_GETTERS(true),
    AUTO_DETECT_IS_GETTERS(true),
    AUTO_DETECT_SETTERS(true),
    
    // Access modifier handling
    REQUIRE_SETTERS_FOR_GETTERS(false),
    ALLOW_FINAL_FIELDS_AS_MUTATORS(false),
    INFER_PROPERTY_MUTATORS(true),
    INFER_CREATOR_FROM_CONSTRUCTOR_PROPERTIES(true),
    
    // Case sensitivity
    ACCEPT_CASE_INSENSITIVE_PROPERTIES(false),
    ACCEPT_CASE_INSENSITIVE_ENUMS(false),
    ACCEPT_CASE_INSENSITIVE_VALUES(false),
    
    // Static typing
    USE_STATIC_TYPING(false),
    
    // Base64 handling
    USE_BASE64_VARIANT_FOR_BINARY(false),
    
    // Getter behavior  
    DEFAULT_VIEW_INCLUSION(true),
    SORT_PROPERTIES_ALPHABETICALLY(false),
    
    // Visibility
    OVERRIDE_PUBLIC_ACCESS_MODIFIERS(true),
    
    // Coercion
    USE_STD_BEAN_NAMING(false),
    ALLOW_VOID_VALUED_PROPERTIES(false),
    
    // Property inclusion
    CAN_OVERRIDE_ACCESS_MODIFIERS(true),
    
    // Constructor properties
    INFER_BUILDER_TYPE_BINDINGS(true),
    
    // Propagate transient marker  
    PROPAGATE_TRANSIENT_MARKER(false),
    
    // Block unsafe polymorphic base types
    BLOCK_UNSAFE_POLYMORPHIC_BASE_TYPES(false),
    
    // Apply default values
    APPLY_DEFAULT_VALUES(false);
    
    private final boolean _defaultState;
    private final int _mask;
    
    private MapperFeature(boolean defaultState) {
        _defaultState = defaultState;
        _mask = (1 << ordinal());
    }
    
    public boolean enabledByDefault() {
        return _defaultState;
    }
    
    public int getMask() {
        return _mask;
    }
    
    public boolean enabledIn(int flags) {
        return (flags & _mask) != 0;
    }
}

SerializationFeature

SerializationFeature controls serialization behavior (covered in detail in serialization.md).

public enum SerializationFeature implements ConfigFeature {
    WRAP_ROOT_VALUE(false),
    INDENT_OUTPUT(false),
    FAIL_ON_EMPTY_BEANS(true),
    FAIL_ON_SELF_REFERENCES(true),
    WRAP_EXCEPTIONS(true),
    FAIL_ON_UNWRAPPED_TYPE_IDENTIFIERS(true),
    WRITE_SELF_REFERENCES_AS_NULL(false),
    CLOSE_CLOSEABLE(false),
    FLUSH_AFTER_WRITE_VALUE(true),
    WRITE_DATES_AS_TIMESTAMPS(true),
    WRITE_DATE_KEYS_AS_TIMESTAMPS(false),
    WRITE_CHAR_ARRAYS_AS_JSON_ARRAYS(false),
    WRITE_ENUMS_USING_TO_STRING(false),
    WRITE_ENUMS_USING_INDEX(false),
    WRITE_ENUM_KEYS_USING_INDEX(false),
    WRITE_NULL_MAP_VALUES(true),
    WRITE_EMPTY_JSON_ARRAYS(true),
    WRITE_SINGLE_ELEM_ARRAYS_UNWRAPPED(false),
    WRITE_BIGDECIMAL_AS_PLAIN(false),
    WRITE_DATE_TIMESTAMPS_AS_NANOSECONDS(true),
    ORDER_MAP_ENTRIES_BY_KEYS(false),
    USE_EQUALITY_FOR_OBJECT_ID(false);
    
    // Implementation similar to MapperFeature
}

DeserializationFeature

DeserializationFeature controls deserialization behavior (covered in detail in deserialization.md).

public enum DeserializationFeature implements ConfigFeature {
    USE_BIG_DECIMAL_FOR_FLOATS(false),
    USE_BIG_INTEGER_FOR_INTS(false),
    USE_LONG_FOR_INTS(false),
    USE_JAVA_ARRAY_FOR_JSON_ARRAY(false),
    FAIL_ON_UNKNOWN_PROPERTIES(true),
    FAIL_ON_NULL_FOR_PRIMITIVES(false),
    FAIL_ON_NUMBERS_FOR_ENUMS(false),
    FAIL_ON_INVALID_SUBTYPE(true),
    FAIL_ON_READING_DUP_TREE_KEY(false),
    FAIL_ON_IGNORED_PROPERTIES(false),
    FAIL_ON_UNRESOLVED_OBJECT_IDS(true),
    FAIL_ON_MISSING_CREATOR_PROPERTIES(false),
    FAIL_ON_NULL_CREATOR_PROPERTIES(false),
    FAIL_ON_MISSING_EXTERNAL_TYPE_ID_PROPERTY(true),
    FAIL_ON_TRAILING_TOKENS(false),
    WRAP_EXCEPTIONS(true),
    ACCEPT_SINGLE_VALUE_AS_ARRAY(false),
    UNWRAP_SINGLE_VALUE_ARRAYS(false),
    UNWRAP_ROOT_VALUE(false),
    ACCEPT_EMPTY_STRING_AS_NULL_OBJECT(false),
    ACCEPT_EMPTY_ARRAY_AS_NULL_OBJECT(false),
    ACCEPT_FLOAT_AS_INT(true),
    READ_ENUMS_USING_TO_STRING(false),
    READ_UNKNOWN_ENUM_VALUES_AS_NULL(false),
    READ_UNKNOWN_ENUM_VALUES_USING_DEFAULT_VALUE(false),
    READ_DATE_TIMESTAMPS_AS_NANOSECONDS(true),
    ADJUST_DATES_TO_CONTEXT_TIME_ZONE(true),
    EAGER_DESERIALIZER_FETCH(true);
    
    // Implementation similar to MapperFeature
}

Base Configuration Classes

MapperConfig

MapperConfig is the base class for mapper configuration objects.

public abstract class MapperConfig<T> implements ClassIntrospector.MixInResolver, Serializable {
    // Feature checking
    public final boolean isEnabled(MapperFeature f);
    public final boolean isEnabled(JsonFactory.Feature f);
    public final boolean hasMapperFeatures(int featureMask);
    public final boolean hasSomeOfFeatures(int featureMask);
    
    // Settings access
    public final BaseSettings getBase();
    public final AnnotationIntrospector getAnnotationIntrospector();
    public final VisibilityChecker<?> getDefaultVisibilityChecker();
    public SubtypeResolver getSubtypeResolver();
    public final PropertyNamingStrategy getPropertyNamingStrategy();
    public final HandlerInstantiator getHandlerInstantiator();
    public final TypeResolverBuilder<?> getDefaultTyper();
    
    // Type factory
    public final TypeFactory getTypeFactory();
    
    // Access control
    public final boolean canOverrideAccessModifiers();
    public final boolean shouldSortPropertiesAlphabetically();
    
    // Locale and timezone
    public final Locale getLocale();
    public final TimeZone getTimeZone();
    
    // Property inclusion
    public abstract JsonInclude.Value getDefaultPropertyInclusion();
    public abstract JsonInclude.Value getDefaultPropertyInclusion(Class<?> baseType);
    public JsonInclude.Value getDefaultInclusion(Class<?> baseType, Class<?> propertyType);
    
    // Configuration overrides
    public final ConfigOverride findConfigOverride(Class<?> type);
    public final ConfigOverride getConfigOverride(Class<?> type);
    public final JsonInclude.Value getDefaultPropertyInclusion(Class<?> baseType, JsonInclude.Value defaultIncl);
    public final JsonFormat.Value getDefaultPropertyFormat(Class<?> type);
    public final VisibilityChecker<?> getDefaultVisibilityChecker(Class<?> forClass, VisibilityChecker<?> defaultVc);
    
    // Mix-in support (from MixInResolver)
    public final Class<?> findMixInClassFor(Class<?> cls);
    public final int mixInCount();
    
    // Root name handling
    public abstract PropertyName findRootName(JavaType rootType);
    public abstract PropertyName findRootName(Class<?> rawRootType);
    
    // View support  
    public final Class<?> getActiveView();
    
    // Context attributes
    public abstract ContextAttributes getAttributes();
    
    // Introspection
    public final ClassIntrospector getClassIntrospector();
    
    // Problem handlers (for deserialization config)
    public abstract boolean useRootWrapping();
    
    // Date format
    public final DateFormat getDateFormat();
    
    // Constructor detector
    public final ConstructorDetector getConstructorDetector();
    
    // Coercion configs
    public final CoercionConfigs getCoercionConfigs();
}

BaseSettings

BaseSettings contains shared configuration settings.

public final class BaseSettings implements Serializable {
    // Construction  
    public BaseSettings(ClassIntrospector ci, AnnotationIntrospector ai, VisibilityChecker<?> vc, PropertyNamingStrategy pns, TypeFactory tf, TypeResolverBuilder<?> typer, DateFormat dateFormat, HandlerInstantiator hi, Locale locale, TimeZone tz, Base64Variant base64);
    
    // Component access
    public ClassIntrospector getClassIntrospector();
    public AnnotationIntrospector getAnnotationIntrospector();
    public PropertyNamingStrategy getPropertyNamingStrategy();  
    public TypeFactory getTypeFactory();
    public TypeResolverBuilder<?> getTypeResolverBuilder();
    public DateFormat getDateFormat();
    public HandlerInstantiator getHandlerInstantiator();
    public Locale getLocale();
    public TimeZone getTimeZone();
    public VisibilityChecker<?> getDefaultVisibilityChecker();
    public Base64Variant getBase64Variant();
    
    // Modification methods  
    public BaseSettings withClassIntrospector(ClassIntrospector ci);
    public BaseSettings withAnnotationIntrospector(AnnotationIntrospector ai);
    public BaseSettings withInsertedAnnotationIntrospector(AnnotationIntrospector ai);
    public BaseSettings withAppendedAnnotationIntrospector(AnnotationIntrospector ai);
    public BaseSettings withVisibilityChecker(VisibilityChecker<?> vc);
    public BaseSettings withPropertyNamingStrategy(PropertyNamingStrategy pns);
    public BaseSettings withTypeFactory(TypeFactory tf);
    public BaseSettings withTypeResolverBuilder(TypeResolverBuilder<?> typer);
    public BaseSettings withDateFormat(DateFormat df);
    public BaseSettings withHandlerInstantiator(HandlerInstantiator hi);
    public BaseSettings withLocale(Locale l);
    public BaseSettings withTimeZone(TimeZone tz);
    public BaseSettings withBase64Variant(Base64Variant base64);
}

Configuration Overrides

ConfigOverride

ConfigOverride allows per-type configuration overrides.

public abstract class ConfigOverride {
    // Format override
    public JsonFormat.Value getFormat();
    
    // Inclusion override  
    public JsonInclude.Value getInclude();
    public JsonInclude.Value getIncludeAsProperty();
    
    // Ignored properties
    public JsonIgnoreProperties.Value getIgnorals();
    
    // Setter configuration
    public JsonSetter.Value getSetterInfo();
    
    // Visibility
    public VisibilityChecker.Std getVisibility();
    
    // Mergeable info
    public Boolean getMergeable();
    
    // Null handling
    public JsonSetter.Value getNullHandling();
}

public class MutableConfigOverride extends ConfigOverride {
    // Modification methods
    public MutableConfigOverride setFormat(JsonFormat.Value v);
    public MutableConfigOverride setInclude(JsonInclude.Value v);  
    public MutableConfigOverride setIncludeAsProperty(JsonInclude.Value v);
    public MutableConfigOverride setIgnorals(JsonIgnoreProperties.Value v);
    public MutableConfigOverride setSetterInfo(JsonSetter.Value v);
    public MutableConfigOverride setVisibility(VisibilityChecker.Std v);
    public MutableConfigOverride setMergeable(Boolean v);
    public MutableConfigOverride setNullHandling(JsonSetter.Value v);
}

public class ConfigOverrides {
    // Override access
    public ConfigOverride findOverride(Class<?> type);
    
    // Default settings
    public MutableConfigOverride setDefaultInclusion(JsonInclude.Value v);
    public MutableConfigOverride setDefaultSetterInfo(JsonSetter.Value v);
    public MutableConfigOverride setDefaultMergeable(Boolean v);
    public MutableConfigOverride setDefaultLeniency(Boolean v);
    
    // Type-specific overrides
    public MutableConfigOverride findOrCreateOverride(Class<?> type);
}

Context Attributes

ContextAttributes

ContextAttributes provides a way to pass context-specific data during serialization/deserialization.

public abstract class ContextAttributes {
    // Attribute access
    public abstract Object getAttribute(Object key);
    public abstract ContextAttributes withSharedAttribute(Object key, Object value);
    public abstract ContextAttributes withSharedAttributes(Map<?, ?> attributes);
    public abstract ContextAttributes withPerCallAttribute(Object key, Object value);
    public abstract ContextAttributes withoutSharedAttribute(Object key);
    
    // Factory methods
    public static ContextAttributes getEmpty();
    
    // Implementation class
    public static class Impl extends ContextAttributes implements Serializable {
        public Impl(Map<?, ?> shared);
        public Impl(Map<?, ?> shared, Map<?, ?> perCall);
        
        public Object getAttribute(Object key);
        public ContextAttributes withSharedAttribute(Object key, Object value);
        public ContextAttributes withSharedAttributes(Map<?, ?> attributes);
        public ContextAttributes withPerCallAttribute(Object key, Object value);
        public ContextAttributes withoutSharedAttribute(Object key);
    }
}

Constructor Detection

ConstructorDetector

ConstructorDetector configures how constructors are detected and used for deserialization.

public final class ConstructorDetector implements Serializable {
    // Predefined strategies
    public static final ConstructorDetector DEFAULT;
    public static final ConstructorDetector USE_PROPERTIES_BASED;
    public static final ConstructorDetector USE_DELEGATING;  
    public static final ConstructorDetector EXPLICIT_ONLY;
    
    // Factory methods
    public static ConstructorDetector requireCtorAnnotation();
    public static ConstructorDetector useDefaultConstructor();
    public static ConstructorDetector useDelegating();
    public static ConstructorDetector useProperties();
    
    // Configuration methods
    public ConstructorDetector withRequireAnnotation(boolean state);
    public ConstructorDetector withAllowJDKTypeConstructors(boolean state);
    public ConstructorDetector withSingleArgConstructorStrategy(SingleArgConstructor strategy);
    
    // Query methods
    public boolean requireCtorAnnotation();
    public boolean allowJDKTypeConstructors();
    public SingleArgConstructor singleArgConstructorStrategy();
    
    // Single argument constructor strategy
    public enum SingleArgConstructor {
        DELEGATING,
        PROPERTIES,  
        HEURISTIC;
    }
}

Coercion Configuration

CoercionConfig

CoercionConfig controls type coercion behavior during deserialization.

public class CoercionConfig implements Serializable {
    // Coercion action lookup
    public CoercionAction findAction(CoercionInputShape inputShape);
    
    // Boolean coercion settings
    public Boolean getAcceptBlankAsEmpty();
    
    // State checking
    public boolean isCoercionEnabled();
}

public class MutableCoercionConfig extends CoercionConfig {
    // Action configuration
    public MutableCoercionConfig setCoercion(CoercionInputShape shape, CoercionAction action);
    public MutableCoercionConfig setAcceptBlankAsEmpty(Boolean state);
}

public class CoercionConfigs implements Serializable {
    // Default coercion lookup
    public CoercionAction findCoercion(DeserializationConfig config, LogicalType logicalType, Class<?> rawTargetType, CoercionInputShape inputShape);
    public CoercionAction findCoercionFromBlankString(DeserializationConfig config, LogicalType logicalType, Class<?> rawTargetType, CoercionAction actionIfBlankNotAllowed);
    
    // Default coercion config access
    public MutableCoercionConfig defaultCoercions();
    
    // Type-specific coercion config
    public MutableCoercionConfig findOrCreateCoercion(LogicalType logicalType);
    public MutableCoercionConfig findOrCreateCoercion(Class<?> rawType);
}

// Coercion enums
public enum CoercionAction {
    AsEmpty,
    AsNull, 
    Fail,
    TryConvert;
}

public enum CoercionInputShape {
    Array,
    Boolean,
    Float,
    Integer,
    Object,
    String;
}

Cache Configuration

CacheProvider

CacheProvider allows customization of caching strategies for deserializers, serializers, and type information.

public interface CacheProvider {
    // Cache creation for different components
    LookupCache<Object, JsonDeserializer<Object>> forDeserializerCache(DeserializationConfig config);
    LookupCache<Object, JsonSerializer<Object>> forSerializerCache(SerializationConfig config);  
    LookupCache<Object, JavaType> forTypeFactory();
}

public class DefaultCacheProvider implements CacheProvider {
    // Default cache instances
    public static final CacheProvider INSTANCE;
    
    // Cache factory methods with default implementations
    public LookupCache<Object, JsonDeserializer<Object>> forDeserializerCache(DeserializationConfig config);
    public LookupCache<Object, JsonSerializer<Object>> forSerializerCache(SerializationConfig config);
    public LookupCache<Object, JavaType> forTypeFactory();
}

Usage Examples

Basic Feature Configuration

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.MapperFeature;

ObjectMapper mapper = new ObjectMapper();

// Configure serialization features
mapper.configure(SerializationFeature.INDENT_OUTPUT, true);
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);

// Configure deserialization features  
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
mapper.configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true);
mapper.configure(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS, true);

// Configure mapper features
mapper.configure(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES, true);
mapper.configure(MapperFeature.SORT_PROPERTIES_ALPHABETICALLY, true);

// Enable/disable multiple features at once
mapper.enable(SerializationFeature.ORDER_MAP_ENTRIES_BY_KEYS,
              SerializationFeature.WRITE_ENUMS_USING_TO_STRING);

mapper.disable(DeserializationFeature.FAIL_ON_IGNORED_PROPERTIES,
               DeserializationFeature.FAIL_ON_INVALID_SUBTYPE);

// Check feature status
boolean indented = mapper.isEnabled(SerializationFeature.INDENT_OUTPUT);
boolean caseSensitive = !mapper.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES);
boolean strict = mapper.isEnabled(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);

Configuration Overrides

import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.cfg.ConfigOverrides;

ObjectMapper mapper = new ObjectMapper();

// Global inclusion setting
mapper.setDefaultPropertyInclusion(JsonInclude.Include.NON_NULL);

// Per-type overrides
ConfigOverrides overrides = mapper.getConfigOverrides();

// Override Date formatting for all Date fields
overrides.findOrCreateOverride(Date.class)
    .setFormat(JsonFormat.Value.forPattern("yyyy-MM-dd"));

// Override inclusion for specific type
overrides.findOrCreateOverride(OptionalData.class)
    .setInclude(JsonInclude.Value.construct(JsonInclude.Include.NON_ABSENT, null));

// Override property naming for specific type  
overrides.findOrCreateOverride(LegacyData.class)
    .setFormat(JsonFormat.Value.forShape(JsonFormat.Shape.OBJECT));

// Multiple overrides for a type
overrides.findOrCreateOverride(PersonData.class)
    .setInclude(JsonInclude.Value.construct(JsonInclude.Include.NON_DEFAULT, null))
    .setFormat(JsonFormat.Value.forShape(JsonFormat.Shape.OBJECT))
    .setMergeable(Boolean.TRUE);

Context Attributes

import com.fasterxml.jackson.databind.cfg.ContextAttributes;

ObjectMapper mapper = new ObjectMapper();

// Set default context attributes
Map<String, Object> defaultAttrs = new HashMap<>();
defaultAttrs.put("version", "2.0");
defaultAttrs.put("environment", "production");
mapper.setDefaultAttributes(ContextAttributes.getEmpty().withSharedAttributes(defaultAttrs));

// Use with ObjectReader/ObjectWriter for per-operation attributes
ObjectReader reader = mapper.reader()
    .withAttribute("requestId", "12345")
    .withAttribute("userId", "user123");

ObjectWriter writer = mapper.writer()
    .withAttribute("outputFormat", "compact")
    .withAttribute("includeMetadata", true);

// Custom serializer that uses context attributes
public class MetadataAwareSerializer extends StdSerializer<MyData> {
    
    public MetadataAwareSerializer() {
        super(MyData.class);
    }
    
    @Override
    public void serialize(MyData value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        gen.writeStartObject();
        
        // Write standard fields
        gen.writeStringField("id", value.getId());
        gen.writeStringField("name", value.getName());
        
        // Check context for metadata inclusion
        Boolean includeMetadata = (Boolean) serializers.getAttribute("includeMetadata");
        if (Boolean.TRUE.equals(includeMetadata)) {
            gen.writeStringField("version", (String) serializers.getAttribute("version"));
            gen.writeStringField("environment", (String) serializers.getAttribute("environment"));
        }
        
        gen.writeEndObject();
    }
}

Constructor Detection Configuration

import com.fasterxml.jackson.databind.cfg.ConstructorDetector;

ObjectMapper mapper = new ObjectMapper();

// Require explicit @JsonCreator annotations
mapper.setConstructorDetector(ConstructorDetector.requireCtorAnnotation());

// Use properties-based detection primarily
mapper.setConstructorDetector(ConstructorDetector.useProperties());

// Custom constructor detection strategy
ConstructorDetector customDetector = ConstructorDetector.DEFAULT
    .withRequireAnnotation(false)
    .withAllowJDKTypeConstructors(true)
    .withSingleArgConstructorStrategy(ConstructorDetector.SingleArgConstructor.HEURISTIC);

mapper.setConstructorDetector(customDetector);

// Example POJOs that work with different strategies
public class ExplicitPerson {
    private String name;
    private int age;
    
    // Requires @JsonCreator when using requireCtorAnnotation()
    @JsonCreator
    public ExplicitPerson(@JsonProperty("name") String name, @JsonProperty("age") int age) {
        this.name = name;
        this.age = age;
    }
    
    // getters/setters
}

public class PropertiesPerson {
    private String name;
    private int age;
    
    // No annotations needed when using useProperties()
    public PropertiesPerson(String name, int age) {
        this.name = name; 
        this.age = age;
    }
    
    // getters/setters
}

Coercion Configuration

import com.fasterxml.jackson.databind.cfg.CoercionAction;
import com.fasterxml.jackson.databind.cfg.CoercionInputShape;
import com.fasterxml.jackson.databind.type.LogicalType;

ObjectMapper mapper = new ObjectMapper();

// Configure default coercion behavior
mapper.coercionConfigDefaults()
    .setCoercion(CoercionInputShape.String, CoercionAction.TryConvert)
    .setCoercion(CoercionInputShape.Integer, CoercionAction.TryConvert)
    .setAcceptBlankAsEmpty(Boolean.TRUE);

// Configure coercion for specific logical types
mapper.coercionConfigFor(LogicalType.Boolean)
    .setCoercion(CoercionInputShape.String, CoercionAction.TryConvert);

mapper.coercionConfigFor(LogicalType.Integer)
    .setCoercion(CoercionInputShape.Float, CoercionAction.TryConvert)
    .setCoercion(CoercionInputShape.String, CoercionAction.Fail);

// Configure coercion for specific Java types
mapper.coercionConfigFor(LocalDate.class)
    .setCoercion(CoercionInputShape.String, CoercionAction.TryConvert)
    .setAcceptBlankAsEmpty(Boolean.FALSE);

// Test coercion behavior
String json = """
{
  "active": "true",
  "count": "123", 
  "rate": 45.67,
  "date": "2024-01-15"
}
""";

// This will succeed with coercion enabled
DataRecord record = mapper.readValue(json, DataRecord.class);

public class DataRecord {
    public boolean active;  // "true" -> true
    public int count;       // "123" -> 123  
    public int rate;        // 45.67 -> 45 (if coercion enabled)
    public LocalDate date;  // "2024-01-15" -> LocalDate (if coercion enabled)
}

Advanced Configuration with Builder

import com.fasterxml.jackson.databind.json.JsonMapper;

// Using JsonMapper builder for comprehensive configuration
JsonMapper mapper = JsonMapper.builder()
    // Features
    .enable(SerializationFeature.INDENT_OUTPUT)
    .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
    .enable(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES)
    
    // Date handling
    .defaultDateFormat(new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"))
    .defaultTimeZone(TimeZone.getTimeZone("UTC"))
    .defaultLocale(Locale.US)
    
    // Property inclusion
    .serializationInclusion(JsonInclude.Include.NON_NULL)
    
    // Property naming
    .propertyNamingStrategy(PropertyNamingStrategies.SNAKE_CASE)
    
    // Visibility
    .visibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.NONE)
    .visibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY)
    
    // Constructor detection
    .constructorDetector(ConstructorDetector.useProperties())
    
    // Polymorphic type validation
    .polymorphicTypeValidator(BasicPolymorphicTypeValidator.builder()
        .allowIfSubType("com.example.model")
        .build())
    
    // Build the mapper
    .build();

// Additional configuration after building
mapper.registerModule(new JavaTimeModule());
mapper.addMixIn(ThirdPartyClass.class, ThirdPartyMixin.class);

// Type-specific overrides
mapper.configOverride(BigDecimal.class)
    .setFormat(JsonFormat.Value.forShape(JsonFormat.Shape.STRING));

Custom Configuration Classes

// Custom configuration holder
public class JsonConfiguration {
    private final ObjectMapper mapper;
    
    public JsonConfiguration() {
        this.mapper = createConfiguredMapper();
    }
    
    private ObjectMapper createConfiguredMapper() {
        ObjectMapper mapper = new ObjectMapper();
        
        // Standard configuration
        configureFeatures(mapper);
        configureFormatting(mapper);
        configureCoercion(mapper);
        configureOverrides(mapper);
        
        return mapper;
    }
    
    private void configureFeatures(ObjectMapper mapper) {
        // Serialization
        mapper.enable(SerializationFeature.INDENT_OUTPUT);
        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
        
        // Deserialization  
        mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
        mapper.enable(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT);
        
        // Mapper
        mapper.enable(MapperFeature.ACCEPT_CASE_INSENSITIVE_PROPERTIES);
        mapper.disable(MapperFeature.AUTO_DETECT_CREATORS);
    }
    
    private void configureFormatting(ObjectMapper mapper) {
        mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"));
        mapper.setTimeZone(TimeZone.getTimeZone("UTC"));
        mapper.setPropertyNamingStrategy(PropertyNamingStrategies.LOWER_CAMEL_CASE);
    }
    
    private void configureCoercion(ObjectMapper mapper) {
        mapper.coercionConfigDefaults()
            .setAcceptBlankAsEmpty(Boolean.TRUE);
            
        mapper.coercionConfigFor(LogicalType.Boolean)
            .setCoercion(CoercionInputShape.String, CoercionAction.TryConvert);
    }
    
    private void configureOverrides(ObjectMapper mapper) {
        // Date formatting override
        mapper.configOverride(Date.class)
            .setFormat(JsonFormat.Value.forPattern("yyyy-MM-dd"));
            
        // Inclusion override for Optional types
        mapper.configOverride(Optional.class)
            .setInclude(JsonInclude.Value.construct(JsonInclude.Include.NON_ABSENT, null));
    }
    
    public ObjectMapper getMapper() {
        return mapper;
    }
    
    // Environment-specific configurations
    public static JsonConfiguration forProduction() {
        JsonConfiguration config = new JsonConfiguration();
        config.mapper.disable(SerializationFeature.INDENT_OUTPUT); // Compact output
        config.mapper.enable(SerializationFeature.FAIL_ON_EMPTY_BEANS); // Strict validation
        return config;
    }
    
    public static JsonConfiguration forDevelopment() {
        JsonConfiguration config = new JsonConfiguration();
        config.mapper.enable(SerializationFeature.INDENT_OUTPUT); // Pretty printing
        config.mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES); // Lenient
        return config;
    }
}

Types

// Configuration feature interface
public interface ConfigFeature {
    boolean enabledByDefault();
    int getMask();
    boolean enabledIn(int flags);
}

// Factory configuration classes
public final class SerializerFactoryConfig implements Serializable {
    public SerializerFactoryConfig withAdditionalSerializers(Serializers additional);
    public SerializerFactoryConfig withAdditionalKeySerializers(Serializers additional);
    public SerializerFactoryConfig withSerializerModifier(BeanSerializerModifier modifier);
    public SerializerFactoryConfig withFilters(FilterProvider filterProvider);
    public boolean hasSerializers();
    public boolean hasKeySerializers();
    public boolean hasSerializerModifiers();
    public Iterable<Serializers> serializers();
    public Iterable<Serializers> keySerializers();
    public Iterable<BeanSerializerModifier> serializerModifiers();
    public FilterProvider filterProvider();
}

public class DeserializerFactoryConfig implements Serializable {
    public DeserializerFactoryConfig withAdditionalDeserializers(Deserializers additional);
    public DeserializerFactoryConfig withAdditionalKeyDeserializers(KeyDeserializers additional);
    public DeserializerFactoryConfig withDeserializerModifier(BeanDeserializerModifier modifier);
    public DeserializerFactoryConfig withAbstractTypeResolver(AbstractTypeResolver resolver);
    public DeserializerFactoryConfig withValueInstantiators(ValueInstantiators instantiators);
    public boolean hasDeserializers();
    public boolean hasKeyDeserializers();
    public boolean hasDeserializerModifiers();
    public boolean hasAbstractTypeResolvers();
    public boolean hasValueInstantiators();
    public Iterable<Deserializers> deserializers();
    public Iterable<KeyDeserializers> keyDeserializers();
    public Iterable<BeanDeserializerModifier> deserializerModifiers();
    public Iterable<AbstractTypeResolver> abstractTypeResolvers();
    public Iterable<ValueInstantiators> valueInstantiators();
}

// Datatype feature interface for specialized features
public interface DatatypeFeature extends JacksonFeature {
    boolean enabledByDefault();
    int getMask();
    boolean enabledIn(int flags);
}

// Container for datatype features
public class DatatypeFeatures {
    public static DatatypeFeatures defaultFeatures();
    public boolean isEnabled(DatatypeFeature feature);
    public DatatypeFeatures with(DatatypeFeature feature);
    public DatatypeFeatures without(DatatypeFeature feature);
    public DatatypeFeatures withFeatures(DatatypeFeature... features);
    public DatatypeFeatures withoutFeatures(DatatypeFeature... features);
}

// Enum and JsonNode features  
public enum EnumFeature implements DatatypeFeature {
    READ_ENUM_KEYS_USING_INDEX(false),
    WRITE_ENUM_KEYS_USING_INDEX(false);
}

public enum JsonNodeFeature implements DatatypeFeature {
    READ_NULL_PROPERTIES(false),
    WRITE_NULL_PROPERTIES(true);
}

Install with Tessl CLI

npx tessl i tessl/maven-com-fasterxml-jackson-core--jackson-databind

docs

advanced-features.md

annotations.md

configuration.md

deserialization.md

index.md

json-tree-model.md

modules.md

object-mapping.md

serialization.md

type-system.md

tile.json