Uses of Class
com.fasterxml.jackson.databind.introspect.Annotated

Packages that use Annotated

Package	Description
com.fasterxml.jackson.databind	Contains basic mapper (conversion) functionality that allows for converting between regular streaming json content and Java objects (beans or Tree Model: support for both is via ObjectMapper class, as well as convenience methods included in JsonParser
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.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.
com.fasterxml.jackson.module.jaxb	Package that contains support for using JAXB annotations for configuring Jackson data-binding aspects.

Uses of Annotated in com.fasterxml.jackson.databind

Methods in com.fasterxml.jackson.databind with parameters of type Annotated

Modifier and Type	Method and Description
protected <A extends Annotation> A	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.
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.findCreatorBinding(Annotated a) Method for finding indication of creator binding mode for a creator (something for which AnnotationIntrospector.hasCreatorAnnotation(com.fasterxml.jackson.databind.introspect.Annotated) returns true), for cases where there may be ambiguity (currently: single-argument creator with implicit but no explicit name for the argument).
Class<?>	AnnotationIntrospector.findDeserializationContentType(Annotated am, JavaType baseContentType) Method for accessing additional narrowing type definition that a method can have, to define more specific content type to use; content refers to Map values and Collection/array elements.
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) Method for accessing additional narrowing type definition that a method can have, to define more specific key type to use.
Class<?>	AnnotationIntrospector.findDeserializationType(Annotated am, JavaType baseType) Method for accessing annotated type definition that a method can have, to be used as the type for serialization instead of the runtime type.
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 Map property.
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) Method for finding list of properties to ignore for given class (null is returned if not specified).
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.
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) Method for finding possible widening type definition that a property value can have, to define less specific key type to use for serialization.
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) Method for checking whether given annotated entity (class, method, field) defines which Bean/Map properties are to be included in serialization.
JsonInclude.Include	AnnotationIntrospector.findSerializationInclusionForContent(Annotated a, JsonInclude.Include defValue) Method for checking whether content (entries) of a Map property are to be included during serialization or not.
Class<?>	AnnotationIntrospector.findSerializationKeyType(Annotated am, JavaType baseType) Method for finding possible widening type definition that a property value can have, to define less specific key type to use for serialization.
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) Method for accessing annotated type definition that a method/field can have, to be used as the type for serialization instead of the runtime type.
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.
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.hasCreatorAnnotation(Annotated a) Method for checking whether given annotated item (method, constructor) has an annotation that suggests that the method is a "creator" (aka factory) method to be used for construct new instances of deserialized values.
abstract KeyDeserializer	DeserializationContext.keyDeserializerInstance(Annotated annotated, Object deserDef)
ObjectIdGenerator<?>	DatabindContext.objectIdGeneratorInstance(Annotated annotated, ObjectIdInfo objectIdInfo)
ObjectIdResolver	DatabindContext.objectIdResolverInstance(Annotated annotated, ObjectIdInfo objectIdInfo)
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.

Uses of Annotated in com.fasterxml.jackson.databind.cfg

Methods in com.fasterxml.jackson.databind.cfg with parameters of type Annotated

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.

Uses of Annotated in com.fasterxml.jackson.databind.deser

Methods in com.fasterxml.jackson.databind.deser with parameters of type Annotated

Modifier and Type	Method and Description
ValueInstantiator	BasicDeserializerFactory._valueInstantiatorInstance(DeserializationConfig config, Annotated annotated, Object instDef)
JsonDeserializer<Object>	DefaultDeserializationContext.deserializerInstance(Annotated ann, Object deserDef)
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.
KeyDeserializer	DefaultDeserializationContext.keyDeserializerInstance(Annotated ann, Object deserDef)
protected <T extends JavaType> T	BasicDeserializerFactory.modifyTypeByAnnotation(DeserializationContext ctxt, Annotated a, T type) Method called to see if given method has annotations that indicate a more specific type than what the argument specifies.

Uses of Annotated in com.fasterxml.jackson.databind.introspect

Subclasses of Annotated in com.fasterxml.jackson.databind.introspect

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.

Methods in com.fasterxml.jackson.databind.introspect that return Annotated

Modifier and Type	Method and Description
Annotated	VirtualAnnotatedMember.withAnnotations(AnnotationMap fallback)
abstract Annotated	Annotated.withAnnotations(AnnotationMap fallback) Fluent factory method that will construct a new instance that uses specified instance annotations instead of currently configured ones.
Annotated	Annotated.withFallBackAnnotationsFrom(Annotated annotated) Fluent factory method that will construct a new instance that uses annotations from specified Annotated as fallback annotations

Methods in com.fasterxml.jackson.databind.introspect with parameters of type Annotated

