类 org.codehaus.jackson.map.introspect.AnnotatedClass
的使用

使用AnnotatedClass的程序包

程序包	说明
org.codehaus.jackson.map	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 Object mapper will convert Json content to ant from basic Java wrapper types (Integer, Boolean, Double), Collection types (List, Map), Java Beans, Strings and nulls.
org.codehaus.jackson.map.deser	Contains implementation classes of deserialization part of data binding.
org.codehaus.jackson.map.introspect	Functionality needed for Bean introspection, required for detecting accessors and mutators for Beans, as well as locating and handling method annotations.
org.codehaus.jackson.map.jsontype	Package that contains interfaces that define how to implement functionality for dynamically resolving type during deserialization.
org.codehaus.jackson.map.jsontype.impl	Package that contains standard implementations for TypeResolverBuilder and TypeIdResolver.
org.codehaus.jackson.xc	Package that contains XML Compatibility functionality for Jackson, such as handlers for JAXB annotations

org.codehaus.jackson.map中AnnotatedClass的使用

返回AnnotatedClass的org.codehaus.jackson.map中的方法

限定符和类型	方法和说明
abstract AnnotatedClass	BeanDescription.getClassInfo()

参数类型为AnnotatedClass的org.codehaus.jackson.map中的方法

限定符和类型	方法和说明
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).
VisibilityChecker<?>	AnnotationIntrospector.Pair.findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker)
Boolean	AnnotationIntrospector.findCachability(AnnotatedClass ac) Method that checks whether specified class has annotations that indicate that it is (or is not) cachable.
Boolean	AnnotationIntrospector.Pair.findCachability(AnnotatedClass ac)
Object	AnnotationIntrospector.findFilterId(AnnotatedClass ac) Method for finding if annotated class has associated filter; and if so, to return id that is used to locate filter.
Object	AnnotationIntrospector.Pair.findFilterId(AnnotatedClass ac)
abstract Boolean	AnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac) Method for checking whether an annotation indicates that all unknown properties
Boolean	AnnotationIntrospector.Pair.findIgnoreUnknownProperties(AnnotatedClass ac)
abstract String[]	AnnotationIntrospector.findPropertiesToIgnore(AnnotatedClass ac) Method for finding list of properties to ignore for given class (null is returned if not specified).
String[]	AnnotationIntrospector.Pair.findPropertiesToIgnore(AnnotatedClass ac)
abstract String	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.Pair.findRootName(AnnotatedClass ac)
abstract String[]	AnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac) Method for accessing defined property serialization order (which may be partial).
String[]	AnnotationIntrospector.Pair.findSerializationPropertyOrder(AnnotatedClass ac)
abstract Boolean	AnnotationIntrospector.findSerializationSortAlphabetically(AnnotatedClass ac) Method for checking whether an annotation indicates that serialized properties for which no explicit is defined should be alphabetically (lexicograpically) ordered
Boolean	AnnotationIntrospector.Pair.findSerializationSortAlphabetically(AnnotatedClass ac) Method for checking whether an annotation indicates that serialized properties for which no explicit is defined should be alphabetically (lexicograpically) ordered
String	AnnotationIntrospector.findTypeName(AnnotatedClass ac) Method for checking if specified type has explicit name.
String	AnnotationIntrospector.Pair.findTypeName(AnnotatedClass ac)
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.
TypeResolverBuilder<?>	AnnotationIntrospector.Pair.findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType)
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.
Object	AnnotationIntrospector.Pair.findValueInstantiator(AnnotatedClass ac)
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.
Boolean	AnnotationIntrospector.Pair.isIgnorableType(AnnotatedClass ac)

org.codehaus.jackson.map.deser中AnnotatedClass的使用

声明为AnnotatedClass的org.codehaus.jackson.map.deser中的字段

限定符和类型	字段和说明
protected AnnotatedClass	BeanDeserializer._forClass Class for which deserializer is built; used for accessing annotations during resolution phase (see BeanDeserializer.resolve(org.codehaus.jackson.map.DeserializationConfig, org.codehaus.jackson.map.DeserializerProvider)).

参数类型为AnnotatedClass的org.codehaus.jackson.map.deser中的构造器

构造器和说明
BeanDeserializer(AnnotatedClass forClass, JavaType type, BeanProperty property, CreatorCollector creators, BeanPropertyMap properties, Map<String,SettableBeanProperty> backRefs, HashSet<String> ignorableProps, boolean ignoreAllUnknown, SettableAnyProperty anySetter) 已过时。 (since 1.9) Use the constructor that takes ValueInstantiator instead
BeanDeserializer(AnnotatedClass forClass, JavaType type, BeanProperty property, ValueInstantiator valueInstantiator, BeanPropertyMap properties, Map<String,SettableBeanProperty> backRefs, HashSet<String> ignorableProps, boolean ignoreAllUnknown, SettableAnyProperty anySetter, List<ValueInjector> injectables)

org.codehaus.jackson.map.introspect中AnnotatedClass的使用

声明为AnnotatedClass的org.codehaus.jackson.map.introspect中的字段

限定符和类型	字段和说明
protected AnnotatedClass	POJOPropertiesCollector._classDef Low-level introspected class information (methods, fields etc)
protected AnnotatedClass	BasicBeanDescription._classInfo Information collected about the class introspected.

返回AnnotatedClass的org.codehaus.jackson.map.introspect中的方法

