org.codehaus.jackson.map.deser.CustomDeserializerFactory Maven / Gradle / Ivy
package org.codehaus.jackson.map.deser;
import java.util.*;
import org.codehaus.jackson.type.JavaType;
import org.codehaus.jackson.map.*;
import org.codehaus.jackson.map.type.*;
/**
* Deserializer factory implementation that allows for configuring
* mapping between types and deserializers to use, by using
* multiple types of overrides. Existing mappings established by
* {@link BeanDeserializerFactory} (and its super class,
* {@link BasicDeserializerFactory}) are used if no overrides are
* defined.
*
* Unlike base deserializer factories, this factory is stateful because
* of configuration settings. It is thread-safe, however, as long as
* all configuration as done before using the factory -- a single
* instance can be shared between providers and mappers.
*
* Configurations currently available are:
*
* - Ability to define explicit mappings between simple non-generic
* classes/interfaces and deserializers to use for deserializing
* instance of these classes. Mappings are one-to-one (i.e. there is
* no "generic" variant for handling sub- or super-classes/interfaces).
*
*
*
* In near future, following features are planned to be added:
*
* - Ability to define "mix-in annotations": associations between types
* (classes, interfaces) to deserialize, and a "mix-in" type which will
* be used so that all of its annotations are added to the deserialized
* type. Mixed-in annotations have priority over annotations that the
* deserialized type has. In effect this allows for overriding annotations
* types have; this is useful when type definition itself can not be
* modified
*
*/
public class CustomDeserializerFactory
extends BeanDeserializerFactory
{
/*
////////////////////////////////////////////////////
// Configuration, direct/special mappings
////////////////////////////////////////////////////
*/
/**
* Direct mappings that are used for exact class and interface type
* matches.
*/
HashMap> _directClassMappings = null;
/*
//////////////////////////////////////////////////////////
// Configuration: mappings that define "mix-in annotations"
//////////////////////////////////////////////////////////
*/
/**
* Mapping that defines how to apply mix-in annotations: key is
* the type to received additional annotations, and value is the
* type that has annotations to "mix in".
*
* Annotations associated with the value classes will be used to
* override annotations of the key class, associated with the
* same field or method. They can be further masked by sub-classes:
* you can think of it as injecting annotations between the target
* class and its sub-classes (or interfaces)
*
* @since 1.2
*/
HashMap> _mixInAnnotations;
/*
////////////////////////////////////////////////////
// Life-cycle, constructors
////////////////////////////////////////////////////
*/
public CustomDeserializerFactory() { super(); }
/*
////////////////////////////////////////////////////
// Configuration: type-to-serializer mappings
////////////////////////////////////////////////////
*/
/**
* Method used to add a mapping for specific type -- and only that
* type -- to use specified deserializer.
* This means that binding is not used for sub-types.
*
* Note that both class and interfaces can be mapped, since the type
* is derived from method declarations; and hence may be abstract types
* and interfaces. This is different from custom serialization where
* only class types can be directly mapped.
*
* @param forClass Class to deserialize using specific deserializer.
* @param deser Deserializer to use for the class. Declared type for
* deserializer may be more specific (sub-class) than declared class
* to map, since that will still be compatible (deserializer produces
* sub-class which is assignable to field/method)
*/
@SuppressWarnings("unchecked")
public void addSpecificMapping(Class forClass, JsonDeserializer deser)
{
ClassKey key = new ClassKey(forClass);
if (_directClassMappings == null) {
_directClassMappings = new HashMap>();
}
_directClassMappings.put(key, (JsonDeserializer