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 | Description |
---|---|---|
JsonDeserializer<java.lang.Object> |
DeserializationConfig.deserializerInstance(Annotated annotated,
java.lang.Class<? extends JsonDeserializer<?>> deserClass) |
|
abstract JsonDeserializer<?> |
HandlerInstantiator.deserializerInstance(DeserializationConfig config,
Annotated annotated,
java.lang.Class<? extends JsonDeserializer<?>> deserClass) |
Method called to get an instance of deserializer of specified type.
|
abstract java.lang.Class<? extends JsonDeserializer<?>> |
AnnotationIntrospector.findContentDeserializer(Annotated am) |
Method for getting a deserializer definition for content (values) of
associated
Collection , array or
Map property. |
java.lang.Class<? extends JsonDeserializer<?>> |
AnnotationIntrospector.Pair.findContentDeserializer(Annotated am) |
|
java.lang.Class<? extends JsonSerializer<?>> |
AnnotationIntrospector.findContentSerializer(Annotated am) |
Method for getting a serializer definition for content (values) of
associated
Collection , array or Map property. |
java.lang.Class<? extends JsonSerializer<?>> |
AnnotationIntrospector.Pair.findContentSerializer(Annotated a) |
|
abstract java.lang.Class<?> |
AnnotationIntrospector.findDeserializationContentType(Annotated am,
JavaType baseContentType,
java.lang.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.
|
java.lang.Class<?> |
AnnotationIntrospector.Pair.findDeserializationContentType(Annotated am,
JavaType baseContentType,
java.lang.String propName) |
|
abstract java.lang.Class<?> |
AnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType baseKeyType,
java.lang.String propName) |
Method for accessing additional narrowing type definition that a
method can have, to define more specific key type to use.
|
java.lang.Class<?> |
AnnotationIntrospector.Pair.findDeserializationKeyType(Annotated am,
JavaType baseKeyType,
java.lang.String propName) |
|
abstract java.lang.Class<?> |
AnnotationIntrospector.findDeserializationType(Annotated am,
JavaType baseType,
java.lang.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.
|
java.lang.Class<?> |
AnnotationIntrospector.Pair.findDeserializationType(Annotated am,
JavaType baseType,
java.lang.String propName) |
|
abstract java.lang.Object |
AnnotationIntrospector.findDeserializer(Annotated am) |
Method for getting a deserializer definition on specified method
or field.
|
java.lang.Object |
AnnotationIntrospector.Pair.findDeserializer(Annotated am) |
|
abstract java.lang.Class<? extends KeyDeserializer> |
AnnotationIntrospector.findKeyDeserializer(Annotated am) |
Method for getting a deserializer definition for keys of
associated
Map property. |
java.lang.Class<? extends KeyDeserializer> |
AnnotationIntrospector.Pair.findKeyDeserializer(Annotated am) |
|
java.lang.Class<? extends JsonSerializer<?>> |
AnnotationIntrospector.findKeySerializer(Annotated am) |
Method for getting a serializer definition for keys of associated
Map property. |
java.lang.Class<? extends JsonSerializer<?>> |
AnnotationIntrospector.Pair.findKeySerializer(Annotated a) |
|
java.lang.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.
|
java.lang.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) |
|
java.lang.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.
|
java.lang.Class<?> |
AnnotationIntrospector.Pair.findSerializationKeyType(Annotated am,
JavaType baseType) |
|
abstract java.lang.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.
|
java.lang.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 java.lang.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.
|
java.lang.Class<?>[] |
AnnotationIntrospector.Pair.findSerializationViews(Annotated a) |
|
abstract java.lang.Object |
AnnotationIntrospector.findSerializer(Annotated am) |
Method for getting a serializer definition on specified method
or field.
|
java.lang.Object |
AnnotationIntrospector.Pair.findSerializer(Annotated am) |
|
java.util.List<NamedType> |
AnnotationIntrospector.findSubtypes(Annotated a) |
Method for locating annotation-specified subtypes related to annotated
entity (class, method, field).
|
java.util.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,
java.lang.Class<? extends KeyDeserializer> keyDeserClass) |
|
abstract KeyDeserializer |
HandlerInstantiator.keyDeserializerInstance(DeserializationConfig config,
Annotated annotated,
java.lang.Class<? extends KeyDeserializer> keyDeserClass) |
Method called to get an instance of key deserializer of specified type.
|
abstract JsonSerializer<?> |
HandlerInstantiator.serializerInstance(SerializationConfig config,
Annotated annotated,
java.lang.Class<? extends JsonSerializer<?>> serClass) |
Method called to get an instance of serializer of specified type.
|
JsonSerializer<java.lang.Object> |
SerializationConfig.serializerInstance(Annotated annotated,
java.lang.Class<? extends JsonSerializer<?>> serClass) |
|
abstract TypeIdResolver |
HandlerInstantiator.typeIdResolverInstance(MapperConfig<?> config,
Annotated annotated,
java.lang.Class<? extends TypeIdResolver> resolverClass) |
Method called to get an instance of TypeIdResolver of specified type.
|
TypeIdResolver |
MapperConfig.typeIdResolverInstance(Annotated annotated,
java.lang.Class<? extends TypeIdResolver> resolverClass) |
Method that can be called to obtain an instance of
TypeIdResolver of
specified type. |
abstract TypeResolverBuilder<?> |
HandlerInstantiator.typeResolverBuilderInstance(MapperConfig<?> config,
Annotated annotated,
java.lang.Class<? extends TypeResolverBuilder<?>> builderClass) |
Method called to get an instance of TypeResolverBuilder of specified type.
|
TypeResolverBuilder<?> |
MapperConfig.typeResolverBuilderInstance(Annotated annotated,
java.lang.Class<? extends TypeResolverBuilder<?>> builderClass) |
Method that can be called to obtain an instance of
TypeIdResolver of
specified type. |
ValueInstantiator |
DeserializationConfig.valueInstantiatorInstance(Annotated annotated,
java.lang.Class<? extends ValueInstantiator> instClass) |
|
ValueInstantiator |
HandlerInstantiator.valueInstantiatorInstance(MapperConfig<?> config,
Annotated annotated,
java.lang.Class<? extends ValueInstantiator> resolverClass) |
Method called to construct an instance of ValueInstantiator of specified type.
|
Modifier and Type | Method | Description |
---|---|---|
protected JsonDeserializer<java.lang.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,
java.lang.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 | 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 | 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 | 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) |
|
java.lang.Class<? extends JsonDeserializer<?>> |
JacksonAnnotationIntrospector.findContentDeserializer(Annotated a) |
|
java.lang.Class<JsonDeserializer<?>> |
NopAnnotationIntrospector.findContentDeserializer(Annotated am) |
|
java.lang.Class<? extends JsonSerializer<?>> |
JacksonAnnotationIntrospector.findContentSerializer(Annotated a) |
|
java.lang.Class<?> |
JacksonAnnotationIntrospector.findDeserializationContentType(Annotated am,
JavaType baseContentType,
java.lang.String propName) |
|
java.lang.Class<?> |
NopAnnotationIntrospector.findDeserializationContentType(Annotated am,
JavaType t,
java.lang.String propName) |
|
java.lang.Class<?> |
JacksonAnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType baseKeyType,
java.lang.String propName) |
|
java.lang.Class<?> |
NopAnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType t,
java.lang.String propName) |
|
java.lang.Class<?> |
JacksonAnnotationIntrospector.findDeserializationType(Annotated am,
JavaType baseType,
java.lang.String propName) |
|
java.lang.Class<?> |
NopAnnotationIntrospector.findDeserializationType(Annotated am,
JavaType t,
java.lang.String propName) |
|
java.lang.Class<? extends JsonDeserializer<?>> |
JacksonAnnotationIntrospector.findDeserializer(Annotated a) |
|
java.lang.Object |
NopAnnotationIntrospector.findDeserializer(Annotated am) |
|
java.lang.Class<? extends KeyDeserializer> |
JacksonAnnotationIntrospector.findKeyDeserializer(Annotated a) |
|
java.lang.Class<KeyDeserializer> |
NopAnnotationIntrospector.findKeyDeserializer(Annotated am) |
|
java.lang.Class<? extends JsonSerializer<?>> |
JacksonAnnotationIntrospector.findKeySerializer(Annotated a) |
|
java.lang.Class<?> |
JacksonAnnotationIntrospector.findSerializationContentType(Annotated am,
JavaType baseType) |
|
JsonSerialize.Inclusion |
JacksonAnnotationIntrospector.findSerializationInclusion(Annotated a,
JsonSerialize.Inclusion defValue) |
|
java.lang.Class<?> |
JacksonAnnotationIntrospector.findSerializationKeyType(Annotated am,
JavaType baseType) |
|
java.lang.Class<?> |
JacksonAnnotationIntrospector.findSerializationType(Annotated am) |
|
java.lang.Class<?> |
NopAnnotationIntrospector.findSerializationType(Annotated a) |
|
JsonSerialize.Typing |
JacksonAnnotationIntrospector.findSerializationTyping(Annotated a) |
|
JsonSerialize.Typing |
NopAnnotationIntrospector.findSerializationTyping(Annotated a) |
|
java.lang.Class<?>[] |
JacksonAnnotationIntrospector.findSerializationViews(Annotated a) |
|
java.lang.Class<?>[] |
NopAnnotationIntrospector.findSerializationViews(Annotated a) |
|
java.lang.Object |
JacksonAnnotationIntrospector.findSerializer(Annotated a) |
|
java.lang.Object |
NopAnnotationIntrospector.findSerializer(Annotated am) |
|
java.util.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 | Description |
---|---|---|
protected static JsonSerializer<java.lang.Object> |
BasicSerializerFactory.findContentSerializer(SerializationConfig config,
Annotated a,
BeanProperty property) |
|
protected static JsonSerializer<java.lang.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<java.lang.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 | Description |
---|---|---|
protected java.lang.Class<?> |
JaxbAnnotationIntrospector._doFindDeserializationType(Annotated a,
JavaType baseType,
java.lang.String propName) |
|
protected javax.xml.bind.annotation.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 java.lang.annotation.Annotation> |
JaxbAnnotationIntrospector.findAnnotation(java.lang.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)
|
java.lang.Class<JsonDeserializer<?>> |
JaxbAnnotationIntrospector.findContentDeserializer(Annotated am) |
|
java.lang.Class<?> |
JaxbAnnotationIntrospector.findDeserializationContentType(Annotated a,
JavaType baseContentType,
java.lang.String propName) |
|
java.lang.Class<?> |
JaxbAnnotationIntrospector.findDeserializationKeyType(Annotated am,
JavaType baseKeyType,
java.lang.String propName) |
|
java.lang.Class<?> |
JaxbAnnotationIntrospector.findDeserializationType(Annotated a,
JavaType baseType,
java.lang.String propName) |
JAXB does allow specifying (more) concrete class for
deserialization by using \@XmlElement annotation.
|
JsonDeserializer<?> |
JaxbAnnotationIntrospector.findDeserializer(Annotated am) |
|
java.lang.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.
|
java.lang.Class<?> |
JaxbAnnotationIntrospector.findSerializationType(Annotated a) |
|
JsonSerialize.Typing |
JaxbAnnotationIntrospector.findSerializationTyping(Annotated a) |
|
java.lang.Class<?>[] |
JaxbAnnotationIntrospector.findSerializationViews(Annotated a) |
|
JsonSerializer<?> |
JaxbAnnotationIntrospector.findSerializer(Annotated am) |
|
java.util.List<NamedType> |
JaxbAnnotationIntrospector.findSubtypes(Annotated a) |
|
boolean |
JaxbAnnotationIntrospector.hasCreatorAnnotation(Annotated am) |