## Uses of Class
com.fasterxml.jackson.databind.introspect.AnnotatedClass

- Packages that use AnnotatedClass
  Package | Description
  --- | ---
  com.fasterxml.jackson.databind | Basic data binding (mapping) functionality that allows for reading JSON content into Java Objects (POJOs) and JSON Trees (`JsonNode`), as well as writing Java Objects and trees as JSON.
  com.fasterxml.jackson.databind.cfg | Package that contains most of configuration-related classes; exception being couple of most-commonly used configuration things (like Feature enumerations) that are at the main level (`com.fasterxml.jackson.databind`).
  com.fasterxml.jackson.databind.introspect | Functionality needed for Bean introspection, required for detecting accessors and mutators for Beans, as well as locating and handling method annotations.
  com.fasterxml.jackson.databind.jsontype | Package that contains interfaces that define how to implement functionality for dynamically resolving type during deserialization.
  com.fasterxml.jackson.databind.jsontype.impl | Package that contains standard implementations for `TypeResolverBuilder` and `TypeIdResolver`.
  com.fasterxml.jackson.databind.ser | Contains implementation classes of serialization part of data binding.
  com.fasterxml.jackson.databind.ser.impl | Contains implementation classes of serialization part of data binding.

- - ### Uses of AnnotatedClass in com.fasterxml.jackson.databind

    Methods in com.fasterxml.jackson.databind that return AnnotatedClass
    Modifier and Type | Method and Description
    --- | ---
    `abstract AnnotatedClass` | BeanDescription.`getClassInfo()` Method for accessing low-level information about Class this item describes.

    Methods in com.fasterxml.jackson.databind with parameters of type AnnotatedClass
    Modifier and Type | Method and Description
    --- | ---
    `void` | AnnotationIntrospector.`findAndAddVirtualProperties(MapperConfig<?> config, AnnotatedClass ac, List<BeanPropertyWriter> properties)` Method for adding possible virtual properties to be serialized along with regular properties.
    `VisibilityChecker<?>` | AnnotationIntrospector.`findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker)` Method for checking if annotations indicate changes to minimum visibility levels needed for auto-detecting property elements (fields, methods, constructors).
    `String` | AnnotationIntrospector.`findClassDescription(AnnotatedClass ac)` Method used to check whether specified class defines a human-readable description to use for documentation.
    `Boolean` | AnnotationIntrospector.`findIgnoreUnknownProperties(AnnotatedClass ac)` Deprecated. Since 2.8, use `AnnotationIntrospector.findPropertyIgnoralByName(com.fasterxml.jackson.databind.cfg.MapperConfig<?>, com.fasterxml.jackson.databind.introspect.Annotated)` instead
    `Object` | AnnotationIntrospector.`findNamingStrategy(AnnotatedClass ac)` Method for finding `PropertyNamingStrategy` for given class, if any specified by annotations; and if so, either return a `PropertyNamingStrategy` instance, or Class to use for creating instance
    `Class<?>` | AnnotationIntrospector.`findPOJOBuilder(AnnotatedClass ac)` Method for finding Builder object to use for constructing value instance and binding data (sort of combining value instantiators that can construct, and deserializers that can bind data).
    `JsonPOJOBuilder.Value` | AnnotationIntrospector.`findPOJOBuilderConfig(AnnotatedClass ac)`
    `PropertyName` | AnnotationIntrospector.`findRootName(AnnotatedClass ac)` Method for locating name used as "root name" (for use by some serializers when outputting root-level object -- mostly for XML compatibility purposes) for given class, if one is defined.
    `String[]` | AnnotationIntrospector.`findSerializationPropertyOrder(AnnotatedClass ac)` Method for accessing defined property serialization order (which may be partial).
    `String` | AnnotationIntrospector.`findTypeName(AnnotatedClass ac)` Method for checking if specified type has explicit name.
    `TypeResolverBuilder<?>` | AnnotationIntrospector.`findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType)` Method for checking if given class has annotations that indicate that specific type resolver is to be used for handling instances.
    `Object` | AnnotationIntrospector.`findValueInstantiator(AnnotatedClass ac)` Method getting `ValueInstantiator` to use for given type (class): return value can either be an instance of instantiator, or class of instantiator to create.
    `Boolean` | AnnotationIntrospector.`isIgnorableType(AnnotatedClass ac)` Method for checking whether properties that have specified type (class, not generics aware) should be completely ignored for serialization and deserialization purposes.

  - ### Uses of AnnotatedClass in com.fasterxml.jackson.databind.cfg

    Methods in com.fasterxml.jackson.databind.cfg with parameters of type AnnotatedClass
    Modifier and Type | Method and Description
    --- | ---
    `abstract JsonIgnoreProperties.Value` | MapperConfig.`getDefaultPropertyIgnorals(Class<?> baseType, AnnotatedClass actualClass)` Helper method that may be called to see if there are property ignoral definitions from annotations (via `AnnotatedClass`) or through "config overrides".
    `JsonIgnoreProperties.Value` | MapperConfigBase.`getDefaultPropertyIgnorals(Class<?> baseType, AnnotatedClass actualClass)`
    `abstract JsonIncludeProperties.Value` | MapperConfig.`getDefaultPropertyInclusions(Class<?> baseType, AnnotatedClass actualClass)` Helper method that may be called to see if there are property inclusion definitions from annotations (via `AnnotatedClass`).
    `JsonIncludeProperties.Value` | MapperConfigBase.`getDefaultPropertyInclusions(Class<?> baseType, AnnotatedClass actualClass)`
    `abstract VisibilityChecker<?>` | MapperConfig.`getDefaultVisibilityChecker(Class<?> baseType, AnnotatedClass actualClass)` Accessor for object used for determining whether specific property elements (method, constructors, fields) can be auto-detected based on their visibility (access modifiers).
    `VisibilityChecker<?>` | MapperConfigBase.`getDefaultVisibilityChecker(Class<?> baseType, AnnotatedClass actualClass)`

  - ### Uses of AnnotatedClass in com.fasterxml.jackson.databind.introspect

    Fields in com.fasterxml.jackson.databind.introspect declared as AnnotatedClass
    Modifier and Type | Field and Description
    --- | ---
    `protected AnnotatedClass` | POJOPropertiesCollector.`_classDef` Low-level introspected class information (methods, fields etc)
    `protected AnnotatedClass` | BasicBeanDescription.`_classInfo` Information collected about the class introspected.
    `protected AnnotatedClass` | DefaultAccessorNamingStrategy.`_forClass`

    Methods in com.fasterxml.jackson.databind.introspect that return AnnotatedClass
    Modifier and Type | Method and Description
    --- | ---
    `protected AnnotatedClass` | BasicClassIntrospector.`_resolveAnnotatedClass(MapperConfig<?> config, JavaType type, ClassIntrospector.MixInResolver r)`
    `protected AnnotatedClass` | BasicClassIntrospector.`_resolveAnnotatedWithoutSuperTypes(MapperConfig<?> config, JavaType type, ClassIntrospector.MixInResolver r)`
    `static AnnotatedClass` | AnnotatedClass.`construct(JavaType type, MapperConfig<?> config)` Deprecated. Since 2.9, use methods in `AnnotatedClassResolver` instead.
    `static AnnotatedClass` | AnnotatedClass.`construct(JavaType type, MapperConfig<?> config, ClassIntrospector.MixInResolver mir)` Deprecated. Since 2.9, use methods in `AnnotatedClassResolver` instead.
    `static AnnotatedClass` | AnnotatedClass.`constructWithoutSuperTypes(Class<?> raw, MapperConfig<?> config)` Deprecated. Since 2.9, use methods in `AnnotatedClassResolver` instead.
    `static AnnotatedClass` | AnnotatedClass.`constructWithoutSuperTypes(Class<?> raw, MapperConfig<?> config, ClassIntrospector.MixInResolver mir)` Deprecated. Since 2.9, use methods in `AnnotatedClassResolver` instead.
    `AnnotatedClass` | POJOPropertiesCollector.`getClassDef()`
    `AnnotatedClass` | BasicBeanDescription.`getClassInfo()`
    `static AnnotatedClass` | AnnotatedClassResolver.`resolve(MapperConfig<?> config, JavaType forType, ClassIntrospector.MixInResolver r)`
    `static AnnotatedClass` | AnnotatedClassResolver.`resolveWithoutSuperTypes(MapperConfig<?> config, Class<?> forType)`
    `static AnnotatedClass` | AnnotatedClassResolver.`resolveWithoutSuperTypes(MapperConfig<?> config, Class<?> forType, ClassIntrospector.MixInResolver r)`
    `static AnnotatedClass` | AnnotatedClassResolver.`resolveWithoutSuperTypes(MapperConfig<?> config, JavaType forType, ClassIntrospector.MixInResolver r)`

    Methods in com.fasterxml.jackson.databind.introspect with parameters of type AnnotatedClass
    Modifier and Type | Method and Description
    --- | ---
    `protected BeanPropertyWriter` | JacksonAnnotationIntrospector.`_constructVirtualProperty(JsonAppend.Attr attr, MapperConfig<?> config, AnnotatedClass ac, JavaType type)`
    `protected BeanPropertyWriter` | JacksonAnnotationIntrospector.`_constructVirtualProperty(JsonAppend.Prop prop, MapperConfig<?> config, AnnotatedClass ac)`
    `protected POJOPropertiesCollector` | BasicClassIntrospector.`constructPropertyCollector(MapperConfig<?> config, AnnotatedClass classDef, JavaType type, boolean forSerialization, AccessorNamingStrategy accNaming)`
    `void` | JacksonAnnotationIntrospector.`findAndAddVirtualProperties(MapperConfig<?> config, AnnotatedClass ac, List<BeanPropertyWriter> properties)`
    `void` | AnnotationIntrospectorPair.`findAndAddVirtualProperties(MapperConfig<?> config, AnnotatedClass ac, List<BeanPropertyWriter> properties)`
    `VisibilityChecker<?>` | JacksonAnnotationIntrospector.`findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker)`
    `VisibilityChecker<?>` | AnnotationIntrospectorPair.`findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker)`
    `String` | JacksonAnnotationIntrospector.`findClassDescription(AnnotatedClass ac)`
    `String` | AnnotationIntrospectorPair.`findClassDescription(AnnotatedClass ac)`
    `Boolean` | AnnotationIntrospectorPair.`findIgnoreUnknownProperties(AnnotatedClass ac)` Deprecated.
    `Object` | JacksonAnnotationIntrospector.`findNamingStrategy(AnnotatedClass ac)`
    `Object` | AnnotationIntrospectorPair.`findNamingStrategy(AnnotatedClass ac)`
    `Class<?>` | JacksonAnnotationIntrospector.`findPOJOBuilder(AnnotatedClass ac)`
    `Class<?>` | AnnotationIntrospectorPair.`findPOJOBuilder(AnnotatedClass ac)`
    `JsonPOJOBuilder.Value` | JacksonAnnotationIntrospector.`findPOJOBuilderConfig(AnnotatedClass ac)`
    `JsonPOJOBuilder.Value` | AnnotationIntrospectorPair.`findPOJOBuilderConfig(AnnotatedClass ac)`
    `PropertyName` | JacksonAnnotationIntrospector.`findRootName(AnnotatedClass ac)`
    `PropertyName` | AnnotationIntrospectorPair.`findRootName(AnnotatedClass ac)`
    `String[]` | JacksonAnnotationIntrospector.`findSerializationPropertyOrder(AnnotatedClass ac)`
    `String[]` | AnnotationIntrospectorPair.`findSerializationPropertyOrder(AnnotatedClass ac)`
    `String` | JacksonAnnotationIntrospector.`findTypeName(AnnotatedClass ac)`
    `String` | AnnotationIntrospectorPair.`findTypeName(AnnotatedClass ac)`
    `TypeResolverBuilder<?>` | JacksonAnnotationIntrospector.`findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType)`
    `TypeResolverBuilder<?>` | AnnotationIntrospectorPair.`findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType)`
    `Object` | JacksonAnnotationIntrospector.`findValueInstantiator(AnnotatedClass ac)`
    `Object` | AnnotationIntrospectorPair.`findValueInstantiator(AnnotatedClass ac)`
    `abstract AccessorNamingStrategy` | AccessorNamingStrategy.Provider.`forBuilder(MapperConfig<?> config, AnnotatedClass builderClass, BeanDescription valueTypeDesc)` Factory method for creating strategy instance for POJOs that are deserialized using Builder type: in this case eventual target (value) type is different from type of "builder" object that is used by databinding to accumulate state.
    `AccessorNamingStrategy` | DefaultAccessorNamingStrategy.Provider.`forBuilder(MapperConfig<?> config, AnnotatedClass builderClass, BeanDescription valueTypeDesc)`
    `static BasicBeanDescription` | BasicBeanDescription.`forOtherUse(MapperConfig<?> config, JavaType type, AnnotatedClass ac)` Factory method to use for constructing an instance to use for purposes other than building serializers or deserializers; will only have information on class, not on properties.
    `abstract AccessorNamingStrategy` | AccessorNamingStrategy.Provider.`forPOJO(MapperConfig<?> config, AnnotatedClass valueClass)` Factory method for creating strategy instance for a "regular" POJO, called if none of the other factory methods is applicable.
    `AccessorNamingStrategy` | DefaultAccessorNamingStrategy.Provider.`forPOJO(MapperConfig<?> config, AnnotatedClass targetClass)`
    `abstract AccessorNamingStrategy` | AccessorNamingStrategy.Provider.`forRecord(MapperConfig<?> config, AnnotatedClass recordClass)` Factory method for creating strategy instance for special `java.lang.Record` type (new in JDK 14).
    `AccessorNamingStrategy` | DefaultAccessorNamingStrategy.Provider.`forRecord(MapperConfig<?> config, AnnotatedClass recordClass)`
    `Boolean` | JacksonAnnotationIntrospector.`isIgnorableType(AnnotatedClass ac)`
    `Boolean` | AnnotationIntrospectorPair.`isIgnorableType(AnnotatedClass ac)`

    Constructors in com.fasterxml.jackson.databind.introspect with parameters of type AnnotatedClass
    Constructor and Description
    `BasicBeanDescription(MapperConfig<?> config, JavaType type, AnnotatedClass classDef, List<BeanPropertyDefinition> props)` Alternate constructor used in cases where property information is not needed, only class info.
    `BasicBeanDescription(POJOPropertiesCollector coll, JavaType type, AnnotatedClass classDef)`
    `DefaultAccessorNamingStrategy(MapperConfig<?> config, AnnotatedClass forClass, String mutatorPrefix, String getterPrefix, String isGetterPrefix, DefaultAccessorNamingStrategy.BaseNameValidator baseNameValidator)`
    `POJOPropertiesCollector(MapperConfig<?> config, boolean forSerialization, JavaType type, AnnotatedClass classDef, AccessorNamingStrategy accessorNaming)`
    `RecordNaming(MapperConfig<?> config, AnnotatedClass forClass)`

  - ### Uses of AnnotatedClass in com.fasterxml.jackson.databind.jsontype

    Methods in com.fasterxml.jackson.databind.jsontype with parameters of type AnnotatedClass
    Modifier and Type | Method and Description
    --- | ---
    `Collection<NamedType>` | SubtypeResolver.`collectAndResolveSubtypes(AnnotatedClass baseType, MapperConfig<?> config, AnnotationIntrospector ai)` Deprecated. Since 2.6 Use either `SubtypeResolver.collectAndResolveSubtypesByClass(MapperConfig, AnnotatedClass)` or `SubtypeResolver.collectAndResolveSubtypesByTypeId(MapperConfig, AnnotatedClass)` instead.
    `Collection<NamedType>` | SubtypeResolver.`collectAndResolveSubtypesByClass(MapperConfig<?> config, AnnotatedClass baseType)` Method for finding out all reachable subtypes for given type, such that access is by type, typically needed for serialization (converting from type to type name).
    `Collection<NamedType>` | SubtypeResolver.`collectAndResolveSubtypesByTypeId(MapperConfig<?> config, AnnotatedClass baseType)` Method for finding out all reachable subtypes for given type, such that access is by type id, typically needed for deserialization (converting from type id to type).

  - ### Uses of AnnotatedClass in com.fasterxml.jackson.databind.jsontype.impl

    Methods in com.fasterxml.jackson.databind.jsontype.impl with parameters of type AnnotatedClass
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | StdSubtypeResolver.`_collectAndResolve(AnnotatedClass annotatedType, NamedType namedType, MapperConfig<?> config, AnnotationIntrospector ai, HashMap<NamedType,NamedType> collectedSubtypes)` Method called to find subtypes for a specific type (class), using type (class) as the unique key (in case of conflicts).
    `protected void` | StdSubtypeResolver.`_collectAndResolveByTypeId(AnnotatedClass annotatedType, NamedType namedType, MapperConfig<?> config, Set<Class<?>> typesHandled, Map<String,NamedType> byName)` Method called to find subtypes for a specific type (class), using type id as the unique key (in case of conflicts).
    `Collection<NamedType>` | StdSubtypeResolver.`collectAndResolveSubtypesByClass(MapperConfig<?> config, AnnotatedClass type)`
    `Collection<NamedType>` | StdSubtypeResolver.`collectAndResolveSubtypesByTypeId(MapperConfig<?> config, AnnotatedClass baseType)`

  - ### Uses of AnnotatedClass in com.fasterxml.jackson.databind.ser

    Methods in com.fasterxml.jackson.databind.ser that return AnnotatedClass
    Modifier and Type | Method and Description
    --- | ---
    `AnnotatedClass` | BeanSerializerBuilder.`getClassInfo()`

    Methods in com.fasterxml.jackson.databind.ser with parameters of type AnnotatedClass
    Modifier and Type | Method and Description
    --- | ---
    `abstract VirtualBeanPropertyWriter` | VirtualBeanPropertyWriter.`withConfig(MapperConfig<?> config, AnnotatedClass declaringClass, BeanPropertyDefinition propDef, JavaType type)` Contextualization method called on a newly constructed virtual bean property.

  - ### Uses of AnnotatedClass in com.fasterxml.jackson.databind.ser.impl

    Methods in com.fasterxml.jackson.databind.ser.impl with parameters of type AnnotatedClass
    Modifier and Type | Method and Description
    --- | ---
    `VirtualBeanPropertyWriter` | AttributePropertyWriter.`withConfig(MapperConfig<?> config, AnnotatedClass declaringClass, BeanPropertyDefinition propDef, JavaType type)` Since this method should typically not be called on this sub-type, default implementation simply throws an `IllegalStateException`.

Copyright © 2008–2020 FasterXML. All rights reserved.