RemoteObjectpublic abstract class RemoteObject extends Object implements Remote, SerializableThe RemoteObject class implements the
java.lang.Object behavior for remote objects.
RemoteObject provides the remote semantics of Object by
implementing methods for hashCode, equals, and toString. |
| Fields Summary |
|---|
| protected transient RemoteRef | refThe object's remote reference. | | private static final long | serialVersionUIDindicate compatibility with JDK 1.1.x version of class |
| Constructors Summary |
|---|
protected RemoteObject()Creates a remote object.
ref = null;
| protected RemoteObject(RemoteRef newref)Creates a remote object, initialized with the specified remote
reference.
ref = newref;
|
| Methods Summary |
|---|
| public boolean | equals(java.lang.Object obj)Compares two remote objects for equality.
Returns a boolean that indicates whether this remote object is
equivalent to the specified Object. This method is used when a
remote object is stored in a hashtable.
If the specified Object is not itself an instance of RemoteObject,
then this method delegates by returning the result of invoking the
equals method of its parameter with this remote object
as the argument.
if (obj instanceof RemoteObject) {
if (ref == null) {
return obj == this;
} else {
return ref.remoteEquals(((RemoteObject)obj).ref);
}
} else if (obj != null) {
/*
* Fix for 4099660: if object is not an instance of RemoteObject,
* use the result of its equals method, to support symmetry is a
* remote object implementation class that does not extend
* RemoteObject wishes to support equality with its stub objects.
*/
return obj.equals(this);
} else {
return false;
}
| | public java.rmi.server.RemoteRef | getRef()Returns the remote reference for the remote object.
Note: The object returned from this method may be an instance of
an implementation-specific class. The RemoteObject
class ensures serialization portability of its instances' remote
references through the behavior of its custom
writeObject and readObject methods. An
instance of RemoteRef should not be serialized outside
of its RemoteObject wrapper instance or the result may
be unportable.
return ref;
| | public int | hashCode()Returns a hashcode for a remote object. Two remote object stubs
that refer to the same remote object will have the same hash code
(in order to support remote objects as keys in hash tables).
return (ref == null) ? super.hashCode() : ref.remoteHashCode();
| | private void | readObject(java.io.ObjectInputStream in)readObject for custom serialization.
This method reads this object's serialized form for this class
as follows:
The readUTF method is invoked on in
to read the external ref type name for the RemoteRef
instance to be filled in to this object's ref field.
If the string returned by readUTF has length zero,
the readObject method is invoked on in,
and than the value returned by readObject is cast to
RemoteRef and this object's ref field is
set to that value.
Otherwise, this object's ref field is set to a
RemoteRef instance that is created of an
implementation-specific class corresponding to the external ref
type name returned by readUTF, and then
the readExternal method is invoked on
this object's ref field.
If the external ref type name is
"UnicastRef", "UnicastServerRef",
"UnicastRef2", "UnicastServerRef2",
or "ActivatableRef", a corresponding
implementation-specific class must be found, and its
readExternal method must read the serial data
for that external ref type name as specified to be written
in the serialData documentation for this class.
If the external ref type name is any other string (of non-zero
length), a ClassNotFoundException will be thrown,
unless the implementation provides an implementation-specific
class corresponding to that external ref type name, in which
case this object's ref field will be set to an
instance of that implementation-specific class.
String refClassName = in.readUTF();
if (refClassName == null || refClassName.length() == 0) {
/*
* No reference class name specified, so construct
* remote reference from its serialized form.
*/
ref = (RemoteRef) in.readObject();
} else {
/*
* Built-in reference class specified, so delegate to
* internal reference class to initialize its fields from
* its external form.
*/
String internalRefClassName =
RemoteRef.packagePrefix + "." + refClassName;
Class refClass = Class.forName(internalRefClassName);
try {
ref = (RemoteRef) refClass.newInstance();
/*
* If this step fails, assume we found an internal
* class that is not meant to be a serializable ref
* type.
*/
} catch (InstantiationException e) {
throw new ClassNotFoundException(internalRefClassName, e);
} catch (IllegalAccessException e) {
throw new ClassNotFoundException(internalRefClassName, e);
} catch (ClassCastException e) {
throw new ClassNotFoundException(internalRefClassName, e);
}
ref.readExternal(in);
}
| | public java.lang.String | toString()Returns a String that represents the value of this remote object.
String classname = Util.getUnqualifiedName(getClass());
return (ref == null) ? classname :
classname + "[" + ref.remoteToString() + "]";
| | public static java.rmi.Remote | toStub(java.rmi.Remote obj)Returns the stub for the remote object obj passed
as a parameter. This operation is only valid after
the object has been exported.
if (obj instanceof RemoteStub ||
(obj != null &&
Proxy.isProxyClass(obj.getClass()) &&
Proxy.getInvocationHandler(obj) instanceof
RemoteObjectInvocationHandler))
{
return obj;
} else {
return sun.rmi.transport.ObjectTable.getStub(obj);
}
| | private void | writeObject(java.io.ObjectOutputStream out)writeObject for custom serialization.
This method writes this object's serialized form for this class
as follows:
The {@link RemoteRef#getRefClass(java.io.ObjectOutput) getRefClass}
method is invoked on this object's ref field
to obtain its external ref type name.
If the value returned by getRefClass was
a non-null string of length greater than zero,
the writeUTF method is invoked on out
with the value returned by getRefClass, and then
the writeExternal method is invoked on
this object's ref field passing out
as the argument; otherwise,
the writeUTF method is invoked on out
with a zero-length string (""), and then
the writeObject method is invoked on out
passing this object's ref field as the argument.
if (ref == null) {
throw new java.rmi.MarshalException("Invalid remote object");
} else {
String refClassName = ref.getRefClass(out);
if (refClassName == null || refClassName.length() == 0) {
/*
* No reference class name specified, so serialize
* remote reference.
*/
out.writeUTF("");
out.writeObject(ref);
} else {
/*
* Built-in reference class specified, so delegate
* to reference to write out its external form.
*/
out.writeUTF(refClassName);
ref.writeExternal(out);
}
}
|
|
