Chapter Five

RMI
RMI stands for “Remote Method Invocation” means communicating the object across the
network.

RMI is a one type of structure or system that allows an object running in one Java virtual
machine (Client) to invoke methods on an object running in another Java virtual machine
(Server).This object is called a Remote Object and such a system is also called RMI Distributed
Application.

RMI provides for remote communication between programs written in the JAVA.

General functioning diagram:

The complete RMI system has a FOUR layer,

(1) Application Layer

(2) Proxy Layer

(3) Remote Reference Layer

(4) Transport Layer

Mainly the RMI application contains the THREE components,

(1) RMI Server

1|P ag e
(2) RMI Client

(3) RMI Registry

RMI Architecture:
The RMI Architecture (System) has a FOUR layer,

(1) Application Layer

(2) Proxy Layer

(3) Remote Reference Layer

(4) Transport Layer

RMI Architecture Diagram:

2|P ag e
(1) Application Layer:

It’s a responsible for the actual logic (implementation) of the client and server applications.

Generally at the server side class contain implementation logic and also apply the reference to
the appropriate object as per the requirement of the logic in application.

(2) Proxy Layer:

It’s also called the “Stub/Skeleton layer”.

A Stub class is a client side proxy handles the remote objects which are getting from the
reference.

A Skeleton class is a server side proxy that set the reference to the objects which communicates
with the Stub.

(3) Remote Reference Layer (RRL):

It’s a responsible for manage the references made by the client to the remote object on the server
so it is available on both JVM (Client and Server).

The Client side RRL receives the request for methods from the Stub that is transferred into byte
stream process called serialization (Marshaling) and then these data are send to the Server side
RRL.

The Server side RRL doing reverse process and convert the binary data into object. This process
called deserialization or unmarshaling and then sent to the Skeleton class.

(4) Transport Layer:

It’s also called the “Connection layer”.

It’s a responsible for the managing the existing connection and also setting up new connections.

So it is a work like a link between the RRL on the Client side and the RRL on the Server side.

RMI Components:
The RMI application contains the THREE components

(1) RMI Server

(2) RMI Client

3|P ag e
(3) RMI Registry

(1) RMI Server:

RMI Server contains objects whose methods are to be called remotely. It creates remote objects
and applies the reference to these objects in the Registry, after that the Registry registers these
objects who are going to be called by client remotely.

(2) RMI Client:

The RMI Client gets the reference of one or more remote objects from Registry with the help of
object name. Now, it can invoke the methods on the remote object to access the services of the
objects as per the requirement of logic in RMI application.

Once the client gets the reference of remote object, the methods in the remote object are invoked
just like as the methods of a local object.

4|P ag e
(3) RMI Registry:

In the Server side the reference of the object (which is invoked remotely) is applied and after that
this reference is set in the RMI registry.

When the Client call the method on this object, it’s not directly call but it call by the reference
which is already set in the Registry so first get the object from this reference which is available at
RMI Registry then after calls the methods as per the requirement of logic in RMI application.

RMI Registry:
The RMI Registry is a naming service.

RMI server programs use this service to bind the remote java object with the names.

Clients executing on local or remote machines retrieve the remote objects by their name
registered with the RMI registry and then execute methods on the objects.

RMI creates a remote proxy for that object and sent it to clients.

An object proxy contains the reference to an object.

In order to work with the RMI registry...

1. Start registry by using following command

start rmiregistry

By default the port 1099 is used by RMI registry to look up the remote objects. After the RMI
registry starts objects can bind to it.

2. Now in second step to bind the remote object with the RMI registry, execute the server
program.

3. To use the remote object execute the client program.

5|P ag e
From the figure we can see that server calls the RMI registry to map a name with a remote object
represented by black circle.

By using the name of remote objects in the server's registry client program locate the remote
object and then methods are called on the remote object by the client program.

RMI Program Code and Example:

To run program of RMI in java is quite difficult, in the following program, there are four
different programs in RMI to add two integer numbers.

