Docstoc

Java RMI_ JAX-RPC and JWSDP

Document Sample
Java RMI_ JAX-RPC and JWSDP Powered By Docstoc
					Java RMI, JAX-RPC and
       JWSDP
     B. Ramamurthy




                        1
                 Inside RMI
• http://java.sun.com/j2se/1.5.0/docs/index.html
• Basic RMI classes: /usr/java1.1/src/java/rmi
  – java.rmi.registry.*
  – java.rmi.Naming class (static/class methods)
  – java.rmi.Remote interface (marker interface)
  – java.rmi.server.*
  – Default RMI port 1099
  – Both lookup from local and remote are
    acceptable.
                                                   2
Implementation of RMI (5.2.5)




                                3
  The role of proxy and skeleton
   in remote method invocation
         client                                         server
                                                                  remote
 object A proxy for B                               skeleton      object B
                            Request               & dispatcher
                                                  for B’s class

                             Reply

                                                                servant
    Remote Communication             CommunicationRemote reference
reference module module               module         module


 Object A invokes a remote object in Object B for which it holds a remote object
 reference.
 “System Model”
                                                                               4
 RMI Internals: Communication
            Module
• Carries out request-reply protocol;
• On the client side {message type, message id,
  remote reference to object} are gathered and
  sent out. At most once invocation semantics;
• On the server side, it gets local reference for
  remote reference from remote reference
  module, invokes a dispatcher with this reference.
• See UnicastRemote (implements
  UnicastRemote)


                                                  5
       RMi Internals: Remote
        Reference module
• Responsible for translating between local
  and remote object references and for
  creating remote object references.
• A remote object table has a mapping
  between local and remote references. A
  table at server (entry for object ref for B)
  and a table at client (entry for object ref for
  proxy B).

                                                6
       RMI Internals: Remote
            References
• Action of remote reference module: See
  RemoteRef.java interface
  – When a remote object is to be passed as argument or
    result for the first time, the remote ref is asked to
    create a remote ref object which is added to the table.
  – When a remote object reference arrives in a request
    or reply, the remote ref module is asked for
    corresponding local object ref, which may either a
    proxy or remote object. If it is not in the table RMI
    runtime creates it and asks remote ref module to add
    it to the table.


                                                          7
    RMI Internals: RMI software
•   Layer of software between application level objects and communication and
    remote reference modules: “Middleware”
•   Proxy: provides remote access transparency. One proxy for every remote
    object in the client.
•   Dispatcher: A server has one dispatcher and skeleton for each class
    representing a remote object.
     – It receives request message from comm. Module
     – It used MessageId to select appropriate method in skeleton.
     – Proxy and dispatcher use same MessageId.
•   Skeleton: A class of remote object has a skeleton that implements of the
    remote interface. All the access dependencies are hidden in this class. A
    remote object has a servant that directly implements the methods. Java 5
    creates this dynamically.
•   Proxies, dispatcher and skeleton are automatically generated by interface
    compiler.
•   Binder: binds textual names to remote object references. RMiRegistry is a
    binder; Naming class; see fig.5.13
•   Server Threads: one thread per invocation
•   Distributed garbage collection: See Andrew Birell’s paper [1995].

                                                                                8
         RMI Internals: Distributed
           Garbage Collection
•   Based on reference counts.
•   Local garbage collectors and a distributed support.
•   Each server holds the list of processes that hold remote object references: for
    example, B.Holders
•   When a client C first receives a remote reference to a particular remote object, say B,
    it makes a addRef(B) invocation to server of that remote object and then creates
    proxy; server adds C to B.Holders.
•   When client C’s garbage collector finds that proxy is no longer reachable (ref count),
    it makes a removeRef(B) invocation to server and then deletes proxy; the server
    removes C from B.Holders.
•   When B.Holders is empty, server’s local garbage collector will reclaim the space
    occupied B unless there are any local holders.
•   These extra calls for updates occur during proxy creation and deletion and do not
    affect normal opertion.
•   Tolerates communication failures: addRef() and removeRef() are idempotent: effects
    of N > 0 identical requests is the same as for a single request.
•   If addRef() fails with an exception, proxy is not created, removeRef() is transmitted;
    removeRef() failures are dealt with by “leases” (Jini kind).



                                                                                          9
RMI Internals: Use of Reflection
• What is reflection? See Reflection package
• Reflection enables Java code to discover
  information about the fields, methods and
  constructors of loaded classes, and
• To use reflected fields, methods, and
  constructors to operate on their underlying
  counterparts on objects, within security
  restrictions.
