## com.fasterxml.jackson.databind.module
Class SimpleModule

    java.lang.Object
      com.fasterxml.jackson.databind.Module
          com.fasterxml.jackson.databind.module.SimpleModule

All Implemented Interfaces:
  Versioned

    public class SimpleModule

extends Module

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

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(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

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.com. All Rights Reserved.