RemoteRequest.java

 1 
 2  
 3   import java.rmi.*;
 4 
 5   public interface RemoteRequest extends Remote
 6   {
 7      public void display(String theString) throws RemoteException;
 8   }
 9   
10 

The remote interface declaration declares the remote methods of the remote object. In this case we have only one remote method. This is in a file called RemoteRequest.java. Note that it uses the java.rmi.*; package.

Notes:

RequestServer.java

 1 
 2   import java.rmi.*;
 3   import java.rmi.server.*;
 4   import java.rmi.registry.*;
 5 
 6   public class RequestServer extends UnicastRemoteObject implements RemoteRequest
 7   {
 8     public RequestServer() throws RemoteException
 9     {
10        super();	
11     }
12     
13     public void display(String theString) throws RemoteException
14     {
15         // implementation of the display method here...
16         System.out.println("Received: "+theString);
17     }
18     
19     public static void main(String args[])
20     {
21       try {
22         LocateRegistry.createRegistry(1099);
23         RequestServer obj = new RequestServer();
24         Naming.rebind("rmi://127.0.0.1/Request", obj);  //for localhost
25         System.out.println("Request bound in registry");
26       }
27       catch (Exception e)
28       {
29         System.out.println("Failed to bind in registry: "+e.getMessage());
30       }
31     }
32   }
33   
34 

This is the server part of the system. Note that we have to import the packages java.rmi.*, java.rmi.server.* and java.rmi.registry.*

It extends the UnicastRemoteObject object which basically allows the Request class to be exported and so usable outside the Virtual Machine where it was created. The constructor calls the constructor of the UnicastRemoteObject class and that is it. This class also provides the implementation for the display() method that was defined in the RemoteRequest interface (that we just defined).

The methods needed to create remote objects and export them (make them available to remote clients) are provided by the class UnicastRemoteObject. The java.rmi.server.UnicastRemoteObject class defines a singleton ^[13] (unicast) remote object whose references are valid only while the server process is alive.

The main() method creates a registry on port 1099 (this is the default port for the registry services) and binds a new instance of the Request object (obj) to it. So, the createRegistry(int port) method creates and exports a registry on a local host that accepts requests on a specified port (It creates a static Registry, i.e. The registry.). Placing an object in a registry makes it available to clients on other virtual machines, once those clients have access to the machine, they can obtain a reference to the remote object by specifying the machine name, port number and the name of the exported object.

RMIClient.java

 1 
 2   import java.rmi.*;
 3   import java.net.*;
 4 
 5   public class RMIClient
 6   {
 7     RemoteRequest aRequest;
 8     
 9     public void goRequest()
10     {
11       try
12       {
13         aRequest = (RemoteRequest) 
14              Naming.lookup("rmi://127.0.0.1/Request"); // for localhost
15         aRequest.display("Test");
16       }
17       catch(MalformedURLException e)
18       {
19         System.out.println("MalformedURLException");
20       }
21       catch(AccessException e)
22       {
23         System.out.println("AccessException");
24       }
25       catch(RemoteException e)
26       {
27         System.out.println("RemoteException");
28       }
29       catch(NotBoundException e)
30       {
31         System.out.println("NotBoundException");
32       }
33     }
34 	
35 	public static void main(String args[])
36 	{
37 	  RMIClient aClient = new RMIClient();
38 	  aClient.goRequest();
39 	}
40   }
41 

The RMIClient object exists on client machine. Note that the RMIClient class is compiled with the RemoteRequest interface.

The main() method creates an instance of RMIClient and calls the goRequest() method. In this method, we call the Naming.lookup() method. The java.rmi.Naming class provides Uniform Resource Locator (URL) based methods to look up, bind, rebind, unbind, and list the name-object pairings maintained on a particular host and port. This method retrieves a reference to the object, specified by the URL reference (This object is described by Remote, the parent of RemoteRequest, the interface that we created) that must be cast convereted back to a RemoteRequest object. As no port number is specified, it is assumed that the port number is 1099 on the machine 127.0.0.1 (you can use any IP address if required). The next line calls the display() method on the remote object created on the remote system. The remainder of the code attempts to catch any exceptions that can occur.

An argument to, or a return value from, a remote object can be any object that is serializable. This includes primitive types, remote objects, and non-remote objects that implement the java.io.Serializable interface. So, when a non-remote object is passed as an argument or return value in a remote method invocation, the content of the non-remote object is copied before invoking the call on the remote object. When a non-remote object is returned from a remote method invocation, a new object is created in the calling virtual machine. When passing an exported remote object as a parameter or return value in a remote method call, the stub for that remote object is passed instead.