http://java.sun.com/docs/books/tutorial/reflect/class/index.html
• Reflection feature allowed for dynamic creation of skeleton and
   proxy in Java 2 version onwards.
• Skeleton has been deprecated since JDk1.4.x
• Read more about reflection model of computing.

                                                                    10
      A Little bit of Reflection
• Method class, invoke method
• Invoke method requires two parameters:
  first the object to receive invocation,
  second an array of Object parameters.
• Invoke executes the method on the object
  and returns result as Object.
• Method m;
• Object result = m.invoke(String, Args);
                                             11
        Using Reflection in RMI
• Proxy has to marshal info. about a method and its
  arguments into a request message.
• For a method it marshals an object of class Method into
  the request. It then adds an array of objects for the
  method’s arguments.
• The dispatcher unmarshals the Method object and its
  arguments from request message.
• The remote object reference is obtained from remote ref.
  table.
• The dispatcher then calls the “invoke” method on the
  object reference and array of arguments values.
• After the method execution the dispatcher marshals the
  result or any exceptions into the reply message.

                                                         12
         Putting it all together
Server side:
 Write a an interface and implement it.
    Implements Remote,
 Inside code publishes the object by (exporting
    to runtime) and by registering it.
Client Side:
 Code: look up server object name from the
    registry {host,port};
 Invoke opertions.
                                                   13
     Lifecycle of a remote call
1. First time, an operation is invoked, remote
   object reference is obtained from remote
   registry, addRef() is sent to remote server, an
   entry made in the local ref table and proxy is
   created.
2. Proxy has message ids while the client’s ref
   table has remote object reference.
3. Remote ref, method id and arguments are
   marshaled into a message and sent across via
   the communication module.

                                                 14
 Lifecycle of a remote call (contd.)
• On the server side RMI runtime maps the
  remote reference to a local object.
• Unmarshalls the operation and parameters and
  uses reflection to “invoke” the method on the
  object reference.
• The result is marshaled back into the response
  and sent back to the caller.
• “Skeleton” that includes the “dispatch” is
  subsumed into the RMI runtime in the latest
  versions of Java.

                                                   15
 Critique of RMI (Sun Java’s) /RPC
             (Microsoft’s)
• Performs very well for single-platform limited distributed
  system.
• Platform dependent
• Tightly coupled
• Inherently synchronous (No chance for eventing or
  notification)
• Object-oriented: Objects not deployable units
• Non-standard
• Not scalable, location dependent, no global
  registry/discovery
• Object reference passed as parameter and/or returned
  as result.

                                                               16
                    Web Services
• Web Services is a technology that allows for applications to
  communicate with each other in a standard format.
• A Web Service exposes an interface that can be accessed through
  messaging.
• Deployable unit.
• A Web service uses protocol to describe an operation and the data
  exchange with another web service. Ex: SOAP
• Platform independent, say, through WSDL.
• Publishable, discoverable, searchable, queryable
• Scalability issues: A group of web services collaborating accomplish
  the tasks of a large-scale application. The architecture of such an
  application is called Service-Oriented Architecture (SOA).




                                                                    17
A Little bit of History: XML to SOAP
• Simple xml can facilitate sending message
  to receive information.
• The message could be operations to be
  performed on objects.
• Standardize the tags for object access.
• Simple Object Access Protocol (SOAP).



                                          18
SOAP Request (Not WS request)
<soap:Envelope
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
   <getProductDetails xmlns="http://warehouse.example.com/ws">
     <productId>827635</productId>
   </getProductDetails>
  </soap:Body>
 </soap:Envelope>




                                                           19
                   SOAP Reply
<soap:Envelope
xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
  <soap:Body>
    <getProductDetailsResponse
xmlns="http://warehouse.example.com/ws">
     <getProductDetailsResult>
      <productName>Toptimate 3-Piece Set</productName>
      <productId>827635</productId>
      <description>3-Piece luggage set. Black
Polyester.</description>
      <price>96.50</price>
      <inStock>true</inStock>
     </getProductDetailsResult>
    </getProductDetailsResponse>
  </soap:Body>
 </soap:Envelope>                                         20
  SOAPWeb Services (WS)
Take a look at

1. http://www.w3.org/DesignIssues/WebServices.html
2. O’Reilly book on Web Services: Kim Topley’s
   Webservices in a Nutshell:
   http://www.oreilly.com/catalog/javawsian/index.html
   This link has a sample chapter (SAAJ) and zip of all
   examples in the book.




                                                          21
    Web Services (Colouris)
