com.fasterxml.jackson.databind.module
Class SimpleModule

java.lang.Object
  extended by com.fasterxml.jackson.databind.Module
      extended by com.fasterxml.jackson.databind.module.SimpleModule
All Implemented Interfaces:
Versioned, Serializable

public class SimpleModule
extends Module
implements Serializable

Simple Module implementation that allows registration of serializers and deserializers, and bean serializer and deserializer modifiers.

See Also:
Serialized Form

Nested Class Summary
 
Nested classes/interfaces inherited from class com.fasterxml.jackson.databind.Module
Module.SetupContext
 
Field Summary
protected  SimpleAbstractTypeResolver _abstractTypes
          Lazily-constructed resolver used for storing mappings from abstract classes to more specific implementing classes (which may be abstract or concrete)
protected  SimpleDeserializers _deserializers
           
protected  SimpleKeyDeserializers _keyDeserializers
           
protected  SimpleSerializers _keySerializers
           
protected  HashMap<Class<?>,Class<?>> _mixins
          Lazily-constructed map that contains mix-in definitions, indexed by target class, value being mix-in to apply.
protected  String _name
           
protected  SimpleSerializers _serializers
           
protected  LinkedHashSet<NamedType> _subtypes
          Set of subtypes to register, if any.
protected  SimpleValueInstantiators _valueInstantiators
          Lazily-constructed resolver used for storing mappings from abstract classes to more specific implementing classes (which may be abstract or concrete)
protected  Version _version
           
 
Constructor Summary
SimpleModule()
          Constructors that should only be used for non-reusable convenience modules used by app code: "real" modules should use actual name and version number information.
SimpleModule(String name)
          Convenience constructor that will default version to Version.unknownVersion().
SimpleModule(String name, Version version)
          Constructor to use for actual reusable modules.
SimpleModule(String name, Version version, List<JsonSerializer<?>> serializers)
           
SimpleModule(String name, Version version, Map<Class<?>,JsonDeserializer<?>> deserializers)
           
SimpleModule(String name, Version version, Map<Class<?>,JsonDeserializer<?>> deserializers, List<JsonSerializer<?>> serializers)
           
SimpleModule(Version version)
          Convenience constructor that will use specified Version, including name from Version.getArtifactId()
 
Method Summary
<T> SimpleModule
addAbstractTypeMapping(Class<T> superType, Class<? extends T> subType)
          Lazily-constructed resolver used for storing mappings from abstract classes to more specific implementing classes (which may be abstract or concrete)
<T> SimpleModule
addDeserializer(Class<T> type, JsonDeserializer<? extends T> deser)
           
 SimpleModule addKeyDeserializer(Class<?> type, KeyDeserializer deser)
           
<T> SimpleModule
addKeySerializer(Class<? extends T> type, JsonSerializer<T> ser)
           
<T> SimpleModule
addSerializer(Class<? extends T> type, JsonSerializer<T> ser)
           
 SimpleModule addSerializer(JsonSerializer<?> ser)
           
 SimpleModule addValueInstantiator(Class<?> beanType, ValueInstantiator inst)
          Method for registering ValueInstantiator to use when deserializing instances of type beanType.
 String getModuleName()
          Method that returns identifier for module; this can be used by Jackson for informational purposes, as well as in associating extensions with module that provides them.
 SimpleModule registerSubtypes(Class<?>... subtypes)
          Method for adding set of subtypes to be registered with ObjectMapper this is an alternative to using annotations in super type to indicate subtypes.
 SimpleModule registerSubtypes(NamedType... subtypes)
          Method for adding set of subtypes (along with type name to use) to be registered with ObjectMapper this is an alternative to using annotations in super type to indicate subtypes.
 void setAbstractTypes(SimpleAbstractTypeResolver atr)
          Resets currently configured abstract type mappings
 void setDeserializers(SimpleDeserializers d)
          Resets all currently configured deserializers.
 void setKeyDeserializers(SimpleKeyDeserializers kd)
          Resets all currently configured key deserializers.
 void setKeySerializers(SimpleSerializers ks)
          Resets all currently configured key serializers.
 SimpleModule setMixInAnnotation(Class<?> targetType, Class<?> mixinClass)
          Method for specifying that annotations define by mixinClass should be "mixed in" with annotations that targetType has (as if they were directly included on it!).
 void setSerializers(SimpleSerializers s)
          Resets all currently configured serializers.
 void setupModule(Module.SetupContext context)
          Method called by ObjectMapper when module is registered.
 void setValueInstantiators(SimpleValueInstantiators svi)
          Resets all currently configured value instantiators
 Version version()
          Method that returns version of this module.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Field Detail

_name

protected final String _name

_version

protected final Version _version

_serializers

protected SimpleSerializers _serializers

_deserializers

protected SimpleDeserializers _deserializers

_keySerializers

protected SimpleSerializers _keySerializers

_keyDeserializers

protected SimpleKeyDeserializers _keyDeserializers

_abstractTypes

