| 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.deser | 
 Contains implementation classes of deserialization part of 
 data binding. 
 | 
| com.fasterxml.jackson.databind.deser.impl | 
 Contains those implementation classes of deserialization part of 
 data binding that are not considered part of public or semi-public
 interfaces. 
 | 
| com.fasterxml.jackson.databind.deser.std | 
 Contains public standard implementations of abstraction that
 Jackson uses. 
 | 
| 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.util | 
 Utility classes for Mapper package. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
abstract AnnotatedMethod | 
BeanDescription.findAnySetter()
Method used to locate the method of introspected class that
 implements  
JsonAnySetter. | 
abstract AnnotatedMethod | 
BeanDescription.findJsonValueMethod()
Method for locating the getter method that is annotated with
  
JsonValue annotation,
 if any. | 
abstract AnnotatedMethod | 
BeanDescription.findMethod(String name,
          Class<?>[] paramTypes)  | 
| Modifier and Type | Method and Description | 
|---|---|
abstract List<AnnotatedMethod> | 
BeanDescription.getFactoryMethods()  | 
| Modifier and Type | Method and Description | 
|---|---|
String | 
AnnotationIntrospector.findDeserializationName(AnnotatedMethod am)
Deprecated. 
 
Since 2.1 should use  
AnnotationIntrospector.findNameForDeserialization(com.fasterxml.jackson.databind.introspect.Annotated) instead | 
String | 
AnnotationIntrospector.findSerializationName(AnnotatedMethod am)
Deprecated. 
 
Since 2.1 should use  
AnnotationIntrospector.findNameForSerialization(com.fasterxml.jackson.databind.introspect.Annotated) instead | 
boolean | 
AnnotationIntrospector.hasAnyGetterAnnotation(AnnotatedMethod am)
Method for checking whether given method has an annotation
 that suggests that the method is to serve as "any setter";
 method to be used for accessing set of miscellaneous "extra"
 properties, often bound with matching "any setter" method. 
 | 
boolean | 
AnnotationIntrospector.hasAnySetterAnnotation(AnnotatedMethod am)
Method for checking whether given method has an annotation
 that suggests that the method is to serve as "any setter";
 method to be used for setting values of any properties for
 which no dedicated setter method is found. 
 | 
boolean | 
AnnotationIntrospector.hasAsValueAnnotation(AnnotatedMethod am)
Method for checking whether given method has an annotation
 that suggests that the return value of annotated method
 should be used as "the value" of the object instance; usually
 serialized as a primitive value such as String or number. 
 | 
String | 
PropertyNamingStrategy.nameForGetterMethod(MapperConfig<?> config,
                   AnnotatedMethod method,
                   String defaultName)
Method called to find external name (name used in JSON) for given logical
 POJO property,
 as defined by given getter method; typically called when building a serializer. 
 | 
String | 
PropertyNamingStrategy.PropertyNamingStrategyBase.nameForGetterMethod(MapperConfig<?> config,
                   AnnotatedMethod method,
                   String defaultName)  | 
String | 
PropertyNamingStrategy.nameForSetterMethod(MapperConfig<?> config,
                   AnnotatedMethod method,
                   String defaultName)
Method called to find external name (name used in JSON) for given logical
 POJO property,
 as defined by given setter method; typically called when building a deserializer
 (but not necessarily only then). 
 | 
String | 
PropertyNamingStrategy.PropertyNamingStrategyBase.nameForSetterMethod(MapperConfig<?> config,
                   AnnotatedMethod method,
                   String defaultName)  | 
| Modifier and Type | Field and Description | 
|---|---|
protected AnnotatedMethod | 
BuilderBasedDeserializer._buildMethod  | 
protected AnnotatedMethod | 
BeanDeserializerBuilder._buildMethod
When creating Builder-based deserializers, this indicates
 method to call on builder to finalize value. 
 | 
| Modifier and Type | Method and Description | 
|---|---|
protected AnnotatedMethod | 
BasicDeserializerFactory._findJsonValueFor(DeserializationConfig config,
                 JavaType enumType)  | 
AnnotatedMethod | 
BeanDeserializerBuilder.getBuildMethod()  | 
| Modifier and Type | Method and Description | 
|---|---|
protected boolean | 
BasicDeserializerFactory._handleSingleArgumentFactory(DeserializationConfig config,
                            BeanDescription beanDesc,
                            VisibilityChecker<?> vchecker,
                            AnnotationIntrospector intr,
                            CreatorCollector creators,
                            AnnotatedMethod factory,
                            boolean isCreator)  | 
protected SettableAnyProperty | 
BeanDeserializerFactory.constructAnySetter(DeserializationContext ctxt,
                  BeanDescription beanDesc,
                  AnnotatedMethod setter)
Method called to construct fallback  
SettableAnyProperty
 for handling unknown bean properties, given a method that
 has been designated as such setter. | 
protected EnumResolver<?> | 
BasicDeserializerFactory.constructEnumResolver(Class<?> enumClass,
                     DeserializationConfig config,
                     AnnotatedMethod jsonValueMethod)  | 
