AJP – Unit 4 - 3

RMI Programming
To set JAVA_HOME in Windows 10 (Java Claspath)
• Open Control Panel and Select System and Security.
• Select System.
• Select Advanced System Settings.
• Select Environment Variables
• Under “System variables” click the “New…” button and enter
JAVA_HOME as “Variable name” and the path to your Java JDK
directory under “Variable value”
• Update System PATH
1. In “Environment Variables” window under “System variables”
select Path
2. Click on “Edit…”
3. In “Edit environment variable” window click “New”
4. Type in  %JAVA_HOME%\bin
• Verify Java path by typing javac in command prompt
2
RMI (Remote Method Invocation)

• The RMI (Remote Method Invocation) is an API that

provides a mechanism to create distributed application in
java. The RMI allows an object to invoke methods on an
object running in another JVM.
• The RMI provides remote communication between the
applications using two objects stub and skeleton.

3
Understanding stub and skeleton
• RMI uses stub and skeleton object for communication with
the remote object.
• A remote object is an object whose method can be invoked
from another JVM. Let's understand the stub and skeleton
objects:

4
stub
• The stub is an object, acts as a gateway for the client side.
All the outgoing requests are routed through it. It resides at
the client side and represents the remote object. When the
caller invokes method on the stub object, it does the
following tasks:
• It initiates a connection with remote Virtual Machine
(JVM),
• It writes and transmits (marshals) the parameters to the
remote Virtual Machine (JVM),
• It waits for the result
• It reads (unmarshals) the return value or exception, and
• It finally, returns the value to the caller.
5
skeleton
• The skeleton is an object, acts as a gateway for the server
side object. All the incoming requests are routed through it.
When the skeleton receives the incoming request, it does the
following tasks:
• It reads the parameter for the remote method
• It invokes the method on the actual remote object, and
• It writes and transmits (marshals) the result to the caller.

6
In the Java 2 SDK, an stub protocol was introduced that
eliminates the need for skeletons.

7
Understanding requirements for the distributed applications

• If any application performs these tasks, it can be distributed

application.
• The application need to locate the remote method
• It need to provide the communication with the remote
objects, and
• The application need to load the class definitions for the
objects.
• The RMI application have all these features, so it is called
the distributed application.

8
Java RMI Example

• Given are the 6 steps to write the RMI program.

• Create the remote interface
• Provide the implementation of the remote interface
• Compile the implementation class and create the stub and
skeleton objects using the rmic tool
• Start the registry service by rmiregistry tool
• Create and start the remote application
• Create and start the client application

9
RMI Example
• In this example, we have followed all the 6 steps to create and run the rmi
application. The client application need only two files, remote interface and client
application. In the rmi application, both client and server interacts with the remote
interface. The client application invokes methods on the proxy object, RMI sends
the request to the remote JVM. The return value is sent back to the proxy object and
then to the client application.

10
1) create the remote interface
• For creating the remote interface, extend the Remote
interface and declare the RemoteException with all the
methods of the remote interface. Here, we are creating a
remote interface that extends the Remote interface. There is
only one method named add() and it declares
RemoteException.
import java.rmi.*;  
public interface Adder extends Remote{  
public int add(int x,int y)throws RemoteException;  
}  

11
2) Provide the implementation of the remote interface
• Now provide the implementation of the remote interface. For
providing the implementation of the Remote interface, we need to
• Either extend the UnicastRemoteObject class, or use the
exportObject() method of the UnicastRemoteObject class
• In case, you extend the UnicastRemoteObject class, you must define a
constructor that declares RemoteException.
import java.rmi.*;  
import java.rmi.server.*;  
public class AdderRemote extends UnicastRemoteObject implements Adder{  
AdderRemote()throws RemoteException{  
super();  
}  
public int add(int x,int y){
return x+y;
}   }  
12
3) create the stub and skeleton objects using the rmic tool.
• Next step is to create stub and skeleton objects using the rmi
compiler. The rmic tool invokes the RMI compiler and
creates stub and skeleton objects.
• rmic AdderRemote  

13
4) Start the registry service by the rmiregistry tool
• Now start the registry service by using the rmiregistry tool.
If you don't specify the port number, it uses a default port
number. In this example, we are using the port number
5000.
• rmiregistry 5000  

14
5) Create and run the server application
• Now rmi services need to be hosted in a server process. The
Naming class provides methods to get and store the remote
object. The Naming class provides 5 methods.

15
• In this example, we are binding the remote object by the
name raghavan .
import java.rmi.*;  
import java.rmi.registry.*;  
public class MyServer{  
public static void main(String args[]){  
try{  
Adder stub=new AdderRemote();  
Naming.rebind("rmi://localhost:5000/raghavan",stub);  
}catch(Exception e){System.out.println(e);}  
}  
}  
16
6) Create and run the client application
• At the client we are getting the stub object by the lookup() method of
the Naming class and invoking the method on this object. In this
example, we are running the server and client applications, in the
same machine so we are using localhost. If you want to access the
remote object from another machine, change the localhost to the host
name (or IP address) where the remote object is located.
import java.rmi.*;  
public class MyClient{  
public static void main(String args[]){  
try{  
Adder stub=(Adder)Naming.lookup("rmi://localhost:5000/raghavan");  
System.out.println(stub.add(34,4));  
}catch(Exception e){}  
}  
}   17
For running this rmi example,  
  
1) compile all the java files  
 javac *.java  
  
2)create stub and skeleton object by rmic tool  
 rmic AdderRemote  
  
3)start rmi registry in one command prompt  
  rmiregistry 5000  
  
4)start the server in another command prompt  
  java MyServer  
  
5)start the client application in another command prompt  
  java MyClient  

18
Real Time example of RMI application with database
• Consider a scenario, there are two applications running in
different machines. Let's say MachineA and MachineB,
machineA is located in United States and MachineB in
India. MachineB want to get list of all the customers of
MachineA application.

19