Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.fasterxml.jackson.databind;
  
  import java.util.*;
  
 
Class that defines API used by ObjectMapper and JsonSerializers to obtain serializers capable of serializing instances of specific types; as well as the default implementation of the functionality.

Provider handles caching aspects of serializer handling; all construction details are delegated to com.fasterxml.jackson.databind.ser.SerializerFactory instance.

Object life-cycle is such that an initial instance ("blueprint") is created and referenced by ObjectMapper and ObjectWriter intances; but for actual usage, a configured instance is created by using a create method in sub-class com.fasterxml.jackson.databind.ser.DefaultSerializerProvider. Only this instance can be used for actual serialization calls; blueprint object is only to be used for creating instances.

 
 public abstract class SerializerProvider
 {
     protected final static JavaType TYPE_OBJECT = TypeFactory.defaultInstance().uncheckedSimpleType(Object.class);

    
Setting for determining whether mappings for "unknown classes" should be cached for faster resolution. Usually this isn't needed, but maybe it is in some cases?
 
     protected final static boolean CACHE_UNKNOWN_MAPPINGS = false;
 
     public final static JsonSerializer<ObjectDEFAULT_NULL_KEY_SERIALIZER =
         new FailingSerializer("Null key for a Map not allowed in JSON (use a converting NullKeySerializer?)");
 
     public final static JsonSerializer<ObjectDEFAULT_UNKNOWN_SERIALIZER = new UnknownSerializer();
 
     /*
     /**********************************************************
     /* Configuration, general
     /**********************************************************
      */
    
    
Serialization configuration to use for serialization processing.
 
     final protected SerializationConfig _config;

    
View used for currently active serialization, if any.
 
     final protected Class<?> _serializationView;
     
     /*
     /**********************************************************
     /* Configuration, factories
     /**********************************************************
      */

    
Factory used for constructing actual serializer instances.
 
     final protected SerializerFactory _serializerFactory;
 
     /*
     /**********************************************************
     /* Helper objects for caching
     /**********************************************************
      */
    
    
Cache for doing type-to-value-serializer lookups.
 
     final protected SerializerCache _serializerCache;

    
Helper object for keeping track of introspected root names
 
     final protected RootNameLookup _rootNames;
     
     /*
     /**********************************************************
    /* Configuration, specialized serializers
    /**********************************************************
     */

    
Serializer that gets called for values of types for which no serializers can be constructed.

The default serializer will simply thrown an exception.

Serializer used to output non-null keys of Maps (which will get output as JSON Objects), if not null; if null, us the standard default key serializer.
    protected JsonSerializer<Object_keySerializer;

    
Serializer used to output a null value. Default implementation writes nulls using com.fasterxml.jackson.core.JsonGenerator.writeNull().
Serializer used to (try to) output a null key, due to an entry of java.util.Map having null key. The default implementation will throw an exception if this happens; alternative implementation (like one that would write an Empty String) can be defined.
    /*
    /**********************************************************
    /* State, for non-blueprint instances: generic
    /**********************************************************
     */
    
    
For fast lookups, we will have a local non-shared read-only map that contains serializers previously fetched.
    protected final ReadOnlyClassToSerializerMap _knownSerializers;

    
Lazily acquired and instantiated formatter object: initialized first time it is needed, reused afterwards. Used via instances (not blueprints), so that access need not be thread-safe.
    protected DateFormat _dateFormat;
    /*
    /**********************************************************
    /* Life-cycle
    /**********************************************************
     */

    
Constructor for creating master (or "blue-print") provider object, which is only used as the template for constructing per-binding instances.
    public SerializerProvider()
    {
         = null;
         = null;
         = new SerializerCache();
        // Blueprints doesn't have access to any serializers...
         = null;
         = new RootNameLookup();
         = null;
    }

    
"Copy-constructor", used by sub-classes.

Parameters:
src Blueprint object used as the baseline for this instance
    protected SerializerProvider(SerializerProvider src,
            SerializationConfig configSerializerFactory f)
    {
        if (config == null) {
            throw new NullPointerException();
        }
         = f;
         = config;
         = src._serializerCache;
         = src._unknownTypeSerializer;
         = src._keySerializer;
         = src._nullValueSerializer;
         = src._nullKeySerializer;
         = src._rootNames;
        /* Non-blueprint instances do have a read-only map; one that doesn't
         * need synchronization for lookups.
         */
         = config.getActiveView();
    }
    
    /*
    /**********************************************************
    /* Methods for configuring default settings
    /**********************************************************
     */

    
Method that can be used to specify serializer that will be used to write JSON property names matching null keys for Java Maps (which will throw an exception if try write such property name)
    {
        if (ks == null) {
            throw new IllegalArgumentException("Can not pass null JsonSerializer");
        }
         = ks;
    }

    
Method that can be used to specify serializer that will be used to write JSON values matching Java null values instead of default one (which simply writes JSON null)
    public void setNullValueSerializer(JsonSerializer<Objectnvs)
    {
        if (nvs == null) {
            throw new IllegalArgumentException("Can not pass null JsonSerializer");
        }
         = nvs;
    }

    
Method that can be used to specify serializer to use for serializing all non-null JSON property names, unless more specific key serializer is found (i.e. if not custom key serializer has been registered for Java type).

Note that key serializer registration are different from value serializer registrations.

    public void setNullKeySerializer(JsonSerializer<Objectnks)
    {
        if (nks == null) {
            throw new IllegalArgumentException("Can not pass null JsonSerializer");
        }
         = nks;
    }
        
    /*
    /**********************************************************
    /* Access to general configuration
    /**********************************************************
     */

    
Method for accessing configuration for the serialization processing.
    public final SerializationConfig getConfig() { return ; }

    
Convenience method for checking whether specified serialization feature is enabled or not. Shortcut for:
  getConfig().isEnabled(feature);
    public final boolean isEnabled(MapperFeature feature) {
        return .isEnabled(feature);
    }

    
Convenience method for checking whether specified serialization feature is enabled or not. Shortcut for:
  getConfig().isEnabled(feature);
    public final boolean isEnabled(SerializationFeature feature) {
        return .isEnabled(feature);
    }

    
Convenience method for accessing serialization view in use (if any); equivalent to:
   getConfig().canOverrideAccessModifiers();
    public final boolean canOverrideAccessModifiers() {
        return .canOverrideAccessModifiers();
    }
    
    
Convenience method for accessing serialization view in use (if any); equivalent to:
   getConfig().getAnnotationIntrospector();
        return .getAnnotationIntrospector();
    }
    
    
