Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd Logo
Upload

Welcome to Scribd!

  • 52 views

    An Overview of RMI Applications: Distributed Object Application

    Uploaded by

    Sanjay Jain
    This document discusses Java RMI (Remote Method Invocation) and how to implement RMI applications in Java. It explains that RMI allows methods to be invoked on different Java Virtual Machines. Typical RMI applications have a client and server program, where the server creates remote objects and the client invokes methods on those objects. It also describes the entities involved - the client, server, and object registry, and provides code examples for the remote interface, implementing class, registry, and client program.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd

    An Overview of RMI Applications: Distributed Object Application

    Uploaded by

    Sanjay Jain
    52 views5 pages
    This document discusses Java RMI (Remote Method Invocation) and how to implement RMI applications in Java. It explains that RMI allows methods to be invoked on different Java Virtual Machines. Typical RMI applications have a client and server program, where the server creates remote objects and the client invokes methods on those objects. It also describes the entities involved - the client, server, and object registry, and provides code examples for the remote interface, implementing class, registry, and client program.

    Original Description:

    Java RMI

    Original Title

    Rmi

    Copyright

    © © All Rights Reserved

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    This document discusses Java RMI (Remote Method Invocation) and how to implement RMI applications in Java. It explains that RMI allows methods to be invoked on different Java Virtual Machines. Typical RMI applications have a client and server program, where the server creates remote objects and the client invokes methods on those objects. It also describes the entities involved - the client, server, and object registry, and provides code examples for the remote interface, implementing class, registry, and client program.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    52 views5 pages

    An Overview of RMI Applications: Distributed Object Application

    Uploaded by

    Sanjay Jain
    This document discusses Java RMI (Remote Method Invocation) and how to implement RMI applications in Java. It explains that RMI allows methods to be invoked on different Java Virtual Machines. Typical RMI applications have a client and server program, where the server creates remote objects and the client invokes methods on those objects. It also describes the entities involved - the client, server, and object registry, and provides code examples for the remote interface, implementing class, registry, and client program.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    of 5

    An Overview of RMI Applications

    Java RMI is a mechanism to allow the invocation of methods that reside on different
    Java Virtual Machines (JVMs). The JVMs may be on different machines or they
    could be on the same machine. In either case, the method runs in a different address
    space than the calling process.

    Java RMI is an object-oriented remote procedure call mechanism.

    ∙​ RMI applications often comprise two separate programs, a server and a client.

    ∙​ A typical server program creates some remote objects, makes references to these
    objects accessible, and waits for clients to invoke methods on these objects.

    ∙​ A typical client program obtains a remote reference to one or more remote objects
    on a server and then invokes methods on them.

    ∙​ RMI provides the mechanism by which the server and the client communicate and
    pass information back and forth. Such an application is sometimes referred to as a
    distributed object application​.

    There are three entities involved in running a program that uses RMI:

    Client​: this is the program that you write to access remote methods

    Server​: this is the program that you write to implement the remote methods - clients
    connect to the server and request that a method be executed. The remote methods to
    the client are local methods to the server.

    Object registry​: this is a program that you use.


    The object registry runs on a known port (1099 by default)
    A server, upon starting, registers its objects with a textual name with the object
    registry.
    A client, before performing invoking a remote method, must first contact the
    object registry to obtain access to the remote object.

    To Implemet RMI In Java One can Create Following Programs:


    1)​ ​Remote Interface​: This program contains all the abstract methods which called by
    clinet remotely.This program use interface instead of class which extends the
    java.rmi.Remote​ interface which contains all remote features. ​Any method that can be
    remotely invoked in Java/RMI may throw a ​java.rmi.RemoteException​.
    java.rmi.RemoteException​ is the superclass of many more RMI specific exception
    classes.
    Program: serverinterface.java

    import java.rmi.*;
    public interface serverinterface extends Remote
    {
    int getAmount(int qty) throws RemoteException;

    }
    2) ​Impementing Remote interface​:in second program all abstract method which
    declared in interfaces are implemented in class. All methods which implement in class
    must throws java.rmi.RemoteException.
    This class must extends UnicastRemoteObject class to acquire the properties and
    behavior of Remote Object. The UnicastRemoteObject subclass exports the remote
    object to make it available for servicing incoming RMI calls.
    Program: serverclass.java

    import java.rmi.*;
    import java.rmi.server.*;
    public class serverclass extends UnicastRemoteObject implements serverinterface
    { private int rate;
    public serverclass(int r) throws RemoteException
    { rate=r;}
    public int getAmount(int qty)throws RemoteException
    { return(rate*qty);
    }
    }
    3) Client Registry: This program is use to register client by binding their names. To
    binding name one can use Naming.rebind() method, each client name bind with
    RemoteObjects which is further search by client machine using method Naming.lookup()
    which returns reference of Remote object to client machine to call remote methods.
    Program:clientregistry.java

    import java.rmi.*;
    public class clientregistry
    { public static void main(String arg[])
    { try
    { serverclass objsony=new serverclass(9000);
    serverclass objlg=new serverclass(8999);
    Naming.rebind("SONY",objsony);
    Naming.rebind("LG",objlg);
    ​​ }
    catch(Exception e)
    {System.out.println(e); } }}

    4)​ ​Client Program: This program Calls the Remote Method.


    Program:client.java
    import java.rmi.*;
    public class client
    { public static void main(String arg[])
    { try
    { String serurl="rmi://192.168.1.2/SONY";
    serverinterface i=(serverinterface)Naming.lookup(serurl);
    int amt=i.getAmount(4);
    System.out.println("Amount is:"+amt); }
    catch(Exception e)
    {System.out.println(e); } }}

    To run the above program follow the following instruction.


    ∙​ ​Compile All Programs
    ∙​ ​Create a Stub using rmi compiler
    rmic serverclass
    this will create stub class name serverclass_stub.class which is further
    use to establish communication between client and server.
    ∙​ ​Start RMI server
    rmiregistry
    ∙​ ​Register the clients on server
    Java clientregistry
    ∙​ ​Run client program to invoke server methods
    Java client
    How remoting works
    To invoke a remote method, the client makes a call to the client proxy. The client side proxy
    packs the call parameters into a request message and invokes a wire protocol JRMP(in
    Java/RMI) to ship the message to the server. At the server side, the wire protocol delivers
    the message to the server side stub. The server side stub then unpacks the message and
    calls the actual method on the object Java/RMI, the client stub is called the ​stub​ or ​proxy
    and the server stub is called ​skeleton​.

    Application of RMI:-
    RMI applications are often comprised of two separate programs: a server and a
    client. A typical server application creates some remote objects, makes references
    to them accessible, and waits for clients to invoke methods on these remote
    objects. A typical client application gets a remote reference to one or more remote
    objects in the server and then invokes methods on them. RMI provides the
    mechanism by which the server and the client communicate and pass information
    back and forth. Such an application is sometimes referred to as a​ ​distributed object
    application.​
    Distributed object applications need to
    ∙​ ​Locate remote objects:​ Applications can use one of two mechanisms to
    obtain references to remote objects. An application can register its remote
    objects with RMI's simple naming facility, the​ ​rmiregistry​, or the application
    can pass and return remote object references as part of its normal operation.
    ∙​ ​Communicate with remote objects​: Details of communication between
    remote objects are handled by RMI; to the programmer, remote
    communication looks like a standard Java method invocation.
    ∙​ ​Load class bytecodes for objects that are passed around​: Because RMI
    allows a caller to pass objects to remote objects, RMI provides the necessary
    mechanisms for loading an object's code, as well as for transmitting its data.
    The following illustration depicts an RMI distributed application that uses the
    registry to obtain a reference to a remote object. The server calls the registry to
    associate (or bind) a name with a remote object. The client looks up the remote
    object by its name in the server's registry and then invokes a method on it. The
    illustration also shows that the RMI system uses an existing Web server to load
    class bytecodes, from server to client and from client to server, for objects when
    needed.

    You might also like