/*
* Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.rmi;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputFilter;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamConstants;
import java.io.OutputStream;
import java.io.Serializable;
import java.security.AccessController;
import java.security.PrivilegedAction;
import sun.rmi.server.MarshalInputStream;
import sun.rmi.server.MarshalOutputStream;
A 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:
- classes are annotated with a codebase URL from where the class
can be loaded (if available), and
- any remote object in the
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.
Author: Ann Wollrath, Peter Jones Type parameters: - <T> – the type of the object contained in this
MarshalledObject
Since: 1.2
/**
* A <code>MarshalledObject</code> contains a byte stream with the serialized
* representation of an object given to its constructor. The <code>get</code>
* 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:
*
* <ul>
* <li> classes are annotated with a codebase URL from where the class
* can be loaded (if available), and
* <li> any remote object in the <code>MarshalledObject</code> is
* represented by a serialized instance of its stub.
* </ul>
*
* <p>When copy of the object is retrieved (via the <code>get</code> 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.
*
* <p><code>MarshalledObject</code> facilitates passing objects in RMI calls
* that are not automatically deserialized immediately by the remote peer.
*
* @param <T> the type of the object contained in this
* <code>MarshalledObject</code>
*
* @author Ann Wollrath
* @author Peter Jones
* @since 1.2
*/
public final class MarshalledObject<T> implements Serializable {
@serial Bytes of serialized representation. If objBytes is
null then the object marshalled was a null
reference.
/**
* @serial Bytes of serialized representation. If <code>objBytes</code> is
* <code>null</code> then the object marshalled was a <code>null</code>
* 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.
/**
* @serial Bytes of location annotations, which are ignored by
* <code>equals</code>. If <code>locBytes</code> is null, there were no
* non-<code>null</code> annotations during marshalling.
*/
private byte[] locBytes = null;
See Also: @serial Stored hash code of contained object.
/**
* @serial Stored hash code of contained object.
*
* @see #hashCode
*/
private int hash;
Filter used when creating the instance from a stream; may be null. /** Filter used when creating the instance from a stream; may be null. */
private transient ObjectInputFilter objectInputFilter = null;
Indicate compatibility with 1.2 version of class. /** 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.
Params: - obj – the object to be serialized (must be serializable)
Throws: - IOException – if an
IOException occurs; an
IOException may occur if obj is not
serializable.
Since: 1.2
/**
* Creates a new <code>MarshalledObject</code> 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 <code>IOException</code> occurs; an
* <code>IOException</code> may occur if <code>obj</code> 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;
}
Reads in the state of the object and saves the stream's
serialization filter to be used when the object is deserialized.
Params: - stream – the stream
Throws: - IOException – if an I/O error occurs
- ClassNotFoundException – if a class cannot be found
/**
* Reads in the state of the object and saves the stream's
* serialization filter to be used when the object is deserialized.
*
* @param stream the stream
* @throws IOException if an I/O error occurs
* @throws ClassNotFoundException if a class cannot be found
*/
private void readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException {
stream.defaultReadObject(); // read in all fields
objectInputFilter = stream.getObjectInputFilter();
}
Returns a new copy of the contained marshalledobject. The internal
representation is deserialized with the semantics used for
unmarshaling parameters for RMI calls.
If the MarshalledObject was read from an ObjectInputStream,
the filter from that stream is used to deserialize the object.
Throws: - IOException – if an
IOException occurs while
deserializing the object from its internal representation. - ClassNotFoundException – if a
ClassNotFoundException occurs while deserializing the
object from its internal representation.
could not be found
Returns: a copy of the contained object Since: 1.2
/**
* Returns a new copy of the contained marshalledobject. The internal
* representation is deserialized with the semantics used for
* unmarshaling parameters for RMI calls.
* If the MarshalledObject was read from an ObjectInputStream,
* the filter from that stream is used to deserialize the object.
*
* @return a copy of the contained object
* @exception IOException if an <code>IOException</code> occurs while
* deserializing the object from its internal representation.
* @exception ClassNotFoundException if a
* <code>ClassNotFoundException</code> 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, objectInputFilter);
@SuppressWarnings("unchecked")
T obj = (T) in.readObject();
in.close();
return obj;
}
Return a hash code for this MarshalledObject.
Returns: a hash code
/**
* Return a hash code for this <code>MarshalledObject</code>.
*
* @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.
Params: - obj – the object to compare with this
MarshalledObject
Returns: true if the argument contains an equivalent
serialized object; false otherwiseSince: 1.2
/**
* Compares this <code>MarshalledObject</code> to another object.
* Returns true if and only if the argument refers to a
* <code>MarshalledObject</code> 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 <i>except</i> for the codebase of each class
* in the serialized representation.
*
* @param obj the object to compare with this <code>MarshalledObject</code>
* @return <code>true</code> if the argument contains an equivalent
* serialized object; <code>false</code> 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 Also: - MarshalledObject
- MarshalledObjectInputStream
/**
* This class is used to marshal objects for
* <code>MarshalledObject</code>. It places the location annotations
* to one side so that two <code>MarshalledObject</code>s can be
* compared for equality if they differ only in location
* annotations. Objects written using this stream should be read back
* from a <code>MarshalledObjectInputStream</code>.
*
* @see java.rmi.MarshalledObject
* @see MarshalledObjectInputStream
*/
private static class MarshalledObjectOutputStream
extends MarshalOutputStream
{
The stream on which location objects are written. /** The stream on which location objects are written. */
private ObjectOutputStream locOut;
true if non-null annotations are
written.
/** <code>true</code> if non-<code>null</code> 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.
/**
* Creates a new <code>MarshalledObjectOutputStream</code> whose
* non-location bytes will be written to <code>objOut</code> and whose
* location annotations (if any) will be written to
* <code>locOut</code>.
*/
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.
/**
* Returns <code>true</code> if any non-<code>null</code> location
* annotations have been written to this stream.
*/
boolean hadAnnotations() {
return hadAnnotations;
}
Overrides MarshalOutputStream.writeLocation implementation to write
annotations to the location stream.
/**
* 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 Also: - MarshalledObjectOutputStream
/**
* The counterpart to <code>MarshalledObjectOutputStream</code>.
*
* @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.
/**
* The stream from which annotations will be read. If this is
* <code>null</code>, then all annotations were <code>null</code>.
*/
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.
/**
* Creates a new <code>MarshalledObjectInputStream</code> that
* reads its objects from <code>objIn</code> and annotations
* from <code>locIn</code>. If <code>locIn</code> is
* <code>null</code>, then all annotations will be
* <code>null</code>.
*/
MarshalledObjectInputStream(InputStream objIn, InputStream locIn,
ObjectInputFilter filter)
throws IOException
{
super(objIn);
this.locIn = (locIn == null ? null : new ObjectInputStream(locIn));
if (filter != null) {
AccessController.doPrivileged((PrivilegedAction<Void>) () -> {
MarshalledObjectInputStream.this.setObjectInputFilter(filter);
if (MarshalledObjectInputStream.this.locIn != null) {
MarshalledObjectInputStream.this.locIn.setObjectInputFilter(filter);
}
return null;
});
}
}
Overrides MarshalInputStream.readLocation to return locations from
the stream we were given, or null if we were given a
null location stream.
/**
* Overrides MarshalInputStream.readLocation to return locations from
* the stream we were given, or <code>null</code> if we were given a
* <code>null</code> location stream.
*/
protected Object readLocation()
throws IOException, ClassNotFoundException
{
return (locIn == null ? null : locIn.readObject());
}
}
}