Convenience method for accessing serialization view in use (if any); equivalent to:
   getConfig().getSerializationView();
    public final Class<?> getSerializationView() { return ; }

    
Convenience method for accessing provider to find serialization filters used, equivalent to calling:
   getConfig().getFilterProvider();
    public final FilterProvider getFilterProvider() {
        return .getFilterProvider();
    }

    
Method for accessing default Locale to use: convenience method for
   getConfig().getLocale();
    public Locale getLocale() {
        return .getLocale();
    }

    
Method for accessing default TimeZone to use: convenience method for
   getConfig().getTimeZone();
    public TimeZone getTimeZone() {
        return .getTimeZone();
    }
    
    /*
    /**********************************************************
    /* Access to type handling
    /**********************************************************
     */
    
    
Convenience method for constructing JavaType for given JDK type (usually java.lang.Class)
    public JavaType constructType(Type type) {
         return .getTypeFactory().constructType(type);
    }

    
Convenience method for constructing subtypes, retaining generic type parameter (if any)
    public JavaType constructSpecializedType(JavaType baseTypeClass<?> subclass) {
        return .constructSpecializedType(baseTypesubclass);
    }
    public TypeFactory getTypeFactory() {
        return .getTypeFactory();
    }
    /*
    /**********************************************************
    /* Access to Object Id aspects
    /**********************************************************
     */

    
Method called to find the Object Id for given POJO, if one has been generated. Will always return a non-null Object; contents vary depending on whether an Object Id already exists or not.
    public abstract WritableObjectId findObjectId(Object forPojo,
            ObjectIdGenerator<?> generatorType);
    
    /*
    /**********************************************************
    /* General serializer locating functionality
    /**********************************************************
     */

    
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).

Note: this method is only called for non-null values; not for keys or null values. For these, check out other accessor methods.

