Java rmi example program with code

RMI

http://www.java2all.com

Chapter 2

RMI Program Code and
Example:


RMI Program Code and
Example:


CLICK HERE for step by step learning with
description of each step
To run program of RMI in java is quite
difficult, Here I am going to give you 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.
Third program is for server side.

And last one is for client side.
At the last I 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.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();
}
}


CalculatorClient.java

public class CalculatorClient
{
{
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 Javajdk1.6.0_23bin
javac Calculator.java
javac CalculatorImpl.java
javac CalculatorServer.java
javac CalculatorClient.java
rmic CalculatorImpl
start rmiregistry
java CalculatorServer
open another cmd and again go to same path
d:Javajdk1.6.0_23bin
java CalculatorClient

Output:

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.

Calculator.java:
import java.rmi.Remote;

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 extends 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.http://www.java2all.com

(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.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
{
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:



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);
}
}
{
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:

public class CalculatorClient
{
{
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));
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 http://www.java2all.com

(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
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


Java rmi example program with code

More Related Content

What's hot

Viewers also liked

Similar to Java rmi example program with code

More from kamal kotecha

Recently uploaded

Java rmi example program with code