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.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.
|
Modifier and Type | Method and Description |
---|---|
abstract AnnotatedClass |
BeanDescription.getClassInfo()
Method for accessing low-level information about Class this
item describes.
|
Modifier and Type | Method and Description |
---|---|
void |
AnnotationIntrospector.findAndAddVirtualProperties(MapperConfig<?> config,
AnnotatedClass ac,
List<BeanPropertyWriter> properties)
Method for adding possible virtual properties to be serialized along
with regular properties.
|
VisibilityChecker<?> |
AnnotationIntrospector.findAutoDetectVisibility(AnnotatedClass ac,
VisibilityChecker<?> checker)
Method for checking if annotations indicate changes to minimum visibility levels
needed for auto-detecting property elements (fields, methods, constructors).
|
String |
AnnotationIntrospector.findClassDescription(AnnotatedClass ac)
Method used to check whether specified class defines a human-readable
description to use for documentation.
|
Boolean |
AnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac)
|
Object |
AnnotationIntrospector.findNamingStrategy(AnnotatedClass ac)
Method for finding
PropertyNamingStrategy for given
class, if any specified by annotations; and if so, either return
a PropertyNamingStrategy instance, or Class to use for
creating instance |
Class<?> |
AnnotationIntrospector.findPOJOBuilder(AnnotatedClass ac)
Method for finding Builder object to use for constructing
value instance and binding data (sort of combining value
instantiators that can construct, and deserializers
that can bind data).
|
JsonPOJOBuilder.Value |
AnnotationIntrospector.findPOJOBuilderConfig(AnnotatedClass ac) |
PropertyName |
AnnotationIntrospector.findRootName(AnnotatedClass ac)
Method for locating name used as "root name" (for use by
some serializers when outputting root-level object -- mostly
for XML compatibility purposes) for given class, if one
is defined.
|
String[] |
AnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac)
Method for accessing defined property serialization order (which may be
partial).
|
String |
AnnotationIntrospector.findTypeName(AnnotatedClass ac)
Method for checking if specified type has explicit name.
|
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.
|
Object |
AnnotationIntrospector.findValueInstantiator(AnnotatedClass ac)
Method getting
ValueInstantiator to use for given
type (class): return value can either be an instance of
instantiator, or class of instantiator to create. |
Boolean |
AnnotationIntrospector.isIgnorableType(AnnotatedClass ac)
Method for checking whether properties that have specified type
(class, not generics aware) should be completely ignored for
serialization and deserialization purposes.
|
Modifier and Type | Method and Description |
---|---|
abstract JsonIgnoreProperties.Value |
MapperConfig.getDefaultPropertyIgnorals(Class<?> baseType,
AnnotatedClass actualClass)
Helper method that may be called to see if there are property ignoral
definitions from annotations (via
AnnotatedClass ) or through
"config overrides". |
JsonIgnoreProperties.Value |
MapperConfigBase.getDefaultPropertyIgnorals(Class<?> baseType,
AnnotatedClass actualClass) |
abstract JsonIncludeProperties.Value |
MapperConfig.getDefaultPropertyInclusions(Class<?> baseType,
AnnotatedClass actualClass)
Helper method that may be called to see if there are property inclusion
definitions from annotations (via
AnnotatedClass ). |
JsonIncludeProperties.Value |
MapperConfigBase.getDefaultPropertyInclusions(Class<?> baseType,
AnnotatedClass actualClass) |
abstract VisibilityChecker<?> |
MapperConfig.getDefaultVisibilityChecker(Class<?> baseType,
AnnotatedClass actualClass)
Accessor for object used for determining whether specific property elements
(method, constructors, fields) can be auto-detected based on
their visibility (access modifiers).
|
VisibilityChecker<?> |
MapperConfigBase.getDefaultVisibilityChecker(Class<?> baseType,
AnnotatedClass actualClass) |
Modifier and Type | Field and Description |
---|---|
protected AnnotatedClass |
POJOPropertiesCollector._classDef
Low-level introspected class information (methods, fields etc)
|
protected AnnotatedClass |
BasicBeanDescription._classInfo
Information collected about the class introspected.
|
protected AnnotatedClass |
DefaultAccessorNamingStrategy._forClass |
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 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.
|
void |
JacksonAnnotationIntrospector.findAndAddVirtualProperties(MapperConfig<?> config,
AnnotatedClass ac,
List<BeanPropertyWriter> properties) |
void |
AnnotationIntrospectorPair.findAndAddVirtualProperties(MapperConfig<?> config,
AnnotatedClass ac,
List<BeanPropertyWriter> properties) |
VisibilityChecker<?> |
JacksonAnnotationIntrospector.findAutoDetectVisibility(AnnotatedClass ac,
VisibilityChecker<?> checker) |
VisibilityChecker<?> |
AnnotationIntrospectorPair.findAutoDetectVisibility(AnnotatedClass ac,
VisibilityChecker<?> checker) |
String |
JacksonAnnotationIntrospector.findClassDescription(AnnotatedClass ac) |
String |
AnnotationIntrospectorPair.findClassDescription(AnnotatedClass ac) |
Boolean |
AnnotationIntrospectorPair.findIgnoreUnknownProperties(AnnotatedClass ac)
Deprecated.
|
Object |
JacksonAnnotationIntrospector.findNamingStrategy(AnnotatedClass ac) |
Object |
AnnotationIntrospectorPair.findNamingStrategy(AnnotatedClass ac) |
Class<?> |
JacksonAnnotationIntrospector.findPOJOBuilder(AnnotatedClass ac) |
Class<?> |
AnnotationIntrospectorPair.findPOJOBuilder(AnnotatedClass ac) |
JsonPOJOBuilder.Value |
JacksonAnnotationIntrospector.findPOJOBuilderConfig(AnnotatedClass ac) |
JsonPOJOBuilder.Value |
AnnotationIntrospectorPair.findPOJOBuilderConfig(AnnotatedClass ac) |
PropertyName |
JacksonAnnotationIntrospector.findRootName(AnnotatedClass ac) |
PropertyName |
AnnotationIntrospectorPair.findRootName(AnnotatedClass ac) |
String[] |
JacksonAnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac) |
String[] |
AnnotationIntrospectorPair.findSerializationPropertyOrder(AnnotatedClass ac) |
String |
JacksonAnnotationIntrospector.findTypeName(AnnotatedClass ac) |
String |
AnnotationIntrospectorPair.findTypeName(AnnotatedClass ac) |
TypeResolverBuilder<?> |
JacksonAnnotationIntrospector.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType) |
TypeResolverBuilder<?> |
AnnotationIntrospectorPair.findTypeResolver(MapperConfig<?> config,
AnnotatedClass ac,
JavaType baseType) |
Object |
JacksonAnnotationIntrospector.findValueInstantiator(AnnotatedClass ac) |
Object |
AnnotationIntrospectorPair.findValueInstantiator(AnnotatedClass ac) |
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) |
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.isIgnorableType(AnnotatedClass ac) |
Boolean |
AnnotationIntrospectorPair.isIgnorableType(AnnotatedClass ac) |
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.
|
BasicBeanDescription(POJOPropertiesCollector coll,
JavaType type,
AnnotatedClass classDef) |
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
|
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.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.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).
|
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).
|
Collection<NamedType> |
StdSubtypeResolver.collectAndResolveSubtypesByClass(MapperConfig<?> config,
AnnotatedClass type) |
Collection<NamedType> |
StdSubtypeResolver.collectAndResolveSubtypesByTypeId(MapperConfig<?> config,
AnnotatedClass baseType) |
Modifier and Type | Method and Description |
---|---|
AnnotatedClass |
BeanSerializerBuilder.getClassInfo() |
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 . |
Copyright © 2008–2021 FasterXML. All rights reserved.