Java RMI, JAX-RPC and JWSDP - PowerPoint PPT Presentation

About This Presentation
Title:

Java RMI, JAX-RPC and JWSDP

Description:

JAX-RPC (The Java API for XML-based RPC) is designed to provide a simple way for ... independent the server can be in .net, Jax-rpc or any other compatible platform. ... – PowerPoint PPT presentation

Number of Views:210
Avg rating:3.0/5.0
Slides: 25
Provided by: binarama
Learn more at: https://cse.buffalo.edu
Category:
Tags: jax | jwsdp | rmi | rpc | java | xmlcompatible

less

Transcript and Presenter's Notes

Title: Java RMI, JAX-RPC and JWSDP


1
Java RMI, JAX-RPC and JWSDP
  • B. Ramamurthy

2
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.

3
Implementation of RMI (5.2.5)
4
The role of proxy and skeleton in remote method
invocation
server

client
remote
skeleton
object B
object A
proxy for B
Request
dispatcher
for Bs class
Reply
servant
Communication
Remote reference
Communication
Remote
module
module
module
reference module
Object A invokes a remote object in Object B for
which it holds a remote object reference. System
Model
5
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)

6
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).

7
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.

8
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
    Birells paper 1995.

9
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 Cs 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, servers 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 gt 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).

10
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/cl
    ass/index.html
  • Reflection feature allowed for dynamic creation
    of skeleton and proxy in Java 2 version onwards.
  • Read more about reflection model of computing.

11
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)

12
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 methods 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.

13
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.

14
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

15
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.

16
Endpoint, Port and binding
Web service
endpoint
Port1 port2
port3
Web services Client
SOAP 1.1 over https
SOAP1.1 Over http
Other. Ex ebXML over SMTP
https 1.1 transport soap1.1 messages
17
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.

18
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 software is
    provided by JAX-RPC runtime.

19
JAX-RPC service creation
  • A service definition describes the operations
    that it provides and the data types that they
    require as argument and provide as return values.
  • This definition can be made available as a
    document written in WSDL.
  • From a WSDL document, JAX-RPC can generate the
    Java code required to connect a client to a
    server leaving one to write only the logic of the
    client application itself.
  • Since WSDL is language independent the server can
    be in .net, Jax-rpc or any other compatible
    platform.

20
JAX-RPC service creation (contd.)
  • Define the service a Java interface.
  • Generate WSDL using the tools provided with
    JAX-RPC package.
  • Advertise it in a registry for the client to
    lookup and import it.

21
Client and Server Programming Environment
  • JAX-RPC API is distributed over a set of
    packages
  • javax.xml.rpc
  • javax.xml.rpc.encoding
  • javax.xml.rpc.handler
  • javax.xml.rpc.handler.soap
  • javax.xml.rpc.holders
  • javax.xml.rpc.server
  • javac.xml.rpc.soap

22
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.

23
Client Invocation Modes
  • Synchronous request-response mode (tightly
    coupled).
  • One-way RPC (loosely coupled) no value returned,
    no exception thrown, need to bypass stub layer,
    use Dynamic Invocation Interface (DII).

24
SEI Invocation Code
  • Service End Point (SEI) invocation code
  • Stub stub (Stub)(new MyHelloService_Impl().getHe
    lloIFPort())
  • stub._setProperty(javax.xml.rpc.Stub.ENDPOIN
    T_ADDRESS_PROPERTY,
  • "http//localhost8080/hello-jaxrpc/hell
    o")
  • HelloIF hello (HelloIF)stub
  • resp hello.sayHello(request.getParameter("
    username"))
Write a Comment
User Comments (0)
About PowerShow.com