Distributed Objects and Remote
Invocation: RMI & CORBA
http://java.sun.com/docs/books/tutorial/rmi/
Outline
Introduction to RMI
RMI Architecture
RMI Programming and a Sample Example:
Server-Side RMI programming
Client-Side RMI programming
Advanced RMI Concepts
Security Policies
Exceptions
Dynamic Loading
A more advanced RMI application
File Server
2
What is Java RMI?
Java Remote Method Invocation (Java RMI) enables
the programmer to create distributed Java
technology-based applications, in which the methods
of remote Java objects can be invoked from other
Java virtual machines*, possibly on different hosts.
RMI uses object serialization to marshal and
unmarshal parameters and does not truncate types,
supporting true object-oriented polymorphism.
Releases of Java RMI
Java RMI is available for Java Standard Edition (JSE) and
Java Micro Edition (JME).
3
RMI Architecture & Components
Remote reference module is responsible for providing addressing to the
proxy (stub) object
Proxy is used to implement a stub and provide transparency to the client. It is
invoked directly by the client (as if the proxy itself was the remote object),
and then marshal the invocation into a request
Communication module is responsible for networking
Dispatcher selects the proper skeleton and forward message to it
Skeleton un-marshals the request and calls the remote object
client server
remote
skeleton object B
object Aproxy for B Request & dispatcher
for B’s class
Reply
servant
Remote Communication CommunicationRemote reference
4 module module module
reference module
Invocation Lifecycle
Client Server
Client Code RMI Object
Invoke Returns Calls actual Returns
method via
stub 1 8 response method
with args 4 5
response /
exception
Stub Skeleton
Serializes Receives, Receives, Serialises
arguments, deserialises deserialises response,
transmit
2 7
response arguments
3 6 transmit
Network
5
Steps of implementing an RMI application
Design and implement the components of your
distributed application
Remote interface
Servant program
Server program
Client program
Compile source and generate stubs
Client proxy stub
Server dispatcher and skeleton
Make classes network accessible
Distribute the application on server side
Start the application
6
RMI Programming and Examples
Application Design
Remote Interface
Exposes the set of methods and properties available
Defines the contract between the client and the server
Constitutes the root for both stub and skeleton
Servant component
Represents the remote object (skeleton)
Implements the remote interface
Server component
Main driver that makes available the servant
It usually registers with the naming service
Client component
7
Example application – Hello World
Server side
Create a HelloWorld interface
Implement HelloWorld interface with methods
Create a main method to register the HelloWorld
service in the RMI Name Registry
Generate Stubs and Start RMI registry
Start Server
Client side
Write a simple Client with main to lookup
HelloWorld Service and invoke the methods
8
Explanation: Server Side
Restrictions on the Remote interface
User defined interface must extend java.rmi.Remote interface
Methods inside the remote interface must throw java.rmi.RemoteException
Servant class is recommended to extend java.rmi.server.UnicastRemoteObject
Servant that does not extend UnicastRemoteObject need to export explicitly
UnicastRemoteObject.export(Remote remoteObj);
Name Service: RMI Registry
Bind, unbind and rebind remote object to specified name
All the classes required need to be on rmiregistry classpath
java.rmi.Naming is an interface for binding object name (URL) to the registry
Format of object URL
//host:port/objectname (implicit declaration of RMI protocol for name)
Eg. //localhost/HelloWorldService or rmi://localhost/HelloWorldService
Default port is 1099
For security reason, a server program can bind, unbind and rebind only on its same host
Prevent any binding from the remote clients
Lookup can be invoked everywhere
After the binding, the remote object will not be reclaimed in garbage collection until the
server unbinds it
Because it is remotely referred by the registry (running in a separate JVM)
9
Server Side : Define an interface
(cs652/HelloWorld.java)
package cs652;
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface HelloWorld extends Remote {
public String sayHello(String who) throws
RemoteException;
}
10
Implementing a remote
interface(cs652/HelloWorldImpl.java)
package cs652;
import java.rmi.Naming;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
public class HelloWorldImpl extends UnicastRemoteObject implements HelloWorld {
public HelloWorldImpl() throws RemoteException {
super();
}
public String sayHello(String who) throws RemoteException {
return "Hello "+who+" from your friend RMI 433-652 :-)";
}
public static void main(String[] args) {
String hostName = "localhost";
String serviceName = "HelloWorldService";
if(args.length == 2){
hostName = args[0];
serviceName = args[1];
}
try{
HelloWorld hello = new HelloWorldImpl();
Naming.rebind("rmi://"+hostName+"/"+serviceName, hello);
System.out.println("HelloWorld RMI Server is running...");
}catch(Exception e){}
}
}11
Generate Stubs and Start RMI registry
Compile
javac cs652/HelloWorld.java
javac cs652/HelloWorldImpl.java
Generate Stubs
rmic cs652.HelloWorldImpl
Start RMI registry
start rmiregistry (windows)
rmiregistry 10000 & (unix)
Start HelloWorld Server
java cs652.HelloWorldImpl
java cs652.HelloWorldImpl localhost:10000
HelloWorldService
12
Explanation: Client Side
RMI Registry RMI Service
Get
Lookup Service
Service Reference
Client
Invoke RMI Remote Object
Service
Look up the server registry
Based on the targeting object URL
Get the remote object reference from the Registry
Invoke the methods on the remote object reference
13
Client Side : A Simple Client
(cs652/RMIClient.java)
package cs652;
import java.rmi.Naming;
public class RMIClient {
public static void main(String[] args) {
String hostName = "localhost";
String serviceName = "HelloWorldService";
String who = "Raj";
if(args.length == 3){
hostName = args[0];
serviceName = args[1];
who = args[2];
}else if(args.length == 1){
who = args[0];
}
try{
HelloWorld hello = (HelloWorld)Naming.lookup("rmi://"+hostName+"/"+serviceName);
System.out.println(hello.sayHello(who));
}catch(Exception e){
e.printStackTrace();
}
}
}
14
Compile and Run
Compile
javac cs652/RMIClient.java
Run it
java cs652.RMIClient
java cs652.RMIClient localhost HelloWorldService
Raj
java cs652.RMIClient manjra.cs.mu.oz.au:10000
HelloWorldService Raj
15
Security Manager
Java’s security framework
java.security.-
Permissions, Principle, Domain etc.
Security manager, for access control (file, socket, class load,
remote code etc)
$JAVA_HOME/jre/lib/security/java.policy
Use security manager in RMI
RMI recommends to install a security manager, or RMI may not
work properly while encountering security constraints.
A security manager ensures that the operations performed by
downloaded code go through a set of security checks.
Eg. Connect and accept ports for RMI socket and allowing code
downloading
16
Security Manager (cont.)
Two ways to declare security manager
Use System property java.security.manager
java –Djava.security.manager cs652.HelloWorldImpl
Explicit declare in the source code
public static void main(String[]args){
//check current security manager
if(System.getSecurityManager()==null){
System.setSecurityManager(new RMISecurityManager());
}
…
//lookup remote object and invoke methods.
}
Use customized policy file instead of java.policy
Usage
java -Djava.security.manager -Djava.security.policy=local.policy
cs652.HelloWorldImpl
17
File: “local.policy” contents
Specific permissions:
grant {
permission java.net.SocketPermission "*:1024-65535","connect,accept";
permission java.io.FilePermission "/home/globus/RMITutorial/-", "read";
};
Grant all permissions:
grant {
permission java.security.AllPermission;
};
18
Exceptions
The only exception that could be thrown out is
RemoteException
All RMI remote methods have to throw this exception
The embedded exceptions could be:
java.net.UnknownHostException or
java.net.ConnectException: if the client can’t connect to the
server using the given hostname. Server may not be running
at the moment
java.rmi.UnmarshalException: if some classes not found.
This may because the codebase has not been properly set
Java.security.AccessControlException: if the security policy
file java.policy has not been properly configured
19
Passing objects
Restrictions on exchanging objects
Implementing java.io.serializable
All the fields in a serializable object must be also
serializable
Primitives are serializable
System related features (e.g. Thread, File) are non-
serializable
How about the socket programming issues?
Where are sockets and corresponding input, output
streams?
How to handle object passing?
Who does all the magic?
20
RMI Dynamic Class Loading
Ability to download bytecode (classes) from
Remote JVM
New types can be introduced into a remote
virtual machine without informing the client
Extend the behavior of an application dynamically
Removes the need to deploy stubs manually
Explicit set property to support dynamic class
load
Specify system property java.rmi.server.codebase
to tell the program where to download classes
21
Sample scenario : File Server
Unix File Server
Windows File Server
Mac File Server
User
File Server Scenario
Basic Requirements ( File Server )
Get the files from the File Server on specific directory
Create new files on the File Server
Create new directories on the File Server
Delete files or directory on the File Server
Client
A File Browser to explore the file system on the File Server
supporting view, create and delete functionalities.
22
Programming File Server
Create RMI remote interface
public interface FileServer extends Remote {
public Map getFiles(String baseDir) throws RemoteException;
public Map getFiles(String baseDir,boolean upper) throws RemoteException;
public void createFile(String filename,boolean isDir) throws RemoteException;
public void deleteFile(String filename) throws RemoteException;
}
Implement the Servant
FileServerImpl.java [FileServerImpl implements FileServer]
Implement the Server
public class RMIFileServer{
public static void main(String [] args){
try{
String host = "localhost";
if(args.length == 1){
host = args[0];
}
Naming.rebind("//"+host+"/FileServer",new FileServerImpl());
}catch(Exception e){}
}
}
Generate Stub
rmic –keep cs652.rmi.server.FileServerImpl (keep option is to keep the generated java file)
23
Programming File Browser
Create a Subclass of JFrame
RMIFileBrowser.java
Locate the FileServer Object
private FileServer findFileServer(String serviceURI)throws Exception{
return (FileServer)Naming.lookup("rmi://"+serviceURI);
}
Invoke the appropriate methods
Get Files : Map result = getFileServer().getFiles(dir,upper);
Create File: getFileServer().createFile(absoluteFilePath,false/*isDir=false*/);
Create Dir: getFileServer().createFile(absoluteFilePath,true/*isDir=true*/);
Delete File: getFileServer().deleteFile(absoluteFilePath);
Write a local policy file
Grant{
java.security.AllPermission;
};
24
Run it!
Two steps
Start the server
start rmiregistry (be aware of your classpath)
java cs652.rmi.server.RMIFileServer
Start the client
java -Djava.security.manager -Djava.security.policy=local.policy
cs652.demo.RMIFileBrowser
Note: Required classes including the generated stubs must be visible
by java classloader.
25
Potential error - no security manager!
26
Successful execution
27
Summary: RMI Programming
RMI greatly simplifies creation of distributed
applications (e.g., compare RMI code with socket-
based apps)
Server Side
Define interface that extend java.rmi.Remote
Servant class both implements the interface and extends
java.rmi.server.UnicastRemoteObject
Register the remote object into RMI registry
Ensure both rmiregistry and the server is running
Client Side
No restriction on client implementation, both thin and rich
client can be used. (Console, Swing, or Web client such as
servlet and JSP)
28
