Advanced Java Unit 4 RMI

1
Advanced JavaUnit 4RMI

• CMSC 291
• Shon Vick

2
Agenda

• Present some ideas about distributed computing
• Briefly look at CORBA and contrast it with RMI
• Look at the Java mechanism for Remote Method
  Invocation (RMI)
• See some examples

3
Overview of RMI Applications

• Pure Java answer to RPC, DCOM, and CORBA
• CORBA allows object on different machines to
  communicate
• RMI allows objects on different JVMs potentially
  on different machines to communicate

4
CORBA

• The Common Object Request Brokering System
  (CORBA) glues together diferent objects models
  regardless of implementation language
• In order to do so it uses a common interface
  definition language that needs to be compiled
  separately for every language for which there is
  a binding

5
Introduction to CORBA

• So what is an object (class, interface) in the
  CORBA sense?
• Collection of data items usually called
  attributes or slots
• Collection of behavioral attachments usually
  called methods

6
What Is Distributed Computing All About

• Goal is to break up a monolithic application into
  smaller components
• Client - user of a resource
• Server - provider of a resource

Request
Client
Server
Response
7
Technical Overview of Architecture

• The client and object implementation are isolated
  from the ORB by an IDL interface
• CORBA requires that objects be defined by OMG
  IDL
• A method request does not pass directly from
  client to server but rather is mediated by the
  ORB
• Method invocation is the same whether the object
  is local or remote

8
CORBA Interfaces

• IDL - interface definition language
• CORBA is language independent
• Can provide a standard notation for software
  components
• IDL supports library function interfaces just as
  well as distributed objects across a network

C
IDL
Client
ORB
9
IDL - Separating Interface From Implementation

• A standard notation language for defining
  interfaces to objects
• OMG IDL is a simple subset of C
• IDL is like a contract for defining an API
• Designed to be efficient across networks

10
Role of IDL
Client Side
Object Implementation Side
COBOL
C
I D L
I D L
I D L
I D L
COBOL
Ada
I D L
I D L
ORB
I D L
I D L
Small talk
I D L
I D L
I D L
I D L
Small talk
C
C
JAVA
JAVA
11
How the IDL is Used
IDL
IDL Compiler
Object Impl Code
Client Code
Skeleton Code
Stub Code
Language Compiler and Linker
Client
Object
Stub
Skel
ORB
12
Programming Steps

• Define the IDL interfaces
• Implement these interfaces with C classes
• Write a client mainline to bind to server
• Write a server mainline which creates instances
  of the classes
• Register the server

13
Comparison of RMI and CORBA

• RMI is Java to Java based
• JNI allows Java to other languages
• No mapping of objects no IDL
• RMI deals only with byte code
• No complicated request broker - just a simple
  registry
• Makes a distinction for a remote object -allows
  errors to be handled

14
RMI

• An Overview of RMI Applications
• Looking at a Simple Example
• Walking through a RMI Server
• Walking through a Client Program
• Running the applications
• Next time
• Additional Examples
• Reviewing Some More Examples

15
An Overview of RMI Applications

• Two Parts to a RMI based distributed object
  application
• Server
• creates remote objects
• makes them available to client
• waits for clients to invoke methods these remote
  objects
• Client
• Use the references to the remote Objects

16
RMI Distributed Object Applications

• Locate remote objects
• Communicate with remote objects
• Load class bytecodes for objects that are passed
  around

17
Locating Remote Objects

• Applications can use one of two mechanisms to
  obtain references to remote objects.
• An application can register its remote objects
  with the rmiregistry - RMI's simple naming
  facility
• An application can pass and return remote object
  references as part of its normal operation

18
Communicating with Remote Objects

• Details of communication between remote objects
  are handled by RMI
• From the perspective of the programmer its as if
  the objects are local
• There is some overhead that makes it slower but
  the communication looks like a standard Java
  method invocation

19
Loading the Class

• The types and the behavior of an object,
  previously available only in a single virtual
  machine can be transmitted to another, possibly
  remote, virtual machine.
• Contrast with the reading and writing of objects
  that we have discussed in the previous units

20
Remote Interfaces, Objects and Methods

• A distributed application built using Java RMI is
  made up of interfaces and classes
• An object becomes remote by implementing a remote
  interface, which has the following
  characteristics
• A remote interface extends the interface
  java.rmi.Remote.
• Each method of the interface declares
  java.rmi.RemoteException in its throws clause, in
  addition to any application-specific exceptions.

21
Remote Objects

• RMI treats a remote object differently from a non
  remote object when the object is passed from one
  virtual machine to another.
• Rather than making a copy of the implementation
  object in the receiving virtual machine, RMI
  passes a remote stub for a remote object.
• The stub acts as a proxy for the remote object
  and is basically a remote reference.
• The caller invokes a method on the local stub,
  which is responsible for carrying out the method
  call on the remote object.

22
Layers
Client
Server
Stub
Skeleton
Remote Reference Layer
Transport Layer
23
What happens Where?

• Layer 1 is the Application Layer
• Layer 2 is the client stub/skeleton layer. These
  are the proxy objects these are produced by the
  rmic command
• Layer 3 is the remote reference that deals with
  the the actual remote invocations
• Layer 4 is the transport layer responsible for
  actually setting up the connections and handling
  the transport of data between machines

24
Using Remote Objects

• A stub for a remote object implements the same
  set of remote interfaces that the remote object
  implements
• This allows a stub to be cast to any of the
  interfaces that the remote object implements
• Only those methods defined in a remote interface
  are available to be called in the receiving
  virtual machine.

25
Using RMI General Steps

