|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use JsonSerializer | |
---|---|
org.codehaus.jackson.map | Contains basic mapper (conversion) functionality that
allows for converting between regular streaming json content and
Java objects (beans or Tree Model: support for both is via
ObjectMapper class, as well
as convenience methods included in
JsonParser |
org.codehaus.jackson.map.ext | Contains extended support for "external" packages: things that may or may not be present in runtime environment, but that are commonly enough used so that explicit support can be added. |
org.codehaus.jackson.map.introspect | Functionality needed for Bean introspection, required for detecting accessors and mutators for Beans, as well as locating and handling method annotations. |
org.codehaus.jackson.map.ser | Contains implementation classes of serialization part of data binding. |
org.codehaus.jackson.xc | Package that contains Xml Compatibility functionality for Jackson. |
Uses of JsonSerializer in org.codehaus.jackson.map |
---|
Subclasses of JsonSerializer in org.codehaus.jackson.map | |
---|---|
static class |
JsonSerializer.None
This marker class is only to be used with annotations, to indicate that no serializer is configured. |
Methods in org.codehaus.jackson.map that return JsonSerializer | ||
---|---|---|
|
SerializerFactory.createSerializer(Class<T> type,
SerializationConfig config)
Deprecated. Use SerializerFactory.createSerializer(JavaType,SerializationConfig) instead |
|
JsonSerializer<Object> |
SerializerFactory.createSerializer(JavaType type,
SerializationConfig config)
Method called to create (or, for immutable serializers, reuse) a serializer for given type. |
|
abstract JsonSerializer<Object> |
SerializerProvider.findTypedValueSerializer(Class<?> valueType,
boolean cache)
Method called to locate regular serializer, matching type serializer, and if both found, wrap them in a serializer that calls both in correct sequence. |
|
abstract JsonSerializer<Object> |
SerializerProvider.findTypedValueSerializer(JavaType valueType,
boolean cache)
Method called to locate regular serializer, matching type serializer, and if both found, wrap them in a serializer that calls both in correct sequence. |
|
abstract JsonSerializer<Object> |
SerializerProvider.findValueSerializer(Class<?> runtimeType)
Method called to get hold of a serializer for a value of given type; or if no such serializer can be found, a default handler (which may do a best-effort generic serialization or just simply throw an exception when invoked). |
|
abstract JsonSerializer<Object> |
SerializerProvider.findValueSerializer(JavaType serializationType)
|
|
abstract JsonSerializer<Object> |
SerializerProvider.getKeySerializer()
Method called to get the serializer to use for serializing non-null Map keys. |
|
abstract JsonSerializer<Object> |
SerializerProvider.getNullKeySerializer()
Method called to get the serializer to use for serializing Map keys that are nulls: this is needed since Json does not allow any non-String value as key, including null. |
|
abstract JsonSerializer<Object> |
SerializerProvider.getNullValueSerializer()
Method called to get the serializer to use for serializing values (root level, Array members or List field values) that are nulls. |
|
abstract JsonSerializer<Object> |
SerializerProvider.getUnknownTypeSerializer(Class<?> unknownType)
Method called to get the serializer to use if provider can not determine an actual type-specific serializer to use; typically when none of SerializerFactory
instances are able to construct a serializer. |
Uses of JsonSerializer in org.codehaus.jackson.map.ext |
---|
Subclasses of JsonSerializer in org.codehaus.jackson.map.ext | |
---|---|
class |
DOMSerializer
|
static class |
JodaSerializers.DateMidnightSerializer
|
static class |
JodaSerializers.DateTimeSerializer
|
protected static class |
JodaSerializers.JodaSerializer<T>
|
static class |
JodaSerializers.LocalDateSerializer
|
static class |
JodaSerializers.LocalDateTimeSerializer
|
Methods in org.codehaus.jackson.map.ext that return types with arguments of type JsonSerializer | |
---|---|
Collection<Map.Entry<Class<?>,JsonSerializer<?>>> |
JodaSerializers.provide()
|
Collection<Map.Entry<Class<?>,JsonSerializer<?>>> |
CoreXMLSerializers.provide()
|
Uses of JsonSerializer in org.codehaus.jackson.map.introspect |
---|
Methods in org.codehaus.jackson.map.introspect that return types with arguments of type JsonSerializer | |
---|---|
Class<? extends JsonSerializer<?>> |
JacksonAnnotationIntrospector.findSerializer(Annotated a)
|
Uses of JsonSerializer in org.codehaus.jackson.map.ser |
---|
Subclasses of JsonSerializer in org.codehaus.jackson.map.ser | |
---|---|
static class |
ArraySerializers.BooleanArraySerializer
|
static class |
ArraySerializers.ByteArraySerializer
Unlike other integral number array serializers, we do not just print out byte values as numbers. |
static class |
ArraySerializers.CharArraySerializer
Character arrays are different from other integral number arrays in that they are most likely to be textual data, and should be written as Strings, not arrays of entries. |
static class |
ArraySerializers.DoubleArraySerializer
|
static class |
ArraySerializers.FloatArraySerializer
|
static class |
ArraySerializers.IntArraySerializer
|
static class |
ArraySerializers.LongArraySerializer
|
static class |
ArraySerializers.ObjectArraySerializer
Generic serializer for Object arrays ( Object[] ). |
static class |
ArraySerializers.ShortArraySerializer
|
static class |
ArraySerializers.StringArraySerializer
|
class |
BeanSerializer
Serializer class that can serialize arbitrary bean objects. |
class |
ContainerSerializerBase<T>
Intermediate base class for types that contain element(s) of other types. |
static class |
ContainerSerializers.CollectionSerializer
Fallback serializer for cases where Collection is not known to be of type for which more specializer serializer exists (such as index-accessible List). |
static class |
ContainerSerializers.EnumSetSerializer
|
static class |
ContainerSerializers.IndexedListSerializer
This is an optimizied serializer for Lists that can be efficiently traversed by index (as opposed to others, such as LinkedList
that can not}. |
static class |
ContainerSerializers.IterableSerializer
|
static class |
ContainerSerializers.IteratorSerializer
|
class |
EnumMapSerializer
Specialized serializer for EnumMap s. |
class |
EnumSerializer
Standard serializer used for all enum types. |
class |
FailingSerializer
Special bogus "serializer" that will throw JsonGenerationException if its FailingSerializer.serialize(java.lang.Object, org.codehaus.jackson.JsonGenerator, org.codehaus.jackson.map.SerializerProvider)
gets invoeked. |
static class |
JdkSerializers.ClassSerializer
Also: default bean access will not do much good with Class.class. |
static class |
JdkSerializers.FileSerializer
For now, File objects get serialized by just outputting absolute (but not canonical) name as String value |
class |
JsonValueSerializer
Serializer class that can serialize Object that have a JsonValue annotation to
indicate that serialization should be done by calling the method
annotated, and serializing result it returns. |
class |
MapSerializer
Standard serializer implementation for serializing {link java.util.Map} types. |
class |
NullSerializer
This is a simple dummy serializer that will just output literal JSON null value whenever serialization is requested. |
class |
ScalarSerializerBase<T>
|
class |
SerializerBase<T>
Base class used by all standard serializers. |
class |
StdKeySerializer
Specialized serializer that can be used as the generic key serializer, when serializing Map s to Json
Objects. |
static class |
StdSerializers.BooleanSerializer
Serializer used for primitive boolean, as well as java.util.Boolean wrapper type. |
static class |
StdSerializers.CalendarSerializer
For time values we should use timestamp, since that is about the only thing that can be reliably converted between date-based objects and json. |
static class |
StdSerializers.DoubleSerializer
This is the special serializer for regular Double s
(and primitive doubles) |
static class |
StdSerializers.FloatSerializer
|
static class |
StdSerializers.IntegerSerializer
This is the special serializer for regular Integer s
(and primitive ints) |
static class |
StdSerializers.IntLikeSerializer
Similar to StdSerializers.IntegerSerializer , but will not cast to Integer:
instead, cast is to Number , and conversion is
by calling Number.intValue() . |
static class |
StdSerializers.LongSerializer
|
protected static class |
StdSerializers.NonTypedScalarSerializer<T>
Intermediate base class for limited number of scalar types that should never include type information. |
static class |
StdSerializers.NumberSerializer
As a fallback, we may need to use this serializer for other types of Number s (custom types). |
static class |
StdSerializers.SerializableSerializer
Generic handler for types that implement JsonSerializable . |
static class |
StdSerializers.SqlDateSerializer
Compared to regular StdSerializers.UtilDateSerializer , we do use String
representation here. |
static class |
StdSerializers.SqlTimeSerializer
|
static class |
StdSerializers.StringSerializer
This is the special serializer for regular String s. |
static class |
StdSerializers.TokenBufferSerializer
We also want to directly support serialization of TokenBuffer ;
and since it is part of core package, it can not implement
JsonSerializable (which is only included in the mapper
package) |
static class |
StdSerializers.UtilDateSerializer
For efficiency, we will serialize Dates as longs, instead of potentially more readable Strings. |
class |
ToStringSerializer
Simple general purpose serializer, useful for any type for which Object.toString() returns the desired Json
value. |
Fields in org.codehaus.jackson.map.ser declared as JsonSerializer | |
---|---|
protected JsonSerializer<Object> |
ArraySerializers.ObjectArraySerializer._elementSerializer
Value serializer to use, if it can be statically determined |
protected JsonSerializer<Object> |
StdSerializerProvider._keySerializer
Serializer used to output non-null keys of Maps (which will get output as Json Objects). |
protected JsonSerializer<Object> |
StdSerializerProvider._nullKeySerializer
Serializer used to (try to) output a null key, due to an entry of Map having null key. |
protected JsonSerializer<Object> |
StdSerializerProvider._nullValueSerializer
Serializer used to output a null value. |
protected JsonSerializer<Object> |
BeanPropertyWriter._serializer
Serializer to use for writing out the value: null if it can not be known statically; non-null if it can. |
protected JsonSerializer<Object> |
StdSerializerProvider._unknownTypeSerializer
Serializer that gets called for values of types for which no serializers can be constructed. |
protected JsonSerializer<Object> |
MapSerializer._valueSerializer
Value serializer to use, if it can be statically determined |
protected JsonSerializer<Object> |
JsonValueSerializer._valueSerializer
|
protected JsonSerializer<Object> |
EnumMapSerializer._valueSerializer
Value serializer to use, if it can be statically determined |
static JsonSerializer<Object> |
StdSerializerProvider.DEFAULT_KEY_SERIALIZER
|
static JsonSerializer<Object> |
StdSerializerProvider.DEFAULT_NULL_KEY_SERIALIZER
|
static JsonSerializer<Object> |
StdSerializerProvider.DEFAULT_UNKNOWN_SERIALIZER
|
Methods in org.codehaus.jackson.map.ser that return JsonSerializer | ||
---|---|---|
protected JsonSerializer<Object> |
StdSerializerProvider._createAndCacheUntypedSerializer(Class<?> type)
Method that will try to construct a value serializer; and if one is succesfully created, cache it for reuse. |
|
protected JsonSerializer<Object> |
StdSerializerProvider._createAndCacheUntypedSerializer(JavaType type)
|
|
protected JsonSerializer<Object> |
StdSerializerProvider._createUntypedSerializer(JavaType type)
|
|
protected JsonSerializer<Object> |
StdSerializerProvider._findExplicitUntypedSerializer(Class<?> runtimeType)
Method that will try to find a serializer, either from cache or by constructing one; but will not return an "unknown" serializer if this can not be done but rather returns null. |
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildCollectionSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
|
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildEnumMapSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
|
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildEnumSetSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
|
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildIndexedListSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
|
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildIterableSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
|
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildIteratorSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
|
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildMapSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
Helper method that handles configuration details when constructing serializers for Map types. |
|
protected JsonSerializer<?> |
BasicSerializerFactory.buildObjectArraySerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
Helper method that handles configuration details when constructing serializers for Object[] (and subtypes). |
|
protected JsonSerializer<Object> |
BeanSerializerFactory.constructBeanSerializer(SerializationConfig config,
BasicBeanDescription beanDesc)
|
|
|
CustomSerializerFactory.createSerializer(Class<T> type,
SerializationConfig config)
|
|
|
BasicSerializerFactory.createSerializer(Class<T> type,
SerializationConfig config)
Main serializer constructor method. |
|
JsonSerializer<Object> |
CustomSerializerFactory.createSerializer(JavaType type,
SerializationConfig config)
|
|
JsonSerializer<Object> |
BeanSerializerFactory.createSerializer(JavaType type,
SerializationConfig config)
Main serializer constructor method. |
|
JsonSerializer<Object> |
BasicSerializerFactory.createSerializer(JavaType type,
SerializationConfig config)
|
|
static JsonSerializer<?> |
ContainerSerializers.enumSetSerializer(JavaType enumType)
|
|
JsonSerializer<Object> |
BeanSerializerFactory.findBeanSerializer(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
Method that will try to construct a BeanSerializer for
given class. |
|
protected JsonSerializer<?> |
CustomSerializerFactory.findCustomSerializer(Class<?> type,
SerializationConfig config)
|
|
JsonSerializer<?> |
BasicSerializerFactory.findSerializerByAddonType(JavaType javaType,
SerializationConfig config,
BasicBeanDescription beanDesc)
Reflection-based serialized find method, which checks if given class implements one of recognized "add-on" interfaces. |
|
JsonSerializer<?> |
BasicSerializerFactory.findSerializerByLookup(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
Fast lookup-based accessor method, which will only check for type itself, but not consider super-classes or implemented interfaces. |
|
JsonSerializer<?> |
BasicSerializerFactory.findSerializerByPrimaryType(JavaType type,
SerializationConfig config,
BasicBeanDescription beanDesc)
Reflection-based serialized find method, which checks if given class is a sub-type of one of well-known classes, or implements a "primary" interface. |
|
protected JsonSerializer<Object> |
BasicSerializerFactory.findSerializerFromAnnotation(SerializationConfig config,
Annotated a)
Helper method called to check if a class or method has an annotation (@link org.codehaus.jackson.map.ser.JsonSerialize#using) that tells the class to use for serialization. |
|
JsonSerializer<Object> |
StdSerializerProvider.findTypedValueSerializer(Class<?> valueType,
boolean cache)
|
|
JsonSerializer<Object> |
StdSerializerProvider.findTypedValueSerializer(JavaType valueType,
boolean cache)
|
|
JsonSerializer<Object> |
StdSerializerProvider.findValueSerializer(Class<?> valueType)
|
|
JsonSerializer<Object> |
StdSerializerProvider.findValueSerializer(JavaType valueType)
This variant was added in 1.5, to allow for efficient access using full structured types, not just classes. |
|
JsonSerializer<Object> |
StdSerializerProvider.getKeySerializer()
|
|
JsonSerializer<Object> |
StdSerializerProvider.getNullKeySerializer()
|
|
JsonSerializer<?> |
BasicSerializerFactory.getNullSerializer()
|
|
JsonSerializer<Object> |
StdSerializerProvider.getNullValueSerializer()
|
|
protected JsonSerializer<Object> |
BeanPropertyWriter.getSerializer()
|
|
JsonSerializer<Object> |
StdSerializerProvider.getUnknownTypeSerializer(Class<?> unknownType)
|
|
JsonSerializer<Object> |
SerializerCache.typedValueSerializer(Class<?> cls)
|
|
JsonSerializer<Object> |
ReadOnlyClassToSerializerMap.typedValueSerializer(Class<?> cls)
|
|
JsonSerializer<Object> |
SerializerCache.typedValueSerializer(JavaType type)
|
|
JsonSerializer<Object> |
ReadOnlyClassToSerializerMap.typedValueSerializer(JavaType type)
|
|
JsonSerializer<Object> |
SerializerCache.untypedValueSerializer(Class<?> type)
Method that checks if the shared (and hence, synchronized) lookup Map might have untyped serializer for given type. |
|
JsonSerializer<Object> |
ReadOnlyClassToSerializerMap.untypedValueSerializer(Class<?> cls)
|
|
JsonSerializer<Object> |
SerializerCache.untypedValueSerializer(JavaType type)
|
|
JsonSerializer<Object> |
ReadOnlyClassToSerializerMap.untypedValueSerializer(JavaType type)
|
Methods in org.codehaus.jackson.map.ser that return types with arguments of type JsonSerializer | |
---|---|
Collection<Map.Entry<Class<?>,JsonSerializer<?>>> |
JdkSerializers.provide()
Method called by BasicSerializerFactory to access
all serializers this class provides. |
Methods in org.codehaus.jackson.map.ser with parameters of type JsonSerializer | ||
---|---|---|
|
CustomSerializerFactory.addGenericMapping(Class<? extends T> type,
JsonSerializer<T> ser)
Method used to add a generic (transitive) mapping from specified class or its sub-classes into a serializer. |
|
void |
SerializerCache.addNonTypedSerializer(Class<?> type,
JsonSerializer<Object> ser)
|
|
void |
SerializerCache.addNonTypedSerializer(JavaType type,
JsonSerializer<Object> ser)
|
|
|
CustomSerializerFactory.addSpecificMapping(Class<? extends T> forClass,
JsonSerializer<T> ser)
Method used to add a mapping from specific type -- and only that type -- to specified serializer. |
|
void |
SerializerCache.addTypedSerializer(Class<?> cls,
JsonSerializer<Object> ser)
|
|
void |
SerializerCache.addTypedSerializer(JavaType type,
JsonSerializer<Object> ser)
Method called if none of lookups succeeded, and caller had to construct a serializer. |
|
protected BeanPropertyWriter |
PropertyBuilder.buildProperty(String name,
JsonSerializer<Object> ser,
TypeSerializer typeSer,
TypeSerializer contentTypeSer,
AnnotatedMember am,
boolean defaultUseStaticTyping)
|
|
void |
ContainerSerializers.CollectionSerializer.serializeContentsUsing(Collection<?> value,
JsonGenerator jgen,
SerializerProvider provider,
JsonSerializer<Object> ser)
|
|
protected void |
EnumMapSerializer.serializeContentsUsing(EnumMap<? extends Enum<?>,?> value,
JsonGenerator jgen,
SerializerProvider provider,
JsonSerializer<Object> valueSer)
|
|
void |
ContainerSerializers.IndexedListSerializer.serializeContentsUsing(List<?> value,
JsonGenerator jgen,
SerializerProvider provider,
JsonSerializer<Object> ser)
|
|
void |
ArraySerializers.ObjectArraySerializer.serializeContentsUsing(Object[] value,
JsonGenerator jgen,
SerializerProvider provider,
JsonSerializer<Object> ser)
|
|
protected void |
MapSerializer.serializeFieldsUsing(Map<?,?> value,
JsonGenerator jgen,
SerializerProvider provider,
JsonSerializer<Object> ser)
Method called to serialize fields, when the value type is statically known, so that value serializer is passed and does not need to be fetched from provider. |
|
void |
CustomSerializerFactory.setEnumSerializer(JsonSerializer<?> enumSer)
Method that can be used to force specified serializer to be used for serializing all Enum instances. |
|
void |
StdSerializerProvider.setKeySerializer(JsonSerializer<Object> ks)
|
|
void |
StdSerializerProvider.setNullKeySerializer(JsonSerializer<Object> nks)
|
|
void |
StdSerializerProvider.setNullValueSerializer(JsonSerializer<Object> nvs)
|
|
BeanPropertyWriter |
BeanPropertyWriter.withSerializer(JsonSerializer<Object> ser)
Method that will construct and return a new writer that has same properties as this writer, but uses specified serializer instead of currently configured one (if any). |
Method parameters in org.codehaus.jackson.map.ser with type arguments of type JsonSerializer | |
---|---|
static ReadOnlyClassToSerializerMap |
ReadOnlyClassToSerializerMap.from(HashMap<Object,JsonSerializer<Object>> src)
Factory method for creating the "blueprint" lookup map. |
Constructors in org.codehaus.jackson.map.ser with parameters of type JsonSerializer | |
---|---|
BeanPropertyWriter(String name,
JsonSerializer<Object> ser,
TypeSerializer typeSer,
JavaType serType,
Method acc,
Field f,
boolean suppressNulls,
Object suppressableValue)
|
|
JsonValueSerializer(Method valueMethod,
JsonSerializer<Object> ser)
|
Uses of JsonSerializer in org.codehaus.jackson.xc |
---|
Subclasses of JsonSerializer in org.codehaus.jackson.xc | |
---|---|
class |
DataHandlerJsonSerializer
|
class |
XmlAdapterJsonSerializer
|
Methods in org.codehaus.jackson.xc that return JsonSerializer | |
---|---|
JsonSerializer<?> |
JaxbAnnotationIntrospector.findSerializer(Annotated am)
|
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |