java.rmi.server Documentation Differences

This file contains all the changes in documentation in the package java.rmi.server as colored differences. Deletions are shown like this, and additions are shown like this.

If no deletions or additions are shown in an entry, the HTML tags will be what has changed. The new HTML tags are shown in the differences. If no documentation existed, and then some was added in a later version, this change is noted in the appropriate class pages of differences, but the change is not shown on this page. Only changes in existing text are shown here. Similarly, documentation which was inherited from another class or interface is not shown here.

Note that an HTML error in the new documentation may cause the display of other documentation changes to be presented incorrectly. For instance, failure to close a <code> tag will cause all subsequent paragraphs to be displayed differently.

An ExportException is a RemoteException thrown if an attempt to export a remote object fails. A remote object is exported via the constructors and exportObject methods of java.rmi.server.UnicastRemoteObject and java.rmi.activation.Activatable. @version 1.9 0210 12/0203/0001 @author Ann Wollrath @since JDK1.1 @see java.rmi.server.UnicastRemoteObject @see java.rmi.activation.Activatable

LoaderHandler is an interface used internally by the RMI runtime in previous implementation versions. It should never be accessed by application code. @version 1.13 0214 12/0203/0001 @author Ann Wollrath @since JDK1.1 @deprecated no replacement

LogStream provides a mechanism for logging errors that are of possible interest to those monitoring a system. @version 1.15 0216 12/0203/0001 @author Ann Wollrath (lots of code stolen from Ken Arnold) @since JDK1.1 @deprecated no replacement

An ObjID is used to identify a remote object exported to an RMI runtime. When a remote objectsobject is exported it is assigned an object identifier either implicitly or explicitly depending on the API used to export.

The #ObjID() constructor can be used uniquely into generate a VMunique object identifier. Such an ObjID is unique over time with respect to the host it is generated on. EachThe #ObjID(int) constructor can be used to create a "well-known" object identifier. The scope of a well-known ObjID depends on the RMI runtime it is exported to.

An ObjID instance contains an object number (of type long) and an address space identifier that(of type I a unique ObjID the address space identifier is unique with respect to a specificgiven host over time. AnIn objecta well-known ObjID the address space identifier is assignedequivalent to aone remote object when itreturned by invoking the isUID#UID(short) exportedconstructor with the value zero.

If the system property java.rmi.server.randomIDs is true then the object numberdefined to equal the string component"true" (64 bitscase insensitive) of an ObjID created withthen the no argument#ObjID() constructor will containuse a cryptographically strong random number. @versiongenerator 1.22to 04/06/00choose the object number of the returned ObjID. @author Ann Wollrath @author Peter Jones @version 1.26 01/12/03 @since JDK1.1

Generates a unique object identifier.

If the system property java.rmi.server.randomIDs is true then the object number componentdefined (64to bits)equal of anthe string ObjID"true" created with(case theinsensitive) no argumentthen this constructor will containuse a cryptographically strong random number. generator to choose the object @sincenumber of the JDK1returned ObjID.1

GeneratesCreates a "well-known" object IDidentifier.

An object IDObjID generatedcreated via this constructor will not clash with any object IDsObjIDs generated via the defaultno-arg constructor. @param num aobjNum object uniquenumber for well-known object number @since JDK1.1identifier

TwoCompares the specified object identifierswith this ObjID for equality. This method returns true are considered equalif and only if theythe specified haveobject is an ObjID instance with the same contentsobject number and address space identifier as this one. @sinceparam JDK1.1obj the object to compare this ObjID to @return true if the given object is equivalent to this one and false otherwise

Returns the hash code value for thethis object ObjIDidentifier (the object number). @sincereturn JDK1.1the hash code value for this object identifier

Constructs anand objectreturns a idnew whoseObjID contents isinstance by readunmarshalling a binary representation from thean ObjectInput instance.

Specifically this method first specifiedinvokes inputthe given stream.'s @paramObjectInput#readLong() inmethod inputto read an object number then it invokes UID#read(DataInput) with the stream to read an address space identifier and then it creates and returns a new ObjID instance that contains the object IDnumber and address space identifier that were read from the stream. @returnparam objectin the IDObjectInput instance to read ObjID from stream@return unmarshalled ObjID instance @throws IOException if an I/O error occurredoccurs @sincewhile JDK1.1performing this operation

Returns a string containing the object id representation. The address spaceof this object identifier is included. in@return thea string representation only ifof thethis object id is from a non-local address space. @since JDK1.1identifier

Marshals objecta binary representation of idthis ObjID to outputan ObjectOutput instance.

Specifically this method first invokes the given stream's ObjectOutput#writeLong(long) method with this object identifier's object number and then it writes its address space identifier by invoking its UID#write(DataOutput) method with the stream. @param out outputthe streamObjectOutput instance to write objectthis IDObjID to @throws IOException if an I/O error occurredoccurs @sincewhile JDK1.1performing this operation

object number for well-known idObjID forof the activator.

object number for well-known idObjID forof the distributed garbage collector.

object number for well-known idObjID forof the registry.

An Operation contains a description of a Java method. Operation objects were used in JDK1.1 version stubs and skeletons. The Operation class is not needed for 1.2 style stubs (stubs generated with rmic -v1.2); hence this class is deprecated. @version 1.13 0214 12/0203/0001 @since JDK1.1 @deprecated no replacement

RMIClassLoader providescomprises static methods to support dynamic class loading with RMI. Included are methods for loading classes from a network location (one or more URLs) and obtaining the location from which an existing class canshould be loaded by remote parties. These methods are used by the RMI runtime when marshalling and unmarshalling classes ofcontained in parametersthe arguments and return values of remote method calls and they also may be invoked directly by applications in order to mimic RMI's dynamic class loading behavior.

The implementation of the following static methods

• {@link #loadClass(URL String)}
• {@link #loadClass(String String)}
• {@link #loadClass(String String ClassLoader)}
• {@link #loadProxyClass(String String[] ClassLoader)}
• {@link #getClassLoader(String)}
• {@link #getClassAnnotation(Class)}

is provided by an instance of RMIClassLoaderSpi the service provider interface for those methods. When one of the methods is invoked its behavior is to delegate to a corresponding method on the service provider instance. The details of how each method delegates to the provider instance is described in the documentation for each particular method.

The service provider instance is chosen as follows:

• If the system property java.rmi.server.RMIClassLoaderSpi is defined then if its value equals the string "default" the provider instance will be the value returned by an invocation of the #getDefaultProviderInstance() method and for any other value if a class named with the value of the property can be loaded by the system class loader (see an that class is assignable to RMIClassLoaderSpi and has a public no-argument constructor then that constructor will be invoked to create the provider instance. If the property is defined but any other of those conditions are not true then an unspecified Error will be thrown to code that attempts to use RMIClassLoader indicating the failure to obtain a provider instance.
• If a resource named META-INF/services/java.rmi.server.RMIClassLoaderSpi is visible to the system class loader then the contents of that resource are interpreted as a provider-configuration file and the first class name specified in that file is used as the provider class name. If a class with that name can be loaded by the system class loader and that class is assignable to RMIClassLoaderSpi and has a public no-argument constructor then that constructor will be invoked to create the provider instance. If the resource is found but a provider cannot be instantiated as described then an unspecified Error will be thrown to code that attempts to use RMIClassLoader indicating the failure to obtain a provider instance.
• Otherwise the provider instance will be the value returned by an invocation of the #getDefaultProviderInstance() method.

@version 1.22 0234 01/0212/0003 @author Ann Wollrath @author Peter Jones @author Laird Dornin @see RMIClassLoaderSpi @since JDK1.1

Returns the class annotation string (representing thea location for athe class definition) that RMI will use to annotate the call streamclass descriptor when marshalling objects of the given class.

This method delegates to the RMIClassLoaderSpi#getClassAnnotation(Class) method of the provider instance passing cl as the argument. @param cl the class to obtain the annotation for @return a string to be used to annotate the given class when it gets marshalled or null @since 1.2

Returns a class loader that loads classes from the given codebase URL path.

The class loader returned is the class loader that the #loadClass(String String) method would use to load classes fromfor the givensame codebase argument. If

This a class loadermethod delegates to withthe RMIClassLoaderSpi#getClassLoader(String) method of the sameprovider instance passing codebase URL pathas the alreadyargument. exists

If forthere is a security manger RMIits runtimecheckPermission itmethod will be returned;invoked otherwisewith a newRuntimePermission("getClassLoader") classpermission; loader will bethis could result createdin a SecurityException. If the given codebase isThe provider implementation of this nullmethod may also perform itfurther returnssecurity checks to verify that the classcalling loadercontext has usedpermission to loadconnect classesto all viaof the #loadClass(String)URLs methodin the codebase URL path. @param codebase the list of URLs (space-separated) URLsfrom which the thereturned class loader will load classes from or null @return a class loader that loads classes from the given codebase URL path @exceptionthrows MalformedURLException if the codebase paramateris non-null and contains an invalid non-URL or if codebase is null and the system property java.rmi.server.codebase contains an invalid URL @exceptionthrows SecurityException if there is a security manager and the invocation of its checkPermission method fails or if the caller does not have permission to connect to all of the URLs in the codebase URL path @since 1.3

Returns the security context of the given class loader. @param loader a class loader from which to get the security context @return the security context @since JDK1.1 @deprecated no replacement. As of the Java 2 platform v1.2 RMI no longer uses this method to obtain a class loader's security context. @see java.lang.SecurityManager#getSecurityContext()

Loads a class from the codebase URL path specified by the java.rmi.server.codebase property.

This method delegates to String) passing null as the first argument and name as the second argument. @param name the name of the class to load @return the Class object representing the loaded class @exceptionthrows MalformedURLException if the system property java.rmi.server.codebase contains an invalid URL @exceptionthrows ClassNotFoundException if a definition for the class could not be found at the codebase location @since JDK1.1 @deprecated replaced by loadClass(String String) method @see #loadClass(String String)

Loads a class from a codebase URL path. If the given codebase is null then the value of the system property Classjava.rmi.server.codebase object returnedis used isas the URL path. equivalent

This method delegates to the Strin ClassLoader)} method of the provider instance passing Classcodebase objectas returned bythe first argument RMIClassLoader.loadClass(name) as the second argument and null as the third argument. @param codebase the list of space-URLs (separated URLsby spaces) to load the class from or null @param name the name of the class to load @return the Class object representing the loaded class @exceptionthrows MalformedURLException if the codebase paramateris non-null and contains an invalid non-URL or if codebase is null and the system property java.rmi.server.codebase contains an invalid URL @exceptionthrows ClassNotFoundException if a definition for the class could not be found at the specified location @since 1.2

An RMIClientSocketFactory instance is used by the RMI runtime in order to obtain client sockets for RMI calls. A remote object can be associated with an RMIClientSocketFactory when it is created/exported via the constructors or exportObject methods of java.rmi.server.UnicastRemoteObject and java.rmi.activation.Activatable .

An RMIClientSocketFactory instance associated with a remote object will be downloaded to clients when the remote object's reference is transmitted in an RMI call. This RMIClientSocketFactory will be used to create connections to the remote object for remote method calls.

An RMIClientSocketFactory instance can also be associated with a remote object registry so that clients can use custom socket communication with a remote object registry.

An implementation of this interface should be serializable and should implement Object#equals to return true when passed an instance that represents the same (functionally equivalent) client socket factory and false otherwise (and it should also implement Object#hashCode consistently with its Object.equals implementation). @version 1.7 029 12/0203/0001 @author Ann Wollrath @author Peter Jones @since 1.2 @see java.rmi.server.UnicastRemoteObject @see java.rmi.activation.Activatable @see java.rmi.registry.LocateRegistry

An RMIFailureHandler can be registered via the RMISocketFactory.setFailureHandler call. The failure method of the handler is invoked when the RMI runtime is unable to create a ServerSocket to listen for incoming calls. The failure method returns a boolean indicating whether the runtime should attempt to re-create the ServerSocket. @author Ann Wollrath @version @(#)RMIFailureHandler.java 1.8 009 01/0212/0203 @since JDK1.1

An RMIServerSocketFactory instance is used by the RMI runtime in order to obtain server sockets for RMI calls. A remote object can be associated with an RMIServerSocketFactory when it is created/exported via the constructors or exportObject methods of java.rmi.server.UnicastRemoteObject and java.rmi.activation.Activatable .

An RMIServerSocketFactory instance associated with a remote object is used to obtain the ServerSocket used to accept incoming calls from clients.

An RMIServerSocketFactory instance can also be associated with a remote object registry so that clients can use custom socket communication with a remote object registry.

An implementation of this interface should implement Object#equals to return true when passed an instance that represents the same (functionally equivalent) server socket factory and false otherwise (and it should also implement Object#hashCode consistently with its Object.equals implementation). @version 1.7 029 12/0203/0001 @author Ann Wollrath @author Peter Jones @since 1.2 @see java.rmi.server.UnicastRemoteObject @see java.rmi.activation.Activatable @see java.rmi.registry.LocateRegistry

An RMISocketFactory instance is used by the RMI runtime in order to obtain client and server sockets for RMI calls. An application may use the setSocketFactory method to request that the RMI runtime use its socket factory instance instead of the default implementation.

The default socket factory implementation used goes through a three-tiered approach to creating client sockets. First a direct socket connection to the remote VM is attempted. If that fails (due to a firewall) the runtime uses HTTP with the explicit port number of the server. If the firewall does not allow this type of communication then HTTP to a cgi-bin script on the server is used to POST the RMI call.

@version 1.16 0217 12/0203/0001 @author Ann Wollrath @author Peter Jones @since JDK1.1

RemoteCall is an abstraction used solely by the RMI runtime (in conjunction with stubs and skeletons of remote objects) to carry out a call to a remote object. The RemoteCall interface is deprecated in the Java 2 platform since it is only used by deprecated methods of java.rmi.server.RemoteRef. @version 1.15 0216 12/0203/0001 @since JDK1.1 @author Ann Wollrath @author Roger Riggs @see java.rmi.server.RemoteRef @deprecated no replacement.

The 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. @versionauthor 1.22Ann 02/02/00Wollrath @author AnnLaird WollrathDornin @author Peter Jones @version 1.25 01/12/03 @since JDK1.1

Creates a remote object. @since JDK1.1

Creates a remote object initialized with the specified remote reference. @param newref remote reference @since JDK1.1

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. @param obj the Object to compare with @return true if these Objects are equal; false otherwise. @see java.util.Hashtable @since JDK1.1

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). @see java.util.Hashtable @since JDK1.1

Returns a String that represents the value of this remote object. @since JDK1.1

the object's remote reference.

RemoteRef represents the handle for a remote object. A RemoteStub uses a remote reference to carry out a remote method invocation to a remote object. @version 1.18 0219 12/0203/0001 @author Ann Wollrath @since JDK1.1 @see java.rmi.server.RemoteStub

The RemoteServer class is the common superclass to server implementations and provides the framework to support a wide range of remote reference semantics. Specifically the functions needed to create and export remote objects (i.e. to make them remotely available) are provided abstractly by RemoteServer and concretely by its subclass(es). @version 1.22 0228 12/0203/0001 @author Ann Wollrath @since JDK1.1

ReturnReturns thea string hostnamerepresentation of the current client. When called from ahost for the remote threadmethod invocation actively handling a remote methodbeing processed in the current invocationthread. the@return a hostnamestring representation of the client is returned.host @exceptionthrows ServerNotActiveException Ifif called outside of servicing a remote methodno remote method invocation is being processed invocation.in @returnthe client hostnamecurrent thread @since JDK1.1

The RemoteStub class is the common superclass to client stubs and provides the framework to support a wide range of remote reference semantics. Stub objects are surrogates that support exactly the same set of remote interfaces defined by the actual implementation of the remote object. @version 1.17 0218 12/0203/0001 @author Ann Wollrath @since JDK1.1

A ServerCloneException is thrown if a remote exception occurs during the cloning of a UnicastRemoteObject.

As of release 1.4 this exception has been retrofitted to conform to the general purpose exception-chaining mechanism. The "nested exception" that may be provided at construction time and accessed via the public #detail field is now known as the cause and may be accessed via the Throwable#getCause() method as well as the aforementioned "legacy field." @version 1.15 0217 12/0203/0001 @author Ann Wollrath @since JDK1.1 @see java.rmi.server.UnicastRemoteObject#clone()

ObtainsReturns the detail message includeincluding the message from the nested exception if there is one. @return the detail message including nested exception message if any

Nested exception for ServerCloneException.

This field predates the general-purpose exception chaining facility. The Throwable#getCause() method is now the preferred means of obtaining this information. @serial @since JDK1.1

An ServerNotActiveException is an Exception thrown during a call to RemoteServer.getClientHost if the getClientHost method is called outside of servicing a remote method call. @version 1.10 0211 12/0203/0001 @author Roger Riggs @since JDK1.1 @see java.rmi.server.RemoteServer#getClientHost()

A ServerRef represents the server-side handle for a remote object implementation. @version 1.13 0214 12/0203/0001 @author Ann Wollrath @since JDK1.1

The Skeleton interface is used solely by the RMI implementation.

Every version 1.1 (and version 1.1 compatible skeletons generated in 1.2 using rmic -vcompat) skeleton class generated by the rmic stub compiler implements this interface. A skeleton for a remote object is a server-side entity that dispatches calls to the actual remote object implementation. @version 1.15 0216 12/0203/0001 @author Ann Wollrath @since JDK1.1 @deprecated no replacement. Skeletons are no longer required for remote method calls in the Java 2 platform v1.2 and greater.

This exception is thrown when a call is received that does not match the available skeleton. It indicates either that the remote method names or signatures in this interface have changed or that the stub class used to make the call and the skeleton receiving the call were not generated by the same version of the stub compiler (rmic). @version 1.11 0212 12/0203/0001 @author Roger Riggs @since JDK1.1 @deprecated no replacement. Skeletons are no longer required for remote method calls in the Java 2 platform v1.2 and greater.

A SkeletonNotFoundException is thrown if the Skeleton corresponding to the remote object being exported is not found. Skeletons are not required in the Java 2 platform so this exception is never thrown if stubs are generated with rmic -v1.2. To generate stubs and skeletons compatible with JDK1.1 and the Java 2 SDK use rmic -vcompat which is the default in the Java 2 SDK. @version 1.11 0212 12/0203/0001 @since JDK1.1 @deprecated no replacement. Skeletons are no longer required for remote method calls in the Java 2 platform v1.2 and greater.

A SocketSecurityException is thrown during remote object export if the code exporting the remote object (either by construction or by explicit call to the exportObject method of UnicastRemoteObject or java.rmi.activation.Activatable) does not have permission to create a java.net.ServerSocket on the port number specified during remote object export. @version 1.9 0210 12/0203/0001 @author Ann Wollrath @since JDK1.1 @see java.rmi.server.UnicastRemoteObject @see java.rmi.activation.Activatable

AbstractionA forUID creatingrepresents identifiersan identifier that areis unique over time with respect to the host it is generated on or one of 2¹⁶ "well-known" identifiers.

The #UID() constructor can be used to generate an identifier that is unique over time with respect to the host it is generated on. The #UID(short) constructor can be used to create one of 2¹⁶ well-known identifiers.

A UID instance contains three primitive values:

• unique an int that uniquely identifies the VM that this UID was generated in with respect to its host and at the time represented by the time value (an example implementation of the unique value would be a process identifier) or zero for a well-known UID
• time a long equal to a time (as returned by a which the VM that this UID was generated in was alive or zero for a well-known UID
• count a short to distinguish UIDs generated in the same VM with the same time value

An independently generated UID instance is unique over time with respect to the host it is generated. @versionon 1as long as the host requires more than one millisecond to reboot and its system clock is never set backward.13 02/02/00A globally unique identifier can be constructed by pairing a UID instance with a unique host identifier such as an IP address. @author Ann Wollrath @author Peter Jones @version 1.19 01/12/03 @since JDK1.1

CreatesGenerates a pure identifierUID that is unique over time with respect to the host on whichthat it iswas generated. This UID is unique under the following conditions: a) the machine takes more than one second to reboot and b) the machine's clock is never set backward. In order to construct a UID that is globally unique simply pair a UID with an InetAddress. @since JDK1on.1

Creates a "well-known" IDUID. There are 2^¹⁶ -1possible such possible well-known ids. An

A idUID generatedcreated via this constructor will not clash with any idUIDs generated via the default UIDno-arg constructor which will generates a genuinely unique identifier with respect to this host. @param num well known ID number @sincefor JDK1.1well-known UID

Compares twothe specified object with this UIDs for content equality. This method returns true if and only if the specified object is a UID instance with the same unique time and count values as this one. @param obj the Objectobject to compare withthis UID to @return true if these Objects arethe given object equal;is falseequivalent otherwise.to @seethis java.util.Hashtableone @sinceand JDK1.1false otherwise

Returns a hashcode for thethe hash code value UID.for Twothis UIDs will have the same hashcode if they are equal with respect to their content. @return the hashcodehash @seecode java.util.Hashtablevalue @sincefor JDK1.1this UID

ReadsConstructs theand returns a new UID instance by unmarshalling a binary representation from thean inputDataInput streaminstance. @param

Specifically inthis method first invokes the inputgiven stream's @returnDataInput#readInt() themethod to read a UIDunique @exceptionvalue IOException ifthen it uidinvoke's couldthe stream's DataInput#readLong() not bemethod to read a time value then it invoke's the stream's DataInput#readShort(due) method to read a count value and then it creates and returns a new UID instance that contains the unique time and count values that were read from the stream. @param failurein the DataInput instance or malformedto read UID) from @sincereturn JDK1.1unmarshalled UID instance @throws IOException if an I/O error occurs while performing this operation

Returns thea string representation of thethis UID. @sincereturn JDK1.1a string representation of this UID

WriteMarshals thea binary representation of this UID to output streama outDataOutput instance. @param

Specifically outthis method first invokes the outputgiven stream's toDataOutput#writeInt(int) whichmethod thewith this UID is's writtenunique @exceptionvalue IOException if writingthen it invokes the stream's DataOutput#writeLong(long) method with this UID's totime value and then it invokes the stream's DataOutput#writeShort(int) method with failsthis UID's count value. @sinceparam JDK1.1out the DataOutput instance to write this UID to @throws IOException if an I/O error occurs while performing this operation

The UnicastRemoteObject class defines a non-replicated remote object whose references are valid only while the server process is alive. The UnicastRemoteObject class provides support for point-to-point active object references (invocations parameters and results) using TCP streams.

Objects that require remote behavior should extend RemoteObject typically via UnicastRemoteObject. If UnicastRemoteObject is not extended the implementation class must then assume the responsibility for the correct semantics of the hashCode equals and toString methods inherited from the Object class so that they behave appropriately for remote objects. @version 1.26 0229 12/0203/0001 @author Ann Wollrath @author Peter Jones @since JDK1.1 @see RemoteServer @see RemoteObject

CreateCreates and exportexports a new UnicastRemoteObject object using an anonymous port. @throws RemoteException if failed to export object @since JDK1.1

CreateCreates and exportexports a new UnicastRemoteObject object using the particular supplied port. @param port the port number on which the remote object receives calls (if port is zero an anonymous port is chosen) @throws RemoteException if failed to export object @since 1.2

CreateCreates and exportexports a new UnicastRemoteObject object using the particular supplied port and socket factories. @param port the port number on which the remote object receives calls (if port is zero an anonymous port is chosen) @param csf the client-side socket factory for making calls to the remote object @param ssf the server-side socket factory for receiving remote calls @throws RemoteException if failed to export object @since 1.2

ExportExports the remote object to make it available to receive incoming calls using an anonymous port. @param obj the remote object to be exported @return remote object stub @exception RemoteException if export fails @since JDK1.1

ExportExports the remote object to make it available to receive incoming calls using the particular supplied port. @param obj the remote object to be exported @param port the port to export the object on @return remote object stub @exception RemoteException if export fails @since 1.2

ExportExports the remote object to make it available to receive incoming calls using a transport specified by the given socket factory. @param obj the remote object to be exported @param port the port to export the object on @param csf the client-side socket factory for making calls to the remote object @param ssf the server-side socket factory for receiving remote calls @return remote object stub @exception RemoteException if export fails @since 1.2

RemoveRemoves 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. @param obj the remote object to be unexported @param force if true unexports the object even if there are pending or in-progress calls; if false only unexports the object if there are no pending or in-progress calls @return true if operation is successful false otherwise @exception NoSuchObjectException if the remote object is not currently exported @since 1.2

A remote object implementation should implement the Unreferenced interface to receive notification when there are no more clients that reference that remote object. @version 1.9 0210 12/0203/0001 @author Ann Wollrath @author Roger Riggs @since JDK1.1