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

object A object BskeletonRequestproxy for B

Reply

CommunicationRemote Remote referenceCommunication module modulereference module module

for B’s class& dispatcher

remoteclient server

servant

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 Birell’s 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 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).

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

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

13

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.

14

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.

15

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.

16

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.

17

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

18

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

19

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>

20

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>

21

SOAPWeb Services (WS)

Take a look at

1. http://www.w3.org/DesignIssues/WebServices.html2. 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.

22

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.

23

Web services infrastructure and components

Security

Service descriptions (in WSDL)

ApplicationsDirectory service

Web Services

XML

Choreography

SOAP

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

24

SOAP message in an envelope

envelope

header

body

header element

body element

header element

body element

25

Example of a simple request without headers

m:exchange

env:envelope xmlns:env =namespace URI for SOAP envelopes

m:arg1

env:body

xmlns:m = namespace URI of the service description

Hellom:arg2

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

26

Example of a reply corresponding to the request

in env:envelope xmlns:env = namespace URI for SOAP envelope

m:res1

env:body

xmlns:m = namespace URI for the service description

m:res2World

m:exchangeResponse

Hello

27

Use of HTTP POST Request in SOAP client-server

communicationendpoint address

action

POST /examples/stringerHost: www.cdk4.net

Content-Type: application/soap+xmlAction: http://www.cdk4.net/examples/stringer#exchange

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

So

ap

me

ssa

ge

HT

TP

h

ead

er

28

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.

29

Endpoint, Port and binding

SOAP1.1Over http

SOAP 1.1 overhttps

Other. Ex:ebXML overSMTP

Port1 port2 port3

endpoint

Web services Client

Web service

https 1.1 transportsoap1.1 messages

30

WS Interoperability Infrastructure

Network

XML Messaging

Service DescriptionWSDL

SOAP

HTTP

31

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.

32

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

33

JAX-RPC Runtime

Client Appl.

Stub

JAX-RPCRuntime

Server Impl.

Ties

JAX-RPCRuntime

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.

34

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.

35

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.

36

Local Date Service

//serverpublic class DataService {

public Data getDate() { return new Date();}//clientPublic 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.

37

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;}

38

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) {}

}

39

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

}}

40

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"));

41

SOAP binding and service definitions

soap:binding transport = URI

binding

style= "rpc"

endpoint

service name =

binding = "tns:ShapeListBinding"

soap:address location = service URI

name = "MyShapeListService"

name = "ShapeListPort"for schemas for soap/http

the service URI is:

operation

soap:operationsoapAction

"ShapeListBinding""tns:ShapeList"type =

name="newShape"

inputsoap:body

encoding, namespace

soap:body encoding, namespace

output

“http://localhost:8080/ShapeList-jaxrpc/ShapeList”

42

The main elements in a WSDL description

abstract concrete

how where

definitions

types

target namespace

interface/(porttype)

bindings servicesmessage

document stylerequest-reply style

43

Message exchange patterns for WSDL operations

Name

In-Out

In-Only

Robust In-Only

Out-In

Out-Only

Robust Out-Only

Client Server Delivery Fault message

Request Reply may replace Reply

Request no fault message

Request guaranteed may be sent

Reply Request may replace Reply

Request no fault message

Request guaranteed may send fault

Messages sent by