Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
package org.codehaus.jackson.map.ser;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.util.*;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.JsonGenerator;
import org.codehaus.jackson.map.JsonSerializable;
import org.codehaus.jackson.map.JsonSerializer;
import org.codehaus.jackson.map.SerializerFactory;
import org.codehaus.jackson.map.SerializerProvider;
/**
* Factory class that can provide serializers for standard JDK classes,
* as well as custom classes that extend standard classes or implement
* one of "well-known" interfaces (such as {@link java.util.Collection}).
*
* Since all the serializers are eagerly instantiated, and there is
* no additional introspection or customazibility of these types,
* this factory is stateless. This means that other delegating
* factories (or {@link SerializerProvider}s) can just use the
* shared singleton instance via static {@link #instance} field.
*/
public class StdSerializerFactory
extends SerializerFactory
{
/*
////////////////////////////////////////////////////////////
// Configuration, lookup tables/maps
////////////////////////////////////////////////////////////
*/
/**
* Since these are all JDK classes, we shouldn't have to worry
* about ClassLoader used to load them. Rather, we can just
* use the class name, and keep things simple and efficient.
*/
final static HashMap> _concrete =
new HashMap>();
static {
/* String and string-like types (note: date types explicitly
* not included -- can use either textual or numeric serialization)
*/
_concrete.put(String.class.getName(), new StringSerializer());
ToStringSerializer sls = ToStringSerializer.instance;
_concrete.put(StringBuffer.class.getName(), sls);
_concrete.put(StringBuilder.class.getName(), sls);
_concrete.put(Character.class.getName(), sls);
_concrete.put(Character.TYPE.getName(), sls);
// currency units best dealt with as strings too
_concrete.put(Currency.class.getName(), sls);
// including things best serialized as Strings
_concrete.put(UUID.class.getName(), sls);
// Primitives/wrappers for primitives (primitives needed for Beans)
_concrete.put(Boolean.class.getName(), BooleanSerializer.instance);
_concrete.put(Boolean.TYPE.getName(), BooleanSerializer.instance);
final IntegerSerializer intS = new IntegerSerializer();
_concrete.put(Integer.class.getName(), intS);
_concrete.put(Integer.TYPE.getName(), intS);
_concrete.put(Long.class.getName(), LongSerializer.instance);
_concrete.put(Long.TYPE.getName(), LongSerializer.instance);
_concrete.put(Byte.class.getName(), IntLikeSerializer.instance);
_concrete.put(Byte.TYPE.getName(), IntLikeSerializer.instance);
_concrete.put(Short.class.getName(), IntLikeSerializer.instance);
_concrete.put(Short.TYPE.getName(), IntLikeSerializer.instance);
// Numbers, limited length floating point
_concrete.put(Float.class.getName(), FloatSerializer.instance);
_concrete.put(Float.TYPE.getName(), FloatSerializer.instance);
_concrete.put(Double.class.getName(), DoubleSerializer.instance);
_concrete.put(Double.TYPE.getName(), DoubleSerializer.instance);
// Other numbers, more complicated
final NumberSerializer ns = new NumberSerializer();
_concrete.put(BigInteger.class.getName(), ns);
_concrete.put(BigDecimal.class.getName(), ns);
/* Other discrete non-container types:
* first, Date/Time zoo:
*/
_concrete.put(Calendar.class.getName(), CalendarSerializer.instance);
_concrete.put(java.util.Date.class.getName(), UtilDateSerializer.instance);
_concrete.put(java.sql.Date.class.getName(), new SqlDateSerializer());
_concrete.put(java.sql.Time.class.getName(), new SqlTimeSerializer());
// note: timestamps are very similar to java.util.Date, thus serialized as such
_concrete.put(java.sql.Timestamp.class.getName(), UtilDateSerializer.instance);
// not sure if this is exactly right (should use toXMLFormat()?) but:
_concrete.put(javax.xml.datatype.XMLGregorianCalendar.class.getName(), StringLikeSerializer.instance);
/* Reference types, URLs, URIs
*/
_concrete.put(java.net.URL.class.getName(), StringLikeSerializer.instance);
_concrete.put(java.net.URI.class.getName(), StringLikeSerializer.instance);
// Arrays of various types (including common object types)
_concrete.put(boolean[].class.getName(), new BooleanArraySerializer());
_concrete.put(byte[].class.getName(), new ByteArraySerializer());
_concrete.put(char[].class.getName(), new CharArraySerializer());
_concrete.put(short[].class.getName(), new ShortArraySerializer());
_concrete.put(int[].class.getName(), new IntArraySerializer());
_concrete.put(long[].class.getName(), new LongArraySerializer());
_concrete.put(float[].class.getName(), new FloatArraySerializer());
_concrete.put(double[].class.getName(), new DoubleArraySerializer());
_concrete.put(Object[].class.getName(), ObjectArraySerializer.instance);
_concrete.put(String[].class.getName(), new StringArraySerializer());
// And then Java Collection classes
final IndexedListSerializer indListS = IndexedListSerializer.instance;
final CollectionSerializer collectionS = CollectionSerializer.instance;
_concrete.put(ArrayList.class.getName(), indListS);
_concrete.put(Vector.class.getName(), indListS);
_concrete.put(LinkedList.class.getName(), collectionS);
// (java.util.concurrent has others, but let's allow those to be
// found via slower introspection; too many to enumerate here)
final MapSerializer mapS = MapSerializer.instance;
_concrete.put(HashMap.class.getName(), mapS);
_concrete.put(Hashtable.class.getName(), mapS);
_concrete.put(LinkedHashMap.class.getName(), mapS);
_concrete.put(TreeMap.class.getName(), mapS);
_concrete.put(Properties.class.getName(), mapS);
_concrete.put(HashSet.class.getName(), collectionS);
_concrete.put(LinkedHashSet.class.getName(), collectionS);
_concrete.put(TreeSet.class.getName(), collectionS);
// and Enum-variations of set/map
_concrete.put(EnumMap.class.getName(), new EnumMapSerializer());
_concrete.put(EnumSet.class.getName(), new EnumSetSerializer());
/* Finally, couple of oddball types. Not sure if these are
* really needed...
*/
final NullSerializer nullS = NullSerializer.instance;
_concrete.put(Void.TYPE.getName(), nullS);
}
/*
////////////////////////////////////////////////////////////
// Life cycle
////////////////////////////////////////////////////////////
*/
/**
* Stateless global singleton instance that should be used
* for factories that want to use delegation to access
* standard serializers.
*/
public final static StdSerializerFactory instance = new StdSerializerFactory();
/*
////////////////////////////////////////////////////////////
// Life cycle
////////////////////////////////////////////////////////////
*/
/**
* We will provide default constructor to allow sub-classing,
* but make it protected so that no non-singleton instances of
* the class will be instantiated.
*/
protected StdSerializerFactory() { }
/*
////////////////////////////////////////////////////////////
// JsonSerializerFactory impl
////////////////////////////////////////////////////////////
*/
/**
* Main serializer constructor method. The base implementation within
* this class first calls a fast lookup method that can find serializers
* for well-known JDK classes; and if that fails, a slower one that
* tries to check out which interfaces given Class implements.
* Sub-classes can (and do) change this behavior to alter behavior.
*/
@Override
@SuppressWarnings("unchecked")
public JsonSerializer createSerializer(Class type)
{
// First, fast lookup for exact type:
JsonSerializer ser = findSerializerByLookup(type);
if (ser == null) {
/* and should that fail, slower introspection methods; first
* one that deals with "primary" types
*/
ser = findSerializerByPrimaryType(type);
if (ser == null) {
// And if that fails, one with "secondary" traits:
ser = findSerializerByAddonType(type);
}
}
return (JsonSerializer) ser;
}
/*
////////////////////////////////////////////////////////////
// Other public methods
////////////////////////////////////////////////////////////
*/
public final JsonSerializer getNullSerializer() {
return NullSerializer.instance;
}
/*
////////////////////////////////////////////////////////////
// Overridable secondary serializer accessor methods
////////////////////////////////////////////////////////////
*/
/**
* Fast lookup-based accessor method, which will only check for
* type itself, but not consider super-classes or implemented
* interfaces.
*/
public final JsonSerializer findSerializerByLookup(Class type)
{
return _concrete.get(type.getName());
}
/**
* 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. Primary here is defined as the main function
* of the Object; as opposed to "add-on" functionality.
*/
public final JsonSerializer findSerializerByPrimaryType(Class type)
{
/* Some types are final, and hence not checked here (will
* have been handled by fast method above):
*
* - Boolean
* - String (StringBuffer, StringBuilder)
* - Arrays for primitive types
*
* But we do need to check for
*
* - "primary" interfaces: Enum, Number, JsonSerializable
* - Most collection types
* - java.lang.Number (but is that integral or not?)
*/
if (JsonSerializable.class.isAssignableFrom(type)) {
return SerializableSerializer.instance;
}
if (Map.class.isAssignableFrom(type)) {
return MapSerializer.instance;
}
if (Object[].class.isAssignableFrom(type)) {
return ObjectArraySerializer.instance;
}
if (List.class.isAssignableFrom(type)) {
if (RandomAccess.class.isAssignableFrom(type)) {
return IndexedListSerializer.instance;
}
return CollectionSerializer.instance;
}
if (Number.class.isAssignableFrom(type)) {
return NumberSerializer.instance;
}
if (Enum.class.isAssignableFrom(type)) {
return new EnumSerializer();
}
if (Calendar.class.isAssignableFrom(type)) {
return CalendarSerializer.instance;
}
if (java.util.Date.class.isAssignableFrom(type)) {
return UtilDateSerializer.instance;
}
if (Collection.class.isAssignableFrom(type)) {
return CollectionSerializer.instance;
}
return null;
}
/**
* Reflection-based serialized find method, which checks if
* given class implements one of recognized "add-on" interfaces.
* Add-on here means a role that is usually or can be a secondary
* trait: for example,
* bean classes may implement {@link Iterable}, but their main
* function is usually something else. The reason for
*/
public final JsonSerializer findSerializerByAddonType(Class type)
{
// These need to be in decreasing order of specificity...
if (Iterator.class.isAssignableFrom(type)) {
return new IteratorSerializer();
}
if (Iterable.class.isAssignableFrom(type)) {
return new IterableSerializer();
}
if (CharSequence.class.isAssignableFrom(type)) {
return StringLikeSerializer.instance;
}
return null;
}
/*
////////////////////////////////////////////////////////////
// Concrete serializers, non-numeric primitives, Strings
////////////////////////////////////////////////////////////
*/
public final static class BooleanSerializer
extends JsonSerializer
{
final static BooleanSerializer instance = new BooleanSerializer();
public void serialize(Boolean value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
jgen.writeBoolean(value.booleanValue());
}
}
/**
* This is the special serializer for regular {@link java.lang.String}s.
*/
public final static class StringSerializer
extends JsonSerializer
{
public void serialize(String value, JsonGenerator jgen, SerializerProvider provider)
throws IOException, JsonGenerationException
{
jgen.writeString(value);
}
}
/**
* This is an interesting general purpose serializer, useful for any
* type for which {@link Object#toString} returns the desired Json
* value.
*/
public final static class StringLikeSerializer
extends JsonSerializer
