Module tools.jackson.databind
Package tools.jackson.databind.module

Class SimpleModule

java.lang.Object
tools.jackson.databind.JacksonModule
tools.jackson.databind.module.SimpleModule
All Implemented Interfaces:
Serializable, Versioned
public class SimpleModule extends JacksonModule implements Serializable
Vanilla JacksonModule implementation that allows registration of serializers and deserializers, bean serializer and deserializer modifiers, registration of subtypes and mix-ins as well as some other commonly needed aspects (addition of custom AbstractTypeResolvers, ValueInstantiators).

NOTE: that [de]serializers are registered as "default" [de]serializers. As a result, they will have lower priority than the ones indicated through annotations on both Class and property-associated annotations -- for example, JsonDeserialize.
In cases where both module-based [de]serializers and annotation-based [de]serializers are registered, the [de]serializer specified by the annotation will take precedence.

NOTE: although it is not expected that sub-types should need to override setupModule(SetupContext) method, if they choose to do so they MUST call super.setupModule(context) to ensure that registration works as expected.

WARNING: when registering ValueSerializers and ValueDeserializers, only type erased Class is compared: this means that usually you should NOT use this implementation for registering structured types such as Collections or Maps: this because parametric type information will not be considered and you may end up having "wrong" handler for your type. What you need to do, instead, is to implement Deserializers and/or Serializers callbacks to match full type signatures (with JavaType).

See Also:

  • Field Details

    • _name

      protected final String _name

    • _version

      protected final Version _version

    • _id

      protected final Object _id
      Unique id generated to avoid instances from ever matching so all registrations succeed.

      NOTE! If serialization of SimpleModule instance needed, should be Serializable.

      Since:
      3.0

    • _serializers

      protected SimpleSerializers _serializers

    • _deserializers

      protected SimpleDeserializers _deserializers

    • _keySerializers

      protected SimpleSerializers _keySerializers

    • _keyDeserializers

      protected SimpleKeyDeserializers _keyDeserializers

    • _defaultNullKeySerializer

      protected ValueSerializer<?> _defaultNullKeySerializer

    • _defaultNullValueSerializer

      protected ValueSerializer<?> _defaultNullValueSerializer

    • _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)

    • _deserializerModifier

      protected ValueDeserializerModifier _deserializerModifier

    • _serializerModifier

      protected ValueSerializerModifier _serializerModifier

    • _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.

    • _namingStrategy

      protected PropertyNamingStrategy _namingStrategy

  • Constructor Details

    • 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, Object registrationId)

  • Method Details

    • version

      public Version version()
      Description copied from class: JacksonModule
      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 JacksonModule

    • getRegistrationId

      public Object getRegistrationId()
      Since instances are likely to be custom, implementation returns null if (but only if!) this class is directly instantiated; but class name (default impl) for sub-classes.
      Overrides:
      getRegistrationId in class JacksonModule

    • setSerializers

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

    • setDeserializers

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

    • setKeySerializers

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

    • setKeyDeserializers

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

    • setDefaultNullKeySerializer

      public SimpleModule setDefaultNullKeySerializer(ValueSerializer<?> ser)

    • setDefaultNullValueSerializer

      public SimpleModule setDefaultNullValueSerializer(ValueSerializer<?> ser)

    • setAbstractTypes

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

    • setValueInstantiators

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

    • setDeserializerModifier

      public SimpleModule setDeserializerModifier(ValueDeserializerModifier mod)

    • setSerializerModifier

      public SimpleModule setSerializerModifier(ValueSerializerModifier mod)

    • setNamingStrategy

      protected SimpleModule setNamingStrategy(PropertyNamingStrategy naming)

    • addSerializer

      public SimpleModule addSerializer(ValueSerializer<?> ser)
      Method for adding serializer to handle type that the serializer claims to handle (see ValueSerializer.handledType()).

      WARNING! Type matching only uses type-erased Class and should NOT be used when registering serializers for generic types like Collection and Map.

      WARNING! "Last one wins" rule is applied. Possible earlier addition of a serializer for a given Class will be replaced.

      NOTE: This method registers "default" (de)serializers only. See a note on precedence in class JavaDoc.

      See Also:

    • addSerializer

      public <T> SimpleModule addSerializer(Class<? extends T> type, ValueSerializer<T> ser)
      Method for adding serializer to handle values of specific type.

      NOTE: This method registers "default" (de)serializers only. See a note on precedence in class JavaDoc.

      WARNING! Type matching only uses type-erased Class and should NOT be used when registering serializers for generic types like Collection and Map.

      WARNING! "Last one wins" rule is applied. Possible earlier addition of a serializer for a given Class will be replaced.

      NOTE: This method registers "default" (de)serializers only. See a note on precedence in class JavaDoc.

      See Also:

    • addKeySerializer

      public <T> SimpleModule addKeySerializer(Class<? extends T> type, ValueSerializer<T> ser)
      NOTE: This method registers "default" (de)serializers only. See a note on precedence in class JavaDoc.

    • addDeserializer

      public <T> SimpleModule addDeserializer(Class<T> type, ValueDeserializer<? extends T> deser)
      Method for adding deserializer to handle specified type.

      WARNING! Type matching only uses type-erased Class and should NOT be used when registering serializers for generic types like Collection and Map.

      WARNING! "Last one wins" rule is applied. Possible earlier addition of a serializer for a given Class will be replaced.

      NOTE: This method registers "default" (de)serializers only. See a note on precedence in class JavaDoc.

      See Also:

    • addKeyDeserializer

      public SimpleModule addKeyDeserializer(Class<?> type, KeyDeserializer deser)
      NOTE: This method registers "default" (de)serializers only. See a note on precedence in class JavaDoc.

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

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

    • registerSubtypes

      public SimpleModule registerSubtypes(Collection<Class<?>> 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.

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

    • 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: JacksonModule
      Method that returns a display that can be used by Jackson for informational purposes, as well as in associating extensions with module that provides them.
      Specified by:
      getModuleName in class JacksonModule

    • setupModule

      public void setupModule(JacksonModule.SetupContext context)
      Standard implementation handles registration of all configured customizations: it is important that sub-classes call this implementation (usually before additional custom logic) if they choose to override it; otherwise customizations will not be registered.
      Specified by:
      setupModule in class JacksonModule

    • _checkNotNull

      protected void _checkNotNull(Object thingy, String type)