The ObjectTransformer interface uses
callbacks to the application to provide custom implementations of
common and expensive operations such as object serialization and deep
copies on objects.
The ObjectTransformer interface has been
replaced by the DataSerializer plug-ins, which you can use to efficiently
store arbitrary data in WebSphere® eXtreme Scale so that existing product APIs can efficiently interact with
your data.
Overview
Copies of values are always made
except when the NO_COPY mode is used. The default copying mechanism
that is employed in eXtreme Scale is
serialization, which is known as an expensive operation. The ObjectTransformer interface
is used in this situation. The ObjectTransformer interface
uses callbacks to the application to provide a custom implementation
of common and expensive operations, such as object serialization and
deep copies on objects.
An application can provide an implementation
of the
ObjectTransformer interface to a map, and
eXtreme Scale then delegates
to the methods on this object and relies on the application to provide
an optimized version of each method in the interface. The
ObjectTransformer interface
follows:
public interface ObjectTransformer {
void serializeKey(Object key, ObjectOutputStream stream) throws IOException;
void serializeValue(Object value, ObjectOutputStream stream) throws IOException;
Object inflateKey(ObjectInputStream stream) throws IOException, ClassNotFoundException;
Object inflateValue(ObjectInputStream stream) throws IOException, ClassNotFoundException;
Object copyValue(Object value);
Object copyKey(Object key);
}
You can associate an
ObjectTransformer interface
with a BackingMap by using the following example code:
ObjectGrid g = ...;
BackingMap bm = g.defineMap("PERSON");
MyObjectTransformer ot = new MyObjectTransformer();
bm.setObjectTransformer(ot);
Tune deep copy operations
After an application
receives an object from an ObjectMap, eXtreme Scale performs
a deep copy on the object value to ensure that the copy in the BaseMap
map maintains data integrity. The application can then modify the
object value safely. When the transaction commits, the copy of the
object value in the BaseMap map is updated to the new modified value
and the application stops using the value from that point on. You
could have copied the object again at the commit phase to make a private
copy. However, in this case the performance cost of this action was
traded off against requiring the application programmer not to use
the value after the transaction commits. The default ObjectTransformer
attempts to use either a clone or a serialize and inflate pair to
generate a copy. The serialize and inflate pair is the worst case
performance scenario. If profiling reveals that serialize and inflate
is a problem for your application, write an appropriate clone method
to create a deep copy. If you cannot alter the class, then create
a custom ObjectTransformer plug-in and implement more efficient copyValue
and copyKey methods.