First program is for declare a method in an interface.

Second Program is for implementing this method and logic.

6|P ag e
Third program is for server side.

And last one is for client side.

At the last we will give steps to run this program in one system.

Calculator.java

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface Calculator extends Remote

{
public long add(long a,long b) throws RemoteException;
}

CalculatorImpl.java
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class CalculatorImpl extends UnicastRemoteObject implements Calculator

{
protected CalculatorImpl() throws RemoteException
{
super();
}
public long add(long a, long b) throws RemoteException
{
return a+b;
}
}

CalculatorServer.java
import java.rmi.Naming;

public class CalculatorServer

{
CalculatorServer()
{
try
{
Calculator c = new CalculatorImpl();
Naming.rebind("rmi://127.0.0.1:1099/CalculatorService",
c);
}
catch (Exception e)
{
e.printStackTrace();
}
}
public static void main(String[] args)
{
new CalculatorServer();
}

7|P ag e
}

CalculatorClient.java
import java.rmi.Naming;

public class CalculatorClient

{
public static void main(String[] args)
{
try
{
Calculator c = (Calculator)
Naming.lookup("//127.0.0.1:1099/CalculatorService");
System.out.println("addition : "+c.add(10, 15));
}
catch (Exception e)
{
System.out.println(e);
}
}
}

Steps to run this programs:

First of all put these four programs inside bin folder of JDK.

As an example suppose our JDK folder is inside java folder in drive D:

Now open command prompt and do following steps.

cd\

d:

cd Java\jdk1.6.0_23\bin

javac Calculator.java

javac CalculatorImpl.java

javac CalculatorServer.java

javac CalculatorClient.java

rmic CalculatorImpl

rmiregistry 1099

java CalculatorServer

8|P ag e
open another cmd and again go to same path d:\Java\jdk1.6.0_23\bin

java CalculatorClient

Output:

9|P ag e
RMI example - code in java - application:
Steps for Developing the RMI Application:

(1) Define the remote interface

(2) Define the class and implement the remote interface (methods) in this class
(3) Define the Server side class
(4) Define the Client side class
(5) Compile the all four source (java) files
(6) Generate the Stub/Skeleton class by command
(7) Start the RMI remote Registry
(8) Run the Server side class
(9) Run the Client side class (at another JVM)

(1) Define the remote interface:

This is an interface in which we are declaring the methods as per our logic and further these
methods will be called using RMI.

Here we create a simple calculator application by RMI so in that we need four methods such as
addition, subtraction, multiplication and division as per logic.

so create an interface name Calculator.java and declare these methods without body as per the
requirement of a simple calculator RMI application.

10 | P a g e
Calculator.java:

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface Calculator extends Remote

{
public long addition(long a,long b) throws RemoteException;
public long subtraction(long a,long b) throws RemoteException;
public long multiplication(long a,long b) throws RemoteException;
public long division(long a,long b) throws RemoteException;
}

Note:

We must extend the Remote interface because this interface will be called remotely in between
the client and server.

Note:

The RemoteException is an exception that can occur when a failure occur in the RMI process.

(2) Define the class and implement the remote interface(methods) in this class:

The next step is to implement the interface so define a class(CalculatorImpl.java) and

implements the interface(Calculator.java) so now in the class we must define the body of those
methods(addition, subtraction, multiplication, division) as per the logic requirement in the RMI
application(Simple Calculator).

This class run on the remote server.

CalculatorImpl.java:
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class CalculatorImpl extends UnicastRemoteObject implements Calculator

{
protected CalculatorImpl() throws RemoteException
{
super();
}
public long addition(long a, long b) throws RemoteException
{
return a+b;
}
public long subtraction(long a, long b) throws RemoteException
{
return a-b;
}
public long multiplication(long a, long b) throws RemoteException
{

11 | P a g e
 return a*b;
}
public long division(long a, long b) throws RemoteException
{
return a/b;
}
public long addition(long a, long b) throws RemoteException
{
return a+b;
}
}

Note:

