org.codehaus.jackson.map.deser.CustomDeserializerFactory Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ehcache Show documentation
Ehcache is an open source, standards-based cache used to boost performance, offload the database and simplify scalability. Ehcache is robust, proven and full-featured and this has made it the most widely-used Java-based cache.
There is a newer version: 2.10.9.2
Show newest version
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).
 *  
 *
 *
 * The way custom deserializer factory instances are hooked to
 * {@link ObjectMapper} is usually by constructing an instance of
 * {@link DeserializerProvider} (most commonly
 * {@link StdDeserializerProvider}) with custom deserializer factory,
 * and setting {@link ObjectMapper} to use it.
 * 
 * @deprecated Starting with 1.7, functionality of this class has been
 *    implemented both in base {@link SerializerFactory} (see methods
 *    like {@link 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 release
 */
@Deprecated
public class CustomDeserializerFactory
    extends BeanDeserializerFactory
{
    /*
    /**********************************************************
    /* Configuration, direct/special mappings
    /**********************************************************
     */

    /**
     * Direct mappings that are used for exact class and interface type
     * matches.
     */
    protected 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
     */
    protected HashMap> _mixInAnnotations;

    /*
    /**********************************************************
    /* Life-cycle, constructors
    /**********************************************************
     */

    public CustomDeserializerFactory() {
        this(null);
    }

    protected CustomDeserializerFactory(Config config)
    {
        super(config);
    }
    
    @Override
    public DeserializerFactory withConfig(Config config)
    {
        // See super-class method for reasons for this check...
        if (getClass() != CustomDeserializerFactory.class) {
            throw new IllegalStateException("Subtype of CustomDeserializerFactory ("+getClass().getName()
                    +") has not properly overridden method 'withAdditionalDeserializers': can not instantiate subtype with "
                    +"additional deserializer definitions");
        }
        return new CustomDeserializerFactory(config);
    }
    
    /*
    /**********************************************************
    /* 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