FileDocCategorySizeDatePackage
PortableRemoteObject.javaAPI DocJava SE 5 API9161Fri Aug 26 14:57:46 BST 2005javax.rmi

PortableRemoteObject

public class PortableRemoteObject extends Object
Server implementation objects may either inherit from javax.rmi.PortableRemoteObject or they may implement a remote interface and then use the exportObject method to register themselves as a server object. The toStub method takes a server implementation and returns a stub that can be used to access that server object. The connect method makes a Remote object ready for remote communication. The unexportObject method is used to deregister a server object, allowing it to become available for garbage collection. The narrow method takes an object reference or abstract interface type and attempts to narrow it to conform to the given interface. If the operation is successful the result will be an object of the specified type, otherwise an exception will be thrown.

Fields Summary
private static javax.rmi.CORBA.PortableRemoteObjectDelegate
proDelegate
private static final String
PortableRemoteObjectClassKey
private static final String
defaultPortableRemoteObjectImplName
Constructors Summary
protected PortableRemoteObject()
Initializes the object by calling exportObject(this).

exception
RemoteException if export fails.


     
        proDelegate = (javax.rmi.CORBA.PortableRemoteObjectDelegate)
            createDelegateIfSpecified(PortableRemoteObjectClassKey);
    
	if (proDelegate != null) {
            PortableRemoteObject.exportObject((Remote)this);
	}
Methods Summary
public static voidconnect(java.rmi.Remote target, java.rmi.Remote source)
Makes a Remote object ready for remote communication. This normally happens implicitly when the object is sent or received as an argument on a remote method call, but in some circumstances it is useful to perform this action by making an explicit call. See the {@link Stub#connect} method for more information.

param
target the object to connect.
param
source a previously connected object.
throws
RemoteException if source is not connected or if target is already connected to a different ORB than source.

    
	if (proDelegate != null) {
	    proDelegate.connect(target, source);
	}
private static java.lang.ObjectcreateDelegateIfSpecified(java.lang.String classKey)

        String className = (String)
            AccessController.doPrivileged(new GetPropertyAction(classKey));
        if (className == null) {
            Properties props = getORBPropertiesFile();
            if (props != null) {
                className = props.getProperty(classKey);
            } 
        }
	if (className == null) {
		className = defaultPortableRemoteObjectImplName;
	}

        try {
            return (Object) loadDelegateClass(className).newInstance();
        } catch (ClassNotFoundException ex) {
	    INITIALIZE exc = new INITIALIZE( "Cannot instantiate " + className);
	    exc.initCause( ex ) ;
	    throw exc ;
        } catch (Exception ex) {
	    INITIALIZE exc = new INITIALIZE( "Error while instantiating" + className);
	    exc.initCause( ex ) ;
	    throw exc ;
        }
public static voidexportObject(java.rmi.Remote obj)
Makes a server object ready to receive remote calls. Note that subclasses of PortableRemoteObject do not need to call this method, as it is called by the constructor.

param
obj the server object to export.
exception
RemoteException if export fails.


	// Let the delegate do everything, including error handling.
	if (proDelegate != null) {
	    proDelegate.exportObject(obj);
	}
private static java.util.PropertiesgetORBPropertiesFile()
Load the orb.properties file.

        return (Properties) AccessController.doPrivileged(new GetORBPropertiesFileAction());
private static java.lang.ClassloadDelegateClass(java.lang.String className)

	try {
	    ClassLoader loader = Thread.currentThread().getContextClassLoader();
	    return Class.forName(className, false, loader);
	} catch (ClassNotFoundException e) {
	    // ignore, then try RMIClassLoader
	}

	try {
	    return RMIClassLoader.loadClass(className);
	} catch (MalformedURLException e) {
	    String msg = "Could not load " + className + ": " + e.toString();
	    ClassNotFoundException exc = new ClassNotFoundException( msg ) ; 
	    throw exc ;
	}
public static java.lang.Objectnarrow(java.lang.Object narrowFrom, java.lang.Class narrowTo)
Checks to ensure that an object of a remote or abstract interface type can be cast to a desired type.

param
narrowFrom the object to check.
param
narrowTo the desired type.
return
an object which can be cast to the desired type.
throws
ClassCastException if narrowFrom cannot be cast to narrowTo.


	if (proDelegate != null) {
	    return proDelegate.narrow(narrowFrom, narrowTo);
	}
	return null;
public static java.rmi.RemotetoStub(java.rmi.Remote obj)
Returns a stub for the given server object.

param
obj the server object for which a stub is required. Must either be a subclass of PortableRemoteObject or have been previously the target of a call to {@link #exportObject}.
return
the most derived stub for the object.
exception
NoSuchObjectException if a stub cannot be located for the given server object.

       
	if (proDelegate != null) {
	    return proDelegate.toStub(obj);
	}
	return null;
public static voidunexportObject(java.rmi.Remote obj)
Deregisters a server object from the runtime, allowing the object to become available for garbage collection.

param
obj the object to unexport.
exception
NoSuchObjectException if the remote object is not currently exported.

	    
	if (proDelegate != null) {
	    proDelegate.unexportObject(obj);
	}