MarshalledObject contains a byte stream with the serialized
* representation of an object given to its constructor. The get
* method returns a new copy of the original object, as deserialized from
* the contained byte stream. The contained object is serialized and
* deserialized with the same serialization semantics used for marshaling
* and unmarshaling parameters and return values of RMI calls: When the
* serialized form is created:
*
* MarshalledObject is
* represented by a serialized instance of its stub.
* When copy of the object is retrieved (via the get method),
* if the class is not available locally, it will be loaded from the
* appropriate location (specified the URL annotated with the class descriptor
* when the class was serialized.
*
*
MarshalledObject facilitates passing objects in RMI calls
* that are not automatically deserialized immediately by the remote peer.
*
* @param MarshalledObject
*
* @author Ann Wollrath
* @author Peter Jones
* @since 1.2
*/
public final class MarshalledObjectobjBytes is
* null then the object marshalled was a null
* reference.
*/
private byte[] objBytes = null;
/**
* @serial Bytes of location annotations, which are ignored by
* equals. If locBytes is null, there were no
* non-null annotations during marshalling.
*/
private byte[] locBytes = null;
/**
* @serial Stored hash code of contained object.
*
* @see #hashCode
*/
private int hash;
/** Indicate compatibility with 1.2 version of class. */
private static final long serialVersionUID = 8988374069173025854L;
/**
* Creates a new MarshalledObject that contains the
* serialized representation of the current state of the supplied object.
* The object is serialized with the semantics used for marshaling
* parameters for RMI calls.
*
* @param obj the object to be serialized (must be serializable)
* @exception IOException if an IOException occurs; an
* IOException may occur if obj is not
* serializable.
* @since 1.2
*/
public MarshalledObject(T obj) throws IOException {
if (obj == null) {
hash = 13;
return;
}
ByteArrayOutputStream bout = new ByteArrayOutputStream();
ByteArrayOutputStream lout = new ByteArrayOutputStream();
MarshalledObjectOutputStream out =
new MarshalledObjectOutputStream(bout, lout);
out.writeObject(obj);
out.flush();
objBytes = bout.toByteArray();
// locBytes is null if no annotations
locBytes = (out.hadAnnotations() ? lout.toByteArray() : null);
/*
* Calculate hash from the marshalled representation of object
* so the hashcode will be comparable when sent between VMs.
*/
int h = 0;
for (int i = 0; i < objBytes.length; i++) {
h = 31 * h + objBytes[i];
}
hash = h;
}
/**
* Returns a new copy of the contained marshalledobject. The internal
* representation is deserialized with the semantics used for
* unmarshaling paramters for RMI calls.
*
* @return a copy of the contained object
* @exception IOException if an IOException occurs while
* deserializing the object from its internal representation.
* @exception ClassNotFoundException if a
* ClassNotFoundException occurs while deserializing the
* object from its internal representation.
* could not be found
* @since 1.2
*/
public T get() throws IOException, ClassNotFoundException {
if (objBytes == null) // must have been a null object
return null;
ByteArrayInputStream bin = new ByteArrayInputStream(objBytes);
// locBytes is null if no annotations
ByteArrayInputStream lin =
(locBytes == null ? null : new ByteArrayInputStream(locBytes));
MarshalledObjectInputStream in =
new MarshalledObjectInputStream(bin, lin);
T obj = (T) in.readObject();
in.close();
return obj;
}
/**
* Return a hash code for this MarshalledObject.
*
* @return a hash code
*/
public int hashCode() {
return hash;
}
/**
* Compares this MarshalledObject to another object.
* Returns true if and only if the argument refers to a
* MarshalledObject that contains exactly the same
* serialized representation of an object as this one does. The
* comparison ignores any class codebase annotation, meaning that
* two objects are equivalent if they have the same serialized
* representation except for the codebase of each class
* in the serialized representation.
*
* @param obj the object to compare with this MarshalledObject
* @return true if the argument contains an equaivalent
* serialized object; false otherwise
* @since 1.2
*/
public boolean equals(Object obj) {
if (obj == this)
return true;
if (obj != null && obj instanceof MarshalledObject) {
MarshalledObject other = (MarshalledObject) obj;
// if either is a ref to null, both must be
if (objBytes == null || other.objBytes == null)
return objBytes == other.objBytes;
// quick, easy test
if (objBytes.length != other.objBytes.length)
return false;
//!! There is talk about adding an array comparision method
//!! at 1.2 -- if so, this should be rewritten. -arnold
for (int i = 0; i < objBytes.length; ++i) {
if (objBytes[i] != other.objBytes[i])
return false;
}
return true;
} else {
return false;
}
}
/**
* This class is used to marshal objects for
* MarshalledObject. It places the location annotations
* to one side so that two MarshalledObjects can be
* compared for equality if they differ only in location
* annotations. Objects written using this stream should be read back
* from a MarshalledObjectInputStream.
*
* @see java.rmi.MarshalledObject
* @see MarshalledObjectInputStream
*/
private static class MarshalledObjectOutputStream
extends MarshalOutputStream
{
/** The stream on which location objects are written. */
private ObjectOutputStream locOut;
/** true if non-null annotations are
* written.
*/
private boolean hadAnnotations;
/**
* Creates a new MarshalledObjectOutputStream whose
* non-location bytes will be written to objOut and whose
* location annotations (if any) will be written to
* locOut.
*/
MarshalledObjectOutputStream(OutputStream objOut, OutputStream locOut)
throws IOException
{
super(objOut);
this.useProtocolVersion(ObjectStreamConstants.PROTOCOL_VERSION_2);
this.locOut = new ObjectOutputStream(locOut);
hadAnnotations = false;
}
/**
* Returns true if any non-null location
* annotations have been written to this stream.
*/
boolean hadAnnotations() {
return hadAnnotations;
}
/**
* Overrides MarshalOutputStream.writeLocation implementation to write
* annotations to the location stream.
*/
protected void writeLocation(String loc) throws IOException {
hadAnnotations |= (loc != null);
locOut.writeObject(loc);
}
public void flush() throws IOException {
super.flush();
locOut.flush();
}
}
/**
* The counterpart to MarshalledObjectOutputStream.
*
* @see MarshalledObjectOutputStream
*/
private static class MarshalledObjectInputStream
extends MarshalInputStream
{
/**
* The stream from which annotations will be read. If this is
* null, then all annotations were null.
*/
private ObjectInputStream locIn;
/**
* Creates a new MarshalledObjectInputStream that
* reads its objects from objIn and annotations
* from locIn. If locIn is
* null, then all annotations will be
* null.
*/
MarshalledObjectInputStream(InputStream objIn, InputStream locIn)
throws IOException
{
super(objIn);
this.locIn = (locIn == null ? null : new ObjectInputStream(locIn));
}
/**
* Overrides MarshalInputStream.readLocation to return locations from
* the stream we were given, or null if we were given a
* null location stream.
*/
protected Object readLocation()
throws IOException, ClassNotFoundException
{
return (locIn == null ? null : locIn.readObject());
}
}
}