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.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.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 | Description |
---|---|---|
protected <A extends Annotation> |
AnnotationIntrospector._findAnnotation(Annotated annotated,
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 annotated,
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 annotated,
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. |
com.fasterxml.jackson.annotation.JsonCreator.Mode |
AnnotationIntrospector.findCreatorAnnotation(MapperConfig<?> config,
Annotated a) |
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. |
com.fasterxml.jackson.annotation.JsonCreator.Mode |
AnnotationIntrospector.findCreatorBinding(Annotated a) |
|
Class<?> |
AnnotationIntrospector.findDeserializationContentType(Annotated am,
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 am,
JavaType baseKeyType) |
|
Class<?> |
AnnotationIntrospector.findDeserializationType(Annotated am,
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.
|
com.fasterxml.jackson.annotation.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
Map property. |
Boolean |
AnnotationIntrospector.findMergeInfo(Annotated a) |
Method for finding merge settings for property, if any.
|
PropertyName |
AnnotationIntrospector.findNameForDeserialization(Annotated a) |
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.
|
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) |
Deprecated.
Since 2.6, use variant that takes second argument.
|
String[] |
AnnotationIntrospector.findPropertiesToIgnore(Annotated ac,
boolean forSerialization) |
Deprecated.
|
com.fasterxml.jackson.annotation.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.
|
com.fasterxml.jackson.annotation.JsonIgnoreProperties.Value |
AnnotationIntrospector.findPropertyIgnorals(Annotated ac) |
Method for finding information about properties to ignore either by
name, or by more general specification ("ignore all unknown").
|
com.fasterxml.jackson.annotation.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!).
|
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. |
com.fasterxml.jackson.annotation.JsonInclude.Include |
AnnotationIntrospector.findSerializationInclusion(Annotated a,
com.fasterxml.jackson.annotation.JsonInclude.Include defValue) |
Deprecated.
|
com.fasterxml.jackson.annotation.JsonInclude.Include |
AnnotationIntrospector.findSerializationInclusionForContent(Annotated a,
com.fasterxml.jackson.annotation.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.
|
com.fasterxml.jackson.annotation.JsonSetter.Value |
AnnotationIntrospector.findSetterInfo(Annotated a) |
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 a) |
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 a) |
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.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 a) |
|
abstract KeyDeserializer |
DeserializationContext.keyDeserializerInstance(Annotated annotated,
Object deserDef) |
|
com.fasterxml.jackson.annotation.ObjectIdGenerator<?> |
DatabindContext.objectIdGeneratorInstance(Annotated annotated,
ObjectIdInfo objectIdInfo) |
|
com.fasterxml.jackson.annotation.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 | 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.
|
com.fasterxml.jackson.annotation.ObjectIdGenerator<?> |
HandlerInstantiator.objectIdGeneratorInstance(MapperConfig<?> config,
Annotated annotated,
Class<?> implClass) |
Method called to construct a ObjectIdHandler instance of specified type.
|
com.fasterxml.jackson.annotation.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.
|
abstract TypeIdResolver |
HandlerInstantiator.typeIdResolverInstance(MapperConfig<?> config,
Annotated annotated,
Class<?> resolverClass) |
Method called to get an instance of TypeIdResolver 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 TypeResolverBuilder<?> |
HandlerInstantiator.typeResolverBuilderInstance(MapperConfig<?> config,
Annotated annotated,
Class<?> builderClass) |
Method called to get an instance of TypeResolverBuilder 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. |
ValueInstantiator |
HandlerInstantiator.valueInstantiatorInstance(MapperConfig<?> config,
Annotated annotated,
Class<?> resolverClass) |
Method called to construct an instance of ValueInstantiator of specified type.
|
Modifier and Type | Method | 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> |
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 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 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.
|
KeyDeserializer |
DefaultDeserializationContext.keyDeserializerInstance(Annotated ann,
Object deserDef) |
|
protected JavaType |
BasicDeserializerFactory.modifyTypeByAnnotation(DeserializationContext ctxt,
Annotated a,
JavaType type) |
Modifier and Type | Class | Description |
---|---|---|
protected static class |
CreatorCollector.StdTypeConstructor |
Replacement for default constructor to use for a small set of
"well-known" types.
|
Modifier and Type | Method | Description |
---|---|---|
Annotated |
CreatorCollector.StdTypeConstructor.withAnnotations(AnnotationMap fallback) |
Modifier and Type | Method | Description |
---|---|---|
abstract Boolean |
Java7Support.findTransient(Annotated a) |
|
Boolean |
Java7SupportImpl.findTransient(Annotated a) |
|
abstract Boolean |
Java7Support.hasCreatorAnnotation(Annotated a) |
|
Boolean |
Java7SupportImpl.hasCreatorAnnotation(Annotated a) |
Modifier and Type | Class | 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 | Method | Description |
---|---|---|
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.
|
Annotated |
VirtualAnnotatedMember.withAnnotations(AnnotationMap fallback) |
Modifier and Type | Method | 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 |
AnnotationIntrospectorPair.findContentDeserializer(Annotated am) |
|
Object |
JacksonAnnotationIntrospector.findContentDeserializer(Annotated a) |
|
Object |
AnnotationIntrospectorPair.findContentSerializer(Annotated a) |
|
Object |
JacksonAnnotationIntrospector.findContentSerializer(Annotated a) |
|
com.fasterxml.jackson.annotation.JsonCreator.Mode |
AnnotationIntrospectorPair.findCreatorAnnotation(MapperConfig<?> config,
Annotated a) |
|
com.fasterxml.jackson.annotation.JsonCreator.Mode |
JacksonAnnotationIntrospector.findCreatorAnnotation(MapperConfig<?> config,
Annotated a) |
|
com.fasterxml.jackson.annotation.JsonCreator.Mode |
AnnotationIntrospectorPair.findCreatorBinding(Annotated a) |
Deprecated.
|
com.fasterxml.jackson.annotation.JsonCreator.Mode |
JacksonAnnotationIntrospector.findCreatorBinding(Annotated a) |
Deprecated.
|
Class<?> |
AnnotationIntrospectorPair.findDeserializationContentType(Annotated am,
JavaType baseContentType) |
Deprecated.
|
Class<?> |
JacksonAnnotationIntrospector.findDeserializationContentType(Annotated am,
JavaType baseContentType) |
Deprecated.
|
Object |
AnnotationIntrospectorPair.findDeserializationConverter(Annotated a) |
|
Object |
JacksonAnnotationIntrospector.findDeserializationConverter(Annotated a) |
|
Class<?> |
AnnotationIntrospectorPair.findDeserializationKeyType(Annotated am,
JavaType baseKeyType) |
Deprecated.
|
Class<?> |
JacksonAnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType baseKeyType) |
Deprecated.
|
Class<?> |
AnnotationIntrospectorPair.findDeserializationType(Annotated am,
JavaType baseType) |
Deprecated.
|
Class<?> |
JacksonAnnotationIntrospector.findDeserializationType(Annotated am,
JavaType baseType) |
Deprecated.
|
Object |
AnnotationIntrospectorPair.findDeserializer(Annotated a) |
|
Object |
JacksonAnnotationIntrospector.findDeserializer(Annotated a) |
|
Object |
AnnotationIntrospectorPair.findFilterId(Annotated ann) |
|
Object |
JacksonAnnotationIntrospector.findFilterId(Annotated a) |
|
com.fasterxml.jackson.annotation.JsonFormat.Value |
AnnotationIntrospectorPair.findFormat(Annotated ann) |
|
com.fasterxml.jackson.annotation.JsonFormat.Value |
JacksonAnnotationIntrospector.findFormat(Annotated ann) |
|
Object |
AnnotationIntrospectorPair.findKeyDeserializer(Annotated a) |
|
Object |
JacksonAnnotationIntrospector.findKeyDeserializer(Annotated a) |
|
Object |
AnnotationIntrospectorPair.findKeySerializer(Annotated a) |
|
Object |
JacksonAnnotationIntrospector.findKeySerializer(Annotated a) |
|
Boolean |
AnnotationIntrospectorPair.findMergeInfo(Annotated a) |
|
Boolean |
JacksonAnnotationIntrospector.findMergeInfo(Annotated a) |
|
PropertyName |
AnnotationIntrospectorPair.findNameForDeserialization(Annotated a) |
|
PropertyName |
JacksonAnnotationIntrospector.findNameForDeserialization(Annotated a) |
|
PropertyName |
AnnotationIntrospectorPair.findNameForSerialization(Annotated a) |
|
PropertyName |
JacksonAnnotationIntrospector.findNameForSerialization(Annotated a) |
|
Object |
AnnotationIntrospectorPair.findNullSerializer(Annotated a) |
|
Object |
JacksonAnnotationIntrospector.findNullSerializer(Annotated a) |
|
ObjectIdInfo |
AnnotationIntrospectorPair.findObjectIdInfo(Annotated ann) |
|
ObjectIdInfo |
JacksonAnnotationIntrospector.findObjectIdInfo(Annotated ann) |
|
ObjectIdInfo |
AnnotationIntrospectorPair.findObjectReferenceInfo(Annotated ann,
ObjectIdInfo objectIdInfo) |
|
ObjectIdInfo |
JacksonAnnotationIntrospector.findObjectReferenceInfo(Annotated ann,
ObjectIdInfo objectIdInfo) |
|
String[] |
AnnotationIntrospectorPair.findPropertiesToIgnore(Annotated ac) |
Deprecated.
|
String[] |
AnnotationIntrospectorPair.findPropertiesToIgnore(Annotated ac,
boolean forSerialization) |
Deprecated.
|
com.fasterxml.jackson.annotation.JsonProperty.Access |
AnnotationIntrospectorPair.findPropertyAccess(Annotated ann) |
|
com.fasterxml.jackson.annotation.JsonProperty.Access |
JacksonAnnotationIntrospector.findPropertyAccess(Annotated m) |
|
List<PropertyName> |
AnnotationIntrospectorPair.findPropertyAliases(Annotated ann) |
|
List<PropertyName> |
JacksonAnnotationIntrospector.findPropertyAliases(Annotated m) |
|
String |
AnnotationIntrospectorPair.findPropertyDefaultValue(Annotated ann) |
|
String |
JacksonAnnotationIntrospector.findPropertyDefaultValue(Annotated ann) |
|
String |
AnnotationIntrospectorPair.findPropertyDescription(Annotated ann) |
|
String |
JacksonAnnotationIntrospector.findPropertyDescription(Annotated ann) |
|
com.fasterxml.jackson.annotation.JsonIgnoreProperties.Value |
AnnotationIntrospectorPair.findPropertyIgnorals(Annotated a) |
|
com.fasterxml.jackson.annotation.JsonIgnoreProperties.Value |
JacksonAnnotationIntrospector.findPropertyIgnorals(Annotated a) |
|
com.fasterxml.jackson.annotation.JsonInclude.Value |
AnnotationIntrospectorPair.findPropertyInclusion(Annotated a) |
|
com.fasterxml.jackson.annotation.JsonInclude.Value |
JacksonAnnotationIntrospector.findPropertyInclusion(Annotated a) |
|
Integer |
AnnotationIntrospectorPair.findPropertyIndex(Annotated ann) |
|
Integer |
JacksonAnnotationIntrospector.findPropertyIndex(Annotated ann) |
|
Class<?> |
AnnotationIntrospectorPair.findSerializationContentType(Annotated am,
JavaType baseType) |
Deprecated.
|
Class<?> |
JacksonAnnotationIntrospector.findSerializationContentType(Annotated am,
JavaType baseType) |
Deprecated.
|
Object |
AnnotationIntrospectorPair.findSerializationConverter(Annotated a) |
|
Object |
JacksonAnnotationIntrospector.findSerializationConverter(Annotated a) |
|
com.fasterxml.jackson.annotation.JsonInclude.Include |
AnnotationIntrospectorPair.findSerializationInclusion(Annotated a,
com.fasterxml.jackson.annotation.JsonInclude.Include defValue) |
Deprecated.
|
com.fasterxml.jackson.annotation.JsonInclude.Include |
AnnotationIntrospectorPair.findSerializationInclusionForContent(Annotated a,
com.fasterxml.jackson.annotation.JsonInclude.Include defValue) |
Deprecated.
|
Class<?> |
AnnotationIntrospectorPair.findSerializationKeyType(Annotated am,
JavaType baseType) |
Deprecated.
|
Class<?> |
JacksonAnnotationIntrospector.findSerializationKeyType(Annotated am,
JavaType baseType) |
Deprecated.
|
Boolean |
AnnotationIntrospectorPair.findSerializationSortAlphabetically(Annotated ann) |
|
Boolean |
JacksonAnnotationIntrospector.findSerializationSortAlphabetically(Annotated ann) |
|
Class<?> |
AnnotationIntrospectorPair.findSerializationType(Annotated a) |
Deprecated.
|
Class<?> |
JacksonAnnotationIntrospector.findSerializationType(Annotated am) |
Deprecated.
|
JsonSerialize.Typing |
AnnotationIntrospectorPair.findSerializationTyping(Annotated a) |
|
JsonSerialize.Typing |
JacksonAnnotationIntrospector.findSerializationTyping(Annotated a) |
|
Object |
AnnotationIntrospectorPair.findSerializer(Annotated am) |
|
Object |
JacksonAnnotationIntrospector.findSerializer(Annotated a) |
|
com.fasterxml.jackson.annotation.JsonSetter.Value |
AnnotationIntrospectorPair.findSetterInfo(Annotated a) |
|
com.fasterxml.jackson.annotation.JsonSetter.Value |
JacksonAnnotationIntrospector.findSetterInfo(Annotated a) |
|
List<NamedType> |
AnnotationIntrospectorPair.findSubtypes(Annotated a) |
|
List<NamedType> |
JacksonAnnotationIntrospector.findSubtypes(Annotated a) |
|
Class<?>[] |
AnnotationIntrospectorPair.findViews(Annotated a) |
|
Class<?>[] |
JacksonAnnotationIntrospector.findViews(Annotated a) |
|
PropertyName |
AnnotationIntrospectorPair.findWrapperName(Annotated ann) |
|
Boolean |
AnnotationIntrospectorPair.hasAnyGetter(Annotated a) |
|
Boolean |
JacksonAnnotationIntrospector.hasAnyGetter(Annotated a) |
|
Boolean |
AnnotationIntrospectorPair.hasAnySetter(Annotated a) |
|
Boolean |
JacksonAnnotationIntrospector.hasAnySetter(Annotated a) |
|
Boolean |
AnnotationIntrospectorPair.hasAsValue(Annotated a) |
|
Boolean |
JacksonAnnotationIntrospector.hasAsValue(Annotated a) |
|
boolean |
AnnotationIntrospectorPair.hasCreatorAnnotation(Annotated a) |
Deprecated.
|
boolean |
JacksonAnnotationIntrospector.hasCreatorAnnotation(Annotated a) |
Deprecated.
|
JavaType |
AnnotationIntrospectorPair.refineDeserializationType(MapperConfig<?> config,
Annotated a,
JavaType baseType) |
|
JavaType |
JacksonAnnotationIntrospector.refineDeserializationType(MapperConfig<?> config,
Annotated a,
JavaType baseType) |
|
JavaType |
AnnotationIntrospectorPair.refineSerializationType(MapperConfig<?> config,
Annotated a,
JavaType baseType) |
|
JavaType |
JacksonAnnotationIntrospector.refineSerializationType(MapperConfig<?> config,
Annotated a,
JavaType baseType) |
Modifier and Type | Method | 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–2018. All rights reserved.