com.fasterxml.jackson.databind.introspect

Class AnnotatedClass

java.lang.Object

com.fasterxml.jackson.databind.introspect.Annotated

com.fasterxml.jackson.databind.introspect.AnnotatedClass

All Implemented Interfaces:

TypeResolutionContext

public final class AnnotatedClass
extends Annotated
implements TypeResolutionContext

Nested Class Summary

Nested classes/interfaces inherited from interface com.fasterxml.jackson.databind.introspect.TypeResolutionContext

TypeResolutionContext.Basic

Field Summary

Fields

Modifier and Type	Field and Description
protected AnnotationIntrospector	_annotationIntrospector Filter used to determine which annotations to gather; used to optimize things so that unnecessary annotations are ignored.
protected TypeBindings	_bindings Type bindings to use for members of _class.
protected Class<?>	_class Class for which annotations apply, and that owns other components (constructors, methods)
protected AnnotationMap	_classAnnotations Combined list of Jackson annotations that the class has, including inheritable ones from super classes and interfaces
protected List<AnnotatedConstructor>	_constructors Single argument constructors the class has, if any.
protected List<AnnotatedMethod>	_creatorMethods Single argument static methods that might be usable as factory methods
protected boolean	_creatorsResolved Flag to indicate whether creator information has been resolved or not.
protected AnnotatedConstructor	_defaultConstructor Default constructor of the annotated class, if it has one.
protected List<AnnotatedField>	_fields Member fields of interest: ones that are either public, or have at least one annotation.
protected AnnotatedMethodMap	_memberMethods Member methods of interest; for now ones with 0 or 1 arguments (just optimization, since others won't be used now)
protected ClassIntrospector.MixInResolver	_mixInResolver Object that knows mapping of mix-in classes (ones that contain annotations to add) with their target classes (ones that get these additional annotations "mixed in").
protected Class<?>	_primaryMixIn Primary mix-in class; one to use for the annotated class itself.
protected List<JavaType>	_superTypes Ordered set of super classes and interfaces of the class itself: included in order of precedence
protected JavaType	_type
protected TypeFactory	_typeFactory

Method Summary

Modifier and Type	Method and Description
protected void	_addClassMixIns(AnnotationMap annotations, Class<?> target)
protected void	_addClassMixIns(AnnotationMap annotations, Class<?> toMask, Class<?> mixin)
protected void	_addClassMixIns(AnnotationMap annotations, JavaType target) Helper method for adding any mix-in annotations specified class might have.
protected void	_addConstructorMixIns(Class<?> mixin)
protected void	_addFactoryMixIns(Class<?> mixin)
protected void	_addFieldMixIns(Class<?> mixInCls, Class<?> targetClass, Map<String,AnnotatedField> fields) Method called to add field mix-ins from given mix-in class (and its fields) into already collected actual fields (from introspected classes and their super-classes)
protected void	_addMemberMethods(Class<?> cls, TypeResolutionContext typeContext, AnnotatedMethodMap methods, Class<?> mixInCls, AnnotatedMethodMap mixIns)
protected void	_addMethodMixIns(Class<?> targetClass, AnnotatedMethodMap methods, Class<?> mixInCls, AnnotatedMethodMap mixIns)
protected void	_addMixOvers(Constructor<?> mixin, AnnotatedConstructor target, boolean addParamAnnotations)
protected void	_addMixOvers(Method mixin, AnnotatedMethod target, boolean addParamAnnotations)
protected void	_addMixUnders(Method src, AnnotatedMethod target) Method that will add annotations from specified source method to target method, but only if target does not yet have them.
protected AnnotationMap	_collectRelevantAnnotations(Annotation[] anns)
protected AnnotationMap[]	_collectRelevantAnnotations(Annotation[][] anns)
protected AnnotatedMethod	_constructCreatorMethod(Method m, TypeResolutionContext typeContext)
protected AnnotatedConstructor	_constructDefaultConstructor(ClassUtil.Ctor ctor, TypeResolutionContext typeContext)
protected AnnotatedField	_constructField(Field f, TypeResolutionContext typeContext)
protected AnnotatedMethod	_constructMethod(Method m, TypeResolutionContext typeContext)
protected AnnotatedConstructor	_constructNonDefaultConstructor(ClassUtil.Ctor ctor, TypeResolutionContext typeContext)
protected Method[]	_findClassMethods(Class<?> cls) Helper method that gets methods declared in given class; usually a simple thing, but sometimes (as per [databind#785]) more complicated, depending on classloader setup.
protected Map<String,AnnotatedField>	_findFields(JavaType type, TypeResolutionContext typeContext, Map<String,AnnotatedField> fields)
protected boolean	_isIncludableMemberMethod(Method m)
Iterable<Annotation>	annotations() Accessor that can be used to iterate over all the annotations associated with annotated component.
static AnnotatedClass	construct(JavaType type, MapperConfig<?> config) Factory method that instantiates an instance.
static AnnotatedClass	construct(JavaType type, MapperConfig<?> config, ClassIntrospector.MixInResolver mir)
static AnnotatedClass	constructWithoutSuperTypes(Class<?> cls, MapperConfig<?> config) Method similar to construct(com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.cfg.MapperConfig<?>), but that will NOT include information from supertypes; only class itself and any direct mix-ins it may have.
static AnnotatedClass	constructWithoutSuperTypes(Class<?> cls, MapperConfig<?> config, ClassIntrospector.MixInResolver mir)
boolean	equals(Object o)
Iterable<AnnotatedField>	fields()
AnnotatedMethod	findMethod(String name, Class<?>[] paramTypes)
protected AnnotationMap	getAllAnnotations() Internal helper method used to access annotation information; not exposed to developers since instances are mutable.
Class<?>	getAnnotated() Method that can be used to find actual JDK element that this instance represents.
<A extends Annotation> A	getAnnotation(Class<A> acls)
Annotations	getAnnotations()
List<AnnotatedConstructor>	getConstructors()
AnnotatedConstructor	getDefaultConstructor()
int	getFieldCount()
int	getMemberMethodCount()
int	getModifiers()
String	getName()
Class<?>	getRawType() "Raw" type (type-erased class) of the annotated element; definition of what exactly this means depends on sub-class.
List<AnnotatedMethod>	getStaticMethods()
JavaType	getType() Full generic type of the annotated element; definition of what exactly this means depends on sub-class.
boolean	hasAnnotation(Class<?> acls)
boolean	hasAnnotations()
int	hashCode()
boolean	hasOneOf(Class<? extends Annotation>[] annoClasses)
Iterable<AnnotatedMethod>	memberMethods()
JavaType	resolveType(Type type)
String	toString()
AnnotatedClass	withAnnotations(AnnotationMap ann) Fluent factory method that will construct a new instance that uses specified instance annotations instead of currently configured ones.

Methods inherited from class com.fasterxml.jackson.databind.introspect.Annotated

getGenericType, getType, isPublic, withFallBackAnnotationsFrom

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

_type

protected final JavaType _type

Since:

2.7

_class

protected final Class<?> _class

Class for which annotations apply, and that owns other components (constructors, methods)

_bindings

protected final TypeBindings _bindings

Type bindings to use for members of _class.

Since:

2.7

_superTypes

protected final List<JavaType> _superTypes

Ordered set of super classes and interfaces of the class itself: included in order of precedence

NOTE: changed in 2.7 from List of Classes to List of JavaTypes.

_annotationIntrospector

protected final AnnotationIntrospector _annotationIntrospector

Filter used to determine which annotations to gather; used to optimize things so that unnecessary annotations are ignored.

_typeFactory

protected final TypeFactory _typeFactory

Since:

2.7

_mixInResolver

protected final ClassIntrospector.MixInResolver _mixInResolver

Object that knows mapping of mix-in classes (ones that contain annotations to add) with their target classes (ones that get these additional annotations "mixed in").

_primaryMixIn

protected final Class<?> _primaryMixIn

Primary mix-in class; one to use for the annotated class itself. Can be null.

_classAnnotations

protected AnnotationMap _classAnnotations

Combined list of Jackson annotations that the class has, including inheritable ones from super classes and interfaces

_creatorsResolved

protected boolean _creatorsResolved

Flag to indicate whether creator information has been resolved or not.

_defaultConstructor

protected AnnotatedConstructor _defaultConstructor

Default constructor of the annotated class, if it has one.

_constructors

protected List<AnnotatedConstructor> _constructors

Single argument constructors the class has, if any.

_creatorMethods

protected List<AnnotatedMethod> _creatorMethods

Single argument static methods that might be usable as factory methods

_memberMethods

protected AnnotatedMethodMap _memberMethods

Member methods of interest; for now ones with 0 or 1 arguments (just optimization, since others won't be used now)

_fields

protected List<AnnotatedField> _fields

Member fields of interest: ones that are either public, or have at least one annotation.

Method Detail

withAnnotations

public AnnotatedClass withAnnotations(AnnotationMap ann)

Description copied from class: Annotated

Fluent factory method that will construct a new instance that uses specified instance annotations instead of currently configured ones.

Specified by:

withAnnotations in class Annotated

construct

public static AnnotatedClass construct(JavaType type,
                                       MapperConfig<?> config)

Factory method that instantiates an instance. Returned instance will only be initialized with class annotations, but not with any method information.

Since:

2.7

construct

public static AnnotatedClass construct(JavaType type,
                                       MapperConfig<?> config,
                                       ClassIntrospector.MixInResolver mir)

Since:

2.7

constructWithoutSuperTypes

public static AnnotatedClass constructWithoutSuperTypes(Class<?> cls,
                                                        MapperConfig<?> config)

Method similar to construct(com.fasterxml.jackson.databind.JavaType, com.fasterxml.jackson.databind.cfg.MapperConfig<?>), but that will NOT include information from supertypes; only class itself and any direct mix-ins it may have.

constructWithoutSuperTypes

public static AnnotatedClass constructWithoutSuperTypes(Class<?> cls,
                                                        MapperConfig<?> config,
                                                        ClassIntrospector.MixInResolver mir)

resolveType

public JavaType resolveType(Type type)

Specified by:

resolveType in interface TypeResolutionContext

getAnnotated

public Class<?> getAnnotated()

Description copied from class: Annotated

Method that can be used to find actual JDK element that this instance represents. It is non-null, except for method/constructor parameters which do not have a JDK counterpart.

Specified by:

getAnnotated in class Annotated

getModifiers

public int getModifiers()

Specified by:

getModifiers in class Annotated

getName

public String getName()

Specified by:

getName in class Annotated

getAnnotation

public <A extends Annotation> A getAnnotation(Class<A> acls)

Specified by:

getAnnotation in class Annotated

hasAnnotation

public boolean hasAnnotation(Class<?> acls)

Specified by:

hasAnnotation in class Annotated

hasOneOf

public boolean hasOneOf(Class<? extends Annotation>[] annoClasses)

Specified by:

hasOneOf in class Annotated

getRawType

public Class<?> getRawType()

Description copied from class: Annotated

"Raw" type (type-erased class) of the annotated element; definition of what exactly this means depends on sub-class.

Specified by:

getRawType in class Annotated

annotations

public Iterable<Annotation> annotations()

Description copied from class: Annotated

Accessor that can be used to iterate over all the annotations associated with annotated component.

Specified by:

annotations in class Annotated

getAllAnnotations

protected AnnotationMap getAllAnnotations()

Description copied from class: Annotated

Internal helper method used to access annotation information; not exposed to developers since instances are mutable.

Specified by:

getAllAnnotations in class Annotated

getType

public JavaType getType()

Description copied from class: Annotated

Full generic type of the annotated element; definition of what exactly this means depends on sub-class.

Specified by:

getType in class Annotated

getAnnotations

public Annotations getAnnotations()

hasAnnotations

public boolean hasAnnotations()

getDefaultConstructor

public AnnotatedConstructor getDefaultConstructor()

getConstructors

public List<AnnotatedConstructor> getConstructors()

getStaticMethods

public List<AnnotatedMethod> getStaticMethods()

memberMethods

public Iterable<AnnotatedMethod> memberMethods()

getMemberMethodCount

public int getMemberMethodCount()

findMethod

public AnnotatedMethod findMethod(String name,
                                  Class<?>[] paramTypes)

getFieldCount

public int getFieldCount()

fields

public Iterable<AnnotatedField> fields()

_addClassMixIns

protected void _addClassMixIns(AnnotationMap annotations,
                               JavaType target)

Helper method for adding any mix-in annotations specified class might have.

_addClassMixIns

protected void _addClassMixIns(AnnotationMap annotations,
                               Class<?> target)

_addClassMixIns

protected void _addClassMixIns(AnnotationMap annotations,
                               Class<?> toMask,
                               Class<?> mixin)

_addConstructorMixIns

protected void _addConstructorMixIns(Class<?> mixin)

_addFactoryMixIns

protected void _addFactoryMixIns(Class<?> mixin)

_addMemberMethods

protected void _addMemberMethods(Class<?> cls,
                                 TypeResolutionContext typeContext,
                                 AnnotatedMethodMap methods,
                                 Class<?> mixInCls,
                                 AnnotatedMethodMap mixIns)

_addMethodMixIns

protected void _addMethodMixIns(Class<?> targetClass,
                                AnnotatedMethodMap methods,
                                Class<?> mixInCls,
                                AnnotatedMethodMap mixIns)

_findFields

protected Map<String,AnnotatedField> _findFields(JavaType type,
                                                 TypeResolutionContext typeContext,
                                                 Map<String,AnnotatedField> fields)

_addFieldMixIns

protected void _addFieldMixIns(Class<?> mixInCls,
                               Class<?> targetClass,
                               Map<String,AnnotatedField> fields)

Method called to add field mix-ins from given mix-in class (and its fields) into already collected actual fields (from introspected classes and their super-classes)

_constructMethod

protected AnnotatedMethod _constructMethod(Method m,
                                           TypeResolutionContext typeContext)

_constructDefaultConstructor

protected AnnotatedConstructor _constructDefaultConstructor(ClassUtil.Ctor ctor,
                                                            TypeResolutionContext typeContext)

_constructNonDefaultConstructor

protected AnnotatedConstructor _constructNonDefaultConstructor(ClassUtil.Ctor ctor,
                                                               TypeResolutionContext typeContext)

_constructCreatorMethod

protected AnnotatedMethod _constructCreatorMethod(Method m,
                                                  TypeResolutionContext typeContext)

_constructField

protected AnnotatedField _constructField(Field f,
                                         TypeResolutionContext typeContext)

_isIncludableMemberMethod

protected boolean _isIncludableMemberMethod(Method m)

_collectRelevantAnnotations

protected AnnotationMap[] _collectRelevantAnnotations(Annotation[][] anns)

_collectRelevantAnnotations

protected AnnotationMap _collectRelevantAnnotations(Annotation[] anns)

_addMixOvers

protected void _addMixOvers(Constructor<?> mixin,
                            AnnotatedConstructor target,
                            boolean addParamAnnotations)

Parameters:

addParamAnnotations - Whether parameter annotations are to be added as well

_addMixOvers

protected void _addMixOvers(Method mixin,
                            AnnotatedMethod target,
                            boolean addParamAnnotations)

Parameters:

addParamAnnotations - Whether parameter annotations are to be added as well

_addMixUnders

protected void _addMixUnders(Method src,
                             AnnotatedMethod target)

Method that will add annotations from specified source method to target method, but only if target does not yet have them.

_findClassMethods

protected Method[] _findClassMethods(Class<?> cls)

Helper method that gets methods declared in given class; usually a simple thing, but sometimes (as per [databind#785]) more complicated, depending on classloader setup.

Since:

2.4.7

toString

public String toString()

Specified by:

toString in class Annotated

hashCode

public int hashCode()

Specified by:

hashCode in class Annotated

equals

public boolean equals(Object o)

Specified by:

equals in class Annotated