• A web service provides a service interface
  enabling clients to interact with servers in a
  more general way than web browsers do.
• Clients access operations in the interface
  usually by XML messages over http.
• However other architectural models such as
  REST and CORBA could access WS.
• WSDL provides additional details than for
  standard operation: for encoding, security,
  communication and location.
                                                   22
Web services infrastructure and
        components

    Applications
                            Directory
                                        Security   Choreography
                            service

             Web Services        Service descriptions (in WSDL)

                            SOAP

 URIs (URLs or URNs)   XML       HTTP, SMTP or other transport



                                                                  23
SOAP message in an envelope
 envelope

     header

              header element   header element




     body
              body element     body element




                                                24
  Example of a simple request
      without headers
env:envelope      xmlns:env =namespace URI for SOAP envelopes
    env:body

        m:exchange
        xmlns:m = namespace URI of the service description
               m:arg1               m:arg2
                  Hello               World




  In this figure and the next, each XML element is represented by a
  shaded box with its name in italic followed by any attributes and its
  content

                                                                      25
             Example of a reply
   corresponding to the request
env:envelope   xmlns:env = in
                           namespace URI for SOAP envelope
    env:body
         m:exchangeResponse
         xmlns:m = namespace URI for the service description
               m:res1           m:res2
                 World            Hello




                                                               26
Use of HTTP POST Request in
            SOAP client-server
                 communication
POST /examples/stringer endpoint address




                                                                   header
                                                                   HTTP
Host: www.cdk4.net
Content-Type: application/soap+xml
Action: http://www.cdk4.net/examples/stringer#exchange    action

<env:envelope xmlns:env=                     >
                        namespace URI for SOAP envelope
<env:header> </env:header>
<env:body> </env:body>
</env:Envelope>




                                                                      27
   Services, ports and bindings
• Service endpoint interface (SEI) or service
  endpoint that defines one or more operations
  that the web service offers.
• Access to an endpoint is provided by binding it
  to a protocol stack through a port.
   – A port has an address that the client can use to
     communicate with the service and invoke its
     operations.
• An endpoint can be bound to different ports
  each offering a different suite of protocols for
  interaction.
                                                        28
  Endpoint, Port and binding
   Web service

                     endpoint



 Port1              port2           port3


SOAP1.1     SOAP 1.1 over                                     Web services Client
                                Other. Ex:
Over http   https               ebXML over
                                SMTP



                                        https 1.1 transport
                                        soap1.1 messages




                                                                                    29
WS Interoperability Infrastructure


WSDL     Service Description



SOAP       XML Messaging



HTTP          Network



                                     30
                  JAX-RPC
• JAX-RPC (The Java API for XML-based RPC) is
  designed to provide a simple way for developers to
  create Web services server and Web services client.
• Based on remote procedure calls; so the
  programming model is familiar to Java developers
  who have used RMI or CORBA.
• Major difference between RMI and JAX-RPC is that
  messages exchanged are encoded in XML based
  protocol and can be carried over a variety of transport
  protocols such as HTTP, SMTP etc.
• You can use JAX-RPC without having to be an expert
  in XML, SOAP, or HTTP.

                                                        31
    The JAX-RPC Programming
             Model
• Services, ports and bindings
• JAX-RPC web service servers and clients
• JAX-RPC service creation
• JAX-RPC client and server programming
  environments
• Stubs and ties
• Client invocation modes
• Static and dynamic stubs and invocation

                                            32
            JAX-RPC Runtime

     Client Appl.                    Server Impl.

        Stub                             Ties

      JAX-RPC                          JAX-RPC
       Runtime                          Runtime
                      SOAP over HTTP


Read the semantics of exchanges in your text book pages 798, 799:
You will observe very similar semantics for stub and ties
as proxy and skeleton in RMI. Exception: no object ref is passed but
request, response go through XML format and are extracted and dispatched.



                                                                     33
                        Stubs and Ties
•   Client Side: Stub object has the same methods as the service
    implementation class.
     – Client application is linked with the stub.
     – When it invokes a method stub delegates the call to the JAX-RPC runtime so
       that appropriate SOAP message can be sent to the server.
     – On completion the result return back in the reverse path as above.
•   Server side:
     – Message received must be converted into a method call on actual service
       implementation. This functionality is provided by another piece of glue called tie.
     – Tie extracts method name and parameter from SOAP message.
     – Tie also converts the result of the method call back into a response message to
       be returned to client JAX-RPC runtime.