Note that starting with version 1.5, serializers should also be type-aware if they handle polymorphic types. That means that it may be necessary to also use a com.fasterxml.jackson.databind.jsontype.TypeSerializer based on declared (static) type being serializer (whereas actual data may be serialized using dynamic type)

Throws:
JsonMappingException if there are fatal problems with accessing suitable serializer; including that of not finding any serializer
    public JsonSerializer<ObjectfindValueSerializer(Class<?> valueType,
            BeanProperty property)
        throws JsonMappingException
    {
        // Fast lookup from local lookup thingy works?
        if (ser == null) {
            // If not, maybe shared map already has it?
            ser = .untypedValueSerializer(valueType);
            if (ser == null) {
                // ... possibly as fully typed?
                ser = .untypedValueSerializer(.constructType(valueType));
                if (ser == null) {
                    // If neither, must create
                    ser = _createAndCacheUntypedSerializer(valueType);
                    // Not found? Must use the unknown type serializer
                    /* Couldn't create? Need to return the fallback serializer, which
                     * most likely will report an error: but one question is whether
                     * we should cache it?
                     */
                    if (ser == null) {
                        ser = getUnknownTypeSerializer(valueType);
                        // Should this be added to lookups?
                        if () {
                            .addAndResolveNonTypedSerializer(valueTypeserthis);
                        }
                        return ser;
                    }
                }
            }
        }
        // at this point, resolution has occured, but not contextualization
        return _handleContextual(serproperty);
    }

    
Similar to findValueSerializer(java.lang.Class,com.fasterxml.jackson.databind.BeanProperty), but takes full generics-aware type instead of raw class. This is necessary for accurate handling of external type information, to handle polymorphic types.

Parameters:
property When creating secondary serializers, property for which serializer is needed: annotations of the property (or bean that contains it) may be checked to create contextual serializers.
    public JsonSerializer<ObjectfindValueSerializer(JavaType valueTypeBeanProperty property)
        throws JsonMappingException
    {
        // Fast lookup from local lookup thingy works?
        if (ser == null) {
            // If not, maybe shared map already has it?
            ser = .untypedValueSerializer(valueType);
            if (ser == null) {
                // If neither, must create
                ser = _createAndCacheUntypedSerializer(valueType);
                // Not found? Must use the unknown type serializer
                /* Couldn't create? Need to return the fallback serializer, which
                 * most likely will report an error: but one question is whether
                 * we should cache it?
                 */
                if (ser == null) {
                    ser = getUnknownTypeSerializer(valueType.getRawClass());
                    // Should this be added to lookups?
                    if () {
                        .addAndResolveNonTypedSerializer(valueTypeserthis);
                    }
                    return ser;
                }
            }
        }
        return _handleContextual(serproperty);
    }
    
    
Method called to locate regular serializer, matching type serializer, and if both found, wrap them in a serializer that calls both in correct sequence. This method is currently only used for root-level serializer handling to allow for simpler caching. A call can always be replaced by equivalent calls to access serializer and type serializer separately.

Parameters:
valueType Type for purpose of locating a serializer; usually dynamic runtime type, but can also be static declared type, depending on configuration
cache Whether resulting value serializer should be cached or not; this is just a hint
property When creating secondary serializers, property for which serializer is needed: annotations of the property (or bean that contains it) may be checked to create contextual serializers.
    public JsonSerializer<ObjectfindTypedValueSerializer(Class<?> valueType,
            boolean cacheBeanProperty property)
        throws JsonMappingException
    {
        // Two-phase lookups; local non-shared cache, then shared:
        JsonSerializer<Objectser = .typedValueSerializer(valueType);
        if (ser != null) {
            return ser;
        }
        // If not, maybe shared map already has it?
        ser = .typedValueSerializer(valueType);
        if (ser != null) {
            return ser;
        }
        // Well, let's just compose from pieces:
        ser = findValueSerializer(valueTypeproperty);
                .constructType(valueType));
        if (typeSer != null) {
            typeSer = typeSer.forProperty(property);
            ser = new TypeWrappedSerializer(typeSerser);
        }
        if (cache) {
            .addTypedSerializer(valueTypeser);
        }
        return ser;
    }

    
