Get the online training        

Get Best Tutorial on all major programing language

Corejava Servlet Jsp  Php  Hibernate  Ajax Web Service   Ejb2.1 Ejb3.0 Struts Struts2  JPA Spring Ibatis   JSF    JSF2.0  CoreJavaDesignPattern    Jquery  Flex J2EE-Design-Patterns  Jboss7  Maven  Contact Me                                                                                                                                                                        
            IGNOU SMU PTU Project                                           Training                                                                                                                              

Contact Us  0091- 9210721663         jaiswaltraining@gmail.com

Web Service

Java Remote Object Invocation (RMI)

  • Java RMI is a mechanism that allows a Java program running on one computer
    to apply a method to an object living on a different computer.
Need For RMI
  • An Application comprised of smaller applications spread across
    different locations in a network.
  • For Using the processing power of multiple computers.
  • Sharing resources and processing load across systems.
RMI's Purpose
  • To make objects in separate JVMs look and act like local objects 
  • One of the most important aspect of RMI design is its transparency,
    where  Applications do not know whether an object is remote or local.
  • A Remote object is always accessed via its remote Interface. 
  • In other words the client invokes methods on the object only after casting
    the reference to the remote interface.
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.
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.

  • Stub is the client side object that represents or acts as a proxy for the remote object.
  •  The stub has the list of methods, as the remote object.
Sequence of tasks performed by a stub:
  •  Initiates a connection with the remote VM containing the actual remote object.
  •  Marshals the parameters to the remove VM.
  •  Waits for the result of method invocation.
  •  Unmarshals the return value or exception returned
  •  Returns the value to the caller.
  • On the server side, the skeleton object takes care of all of the details of “Remoteness”
    so that the remote object doesn't need ot worry about them.
  • In other words, You can pretty much code a remote object the same way as if it were local.
Sequence of tasks performed by a skeleton
  • Unmarshals the parameters for the remote method.
  • Invokes the method on the actual remote object implementation
  • Marshals the result or exception to the caller.

Remote Interface
  • java.rmi.Remote – A marker –
  • It is  used to mark object as being remote.
    • Remote Interface must be declared public.
    • It must extend the java.rmi.Remote Interface.
    • Each method in the Interface has to throw java.rmi.RemoteException.
Steps for Developing an RMI System
  1. Define the remote interface
  2. Develop the remote object by implementing the remote interface.
  3. Develop the client program.
  4. Compile the Java source files.
  5. Generate the client stubs and server skeletons.
  6. Start the RMI registry.
  7. Start the remote server objects.
  8. Run the client
Step 1:  Defining the Remote Interface
  • To create an RMI application, the first step is the defining of a remote interface
    between the client and server objects
/* SampleServer.java */
import java.rmi.*;

public interface SampleServer extends Remote
  public int sum(int a,int bthrows RemoteException;

Step 2: Develop the remote object and its interface
  • The server is a simple unicast remote server. 
  • Create server by extending java.rmi.server.UnicastRemoteObject
/* SampleServerImpl.java */
import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;

public class SampleServerImpl extends UnicastRemoteObject
                             implements SampleServer
  SampleServerImpl() throws RemoteException

  • Implement the remote methods
/* SampleServerImpl.java */
  public int sum(int a,int bthrows RemoteException
     return a + b;
  • The server must bind its name to the registry, the client will look up the server name.
  • Use java.rmi.Naming class to bind the server name to registry.
  • In this example the name call “SAMPLE-SERVER”.
/* RemoteServer.java */
import java.rmi.*;
import java.rmi.server.*;
import java.rmi.registry.*;

public class RemoteServer

  public static void main(String args[])
        //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());  }

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.
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
          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());

Step 4 & 5: Compile the Java source files & Generate the client stubs and server skeletons
  • Once the interface is completed, you need to generate stubs and skeleton code.
  • The RMI system provides an RMI compiler (rmic) that takes your generated interface
    class and procedures stub code on its self.

javac SampleServer.java
javac SampleServerImpl.java
javac RemoteServer.java
rmic SampleServerImpl
javac SampleClient.java
  • Copy the Stub and Interface class files to the client folder
Step 6: Start the RMI registry
  • The RMI applications need install to Registry.
  • And the Registry must start manually by calling rmiregisty.
  • The rmiregistry uses port 1099 by default.
  • You can also bind rmiregistry to a different port by indicating the new
    port number as : rmiregistry <new port>
Steps 7 & 8: Start the remote server objects & Run the client
  • Once the Registry is started, the server can be started and will be able to store itself in the Registry. 
  • Before starting the server set the classpath variable to the path where your server is located.
  • Now Run the server and server will be started
  • Now run client and you will see it will calculate the sum from the remote server object

Download code