|
||||||||||
| 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.
ValueInstantiators,
by adding ValueInstantiators object that gets called when
instantatiator is needed by a deserializer.
AnnotationMap).AnnotatedMethods, 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.
StdArraySerializersCollection
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.Names, 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.
JsonSerializers.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.
JsonDeserializers can implement to get a callback
that can be used to create contextual instances of deserializer to use for
handling properties of supported type.KeyDeserializers 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.JsonSerializers 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.
DeserializerProviders 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
JsonDeserializers 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.EnumMaps.EnumResolver instead.EnumSerializerEnum 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.
JsonGenerators
it creates.
JsonGenerators
it creates.
JsonGenerators
it creates.
JsonGenerators
it creates.
JsonGenerator.writeObject(java.lang.Object)).
ObjectCodec associated with this
parser, if any.
ObjectMapper to use
JsonToken.FIELD_NAMEs 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 JsonParsers
and/or JsonGenerators.
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
JsonSerializers, JsonDeserializers, various type
handlers) of specific types.TokenBuffer
(as field entries, name and value).
DeserializationProblemHandlers
of an unrecognized property.
DeserializationProblemHandlers
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.Lists 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).StdJdkSerializersDateTime.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 JsonDeserializers 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.JsonParsers 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 JsonSerializers 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
TypeSerializers
and TypeDeserializers
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).MapSerializerMethods and Constructors)
in Maps.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 JsonParsers and/or
JsonGenerators.
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
JsonParserTypeResolverBuilder
and
TypeIdResolver.Modules
(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,
Lists and Maps).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.PropertyValues.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().
JsonMappingExceptionSerializerBase 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)
SerializerBaseSerializerProvider
to obtain actual
JsonSerializer instances from multiple distinct factories.ObjectMapper and
JsonSerializers 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
JsonGenerators
it creates.
JsonGenerators
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.
VisibilityCheckers, 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.Lists,
Maps 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.Maps 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 insteadDoubles
(and primitive doubles)Integers
(and primitive ints)StdSerializers.IntegerSerializer, but will not cast to Integer:
instead, cast is to Number, and conversion is
by calling Number.intValue().Numbers (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.Collections that contain Strings.Strings.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.
ToStringSerializerJsonParser 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).
Versions.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
JsonParseExceptions
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.Features
are enabled.
JsonParser.Features
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.Features
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.
ValueInjectors, if any injectable values are
expected by the bean; otherwise null.
JsonParser and JsonGenerator
instances as necessary.
JsonGenerators
JsonGenerators
JsonParser.clearCurrentToken() was called.
ObjectMapper
DataFormatMatcher._match
BeanDeserializer instances
are configured and constructed.
BeanSerializer instances
are configured and constructed.
TypeModifiers: 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.
chars 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 | |||||||||