void | 
BeanDeserializerBuilder.setPOJOBuilder(AnnotatedMethod buildMethod,
              JsonPOJOBuilder.Value config)  | 
| Constructor and Description | 
|---|
SettableAnyProperty(BeanProperty property,
                   AnnotatedMethod setter,
                   JavaType type,
                   JsonDeserializer<Object> valueDeser)  | 
| Modifier and Type | Field and Description | 
|---|---|
protected AnnotatedMethod | 
SetterlessProperty._annotated  | 
protected AnnotatedMethod | 
MethodProperty._annotated  | 
protected AnnotatedMethod | 
BeanAsArrayBuilderDeserializer._buildMethod  | 
| Constructor and Description | 
|---|
BeanAsArrayBuilderDeserializer(BeanDeserializerBase delegate,
                              SettableBeanProperty[] ordered,
                              AnnotatedMethod buildMethod)
Main constructor used both for creating new instances (by
  
BeanDeserializer.asArrayDeserializer()) and for
 creating copies with different delegate. | 
MethodProperty(BeanPropertyDefinition propDef,
              JavaType type,
              TypeDeserializer typeDeser,
              Annotations contextAnnotations,
              AnnotatedMethod method)  | 
SetterlessProperty(BeanPropertyDefinition propDef,
                  JavaType type,
                  TypeDeserializer typeDeser,
                  Annotations contextAnnotations,
                  AnnotatedMethod method)  | 
| Modifier and Type | Method and Description | 
|---|---|
static KeyDeserializer | 
StdKeyDeserializers.constructEnumKeyDeserializer(EnumResolver<?> enumResolver,
                            AnnotatedMethod factory)  | 
static JsonDeserializer<?> | 
EnumDeserializer.deserializerForCreator(DeserializationConfig config,
                      Class<?> enumClass,
                      AnnotatedMethod factory)
Factory method used when Enum instances are to be deserialized
 using a creator (static factory method) 
 | 
| Constructor and Description | 
|---|
EnumDeserializer.FactoryBasedDeserializer(Class<?> cls,
                                         AnnotatedMethod f,
                                         Class<?> inputType)  | 
| Modifier and Type | Field and Description | 
|---|---|
protected AnnotatedMethod | 
BasicBeanDescription._anySetterMethod  | 
protected AnnotatedMethod | 
BasicBeanDescription._jsonValueMethod  | 
| Modifier and Type | Field and Description | 
|---|---|
protected LinkedList<AnnotatedMethod> | 
POJOPropertiesCollector._anySetters  | 
protected List<AnnotatedMethod> | 
AnnotatedClass._creatorMethods
Single argument static methods that might be usable
 as factory methods 
 | 
protected com.fasterxml.jackson.databind.introspect.POJOPropertyBuilder.Linked<AnnotatedMethod> | 
POJOPropertyBuilder._getters  | 
protected LinkedList<AnnotatedMethod> | 
POJOPropertiesCollector._jsonValueGetters
Method(s) marked with 'JsonValue' annotation 
 | 
protected LinkedHashMap<MemberKey,AnnotatedMethod> | 
AnnotatedMethodMap._methods  | 
protected com.fasterxml.jackson.databind.introspect.POJOPropertyBuilder.Linked<AnnotatedMethod> | 
POJOPropertyBuilder._setters  | 
| Modifier and Type | Method and Description | 
|---|---|
protected AnnotatedMethod | 
AnnotatedClass._constructCreatorMethod(Method m)  | 
protected AnnotatedMethod | 
AnnotatedClass._constructMethod(Method m)  | 
AnnotatedMethod | 
AnnotatedMethodMap.find(Method m)  | 
AnnotatedMethod | 
AnnotatedMethodMap.find(String name,
    Class<?>[] paramTypes)  | 
AnnotatedMethod | 
BasicBeanDescription.findAnySetter()  | 
AnnotatedMethod | 
BasicBeanDescription.findJsonValueMethod()  | 
AnnotatedMethod | 
BasicBeanDescription.findMethod(String name,
          Class<?>[] paramTypes)  | 
AnnotatedMethod | 
AnnotatedClass.findMethod(String name,
          Class<?>[] paramTypes)  | 
AnnotatedMethod | 
POJOPropertiesCollector.getAnySetterMethod()  | 
AnnotatedMethod | 
POJOPropertyBuilder.getGetter()  | 
abstract AnnotatedMethod | 
BeanPropertyDefinition.getGetter()  | 
AnnotatedMethod | 
POJOPropertiesCollector.getJsonValueMethod()  | 
AnnotatedMethod | 
POJOPropertyBuilder.getSetter()  | 
abstract AnnotatedMethod | 
BeanPropertyDefinition.getSetter()  | 
AnnotatedMethod | 
AnnotatedMethodMap.remove(AnnotatedMethod am)
Method called to remove specified method, assuming
 it exists in the Map 
 | 
AnnotatedMethod | 
AnnotatedMethodMap.remove(Method m)  | 
AnnotatedMethod | 
AnnotatedMethod.withAnnotations(AnnotationMap ann)  | 
AnnotatedMethod | 
AnnotatedMethod.withMethod(Method m)
Method that constructs a new instance with settings (annotations, parameter annotations)
 of this instance, but with different physical  