Method called to locate regular serializer, matching type serializer, and if both found, wrap them in a serializer that calls both in correct sequence. This method is currently only used for root-level serializer handling to allow for simpler caching. A call can always be replaced by equivalent calls to access serializer and type serializer separately.

Parameters:
valueType Declared type of value being serialized (which may not be actual runtime type); used for finding both value serializer and type serializer to use for adding polymorphic type (if any)
cache Whether resulting value serializer should be cached or not; this is just a hint
property When creating secondary serializers, property for which serializer is needed: annotations of the property (or bean that contains it) may be checked to create contextual serializers.
    public JsonSerializer<ObjectfindTypedValueSerializer(JavaType valueTypeboolean cache,
            BeanProperty property)
        throws JsonMappingException
    {
        // Two-phase lookups; local non-shared cache, then shared:
        JsonSerializer<Objectser = .typedValueSerializer(valueType);
        if (ser != null) {
            return ser;
        }
        // If not, maybe shared map already has it?
        ser = .typedValueSerializer(valueType);
        if (ser != null) {
            return ser;
        }
        // Well, let's just compose from pieces:
        ser = findValueSerializer(valueTypeproperty);
        TypeSerializer typeSer = .createTypeSerializer(valueType);
        if (typeSer != null) {
            typeSer = typeSer.forProperty(property);
            ser = new TypeWrappedSerializer(typeSerser);
        }
        if (cache) {
            .addTypedSerializer(valueTypeser);
        }
        return ser;
    }

    
Method called to get the serializer to use for serializing non-null Map keys. Separation from regular findValueSerializer(java.lang.Class,com.fasterxml.jackson.databind.BeanProperty) method is because actual write method must be different (@link JsonGenerator#writeFieldName}; but also since behavior for some key types may differ.

Note that the serializer itself can be called with instances of any Java object, but not nulls.

            BeanProperty property)
        throws JsonMappingException
    {
    
        // First things first: maybe there are registered custom implementations
        // if not, use default one:
        if (ser == null) {
            if ( == null) {
                ser = StdKeySerializers.getStdKeySerializer(keyType);
            } else {
                ser = ;
            }
        }
        // 25-Feb-2011, tatu: As per [JACKSON-519], need to ensure contextuality works here, too
        return _handleContextualResolvable(serproperty);
    }
    
    /*
    /********************************************************
    /* Accessors for specialized serializers
    /********************************************************
     */

    

Since:
2.0
        return ;
    }

    

Since:
2.0
        return ;
    }
    
    
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.

Typically, returned serializer will either throw an exception, or use an empty String; but other behaviors are possible.


    
Method called to find a serializer to use for null values for given declared type. Note that type is completely based on declared type, since nulls in Java have no type and thus runtime type can not be determined.

Since:
2.0
    public JsonSerializer<ObjectfindNullKeySerializer(JavaType serializationType,
            BeanProperty property)
        throws JsonMappingException {
        return getDefaultNullKeySerializer();
    }

    
Method called to get the serializer to use for serializing null property values.

Default implementation simply calls getDefaultNullValueSerializer(); can be overridden to add custom null serialization for properties of certain type or name.

Since:
2.0
        throws JsonMappingException {
        return getDefaultNullValueSerializer();
    }

    
Method called to get the serializer to use if provider can not determine an actual type-specific serializer to use; typically when none of com.fasterxml.jackson.databind.ser.SerializerFactory instances are able to construct a serializer.

Typically, returned serializer will throw an exception, although alternatively com.fasterxml.jackson.databind.ser.std.ToStringSerializer could be returned as well.

Parameters:
unknownType Type for which no serializer is found
    public JsonSerializer<ObjectgetUnknownTypeSerializer(Class<?> unknownType) {
        return ;
    }
    /*
    /**********************************************************
    /* Methods for creating instances based on annotations
    /**********************************************************
     */

    
Method that can be called to construct and configure serializer instance, either given a java.lang.Class to instantiate (with default constructor), or an uninitialized serializer instance. Either way, serialize will be properly resolved (via com.fasterxml.jackson.databind.ser.ResolvableSerializer) and/or contextualized (via com.fasterxml.jackson.databind.ser.ContextualSerializer) as necessary.

