WRITE A PROGRAM TO IMPLEMENT RMI IN JAVA FOR

(I) A SINGLE CLIENT

(II) MULTIPLE CLIENTS

INTRODUCTION :

RMI is one of the core Java APIs since version 1.1. It provides a framework for distributed computing.
With RMI, separate parts of a single program can exist in multiple Java environments on multiple
machines. To the client and server, the program operates much like it is local to their environment and
within a single memory space.

There are many cases where a distributed environment is beneficial. As applications grow large and
complex they are more manageable, more performant, and more robust when they are distributed
among multiple machines. Resources can be physically located where they make the most sense.
Dedicated machines can be configured optimally to perform specialized operations. Heavy processing
can be allocated to the best-suited hardware, centralized data servers can handle data processing, and
web servers can just serve web pages. A large application can distribute the workload and achieve
better efficiency and data isolation. RMI is a proven framework to design and implement a distributed
application in a Java environment. Due to the multi-platform nature of Java, RMI is probably the best
choice of API for this type of application.

The client is defined as the application, which uses a remote object, and the server is defined as the
machine which hosts the remote object. Communication is two way. Below is the standard simple
diagram showing the relationship.

To both the client and server, the application appears to be local even though it is actually distributed
among multiple Java environments. This is achieved by implementing interfaces, which define the
methods, which can be invoked. The interfaces define the contract between the objects. What is
actually passed back and forth are primitive data types (passed by value), remote references (objects
which implement java.Remote), or copies of local objects (objects which implement
java.io.Serializable). As one would expect, changes to the remote reference results in changes to the
object; changes to the copy do not.

Remote objects are listed in the rmiregistry of the server. A client will query the rmiregistry for an
object by its handle and will receive a reference to the remote object. The client then invokes methods
on the remote object. What actually is happening is that the client is invoking methods locally on the
stub, which carries out the interaction. Likewise on the server side, the server interacts with the
skeleton. The operations of the Remote Reference Layer and the Transport Layer are hidden from both
sides. This allows different implementations of the Java Virtual Machine, which may be on different
platforms, to integrate seamlessly.

When the resources become large, extensive processing is required, or resources exist in multiple
physical locations, then distributed objects are the way to go. The advantages include all of the power
words that are commonly tossed around: scalability, maintainability, reliability, availability,
extensibility, and manageability.
It provides an efficient network environment as the resources are only transmitted as needed and do
not have to be loaded locally to each individual client. They can also be managed locally. The
transmissions are much smaller than sending a complete formatted page for each query. This benefit
would be magnified if the resources are large or need to be updated regularly.
CODE (SINGLE CLIENT):

RandomQuote.java

import java.rmi.*;

public interface RandomQuote extends Remote

{
public String getQuote() throws RemoteException;
public String getQuotes(int n) throws RemoteException;
}

QuoteServer.java

import java.net.*;
import java.rmi.*;

public class QuoteServer

