The document discusses Java Remote Method Invocation (RMI) which allows Java programs running on one computer to invoke methods on Java objects residing on other computers. RMI uses stub and skeleton patterns to transparently handle remote method calls similarly to local method calls. It also describes the three independent layers of RMI - the stub-skeleton layer, remote reference layer, and transport layer which handle different aspects of remote communication.

1. June 21, 2017 www.snipe.co.in 1
Prepared :Snipe Team

2. June 21, 2017 2
RMI

3. June 21, 2017 3
• Overview of RMI.
• Java RMI allowed programmer to execute remote function class using
the same semantics as local functions calls.
Java Remote Object Invocation (RMI)?
Local Machine (Client)
SampleServer remoteObject;
int s;
…
s = remoteObject.sum(1,2);
System.out.println(s);
Remote Machine (Server)
public int sum(int a,int b)
{
return a + b;
}
1,2
3

4. June 21, 2017 4
• Java RMI is a mechanism that allows a Java program running on one
computer (e.g., the client) to apply a method to an object on a different
computer (e.g., the server).
• In itself, the syntax of the remote invocation looks exactly like an
ordinary Java method invocation. The remote method call can be
passed arguments computed in the context of the local machine. It can
return arbitrary values computed in the context of the remote machine.
The RMI system transparently forwards these arguments and results.
• RMI is an implementation of the of the Distributed Object
programming model—similar to CORBA, but simpler, and specialized
to the Java language
Java Remote Object Invocation (RMI)?

5. June 21, 2017 5
Advantages and Disadvantages
Advantages
True object-orientation: Objects as arguments and values
Mobile behavior: Returned objects can execute on caller
Integrated security
Built-in concurrency (through Java threads)
Disadvantages
Java only
Advertises support for non-Java
But this is external to RMI – requires Java on both sides

6. June 21, 2017 6
There are 3 Independent Layers
-Stub-Skeleton layer – client stubs and server skeletons
-Remote reference layer
-Transport layer –connection up , management and object tracking
System Architecture

7. June 21, 2017 7
•Interface to applications. Stub functions:
– Initiating a call to the remote object (via remote reference layer).
– Marshaling arguments (using serialization)
– Informing the remote reference layer that the call should be invoked.
– Unmarshaling the return value or exception from a marshal stream.
– Informing the remote reference layer that the call is complete.
•Skeleton functions:
– Unmarshaling arguments from the marshal stream.
– Making the up-call to the actual remote object implementation.
– Marshaling the return value of the call or an exception (if one occurred)
onto the marshal stream.
•Stub and skeleton (bytecode) generated by RMI compiler (rmic)
Stub-Skeleteon Layer

8. June 21, 2017 8
•An object implementation selects a specific remote reference sub-class.
Examples :
– Unicast point-to-point invocation
– Invocation to replicated object groups (multiple servers)
– Support for a user-defined replication/redirection strategy.
– Support for a persistent reference to the remote object (enabling activation
of the remote object).
– Reconnection strategies (if remote object becomes inaccessible).
•client-side - information on invocation according to specified remote reference
semantics.
•server-side - implements the specific remote reference semantics prior to
invoking the skeleton (e.g., atomic multicast delivery)
•data is transmitted from stub-skeleton to transport layer (and vice-versa) via
connection-oriented stream abstraction
•a connectionless transport (UDP) can be implemented underneath
Remote Reference Layer

9. June 21, 2017 9
Functions:
• Setting up and managing connections
• Monitoring connection "liveness."
• Listening for incoming calls.
• Maintaining a table of remote objects that reside in the address space.
• Setting up a connection for an incoming call.
• Locating the dispatcher for the target of the remote call and passing the
connection to this dispatcher.
Abstractions:
• endpoint - denotes an address space or Java virtual machine.
• channel - manages connection between local and remote address spaces
• connection - transfer data
• transport - channel managment
Transport Layer

10. June 21, 2017 10
• Assume code running in the local machine holds a remote reference to
an object obj on a remote machine.
Example ?
res = obj.meth(arg) ;
ResType meth(ArgType arg) {
. . .
return new ResImpl(. . .) ;
}
Local machine Remote machine

11. June 21, 2017 11
The General RMI Architecture
• The server must first bind
its name to the registry
• The client lookup the server
name in the registry to
establish remote references.
• The Stub serializing the
parameters to skeleton, the
skeleton invoking the
remote method and
serializing the result back to
the stub.
RMI Server
skeleton
stub
RMI Client
Registry
bind
lookupreturn call
Local Machine
Remote Machine

12. June 21, 2017 12
The Stub and Skeleton
• A client invokes a remote method, the call is first forwarded to stub.
• The stub is responsible for sending the remote call over to the server-
side skeleton
• The stub opening a socket to the remote server, marshaling the object
parameters and forwarding the data stream to the skeleton.
• A skeleton contains a method that receives the remote calls, unmarshals
the parameters, and invokes the actual remote object implementation

13. June 21, 2017 13
The Steps for Developing an RMI System
1. Develop the remote object and its interface
/* SampleServer.java */
import java.rmi.*;
public interface SampleServer extends Remote
{
public int sum(int a,int b) throws
RemoteException;
}

