| Package | Description |
|---|---|
| com.fasterxml.jackson.databind |
Basic data binding (mapping) functionality that
allows for reading JSON content into Java Objects (POJOs)
and JSON Trees (
JsonNode), as well as
writing Java Objects and trees as JSON. |
| com.fasterxml.jackson.databind.cfg |
Package that contains most of configuration-related classes;
exception being couple of most-commonly used configuration
things (like Feature enumerations) that are at the
main level (
com.fasterxml.jackson.databind). |
| com.fasterxml.jackson.databind.deser.impl |
Contains those implementation classes of deserialization part of
data binding that are not considered part of public or semi-public
interfaces.
|
| com.fasterxml.jackson.databind.introspect |
Functionality needed for Bean introspection, required for detecting
accessors and mutators for Beans, as well as locating and handling
method annotations.
|
| com.fasterxml.jackson.databind.jsontype |
Package that contains interfaces that define how to implement
functionality for dynamically resolving type during deserialization.
|
| com.fasterxml.jackson.databind.jsontype.impl |
Package that contains standard implementations for
TypeResolverBuilder
and
TypeIdResolver. |
| com.fasterxml.jackson.databind.ser |
Contains implementation classes of serialization part of
data binding.
|
| com.fasterxml.jackson.databind.ser.impl |
Contains implementation classes of serialization part of
data binding.
|
| com.fasterxml.jackson.databind.util |
Utility classes for Mapper package.
|
| Modifier and Type | Class and Description |
|---|---|
class |
DeserializationConfig
Object that contains baseline configuration for deserialization
process.
|
class |
SerializationConfig
Object that contains baseline configuration for serialization
process.
|
| Modifier and Type | Method and Description |
|---|---|
abstract MapperConfig<?> |
DatabindContext.getConfig()
Accessor to currently active configuration (both per-request configs
and per-mapper config).
|
| Modifier and Type | Method and Description |
|---|---|
List<PropertyName> |
BeanProperty.findAliases(MapperConfig<?> config)
Method for accessing set of possible alternate names that are accepted
during deserialization.
|
List<PropertyName> |
BeanProperty.Std.findAliases(MapperConfig<?> config) |
List<PropertyName> |
BeanProperty.Bogus.findAliases(MapperConfig<?> config) |
void |
AnnotationIntrospector.findAndAddVirtualProperties(MapperConfig<?> config,
AnnotatedClass ac,
List<BeanPropertyWriter> properties)
Method for adding possible virtual properties to be serialized along
with regular properties.
|
JsonCreator.Mode |
AnnotationIntrospector.findCreatorAnnotation(MapperConfig<?> config,
Annotated ann)
Method called to check whether potential Creator (constructor or static factory
method) has explicit annotation to indicate it as actual Creator; and if so,
which
JsonCreator.Mode to use. |
String |
AnnotationIntrospector.XmlExtensions.findNamespace(MapperConfig<?> config,
Annotated ann)
Method that can be called to figure out generic namespace
property for an annotated object.
|
TypeResolverBuilder<?> |
AnnotationIntrospector.findPropertyContentTypeResolver(MapperConfig<?> config,
AnnotatedMember am,
JavaType containerType)
Method for checking if given structured property entity (field or method that
has nominal value of Map, Collection or array type) has annotations
that indicate that specific type resolver is to be used for handling type
information of contained values.
|
JsonFormat.Value |
BeanProperty.findPropertyFormat(MapperConfig<?> config,
Class<?> baseType)
Helper method used to look up format settings applicable to this property,
considering both possible per-type configuration settings
|
JsonFormat.Value |
BeanProperty.Std.findPropertyFormat(MapperConfig<?> config,
Class<?> baseType) |
JsonFormat.Value |
BeanProperty.Bogus.findPropertyFormat(MapperConfig<?> config,
Class<?> baseType) |
JsonIgnoreProperties.Value |
AnnotationIntrospector.findPropertyIgnoralByName(MapperConfig<?> config,
Annotated ann)
Method for finding information about properties to ignore either by
name, or by more general specification ("ignore all unknown").
|
JsonInclude.Value |
BeanProperty.findPropertyInclusion(MapperConfig<?> config,
Class<?> baseType)
Convenience method that is roughly equivalent to
|
JsonInclude.Value |
BeanProperty.Std.findPropertyInclusion(MapperConfig<?> config,
Class<?> baseType) |
JsonInclude.Value |
BeanProperty.Bogus.findPropertyInclusion(MapperConfig<?> config,
Class<?> baseType) |
JsonIncludeProperties.Value |
AnnotationIntrospector.findPropertyInclusionByName(MapperConfig<?> config,
Annotated ann)
Method for finding information about names of properties to included.
|
TypeResolverBuilder<?> |
AnnotationIntrospector.findPropertyTypeResolver(MapperConfig<?> config,
AnnotatedMember am,
JavaType baseType)
Method for checking if given property entity (field or method) has annotations
that indicate that specific type resolver is to be used for handling instances.
|
PropertyName |
AnnotationIntrospector.findRenameByField(MapperConfig<?> config,
AnnotatedField f,
PropertyName implName)
Method called on fields that are eligible candidates for properties
(that is, non-static member fields), but not necessarily selected (may
or may not be visible), to let fields affect name linking.
|
TypeResolverBuilder<?> |
AnnotationIntrospector.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType)
Method for checking if given class has annotations that indicate
that specific type resolver is to be used for handling instances.
|
Boolean |
AnnotationIntrospector.hasAsKey(MapperConfig<?> config,
Annotated a)
Method for checking whether given method has an annotation
that suggests the return value of annotated field or method
should be used as "the key" of the object instance; usually
serialized as a primitive value such as String or number.
|
Boolean |
AnnotationIntrospector.XmlExtensions.isOutputAsAttribute(MapperConfig<?> config,
Annotated ann)
Method used to check whether given annotated element
(field, method, constructor parameter) has indicator that suggests
it be output as an XML attribute or not (if not, then as element)
|
Boolean |
AnnotationIntrospector.XmlExtensions.isOutputAsCData(MapperConfig<?> config,
Annotated ann)
Method used to check whether given annotated element
(field, method, constructor parameter) has indicator that suggests
it should be wrapped in a CDATA tag.
|
Boolean |
AnnotationIntrospector.XmlExtensions.isOutputAsText(MapperConfig<?> config,
Annotated ann)
Method used to check whether given annotated element
(field, method, constructor parameter) has indicator that suggests
it should be serialized as text, without element wrapper.
|
String |
PropertyNamingStrategy.nameForConstructorParameter(MapperConfig<?> config,
AnnotatedParameter ctorParam,
String defaultName)
Method called to find external name (name used in JSON) for given logical
POJO property,
as defined by given constructor parameter; typically called when building a deserializer
(but not necessarily only then).
|
String |
PropertyNamingStrategy.PropertyNamingStrategyBase.nameForConstructorParameter(MapperConfig<?> config,
AnnotatedParameter ctorParam,
String defaultName)
Deprecated.
|
String |
PropertyNamingStrategies.NamingBase.nameForConstructorParameter(MapperConfig<?> config,
AnnotatedParameter ctorParam,
String defaultName) |
String |
PropertyNamingStrategy.nameForField(MapperConfig<?> config,
AnnotatedField field,
String defaultName)
Method called to find external name (name used in JSON) for given logical
POJO property,
as defined by given field.
|
String |
PropertyNamingStrategy.PropertyNamingStrategyBase.nameForField(MapperConfig<?> config,
AnnotatedField field,
String defaultName)
Deprecated.
|
String |
PropertyNamingStrategies.NamingBase.nameForField(MapperConfig<?> config,
AnnotatedField field,
String defaultName) |
String |
PropertyNamingStrategy.nameForGetterMethod(MapperConfig<?> config,
AnnotatedMethod method,
String defaultName)
Method called to find external name (name used in JSON) for given logical
POJO property,
as defined by given getter method; typically called when building a serializer.
|
String |
PropertyNamingStrategy.PropertyNamingStrategyBase.nameForGetterMethod(MapperConfig<?> config,
AnnotatedMethod method,
String defaultName)
Deprecated.
|
String |
PropertyNamingStrategies.NamingBase.nameForGetterMethod(MapperConfig<?> config,
AnnotatedMethod method,
String defaultName) |
String |
PropertyNamingStrategy.nameForSetterMethod(MapperConfig<?> config,
AnnotatedMethod method,
String defaultName)
Method called to find external name (name used in JSON) for given logical
POJO property,
as defined by given setter method; typically called when building a deserializer
(but not necessarily only then).
|
String |
PropertyNamingStrategy.PropertyNamingStrategyBase.nameForSetterMethod(MapperConfig<?> config,
AnnotatedMethod method,
String defaultName)
Deprecated.
|
String |
PropertyNamingStrategies.NamingBase.nameForSetterMethod(MapperConfig<?> config,
AnnotatedMethod method,
String defaultName) |
JavaType |
AnnotationIntrospector.refineDeserializationType(MapperConfig<?> config,
Annotated a,
JavaType baseType)
Method called to find out possible type refinements to use
for deserialization.
|
JavaType |
AnnotationIntrospector.refineSerializationType(MapperConfig<?> config,
Annotated a,
JavaType baseType)
Method called to find out possible type refinements to use
for deserialization, including not just value itself but
key and/or content type, if type has those.
|
AnnotatedMethod |
AnnotationIntrospector.resolveSetterConflict(MapperConfig<?> config,
AnnotatedMethod setter1,
AnnotatedMethod setter2)
Method called in cases where a class has two methods eligible to be used
for the same logical property, and default logic is not enough to figure
out clear precedence.
|
SerializableString |
PropertyName.simpleAsEncoded(MapperConfig<?> config)
Accessor that may be used to get lazily-constructed efficient
representation of the simple name.
|
PolymorphicTypeValidator |
ObjectMapper.DefaultTypeResolverBuilder.subTypeValidator(MapperConfig<?> config) |
| Modifier and Type | Class and Description |
|---|---|
class |
MapperConfig<T extends MapperConfig<T>>
Interface that defines functionality accessible through both
serialization and deserialization configuration objects;
accessors to mode-independent configuration settings
and such.
|
| Modifier and Type | Class and Description |
|---|---|
class |
MapperConfigBase<CFG extends ConfigFeature,T extends MapperConfigBase<CFG,T>> |
| Modifier and Type | Method and Description |
|---|---|
Converter<?,?> |
HandlerInstantiator.converterInstance(MapperConfig<?> config,
Annotated annotated,
Class<?> implClass)
Method called to construct a Converter instance used for specified class.
|
PropertyNamingStrategy |
HandlerInstantiator.namingStrategyInstance(MapperConfig<?> config,
Annotated annotated,
Class<?> implClass)
Method called to construct a NamingStrategy instance used for specified
class.
|
ObjectIdGenerator<?> |
HandlerInstantiator.objectIdGeneratorInstance(MapperConfig<?> config,
Annotated annotated,
Class<?> implClass)
Method called to construct a ObjectIdHandler instance of specified type.
|
ObjectIdResolver |
HandlerInstantiator.resolverIdGeneratorInstance(MapperConfig<?> config,
Annotated annotated,
Class<?> implClass) |
abstract TypeIdResolver |
HandlerInstantiator.typeIdResolverInstance(MapperConfig<?> config,
Annotated annotated,
Class<?> resolverClass)
Method called to get an instance of TypeIdResolver of specified type.
|
abstract TypeResolverBuilder<?> |
HandlerInstantiator.typeResolverBuilderInstance(MapperConfig<?> config,
Annotated annotated,
Class<?> builderClass)
Method called to get an instance of TypeResolverBuilder of specified type.
|
ValueInstantiator |
HandlerInstantiator.valueInstantiatorInstance(MapperConfig<?> config,
Annotated annotated,
Class<?> resolverClass)
Method called to construct an instance of ValueInstantiator of specified type.
|
VirtualBeanPropertyWriter |
HandlerInstantiator.virtualPropertyWriterInstance(MapperConfig<?> config,
Class<?> implClass)
Method called to construct a
VirtualBeanPropertyWriter instance
of specified type. |
| Constructor and Description |
|---|
MapperConfig(MapperConfig<T> src) |
MapperConfig(MapperConfig<T> src,
BaseSettings base) |
MapperConfig(MapperConfig<T> src,
long mapperFeatures) |
| Modifier and Type | Method and Description |
|---|---|
static BeanPropertyMap |
BeanPropertyMap.construct(MapperConfig<?> config,
Collection<SettableBeanProperty> props,
Map<String,List<PropertyName>> aliasMapping)
Deprecated.
since 2.12
|
static BeanPropertyMap |
BeanPropertyMap.construct(MapperConfig<?> config,
Collection<SettableBeanProperty> props,
Map<String,List<PropertyName>> aliasMapping,
boolean caseInsensitive) |
| Constructor and Description |
|---|
CreatorCollector(BeanDescription beanDesc,
MapperConfig<?> config) |
| Modifier and Type | Field and Description |
|---|---|
protected MapperConfig<?> |
POJOPropertiesCollector._config
Configuration settings
|
protected MapperConfig<?> |
POJOPropertyBuilder._config |
protected MapperConfig<?> |
BasicBeanDescription._config |
protected MapperConfig<?> |
DefaultAccessorNamingStrategy._config |
| Modifier and Type | Method and Description |
|---|---|
MapperConfig<?> |
POJOPropertiesCollector.getConfig() |
| Modifier and Type | Method and Description |
|---|---|
protected BeanPropertyWriter |
JacksonAnnotationIntrospector._constructVirtualProperty(JsonAppend.Attr attr,
MapperConfig<?> config,
AnnotatedClass ac,
JavaType type) |
protected BeanPropertyWriter |
JacksonAnnotationIntrospector._constructVirtualProperty(JsonAppend.Prop prop,
MapperConfig<?> config,
AnnotatedClass ac) |
protected BasicBeanDescription |
BasicClassIntrospector._findStdJdkCollectionDesc(MapperConfig<?> cfg,
JavaType type) |
protected BasicBeanDescription |
BasicClassIntrospector._findStdTypeDesc(MapperConfig<?> config,
JavaType type)
Method called to see if type is one of core JDK types
that we have cached for efficiency.
|
protected TypeResolverBuilder<?> |
JacksonAnnotationIntrospector._findTypeResolver(MapperConfig<?> config,
Annotated ann,
JavaType baseType)
Helper method called to construct and initialize instance of
TypeResolverBuilder
if given annotated element indicates one is needed. |
protected AnnotatedClass |
BasicClassIntrospector._resolveAnnotatedClass(MapperConfig<?> config,
JavaType type,
ClassIntrospector.MixInResolver r) |
protected AnnotatedClass |
BasicClassIntrospector._resolveAnnotatedWithoutSuperTypes(MapperConfig<?> config,
JavaType type,
ClassIntrospector.MixInResolver r) |
protected POJOPropertiesCollector |
BasicClassIntrospector.collectProperties(MapperConfig<?> config,
JavaType type,
ClassIntrospector.MixInResolver r,
boolean forSerialization) |
protected POJOPropertiesCollector |
BasicClassIntrospector.collectProperties(MapperConfig<?> config,
JavaType type,
ClassIntrospector.MixInResolver r,
boolean forSerialization,
String mutatorPrefix)
Deprecated.
|
protected POJOPropertiesCollector |
BasicClassIntrospector.collectPropertiesWithBuilder(MapperConfig<?> config,
JavaType type,
ClassIntrospector.MixInResolver r,
BeanDescription valueTypeDesc,
boolean forSerialization) |
protected POJOPropertiesCollector |
BasicClassIntrospector.collectPropertiesWithBuilder(MapperConfig<?> config,
JavaType type,
ClassIntrospector.MixInResolver r,
boolean forSerialization)
Deprecated.
|
static AnnotatedClass |
AnnotatedClass.construct(JavaType type,
MapperConfig<?> config)
Deprecated.
Since 2.9, use methods in
AnnotatedClassResolver instead. |
static AnnotatedClass |
AnnotatedClass.construct(JavaType type,
MapperConfig<?> config,
ClassIntrospector.MixInResolver mir)
Deprecated.
Since 2.9, use methods in
AnnotatedClassResolver instead. |
protected POJOPropertiesCollector |
BasicClassIntrospector.constructPropertyCollector(MapperConfig<?> config,
AnnotatedClass classDef,
JavaType type,
boolean forSerialization,
AccessorNamingStrategy accNaming)
Overridable method called for creating
POJOPropertiesCollector instance
to use; override is needed if a custom sub-class is to be used. |
protected POJOPropertiesCollector |
BasicClassIntrospector.constructPropertyCollector(MapperConfig<?> config,
AnnotatedClass ac,
JavaType type,
boolean forSerialization,
String mutatorPrefix)
Deprecated.
|
static AnnotatedClass |
AnnotatedClass.constructWithoutSuperTypes(Class<?> raw,
MapperConfig<?> config)
Deprecated.
Since 2.9, use methods in
AnnotatedClassResolver instead. |
static AnnotatedClass |
AnnotatedClass.constructWithoutSuperTypes(Class<?> raw,
MapperConfig<?> config,
ClassIntrospector.MixInResolver mir)
Deprecated.
Since 2.9, use methods in
AnnotatedClassResolver instead. |
List<PropertyName> |
ConcreteBeanPropertyBase.findAliases(MapperConfig<?> config) |
void |
JacksonAnnotationIntrospector.findAndAddVirtualProperties(MapperConfig<?> config,
AnnotatedClass ac,
List<BeanPropertyWriter> properties) |
void |
AnnotationIntrospectorPair.findAndAddVirtualProperties(MapperConfig<?> config,
AnnotatedClass ac,
List<BeanPropertyWriter> properties) |
JsonCreator.Mode |
JacksonAnnotationIntrospector.findCreatorAnnotation(MapperConfig<?> config,
Annotated a) |
JsonCreator.Mode |
AnnotationIntrospectorPair.findCreatorAnnotation(MapperConfig<?> config,
Annotated a) |
TypeResolverBuilder<?> |
JacksonAnnotationIntrospector.findPropertyContentTypeResolver(MapperConfig<?> config,
AnnotatedMember am,
JavaType containerType) |
TypeResolverBuilder<?> |
AnnotationIntrospectorPair.findPropertyContentTypeResolver(MapperConfig<?> config,
AnnotatedMember am,
JavaType baseType) |
JsonFormat.Value |
ConcreteBeanPropertyBase.findPropertyFormat(MapperConfig<?> config,
Class<?> baseType) |
JsonIgnoreProperties.Value |
JacksonAnnotationIntrospector.findPropertyIgnoralByName(MapperConfig<?> config,
Annotated a) |
JsonIgnoreProperties.Value |
AnnotationIntrospectorPair.findPropertyIgnoralByName(MapperConfig<?> config,
Annotated ann) |
JsonInclude.Value |
ConcreteBeanPropertyBase.findPropertyInclusion(MapperConfig<?> config,
Class<?> baseType) |
JsonIncludeProperties.Value |
JacksonAnnotationIntrospector.findPropertyInclusionByName(MapperConfig<?> config,
Annotated a) |
JsonIncludeProperties.Value |
AnnotationIntrospectorPair.findPropertyInclusionByName(MapperConfig<?> config,
Annotated a) |
TypeResolverBuilder<?> |
JacksonAnnotationIntrospector.findPropertyTypeResolver(MapperConfig<?> config,
AnnotatedMember am,
JavaType baseType) |
TypeResolverBuilder<?> |
AnnotationIntrospectorPair.findPropertyTypeResolver(MapperConfig<?> config,
AnnotatedMember am,
JavaType baseType) |
PropertyName |
JacksonAnnotationIntrospector.findRenameByField(MapperConfig<?> config,
AnnotatedField f,
PropertyName implName) |
PropertyName |
AnnotationIntrospectorPair.findRenameByField(MapperConfig<?> config,
AnnotatedField f,
PropertyName implName) |
TypeResolverBuilder<?> |
JacksonAnnotationIntrospector.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType) |
TypeResolverBuilder<?> |
AnnotationIntrospectorPair.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType) |
abstract AccessorNamingStrategy |
AccessorNamingStrategy.Provider.forBuilder(MapperConfig<?> config,
AnnotatedClass builderClass,
BeanDescription valueTypeDesc)
Factory method for creating strategy instance for POJOs
that are deserialized using Builder type: in this case eventual
target (value) type is different from type of "builder" object that is
used by databinding to accumulate state.
|
AccessorNamingStrategy |
DefaultAccessorNamingStrategy.Provider.forBuilder(MapperConfig<?> config,
AnnotatedClass builderClass,
BeanDescription valueTypeDesc) |
BasicBeanDescription |
BasicClassIntrospector.forClassAnnotations(MapperConfig<?> config,
JavaType type,
ClassIntrospector.MixInResolver r) |
abstract BeanDescription |
ClassIntrospector.forClassAnnotations(MapperConfig<?> cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
Factory method that constructs an introspector that only has
information regarding annotations class itself (or its supertypes) has,
but nothing on methods or constructors.
|
BasicBeanDescription |
BasicClassIntrospector.forDirectClassAnnotations(MapperConfig<?> config,
JavaType type,
ClassIntrospector.MixInResolver r) |
abstract BeanDescription |
ClassIntrospector.forDirectClassAnnotations(MapperConfig<?> cfg,
JavaType type,
ClassIntrospector.MixInResolver r)
Factory method that constructs an introspector that only has
information regarding annotations class itself has (but NOT including
its supertypes), but nothing on methods or constructors.
|
static BasicBeanDescription |
BasicBeanDescription.forOtherUse(MapperConfig<?> config,
JavaType type,
AnnotatedClass ac)
Factory method to use for constructing an instance to use for purposes
other than building serializers or deserializers; will only have information
on class, not on properties.
|
abstract AccessorNamingStrategy |
AccessorNamingStrategy.Provider.forPOJO(MapperConfig<?> config,
AnnotatedClass valueClass)
Factory method for creating strategy instance for a "regular" POJO,
called if none of the other factory methods is applicable.
|
AccessorNamingStrategy |
DefaultAccessorNamingStrategy.Provider.forPOJO(MapperConfig<?> config,
AnnotatedClass targetClass) |
abstract AccessorNamingStrategy |
AccessorNamingStrategy.Provider.forRecord(MapperConfig<?> config,
AnnotatedClass recordClass)
Factory method for creating strategy instance for special
java.lang.Record
type (new in JDK 14). |
AccessorNamingStrategy |
DefaultAccessorNamingStrategy.Provider.forRecord(MapperConfig<?> config,
AnnotatedClass recordClass) |
Boolean |
JacksonAnnotationIntrospector.hasAsKey(MapperConfig<?> config,
Annotated a) |
Boolean |
AnnotationIntrospectorPair.hasAsKey(MapperConfig<?> config,
Annotated a) |
JavaType |
JacksonAnnotationIntrospector.refineDeserializationType(MapperConfig<?> config,
Annotated a,
JavaType baseType) |
JavaType |
AnnotationIntrospectorPair.refineDeserializationType(MapperConfig<?> config,
Annotated a,
JavaType baseType) |
JavaType |
JacksonAnnotationIntrospector.refineSerializationType(MapperConfig<?> config,
Annotated a,
JavaType baseType) |
JavaType |
AnnotationIntrospectorPair.refineSerializationType(MapperConfig<?> config,
Annotated a,
JavaType baseType) |
static AnnotatedClass |
AnnotatedClassResolver.resolve(MapperConfig<?> config,
JavaType forType,
ClassIntrospector.MixInResolver r) |
AnnotatedMethod |
JacksonAnnotationIntrospector.resolveSetterConflict(MapperConfig<?> config,
AnnotatedMethod setter1,
AnnotatedMethod setter2)
Specific implementation that will use following tie-breaker on
given setter parameter types:
If either one is primitive type then either return
null
(both primitives) or one that is primitive (when only primitive)
If only one is of type String, return that setter
Otherwise return null
Returning null will indicate that resolution could not be done. |
AnnotatedMethod |
AnnotationIntrospectorPair.resolveSetterConflict(MapperConfig<?> config,
AnnotatedMethod setter1,
AnnotatedMethod setter2) |
static AnnotatedClass |
AnnotatedClassResolver.resolveWithoutSuperTypes(MapperConfig<?> config,
Class<?> forType) |
static AnnotatedClass |
AnnotatedClassResolver.resolveWithoutSuperTypes(MapperConfig<?> config,
Class<?> forType,
ClassIntrospector.MixInResolver r) |
static AnnotatedClass |
AnnotatedClassResolver.resolveWithoutSuperTypes(MapperConfig<?> config,
JavaType forType,
ClassIntrospector.MixInResolver r) |
| Constructor and Description |
|---|
BasicBeanDescription(MapperConfig<?> config,
JavaType type,
AnnotatedClass classDef,
List<BeanPropertyDefinition> props)
Alternate constructor used in cases where property information is not needed,
only class info.
|
DefaultAccessorNamingStrategy(MapperConfig<?> config,
AnnotatedClass forClass,
String mutatorPrefix,
String getterPrefix,
String isGetterPrefix,
DefaultAccessorNamingStrategy.BaseNameValidator baseNameValidator) |
POJOPropertiesCollector(MapperConfig<?> config,
boolean forSerialization,
JavaType type,
AnnotatedClass classDef,
AccessorNamingStrategy accessorNaming) |
POJOPropertiesCollector(MapperConfig<?> config,
boolean forSerialization,
JavaType type,
AnnotatedClass classDef,
String mutatorPrefix)
Deprecated.
Since 2.12
|
POJOPropertyBuilder(MapperConfig<?> config,
AnnotationIntrospector ai,
boolean forSerialization,
PropertyName internalName) |
POJOPropertyBuilder(MapperConfig<?> config,
AnnotationIntrospector ai,
boolean forSerialization,
PropertyName internalName,
PropertyName name) |
RecordNaming(MapperConfig<?> config,
AnnotatedClass forClass) |
| Modifier and Type | Method and Description |
|---|---|
Collection<NamedType> |
SubtypeResolver.collectAndResolveSubtypes(AnnotatedClass baseType,
MapperConfig<?> config,
AnnotationIntrospector ai)
Deprecated.
|
Collection<NamedType> |
SubtypeResolver.collectAndResolveSubtypes(AnnotatedMember property,
MapperConfig<?> config,
AnnotationIntrospector ai,
JavaType baseType)
Deprecated.
|
Collection<NamedType> |
SubtypeResolver.collectAndResolveSubtypesByClass(MapperConfig<?> config,
AnnotatedClass baseType)
Method for finding out all reachable subtypes for given type,
such that access is by type,
typically needed for serialization (converting from type to type name).
|
Collection<NamedType> |
SubtypeResolver.collectAndResolveSubtypesByClass(MapperConfig<?> config,
AnnotatedMember property,
JavaType baseType)
Method for finding out all reachable subtypes for a property specified
by given element (method or field),
such that access is by type,
typically needed for serialization (converting from type to type name).
|
Collection<NamedType> |
SubtypeResolver.collectAndResolveSubtypesByTypeId(MapperConfig<?> config,
AnnotatedClass baseType)
Method for finding out all reachable subtypes for given type,
such that access is by type id,
typically needed for deserialization (converting from type id to type).
|
Collection<NamedType> |
SubtypeResolver.collectAndResolveSubtypesByTypeId(MapperConfig<?> config,
AnnotatedMember property,
JavaType baseType)
Method for finding out all reachable subtypes for a property specified
by given element (method or field),
such that access is by type id,
typically needed for deserialization (converting from type id to type).
|
protected boolean |
DefaultBaseTypeLimitingValidator.isSafeSubType(MapperConfig<?> config,
JavaType baseType,
JavaType subType)
Helper called to determine whether given actual subtype is considered safe
to process: this will only be called if subtype was considered acceptable
earlier.
|
protected boolean |
DefaultBaseTypeLimitingValidator.isUnsafeBaseType(MapperConfig<?> config,
JavaType baseType)
Helper method called to determine if the given base type is known to be
problematic regarding possible "gadget types".
|
abstract boolean |
BasicPolymorphicTypeValidator.TypeMatcher.match(MapperConfig<?> config,
Class<?> clazz) |
abstract boolean |
BasicPolymorphicTypeValidator.NameMatcher.match(MapperConfig<?> config,
String clazzName) |
PolymorphicTypeValidator.Validity |
BasicPolymorphicTypeValidator.validateBaseType(MapperConfig<?> ctxt,
JavaType baseType) |
PolymorphicTypeValidator.Validity |
DefaultBaseTypeLimitingValidator.validateBaseType(MapperConfig<?> config,
JavaType baseType) |
abstract PolymorphicTypeValidator.Validity |
PolymorphicTypeValidator.validateBaseType(MapperConfig<?> config,
JavaType baseType)
Method called when a property with polymorphic value is encountered, and a
TypeResolverBuilder is needed. |
PolymorphicTypeValidator.Validity |
PolymorphicTypeValidator.Base.validateBaseType(MapperConfig<?> config,
JavaType baseType) |
PolymorphicTypeValidator.Validity |
BasicPolymorphicTypeValidator.validateSubClassName(MapperConfig<?> ctxt,
JavaType baseType,
String subClassName) |
PolymorphicTypeValidator.Validity |
DefaultBaseTypeLimitingValidator.validateSubClassName(MapperConfig<?> config,
JavaType baseType,
String subClassName) |
abstract PolymorphicTypeValidator.Validity |
PolymorphicTypeValidator.validateSubClassName(MapperConfig<?> config,
JavaType baseType,
String subClassName)
|
PolymorphicTypeValidator.Validity |
PolymorphicTypeValidator.Base.validateSubClassName(MapperConfig<?> config,
JavaType baseType,
String subClassName) |
PolymorphicTypeValidator.Validity |
BasicPolymorphicTypeValidator.validateSubType(MapperConfig<?> ctxt,
JavaType baseType,
JavaType subType) |
PolymorphicTypeValidator.Validity |
DefaultBaseTypeLimitingValidator.validateSubType(MapperConfig<?> config,
JavaType baseType,
JavaType subType) |
abstract PolymorphicTypeValidator.Validity |
PolymorphicTypeValidator.validateSubType(MapperConfig<?> config,
JavaType baseType,
JavaType subType)
Method called after class name has been resolved to actual type, in cases where previous
call to
PolymorphicTypeValidator.validateSubClassName(com.fasterxml.jackson.databind.cfg.MapperConfig<?>, com.fasterxml.jackson.databind.JavaType, java.lang.String) returned PolymorphicTypeValidator.Validity.INDETERMINATE. |
PolymorphicTypeValidator.Validity |
PolymorphicTypeValidator.Base.validateSubType(MapperConfig<?> config,
JavaType baseType,
JavaType subType) |
| Modifier and Type | Field and Description |
|---|---|
protected MapperConfig<?> |
TypeNameIdResolver._config |
| Modifier and Type | Method and Description |
|---|---|
protected void |
StdSubtypeResolver._collectAndResolve(AnnotatedClass annotatedType,
NamedType namedType,
MapperConfig<?> config,
AnnotationIntrospector ai,
HashMap<NamedType,NamedType> collectedSubtypes)
Method called to find subtypes for a specific type (class), using
type (class) as the unique key (in case of conflicts).
|
protected void |
StdSubtypeResolver._collectAndResolveByTypeId(AnnotatedClass annotatedType,
NamedType namedType,
MapperConfig<?> config,
Set<Class<?>> typesHandled,
Map<String,NamedType> byName)
Method called to find subtypes for a specific type (class), using
type id as the unique key (in case of conflicts).
|
protected boolean |
StdTypeResolverBuilder.allowPrimitiveTypes(MapperConfig<?> config,
JavaType baseType)
Overridable helper method that is called to determine whether type serializers
and type deserializers may be created even if base type is Java
primitive
type. |
Collection<NamedType> |
StdSubtypeResolver.collectAndResolveSubtypesByClass(MapperConfig<?> config,
AnnotatedClass type) |
Collection<NamedType> |
StdSubtypeResolver.collectAndResolveSubtypesByClass(MapperConfig<?> config,
AnnotatedMember property,
JavaType baseType) |
Collection<NamedType> |
StdSubtypeResolver.collectAndResolveSubtypesByTypeId(MapperConfig<?> config,
AnnotatedClass baseType) |
Collection<NamedType> |
StdSubtypeResolver.collectAndResolveSubtypesByTypeId(MapperConfig<?> config,
AnnotatedMember property,
JavaType baseType) |
static ClassNameIdResolver |
ClassNameIdResolver.construct(JavaType baseType,
MapperConfig<?> config,
PolymorphicTypeValidator ptv) |
static MinimalClassNameIdResolver |
MinimalClassNameIdResolver.construct(JavaType baseType,
MapperConfig<?> config,
PolymorphicTypeValidator ptv) |
static TypeNameIdResolver |
TypeNameIdResolver.construct(MapperConfig<?> config,
JavaType baseType,
Collection<NamedType> subtypes,
boolean forSer,
boolean forDeser) |
protected TypeIdResolver |
StdTypeResolverBuilder.idResolver(MapperConfig<?> config,
JavaType baseType,
PolymorphicTypeValidator subtypeValidator,
Collection<NamedType> subtypes,
boolean forSer,
boolean forDeser)
Helper method that will either return configured custom
type id resolver, or construct a standard resolver
given configuration.
|
protected PolymorphicTypeValidator |
StdTypeResolverBuilder.reportInvalidBaseType(MapperConfig<?> config,
JavaType baseType,
PolymorphicTypeValidator ptv) |
PolymorphicTypeValidator |
StdTypeResolverBuilder.subTypeValidator(MapperConfig<?> config)
Overridable helper method for determining actual validator to use when constructing
type serializers and type deserializers.
|
PolymorphicTypeValidator.Validity |
LaissezFaireSubTypeValidator.validateBaseType(MapperConfig<?> ctxt,
JavaType baseType) |
PolymorphicTypeValidator.Validity |
LaissezFaireSubTypeValidator.validateSubClassName(MapperConfig<?> ctxt,
JavaType baseType,
String subClassName) |
PolymorphicTypeValidator.Validity |
LaissezFaireSubTypeValidator.validateSubType(MapperConfig<?> ctxt,
JavaType baseType,
JavaType subType) |
protected PolymorphicTypeValidator |
StdTypeResolverBuilder.verifyBaseTypeValidity(MapperConfig<?> config,
JavaType baseType)
Helper method called to check that base type is valid regarding possible constraints
on basetype/subtype combinations allowed for polymorphic type handling.
|
| Constructor and Description |
|---|
TypeNameIdResolver(MapperConfig<?> config,
JavaType baseType,
ConcurrentHashMap<String,String> typeToId,
HashMap<String,JavaType> idToType) |
| Modifier and Type | Method and Description |
|---|---|
abstract VirtualBeanPropertyWriter |
VirtualBeanPropertyWriter.withConfig(MapperConfig<?> config,
AnnotatedClass declaringClass,
BeanPropertyDefinition propDef,
JavaType type)
Contextualization method called on a newly constructed virtual bean property.
|
| Modifier and Type | Method and Description |
|---|---|
VirtualBeanPropertyWriter |
AttributePropertyWriter.withConfig(MapperConfig<?> config,
AnnotatedClass declaringClass,
BeanPropertyDefinition propDef,
JavaType type)
Since this method should typically not be called on this sub-type,
default implementation simply throws an
IllegalStateException. |
| Modifier and Type | Method and Description |
|---|---|
static SimpleBeanPropertyDefinition |
SimpleBeanPropertyDefinition.construct(MapperConfig<?> config,
AnnotatedMember member) |
static SimpleBeanPropertyDefinition |
SimpleBeanPropertyDefinition.construct(MapperConfig<?> config,
AnnotatedMember member,
PropertyName name) |
static SimpleBeanPropertyDefinition |
SimpleBeanPropertyDefinition.construct(MapperConfig<?> config,
AnnotatedMember member,
PropertyName name,
PropertyMetadata metadata,
JsonInclude.Include inclusion)
Method called to create instance for virtual properties.
|
static SimpleBeanPropertyDefinition |
SimpleBeanPropertyDefinition.construct(MapperConfig<?> config,
AnnotatedMember member,
PropertyName name,
PropertyMetadata metadata,
JsonInclude.Value inclusion) |
static EnumValues |
EnumValues.construct(MapperConfig<?> config,
Class<Enum<?>> enumClass,
List<String> externalValues) |
static EnumValues |
EnumValues.constructFromName(MapperConfig<?> config,
Class<Enum<?>> enumClass) |
static EnumValues |
EnumValues.constructFromToString(MapperConfig<?> config,
Class<Enum<?>> enumClass) |
PropertyName |
RootNameLookup.findRootName(Class<?> rootType,
MapperConfig<?> config) |
PropertyName |
RootNameLookup.findRootName(JavaType rootType,
MapperConfig<?> config) |
Copyright © 2008–2021 FasterXML. All rights reserved.