限定符和类型	方法和说明
AnnotatedClass	BasicClassIntrospector.classWithCreators(MapperConfig<?> config, JavaType type, ClassIntrospector.MixInResolver r)
static AnnotatedClass	AnnotatedClass.construct(Class<?> cls, AnnotationIntrospector aintr, ClassIntrospector.MixInResolver mir) Factory method that instantiates an instance.
static AnnotatedClass	AnnotatedClass.constructWithoutSuperTypes(Class<?> cls, AnnotationIntrospector aintr, ClassIntrospector.MixInResolver mir) Method similar to construct(java.lang.Class<?>, org.codehaus.jackson.map.AnnotationIntrospector, org.codehaus.jackson.map.ClassIntrospector.MixInResolver), but that will NOT include information from supertypes; only class itself and any direct mix-ins it may have.
AnnotatedClass	POJOPropertiesCollector.getClassDef()
AnnotatedClass	BasicBeanDescription.getClassInfo()
AnnotatedClass	AnnotatedClass.withAnnotations(AnnotationMap ann)

参数类型为AnnotatedClass的org.codehaus.jackson.map.introspect中的方法

限定符和类型	方法和说明
protected POJOPropertiesCollector	BasicClassIntrospector.constructPropertyCollector(MapperConfig<?> config, AnnotatedClass ac, JavaType type, boolean forSerialization) Overridable method called for creating POJOPropertiesCollector instance to use; override is needed if a custom sub-class is to be used.
VisibilityChecker<?>	JacksonAnnotationIntrospector.findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker)
Boolean	JacksonAnnotationIntrospector.findCachability(AnnotatedClass ac)
Object	JacksonAnnotationIntrospector.findFilterId(AnnotatedClass ac)
Boolean	NopAnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac)
Boolean	JacksonAnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac)
String[]	NopAnnotationIntrospector.findPropertiesToIgnore(AnnotatedClass ac)
String[]	JacksonAnnotationIntrospector.findPropertiesToIgnore(AnnotatedClass ac)
String	NopAnnotationIntrospector.findRootName(AnnotatedClass ac)
String	JacksonAnnotationIntrospector.findRootName(AnnotatedClass ac)
String[]	NopAnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac)
String[]	JacksonAnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac)
Boolean	NopAnnotationIntrospector.findSerializationSortAlphabetically(AnnotatedClass ac)
Boolean	JacksonAnnotationIntrospector.findSerializationSortAlphabetically(AnnotatedClass ac)
String	JacksonAnnotationIntrospector.findTypeName(AnnotatedClass ac)
TypeResolverBuilder<?>	JacksonAnnotationIntrospector.findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType)
Object	JacksonAnnotationIntrospector.findValueInstantiator(AnnotatedClass ac)
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.
Boolean	JacksonAnnotationIntrospector.isIgnorableType(AnnotatedClass ac)

参数类型为AnnotatedClass的org.codehaus.jackson.map.introspect中的构造器

构造器和说明
BasicBeanDescription(MapperConfig<?> config, JavaType type, AnnotatedClass ac) 已过时。 Since 1.9, should use factory methods instead
BasicBeanDescription(MapperConfig<?> config, JavaType type, AnnotatedClass ac, List<BeanPropertyDefinition> properties)
POJOPropertiesCollector(MapperConfig<?> config, boolean forSerialization, JavaType type, AnnotatedClass classDef)

org.codehaus.jackson.map.jsontype中AnnotatedClass的使用

参数类型为AnnotatedClass的org.codehaus.jackson.map.jsontype中的方法

限定符和类型	方法和说明
abstract Collection<NamedType>	SubtypeResolver.collectAndResolveSubtypes(AnnotatedClass basetype, MapperConfig<?> config, AnnotationIntrospector ai) Method for finding out all reachable subtypes for given type.

org.codehaus.jackson.map.jsontype.impl中AnnotatedClass的使用

参数类型为AnnotatedClass的org.codehaus.jackson.map.jsontype.impl中的方法

限定符和类型	方法和说明
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)
Collection<NamedType>	StdSubtypeResolver.collectAndResolveSubtypes(AnnotatedClass type, MapperConfig<?> config, AnnotationIntrospector ai)

org.codehaus.jackson.xc中AnnotatedClass的使用

参数类型为AnnotatedClass的org.codehaus.jackson.xc中的方法

限定符和类型	方法和说明
VisibilityChecker<?>	JaxbAnnotationIntrospector.findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker)
Boolean	JaxbAnnotationIntrospector.findCachability(AnnotatedClass ac)
Boolean	JaxbAnnotationIntrospector.findIgnoreUnknownProperties(AnnotatedClass ac)
String[]	JaxbAnnotationIntrospector.findPropertiesToIgnore(AnnotatedClass ac)
String	JaxbAnnotationIntrospector.findRootName(AnnotatedClass ac)
String[]	JaxbAnnotationIntrospector.findSerializationPropertyOrder(AnnotatedClass ac)
Boolean	JaxbAnnotationIntrospector.findSerializationSortAlphabetically(AnnotatedClass ac)
String	JaxbAnnotationIntrospector.findTypeName(AnnotatedClass ac)
TypeResolverBuilder<?>	JaxbAnnotationIntrospector.findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType)
Boolean	JaxbAnnotationIntrospector.isIgnorableType(AnnotatedClass ac)