| 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 |
Contains implementation classes of deserialization part of
data binding.
|
| com.fasterxml.jackson.databind.ext |
Contains extended support for "external" packages: things that
may or may not be present in runtime environment, but that are
commonly enough used so that explicit support can be added.
|
| 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.ser |
Contains implementation classes of serialization part of
data binding.
|
| Modifier and Type | Method and Description |
|---|---|
protected <A extends Annotation> |
AnnotationIntrospector._findAnnotation(Annotated ann,
Class<A> annoClass)
Method that should be used by sub-classes for ALL
annotation access;
overridable so
that sub-classes may, if they choose to, mangle actual access to
block access ("hide" annotations) or perhaps change it.
|
protected boolean |
AnnotationIntrospector._hasAnnotation(Annotated ann,
Class<? extends Annotation> annoClass)
Method that should be used by sub-classes for ALL
annotation existence access;
overridable so that sub-classes may, if they choose to, mangle actual access to
block access ("hide" annotations) or perhaps change value seen.
|
protected boolean |
AnnotationIntrospector._hasOneOf(Annotated ann,
Class<? extends Annotation>[] annoClasses)
Alternative lookup method that is used to see if annotation has at least one of
annotations of types listed in second argument.
|
Converter<Object,Object> |
DatabindContext.converterInstance(Annotated annotated,
Object converterDef)
Helper method to use to construct a
Converter, given a definition
that may be either actual converter instance, or Class for instantiating one. |
abstract JsonDeserializer<Object> |
DeserializationContext.deserializerInstance(Annotated annotated,
Object deserDef) |
Object |
AnnotationIntrospector.findContentDeserializer(Annotated am)
Method for getting a deserializer definition for content (values) of
associated
Collection, array or
Map property. |
Object |
AnnotationIntrospector.findContentSerializer(Annotated am)
Method for getting a serializer definition for content (values) of
associated
Collection, array or Map property. |
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. |
JsonCreator.Mode |
AnnotationIntrospector.findCreatorBinding(Annotated ann)
|
Class<?> |
AnnotationIntrospector.findDeserializationContentType(Annotated ann,
JavaType baseContentType)
|
Object |
AnnotationIntrospector.findDeserializationConverter(Annotated a)
Method for finding
Converter that annotated entity
(property or class) has indicated to be used as part of
deserialization. |
Class<?> |
AnnotationIntrospector.findDeserializationKeyType(Annotated ann,
JavaType baseKeyType)
|
Class<?> |
AnnotationIntrospector.findDeserializationType(Annotated ann,
JavaType baseType)
|
Object |
AnnotationIntrospector.findDeserializer(Annotated am)
Method for getting a deserializer definition on specified method
or field.
|
Object |
AnnotationIntrospector.findFilterId(Annotated ann)
Method for finding if annotated class has associated filter; and if so,
to return id that is used to locate filter.
|
JsonFormat.Value |
AnnotationIntrospector.findFormat(Annotated memberOrClass)
Method for finding format annotations for property or class.
|
Object |
AnnotationIntrospector.findKeyDeserializer(Annotated am)
Method for getting a deserializer definition for keys of
associated
Map property. |
Object |
AnnotationIntrospector.findKeySerializer(Annotated am)
Method for getting a serializer definition for keys of associated
java.util.Map property. |
Boolean |
AnnotationIntrospector.findMergeInfo(Annotated ann)
Method for finding merge settings for property, if any.
|
PropertyName |
AnnotationIntrospector.findNameForDeserialization(Annotated ann)
Method for checking whether given property accessors (method,
field) has an annotation that suggests property name to use
for deserialization (reading JSON into POJOs).
|
PropertyName |
AnnotationIntrospector.findNameForSerialization(Annotated a)
Method for checking whether given property accessors (method,
field) has an annotation that suggests property name to use
for serialization.
|
String |
AnnotationIntrospector.XmlExtensions.findNamespace(MapperConfig<?> config,
Annotated ann)
Method that can be called to figure out generic namespace
property for an annotated object.
|
Object |
AnnotationIntrospector.findNullSerializer(Annotated am)
Method for getting a serializer definition for serializer to use
for nulls (null values) of associated property or type.
|
ObjectIdInfo |
AnnotationIntrospector.findObjectIdInfo(Annotated ann)
Method for checking whether given annotated thing
(type, or accessor) indicates that values
referenced (values of type of annotated class, or
values referenced by annotated property; latter
having precedence) should include Object Identifier,
and if so, specify details of Object Identity used.
|
ObjectIdInfo |
AnnotationIntrospector.findObjectReferenceInfo(Annotated ann,
ObjectIdInfo objectIdInfo)
Method for figuring out additional properties of an Object Identity reference
|
String[] |
AnnotationIntrospector.findPropertiesToIgnore(Annotated ac,
boolean forSerialization)
|
JsonProperty.Access |
AnnotationIntrospector.findPropertyAccess(Annotated ann)
Method for finding optional access definition for a property, annotated
on one of its accessors.
|
List<PropertyName> |
AnnotationIntrospector.findPropertyAliases(Annotated ann)
Method called to find if given property has alias(es) defined.
|
String |
AnnotationIntrospector.findPropertyDefaultValue(Annotated ann)
Method for finding suggested default value (as simple textual serialization)
for the property.
|
String |
AnnotationIntrospector.findPropertyDescription(Annotated ann)
Method used to check whether specified property member (accessor
or mutator) defines human-readable description to use for documentation.
|
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").
|
JsonIgnoreProperties.Value |
AnnotationIntrospector.findPropertyIgnorals(Annotated ac)
|
JsonInclude.Value |
AnnotationIntrospector.findPropertyInclusion(Annotated a)
Method for checking inclusion criteria for a type (Class) or property (yes, method
name is bit unfortunate -- not just for properties!).
|
JsonIncludeProperties.Value |
AnnotationIntrospector.findPropertyInclusionByName(MapperConfig<?> config,
Annotated ann)
Method for finding information about names of properties to included.
|
Integer |
AnnotationIntrospector.findPropertyIndex(Annotated ann)
Method used to check whether specified property member (accessor
or mutator) defines numeric index, and if so, what is the index value.
|
Class<?> |
AnnotationIntrospector.findSerializationContentType(Annotated am,
JavaType baseType)
|
Object |
AnnotationIntrospector.findSerializationConverter(Annotated a)
Method for finding
Converter that annotated entity
(property or class) has indicated to be used as part of
serialization. |
JsonInclude.Include |
AnnotationIntrospector.findSerializationInclusion(Annotated a,
JsonInclude.Include defValue)
Deprecated.
|
JsonInclude.Include |
AnnotationIntrospector.findSerializationInclusionForContent(Annotated a,
JsonInclude.Include defValue)
Deprecated.
|
Class<?> |
AnnotationIntrospector.findSerializationKeyType(Annotated am,
JavaType baseType)
|
Boolean |
AnnotationIntrospector.findSerializationSortAlphabetically(Annotated ann)
Method for checking whether an annotation indicates that serialized properties
for which no explicit is defined should be alphabetically (lexicograpically)
ordered
|
Class<?> |
AnnotationIntrospector.findSerializationType(Annotated a)
|
JsonSerialize.Typing |
AnnotationIntrospector.findSerializationTyping(Annotated a)
Method for accessing declared typing mode annotated (if any).
|
Object |
AnnotationIntrospector.findSerializer(Annotated am)
Method for getting a serializer definition on specified method
or field.
|
JsonSetter.Value |
AnnotationIntrospector.findSetterInfo(Annotated ann)
Method for finding possible settings for property, given annotations
on an accessor.
|
List<NamedType> |
AnnotationIntrospector.findSubtypes(Annotated a)
Method for locating annotation-specified subtypes related to annotated
entity (class, method, field).
|
Class<?>[] |
AnnotationIntrospector.findViews(Annotated a)
Method for checking if annotated property (represented by a field or
getter/setter method) has definitions for views it is to be included in.
|
PropertyName |
AnnotationIntrospector.findWrapperName(Annotated ann)
Method used to check if specified property has annotation that indicates
that it should be wrapped in an element; and if so, name to use.
|
Boolean |
AnnotationIntrospector.hasAnyGetter(Annotated ann)
Method for checking whether given method has an annotation
that suggests that the method is to serve as "any setter";
method to be used for accessing set of miscellaneous "extra"
properties, often bound with matching "any setter" method.
|
Boolean |
AnnotationIntrospector.hasAnySetter(Annotated ann)
Method for checking whether given method has an annotation
that suggests that the method is to serve as "any setter";
method to be used for setting values of any properties for
which no dedicated setter method is found.
|
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.hasAsValue(Annotated a)
Method for checking whether given method has an annotation
that suggests that the return value of annotated method
should be used as "the value" of the object instance; usually
serialized as a primitive value such as String or number.
|
boolean |
AnnotationIntrospector.hasCreatorAnnotation(Annotated ann)
|
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.
|
abstract KeyDeserializer |
DeserializationContext.keyDeserializerInstance(Annotated annotated,
Object deserDef) |
ObjectIdGenerator<?> |
DatabindContext.objectIdGeneratorInstance(Annotated annotated,
ObjectIdInfo objectIdInfo) |
ObjectIdResolver |
DatabindContext.objectIdResolverInstance(Annotated annotated,
ObjectIdInfo objectIdInfo) |
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.
|
abstract JsonSerializer<Object> |
SerializerProvider.serializerInstance(Annotated annotated,
Object serDef)
Method that can be called to construct and configure serializer instance,
either given a
Class to instantiate (with default constructor),
or an uninitialized serializer instance. |
| 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.
|
abstract JsonDeserializer<?> |
HandlerInstantiator.deserializerInstance(DeserializationConfig config,
Annotated annotated,
Class<?> deserClass)
Method called to get an instance of deserializer of specified type.
|
abstract KeyDeserializer |
HandlerInstantiator.keyDeserializerInstance(DeserializationConfig config,
Annotated annotated,
Class<?> keyDeserClass)
Method called to get an instance of key deserializer of specified type.
|
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 JsonSerializer<?> |
HandlerInstantiator.serializerInstance(SerializationConfig config,
Annotated annotated,
Class<?> serClass)
Method called to get an instance of serializer of specified type.
|
TypeIdResolver |
MapperConfig.typeIdResolverInstance(Annotated annotated,
Class<? extends TypeIdResolver> resolverClass)
Method that can be called to obtain an instance of
TypeIdResolver of
specified type. |
abstract TypeIdResolver |
HandlerInstantiator.typeIdResolverInstance(MapperConfig<?> config,
Annotated annotated,
Class<?> resolverClass)
Method called to get an instance of TypeIdResolver of specified type.
|
TypeResolverBuilder<?> |
MapperConfig.typeResolverBuilderInstance(Annotated annotated,
Class<? extends TypeResolverBuilder<?>> builderClass)
Method that can be called to obtain 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.
|
| Modifier and Type | Method and Description |
|---|---|
protected boolean |
BasicDeserializerFactory._hasCreatorAnnotation(DeserializationContext ctxt,
Annotated ann) |
ValueInstantiator |
BasicDeserializerFactory._valueInstantiatorInstance(DeserializationConfig config,
Annotated annotated,
Object instDef) |
JsonDeserializer<Object> |
DefaultDeserializationContext.deserializerInstance(Annotated ann,
Object deserDef) |
protected JsonDeserializer<Object> |
BasicDeserializerFactory.findContentDeserializerFromAnnotation(DeserializationContext ctxt,
Annotated ann) |
protected Converter<Object,Object> |
DeserializerCache.findConverter(DeserializationContext ctxt,
Annotated a) |
protected JsonDeserializer<Object> |
DeserializerCache.findConvertingDeserializer(DeserializationContext ctxt,
Annotated a,
JsonDeserializer<Object> deser)
Helper method that will check whether given annotated entity (usually class,
but may also be a property accessor) indicates that a
Converter is to
be used; and if so, to construct and return suitable serializer for it. |
protected JsonDeserializer<Object> |
DeserializerCache.findDeserializerFromAnnotation(DeserializationContext ctxt,
Annotated ann)
Helper method called to check if a class or method
has annotation that tells which class to use for deserialization.
|
protected JsonDeserializer<Object> |
BasicDeserializerFactory.findDeserializerFromAnnotation(DeserializationContext ctxt,
Annotated ann)
Helper method called to check if a class or method
has annotation that tells which class to use for deserialization; and if
so, to instantiate, that deserializer to use.
|
protected KeyDeserializer |
BasicDeserializerFactory.findKeyDeserializerFromAnnotation(DeserializationContext ctxt,
Annotated ann)
Helper method called to check if a class or method
has annotation that tells which class to use for deserialization of
Map keys. |
KeyDeserializer |
DefaultDeserializationContext.keyDeserializerInstance(Annotated ann,
Object deserDef) |
protected JavaType |
BasicDeserializerFactory.modifyTypeByAnnotation(DeserializationContext ctxt,
Annotated a,
JavaType type)
|
| Modifier and Type | Method and Description |
|---|---|
Boolean |
Java7SupportImpl.findTransient(Annotated a) |
abstract Boolean |
Java7Support.findTransient(Annotated a) |
Boolean |
Java7SupportImpl.hasCreatorAnnotation(Annotated a) |
abstract Boolean |
Java7Support.hasCreatorAnnotation(Annotated a) |
| Modifier and Type | Class and Description |
|---|---|
class |
AnnotatedAndMetadata<A extends Annotated,M>
Silly little "Pair" class needed for 2-element tuples (without
adding dependency to one of 3rd party packages that has one).
|
| Modifier and Type | Class and Description |
|---|---|
class |
AnnotatedClass |
class |
AnnotatedConstructor |
class |
AnnotatedField
Object that represents non-static (and usually non-transient/volatile)
fields of a class.
|
class |
AnnotatedMember
Intermediate base class for annotated entities that are members of
a class; fields, methods and constructors.
|
class |
AnnotatedMethod |
class |
AnnotatedParameter
Object that represents method parameters, mostly so that associated
annotations can be processed conveniently.
|
class |
AnnotatedWithParams
Intermediate base class that encapsulates features that
constructors and methods share.
|
class |
VirtualAnnotatedMember
Placeholder used by virtual properties as placeholder for
underlying
AnnotatedMember. |
| Modifier and Type | Field and Description |
|---|---|
A |
AnnotatedAndMetadata.annotated |
| Modifier and Type | Method and Description |
|---|---|
static <A extends Annotated,M> |
AnnotatedAndMetadata.of(A ann,
M md) |
| Modifier and Type | Method and Description |
|---|---|
Annotated |
VirtualAnnotatedMember.withAnnotations(AnnotationMap fallback) |
abstract Annotated |
AnnotatedMember.withAnnotations(AnnotationMap fallback)
Fluent factory method that will construct a new instance that uses specified
instance annotations instead of currently configured ones.
|
| Modifier and Type | Method and Description |
|---|---|
protected PropertyName |
JacksonAnnotationIntrospector._findConstructorName(Annotated a) |
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 boolean |
JacksonAnnotationIntrospector._isIgnorable(Annotated a) |
Object |
JacksonAnnotationIntrospector.findContentDeserializer(Annotated a) |
Object |
AnnotationIntrospectorPair.findContentDeserializer(Annotated am) |
Object |
JacksonAnnotationIntrospector.findContentSerializer(Annotated a) |
Object |
AnnotationIntrospectorPair.findContentSerializer(Annotated a) |
JsonCreator.Mode |
JacksonAnnotationIntrospector.findCreatorAnnotation(MapperConfig<?> config,
Annotated a) |
JsonCreator.Mode |
AnnotationIntrospectorPair.findCreatorAnnotation(MapperConfig<?> config,
Annotated a) |
JsonCreator.Mode |
JacksonAnnotationIntrospector.findCreatorBinding(Annotated a)
Deprecated.
|
JsonCreator.Mode |
AnnotationIntrospectorPair.findCreatorBinding(Annotated a)
Deprecated.
|
Class<?> |
JacksonAnnotationIntrospector.findDeserializationContentType(Annotated am,
JavaType baseContentType)
Deprecated.
|
Class<?> |
AnnotationIntrospectorPair.findDeserializationContentType(Annotated am,
JavaType baseContentType)
Deprecated.
|
Object |
JacksonAnnotationIntrospector.findDeserializationConverter(Annotated a) |
Object |
AnnotationIntrospectorPair.findDeserializationConverter(Annotated a) |
Class<?> |
JacksonAnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType baseKeyType)
Deprecated.
|
Class<?> |
AnnotationIntrospectorPair.findDeserializationKeyType(Annotated am,
JavaType baseKeyType)
Deprecated.
|
Class<?> |
JacksonAnnotationIntrospector.findDeserializationType(Annotated am,
JavaType baseType)
Deprecated.
|
Class<?> |
AnnotationIntrospectorPair.findDeserializationType(Annotated am,
JavaType baseType)
Deprecated.
|
Object |
JacksonAnnotationIntrospector.findDeserializer(Annotated a) |
Object |
AnnotationIntrospectorPair.findDeserializer(Annotated a) |
Object |
JacksonAnnotationIntrospector.findFilterId(Annotated a) |
Object |
AnnotationIntrospectorPair.findFilterId(Annotated ann) |
JsonFormat.Value |
JacksonAnnotationIntrospector.findFormat(Annotated ann) |
JsonFormat.Value |
AnnotationIntrospectorPair.findFormat(Annotated ann) |
Object |
JacksonAnnotationIntrospector.findKeyDeserializer(Annotated a) |
Object |
AnnotationIntrospectorPair.findKeyDeserializer(Annotated a) |
Object |
JacksonAnnotationIntrospector.findKeySerializer(Annotated a) |
Object |
AnnotationIntrospectorPair.findKeySerializer(Annotated a) |
Boolean |
JacksonAnnotationIntrospector.findMergeInfo(Annotated a) |
Boolean |
AnnotationIntrospectorPair.findMergeInfo(Annotated a) |
PropertyName |
JacksonAnnotationIntrospector.findNameForDeserialization(Annotated a) |
PropertyName |
AnnotationIntrospectorPair.findNameForDeserialization(Annotated a) |
PropertyName |
JacksonAnnotationIntrospector.findNameForSerialization(Annotated a) |
PropertyName |
AnnotationIntrospectorPair.findNameForSerialization(Annotated a) |
Object |
JacksonAnnotationIntrospector.findNullSerializer(Annotated a) |
Object |
AnnotationIntrospectorPair.findNullSerializer(Annotated a) |
ObjectIdInfo |
JacksonAnnotationIntrospector.findObjectIdInfo(Annotated ann) |
ObjectIdInfo |
AnnotationIntrospectorPair.findObjectIdInfo(Annotated ann) |
ObjectIdInfo |
JacksonAnnotationIntrospector.findObjectReferenceInfo(Annotated ann,
ObjectIdInfo objectIdInfo) |
ObjectIdInfo |
AnnotationIntrospectorPair.findObjectReferenceInfo(Annotated ann,
ObjectIdInfo objectIdInfo) |
String[] |
AnnotationIntrospectorPair.findPropertiesToIgnore(Annotated ac,
boolean forSerialization)
Deprecated.
|
JsonProperty.Access |
JacksonAnnotationIntrospector.findPropertyAccess(Annotated m) |
JsonProperty.Access |
AnnotationIntrospectorPair.findPropertyAccess(Annotated ann) |
List<PropertyName> |
JacksonAnnotationIntrospector.findPropertyAliases(Annotated m) |
List<PropertyName> |
AnnotationIntrospectorPair.findPropertyAliases(Annotated ann) |
String |
JacksonAnnotationIntrospector.findPropertyDefaultValue(Annotated ann) |
String |
AnnotationIntrospectorPair.findPropertyDefaultValue(Annotated ann) |
String |
JacksonAnnotationIntrospector.findPropertyDescription(Annotated ann) |
String |
AnnotationIntrospectorPair.findPropertyDescription(Annotated ann) |
JsonIgnoreProperties.Value |
JacksonAnnotationIntrospector.findPropertyIgnoralByName(MapperConfig<?> config,
Annotated a) |
JsonIgnoreProperties.Value |
AnnotationIntrospectorPair.findPropertyIgnoralByName(MapperConfig<?> config,
Annotated ann) |
JsonIgnoreProperties.Value |
JacksonAnnotationIntrospector.findPropertyIgnorals(Annotated ac)
Deprecated.
|
JsonIgnoreProperties.Value |
AnnotationIntrospectorPair.findPropertyIgnorals(Annotated a)
Deprecated.
|
JsonInclude.Value |
JacksonAnnotationIntrospector.findPropertyInclusion(Annotated a) |
JsonInclude.Value |
AnnotationIntrospectorPair.findPropertyInclusion(Annotated a) |
JsonIncludeProperties.Value |
JacksonAnnotationIntrospector.findPropertyInclusionByName(MapperConfig<?> config,
Annotated a) |
JsonIncludeProperties.Value |
AnnotationIntrospectorPair.findPropertyInclusionByName(MapperConfig<?> config,
Annotated a) |
Integer |
JacksonAnnotationIntrospector.findPropertyIndex(Annotated ann) |
Integer |
AnnotationIntrospectorPair.findPropertyIndex(Annotated ann) |
Class<?> |
JacksonAnnotationIntrospector.findSerializationContentType(Annotated am,
JavaType baseType)
Deprecated.
|
Class<?> |
AnnotationIntrospectorPair.findSerializationContentType(Annotated am,
JavaType baseType)
Deprecated.
|
Object |
JacksonAnnotationIntrospector.findSerializationConverter(Annotated a) |
Object |
AnnotationIntrospectorPair.findSerializationConverter(Annotated a) |
JsonInclude.Include |
AnnotationIntrospectorPair.findSerializationInclusion(Annotated a,
JsonInclude.Include defValue)
Deprecated.
|
JsonInclude.Include |
AnnotationIntrospectorPair.findSerializationInclusionForContent(Annotated a,
JsonInclude.Include defValue)
Deprecated.
|
Class<?> |
JacksonAnnotationIntrospector.findSerializationKeyType(Annotated am,
JavaType baseType)
Deprecated.
|
Class<?> |
AnnotationIntrospectorPair.findSerializationKeyType(Annotated am,
JavaType baseType)
Deprecated.
|
Boolean |
JacksonAnnotationIntrospector.findSerializationSortAlphabetically(Annotated ann) |
Boolean |
AnnotationIntrospectorPair.findSerializationSortAlphabetically(Annotated ann) |
Class<?> |
JacksonAnnotationIntrospector.findSerializationType(Annotated am)
Deprecated.
|
Class<?> |
AnnotationIntrospectorPair.findSerializationType(Annotated a)
Deprecated.
|
JsonSerialize.Typing |
JacksonAnnotationIntrospector.findSerializationTyping(Annotated a) |
JsonSerialize.Typing |
AnnotationIntrospectorPair.findSerializationTyping(Annotated a) |
Object |
JacksonAnnotationIntrospector.findSerializer(Annotated a) |
Object |
AnnotationIntrospectorPair.findSerializer(Annotated am) |
JsonSetter.Value |
JacksonAnnotationIntrospector.findSetterInfo(Annotated a) |
JsonSetter.Value |
AnnotationIntrospectorPair.findSetterInfo(Annotated a) |
List<NamedType> |
JacksonAnnotationIntrospector.findSubtypes(Annotated a) |
List<NamedType> |
AnnotationIntrospectorPair.findSubtypes(Annotated a) |
Class<?>[] |
JacksonAnnotationIntrospector.findViews(Annotated a) |
Class<?>[] |
AnnotationIntrospectorPair.findViews(Annotated a) |
PropertyName |
AnnotationIntrospectorPair.findWrapperName(Annotated ann) |
Boolean |
JacksonAnnotationIntrospector.hasAnyGetter(Annotated a) |
Boolean |
AnnotationIntrospectorPair.hasAnyGetter(Annotated a) |
Boolean |
JacksonAnnotationIntrospector.hasAnySetter(Annotated a) |
Boolean |
AnnotationIntrospectorPair.hasAnySetter(Annotated a) |
Boolean |
JacksonAnnotationIntrospector.hasAsKey(MapperConfig<?> config,
Annotated a) |
Boolean |
AnnotationIntrospectorPair.hasAsKey(MapperConfig<?> config,
Annotated a) |
Boolean |
JacksonAnnotationIntrospector.hasAsValue(Annotated a) |
Boolean |
AnnotationIntrospectorPair.hasAsValue(Annotated a) |
boolean |
JacksonAnnotationIntrospector.hasCreatorAnnotation(Annotated a)
Deprecated.
|
boolean |
AnnotationIntrospectorPair.hasCreatorAnnotation(Annotated a)
Deprecated.
|
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) |
| Modifier and Type | Method and Description |
|---|---|
protected JsonSerializer<Object> |
BasicSerializerFactory._findContentSerializer(SerializerProvider prov,
Annotated a)
Helper method called to try to find whether there is an annotation in the
class that indicates content ("value") serializer to use.
|
protected JsonSerializer<Object> |
BasicSerializerFactory._findKeySerializer(SerializerProvider prov,
Annotated a)
Helper method called to try to find whether there is an annotation in the
class that indicates key serializer to use.
|
protected Converter<Object,Object> |
BasicSerializerFactory.findConverter(SerializerProvider prov,
Annotated a) |
protected JsonSerializer<?> |
BasicSerializerFactory.findConvertingSerializer(SerializerProvider prov,
Annotated a,
JsonSerializer<?> ser)
Helper method that will check whether given annotated entity (usually class,
but may also be a property accessor) indicates that a
Converter is to
be used; and if so, to construct and return suitable serializer for it. |
protected JavaType |
PropertyBuilder.findSerializationType(Annotated a,
boolean useStaticTyping,
JavaType declaredType)
Method that will try to determine statically defined type of property
being serialized, based on annotations (for overrides), and alternatively
declared type (if static typing for serialization is enabled).
|
protected JsonSerializer<Object> |
BasicSerializerFactory.findSerializerFromAnnotation(SerializerProvider prov,
Annotated a)
Helper method called to check if a class or method
has an annotation
(@link com.fasterxml.jackson.databind.annotation.JsonSerialize#using)
that tells the class to use for serialization.
|
JsonSerializer<Object> |
DefaultSerializerProvider.serializerInstance(Annotated annotated,
Object serDef) |
Copyright © 2008–2021 FasterXML. All rights reserved.