|
|
Start of Tutorial > Start of Trail > Start of Lesson |
Search
Feedback Form |
Let's turn now to the task of implementing a class for the compute engine. In general the implementation class of a remote interface should at least
- Declare the remote interfaces being implemented
- Define the constructor for the remote object
- Provide an implementation for each remote method in the remote interfaces
The server needs to create and to install the remote objects. This setup procedure can be encapsulated in a
mainmethod in the remote object implementation class itself, or it can be included in another class entirely. The setup procedure should
- Create and install a security manager
- Create one or more instances of a remote object
- Register at least one of the remote objects with the RMI remote object registry (or another naming service such as one that uses JNDI), for bootstrapping purposes
The complete implementation of the compute engine follows. The
engine.ComputeEngineclass implements the remote interface
Computeand also includes themainmethod for setting up the compute engine.package engine; import java.rmi.*; import java.rmi.server.*; import compute.*; public class ComputeEngine extends UnicastRemoteObject implements Compute { public ComputeEngine() throws RemoteException { super(); } public Object executeTask(Task t) { return t.execute(); } public static void main(String[] args) { if (System.getSecurityManager() == null) { System.setSecurityManager(new RMISecurityManager()); } String name = "//host/Compute"; try { Compute engine = new ComputeEngine(); Naming.rebind(name, engine); System.out.println("ComputeEngine bound"); } catch (Exception e) { System.err.println("ComputeEngine exception: " + e.getMessage()); e.printStackTrace(); } } }Now let's take a closer look at each of the components of the compute engine implementation.
The implementation class for the compute engine is declared aspublic class ComputeEngine extends UnicastRemoteObject implements ComputeThis declaration states that the class implements the
Computeremote interface (and therefore defines a remote object) and extends the classjava.rmi.server.UnicastRemoteObject.
UnicastRemoteObjectis a convenience class, defined in the RMI public API, that can be used as a superclass for remote object implementations. The superclassUnicastRemoteObjectsupplies implementations for a number ofjava.lang.Objectmethods (equals,hashCode,toString) so that they are defined appropriately for remote objects. UnicastRemoteObjectalso includes constructors and static methods used to export a remote object, that is, make the remote object available to receive incoming calls from clients.A remote object implementation does not have to extend
UnicastRemoteObject, but any implementation that does not must supply appropriate implementations of thejava.lang.Objectmethods. Furthermore, a remote object implementation must make an explicit call to one ofUnicastRemoteObject'sexportObjectmethods to make the RMI runtime aware of the remote object so that the object can accept incoming calls. By extendingUnicastRemoteObject, theComputeEngineclass can be used to create a simple remote object that supports unicast (point-to-point) remote communication and that uses RMI's default sockets-based transport for communication.If you choose to extend a remote object from any class other than
Unicast-RemoteObjector, alternatively, extend from the new JDK 1.2 classjava.rmi.activation.Activatable(used to construct remote objects that can execute on demand), you need to export the remote object by calling either theUnicastRemoteObject.exportObjectorActivatable.exportObjectmethod explicitly from your class's constructor (or another initialization method, as appropriate).The compute engine example defines a remote object class that implements only a single remote interface and no other interfaces. The
ComputeEngineclass also contains some methods that can be called only locally. The first of these is a constructor forComputeEngineobjects; the second is amainmethod that is used to create aComputeEngineand make it available to clients.
TheComputeEngineclass has a single constructor that takes no arguments. The code for the constructor isThis constructor simply calls the superclass constructor, which is the no-argument constructor of thepublic ComputeEngine() throws RemoteException { super(); }UnicastRemoteObjectclass. Although the superclass constructor gets called even if omitted from theComputeEngineconstructor, we include it for clarity.During construction, a
UnicastRemoteObjectis exported, meaning that it is available to accept incoming requests by listening for incoming calls from clients on an anonymous port.
Note: In JDK 1.2 you may indicate the specific port that a remote object uses to accept requests.The no-argument constructor for the superclass,
UnicastRemoteObject, declares the exceptionRemoteExceptionin itsthrowsclause, so theCompute-Engineconstructor must also declare that it can throwRemoteException. ARemoteExceptioncan occur during construction if the attempt to export the object fails--due to, for example, communication resources being unavailable or the appropriate stub class not being found.
The class for a remote object provides implementations for each of the remote methods specified in the remote interfaces. TheComputeinterface contains a single remote method,executeTask, which is implemented as follows:public Object executeTask(Task t) { return t.execute(); }This method implements the protocol between the
ComputeEngineand its clients. Clients provide theComputeEnginewith aTaskobject, which has an implementation of the task'sexecutemethod. TheComputeEngineexecutes theTaskand returns the result of the task'sexecutemethod directly to the caller.The
executeTaskmethod does not need to know anything more about the result of theexecutemethod than that it is at least anObject. The caller presumably knows more about the precise type of theObjectreturned and can cast the result to the appropriate type.Passing Objects in RMI
Arguments to or return values from remote methods can be of almost any type, including local objects, remote objects, and primitive types. More precisely, any entity of any type can be passed to or from a remote method as long as the entity is an instance of a type that is a primitive data type, a remote object, or a serializable object, which means that it implements the interfacejava.io.Serializable.A few object types do not meet any of these criteria and thus cannot be passed to or returned from a remote method. Most of these objects, such as a file descriptor, encapsulate information that makes sense only within a single address space. Many of the core classes, including those in the packages
java.langandjava.util, implement theSerializableinterface.The rules governing how arguments and return values are passed are as follows.
- Remote objects are essentially passed by reference. A remote object reference is a stub, which is a client-side proxy that implements the complete set of remote interfaces that the remote object implements.
- Local objects are passed by copy, using object serialization. By default all fields are copied, except those that are marked
staticortransient. Default serialization behavior can be overridden on a class-by-class basis.Passing an object by reference (as is done with remote objects) means that any changes made to the state of the object by remote method calls are reflected in the original remote object. When passing a remote object, only those interfaces that are remote interfaces are available to the receiver; any methods defined in the implementation class or defined in nonremote interfaces implemented by the class are not available to that receiver.
For example, if you were to pass a reference to an instance of the
ComputeEngineclass, the receiver would have access only to the compute engine'sexecuteTaskmethod. That receiver would not see either theComputeEngineconstructor or itsmainmethod or any of the methods injava.lang.Object.In remote method calls objects--parameters, return values, and exceptions--that are not remote objects are passed by value. This means that a copy of the object is created in the receiving virtual machine. Any changes to this object's state at the receiver are reflected only in the receiver's copy, not in the original instance.
The most involved method of theComputeEngineimplementation is themainmethod. Themainmethod is used to start theComputeEngineand therefore needs to do the necessary initialization and housekeeping to prepare the server for accepting calls from clients. This method is not a remote method, which means that it cannot be called from a different virtual machine. Since themainmethod is declaredstatic, the method is not associated with an object at all but rather with the classComputeEngine.
The first thing that themainmethod does is to create and to install a security manager, which protects access to system resources from untrusted downloaded code running within the virtual machine. The security manager determines whether downloaded code has access to the local file system or can perform any other privileged operations.All programs using RMI must install a security manager, or RMI will not download classes (other than from the local class path) for objects received as parameters, return values, or exceptions in remote method calls. This restriction ensures that the operations performed by downloaded code go through a set of security checks.
The
ComputeEngineuses a security manager supplied as part of the RMI system, theRMISecurityManager. This security manager enforces a similar security policy as the typical security manager for applets; that is to say, it is very conservative as to what access it allows. An RMI application could define and use anotherSecurityManagerclass that gave more liberal access to system resources or, in JDK 1.2, use a policy file that grants more permissions.Here's the code that creates and installs the security manager:
if (System.getSecurityManager() == null) { System.setSecurityManager(new RMISecurityManager()); }
Next, themainmethod creates an instance of theComputeEngine. This is done with the statementCompute engine = new ComputeEngine();As mentioned, this constructor calls the
UnicastRemoteObjectsuperclass constructor, which in turn exports the newly created object to the RMI runtime. Once the export step is complete, theComputeEngineremote object is ready to accept incoming calls from clients on an anonymous port, one chosen by RMI or the underlying operating system. Note that the type of the variableengineisCompute, notComputeEngine. This declaration emphasizes that the interface available to clients is theComputeinterface and its methods, not theCompute-Engineclass and its methods.Before a caller can invoke a method on a remote object, that caller must first obtain a reference to the remote object. This can be done in the same way that any other object reference is obtained in a program, such as getting it as part of the return value of a method or as part of a data structure that contains such a reference.
The system provides a particular remote object, the RMI registry, for finding references to remote objects. The RMI registry is a simple remote object name service that allows remote clients to get a reference to a remote object by name. The registry is typically used only to locate the first remote object an RMI client needs to use. That first remote object then provides support for finding other objects.
The
java.rmi.Naminginterface is used as a front-end API for binding, or registering, and looking up remote objects in the registry. Once a remote object is registered with the RMI registry on the local host, callers on any host can look up the remote object by name, obtain its reference, and then invoke remote methods on the object. The registry may be shared by all servers running on a host, or an individual server process may create and use its own registry, if desired.The
ComputeEngineclass creates a name for the object with the statementString name = "//host/Compute";This name includes the host name,
host, on which the registry (and remote object) is being run and a name,Compute, that identifies the remote object in the registry. The code then needs to add the name to the RMI registry running on the server. This is done later (within thetryblock) with the statementNaming.rebind(name, engine);Calling the
rebindmethod makes a remote call to the RMI registry on the local host. This call can result in aRemoteExceptionbeing generated, so the exception needs to be handled. TheComputeEngineclass handles the exception within thetry/catchblock. If the exception is not handled in this way,RemoteExceptionwould have to be added to thethrowsclause (currently nonexistent) of themainmethod.Note the following about the arguments to the call to
Naming.rebind.
- The first parameter is a URL-formatted
java.lang.Stringrepresenting the location and the name of the remote object. You will need to change the value ofhostto be the name, or IP address, of your server machine. If the host is omitted from the URL, the host defaults to the local host. Also, you don't need to specify a protocol in the URL. For example, supplyingComputeas the name in theNaming.rebindcall is allowed. Optionally a port number may be supplied in the URL; for example, the name//host:1234/objectnameis legal. If the port is omitted, it defaults to 1099. You must specify the port number only if a server creates a registry on a port other than the default 1099. The default port is useful in that it provides a well-known place to look for the remote objects that offer services on a particular host.- The RMI runtime substitutes a reference to the stub for the remote object reference specified by the argument. Remote implementation objects, such as instances of
ComputeEngine,never leave the VM where they are created, so when a client performs a lookup in a server's remote object registry, a reference to the stub is returned. As discussed earlier, remote objects in such cases are passed by reference rather than by value.- Note that for security reasons, an application can
bind,unbind, orrebindremote object references only with a registry running on the same host. This restriction prevents a remote client from removing or overwriting any of the entries in a server's registry. Alookup, however, can be requested from any host, local or remote.Once the server has registered with the local RMI registry, it prints out a message indicating that it's ready to start handling calls and then the
mainmethod exits. It is not necessary to have a thread wait to keep the server alive. As long as there is a reference to theComputeEngineobject in another virtual machine, local or remote, theComputeEngineobject will not be shut down, or garbage collected. Because the program binds a reference to theComputeEnginein the registry, it is reachable from a remote client, the registry itself! The RMI system takes care of keeping theComputeEngine's process up. TheComputeEngineis available to accept calls and won't be reclaimed until its binding is removed from the registry, and no remote clients hold a remote reference to theComputeEngineobject.The final piece of code in the
ComputeEngine.mainmethod deals with handling any exception that might arise. The only exception that could be thrown in the code is aRemoteException, thrown either by the constructor of theComputeEngineclass or by the call to the RMI registry to bind the object to the nameCompute. In either case the program can't do much more than exit after printing an error message. In some distributed applications it is possible to recover from the failure to make a remote call. For example, the application could choose another server and continue operation.
|
|
Start of Tutorial > Start of Trail > Start of Lesson |
Search
Feedback Form |
Copyright 1995-2004 Sun Microsystems, Inc. All rights reserved.