Package com.tangosol.io

Class MultiplexingSerializer

java.lang.Object
com.tangosol.io.MultiplexingSerializer
All Implemented Interfaces:
ClassLoaderAware, Serializer
@Named("multi") public class MultiplexingSerializer extends Object implements Serializer, ClassLoaderAware
A Serializer implementation that multiplexes serialization/deserialization requests across multiple Serializer implementations.

More specifically, for serialization operations, the list of available Serializers are iterated over. The first serializer that is able to serialize the object without error, will be the Serializer used for that type going forward. All serialized payloads will be prefixed with the following header to enable deserialization. 

     +--------------+-------------------------+
     |  Length (4)  | Serializer Name (1...)  |
     +--------------+-------------------------+
     |  Serialized Payload (0...)             |
     +----------------------------------------+
Upon deserialization, the header will be read and the specified Serializer will be used to deserialize the payload. If the header is no present, an IOException will be thrown.
Since:
20.06

  • Field Details

  • Constructor Details

    • MultiplexingSerializer

      public MultiplexingSerializer(Serializer... serializers)
      Construct a new Serializer that will multiplex serialization operations across the provided list of Serializers. It's important to keep in mind that the iteration order when performing serialization/deserialization operation is based on the order they are provided. This may have bearing on ordering decisions.
      Throws:
      IllegalArgumentException - if no Serializers are provided, or if the any of the provided Serializers return null from Serializer.getName()

  • Method Details

    • serialize

      public void serialize(WriteBuffer.BufferOutput out, Object o) throws IOException
      Description copied from interface: Serializer
      Serialize an object to a WriteBuffer by writing its state using the specified BufferOutput object.

      Note: Starting with Coherence 12.2.1 classes that need to designate an alternative object to be used by the Serializer when writing the object to the buffer should implement the SerializationSupport.writeReplace() method.

      Specified by:
      serialize in interface Serializer
      Parameters:
      out - the BufferOutput with which to write the object's state
      o - the object to serialize
      Throws:
      IOException - if an I/O error occurs

    • deserialize

      public <T> T deserialize(ReadBuffer.BufferInput in, Class<? extends T> clazz) throws IOException
      Description copied from interface: Serializer
      Deserialize an object as an instance of the specified class by reading its state using the specified BufferInput object.

      Note: Starting with Coherence 12.2.1 classes that need to designate an alternative object to be returned by the Serializer after an object is deserialized from the buffer should implement the SerializationSupport.readResolve() method.

      Specified by:
      deserialize in interface Serializer
      Type Parameters:
      T - the class to deserialize to
      Parameters:
      in - the BufferInput with which to read the object's state
      clazz - the type of the object to deserialize
      Returns:
      the deserialized user type instance
      Throws:
      IOException - if an I/O error occurs

    • getName

      public String getName()
      Description copied from interface: Serializer
      Return the name of this serializer.
      Specified by:
      getName in interface Serializer
      Returns:
      the name of this serializer

    • getContextClassLoader

      public ClassLoader getContextClassLoader()
      Description copied from interface: ClassLoaderAware
      Retrieve the context ClassLoader for this object. The context ClassLoader is provided by the creator of the object for use by the object when loading classes and resources.
      Specified by:
      getContextClassLoader in interface ClassLoaderAware
      Returns:
      the context ClassLoader for this object
      See Also:

    • setContextClassLoader

      public void setContextClassLoader(ClassLoader loader)
      Description copied from interface: ClassLoaderAware
      Specify the context ClassLoader for this object. The context ClassLoader can be set when the object is created, and allows the creator to provide the appropriate class loader to be used by the object when when loading classes and resources.
      Specified by:
      setContextClassLoader in interface ClassLoaderAware
      Parameters:
      loader - the context ClassLoader for this object

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • doSerialization

      protected void doSerialization(WriteBuffer.BufferOutput out, Object o, Serializer[] serializers) throws IOException
      See Serializer.serialize(WriteBuffer.BufferOutput, Object)
      Parameters:
      out - the WriteBuffer.BufferOutput to write to
      o - the object to serialize
      serializers - the Serializers to attempt the serialization operation against
      Throws:
      IOException - if an error occurs during serialization

    • doWrite

      protected void doWrite(WriteBuffer.BufferOutput out, Object o, Serializer serializer) throws IOException
      Writes the serialization header and payload.
      Parameters:
      out - the WriteBuffer.BufferOutput to write to
      o - the object to serialize
      serializer - the Serializer to use
      Throws:
      IOException - if an error occurs during serialization

    • logSerializationErrors

      protected void logSerializationErrors(Map<Serializer,Exception> serializerExceptionMap, String typeName)
      Given the provided mappings between a Serializer and the Exception it threw, log each mapping for diagnostic purposes.
      Parameters:
      serializerExceptionMap - a mapping between a Serializer instance and the Exception it threw for any given serialization operation
      typeName - The name of the type that produced the error.

    • writeSerializationHeader

      protected int writeSerializationHeader(WriteBuffer.BufferOutput out, String serializerName) throws IOException
      Write the multiplex serialization header. 
           +--------------+-------------------------+
     |  Length (4)  | Serializer Name (1...)  |
     +--------------+-------------------------+
     |  Serialized Payload (0...)             |
     +----------------------------------------+
      Parameters:
      out - the stream to write to
      serializerName - the name of the Serializer
      Throws:
      IOException - if an error occurs writing the header or payload
      See Also:

    • readSerializationHeader

      protected MultiplexingSerializer.SerializationHeader readSerializationHeader(ReadBuffer.BufferInput in)
      Read the MultiplexingSerializer.SerializationHeader. 
           +--------------+-------------------------+
     |  Length (4)  | Serializer Name (1...)  |
     +--------------+-------------------------+
     |  Serialized Payload (0...)             |
     +----------------------------------------+
      Parameters:
      in - the stream to read from
      Returns:
      the SerializationHeader if present and a matching Serializer is found, otherwise returns null