{
public static void main(String[] args)
{
try
{
QuoteServerImpl q = new QuoteServerImpl();
Naming.rebind("quotes", q); // sets the handle
System.out.println("QuoteServer started and "+"awaiting
connections.");
}
catch (RemoteException er)
{
System.out.println("Exception in QuoteServer.main: " + er);
}
catch (Exception err)
{
System.out.println("Exception occurred: " + err);
}
}
}

QuoteServerImpl.java

import java.rmi.*;
import java.rmi.server.UnicastRemoteObject;
import java.io.*;
import java.util.*;

public class QuoteServerImpl implements RandomQuote

{
ArrayList quotes = new ArrayList();
ArrayList chosen = new ArrayList();
String resources = "quote_r.txt"; //full path to your resources!!

public QuoteServerImpl() throws RemoteException

{
UnicastRemoteObject.exportObject(this);
}

public String getQuote() throws RemoteException

{
if (quotes.size() == 0)
{
readQuotes();
}
String output = getRandomQuote();
return output;
}

public String getQuotes(int n) throws RemoteException

{
if (quotes.size() == 0)
{
readQuotes();
}
chosen.clear();
StringBuffer output = new StringBuffer();
String temp = "";
for (int i = 0; i < n; i++)
{
temp = getRandomQuote();
if (chosen.contains(temp))
{
i--;
}
else
{
output.append(temp + "\n\n");
chosen.add(temp);
}
}
return output.toString();
}

private void readQuotes()

{
quotes.clear();
try
{
File f = new File(resources);
FileReader fr = new FileReader(f);
BufferedReader in = new BufferedReader(fr);
String s = "";
while ((s = in.readLine()) != null)
{
quotes.add(s);
}
in.close();
}
catch (IOException e)
{
System.out.println("ERROR: " + e);
 quotes.add("Unable to access the Quotes " +"at this time. Please
try again later.");
}
}

private String getRandomQuote()

{
int n = quotes.size();
int selection = (int)Math.round(Math.random() * n);
return (String)quotes.get(selection);
}
}

QuoteClient.java

import java.rmi.*;

public class QuoteClient

{
String quoteServer = "rmi://localhost/quotes";

public static void main(String[] args)

{
int num = 0;
if (args.length > 0)
{
try
{
num = Integer.parseInt(args[0]);
}
catch (Exception e)
{
System.out.println("please enter a number as an
argument");
System.exit(0);
}
}
QuoteClient q = new QuoteClient();
if (num < 2)
q.getQuote();
else if (num > 10) // enforcing a limit of 10
q.getQuotes(10);
else
q.getQuotes(num);
}

public void getQuote()

{
try
{
RandomQuote rq =(RandomQuote)Naming.lookup(quoteServer);
System.out.println(rq.getQuote());
}
catch (Exception e){System.out.println("ERROR: " + e);}
}
 public void getQuotes(int n)
{
try
{
RandomQuote rq =(RandomQuote)Naming.lookup(quoteServer);
System.out.println(rq.getQuotes(n));
}
catch (Exception e){System.out.println("ERROR: " + e);}
}
}
OUTPUT:
CODE (MULTIPLE CLIENTS):

BroadcastServer.java

import java.rmi.*;

public interface BroadcastServer extends Remote

{
void addBroadcastListener(BroadcastListener bl)
throws RemoteException;
void removeBroadcastListener(BroadcastListener bl)
throws RemoteException;
}

BroadcastServerApp.java

import java.net.*;
import java.rmi.*;

public class BroadcastServerApp

{
public static void main(String args[])
{
try
{
BroadcastServerImpl bsi;
bsi = new BroadcastServerImpl();
Naming.rebind("BroadcastServer", bsi);
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
}
BroadcastServerImpl.java

import java.io.*;
import java.rmi.*;
import java.rmi.server.*;
import java.util.*;

public class BroadcastServerImpl extends UnicastRemoteObject implements BroadcastServer,

Runnable
{
private Vector listeners;
private Thread thread;

public BroadcastServerImpl() throws RemoteException

{
listeners = new Vector();
thread = new Thread(this);
thread.start();
}

public void addBroadcastListener(BroadcastListener bl) throws RemoteException

{
listeners.addElement(bl);
}

public void removeBroadcastListener(BroadcastListener bl) throws

RemoteException
{
listeners.removeElement(bl);
}

public void run()

{
try
{
InputStreamReader isr;
isr = new InputStreamReader(System.in);
BufferedReader br;
br = new BufferedReader(isr);
while(true)
{
String p = "Enter the message to be broadcast:";
System.out.println(p);
String s = br.readLine();
if(s == null)
{
return;
}
sendMessage(s);
}
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
 protected void sendMessage(String message)
{
// v1 = a clone of the listeners vector, v2 = a new vector
Vector v1, v2;
synchronized(this)
{
v1 = (Vector)listeners.clone();
}
v2 = new Vector();

// Broadcast the message to these listeners

Enumeration e1 = v1.elements();
while(e1.hasMoreElements())
{
BroadcastListener bl;
bl = (BroadcastListener)e1.nextElement();
try
{
bl.receiveBroadcast(message);
}
catch(Exception ex)
{
v2.addElement(bl);
}
}

// Remove listeners that caused exceptions

Enumeration e2 = v2.elements();
while(e2.hasMoreElements())
{
listeners.removeElement(e2.nextElement());
}
}
}

BroadcastListener.java

import java.rmi.*;

public interface BroadcastListener extends Remote

{
public void receiveBroadcast(String message)
throws RemoteException;
}

BroadcastListenerImpl.java

import java.rmi.*;
import java.rmi.server.*;

public class BroadcastListenerImpl extends UnicastRemoteObject implements BroadcastListener

{
 public BroadcastListenerImpl()
throws RemoteException
{

public void receiveBroadcast(String message)

throws RemoteException
{
System.out.println("Message = " + message);
}
}

BroadcastClient.java

import java.rmi.*;

public class BroadcastClient

{
private static BroadcastListenerImpl bli;

public static void main(String[] args)

{
try
{
// Make rmi URL to BroadcastServer
String broadcastServerURL;
broadcastServerURL ="rmi://" + args[0] + "//BroadcastServer";

// Obtain a reference to that remote object

BroadcastServer broadcastServer =
(BroadcastServer)Naming.lookup(broadcastServerURL);
bli = new BroadcastListenerImpl();
broadcastServer.addBroadcastListener(bli);
}
catch(Exception ex)
{
ex.printStackTrace();
}
}
}
OUTPUT:

Server Side Shell:

Server Side Shell:

Client Side Shell:

Server Side Shell:

Client Side Shell: