UnicastRemoteObjectpublic class UnicastRemoteObject extends RemoteServer | Used for exporting a remote object with JRMP and obtaining a stub
that communicates to the remote object.
For the constructors and static exportObject methods
below, the stub for a remote object being exported is obtained as
follows:
- If the remote object is exported using the {@link
#exportObject(Remote) UnicastRemoteObject.exportObject(Remote)} method,
a stub class (typically pregenerated from the remote object's class
using the
rmic tool) is loaded and an instance of that stub
class is constructed as follows.
- A "root class" is determined as follows: if the remote object's
class directly implements an interface that extends {@link Remote}, then
the remote object's class is the root class; otherwise, the root class is
the most derived superclass of the remote object's class that directly
implements an interface that extends
Remote.
- The name of the stub class to load is determined by concatenating
the binary name of the root class with the suffix
"_Stub".
- The stub class is loaded by name using the class loader of the root
class. The stub class must extend {@link RemoteStub} and must have a
public constructor that has one parameter, of type {@link RemoteRef}.
- Finally, an instance of the stub class is constructed with a
{@link RemoteRef}.
- If the appropriate stub class could not be found, or the stub class
could not be loaded, or a problem occurs creating the stub instance, a
{@link StubNotFoundException} is thrown.
- For all other means of exporting:
- If the remote object's stub class (as defined above) could not be
loaded or the system property
java.rmi.server.ignoreStubClasses is set to
"true" (case insensitive), a {@link
java.lang.reflect.Proxy} instance is constructed with the following
properties:
- The proxy's class is defined by the class loader of the remote
object's class.
- The proxy implements all the remote interfaces implemented by the
remote object's class.
- The proxy's invocation handler is a {@link
RemoteObjectInvocationHandler} instance constructed with a
{@link RemoteRef}.
- If the proxy could not be created, a {@link StubNotFoundException}
will be thrown.
- Otherwise, an instance of the remote object's stub class (as
described above) is used as the stub.
|
| Fields Summary |
|---|
| private int | port | | private RMIClientSocketFactory | csf | | private RMIServerSocketFactory | ssf | | private static final long | serialVersionUID |
| Constructors Summary |
|---|
protected UnicastRemoteObject()Creates and exports a new UnicastRemoteObject object using an
anonymous port.
this(0);
| protected UnicastRemoteObject(int port)Creates and exports a new UnicastRemoteObject object using the
particular supplied port.
this.port = port;
exportObject((Remote) this, port);
| protected UnicastRemoteObject(int port, RMIClientSocketFactory csf, RMIServerSocketFactory ssf)Creates and exports a new UnicastRemoteObject object using the
particular supplied port and socket factories.
this.port = port;
this.csf = csf;
this.ssf = ssf;
exportObject((Remote) this, port, csf, ssf);
|
| Methods Summary |
|---|
| public java.lang.Object | clone()Returns a clone of the remote object that is distinct from
the original.
try {
UnicastRemoteObject cloned = (UnicastRemoteObject) super.clone();
cloned.reexport();
return cloned;
} catch (RemoteException e) {
throw new ServerCloneException("Clone failed", e);
}
| | private static java.rmi.Remote | exportObject(java.rmi.Remote obj, sun.rmi.server.UnicastServerRef sref)Exports the specified object using the specified server ref.
// if obj extends UnicastRemoteObject, set its ref.
if (obj instanceof UnicastRemoteObject) {
((UnicastRemoteObject) obj).ref = sref;
}
return sref.exportObject(obj, null, false);
| | public static java.rmi.server.RemoteStub | exportObject(java.rmi.Remote obj)Exports the remote object to make it available to receive incoming
calls using an anonymous port.
/*
* Use UnicastServerRef constructor passing the boolean value true
* to indicate that only a generated stub class should be used. A
* generated stub class must be used instead of a dynamic proxy
* because the return value of this method is RemoteStub which a
* dynamic proxy class cannot extend.
*/
return (RemoteStub) exportObject(obj, new UnicastServerRef(true));
| | public static java.rmi.Remote | exportObject(java.rmi.Remote obj, int port)Exports the remote object to make it available to receive incoming
calls, using the particular supplied port.
return exportObject(obj, new UnicastServerRef(port));
| | public static java.rmi.Remote | exportObject(java.rmi.Remote obj, int port, java.rmi.server.RMIClientSocketFactory csf, java.rmi.server.RMIServerSocketFactory ssf)Exports the remote object to make it available to receive incoming
calls, using a transport specified by the given socket factory.
return exportObject(obj, new UnicastServerRef2(port, csf, ssf));
| | private void | readObject(java.io.ObjectInputStream in)Re-export the remote object when it is deserialized.
in.defaultReadObject();
reexport();
| | private void | reexport()
if (csf == null && ssf == null) {
exportObject((Remote) this, port);
} else {
exportObject((Remote) this, port, csf, ssf);
}
| | public static boolean | unexportObject(java.rmi.Remote obj, boolean force)Removes the remote object, obj, from the RMI runtime. If
successful, the object can no longer accept incoming RMI calls.
If the force parameter is true, the object is forcibly unexported
even if there are pending calls to the remote object or the
remote object still has calls in progress. If the force
parameter is false, the object is only unexported if there are
no pending or in progress calls to the object.
return sun.rmi.transport.ObjectTable.unexportObject(obj, force);
|
|
