Remote Method Invocation

Introduction

What is Remote Method Invocation? Remote method invocation allows objects

residing in one JVM execute methods of objects residing in another JVM.

The two JVMs can be in the same machine or executing on different machines located in a network.

The object executing a remote method does so as if the remote object was present locally (i.e. accessible through the local classpath.

Why RMI?

To understand this a review of the traditional approach to invoking remote methods is warranted: Traditional method of doing this was by use of Stream Sockets. Stream sockets can be used to pass primitive data types or

objects(provided they implement the Serializable interface) between two hosts on a network.

Stream sockets always passed data by value. That is copies of objects were passed back and forth to effect communication.

Why RMI?

Now imagine a client server scenario, in which a client wants to update an Account object present on the server. The client will typically open a connection to the

server and request the object by name. The server will then send a copy of this object to the

client through an ObjectOutputStream. The client will receive this object, update the object

and send the modified object to the server. The server in turn will replace the server object with

the new object received from the client.

Why RMI?

If many clients are requesting updates on objects residing on the server, the number of object copies that travel on the network increases proportionally. The point is that since Objects are passed by value, a copy of the object

is sent to the requesting client Thus any modification made on the passed object is not reflected on the

server unless the modified object is passed back. This increases network traffic and can have serious implications on the

network band-width. For more complex operations like querying a database located on the

server the performance implications will be extremely high. Another problem with this approach is that if the address of the

server changes, the client needs to know the location of the new server before it can access the object. That is, the objects are not inherently location transparent.

Why RMI?

If it were possible for a client to invoke the methods of objects residing on the server with out actually downloading the object, considerable performance improvements can be achieved.

Further it were possible for a client to access a remote object regardless of on which server the object actually existed, the objects become location transparent.

Why RMI?

RMI ( and before RMI , RPC or Remote Procedure Calls) achieves precisely this objective. Remote Method Invocation involves using the various classes and

interfaces available in the java.rmi and java.rmi.server packages. These classes and interfaces provide a framework for an application to

access objects residing on remote hosts by reference(not value). Once a client obtains a reference to a remote object, it can invoke the

methods on these remote objects as if they existed locally. Any modification made to the object through the remote object reference

is reflected on the server. Thus copies are never passed over the network.

Stubs & Skeletons

RMI is ideally suited to applications which require a client to an application residing on another machine. Almost all application servers(servers that run applications as

opposed to file servers that serve files or data) can benefit from RMI or a framework that allows RMI.

RMI is the distributed component model for JAVA applications. COM/DCOM will be Microsoft’s equivalent. This means one Component(java Object) distributed in a

network can be accessed by any other Component on the network.

This is made possible by what are known as client-stubs and server-skeletons.

Stubs & Skeletons

The java.rmi.Remote interface

RMI provides an interface called Remote. This is contained in the java.rmi package. If a class wants it’s objects to be accessible remotely, that class

must implement this interface. Thus we call an object a Remote Object if it is accessible

remotely. The Remote interface is an empty interface having no methods.

It is a tag interface that tells the Java run time that objects of this class are remotely accessible.

To make this class have it’s methods remotely accessible, the methods need to be declared in an interface that extends the Remote interface.

Using the java.rmi.Remote interface

Using the RMI interface

The exact steps needed to do this are:1. Declare an interface that extends

java.rmi.Remote2. Declare methods that need to be accessed

remotely in this All Remote methods must throw

java.rmi.RemoteException

3. Define a class that implements this interface.

1. Extend RMI

Declare an interface that extends java.rmi.Remote:

public interface MyInterface extends java.rmi.Remote

2. Declare methods that need to be accessed remotely public interface:

MyInterface extends java.rmi.Remote{//Declare all methods herepublic String getMessage()throws java.rmi.RemoteException;

//More methods}

3. Define a class that implements this interface.Public class MyClass implements MyInterface{ //Variable definitions/Declarations //Constructors //Other methods public String getMessage()throws

RemoteException { return new String(“Hello there!”); }}

RMI Class Hierarchy

A Sample Case

Mortgage Computation via RMI

A Scenario

Betty just got a job in a mortgage company. Her supervisor Joy asked her to make the mortgage calculator

available to the public. That is to say the mortgage calculator will be put on an intranet

or the internet. The mortgage calculator is an existing software and installed on

an individual computer. If it is installed on the server, it will be easier to maintain and

update. This is Betty's first assignment. She felt so excited. She decided

to use Java Remote Method Invocation (RMI) technology.

The calculatePayment() Method

She was ready to start now. She started to look at the Mortgage calculator class. The key method in the Mortgage class is the calculatePayment() method listed below:

public double calculatePayment(double principal, double annualRate, int years){

double monthlyInterest = annualRate / 12; double monthlyPayment = (principal *

monthlyInterest) / (1 - Math.pow(1/ (1 +

monthlyInterest), years * 12)); return monthlyPayment;}

The calculatePayment() Method

To calculate the monthly payment for a mortgage, you need three data: principal, annual rate and term. When a user provided these three data to an

application, the monthly payment would be returned. In order to try new RMI features, she quickly

wrote a Mortgage program. She was going to use this command-line

program to try the RMI features.

Designing a Remote Interface

Since the calculatePayment() method is a key method in Mortgage class, Betty decided to make this method remotely available (invoked). If a user provides principal, annual interest rate and loan term

from a command-line, the monthly payment information will be printed on the client side.

How to make such method available via network? According to the RMI technology, you should design a remote

interface first and then put the method signature inside the remote interface.

Betty checked the new RMI specification, such design step since jdk 1.1 has not been changed.

What is a remote interface?

According to RMI specification, a remote interface is an interface that extends java.rmi.Remote interface and declares a set of methods that may be invoked from a remote Java Virtual Machine(JVM).

Note that the java.rmi.Remote interface serves as a mark to tell the system that methods declared within this interface may be invoked from a non-local virtual machine.

What is a remote method?

A remote method is a method that is declared inside a remote interface.

Betty followed the step and designed a remote interface named Payment.

She declared the method calculatePayment() signature and made it throw RemoteException which is required.

What is a remote method?

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

public interface Payment extends Remote { public double calculatePayment(double principal, double annualRate, int terms)

throws RemoteException;}

More on remote methods

Recall that only method signatures or abstract methods are allowed within an interface, so does the remote interface. The implementation class will take care of the remote methods.

Right now, we can say that Payment is a remote interface and calculatePayment() is a remote method.

You may be wondering why the method must throw RemoteException. Because remote method invocation may fail in many ways, like server

down, resources unavailable, the method itself may throw exception, etc.

If the failure happens, the client should be able to know it via the RemoteException.

More on remote methods

Please note that: The Payment interface must extends java.rmi.Remote interface. It is

required. The method signature in the remote interface must throw

java.rmi.RemoteException. It is required too. If you want multiple methods available remotely, just put these

method signatures inside one or more remote interfaces and let them throw java.rmi.RemoteException.

This is the first step you should do when you use RMI technology. Ask yourself if you know how to make a method remotely available, what is the first step?

The next step is to design a remote object.

Design a Remote Object

According to the RMI specification, a remote object is one whose methods can be invoked from another Java virtual machine, potentially on a different host(JVM).


You have learnt from the previous section how to design a remote interface. Do you remember that you have not implemented the remote method calculatePayment().

The implementation class is a remote object. So we need to design a class which implements the

remote interface Payment and defines the remote method -- calculatePayment().


Betty made the implementation class name PaymentImpl, because it is easily to be recognized when you deal with multiple classes. Since Payment is an interface, "Impl" means

implementation, PaymentImpl is an implementation class of Payment interface.

We will adopt such name convention in the following sections.

The Remote Object

import java.rmi.RemoteException;

public class PaymentImpl implements Payment {

public double calculatePayment(double principal, double annRate, int years) throws RemoteException { double monthlyInt = annRate / 12; double monthlyPayment = (principal * monthlyInt) / (1 - Math.pow(1/ (1 + monthlyInt), years * 12)); return format(monthlyPayment, 2); } public double format(double amount, int places) { double temp = amount; temp = temp * Math.pow(10, places); temp = Math.round(temp); temp = temp/Math.pow(10, places); return temp; }}

More on Remote Objects

Note that: The remote object class must implement remote

interface. In this context, it is Payment interface. The remote object class can have any other

methods not defined in the remote interface, but these methods can only be used locally, not remotely, like format() method in the example.

More on Remote Objects

When you implement a remote method, if the method doesn't throw any exception, the method head can omit the RemoteException. In this context, we have to throw the

RemoteException, because we have not written any contract to guarantee that the parameters are valid before this method being called.

Ask yourself: what is a remote object? Next step, we should create a server which can

be used to hold the remote object.

Design an RMI Server

When you have a remote object, you need a carrier to hold it for a possible remote invocation.

That carrier is often called a server.

What is an RMI Server?

A typical RMI server is an application that creates a number of remote objects, makes references to those remote objects and waits for clients to invoke methods on those remote objects.

What is an RMI Server?

In this context, a server is a class. In this class, we need a main method that creates an instance of the remote object, exports the remote object, and then binds that instance to a name in a Java RMI registry.

So we list the server jobs as follows: 1. Create an instance of the remote object 2. Export the remote object 3. Bind the instance to a name in RMI registry

How to create an instance of the remote object We already create a remote object class --

PaymentImpl. To instantiate it, just do it like any other

class instantiation. PaymentImpl robj = new PaymentImpl();

Here robj is an instance of the remote object PaymentImpl.

How to export the remote object? We will use this method:

java.rmi.server.UnicastRemoteObject.exportObject(Remote, int);

to export the remote object.

How to export the remote object? When you export a remote object, you make that object

available to accept incoming calls from clients. The exportObject() method takes 2 parameters, one is an

instance of the remote object, the other is TCP port number. Note that the same port number can accept incoming calls for

more than one remote objects. The default number for RMI is 1099.

If you pass a zero to the method, the default number 1099 is used. Of course, you can use a different number to listen to different remote client calls.

Payment stub = (Payment) UnicastRemoteObject.exportObject(robj, 0);

How to export the remote object? Note that the exportObject() method will return a

stub which is a term used to describe a proxy class. The stub class is a key to make remote object

available for remote invocation. We need to cast it to the remote interface for safe. The second parameter we use "0" that means we are

going to use the default TCP port number, which is 1099.

An alternative way to export remote object You can make the server class extend

java.rmi.server.UnicastRemoteObject class and use a constructor to export the object and define a port number.

An alternative way to export remote objectpublic class Server extends java.rmi.server.UnicastRemoteObject implements aRemoteInterface{

public Server(int port) { super(port); } .... Naming.bind(uniqueName, this); ....}

What is Java RMI registry

The Java RMI registry is a remote object that maps names to remote objects.

The methods of LocateRegistry are used to get a registry operating on a particular host or host and port.

The method bind() or rebind() binds a unique name to the reference of the remote object.

What is Java RMI registry

java.rmi.registry.Registry registry = java.rmi.registry.LocateRegistry.getRegistry();

registry.bind("Mortgage", stub);

or use:

registry.rebind("Mortgage", stub);

The Server Classimport java.rmi.registry.Registry;import java.rmi.registry.LocateRegistry;import java.rmi.RemoteException;import java.rmi.server.UnicastRemoteObject;

public class Server {

public Server() {}

public static void main(String args[]) {

try { PaymentImpl robj = new PaymentImpl(); Payment stub = (Payment) UnicastRemoteObject.exportObject(robj, 0);

Registry registry = LocateRegistry.getRegistry(); registry.bind("Mortgage", stub); System.out.println("Mortgage Server is ready to listen...");

} catch (Exception e) { System.err.println("Server exception thrown: " + e.toString()); e.printStackTrace();}

}}

Design an RMI Client

In the previous sections, we designed a remote interface, a remote object and a server.

And now we need to design a client to test the functionality of the server.

What is an RMI Client?

A typical RMI cient is an application that gets a remote reference to one or more remote objects in the server, then invokes methods on these remote objects.


Remember that we register a remote object by name "Mortgage" with a TCP port number 1099(default). In our client class, we need some code to

look up the object by name "Mortgage" and a TCP port number.

When we get the stub class from the RMI server, we can use this stub class to call the remote method.


There are two things you should do before calling the remote method: 1. Locate a host from the registry mechanism.

2. Look up the remote object by its name.

How to locate a host?

Use the following code to locate a host. Registry reg = LocateRegistry.getRegistry(hostName);

In our example, we will use localhost as the default host. If you run the server in a different computer, you need to give that computer's name as a host name.

How to look up a remote object?

You look up a remote object by its name. So, you must first know the name of the remote object. Remember that we register the remote object by

name "Mortgage" in the server's registry. We use code below to look up "Mortgage" object and

get a stub back. The stub can be used to access the remote method. Payment stub = (Payment) reg.lookup("Mortgage");

How to look up a remote object?

Note that the returned remote object reference should be cast back to the remote interface.

In this context, we cast to Payment interface. The most beautiful thing is that a method

invocation on a remote object has the same syntax as a method invocation on a local object when you get the reference to a remote object.

The Client Class

Note that we use the returned stub from lookup() method to call the remote method calculatePayment() and pass three parameters obtained from the command-line.

We have to use try/catch block to locate RMI registry, look up stub class and call the remote method. If the server has a problem or the remote method has

a failure, the client side should be able to know it through the catch clause.

Running the files

Now, you can try the client\server system on your own computer. You may be wondering how it could be to use one

computer to try a client\server system. Remember that, you can start different command-line

windows to try it. Because every command-line window will get one

distinguished Java Virtual Machine(JVM) instance, and the communication between two JVMs can be established in one computer.

We will use localhost as a host for the server.

Running the files

Betty checked the RMI specification, found that a new feature for running an RMI server is available.

New feature: You don't need to generate a stub class

before you start the server. The stub class will be generated on the fly

if you use jdk 1.5.0 version or above.

Running the files

If you use jdk version below 1.5.0, you cannot run the examples listed here.

You must use rmic utility to generate a stub class.

If so, use the following command to generate a stub class: set classpath= rmic -v1.2 Server

Running the files

A file with name Server_stub.class is generated for JVM communication.

Now you can go to the next step to start rmiregistry and server.

You need to follow the steps below to run the server:1. Start rmiregistry utility 2. Start a server

Running the files

Let's start rmiregistry. First make sure the classpath is empty, then use

command as follows:C:\*your_directory*\set classpath=C:\*your_directory*\start rmiregistry Note that an empty command-line window will

pop-up. Don't close it, minimize it if you want. That window is for rmiregistry.exe program.

Running the Server

Then, you can start a server window in the following command:C:\myrmi\start java Server

The pop-up window will have the following printout which indicates the server is started successfully and ready to accept client connection.Mortgage server is ready to listen...

Note that the RMI server we designed is not for one client connection. It can accept many-client connections simultaneously.

Running the Server

Then, you can start a server window in the following command:C:\myrmi\start java Server

The pop-up window will have the following printout which indicates the server is started successfully and ready to accept client connection.Mortgage server is ready to listen...

Running the Client

When the server starts, you are ready to start a client. Please issue the following command:C:\myrmi\java Client

When the client starts, the LocateRegistry.getRegistry("localhost") sends information to the RMI registry which is held by the localhost(the Server command-line window) and asks to look for a remote object named "Mortgage".

Running the Client

Since the server has such remote object, so the server sends an instance of stub class back, or we can say the client downloads the stub class from the localhost server.

When the client gets the reference to the remote object, it can use such reference to call remote method calculatePayment() just like to call a local method.

This is the most beautiful thing we mentioned earlier for RMI technology.

Running Everything

The following shows all commands and printout when you start the RMI server and client system.

C:\myrmi>javac -d . Payment.java PaymentImpl.java Server.java Client.java

C:\myrmi>set classpath=

C:\myrmi>start rmiregistry

C:\myrmi>start java Server

Running Everything

C:\myrmi>java ClientUsage: java Client principal annualInterest years

For example: java Client 80000 .065 15

You will get the output like the following:

The principal is $80000The annual interest rate is 6.5%The term is 15 yearsYour monthly payment is $696.89

Running Everything

C:\myrmi>java Client 150000 .060 15

The principal is $150000

The annual interest rate is 6.0%

The term is 15 years

Your monthly payment is $1265.79

C:\myrmi>

Process of designing an RMI server and client system

1. Design a remote interface.

2. Design a remote object.

3. Design an RMI server.

4. Design an RMI client.

Remote Method Invocation

Technology

Transcript of Remote Method Invocation