| Package | Description |
|---|---|
| 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 |
| 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.ser |
Contains implementation classes of serialization part of
data binding.
|
| org.codehaus.jackson.xc |
Package that contains XML Compatibility functionality for Jackson, such
as handlers for JAXB annotations
|
| Modifier and Type | Method and Description |
|---|---|
JsonDeserializer<Object> |
DeserializationConfig.deserializerInstance(Annotated annotated,
Class<? extends JsonDeserializer<?>> deserClass) |
abstract JsonDeserializer<?> |
HandlerInstantiator.deserializerInstance(DeserializationConfig config,
Annotated annotated,
Class<? extends JsonDeserializer<?>> deserClass)
Method called to get an instance of deserializer of specified type.
|
abstract Class<? extends JsonDeserializer<?>> |
AnnotationIntrospector.findContentDeserializer(Annotated am)
Method for getting a deserializer definition for content (values) of
associated
Collection, array or
Map property. |
Class<? extends JsonDeserializer<?>> |
AnnotationIntrospector.Pair.findContentDeserializer(Annotated am) |
Class<? extends JsonSerializer<?>> |
AnnotationIntrospector.findContentSerializer(Annotated am)
Method for getting a serializer definition for content (values) of
associated
Collection, array or Map property. |
Class<? extends JsonSerializer<?>> |
AnnotationIntrospector.Pair.findContentSerializer(Annotated a) |
abstract Class<?> |
AnnotationIntrospector.findDeserializationContentType(Annotated am,
JavaType baseContentType,
String propName)
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.
|
Class<?> |
AnnotationIntrospector.Pair.findDeserializationContentType(Annotated am,
JavaType baseContentType,
String propName) |
abstract Class<?> |
AnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType baseKeyType,
String propName)
Method for accessing additional narrowing type definition that a
method can have, to define more specific key type to use.
|
Class<?> |
AnnotationIntrospector.Pair.findDeserializationKeyType(Annotated am,
JavaType baseKeyType,
String propName) |
abstract Class<?> |
AnnotationIntrospector.findDeserializationType(Annotated am,
JavaType baseType,
String propName)
Method for accessing annotated type definition that a
method can have, to be used as the type for serialization
instead of the runtime type.
|
Class<?> |
AnnotationIntrospector.Pair.findDeserializationType(Annotated am,
JavaType baseType,
String propName) |
abstract Object |
AnnotationIntrospector.findDeserializer(Annotated am)
Method for getting a deserializer definition on specified method
or field.
|
Object |
AnnotationIntrospector.Pair.findDeserializer(Annotated am) |
abstract Class<? extends KeyDeserializer> |
AnnotationIntrospector.findKeyDeserializer(Annotated am)
Method for getting a deserializer definition for keys of
associated
Map property. |
Class<? extends KeyDeserializer> |
AnnotationIntrospector.Pair.findKeyDeserializer(Annotated am) |
Class<? extends JsonSerializer<?>> |
AnnotationIntrospector.findKeySerializer(Annotated am)
Method for getting a serializer definition for keys of associated
Map property. |
Class<? extends JsonSerializer<?>> |
AnnotationIntrospector.Pair.findKeySerializer(Annotated a) |
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.
|
Class<?> |
AnnotationIntrospector.Pair.findSerializationContentType(Annotated am,
JavaType baseType) |
JsonSerialize.Inclusion |
AnnotationIntrospector.findSerializationInclusion(Annotated a,
JsonSerialize.Inclusion defValue)
Method for checking whether given annotated entity (class, method,
field) defines which Bean/Map properties are to be included in
serialization.
|
JsonSerialize.Inclusion |
AnnotationIntrospector.Pair.findSerializationInclusion(Annotated a,
JsonSerialize.Inclusion defValue) |
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.Pair.findSerializationKeyType(Annotated am,
JavaType baseType) |
abstract 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.
|
Class<?> |
AnnotationIntrospector.Pair.findSerializationType(Annotated a) |
abstract JsonSerialize.Typing |
AnnotationIntrospector.findSerializationTyping(Annotated a)
Method for accessing declared typing mode annotated (if any).
|
JsonSerialize.Typing |
AnnotationIntrospector.Pair.findSerializationTyping(Annotated a) |
abstract Class<?>[] |
AnnotationIntrospector.findSerializationViews(Annotated a)
Method for checking if annotated serializable property (represented by
field or getter method) has definitions for views it is to be included
in.
|
Class<?>[] |
AnnotationIntrospector.Pair.findSerializationViews(Annotated a) |
abstract Object |
AnnotationIntrospector.findSerializer(Annotated am)
Method for getting a serializer definition on specified method
or field.
|
Object |
AnnotationIntrospector.Pair.findSerializer(Annotated am) |
List<NamedType> |
AnnotationIntrospector.findSubtypes(Annotated a)
Method for locating annotation-specified subtypes related to annotated
entity (class, method, field).
|
List<NamedType> |
AnnotationIntrospector.Pair.findSubtypes(Annotated a) |
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.
|
boolean |
AnnotationIntrospector.Pair.hasCreatorAnnotation(Annotated a) |
KeyDeserializer |
DeserializationConfig.keyDeserializerInstance(Annotated annotated,
Class<? extends KeyDeserializer> keyDeserClass) |
abstract KeyDeserializer |
HandlerInstantiator.keyDeserializerInstance(DeserializationConfig config,
Annotated annotated,
Class<? extends KeyDeserializer> keyDeserClass)
Method called to get an instance of key deserializer of specified type.
|
JsonSerializer<Object> |
SerializationConfig.serializerInstance(Annotated annotated,
Class<? extends JsonSerializer<?>> serClass) |
abstract JsonSerializer<?> |
HandlerInstantiator.serializerInstance(SerializationConfig config,
Annotated annotated,
Class<? extends JsonSerializer<?>> 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<? extends TypeIdResolver> 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<? extends TypeResolverBuilder<?>> builderClass)
Method called to get an instance of TypeResolverBuilder of specified type.
|
ValueInstantiator |
DeserializationConfig.valueInstantiatorInstance(Annotated annotated,
Class<? extends ValueInstantiator> instClass) |
ValueInstantiator |
HandlerInstantiator.valueInstantiatorInstance(MapperConfig<?> config,
Annotated annotated,
Class<? extends ValueInstantiator> resolverClass)
Method called to construct an instance of ValueInstantiator of specified type.
|
| Modifier and Type | Method and Description |
|---|---|
protected JsonDeserializer<Object> |
BasicDeserializerFactory.findDeserializerFromAnnotation(DeserializationConfig config,
Annotated ann,
BeanProperty property)
Helper method called to check if a class or method
has annotation that tells which class to use for deserialization.
|
protected <T extends JavaType> |
BasicDeserializerFactory.modifyTypeByAnnotation(DeserializationConfig config,
Annotated a,
T type,
String propName)
Method called to see if given method has annotations that indicate
a more specific type than what the argument specifies.
|
| 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.
|
| 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 |
| 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<JsonDeserializer<?>> |
NopAnnotationIntrospector.findContentDeserializer(Annotated am) |
Class<? extends JsonDeserializer<?>> |
JacksonAnnotationIntrospector.findContentDeserializer(Annotated a) |
Class<? extends JsonSerializer<?>> |
JacksonAnnotationIntrospector.findContentSerializer(Annotated a) |
Class<?> |
NopAnnotationIntrospector.findDeserializationContentType(Annotated am,
JavaType t,
String propName) |
Class<?> |
JacksonAnnotationIntrospector.findDeserializationContentType(Annotated am,
JavaType baseContentType,
String propName) |
Class<?> |
NopAnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType t,
String propName) |
Class<?> |
JacksonAnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType baseKeyType,
String propName) |
Class<?> |
NopAnnotationIntrospector.findDeserializationType(Annotated am,
JavaType t,
String propName) |
Class<?> |
JacksonAnnotationIntrospector.findDeserializationType(Annotated am,
JavaType baseType,
String propName) |
Object |
NopAnnotationIntrospector.findDeserializer(Annotated am) |
Class<? extends JsonDeserializer<?>> |
JacksonAnnotationIntrospector.findDeserializer(Annotated a) |
Class<KeyDeserializer> |
NopAnnotationIntrospector.findKeyDeserializer(Annotated am) |
Class<? extends KeyDeserializer> |
JacksonAnnotationIntrospector.findKeyDeserializer(Annotated a) |
Class<? extends JsonSerializer<?>> |
JacksonAnnotationIntrospector.findKeySerializer(Annotated a) |
Class<?> |
JacksonAnnotationIntrospector.findSerializationContentType(Annotated am,
JavaType baseType) |
JsonSerialize.Inclusion |
JacksonAnnotationIntrospector.findSerializationInclusion(Annotated a,
JsonSerialize.Inclusion defValue) |
Class<?> |
JacksonAnnotationIntrospector.findSerializationKeyType(Annotated am,
JavaType baseType) |
Class<?> |
NopAnnotationIntrospector.findSerializationType(Annotated a) |
Class<?> |
JacksonAnnotationIntrospector.findSerializationType(Annotated am) |
JsonSerialize.Typing |
NopAnnotationIntrospector.findSerializationTyping(Annotated a) |
JsonSerialize.Typing |
JacksonAnnotationIntrospector.findSerializationTyping(Annotated a) |
Class<?>[] |
NopAnnotationIntrospector.findSerializationViews(Annotated a) |
Class<?>[] |
JacksonAnnotationIntrospector.findSerializationViews(Annotated a) |
Object |
NopAnnotationIntrospector.findSerializer(Annotated am) |
Object |
JacksonAnnotationIntrospector.findSerializer(Annotated a) |
List<NamedType> |
JacksonAnnotationIntrospector.findSubtypes(Annotated a) |
boolean |
JacksonAnnotationIntrospector.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 |
| Modifier and Type | Method and Description |
|---|---|
protected static JsonSerializer<Object> |
BasicSerializerFactory.findContentSerializer(SerializationConfig config,
Annotated a,
BeanProperty property) |
protected static JsonSerializer<Object> |
BasicSerializerFactory.findKeySerializer(SerializationConfig config,
Annotated a,
BeanProperty property) |
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(SerializationConfig config,
Annotated a,
BeanProperty property)
Helper method called to check if a class or method
has an annotation
(@link org.codehaus.jackson.map.ser.JsonSerialize#using)
that tells the class to use for serialization.
|
protected static <T extends JavaType> |
BasicSerializerFactory.modifySecondaryTypesByAnnotation(SerializationConfig config,
Annotated a,
T type) |
protected <T extends JavaType> |
BasicSerializerFactory.modifyTypeByAnnotation(SerializationConfig config,
Annotated a,
T type)
Helper method used to encapsulate details of annotation-based type
coercion
|
| Modifier and Type | Method and Description |
|---|---|
protected Class<?> |
JaxbAnnotationIntrospector._doFindDeserializationType(Annotated a,
JavaType baseType,
String propName) |
protected XmlAccessType |
JaxbAnnotationIntrospector.findAccessType(Annotated ac)
Method for locating JAXB
XmlAccessType annotation value
for given annotated entity, if it has one, or inherits one from
its ancestors (in JAXB sense, package etc). |
protected <A extends Annotation> |
JaxbAnnotationIntrospector.findAnnotation(Class<A> annotationClass,
Annotated annotated,
boolean includePackage,
boolean includeClass,
boolean includeSuperclasses)
Finds an annotation associated with given annotatable thing; or if
not found, a default annotation it may have (from super class, package
and so on)
|
Class<JsonDeserializer<?>> |
JaxbAnnotationIntrospector.findContentDeserializer(Annotated am) |
Class<?> |
JaxbAnnotationIntrospector.findDeserializationContentType(Annotated a,
JavaType baseContentType,
String propName) |
Class<?> |
JaxbAnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType baseKeyType,
String propName) |
Class<?> |
JaxbAnnotationIntrospector.findDeserializationType(Annotated a,
JavaType baseType,
String propName)
JAXB does allow specifying (more) concrete class for
deserialization by using \@XmlElement annotation.
|
JsonDeserializer<?> |
JaxbAnnotationIntrospector.findDeserializer(Annotated am) |
Class<KeyDeserializer> |
JaxbAnnotationIntrospector.findKeyDeserializer(Annotated am) |
JsonSerialize.Inclusion |
JaxbAnnotationIntrospector.findSerializationInclusion(Annotated a,
JsonSerialize.Inclusion defValue)
Implementation of this method is slightly tricky, given that JAXB defaults differ
from Jackson defaults.
|
Class<?> |
JaxbAnnotationIntrospector.findSerializationType(Annotated a) |
JsonSerialize.Typing |
JaxbAnnotationIntrospector.findSerializationTyping(Annotated a) |
Class<?>[] |
JaxbAnnotationIntrospector.findSerializationViews(Annotated a) |
JsonSerializer<?> |
JaxbAnnotationIntrospector.findSerializer(Annotated am) |
List<NamedType> |
JaxbAnnotationIntrospector.findSubtypes(Annotated a) |
boolean |
JaxbAnnotationIntrospector.hasCreatorAnnotation(Annotated am) |