Class SimpleModule

  • All Implemented Interfaces:
    Versioned, Serializable

    public class SimpleModule
    extends Module
    implements Serializable
    Vanilla Module 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: 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 JsonSerializers and JsonDeserializers, 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:
    Serialized Form
    • 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​(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

      • getTypeId

        public Object getTypeId()
        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:
        getTypeId in class Module
      • 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)
        Method for adding serializer to handle type that the serializer claims to handle (see JsonSerializer.handledType()).

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

      • addSerializer

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

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

      • addDeserializer

        public <T> SimpleModule addDeserializer​(Class<T> type,
                                                JsonDeserializer<? 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.

      • 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.
        Since:
        2.9
      • 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: Module
        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 Module
      • setupModule

        public void setupModule​(Module.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 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
        Returns:
        Version of the component