Scribd Logo
Upload

Welcome to Scribd!

  • 49 views

    Java Remote Object Invocation (RMI)

    Uploaded by

    Ankit Kumar
    Java Remote Method Invocation (RMI) allows programmers to execute remote methods on a remote Java object similarly to local method calls. To develop an RMI application, developers define a remote interface, develop a remote object that implements the interface, generate stubs and skeletons, start the RMI registry, run the remote server, and execute calls from the client using the remote interface. The client looks up the remote object in the registry by name and then can invoke methods on it similarly to a local object.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PPT, PDF, TXT or read online from Scribd

    Java Remote Object Invocation (RMI)

    Uploaded by

    Ankit Kumar
    49 views13 pages
    Java Remote Method Invocation (RMI) allows programmers to execute remote methods on a remote Java object similarly to local method calls. To develop an RMI application, developers define a remote interface, develop a remote object that implements the interface, generate stubs and skeletons, start the RMI registry, run the remote server, and execute calls from the client using the remote interface. The client looks up the remote object in the registry by name and then can invoke methods on it similarly to a local object.

    Original Title

    JavaRMI

    Copyright

    © Attribution Non-Commercial (BY-NC)

    Available Formats

    PPT, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    Java Remote Method Invocation (RMI) allows programmers to execute remote methods on a remote Java object similarly to local method calls. To develop an RMI application, developers define a remote interface, develop a remote object that implements the interface, generate stubs and skeletons, start the RMI registry, run the remote server, and execute calls from the client using the remote interface. The client looks up the remote object in the registry by name and then can invoke methods on it similarly to a local object.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PPT, PDF, TXT or read online from Scribd
    Download as ppt, pdf, or txt
    49 views13 pages

    Java Remote Object Invocation (RMI)

    Uploaded by

    Ankit Kumar
    Java Remote Method Invocation (RMI) allows programmers to execute remote methods on a remote Java object similarly to local method calls. To develop an RMI application, developers define a remote interface, develop a remote object that implements the interface, generate stubs and skeletons, start the RMI registry, run the remote server, and execute calls from the client using the remote interface. The client looks up the remote object in the registry by name and then can invoke methods on it similarly to a local object.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PPT, PDF, TXT or read online from Scribd
    Download as ppt, pdf, or txt
    of 13

    Java Remote Object Invocation (RMI)

    • Overview of RMI
    • Java RMI allowed programmer to execute remote function
    class using the same semantics as local functions calls.
    Local Machine (Client) Remote Machine (Server)

    SampleServer remoteObject;
    int s;
    …

    s = remoteObject.sum(1,2);
    1,2
    public int sum(int a,int b)
    {
    3 }
    return a + b;

    System.out.println(s);
    The General RMI Architecture
    Remote Machine
    • The server must first bind
    bind
    its name to the registry RMI Server

    • The client lookup the server Registry


    name in the registry to skeleton

    establish remote references.


    • The Stub serializing the return call lookup

    parameters to skeleton, the


    skeleton invoking the stub
    remote method and
    serializing the result back to RMI Client
    the stub.
    Local Machine
    The Stub and Skeleton
    call

    skeleton
    Stub
    RMI Client RMI Server
    return

    • 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.
    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 b) throws 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.
    • The server uses the RMISecurityManager to protect its resources
    while engaging in remote communication.

    /* SampleServerImpl.java */
    import java.rmi.*;
    import java.rmi.server.*;
    import java.rmi.registry.*;

    public class SampleServerImpl extends UnicastRemoteObject


    implements SampleServer
    {
    SampleServerImpl() throws RemoteException
    {
    }
    Step 2: Develop the remote object and its interface
    • Implement the remote methods
    /* SampleServerImpl.java */
    public int sum(int a,int b) throws 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”.
    • In the main method of your server object, the RMI
    security manager is created and installed.
    Step 2: Develop the remote object and its interface
    /* SampleServerImpl.java */
    public static void main(String args[])
    {
    try
    {
    //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.
    Step 3: 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()); }
    }
    }
    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.

    ~/rmi> set CLASSPATH=”~/rmi”


    ~/rmi> javac SampleServer.java
    ~/rmi> javac SampleServerImpl.java
    ~/rmi> rmic SampleServerImpl

    ~/rmi> javac SampleClient.java


    Step 6: Start the RMI registry

    • The RMI applications need install to Registry. And the


    Registry must start manual by call rmiregisty.
    • The rmiregistry us uses port 1099 by default. You
    can also bind rmiregistry to a different port by indicating
    the new port number as : rmiregistry <new port>

    ~/rmi> rmiregistry

    • Remark: On Windows, you have to type in from the


    command line:
    > start rmiregistry
    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.
    • Because of the grained security model in Java 2.0, you
    must setup a security policy for RMI by set
    java.security.policy to the file policy.all

    ~/rmi> java –Djava.security.policy=policy.all


    SampleServerImpl

    ~/rmi> java –Djava.security.policy=policy.all


    SampleClient

    You might also like