Method. | 
| Modifier and Type | Method and Description | 
|---|---|
List<AnnotatedMethod> | 
BasicBeanDescription.getFactoryMethods()  | 
List<AnnotatedMethod> | 
AnnotatedClass.getStaticMethods()  | 
Iterator<AnnotatedMethod> | 
AnnotatedMethodMap.iterator()  | 
Iterable<AnnotatedMethod> | 
AnnotatedClass.memberMethods()  | 
| Modifier and Type | Method and Description | 
|---|---|
protected void | 
POJOPropertiesCollector._addGetterMethod(AnnotatedMethod m,
                AnnotationIntrospector ai)  | 
protected void | 
AnnotatedClass._addMixOvers(Method mixin,
            AnnotatedMethod target,
            boolean addParamAnnotations)  | 
protected void | 
AnnotatedClass._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 void | 
POJOPropertiesCollector._addSetterMethod(AnnotatedMethod m,
                AnnotationIntrospector ai)  | 
void | 
AnnotatedMethodMap.add(AnnotatedMethod am)
Method called to add specified annotated method in the Map. 
 | 
void | 
POJOPropertyBuilder.addGetter(AnnotatedMethod a,
         String ename,
         boolean visible,
         boolean ignored)  | 
void | 
POJOPropertyBuilder.addSetter(AnnotatedMethod a,
         String ename,
         boolean visible,
         boolean ignored)  | 
String | 
JacksonAnnotationIntrospector.findDeserializationName(AnnotatedMethod am)  | 
String | 
AnnotationIntrospectorPair.findDeserializationName(AnnotatedMethod am)
Deprecated.  
 | 
String | 
JacksonAnnotationIntrospector.findSerializationName(AnnotatedMethod am)  | 
String | 
AnnotationIntrospectorPair.findSerializationName(AnnotatedMethod am)
Deprecated.  
 | 
boolean | 
JacksonAnnotationIntrospector.hasAnyGetterAnnotation(AnnotatedMethod am)  | 
boolean | 
AnnotationIntrospectorPair.hasAnyGetterAnnotation(AnnotatedMethod am)  | 
boolean | 
JacksonAnnotationIntrospector.hasAnySetterAnnotation(AnnotatedMethod am)  | 
boolean | 
AnnotationIntrospectorPair.hasAnySetterAnnotation(AnnotatedMethod am)  | 
boolean | 
JacksonAnnotationIntrospector.hasAsValueAnnotation(AnnotatedMethod am)  | 
boolean | 
AnnotationIntrospectorPair.hasAsValueAnnotation(AnnotatedMethod am)  | 
protected boolean | 
BasicBeanDescription.isFactoryMethod(AnnotatedMethod am)  | 
boolean | 
VisibilityChecker.isGetterVisible(AnnotatedMethod m)  | 
boolean | 
VisibilityChecker.Std.isGetterVisible(AnnotatedMethod m)  | 
boolean | 
VisibilityChecker.isIsGetterVisible(AnnotatedMethod m)  | 
boolean | 
VisibilityChecker.Std.isIsGetterVisible(AnnotatedMethod m)  | 
boolean | 
VisibilityChecker.isSetterVisible(AnnotatedMethod m)  | 
boolean | 
VisibilityChecker.Std.isSetterVisible(AnnotatedMethod m)  | 
AnnotatedMethod | 
AnnotatedMethodMap.remove(AnnotatedMethod am)
Method called to remove specified method, assuming
 it exists in the Map 
 | 
| Modifier and Type | Method and Description | 
|---|---|
AnnotatedMethod | 
SimpleBeanPropertyDefinition.getGetter()  | 
AnnotatedMethod | 
SimpleBeanPropertyDefinition.getSetter()  | 
| Modifier and Type | Method and Description | 
|---|---|
protected static boolean | 
BeanUtil.isCglibGetCallbacks(AnnotatedMethod am)
This method was added to address [JACKSON-53]: need to weed out
 CGLib-injected "getCallbacks". 
 | 
protected static boolean | 
BeanUtil.isGroovyMetaClassGetter(AnnotatedMethod am)
Another helper method to deal with rest of [JACKSON-103] 
 | 
protected static boolean | 
BeanUtil.isGroovyMetaClassSetter(AnnotatedMethod am)
Similar to  
BeanUtil.isCglibGetCallbacks(com.fasterxml.jackson.databind.introspect.AnnotatedMethod), need to suppress
 a cyclic reference to resolve [JACKSON-103] | 
static String | 
BeanUtil.okNameForGetter(AnnotatedMethod am)  | 
static String | 
BeanUtil.okNameForIsGetter(AnnotatedMethod am,
                 String name)  | 
static String | 
BeanUtil.okNameForMutator(AnnotatedMethod am,
                String prefix)  | 
static String | 
BeanUtil.okNameForRegularGetter(AnnotatedMethod am,
                      String name)  | 
static String | 
BeanUtil.okNameForSetter(AnnotatedMethod am)  | 
Copyright © 2012-2013 FasterXML. All Rights Reserved.