JAX-RPC comes with tools to generate these.




                                                                                         34
       Web Service Clients and
              Servers
• JAX-RPC maps a
   – web service operation to a java method call.
   – service endpoint to a Java Interface.
• Thus one way to begin implementation of a web service
  in JAX-RPC is to define a Java interface with a method
  for each operation of the service along with a class that
  implements the interface. Of course, following the rules
  of remote invocation etc.
• Now visualize client/server invocation in the same
  address space and lets compare it with remote
  invocation.


                                                          35
           Local Date Service
//server
public class DataService {
    public Data getDate() {
       return new Date();}
//client
Public class Appln {
   public static void main (..) {
     DateService instance = new DateService();
      Date date = instance.getDate();
      System.out.println (“ The date is” + date);
}
• In the case of the remote call a layer of software is used to
    convey the method call from client to server. This layer of
                                                                36
    software is provided by JAX-RPC runtime.
      Java web service interface
             ShapeList
import java.rmi.*;
public interface ShapeList extends Remote {
        int newShape(GraphicalObject g) throws
RemoteException;
        int numberOfShapes()throws RemoteException;
        int getVersion() throws RemoteException;
        int getGOVersion(int i)throws RemoteException;
        GraphicalObject getAllState(int i) throws
RemoteException;
}


                                                         37
  Java implementation of the
      ShapeList server
import java.util.Vector;
public class ShapeListImpl implements ShapeList {
         private Vector theList = new Vector();
         private int version = 0;
         private Vector theVersions = new Vector();
         public int newShape(GraphicalObject g) throws RemoteException{
                   version++;
                   theList.addElement(g);
                   theVersions.addElement(new Integer(version));
                   return theList.size();
         }
         public int numberOfShapes(){}
         public int getVersion() {}
         public int getGOVersion(int i){ }
         public GraphicalObject getAllState(int i) {}
}
                                                                   38
        Java implementation of the
             ShapeList client
package staticstub;
import javax.xml.rpc.Stub;
public class ShapeListClient {
      public static void main(String[] args) { /* pass URL of service */
         try {
             Stub proxy = createProxy();
             proxy._setProperty
               (javax.xml.rpc.Stub.ENDPOINT_ADDRESS_PROPERTY, args[0]);
             ShapeList aShapeList = (ShapeList)proxy;
             GraphicalObject g = aShapeList.getAllState(0);
         } catch (Exception ex) { ex.printStackTrace(); }
      }
        private static Stub createProxy() {
              return
                 (Stub) (new MyShapeListService_Impl().getShapeListPort());
    }
}                                                                             39
             SEI Invocation Code

• Service End Point (SEI) invocation code:
Stub stub = (Stub)(new MyHelloService_Impl().getHelloIFPort());

  stub._setProperty(javax.xml.rpc.Stub.ENDPOINT_ADDRESS
  _PROPERTY,
     "http://localhost:8080/hello-jaxrpc/hello");
   HelloIF hello = (HelloIF)stub;
   resp = hello.sayHello(request.getParameter("username"));




                                                                  40
  SOAP binding and service
        definitions
binding                           service
                      "
   name " ShapeListBinding
         =                           name " MyShapeListService
                                          =             "
                   "
   type ="tns:ShapeList
            transport = URI
 soap:binding                       endpoint
   for schemas for soap/http
        " "
  style= rpc                               "         "
                                      name =ShapeListPort
                                                               "
                                      binding " tns:ShapeListBinding
                                              =
  operation
      name=        "
           " newShape
   input                               soap:address
    soap:body                           location = service URI
      encoding, namespace


   output
    soap:body
     encoding, namespace

  soap:operation                      the service URI is:
        soapAction             “http://localhost:8080/ShapeList-
                               jaxrpc/ShapeList”
                                                                       41
      The main elements in a WSDL
               description
    definitions
     types          message        interface/      bindings       services
                                   (porttype)


target namespace
                   document style request-reply style how            where
                      abstract                                concrete




                                                                             42
Message exchange patterns for
     WSDL operations
Name         Messages sent by

                  Client    Server    Delivery     Fault message
                  Request   Reply                  may replaceReply
In-Out
                  Request                          no fault message
In-Only
Robust In-Only Request                guaranteed   may be sent

Out-In         Reply        Request                may replaceReply

Out-Only                    Request                no fault message
Robust Out-Only             Request   guaranteed   may send fault


                                                                    43

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:14
posted:2/27/2012
language:Latin
pages:43