14. June 21, 2017 14
Develop the remote object and its interface
/* SampleServerImpl.java */
public static void main(String args[])
{
try
{
System.setSecurityManager(new RMISecurityManager());
//set the security manager
//create a local instance of the object
SampleServerImpl Server = new SampleServerImpl();
//put the local instance in the registry
Naming.rebind("SAMPLE-SERVER" , Server);
System.out.println("Server waiting.....");
}
catch (java.net.MalformedURLException me) {
System.out.println("Malformed URL: " + me.toString()); }
catch (RemoteException re) {
System.out.println("Remote exception: " + re.toString()); }
}

15. June 21, 2017 15
Develop the client program
Step 3: Develop the client program
• In order for the client object to invoke methods on the server, it must
first look up the name of server in the registry. You use the
java.rmi.Naming class to lookup the server name.
• The server name is specified as URL in the from
( rmi://host:port/name )
• Default RMI port is 1099.
• The name specified in the URL must exactly match the name that the
server has bound to the registry. In this example, the name is
“SAMPLE-SERVER”
• The remote method invocation is programmed using the remote
interface name (remoteObject) as prefix and the remote method name
(sum) as suffix.

16. June 21, 2017 16
Develop the client program
import java.rmi.*;
import java.rmi.server.*;
public class SampleClient
{
public static void main(String[] args)
{
// set the security manager for the client
System.setSecurityManager(new RMISecurityManager());
//get the remote object from the registry
try
{
System.out.println("Security Manager loaded");
String url = "//localhost/SAMPLE-SERVER";
SampleServer remoteObject = (SampleServer)Naming.lookup(url);
System.out.println("Got remote object");
System.out.println(" 1 + 2 = " + remoteObject.sum(1,2) );
}
catch (RemoteException exc) {
System.out.println("Error in lookup: " + exc.toString()); }
catch (java.net.MalformedURLException exc) {
System.out.println("Malformed URL: " + exc.toString()); }
catch (java.rmi.NotBoundException exc) {
System.out.println("NotBound: " + exc.toString());
}
}
}

17. June 21, 2017 17
the Remote Interface
• In RMI, a common remote interface is the minimum amount of
information that must be shared in advance between “client” and
“server” machines. It defines a high-level “protocol” through
which the machines will communicate.
• A remote interface is an ordinary Java interface, which must
extent the marker interface java.rmi.Remote.
• All methods in a remote interface must be declared to throw the
java.rmi.RemoteException exception.

18. June 21, 2017 18
java.rmi.Remote
• The interface java.rmi.Remote is a marker interface.
• It declares no methods or fields; however, extending it tells the
RMI system to treat the interface concerned as a remote
interface.
• In particular we will see that the rmic compiler generates extra
code for classes that implement remote interfaces. This code
allows their methods to be called remotely

19. June 21, 2017 19
java.rmi.RemoteException
• The Requiring all remote methods be declared to throw
RemoteException was a philosophical choice by the designers of
RMI.
• RMI makes remote invocations look syntactically like local
invocation. In practice, though, it cannot defend from problems
unique to distributed computing—unexpected failure of the
network or remote machine.
• Forcing the programmer to handle remote exceptions helps to
encourage thinking about how these partial failures should be
dealt with.

20. June 21, 2017 20
The Remote Object
• A remote object is an instance of a class that implements a
remote interface.
• Most often this class also extends the library class
java.rmi.server.UnicastRemoteObject. This class includes a
constructor that exports the object to the RMI system when it is
created, thus making the object visible to the outside world.
• Usually you will not have to deal with this class explicitly—your
remote object classes just have to extend it.
• One fairly common convention is to name the class of the remote
object after the name of the remote interface it implements, but
append “Impl” to the end
• .

21. June 21, 2017 21
The Stub
• A What this tells us is that, however they are obtained—and
however they look—remote references are not, in reality, Java
references to remote objects. They are Java references to local
objects that happen to implement the same remote interfaces as
the remote objects concerned.
• The local Java object referenced is actually an instance of a stub
class.

22. June 21, 2017 22
The Architecture
• A
Client
Code Stub
RMI
“Run-time”
System
Remote
Object
Call stub method
locally
Return value
or throw exception
Call remote object
method locally
Return value
or throw exception
Send marshaled
arguments
Send marshaled
result or
exception
Internet
Client
Server

23. The Role of rmic
• The only “compiler” technology peculiar to RMI is the
rmic stub generator.
• The input to rmic is a remote implementation class,
compiled in the normal way with javac (for example).
• The stub generator outputs a new class that implements
the same remote interfaces as the input class.
• The methods of the new class contain code to send
arguments to, and receive results from, a remote object,
whose Internet address is stored in the stub instance

24. The RMI Registry
Client
Code
Remote
Object
Client Server
Registry Store
Reference
Request
Reference

25. The RMI Registry
Instead of interacting with the registry indirectly through the
Naming class, it is possible to obtain a direct remote reference to
the registry object.
Its remote interface is defined in the package java.rmi.registry.
The interface includes:
public interface Registry extends Remote {
public Remote lookup(String name) throws . . . ;
public bind(String name, Remote obj) throws . . . ;
public rebind(String name, Remote obj) throws . . . ;
. . .
}

26. The LocateRegistry
This class constructs a stub for an existing Registry object. (It can
also create a new registry implementation object, running in the
current JVM.)
The interface includes:
public final class LocateRegistry {
public static Registry getRegistry(String host, int port)
throws . . .
{. . .}
public static Registry createRegistry(int port)
throws . . .
{. . .}
. . .
}