## 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.

- - ### 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
    --- | ---
    `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.
    `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.
    `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.
    `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).
    `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.
    `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.
    `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)`
    `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.
    `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 annotated, 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 annotated, 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.

    Methods in com.fasterxml.jackson.databind.introspect that return Annotated
    Modifier and Type | Method and Description
    --- | ---
    `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 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)`
    `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)`
    `JsonFormat.Value` | JacksonAnnotationIntrospector.`findFormat(Annotated annotated)`
    `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)`
    `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)`
    `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)`
    `Class<?>` | JacksonAnnotationIntrospector.`findSerializationKeyType(Annotated am, JavaType baseType)`
    `Class<?>` | AnnotationIntrospectorPair.`findSerializationKeyType(Annotated am, JavaType baseType)`
    `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)`

Copyright © 2012-2013 FasterXML. All Rights Reserved.