protected SimpleAbstractTypeResolver _abstractTypes
Lazily-constructed resolver used for storing mappings from abstract classes to more specific implementing classes (which may be abstract or concrete)


_valueInstantiators

protected SimpleValueInstantiators _valueInstantiators
Lazily-constructed resolver used for storing mappings from abstract classes to more specific implementing classes (which may be abstract or concrete)


_mixins

protected HashMap<Class<?>,Class<?>> _mixins
Lazily-constructed map that contains mix-in definitions, indexed by target class, value being mix-in to apply.


_subtypes

protected LinkedHashSet<NamedType> _subtypes
Set of subtypes to register, if any.

Constructor Detail

SimpleModule

public SimpleModule()
Constructors that should only be used for non-reusable convenience modules used by app code: "real" modules should use actual name and version number information.


SimpleModule

public SimpleModule(String name)
Convenience constructor that will default version to Version.unknownVersion().


SimpleModule

public SimpleModule(Version version)
Convenience constructor that will use specified Version, including name from Version.getArtifactId()


SimpleModule

public SimpleModule(String name,
                    Version version)
Constructor to use for actual reusable modules. ObjectMapper may use name as identifier to notice attempts for multiple registrations of the same module (although it does not have to).

Parameters:
name - Unique name of the module
version - Version of the module

SimpleModule

public SimpleModule(String name,
                    Version version,
                    Map<Class<?>,JsonDeserializer<?>> deserializers)
Since:
2.1

SimpleModule

public SimpleModule(String name,
                    Version version,
                    List<JsonSerializer<?>> serializers)
Since:
2.1

SimpleModule

public SimpleModule(String name,
                    Version version,
                    Map<Class<?>,JsonDeserializer<?>> deserializers,
                    List<JsonSerializer<?>> serializers)
Since:
2.1
Method Detail

setSerializers

public void setSerializers(SimpleSerializers s)
Resets all currently configured serializers.


setDeserializers

public void setDeserializers(SimpleDeserializers d)
Resets all currently configured deserializers.


setKeySerializers

public void setKeySerializers(SimpleSerializers ks)
Resets all currently configured key serializers.


setKeyDeserializers

public void setKeyDeserializers(SimpleKeyDeserializers kd)
Resets all currently configured key deserializers.


setAbstractTypes

public void setAbstractTypes(SimpleAbstractTypeResolver atr)
Resets currently configured abstract type mappings


setValueInstantiators

public void setValueInstantiators(SimpleValueInstantiators svi)
Resets all currently configured value instantiators


addSerializer

public SimpleModule addSerializer(JsonSerializer<?> ser)

addSerializer

public <T> SimpleModule addSerializer(Class<? extends T> type,
                                      JsonSerializer<T> ser)

addKeySerializer

public <T> SimpleModule addKeySerializer(Class<? extends T> type,
                                         JsonSerializer<T> ser)

addDeserializer

public <T> SimpleModule addDeserializer(Class<T> type,
                                        JsonDeserializer<? extends T> deser)

addKeyDeserializer

public SimpleModule addKeyDeserializer(Class<?> type,
                                       KeyDeserializer deser)

addAbstractTypeMapping

public <T> SimpleModule addAbstractTypeMapping(Class<T> superType,
                                               Class<? extends T> subType)
Lazily-constructed resolver used for storing mappings from abstract classes to more specific implementing classes (which may be abstract or concrete)


addValueInstantiator

public SimpleModule addValueInstantiator(Class<?> beanType,
                                         ValueInstantiator inst)
Method for registering ValueInstantiator to use when deserializing instances of type beanType.

Instantiator is registered when module is registered for ObjectMapper.


registerSubtypes

public SimpleModule registerSubtypes(Class<?>... subtypes)
Method for adding set of subtypes to be registered with ObjectMapper this is an alternative to using annotations in super type to indicate subtypes.


registerSubtypes

public SimpleModule registerSubtypes(NamedType... subtypes)
Method for adding set of subtypes (along with type name to use) to be registered with ObjectMapper this is an alternative to using annotations in super type to indicate subtypes.


setMixInAnnotation

public SimpleModule setMixInAnnotation(Class<?> targetType,
                                       Class<?> mixinClass)
Method for specifying that annotations define by mixinClass should be "mixed in" with annotations that targetType has (as if they were directly included on it!).

Mix-in annotations are registered when module is registered for ObjectMapper.


getModuleName

public String getModuleName()
Description copied from class: Module
Method that returns identifier for module; this can be used by Jackson for informational purposes, as well as in associating extensions with module that provides them.

Specified by:
getModuleName in class Module

setupModule

public void setupModule(Module.SetupContext context)
Description copied from class: Module
Method called by ObjectMapper when module is registered. It is called to let module register functionality it provides, using callback methods passed-in context object exposes.

Specified by:
setupModule in class Module

version

public Version version()
Description copied from class: Module
Method that returns version of this module. Can be used by Jackson for informational purposes.

Specified by:
version in interface Versioned
Specified by:
version in class Module


Copyright © 2012 FasterXML. All Rights Reserved.