4.1
Data-Store
Basic Concepts
Custom Type Handler
This is the manual for older MicroStream versions (Version < 5.0).
The new documentation (Version >= 5.0) is located at:
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.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:1
EmbeddedStorageManager storage = EmbeddedStorage
2
.Foundation(WORKINGDIR)
3
.onConnectionFoundation(f ->
4
f.registerCustomTypeHandlers(new CustomBufferedImageHandler())
5
)
6
.start(ROOT);
Copied!
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.
1
public class Employee
2
{
3
/*
4
* Fields with primitive data are (for whatever reason, e.g. project
5
* design rules) all object types, but records should be stored as
6
* efficient as possible, i.e. without overhead of references and value objects.
7
*
8
* MicroStream's generic type analysis does not know of this and hence cannot
9
* do it. But defining a custom type handler can
10
*/
11
​
12
String id ;
13
Double salary ;
14
Date dateOfBirth;
15
16
// constructor, getters, setters, etc
17
18
/*
19
* The entity class must just contain "any" method returning a suitable type
20
* handler and MicroStream will recognize it and use the returned handler
21
* automatically.
22
*
23
* Type type handler just needs to specify the entity class and define a list
24
* of fields comprised of (name, getter, setter) in arbitrary order.
25
*/
26
static BinaryTypeHandler<Employee> provideTypeHandler()
27
{
28
return Binary.TypeHandler(
29
Employee.class,
30
Binary.Field_long("id",
31
e -> Long.parseLong(e.id),
32
(e, value) -> e.id = String.valueOf(value)
33
),
34
Binary.Field_long("dateOfBirth",
35
e -> e.dateOfBirth.getTime(),
36
(e, value) -> e.dateOfBirth = new Date(value)
37
),
38
Binary.Field_double("salary",
39
e -> e.salary.longValue(),
40
(e, value) -> e.salary = Double.valueOf(value)
41
)
42
);
43
}
44
45
}
Copied!
Last modified 4mo ago
Export as PDF
Copy link