The UnicastRemoteObject is a base class for most user-defined remote objects. The general form
of this class is,

Public class UnicastRemoteObject extends RemoteServer

It supplies the TCP based point-to-point references so this class provides some necessary
services that we need in our application otherwise have to implement of interface cannot do
ourselves as well as can’t access these methods remotely.

(3) Define the Server side class:

The server must bind its name to the registry by passing the reference link with remote object
name.
For that here we are going to use rebind method which has two arguments:

The first parameter is a URL to a registry that includes the name of the application and The
second parameter is an object name that is access remotely in between the client and server.

This rebind method is a method of the Naming class which is available in the java.rmi.* package.

The server name is specified in URL as a application name and here the name is
CalculatorService in our application.

Note:

The general form of the URL:

rmi://localhost:port/application_name

Here, 1099 is the default RMI port and 127.0.0.1 is a localhost-ip address.

CalculatorServer.java:
import java.rmi.Naming;

12 | P a g e
public class CalculatorServer
{
CalculatorServer()
{
try
{
Calculator c = new CalculatorImpl();
Naming.rebind("rmi://localhost:1099/CalculatorService",
c);
}
catch (Exception e)
{
System.out.println(“Exception is : ”+e);
}
}
public static void main(String[] args)
{
new CalculatorServer();
}
}

(4) Define the Client side class:

To access an object remotely by client side that is already bind at a server side by one reference
URL we use the lookup method which has one argument that is a same reference URL as already
applied at server side class.

This lookup method is a method of the Naming class which is available in the java.rmi.*
package.

The name specified in the URL must be exactly match the name that the server has bound to the
registry in server side class and here the name is CalculatorService.

After getting an object we can call all the methods which already declared in the interface
Calculator or already defined in the class CalculatorImpl by this remote object.

CalculatorClient.java:
import java.rmi.Naming;

public class CalculatorClient

{
public static void main(String[] args)
{
try
{
Calculator c = (Calculator)
Naming.lookup("//127.0.0.1:1099/CalculatorService");
System.out.println("Addition : "+c.addition(10,5));
System.out.println("Subtraction :
"+c.subtraction(10,5));

13 | P a g e
 System.out.println("Multiplication
:"+c.multiplication(10,5));
System.out.println("Division : "+c. division(10,5));
}
catch (Exception e)
{
System.out.println(“Exception is : ”+e);
}
}
}

(5) Compile the all four source(java) files:

javac Calculator.java
javac CalculatorImpl.java
javac CalculatorClient.java
javac CalculatorServer.java

After compiled, in the folder we can see the four class files such as

Calculator.class
CalculatorImpl.class
CalculatorClient.class
CalculatorServer.class

(6) Generate the Stub/Skeleton class by command:

There is a command rmic by which we can generate a Stub/Skeleton class.

Syntax:

rmic class_name

Here the class_name is a java file in which the all methods are defined so in this application the
class name is CalculatorImpl.java file.

Example:
rmic CalculatorImpl

The above command produce the “CalculatorImpl_Stub.class” file.

(7) Start the RMI remote Registry:

The references of the objects are registered into the RMI Registry So now you need to start the
RMI registry for that use the command

start rmiregistry

14 | P a g e
So the system will open rmiregistry.exe (like a blank command prompt)

(8) Run the Server side class:

Now you need to run the RMI Server class.

Here CalculatorServer.java file is a working as a Server so run this fie.

Java CalculatorServer

(9) Run the Client side class(at another JVM):

Now open a new command prompt for the client because current command prompt working as a
server and finally run the RMI client class.

Here CalculatorClient.java file is a working as a Client so finally run this fie.

Java CalculatorClient

Get the output like

Addition : 15
Subtraction : 5
Multiplication : 50
Division : 2

NOTE:

For compile or run all the file from command prompt and also use the different commands like
javac, java, start, rmic etc you need to set the class path or copy all the java files in bin folder of
JDK.

CLICK HERE for simple addition program of RMI in java

15 | P a g e