Parameters:
annotated Annotated entity that contained definition
serDef Serializer definition: either an instance or class
    public abstract JsonSerializer<ObjectserializerInstance(Annotated annotated,
            Object serDef)
        throws JsonMappingException;
    public abstract ObjectIdGenerator<?> objectIdGeneratorInstance(Annotated annotated,
            ObjectIdInfo objectIdInfo)
        throws JsonMappingException;
    
    /*
    /********************************************************
    /* Convenience methods
    /********************************************************
     */

    
Convenience method that will serialize given value (which can be null) using standard serializer locating functionality. It can be called for all values including field and Map values, but usually field values are best handled calling defaultSerializeField(java.lang.String,java.lang.Object,com.fasterxml.jackson.core.JsonGenerator) instead.
    public final void defaultSerializeValue(Object valueJsonGenerator jgen)
        throws IOExceptionJsonProcessingException
    {
        if (value == null) {
            getDefaultNullValueSerializer().serialize(nulljgenthis);
        } else {
            Class<?> cls = value.getClass();
            findTypedValueSerializer(clstruenull).serialize(valuejgenthis);
        }
    }
    
    
Convenience method that will serialize given field with specified value. Value may be null. Serializer is done using the usual null) using standard serializer locating functionality.
    public final void defaultSerializeField(String fieldNameObject valueJsonGenerator jgen)
        throws IOExceptionJsonProcessingException
    {
        jgen.writeFieldName(fieldName);
        if (value == null) {
            /* Note: can't easily check for suppression at this point
             * any more; caller must check it.
             */
            getDefaultNullValueSerializer().serialize(nulljgenthis);
        } else {
            Class<?> cls = value.getClass();
            findTypedValueSerializer(clstruenull).serialize(valuejgenthis);
        }
    }
    /*
    /**********************************************************
    /* Convenience methods
    /**********************************************************
     */

    
Method that will handle serialization of Date(-like) values, using SerializationConfig settings to determine expected serialization behavior. Note: date here means "full" date, that is, date AND time, as per Java convention (and not date-only values like in SQL)
    public final void defaultSerializeDateValue(long timestampJsonGenerator jgen)
        throws IOExceptionJsonProcessingException
    {
        // [JACKSON-87]: Support both numeric timestamps and textual
            jgen.writeNumber(timestamp);
        } else {
            jgen.writeString(_dateFormat().format(new Date(timestamp)));
        }
    }

    
Method that will handle serialization of Date(-like) values, using SerializationConfig settings to determine expected serialization behavior. Note: date here means "full" date, that is, date AND time, as per Java convention (and not date-only values like in SQL)
    public final void defaultSerializeDateValue(Date dateJsonGenerator jgen)
        throws IOExceptionJsonProcessingException
    {
        // [JACKSON-87]: Support both numeric timestamps and textual
            jgen.writeNumber(date.getTime());
        } else {
            jgen.writeString(_dateFormat().format(date));
        }
    }

    
Method that will handle serialization of Dates used as java.util.Map keys, based on SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS value (and if using textual representation, configured date format)
    public void defaultSerializeDateKey(long timestampJsonGenerator jgen)
        throws IOExceptionJsonProcessingException
    {
            jgen.writeFieldName(String.valueOf(timestamp));
        } else {
            jgen.writeFieldName(_dateFormat().format(new Date(timestamp)));
        }
    }

    
Method that will handle serialization of Dates used as java.util.Map keys, based on SerializationFeature.WRITE_DATE_KEYS_AS_TIMESTAMPS value (and if using textual representation, configured date format)
    public void defaultSerializeDateKey(Date dateJsonGenerator jgen)
        throws IOExceptionJsonProcessingException
    {
            jgen.writeFieldName(String.valueOf(date.getTime()));
        } else {
            jgen.writeFieldName(_dateFormat().format(date));
        }
    }
    
    public final void defaultSerializeNull(JsonGenerator jgen)
        throws IOExceptionJsonProcessingException
    {
        getDefaultNullValueSerializer().serialize(nulljgenthis);
    }
    /*
    /********************************************************
    /* Helper methods
    /********************************************************
     */
    
    protected void _reportIncompatibleRootType(Object valueJavaType rootType)
        throws IOExceptionJsonProcessingException
    {
        /* 07-Jan-2010, tatu: As per [JACKSON-456] better handle distinction between wrapper types,
         *    primitives
         */
        if (rootType.isPrimitive()) {
            Class<?> wrapperType = ClassUtil.wrapperType(rootType.getRawClass());
            // If it's just difference between wrapper, primitive, let it slide
            if (wrapperType.isAssignableFrom(value.getClass())) {
                return;
            }
        }
        throw new JsonMappingException("Incompatible types: declared root type ("+rootType+") vs "
                +value.getClass().getName());
    }
    
    
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.