• Design and implement the components of your
  distributed application.
• Compile sources and generate stubs and skeletons
• Make classes network accessible
• Start the application.

26
Design and Implement the Application Components

• Defining the remote interfaces
• Implementing the remote objects
• Implementing the clients

27
Compile Sources and Generate Stubs

• This is a two-step process.
• In the first step you use the javac compiler to
  compile the source files containing the
  implementation of the remote interfaces and
  implementations, the server classes, and the
  client classes.
• In the second step you use the rmic compiler to
  create stubs for the remote objects. RMI uses a
  remote object's stub class as a proxy in clients
  so that clients can communicate with a particular
  remote object.

28
Make Classes Network Accessible/ Starting

• In this step you make everything--the class files
  associated with the remote interfaces, stubs, and
  other classes that need to be downloaded to
  clients--accessible via a Web server
• Starting the application includes running the RMI
  remote object registry, the server, and the
  client.

29
The Four Required Classes

• To use RMI you need to build man classes
• An interface for the remote object to be used by
  both the client and the server
• The RMI client which looks up the object on a
  remote machine, cast it to the needed type of the
  interface given in the step 1
• The object implementation implements the
  interface of step 1
• The RMI server which creates an instance of the
  object from step 3

30
Steps for Compiling and Running the System

1. Compile the client and the server
2. Generate the client stub using rmic
3. Start the RMI registry this only needs to be
   done once
4. Start the the server done on same machine as
   in step 3
5. Start the client this doesnt have to be on the
   same machine as 3 and 4

31
A Simple Example

• In this example the remote object just returns a
  message string
• The interface
• The client
• The Remote Object Implementation
• The RMI Server

32
The interface
import java.rmi.   / The RMI client will use
this interface directly. The RMI server will
make a real remote object that implements
this, then register an instance of it with
some URL. /   public interface Rem extends
Remote public String getMessage() throws
RemoteException
33
The RMI Client

• Looks up the object from the appropriate host
  using Naming.lookup
• Casts it to the appropriate type then uses it
  like a local object
• Unlike CORBA RMI has to know the host that is
  providing the remote services
• uses URL of the form rmi//host/path or rmi
  rmi//hostport/path
• the default port is 1099

34
The RMI Client

• A number of exceptions must be caught
• RemoteException
• NotBoundException
• MalformedURLException
• Requires java.rmi for RemoteException as well
  Naming and and NotBound Exception
• Requires java.net for MalformedURLException as we
  have already seen
• Many Clients will pass Serializable objects to
  the remote objects so importing java.io is
  usually done as well not needed here however

35
The Client Code

• Import the needed Packages

import java.rmi. // For Naming,
RemoteException, etc. import java.net. // For
MalformedURLException import java.io. //
For Serializable interface
36
The Client Code Body

• public class RemClient
• public static void main(String args)
• try
• String host (args.length gt 0) ? args0
  "localhost"
• // Get the remote object and store it in
  remObject
• Rem remObject
• (Rem)Naming.lookup("rmi//" host
  "/Rem")
• // Call methods in remObject
• System.out.println(remObject.getMessage())
• //catch the exceptions

Can now use like a local object
37
Catching the Exceptions in the Client

• try
• //
• catch(RemoteException re)
• System.out.println("RemoteException "
  re)
• catch(NotBoundException nbe)
• System.out.println("NotBoundException "
  nbe)
• catch(MalformedURLException mfe)
• System.out.println("MalformedURLException
  "
• mfe)
• //

38
The Remote Object Implementation

• This class must extend UnicastRemoteObject and
  implement the interface discussed previously
• The constructor show throw a RemoteException

39
The Remote Object
import java.rmi. import java.rmi.server.UnicastR
emoteObject public class RemImpl extends
UnicastRemoteObject
implements Rem public RemImpl() throws
RemoteException   public String getMessage()
throws RemoteException return("Here is a
remote message.")
40
The RemImpl Object

• This is the actual implementation of Rem that the
  RMI server uses.
• The server builds an instance of this then
  registers it with a URL
• The client accesses the URL and binds the result
  to Rem (not a RemImpl it doesn't have this).

41
The RMI Server

• Builds an object and registers it with a
  particular URL using Naming.rebind to replace any
  other bindings or Naming.bind which throws a
  AlreadyBoundException if there is a previous
  binding
• Bind really means register here
• You have to catch RemoteException and
  URLMalformedException

42
RemServer
mport java.rmi. import java.net.   public
class RemServer public static void
main(String args) try RemImpl
localObject new RemImpl()
Naming.rebind("rmi///Rem", localObject)
catch(RemoteException re)
System.out.println("RemoteException " re)
catch(MalformedURLException mfe)
System.out.println("MalformedURLException "
mfe)
Makes an Object
Registers an Object
43
Putting it all Together

• Compile the Client and the Server
• javac RemClient.java RemServer.java
• Generate the Client Stub and Server Skeleton
• rmic RemImpl
• Starts the RMI registry
• Rmiregistry
• Start the server Start the
  client
• java RemServer java RemClient

44
Next Unit

• RMI/CORBA Issues
• More Examples
• Start Chapter 11 - Threads

45
Next Time

• Study Chapter 7 and review Example
• Homework posted Monday AM
• Read Chapter 11 - Threads

46
Selected References

• Advanced Techniques for Java Developers Chapter
  6,7
• http//java.sun.com/docs/books/tutorial/rmi/index.
  html
• Exploring Java, OReilly, Niemeyer Peck
• Java RMI Remote Method Invocation, Troy Downing,
  IDG Books
• The RMI example comes from Core Web Programming,
  Marty Hall, Prentice Hall