Custom Type Handler

Custom type handlers allow taking control over the storing and loading procedure of specific java types. This is useful to optimize the performance for storing complex objects or in the rare case that it is not possible to store a type with the default type handlers.

Implementation

There are two strategies for a simplified type handler implementation.

A Custom Binary Handler

Implementing a class that extends CustomBinaryHandler and defines a sequence of BinaryFields via the #Field~ static pseudo-constructor methods. Everything else like setting the name, calculating the binary offsets, etc. is then done implicitly via reflection.

Example on GitHub

This example implements a custom type handler for the java.awt.image.BufferedImage class. Instead of storing the rather complex object structure of that class the image is serialized as PNG image format using javax.imageio.ImageIO into a byte array. This byte array is then stored by MicroStream.

The custom type handler must be registered in the CustomTypeHandlerRegistry to enable it:

EmbeddedStorageManager storage = EmbeddedStorage
.Foundation(WORKINGDIR)
.onConnectionFoundation(f ->
f.registerCustomTypeHandlers(new CustomBufferedImageHandler())
)
.start(ROOT);

A Static Provider Method

Implementing a class can be skipped altogether by using the method Binary#TypeHandler and passing the BinaryFields directly. Registering such a generically created TypeHandler is not required, either, since Version 3 of MicroStream brought a solution to just define a static method in the entity class that will be recognized and used by MicroStream.

The following is a simple technical example on how a custom binary handler can be easily defined and technically leveraged to optimize storage behavior. E.g. imagine having millions of such objects that now only create 1 database record with a fraction of the required storage space instead of 4 records but hold the same information.

public class Employee
{
/*
* Fields with primitive data are (for whatever reason, e.g. project
* design rules) all object types, but records should be stored as
* efficient as possible, i.e. without overhead of references and value objects.
*
* MicroStream's generic type analysis does not know of this and hence cannot
* do it. But defining a custom type handler can
*/
String id ;
Double salary ;
Date dateOfBirth;
// constructor, getters, setters, etc
/*
* The entity class must just contain "any" method returning a suitable type
* handler and MicroStream will recognize it and use the returned handler
* automatically.
*
* Type type handler just needs to specify the entity class and define a list
* of fields comprised of (name, getter, setter) in arbitrary order.
*/
static BinaryTypeHandler<Employee> provideTypeHandler()
{
return Binary.TypeHandler(
Employee.class,
Binary.Field_long("id",
e -> Long.parseLong(e.id),
(e, value) -> e.id = String.valueOf(value)
),
Binary.Field_long("dateOfBirth",
e -> e.dateOfBirth.getTime(),
(e, value) -> e.dateOfBirth = new Date(value)
),
Binary.Field_double("salary",
e -> e.salary.longValue(),
(e, value) -> e.salary = Double.valueOf(value)
)
);
}
}

Full example is available on GitHub.