Returns:
Serializer if one can be found, null if not.
    protected JsonSerializer<Object_findExplicitUntypedSerializer(Class<?> runtimeType)
    {        
        // Fast lookup from local lookup thingy works?
        JsonSerializer<Objectser = .untypedValueSerializer(runtimeType);
        if (ser != null) {
            return ser;
        }
        // If not, maybe shared map already has it?
        ser = .untypedValueSerializer(runtimeType);
        if (ser != null) {
            return ser;
        }
        try {
            return _createAndCacheUntypedSerializer(runtimeType);
        } catch (Exception e) {
            return null;
        }
    }
    /*
    /**********************************************************
    /* Low-level methods for actually constructing and initializing
    /* serializers
    /**********************************************************
     */
    
    
Method that will try to construct a value serializer; and if one is successfully created, cache it for reuse.
        throws JsonMappingException
    {        
        JsonSerializer<Objectser;
        try {
            ser = _createUntypedSerializer(.constructType(type));
        } catch (IllegalArgumentException iae) {
            /* We better only expose checked exceptions, since those
             * are what caller is expected to handle
             */
            throw new JsonMappingException(iae.getMessage(), nulliae);
        }
        if (ser != null) {
            .addAndResolveNonTypedSerializer(typeserthis);
        }
        return ser;
    }
        throws JsonMappingException
    {        
        JsonSerializer<Objectser;
        try {
            ser = _createUntypedSerializer(type);
        } catch (IllegalArgumentException iae) {
            /* We better only expose checked exceptions, since those
             * are what caller is expected to handle
             */
            throw new JsonMappingException(iae.getMessage(), nulliae);
        }
    
        if (ser != null) {
            .addAndResolveNonTypedSerializer(typeserthis);
        }
        return ser;
    }

    

Since:
2.1
    @SuppressWarnings("deprecation")
        throws JsonMappingException
    {
        /* 30-Sep-2012, tatu: For now need to call the deprecated method; for 2.2,
         *   convert to using new one. But note that we do NOT pass 'property' along.
         */
        return (JsonSerializer<Object>).createSerializer(thistypenull);
    }

    
Helper method called to resolve and contextualize given serializer, if and as necessary.
            BeanProperty property)
        throws JsonMappingException
    {
        if (ser instanceof ResolvableSerializer) {
            ((ResolvableSerializerser).resolve(this);
        }
        return _handleContextual(serproperty);
    }
    @SuppressWarnings("unchecked")
        throws JsonMappingException
    {
        if (ser instanceof ResolvableSerializer) {
            ((ResolvableSerializerser).resolve(this);
        }
        return (JsonSerializer<Object>) ser;
    }
    
    @SuppressWarnings("unchecked")
            BeanProperty property)
        throws JsonMappingException
    {
        if (ser instanceof ContextualSerializer) {
            ser = ((ContextualSerializerser).createContextual(thisproperty);
        }
        return (JsonSerializer<Object>) ser;
    }
    /*
    /**********************************************************
    /* Internal methods
    /**********************************************************
     */
    protected final DateFormat _dateFormat()
    {
        if ( != null) {
            return ;
        }
        /* 24-Feb-2012, tatu: At this point, all timezone configuration
         *    should have occured, with respect to default dateformat
         *    and timezone configuration. But we still better clone
         *    an instance as formatters may be stateful.
         */
        DateFormat df = .getDateFormat();
         = df = (DateFormatdf.clone();
        return df;
    }
New to GrepCode? Check out our FAQ X