<document>
<deftable>
Serialization Servlet
Serialized class
Enumeration for the car color
Enumeration for the car model
</deftable>

In this simple example, we'll use Hessian 2.0 to serialize three Car objects to a byte array. The serialized data could be saved in a persistent store, or sent as a message in a SOA or JMS application. Because Hessian 2.0 is cross-language, the message could be deserialized by a .NET or even a PHP application.

The efficiency of Hessian 2.0 is about twice that of java.io serialization. This is a tiny example, of course, but does show that you can send compact, cross-language messages without having to use bloated XML solutions like SOAP.

<deftable>
Hessian 2.0 139 bytes
java.io 287 bytes
Hessian 2.0 with Deflation 164 bytes
</deftable>

The example's model is a Car object with three fields: year, model, and color. The model and color are enumeration types.

package example; public class Car { private int year; private Model model; private Color color; } package example; public enum Model { CIVIC, EDSEL, MODEL_T, } package example; public enum Model { BLACK, GREEN, BLUE, }

The Hessian serialization API resembles java.io `ObjectOutputStream` serialization. The general steps are to create a `Hessian2Output` around any `OutputStream` and write data to the stream. In this example, we've encapsulated the object in a Hessian 2.0 message using `startMessage` and `completeMessage` to show how you would create a message for an SOA or JMS application.

ByteArrayOutputStream bos = new ByteArrayOutputStream(); Hessian2Output out = new Hessian2Output(bos); out.startMessage(); out.writeInt(2); Car car1 = new Car(Model.EDSEL, Color.GREEN, 1954); out.writeObject(car1); Car car2 = new Car(Model.MODEL_T, Color.BLACK, 1937); out.writeObject(car2); out.completeMessage(); out.close(); byte []data = bos.toByteArray();

The deserialization is the same as serialization. Create an `Hessian2Input` around any `InputStream` and read data from the stream.

ByteArrayInputStream bin = new ByteArrayInputStream(data); Hessian2Input in = new Hessian2Input(bin); in.startMessage(); ArrayList list = new ArrayList(); int length = in.readInt(); for (int i = 0; i < length; i++) { list.add(in.readObject()); } in.completeMessage(); in.close(); bin.close();

The Hessian 2.0 draft specification has added support for envelopes around Hessian messages. These envelopes can provide additional capabilities like compression, encryption, and message signatures. The envelope can also be used to attach routing and reliability information to a message. Since envelopes are nestable, each envelope can be simple and provide powerful capabilities when combined. For example, a secure messaging system might compress, encrypt and then securely sign a message.

The API for using envelopes is `wrap()` for writing a message and `unwrap()` for reading a message. The application serialization code itself is identical, since the envelope just creates a `Hessian2Input` or `Hessian2Output` wrapper around the original stream.

Deflation envelope = new Deflation(); ByteArrayOutputStream bos = new ByteArrayOutputStream(); Hessian2Output out = new Hessian2Output(bos); out = out.wrap(out); out.startMessage(); Car car1 = new Car(Model.EDSEL, Color.GREEN, 1954); out.writeObject(car1); out.completeMessage(); out.close(); byte []data = bos.toByteArray(); Deflation envelope = new Deflation(); ByteArrayInputStream bin = new ByteArrayInputStream(data); Hessian2Input in = new Hessian2Input(bin); in = envelope.unwrap(in); in.startMessage(); Object value = in.readObject(); in.completeMessage();
</document>