Modifier and Type	Method and Description
protected Object	JacksonAnnotationIntrospector._findFilterId(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)
Class<? extends JsonDeserializer<?>>	JacksonAnnotationIntrospector.findContentDeserializer(Annotated a)
Object	AnnotationIntrospectorPair.findContentDeserializer(Annotated am)
Class<? extends JsonSerializer<?>>	JacksonAnnotationIntrospector.findContentSerializer(Annotated a)
Object	AnnotationIntrospectorPair.findContentSerializer(Annotated a)
JsonCreator.Mode	JacksonAnnotationIntrospector.findCreatorBinding(Annotated a)
JsonCreator.Mode	AnnotationIntrospectorPair.findCreatorBinding(Annotated a)
Class<?>	JacksonAnnotationIntrospector.findDeserializationContentType(Annotated am, JavaType baseContentType)
Class<?>	AnnotationIntrospectorPair.findDeserializationContentType(Annotated am, JavaType baseContentType)
Object	JacksonAnnotationIntrospector.findDeserializationConverter(Annotated a)
Object	AnnotationIntrospectorPair.findDeserializationConverter(Annotated a)
Class<?>	JacksonAnnotationIntrospector.findDeserializationKeyType(Annotated am, JavaType baseKeyType)
Class<?>	AnnotationIntrospectorPair.findDeserializationKeyType(Annotated am, JavaType baseKeyType)
Class<?>	JacksonAnnotationIntrospector.findDeserializationType(Annotated am, JavaType baseType)
Class<?>	AnnotationIntrospectorPair.findDeserializationType(Annotated am, JavaType baseType)
Class<? extends JsonDeserializer<?>>	JacksonAnnotationIntrospector.findDeserializer(Annotated a)
Object	AnnotationIntrospectorPair.findDeserializer(Annotated am)
Object	JacksonAnnotationIntrospector.findFilterId(Annotated a)
Object	AnnotationIntrospectorPair.findFilterId(Annotated ann)
JsonFormat.Value	JacksonAnnotationIntrospector.findFormat(Annotated ann)
JsonFormat.Value	AnnotationIntrospectorPair.findFormat(Annotated ann)
Class<? extends KeyDeserializer>	JacksonAnnotationIntrospector.findKeyDeserializer(Annotated a)
Object	AnnotationIntrospectorPair.findKeyDeserializer(Annotated am)
Class<? extends JsonSerializer<?>>	JacksonAnnotationIntrospector.findKeySerializer(Annotated a)
Object	AnnotationIntrospectorPair.findKeySerializer(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[]	JacksonAnnotationIntrospector.findPropertiesToIgnore(Annotated ac)
String[]	AnnotationIntrospectorPair.findPropertiesToIgnore(Annotated ac)
String	JacksonAnnotationIntrospector.findPropertyDefaultValue(Annotated ann)
String	AnnotationIntrospectorPair.findPropertyDefaultValue(Annotated ann)
String	JacksonAnnotationIntrospector.findPropertyDescription(Annotated ann)
String	AnnotationIntrospectorPair.findPropertyDescription(Annotated ann)
Integer	JacksonAnnotationIntrospector.findPropertyIndex(Annotated ann)
Integer	AnnotationIntrospectorPair.findPropertyIndex(Annotated ann)
Class<?>	JacksonAnnotationIntrospector.findSerializationContentType(Annotated am, JavaType baseType)
Class<?>	AnnotationIntrospectorPair.findSerializationContentType(Annotated am, JavaType baseType)
Object	JacksonAnnotationIntrospector.findSerializationConverter(Annotated a)
Object	AnnotationIntrospectorPair.findSerializationConverter(Annotated a)
JsonInclude.Include	JacksonAnnotationIntrospector.findSerializationInclusion(Annotated a, JsonInclude.Include defValue)
JsonInclude.Include	AnnotationIntrospectorPair.findSerializationInclusion(Annotated a, JsonInclude.Include defValue)
JsonInclude.Include	JacksonAnnotationIntrospector.findSerializationInclusionForContent(Annotated a, JsonInclude.Include defValue)
JsonInclude.Include	AnnotationIntrospectorPair.findSerializationInclusionForContent(Annotated a, JsonInclude.Include defValue)
Class<?>	JacksonAnnotationIntrospector.findSerializationKeyType(Annotated am, JavaType baseType)
Class<?>	AnnotationIntrospectorPair.findSerializationKeyType(Annotated am, JavaType baseType)
Boolean	JacksonAnnotationIntrospector.findSerializationSortAlphabetically(Annotated ann)
Boolean	AnnotationIntrospectorPair.findSerializationSortAlphabetically(Annotated ann)
Class<?>	JacksonAnnotationIntrospector.findSerializationType(Annotated am)
Class<?>	AnnotationIntrospectorPair.findSerializationType(Annotated a)
JsonSerialize.Typing	JacksonAnnotationIntrospector.findSerializationTyping(Annotated a)
JsonSerialize.Typing	AnnotationIntrospectorPair.findSerializationTyping(Annotated a)
Object	JacksonAnnotationIntrospector.findSerializer(Annotated a)
Object	AnnotationIntrospectorPair.findSerializer(Annotated am)
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.hasCreatorAnnotation(Annotated a)
boolean	AnnotationIntrospectorPair.hasCreatorAnnotation(Annotated a)
Annotated	Annotated.withFallBackAnnotationsFrom(Annotated annotated) Fluent factory method that will construct a new instance that uses annotations from specified Annotated as fallback annotations

Uses of Annotated in com.fasterxml.jackson.databind.ser

Methods in com.fasterxml.jackson.databind.ser with parameters of type Annotated

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.
protected static <T extends JavaType> T	BasicSerializerFactory.modifySecondaryTypesByAnnotation(SerializationConfig config, Annotated a, T type)
protected <T extends JavaType> T	BasicSerializerFactory.modifyTypeByAnnotation(SerializationConfig config, Annotated a, T type) Helper method used to encapsulate details of annotation-based type coercion
JsonSerializer<Object>	DefaultSerializerProvider.serializerInstance(Annotated annotated, Object serDef)

Uses of Annotated in com.fasterxml.jackson.module.jaxb

Methods in com.fasterxml.jackson.module.jaxb with parameters of type Annotated

Modifier and Type	Method and Description
protected Class<?>	JaxbAnnotationIntrospector._doFindDeserializationType(Annotated a, JavaType baseType)
protected XmlAdapter<?,?>	JaxbAnnotationIntrospector._findContentAdapter(Annotated ann, boolean forSerialization)
protected Class<?>	JaxbAnnotationIntrospector._rawDeserializationType(Annotated a)
protected Class<?>	JaxbAnnotationIntrospector._rawSerializationType(Annotated a)
protected XmlAccessType	JaxbAnnotationIntrospector.findAccessType(Annotated ac) Method for locating JAXB XmlAccessType annotation value for given annotated entity, if it has one, or inherits one from its ancestors (in JAXB sense, package etc).
Object	JaxbAnnotationIntrospector.findContentDeserializer(Annotated a)
Object	JaxbAnnotationIntrospector.findContentSerializer(Annotated a)
Class<?>	JaxbAnnotationIntrospector.findDeserializationContentType(Annotated a, JavaType baseContentType)
Object	JaxbAnnotationIntrospector.findDeserializationConverter(Annotated a)
Class<?>	JaxbAnnotationIntrospector.findDeserializationType(Annotated a, JavaType baseType) JAXB does allow specifying (more) concrete class for deserialization by using \@XmlElement annotation.
Object	JaxbAnnotationIntrospector.findDeserializer(Annotated am)
JsonFormat.Value	JaxbAnnotationIntrospector.findFormat(Annotated m)
Object	JaxbAnnotationIntrospector.findKeyDeserializer(Annotated am)
PropertyName	JaxbAnnotationIntrospector.findNameForDeserialization(Annotated a)
PropertyName	JaxbAnnotationIntrospector.findNameForSerialization(Annotated a)
String	JaxbAnnotationIntrospector.findNamespace(Annotated ann)
ObjectIdInfo	JaxbAnnotationIntrospector.findObjectIdInfo(Annotated ann)
ObjectIdInfo	JaxbAnnotationIntrospector.findObjectReferenceInfo(Annotated ann, ObjectIdInfo base)
Object	JaxbAnnotationIntrospector.findSerializationConverter(Annotated a)
JsonInclude.Include	JaxbAnnotationIntrospector.findSerializationInclusion(Annotated a, JsonInclude.Include defValue) Implementation of this method is slightly tricky, given that JAXB defaults differ from Jackson defaults.
Boolean	JaxbAnnotationIntrospector.findSerializationSortAlphabetically(Annotated ann)
Class<?>	JaxbAnnotationIntrospector.findSerializationType(Annotated a)
JsonSerializer<?>	JaxbAnnotationIntrospector.findSerializer(Annotated am)
List<NamedType>	JaxbAnnotationIntrospector.findSubtypes(Annotated a)
PropertyName	JaxbAnnotationIntrospector.findWrapperName(Annotated ann)
boolean	JaxbAnnotationIntrospector.hasCreatorAnnotation(Annotated am)
Boolean	JaxbAnnotationIntrospector.isOutputAsAttribute(Annotated ann) Here we assume fairly simple logic; if there is XmlAttribute to be found, we consider it an attribute; if XmlElement, not-an-attribute; and otherwise we will consider there to be no information.
Boolean	JaxbAnnotationIntrospector.isOutputAsText(Annotated ann)