|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
AbstractTypeResolver
instance, to handle resolution of
abstract to concrete types (either by defaulting, or by materializing).
ValueInjector
instances, and add them to builder.
JsonToken.FIELD_NAME
instead of String value).
classWithMixIns
contains into class
destinationClass
.
JsonSerializer.handledType()
specifies (which MUST return a non-null class; and can NOT be Object
, as a
sanity check).
TypeModifier
instance, which can augment JavaType
instances constructed by TypeFactory
.
ValueInstantiator
to use when deserializing
instances of type beanType
.
ValueInstantiator
s,
by adding ValueInstantiators
object that gets called when
instantatiator is needed by a deserializer.
AnnotationMap
).AnnotatedMethod
s, accessible by lookup.BeanPropertyWriter
, but that will be used
for serializing JsonAnyGetter
annotated
(Map) propertiesMapperConfig.withAppendedAnnotationIntrospector(AnnotationIntrospector)
instead;
this method is deprecated as it changes state, preventing immutability of instances
AnnotationIntrospector
as the lowest
priority introspector, chained with existing introspector(s) and called
as fallback for cases not otherwise handled.
ObjectArrayDeserializer
instead.PrimitiveArrayDeserializers
instead.ArrayNode
Construction is done using registered JsonNodeFactory
.
StdArraySerializers
Collection
and array types.JsonTypeInfo.As.WRAPPER_ARRAY
inclusion mechanism.JsonTypeInfo.As.EXTERNAL_PROPERTY
inclusion mechanism.JsonParser
that can read contents
stored in this buffer.
JsonParser
that can read contents
stored in this buffer.
JsonTypeInfo.As.PROPERTY
inclusion mechanism.JsonNode.isValueNode()
returns true), otherwise
empty String.
JsonTypeInfo.As.WRAPPER_OBJECT
inclusion mechanism.JsonNode
implementations.BeanDescription
implementation.Collection
).Collection
).ClassIntrospector
to
help in constructing serializers and deserializers.ValueInstantiator
instead
JsonDeserializer
for deserializing
intances.BeanDeserializerFactory
to participate in constructing BeanDeserializer
instances.JsonFilter
)
for filtering bean properties to serialize.SettableBeanProperty
instances.BeanSerializer
passing an instance of
"compatible enough" source serializer.
JsonSerializer
for serializing
intances.Object.getClass()
does not count);
as well as for "standard" JDK types.BeanSerializerFactory
to participate in constructing BeanSerializer
instances.BeanSerializer
instance with
all accumulated information.
Object[]
(and subtypes, except for String).
List
types that support efficient by-index access
EnumMap
types.
Map
and
ones that do not (but that have been indicated to behave like Maps).
Map
types.
ByteArrayOutputStream
in usage, but more geared to Jackson use cases internally.Name
s, constructed directly from a byte-based
input source.Calendar
.PropertyNamingStrategy.LowerCaseWithUnderscoresStrategy
for details.
ValueInstantiator.createFromDouble(double)
).
ValueInstantiator.createFromDouble(double)
).
ValueInstantiator.createFromInt(int)
).
ValueInstantiator.createFromLong(long)
).
canCreateXxx
method
returns true: that is, if there is any way that an instance could
be created.
JsonGenerator.setSchema(org.codehaus.jackson.FormatSchema)
).
JsonParser.setSchema(org.codehaus.jackson.FormatSchema)
).
BeanSerializerFactory
with tentative set
of discovered properties.
JacksonJsonProvider.isReadable(java.lang.Class>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType)
is called.
JacksonJsonProvider.isWriteable(java.lang.Class>, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType)
is called.
JsonSerializer
s.TypeIdResolver
implementation
that converts between fully-qualified
Java class names and (JSON) Strings.JsonParser.hasCurrentToken()
returns false, and
JsonParser.getCurrentToken()
null).
JsonParser.Feature.AUTO_CLOSE_SOURCE
is enabled.
ContainerDeserializerBase
instead.Collection
instance, with typed contents.Collection
;
but may or may not be instances of that interface.Comparable
) is to prevent constructing a
reference without type information.
ObjectBuffer.completeAndClearBuffer(Object[], int)
, to allow
for constructing explicitly typed result array.
JsonParser.Feature
for list of features)
JsonGenerator.Feature
for list of features)
JsonGenerator.Feature
for list of available features.
JsonParser.Feature
for list of features)
JsonParser
feature for
JsonFactory
instance this object mapper uses.
JsonGenerator
feature for
JsonFactory
instance this object mapper uses.
SettableAnyProperty
for handling unknown bean properties, given a method that
has been designated as such setter.
ArrayType
.
ArrayType
.
BeanDeserializerBuilder
which is used to accumulate information needed to create deserializer
instance.
CollectionLikeType
.
CollectionLikeType
.
CollectionType
.
CollectionType
.
ValueInstantiator
using annotations (like @JsonCreator) and visibility rules
JavaType
out of its canonical
representation (see JavaType.toCanonical()
).
MapLikeType
instance
MapLikeType
instance
MapType
instance
MapType
instance
JavaType
that
represents a parameterized type.
JavaType
that
represents a parameterized type.
POJOPropertiesCollector
instance
to use; override is needed if a custom sub-class is to be used.
JavaType
for given
raw class.
JavaType
for given
type reference
This is a simple short-cut for:
JavaType
out of given
type (typically java.lang.Class
), but without explicit
context.
EnumResolver.constructUsingToString(java.lang.Class)
if static type of enum is not known.
AnnotatedClass.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.
ContainerDeserializerBase
instead.StdContainerSerializers
insteadBigDecimal
.
JsonDeserializer
s can implement to get a callback
that can be used to create contextual instances of deserializer to use for
handling properties of supported type.KeyDeserializer
s can implement to get a callback
that can be used to create contextual instances of key deserializer to use for
handling Map keys of supported type.JsonSerializer
s can implement to get a callback
that can be used to create contextual instances of serializer to use for
handling properties of supported type.DeserializationConfig
object
that defines configuration settings for deserialization.
SerializationConfig
object
that defines configuration settings for serialization.
DeserializerProvider
s call to create a new
deserializer for types other than Collections, Maps, arrays and
enums.
Enum
types.
JsonToken.FIELD_NAME
) for Map that has specified declared
key type, and is for specified property (or, if property is null, as root value)
JsonParser
for
parsing content which is assumed to be in detected data format.
JsonFactory
instance.
SerializerFactory
(see methods
like SerializerFactory.withAdditionalSerializers(Serializers)
)
and through new Module API. As such, this class is not the best way
to add custom functionality, and will likely be removed from 2.0 releaseJsonFactory
instances to use for actual low-level
detection.DataFormatDetector
when requested
to detect format of given input data.JsonNodeDeserializer
instead.Date
values.JsonFactory
instance when
creating parser given an InputStream
, when this decorator
has been registered.
JsonFactory
instance when
creating parser on given "raw" byte source.
JsonFactory
instance when
creating parser given an Reader
, when this decorator
has been registered.
JsonFactory
instance when
creating generator for given OutputStream
, when this decorator
has been registered.
JsonFactory
instance when
creating generator for given Writer
, when this decorator
has been registered.
DateFormat
used unless overridden by
custom implementation.
StdKeySerializers
instead
DefaultPrettyPrinter
; will be removed in Jackson 2.0PrettyPrinter
implementation that uses 2-space
indentation with platform-default linefeeds.ObjectMapper.writerWithDefaultPrettyPrinter()
instead.
Map
keys,
based on SerializationConfig.Feature.WRITE_DATE_KEYS_AS_TIMESTAMPS
value (and if using textual representation, configured date format)
Map
keys,
based on SerializationConfig.Feature.WRITE_DATE_KEYS_AS_TIMESTAMPS
value (and if using textual representation, configured date format)
SerializationConfig
settings to determine expected serialization
behavior.
SerializationConfig
settings to determine expected serialization
behavior.
DeserializationConfig
object owner by
ObjectMapper
) to get calledn when a potentially
recoverable problem is encountered during deserialization
process.SettableBeanProperty.deserializeAndSet(org.codehaus.jackson.JsonParser, org.codehaus.jackson.map.DeserializationContext, java.lang.Object)
implementations.
JsonDeserializer.deserialize(JsonParser, DeserializationContext)
),
which takes in initialized value instance, to be
configured and/or populated by deserializer.
Map
key from JSON property name.
DeserializerProvider
to obtain actual
JsonDeserializer
instances from multiple distinct factories.ObjectMapper
and
JsonDeserializer
s to obtain deserializers capable of
re-constructing instances of handled type from JSON content.Deserializers
implementation that implements all methods but provides
no deserializers.Deserializers.Base
insteadJsonParser.Feature
for list of features)
JsonGenerator.Feature
for list of features)
JsonGenerator.Feature
for list of features)
JsonParser.Feature
for list of features)
DeserializationConfig.without(org.codehaus.jackson.map.DeserializationConfig.Feature...)
instead;
this method is deprecated as it modifies current instance instead of
creating a new one (as the goal is to make this class immutable)
DeserializationConfig
features.
DeserializationConfig
features.
SerializationConfig.without(org.codehaus.jackson.map.SerializationConfig.Feature...)
instead;
this method is deprecated as it modifies current instance instead of
creating a new one (as the goal is to make this class immutable)
JsonTypeInfo
) will have
additional embedded type information.
JsonGenerator.disable(org.codehaus.jackson.JsonGenerator.Feature)
instead
JsonParser.disable(Feature)
instead
JsonFactory.disable(JsonGenerator.Feature)
instead
JsonFactory.disable(JsonParser.Feature)
instead
JsonParser.Feature
for list of features)
JsonGenerator.Feature
for list of features)
JsonGenerator.Feature
for list of available features.
JsonParser.Feature
for list of features)
DeserializationConfig.with(org.codehaus.jackson.map.DeserializationConfig.Feature...)
instead;
this method is deprecated as it modifies current instance instead of
creating a new one (as the goal is to make this class immutable)
DeserializationConfig
features.
DeserializationConfig
features.
SerializationConfig.with(org.codehaus.jackson.map.SerializationConfig.Feature...)
instead;
this method is deprecated as it modifies current instance instead of
creating a new one (as the goal is to make this class immutable)
JsonTypeInfo
).
JsonTypeInfo
) --
using "As.PROPERTY" inclusion mechanism and specified property name
to use for inclusion (default being "@class" since default type information
always uses class name as type identifier)
JsonGenerator.enable(org.codehaus.jackson.JsonGenerator.Feature)
instead
JsonParser.enable(Feature)
instead
JsonFactory.enable(JsonGenerator.Feature)
instead
JsonFactory.enable(JsonParser.Feature)
instead
EnumDeserializer
instead.EnumMap
s.EnumResolver
instead.EnumSerializer
Enum
types.CharacterEscapes.getEscapeSequence(int)
is needed to figure out exact escape
sequence to output.
JsonTypeInfo.As.EXTERNAL_PROPERTY
).JsonGenerationException
if its FailingSerializer.serialize(java.lang.Object, org.codehaus.jackson.JsonGenerator, org.codehaus.jackson.map.SerializerProvider)
gets invoked.BeanPropertyWriter
that will filter out
properties that are not to be included in currently active
JsonView.ObjectMapper.writer(FilterProvider)
instead.
BeanPropertyFilter
that match given ids.XmlAccessType
annotation value
for given annotated entity, if it has one, or inherits one from
its ancestors (in JAXB sense, package etc).
JsonAnyGetter
.
JsonAnySetter
.
BeanDeserializerFactory
to properly link
managed- and back-reference pairs.
BeanSerializer
for
given class.
Collection
(List, Set etc) type.
Collection
but does not implement it).
Collection
, array
or
Map
property.
Collection
, array
or Map
property.
BeanDescription.findProperties()
Enum
type.
EnumSet
, without having
access to its declaration.
EnumSet
, without having
access to its declaration.
BeanPropertyFilter
that has specified id.
InputStream
) given has, as per configuration of this detector
instance.
BeanDescription.findProperties()
valueId
to
inject as value of specified property during deserialization, passing
POJO instance in which value will be injected if it is available
(will be available when injected via field or setter; not available
when injected via constructor or factory method argument).
JsonValue
annotation,
if any.
Map
property.
Map
.
Map
property.
Map
type.
Map
but does not implement it).
JsonNode.findValue(java.lang.String)
, but that will return a
"missing node" instead of null if no field is found.
JsonTypeInfo
from a property too.
JsonTypeInfo
from a property too.
findSerializerByLookup
).
BeanDescription.findProperties()
BeanDeserializerFactory
to see if there might be a standard
deserializer registered for given type.
ValueInstantiator
to use for given
type (class): return value can either be an instance of
instantiator, or class of instantiator to create.
ValueInstantiator
to use for creating
instances of specified type during deserialization.
JsonNode.findValues(java.lang.String)
, but will additionally convert
values into Strings, calling JsonNode.getValueAsText()
.
SerializerProvider.findValueSerializer(Class)
, but takes full generics-aware
type instead of raw class.
AccessibleObject.setAccessible(java.lang.reflect.AccessibleObject[], boolean)
on
the underlying annotated element.
StdDeserializerProvider.cachedDeserializersCount()
).
DeserializerProvider.cachedDeserializersCount()
).
JavaType.narrowBy(java.lang.Class>)
, called by
internal framework in cases where compatibility checks
are to be skipped.
JsonFactory.getFormatName()
JsonParser
and JsonGenerator
implementations to further
specify structure of expected format.TypeFactory.type(Type)
instead
FromStringDeserializer
instead.TypeFactory.type(Type)
instead
TypeFactory.type(Type)
instead
AnnotationIntrospector
configured
to introspect annotation values used for configuration.
AnnotationIntrospector
configured
to introspect annotation values used for configuration.
JsonToken.VALUE_NUMBER_INT
and
it can not be used as a Java long primitive type due to its
magnitude.
JsonNode.isBinary()
returns true); or for Text Nodes
(ones for which JsonNode.getTextValue()
returns non-null value),
to read decoded base64 data.
JsonParser.getBinaryValue(Base64Variant)
that defaults to using
Base64Variants.getDefaultVariant()
as the default encoding.
JsonToken.VALUE_TRUE
or
JsonToken.VALUE_FALSE
.
JsonToken.VALUE_NUMBER_INT
and
it can be expressed as a value of Java byte primitive type.
JsonGenerator
s
it creates.
JsonGenerator
s
it creates.
JsonGenerator
s
it creates.
JsonGenerator
s
it creates.
JsonGenerator.writeObject(java.lang.Object)
).
ObjectCodec
associated with this
parser, if any.
ObjectMapper
to use
JsonToken.FIELD_NAME
s it will
be the same as what JsonParser.getText()
returns;
for field values it will be preceding field name;
and for others (array values, root-level values) null.
JsonToken.VALUE_NUMBER_FLOAT
or
JsonToken.VALUE_NUMBER_INT
.
DeserializationConfig
object
that defines configuration settings for deserialization.
JsonToken.VALUE_NUMBER_FLOAT
and
it can be expressed as a Java double primitive type.
JsonToken.VALUE_EMBEDDED_OBJECT
.
JsonToken.VALUE_NUMBER_FLOAT
and
it can be expressed as a Java float primitive type.
ValueInstantiator.canCreateFromObjectWith()
returns true).
InputStream
or Reader
, depending on what
parser was constructed with.
JsonNode.isNumber()
returns true).
JsonToken.VALUE_NUMBER_INT
and
it can be expressed as a value of Java int primitive type.
JsonFactory
that this
mapper uses if it needs to construct JsonParser
s
and/or JsonGenerator
s.
JsonParser.clearCurrentToken()
.
JsonToken.VALUE_NUMBER_INT
and
it can be expressed as a Java long primitive type.
ObjectMapper
that implements this context.
JsonFactory
that represents format that data matched.
MatchStrength.INCONCLUSIVE
.
JsonNodeFactory
that this mapper will use when directly constructing
root JsonNode
instances for Trees.
JsonToken.VALUE_NULL
).
JsonNode.isNumber()
),
returns native type that node uses to store the numeric
value.
JsonToken.VALUE_NUMBER_INT
or
JsonToken.VALUE_NUMBER_FLOAT
, returns
one of JsonParser.NumberType
constants; otherwise returns null.
JsonNode.isNumber()
returns true); otherwise
returns null
OutputStream
or Writer
, depending on what
generator was constructed with.
JsonNode.path(String)
instead
JsonNode.path(int)
instead
BeanDeserializer
have
been collected.
SettableBeanProperty.getName()
instead.
SettableBeanProperty.getPropertyIndex()
instead
SerializationConfig
object that defines configuration settings for serialization.
JsonToken.VALUE_NUMBER_INT
and
it can be expressed as a value of Java short primitive type.
ReaderBasedParser.nextToken()
, or
after encountering end-of-input), returns null.
JsonParser.nextToken()
, or
after encountering end-of-input), returns null.
JsonParser.getText()
, but that will return
underlying (unmodifiable) character array that contains
textual value, instead of constructing a String object
to contain this information.
JsonParser.getTextCharacters()
, to know length
of String stored in returned buffer.
JsonParser.getTextCharacters()
, to know offset
of the first text content character within buffer.
TypeFactory
instance.
SerializerFactory
instances are able to construct a serializer.
JsonNode.asBoolean()
instead
JsonNode.asBoolean()
instead
JsonNode.asDouble()
instead
JsonNode.asDouble()
instead
JsonNode.asInt()
instead
JsonNode.asInt()
instead
JsonNode.asLong()
instead
JsonNode.asLong()
instead
JsonNode.asText()
instead
JsonSerializer
s, JsonDeserializer
s, various type
handlers) of specific types.TokenBuffer
(as field entries, name and value).
DeserializationProblemHandler
s
of an unrecognized property.
DeserializationProblemHandler
s
of an unrecognized property.
ByteSourceBootstrapper
);
supports UTF-8, for example.
MappingIterator.next()
but one that may throw checked
exceptions from Jackson due to invalid input.
TextBuffer.getTextBuffer()
.
JsonParser.getTextCharacters()
would be the most efficient
way to access textual content for the event parser currently
points to.
Class
(and/or various Type subtypes)
that is used as part of single-path extends/implements chain to express
specific relationship between one subtype and one supertype.List
s that contains Strings and are random-accessible.InetAddress
.NumberInput.inLongRange(char[],int,int,boolean)
, but
with String argument
InputStream
and buffers it as necessary.MapperConfig.withInsertedAnnotationIntrospector(AnnotationIntrospector)
instead;
this method is deprecated as it changes state, preventing immutability of instances
AnnotationIntrospector
as the highest
priority introspector (will be chained with existing introspector(s) which
will be used as fallbacks for cases this introspector does not handle)
JsonNodeDeserializer.getDeserializer(java.lang.Class>)
accessor instead: will be removed from 2.0
BasicSerializerFactory
, this factory is stateless, and
thus a single shared global (== singleton) instance can be used
without thread-safety issues.
JsonParser.Feature
is enabled.
MapperConfig.isEnabled(MapperConfig.ConfigFeature)
,
needed for backwards-compatibility.
MapperConfig.isEnabled(org.codehaus.jackson.map.MapperConfig.ConfigFeature)
.
JsonToken.START_ARRAY
) when start array is expected.
JsonGenerator.isEnabled(org.codehaus.jackson.JsonGenerator.Feature)
instead
JsonParser.isEnabled(Feature)
instead
JsonFactory.isEnabled(JsonGenerator.Feature)
instead
BeanUtil.isCglibGetCallbacks(org.codehaus.jackson.map.introspect.AnnotatedMethod)
, need to suppress
a cyclic reference to resolve [JACKSON-103]
JsonFactory.isEnabled(JsonParser.Feature)
instead
Collection
or just something that acts
like one.
Collection
or just something that acts
like one.
JsonNode.getElements()
; implemented so that
convenience "for-each" loop can be used for looping over elements
of JSON Array constructs.
AnnotationIntrospector
implementation that handles standard
Jackson annotations.MessageBodyReader
,
MessageBodyWriter
) needed for binding
JSON ("application/json") content to and from Java Objects ("POJO"s).StdJdkSerializers
DateTime
.JsonAnySetter
method; basically being used like a
getter but such that contents of the returned Map (type must be
Map
) are serialized as if they were actual properties
of the bean that contains method/field with this annotations.JsonDeserializer
)
can be cached.ObjectMapper
(and
other chained JsonDeserializer
s too) to deserialize Objects of
arbitrary types from JSON, using provided JsonParser
.JsonParser
)
and writer (aka generator, JsonGenerator
)
instances.ObjectMapper
(or objects
it delegates to) providing matching filters by id.JsonProperty
instead (deprecated since version 1.5)ExceptionMapper
to send down a "400 Bad Request"
response in the event that unmappable JSON is received.JsonAutoDetect
apply to.JsonNodeDeserializer
instead.JsonNode
from any
JSON content, using appropriate JsonNode
type.ExceptionMapper
to send down a "400 Bad Request"
in the event unparsable JSON is received.JsonParser
implementations.JsonParser
,
to allow for simple overridability of basic parsing functionality.JsonParser
implementations, but does not add any additional fields that depend
on particular method of obtaining input.JsonParser
s to create a single logical sequence of
tokens, as a single JsonParser
.JsonStreamContext
, which implements
core methods needed, and also exposes
more complete API to parser implementation classes.XmlRootElement
,
used to indicate name to use for root-level wrapping, if wrapping is
enabled.JsonNode
that represents a JSON-Schema instance.JsonSerializable
to
allow for dynamic type information embedding.JsonSerialize.include()
property
to define which properties
of Java Beans are to be included in serializationJsonSerialize.typing()
property
to define whether type detection is based on dynamic runtime
type (DYNAMIC) or declared type (STATIC).ObjectMapper
(and
other chained JsonSerializer
s too) to serialize Objects of
arbitrary types into JSON, using provided JsonGenerator
.JsonProperty
annotation (which was introduced in version 1.1).JsonTypeInfo
to indicate sub types of serializable
polymorphic types, and to associate logical names used within JSON content
(which is more portable than using physical Java class names).TypeIdResolver
)
to be used by
TypeSerializer
s
and TypeDeserializer
s
for converting between java types and type id included in JSON content.defaultImpl
annotation property, to indicate that there is no default implementation
specified.XmlValue
that indicates that results of the annotated "getter" method
(which means signature must be that of getters; non-void return
type, no args) is to be used as the single value to serialize
for the instance.ValueInstantiator
to use
for creating instances of specified type.JsonValue
annotation to
indicate that serialization should be done by calling the method
annotated, and serializing result it returns.JavaType
,
to ensure type has been properly resolved
JsonStreamContext
, which implements
core methods needed, and also exposes
more complete API to generator implementation classes.JsonSerialize.include()
(with values ALWAYS
or NON_NULL
)ObjectMapper
to use for serialization
and deserialization.
MapDeserializer
instead.Map
instance, with typed contents.Map
, but that do not have enough
introspection functionality to allow for some level of generic handling.MapperConfig
implementations must implement.ObjectMapper
instance to be used for data binding, as
well as accessing it.ObjectMapper
when binding sequence of
objects.JsonFactory
that will create a proper
ObjectCodec
to allow seamless conversions between
Json content and Java objects (POJOs).MapSerializer
Method
s and Constructor
s)
in Map
s.InputStream
implementation that is used to "unwind" some
data previously read from an input stream; so that as long as some of
that data remains, it's returned; but as long as it's read, we'll
just use data from the underlying original stream.Base64Variants.MIME
which does not
use linefeeds (max line length set to infinite).
PrettyPrinter
implementation that adds no indentation,
just implements everything necessary for value output to work
as expected, and provide simpler extension points to allow
for creating simple custom implementations that add specific
decoration or overrides.BeanDeserializerFactory
after constructing default
bean deserializer instance with properties collected and ordered earlier.
BeanSerializerFactory
after constructing default
bean serializer instance with properties collected and ordered earlier.
ObjectMapper
to provide a well-defined set of extensions to default functionality; such as
support for new data types.InputStream
.JsonParser.nextToken()
) and
if it is JsonToken.VALUE_TRUE
or JsonToken.VALUE_FALSE
returns matching Boolean value; otherwise return null.
EOFException
.
JsonParser.nextToken()
) and
verifies whether it is JsonToken.FIELD_NAME
with specified name
and returns result of that comparison.
JsonParser.nextToken()
) and
if it is JsonToken.VALUE_NUMBER_INT
returns 32-bit int value;
otherwise returns specified default value
It is functionally equivalent to:
JsonParser.nextToken()
) and
if it is JsonToken.VALUE_NUMBER_INT
returns 64-bit long value;
otherwise returns specified default value
It is functionally equivalent to:
JsonParser.nextToken()
) and
if it is JsonToken.VALUE_STRING
returns contained String value;
otherwise returns null.
Serializers
array (which by definition
is stateless and reusable)
AnnotationIntrospector
.Object[]
).JsonParser
and
JsonGenerator
use to serialize and deserialize regular
Java objects (POJOs aka Beans).JsonFactory
as necessary, use
StdSerializerProvider
as its
SerializerProvider
, and
BeanSerializerFactory
as its
SerializerFactory
.
JsonFactory
for constructing necessary JsonParser
s and/or
JsonGenerator
s.
ObjectMapper.setSerializerFactory(org.codehaus.jackson.map.SerializerFactory)
TypeResolverBuilder
that provides type resolver builders
used with so-called "default typing"
(see ObjectMapper.enableDefaultTyping()
for details).ObjectMapper.enableDefaultTyping()
to specify what kind of types (classes) default typing should
be used for.ObjectNode
Construction is done using registered JsonNodeFactory
.
ObjectMapper
for initial instantiation
ObjectMapper
for initial instantiation
BeanSerializerFactory
with set of properties
to serialize, in default ordering (based on defaults as well as
possible type annotations).
JsonFactory
used for constructing
JSON parser (JsonParser
)
and generator
(JsonParser
)
instances.ObjectMapper
class, as well
as convenience methods included in
JsonParser
TypeResolverBuilder
and
TypeIdResolver
.Module
s
(which are registered using
ObjectMapper.registerModule(org.codehaus.jackson.map.Module)
.JavaType
, as
well as the factory (TypeFactory
) for
constructing instances from various input data types
(like Class
, Type
)
and programmatically (for structured types, arrays,
List
s and Map
s).JsonNode
implementations
Jackson uses for the Tree model.MapperConfig.getDateFormat()
).
JsonNode.get(String)
, except
that instead of returning null if no such value exists (due
to this node not being an object, or object not having value
for the specified field),
a "missing node" (node that returns true for
JsonNode.isMissingNode()
) will be returned.
JsonNode.get(int)
, except
that instead of returning null if no such element exists (due
to index being out of range, or this node not being an array),
a "missing node" (node that returns true for
JsonNode.isMissingNode()
) will be returned.
Base64Variants.MIME
: it is otherwise
identical, except that it mandates shorter line length.
ObjectMapper
).ObjectMapper.writer(FilterProvider)
instead.
BeanSerializerFactory
that is used to
construct BeanPropertyWriter
instances.PropertyNamingStrategy
that translates typical camel case Java
property names to lower case JSON element names, separated by
underscores.PropertyValue
s.BasicDeserializerFactory
to register deserializers this class provides.
BasicSerializerFactory
to access
all serializers this class provides.
ObjectReader
with
default settings.
ObjectReader
that will
read or update instances of specified type
ObjectReader
that will
read or update instances of specified type
ObjectReader
that will
read or update instances of specified type
ObjectReader
that will
use specified JsonNodeFactory
for constructing JSON trees.
ObjectReader
that will
pass specific schema object to JsonParser
used for
reading content.
ObjectReader
that will
use specified injectable values.
JsonParser
, which is
based on a Reader
to handle low-level character
conversion tasks.ObjectReader
that will
update given Object (usually Bean, but can be a Collection or Map
as well, but NOT an array) with JSON data.
JsonNode
instances.
JsonNode
instances.
JsonNode
instances.
JsonNode
instances.
JsonNode
instances.
JsonNode
instances.
JsonNode
instances.
JsonNode
instances.
JsonNode
instances.
Boolean
).
Boolean
).
Boolean
).
JsonNode
instances.
Boolean
).
JsonNode
of resulting model.
JsonIgnoreType
annotation but
can be supplied by module-provided introspectors too.
DeserializerProvider
,
but before being used.SerializerProvider
,
but before being used.DeserializerProvider
has registered
the deserializer, but before it has returned it to the caller.
SerializerProvider
has registered
the serializer, but before it has returned it to the caller.
DeserializationContext.leaseObjectBuffer()
.
JsonMappingException
SerializerBase
instead.ObjectMapper.reader(FormatSchema)
instead.
ObjectMapper.writer(FilterProvider)
instead.
StringWriter
, based on using segmented
internal buffer.JsonSerializable
.JsonSerializableWithType
.BeanPropertyWriter
instances.
BeanPropertyWriter
instances.
JsonGenerator
.
BeanSerializer
to let filter decide what to do with
given bean property value: the usual choices are to either filter out (i.e.
BeanPropertyFilter
that needs to be called to determine
which properties are to be serialized (and possibly how)
SerializerBase
SerializerProvider
to obtain actual
JsonSerializer
instances from multiple distinct factories.ObjectMapper
and
JsonSerializer
s to obtain serializers capable of serializing
instances of specific types.Serializers
implementation that implements all methods but provides
no serializers.Serializers.Base
insteadObjectMapper
to
execute recursive serialization, using serializers that
this provider has access to.
ObjectMapper
to
execute recursive serialization, using serializers that
this provider has access to; and using specified root type
for locating first-level serializer.
DeserializationConfig.without(org.codehaus.jackson.map.DeserializationConfig.Feature...)
and DeserializationConfig.with(org.codehaus.jackson.map.DeserializationConfig.Feature...)
instead;
this method is deprecated as it modifies current instance instead of
creating a new one (as the goal is to make this class immutable)
SerializationConfig.without(org.codehaus.jackson.map.SerializationConfig.Feature...)
and SerializationConfig.with(org.codehaus.jackson.map.SerializationConfig.Feature...)
instead;
this method is deprecated as it modifies current instance instead of
creating a new one (as the goal is to make this class immutable)
MapperConfig.withAnnotationIntrospector(AnnotationIntrospector)
or
Module API instead
AnnotationIntrospector
used by this
mapper instance for both serialization and deserialization
JsonGenerator
s
it creates.
JsonGenerator
s
it creates.
ObjectCodec
(typically
a ObjectMapper
) with
this factory (and more importantly, parsers and generators
it constructs).
JsonGenerator.writeObject(java.lang.Object)
).
ObjectCodec
associated with this
parser, if any.
ObjectMapper
instead; or construct new instance with
MapperConfig.withDateFormat(DateFormat)
DateFormat
to use when serializing time
values as Strings, and deserializing from JSON Strings.
SerializationConfig.withDateFormat(java.text.DateFormat)
instead.
DeserializerProvider
to use
for handling caching of JsonDeserializer
instances.
JsonGenerator.configure(org.codehaus.jackson.JsonGenerator.Feature, boolean)
instead
JsonParser.configure(org.codehaus.jackson.JsonParser.Feature, boolean)
instead
JsonFactory.configure(JsonGenerator.Feature, boolean)
instead
HandlerInstantiator
to use for creating
instances of handlers (such as serializers, deserializers, type and type
id resolvers), given a class.
ObjectMapper
to use
for serialization and deserialization; if null, will use the standard
provider discovery from context instead.
mixinClass
should be "mixed in" with annotations that targetType
has (as if they were directly included on it!).
JsonNodeFactory
to use for
constructing root level tree nodes (via method
ObjectMapper.createObjectNode()
JsonFactory.configure(JsonParser.Feature, boolean)
instead
SerializationConfig.withSerializationInclusion(org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion)
to construct new instance, or configure through ObjectMapper
SerializationConfig.withView(java.lang.Class>)
instead
SerializerFactory
to use
for constructing (bean) serializers.
SerializerProvider
to use
for handling caching of JsonSerializer
instances.
TypeFactory
instance
used by this mapper.
ObjectMapper
when module is registered.
withContentTypeHandler
and
withContentValueHandler
methods.
VisibilityChecker
s, to change details of what kinds of
properties are auto-detected.
AbstractTypeResolver
implementation, which is
based on static mapping from abstract super types into
sub types (concrete or abstract), but retaining generic
parameterization.BeanPropertyFilter
implementation that only uses property name
to determine whether to serialize property as is, or to filter it out.Deserializers
which allows registration of
deserializers based on raw (type erased class).FilterProvider
implementation that just stores
direct id-to-filter mapping.KeyDeserializers
which allows registration of
deserializers based on raw (type erased class).Module
implementation that allows registration
of serializers and deserializers, and bean serializer
and deserializer modifiers.Serializers
which allows registration of
serializers based on raw (type erased class).JsonToken.START_OBJECT
or JsonToken.START_ARRAY
.
String[]
values.List
s,
Map
s and such.LinkedList
that can not}.DateFormat
implementation used by standard Date
serializers and deserializers.DeserializationContext
.StdDeserializer
instead.CalendarDeserializer
instead.ClassDeserializer
instead.Number.class
, we can just rely on type
mappings that plain JsonParser.getNumberValue()
returns.Date
, SQL version is easier
to deal with: mostly because it is more limited.StringDeserializer
instead.DeserializerProvider
implementation.ToStringSerializer
,
others explicit serializers.StdKeyDeserializer
instead.Map
s to JSON
Objects.StdKeySerializer
insteadStdScalarDeserializer
instead.SerializerProvider
implementation.StdSerializerProvider.createInstance(org.codehaus.jackson.map.SerializationConfig, org.codehaus.jackson.map.SerializerFactory)
(or by
sub-classes)
DateSerializer
insteadDouble
s
(and primitive doubles)Integer
s
(and primitive ints)StdSerializers.IntegerSerializer
, but will not cast to Integer:
instead, cast is to Number
, and conversion is
by calling Number.intValue()
.Number
s (custom types).DateSerializer
insteadDateSerializer
insteadStdSerializers.UtilDateSerializer
, we do use String
representation here.StringSerializer
insteadDateSerializer
insteadTypeResolverBuilder
implementation.ValueInstantiator
implementation, which only
supports use of default constructor.Collection
s that contain Strings.String
s.StringBuffer
, with
following differences:
TextBuffer uses segments character arrays, to avoid having
to do additional array copies when array is not big enough.BeanDeserializer
but
override some aspects like instance construction.ThrowableDeserializer
instead.IllegalArgumentException
if it
is a checked exception; otherwise (runtime exception or error) throw as is
IllegalArgumentException
(and with
specified message) if it
is a checked exception; otherwise (runtime exception or error) throw as is
Exception
or Error
as is.
Timestamp
values.TypeFactory
from mapper package).
JsonToken
sequences, needed for temporary buffering.TokenBuffer
.TokenBuffer
;
and since it is part of core package, it can not implement
JsonSerializable
(which is only included in the mapper package)TextBuffer.contentsAsString()
, since it's not guaranteed that resulting
String is cached.
Object.toString()
returns the desired JSON
value.ToStringSerializer.instance
which is stateless and fully thread-safe.
ToStringSerializer
JsonParser
instance for
iterating over contents of the tree that this
node is root of.
JsonParser
out of JSON tree
representation.
JsonParser
for reading
contents of a JSON tree, as if it was external serialized
JSON content.
JsonNode
that implements JsonParser
to allow
accessing contents of JSON tree in alternate form (stream of tokens).ObjectMapper.writerWithType(Class)
instead.
ObjectMapper.writerWithType(JavaType)
instead.
ObjectMapper.writerWithType(TypeReference)
instead.
JavaType
instances,
given various inputs.TypeIdResolver
of
specified type.
JavaType
instances constructed using TypeFactory
.JavaType
representations and constructing type instances.JsonTypeInfo
or JAXB annotations),
and produce type serializers and deserializers used for
handling type information embedded in JSON to allow for safe
polymorphic type handling.TypeIdResolver
of
specified type.
java.lang.Object
.
JsonMappingException
sub-class specifically used
to indicate problems due to encountering a JSON property that could
not be mapped to an Object property (via getter, constructor argument
or field).Object
(either explicitly, or due to type erasure).UntypedObjectDeserializer
instead.IllegalArgumentException
if it
is a checked exception; otherwise (runtime exception or error) throw as is
IllegalArgumentException
if it
is a checked exception; otherwise (runtime exception or error) throw as is
BeanPropertyWriter
which will handle unwrapping
of JSON Object (including of properties of Object within surrounding
JSON object, and not as sub-object).BeanSerializer
BeanDeserializerFactory
when it has collected
basic information such as tentative list of properties to deserialize.
BeanSerializerFactory
after collecting all information
regarding POJO to serialize and updating builder with it, but before constructing
serializer.
ObjectMapper.readerForUpdating(java.lang.Object)
instead.
DefaultPrettyPrinter
).
JsonParser
, which is
based on a InputStream
as the input source.EnumValues.serializedValueFor(java.lang.Enum>)
instead
ValueInstantiator
instances.ObjectMapper.treeToValue(org.codehaus.jackson.JsonNode, java.lang.Class)
; given a value (usually bean), will
construct equivalent JSON Tree representation.
Versioned.version()
.Version
for details).
Version
s.ObjectMapper.writerWithView(Class)
instead.
JsonAutoDetect.Visibility
value to use for all property elements.
AbstractTypeResolver
.
DeserializerFactory
that provider has
to use specified deserializer provider, with highest precedence (that is,
additional providers have higher precedence than default one or previously
added ones)
KeyDeserializers
.
AnnotationIntrospector
to use (replacing old one).
AnnotationIntrospector
appended (as the lowest priority one)
ClassIntrospector
to use.
DateFormat
to use.
Feature.WRITE_DATES_AS_TIMESTAMPS
(enable if format set as null; disable if non-null)
BeanDeserializerModifier
.
Annotated
as fallback annotations
HandlerInstantiator
to use.
AnnotationIntrospector
inserted (as the highest priority one)
Method
.
ObjectMapper.registerModule(org.codehaus.jackson.map.Module)
; functionally equivalent to:
JsonNodeFactory
PropertyNamingStrategy
to use.
SubtypeResolver
to use.
TypeFactory
to use.
TypeResolverBuilder
to use.
ValueInstantiators
.
TypeSerializer
for decorating
contained values with additional type information.
JsonAutoDetect.Visibility
value to use for specified property.
VisibilityChecker
to use.
IOException
, or an unchecked exception.
DeserializationContext
DeserializationContext
IOException
, or an unchecked exception.
SerializerProvider
instead.
SerializerProvider
instead.
JsonGenerator.writeBinary(Base64Variant,byte[],int,int)
,
but default to using the Jackson default Base64 variant
(which is Base64Variants.MIME_NO_LINEFEEDS
).
JsonGenerator.writeBinary(Base64Variant,byte[],int,int)
,
but assumes default to using the Jackson default Base64 variant
(which is Base64Variants.MIME_NO_LINEFEEDS
).
JsonGenerator.writeFieldName(String)
, main difference
being that it may perform better as some of processing (such as
quoting of certain characters, or encoding into external encoding
if supported by generator) can be done just once and reused for
later calls.
JsonGenerator.writeFieldName(String)
, main difference
being that it may perform better as some of processing (such as
quoting of certain characters, or encoding into external encoding
if supported by generator) can be done just once and reused for
later calls.
ObjectWriter
with default settings.
ObjectWriter
that will
serialize objects using specified DateFormat
; or, if
null passed, using timestamp (64-bit number.
ObjectWriter
that will
serialize objects using specified pretty printer for indentation
(or if null, no pretty printer)
ObjectWriter
that will
serialize objects using specified filter provider.
ObjectWriter
that will
pass specific schema object to JsonGenerator
used for
writing content.
JsonGenerator.writeString(String)
but that takes as
its input a UTF-8 encoded String that is to be output as-is, without additional
escaping (type of which depends on data format; backslashes for JSON).
JsonGenerator
that outputs JSON content using a Writer
which handles character encoding.ObjectWriter
that will
serialize objects using the default pretty printer for indentation
ObjectWriter
that will
serialize objects using specified root type, instead of actual
runtime type of value.
ObjectWriter
that will
serialize objects using specified root type, instead of actual
runtime type of value.
ObjectWriter
that will
serialize objects using specified root type, instead of actual
runtime type of value.
ObjectWriter
that will
serialize objects using specified JSON View (filter).
JsonGenerator.writeString(String)
, but that takes
SerializableString
which can make this potentially
more efficient to call as generator may be able to reuse
quoted and/or encoded representation.
ObjectReader
.
TypeSerializer.writeTypeSuffixForScalar(java.lang.Object, org.codehaus.jackson.JsonGenerator)
.
TypeSerializer.writeTypePrefixForObject(java.lang.Object, org.codehaus.jackson.JsonGenerator)
.
TypeSerializer.writeTypePrefixForScalar(java.lang.Object, org.codehaus.jackson.JsonGenerator)
.
JsonGenerator.writeString(String)
but that takes as its input
a UTF-8 encoded String which has not been escaped using whatever
escaping scheme data format requires (for JSON that is backslash-escaping
for control characters and double-quotes; for other formats something else).
JsonGenerator
.
JsonGenerator
,
configured as per passed configuration object.
JsonEncoding.UTF8
).
JsonGenerator
.
JsonEncoding.UTF8
).
Class
or
ParameterizedType
.
JsonAnyGetter
annotated properties
MinimalClassNameIdResolver._basePackageName
, but includes trailing dot.
JsonParserMinimalBase.getBinaryValue(org.codehaus.jackson.Base64Variant)
will not need to decode data more
than once.
InputAccessor.Std._buffer
that are valid
buffered content.
DataFormatMatcher._bufferedData
that were read.
ArrayList
to its supertypes.
HashMap
to its supertypes.
JsonGenerator.Feature.WRITE_NUMBERS_AS_STRINGS
).
_charBuffer
JsonParseException
s
based on current state of the parser
TypeResolverBuilder
implementation.
getGenericXxx
methods
(usually for a return or argument type).
BeanPropertyWriter
for
given member (field or method).
Writer
and context object.
InputStream
and context object.
Reader
object for reading content.
Reader
object for reading content
passed as raw byte array.
OutputStream
and context object, using UTF-8 encoding.
JsonParser.nextToken()
, if any.
MapperConfigurator.setAnnotationsToUse(org.codehaus.jackson.jaxrs.Annotations[])
JsonSerialize.Inclusion.ALWAYS
, we need to know the default
value of the bean, to know if property value equals default
one.
StdValueInstantiator.createUsingDefault()
)
JsonGenerator.Feature
s
are enabled.
JsonParser.Feature
s
are enabled.
TypeResolverBuilder
if given annotated element indicates one is needed.
BeanDeserializer.resolve(org.codehaus.jackson.map.DeserializationConfig, org.codehaus.jackson.map.DeserializerProvider)
).
TypeParser
when generics-aware version
is constructed.
JsonGenerator.Feature
s
are enabled.
Collection
instance that contained
the reference; used if index is relevant and available.
_buckets.length - 1
, when _buckets.length is
a power of two.
ValueInjector
s, if any injectable values are
expected by the bean; otherwise null.
JsonParser
and JsonGenerator
instances as necessary.
JsonGenerator
s
JsonGenerator
s
JsonParser.clearCurrentToken()
was called.
ObjectMapper
DataFormatMatcher._match
BeanDeserializer
instances
are configured and constructed.
BeanSerializer
instances
are configured and constructed.
TypeModifier
s: objects that can change details
of JavaType
instances factory constructs.
JsonParserMinimalBase.getTextCharacters()
method (instead of String
returning alternatives)
JsonParserSequence._parsers
.
JsonNode
instances.
Map
having null key.
ObjectMapper
, but that abstract is not part of core
package.
Utf8Generator._outputStream
.
WriterBasedGenerator._writer
.
char
s that we know will always fit
in the output buffer after escaping
ObjectMapper
to use for actual
serialization.
InputAccessor.Std._buffer
.
ThreadLocal
contains a SoftRerefence
to a BufferRecycler
used to provide a low-cost
buffer recycling between reader and writer instances.
SerializationConfig
which is needed to
know if serializer will by default sort properties in
alphabetic order.
ThreadLocal
contains a SoftRerefence
to a BufferRecycler
used to provide a low-cost
buffer recycling between reader and writer instances.
JavaType
instances;
needed to allow modules to add more custom type handling
(mostly to support types of non-Java JVM languages)
JavaType
instances;
needed to allow modules to add more custom type handling
(mostly to support types of non-Java JVM languages)
SimpleType._typeParameters
Object.class
)
Object
in some case)
JavaType._narrow(java.lang.Class>)
, since
underlying type construction is usually identical
JsonGeneratorBase.writeEndArray()
instead
of defining this method
JsonGeneratorBase.writeEndObject()
instead
of defining this method
_writeFieldName
, off-lined
to keep the "fast path" as simple (and hopefully fast) as possible.
_writeFieldName
, off-lined
to keep the "fast path" as simple (and hopefully fast) as possible.
JsonGeneratorBase.writeStartArray()
instead
of defining this method
JsonGeneratorBase.writeStartObject()
instead
of defining this method
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |