Home Shipping Java RMI

Java RMI

Java RMI

Basic Model of JAVA RMI: Execution of distributed object in Java is possible with the help of Java RMI. A client can access to a Java Object Hosted which is on a remote virtual machine from any JVM. It is two step procedures. First step is about execution of the clients and servers in Java. This will allows them to an inherent object-oriented appearance and objects to interact with all the characteristics of Java. So it’s mean we can access/run a server object from any java virtual machine (JVM) therefore, we can achieve the platform independently.

Second is that the Java RMI’s fundamental model always have a client program, and this client program is used to approach the remote objects from any Java virtual machine. For the Connection between a client and a remote object need a reference to object, this is hosted by a server program. Remote server object can be located by server in two different ways. These two procedures have their own methods to give remote reference to the client. These are procedures are,

• Explicitly.
• Implicitly.

Both are used for “obtaining a remote reference”.

Java RMI Architecture:

To create a Math service using Java RMI I have follow these steps.

1. Define a remote interface
2. Implementation of the server
3. Implementation of the client
4. Compile the source code
5. Start Java RMI registry, server and then client.

Create the Remote Interface:

In Java RMI an interface is used to extend the “java.rmi.Remote” interface. Remote interface doesn’t have any method of its own, and it is used for tagging the remote objects, which makes possible to identify as it is. (Harold E. R., 2000). Set of remote methods also declared in the interface. Every single remote method must declare “java.rmi.RemoteException” or a superclass of the “RemoteException” in its throws section, in addition to any application’s specific exception.

Example which I have use in this paragraph for remote interface, “bite.example.SampleServer”. It declares the four methods, “Addition”, “Subtraction”, “Multiplication” and “Square”.

Following is the source code for “SampleServer.java”.

Sample Server
package bite.example;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface SampleServer extends Remote

public int addition(int x, int y) throws RemoteException;
public int subtract(int x, int y)throws RemoteException;
public int multiply(int x, int y)throws RemoteException;
public int square(int x)throws RemoteException;
public int getValue()throws RemoteException;
public String getLastOp()throws RemoteException;

Implementation of Sever:

In this context our “server” class exports the remote object and this server class holds a “main” method, this produce an instance of the remote object implementation. Then it combines that instance to a name in a Java RMI registry. The class which holds this “main” method possibly the implementation class by itself or another class completely.

In the class “Server” we declare the “main” method for server, and it also perform the remote interface SampleServer. Our server’s “main” method follows these two steps. A new remote object is produced and export in first step, second step is about the registration of an object with a Java RMI registry.
Source code for class “SampleServerImpl.java” is as following.

Sample Server Impl.
package bite.example;
import java.rmi.registry.Registry;
import java.rmi.registry.LocateRegistry;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class SampleServerImpl implements SampleServer
private int value =0;
private String lastOp;

public int addition(int x, int y) throws RemoteException
value = x + y;
lastOp = “ADDITION”;
return value;

public int subtract(int x, int y)throws RemoteException
value = x – y;
return value;

public int multiply(int x, int y)throws RemoteException
value = x*y;
lastOp = “MULTIPLY”;
return value;

public int square(int x)throws RemoteException
value = x*x;
lastOp = “SQUARE”;
return value;

/* Resource properties */
public int getValue() throws RemoteException
return value;

public void setValue(int value)
this.value = value;

public String getLastOp()throws RemoteException
return lastOp;

public void setLastOp(String lastOp)
this.lastOp = lastOp;

public static void main(String args[])
//Create and export a remote object
SampleServerImpl obj = new SampleServerImpl();
SampleServer stub = (SampleServer)UnicastRemoteObject.exportObject(obj, 0);
//Register the remote object with a Java RMI registry
//and bind the remote object’s stub in the registry
Registry registry = LocateRegistry.getRegistry();
registry.bind(“SampleServer”, stub);

System.err.println(“Server ready”);
catch (Exception e)
System.err.println(“Server exception: ” + e.toString());

Implementation of Client:

Client class acquires a “stub” for the registry on the server’s host, and it is searches remote object’s stub in the registry by their names, and then it invokes the “Addition”, “Subtraction”, “Multiply” and “Square” methods on the remote object using stub.
Source code for the Client is following.

Sample Client

package bite.example;
import java.io.*;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.Scanner;
public class SampleClient {
public static void main(String[] args) {
String host = (args.length start java -Djava.rmi.server.codebase=file:C:/rmi/ -Djava.rmi.server.name= bite.example.SampleServerImpl”
And then I have got the output “Server ready”

Start the Client: Final step is to start the client. When server was ready I open another window of command prompt line and then run the client as follow “C:\rmi>java bite.example.SampleClient”