Upload
avani
View
27
Download
1
Embed Size (px)
DESCRIPTION
Programming in Java. RMI 蔡文能 交通大學資訊工程學系 [email protected]. http://www.csie.nctu.edu.tw/~tsaiwn /java/. Agenda. RMI Introduction RPC vs. RMI Remote Procedure Call Remote Method invocation RPC example RMI Architecture Client stub and Server skeleton - PowerPoint PPT Presentation
Citation preview
交通大學資訊工程學系
Programming in Java
RMI
蔡文能交通大學資訊工程學系[email protected]
http://www.csie.nctu.edu.tw/~tsaiwn/java/
交通大學資訊工程學系 蔡文能 RMI-第 2頁
Java RMI
AgendaRMI IntroductionRPC vs. RMI Remote Procedure Call Remote Method invocation
RPC exampleRMI Architecture Client stub and Server skeleton RMI Deployment and RMI registry RMI Example
From function to Distributed computing DLL, RPC/RMI, CORBA, Web Services
交通大學資訊工程學系 蔡文能 RMI-第 3頁
Java RMI
交通大學資訊工程學系 蔡文能 RMI-第 4頁
Java RMI
交通大學資訊工程學系 蔡文能 RMI-第 5頁
Java RMI
RMI Introduction RMI enables the programmer to create distributed Java
applications, in which the methods of remote Java objects can be invoked from other Java virtual machines, possibly on different hosts.
A Java program can make a call on a remote object once it obtains a reference to the remote object, either by looking up the remote object in the naming service provided by RMI or by receiving the reference as an argument or a return value. A client can call a remote object in a server, and that server can also be a client of other remote objects.
RMI uses object serialization to marshal and unmarshal parameters.
交通大學資訊工程學系 蔡文能 RMI-第 6頁
Java RMI
Serialization
Action of encoding of an object into a stream of bytes
RMI performs marshalling/unmarshalling via Java Serialization Marshalling is the process of encoding arguments and results for
transmission
Thus, objects to be marshalled or unmarshalled must be serializable ( should implements java.io.serializable)
交通大學資訊工程學系 蔡文能 RMI-第 7頁
Java RMI
RMI Overview
Remote Method Invocation Java version of RPC
ha.nctu.edu.tw hehe.nctu.edu.tw
networknetworkObjectClient
RemoteObjectServer
method invocation
交通大學資訊工程學系 蔡文能 RMI-第 8頁
Java RMI
blah, blah, blah
bar = foo(a,b);
blah, blah, blah
blah, blah, blah
bar = foo(a,b);
blah, blah, blah
int foo(int x, int y ) { if (x>100)
return(y-2); else if (x>10)
return(y-x); else
return(x+y);}
int foo(int x, int y ) { if (x>100)
return(y-2); else if (x>10)
return(y-x); else
return(x+y);}
ClientClient
ServerServer
protocol
Remote Procedure Call (RPC)
RPCRPC
交通大學資訊工程學系 蔡文能 RMI-第 9頁
Java RMI
Why RPC/RMI
Advanced form of communication Sockets and MPI: data transfer RPC/RMI: control transfer
Transparency in function calls No distinguish between local and remote calls (in theoretical) Also applied to IPC on the same machine
Ease of use Compiled-time argument type checking Automatic stub generation
Calling a function/method at a remote server:
IPC : Inter-Process Communication
交通大學資訊工程學系 蔡文能 RMI-第 10頁
Java RMI
Middleware Layers
Applications
Middlewarelayers Request reply
protocoleXternal Data Representation(XDR)
Operating System
RPC, RMI, and events
分層負責 , 分工合作
交通大學資訊工程學系 蔡文能 RMI-第 11頁
Java RMI
RPC – Remote Procedure CallThere are a number of popular RPC specifications.
Sun RPC is widely used.
NFS (Network File System) is RPC based.
RPC clients are processes that call remote procedures.
RPC servers are processes that include procedure(s) that can be called by clients.
Rich set of support tools.The RPC Library is a collection of tools for automating the creation of RPC clients and servers.
交通大學資訊工程學系 蔡文能 RMI-第 12頁
Java RMI
Sun RPCRPCGEN command There is a tool for automating the creation of RPC
clients and servers. The program rpcgen does most of the work for you.
This rpcgen is usually knows as RPC compiler. The input to rpcgen is a protocol definition in the form
of a list of remote procedures and parameter types.
交通大學資訊工程學系 蔡文能 RMI-第 13頁
Java RMI
RPCGEN
Input File
rpcgen
Client Stubs XDR filters header file Server skeleton
C Source CodeC Source Code
ProtocolProtocolDescriptionDescription
foo_clnt.c foo_svc.c
foo.xx
% rpcgen –C foo.xx
foo_xdr.c foo.h
交通大學資訊工程學系 蔡文能 RMI-第 14頁
Java RMI
RPC Programming
RPC Library XDR routines RPC run time library
call rpc service
register with portmapper
dispatch incoming request to correct procedure
Program Generatorrpcgen
交通大學資訊工程學系 蔡文能 RMI-第 15頁
Java RMI
RPC Run-time Library
High- and Low-level functions that can be used by clients and servers.
High-level functions provide simple access to RPC services. For client: int callrpc( . . . ) For server: int registerrpc( . . . ) svc_run() is a dispatcher on server
A dispatcher waits for incoming connections and invokes the appropriate function to handle each incoming request.
交通大學資訊工程學系 蔡文能 RMI-第 16頁
Java RMI
Procedure Arguments
To reduce the complexity of the interface specification, Sun RPC includes support for a single argument to a remote procedure.*Typically the single argument is a structure that contains a number of values.
* Newer versions can handle multiple args.
交通大學資訊工程學系 蔡文能 RMI-第 17頁
Java RMI
Procedure Identification
Each procedure is identified by: Hostname (IP Address) Program Identifier (32 bit integer) Procedure Identifier (32 bit integer)
Program Version identifierfor testing and migration.
交通大學資訊工程學系 蔡文能 RMI-第 18頁
Java RMI
Program Identifiers
Each remote program has a unique ID.
Sun divided up the IDs:
0x00000000 - 0x1fffffff
0x20000000 - 0x3fffffff
0x40000000 - 0x5fffffff
0x60000000 - 0xffffffff
SunSun
SysAdmin SysAdmin
TransientTransient
ReservedReserved
交通大學資訊工程學系 蔡文能 RMI-第 19頁
Java RMI
Procedure Identifiers &Program Version Numbers
Procedure Identifiers usually start at 1 and are numbered sequentially
Version Numbers typically start at 1 and are numbered sequentially.
交通大學資訊工程學系 蔡文能 RMI-第 20頁
Java RMI
Iterative ServerSun RPC specifies that at most one remote procedure within a program can be invoked at any given time.
If a 2nd procedure is called, the call blocks until the 1st procedure has completed.
Having an iterative server is useful for applications that may share data among procedures.
Example: database - to avoid insert/delete/modify collisions.
We can provide concurrency when necessary...
交通大學資訊工程學系 蔡文能 RMI-第 21頁
Java RMI
RPC example (1/7)This program shows you how to use a server program, a client program and an interface definition file to let the client program call the functions in the server program and get the results.Files: ① test_proc.c --- the server file ② test_client.c --- the client file ③ test.xx --- the Interface Definition file of RPC Files generated by rpcgen: rpcgen –C test.xx
test_clnt.c test_svc.c test.h
交通大學資訊工程學系 蔡文能 RMI-第 22頁
Java RMI
RPC example (2/7)File test_proc.c (1/1) for server side
#include "test.h"int *addd_1_svc(int *argp, struct svc_req *rqstp){ static int result; result = *argp + 1; return (&result);}int *decc_1_svc(int *argp, struct svc_req *rqstp){ static int result; result = *argp - 1; return (&result);}
交通大學資訊工程學系 蔡文能 RMI-第 23頁
Java RMI
RPC example (3/7)File test_client.c (1/3) for client side
#include "test.h" /* test_client.c , page1 */void test_prog_1(char *host){ CLIENT *clnt; int *result_1; int addd_1_arg; int *result_2; int decc_1_arg; #ifndef DEBUG clnt = clnt_create(host, TEST_PROG, TEST_VERS, "netpath"); if (clnt == (CLIENT *) NULL) /* NULL is 0 */ { clnt_pcreateerror(host); exit(1); } /* to be continued */
交通大學資訊工程學系 蔡文能 RMI-第 24頁
Java RMI
RPC example (4/7)File test_client.c (2/3) for client side
#endif /* DEBUG */ /* test_client.c , page2 */ scanf ("%d",&addd_1_arg); scanf ("%d",&decc_1_arg); result_1 = addd_1(&addd_1_arg, clnt); if (result_1 == (int *) NULL) { clnt_perror(clnt, "call failed"); } result_2 = decc_1(&decc_1_arg, clnt); if (result_2 == (int *) NULL) { clnt_perror(clnt, "call failed"); } printf ("addd_1_result = %d\n",*result_1); printf ("decc_1_result = %d\n",*result_2); #ifndef DEBUG clnt_destroy(clnt); #endif/* DEBUG */} /* test_prog_1 *//* to be continued */
交通大學資訊工程學系 蔡文能 RMI-第 25頁
Java RMI
RPC example (5/7)File test_client.c (3/3) for client side
/* test_client.c , page3 */main(int argc, char *argv[]){ char *host; if (argc < 2) /* no host name given */ { printf("usage: %s server_host\n", argv[0]); exit(1); } host = argv[1]; test_prog_1(host);}
交通大學資訊工程學系 蔡文能 RMI-第 26頁
Java RMI
RPC example (6/7)File : test.xx
program TEST_PROG{ version TEST_VERS { int ADDD(int)=1; int DECC(int)=2; }=1;}=0x31234567;
rpcgen –C test.xx
交通大學資訊工程學系 蔡文能 RMI-第 27頁
Java RMI
RPC example (7/7)Use rpcgen , C compiler, and Linking/loader By rpcgen test.xx , you can get test_clnt.c, test_svc.c and test.h. Compile/link on the client
gcc -o test test_client.c test_clnt.c -lnsl
Compile/link/run on the server (ccsun2.csie.nctu.edu.tw)
gcc -o test_svc test_svc.c test_proc.c -lrpcsvc -lnsl
./test_svc&
Run clien program on the client
./test ccsun2.csie.nctu.edu.tw
Demo on Sun machines
交通大學資訊工程學系 蔡文能 RMI-第 28頁
Java RMI
rpcgen –C test.xx
交通大學資訊工程學系 蔡文能 RMI-第 29頁
Java RMI
Test RPC -- Server Side
交通大學資訊工程學系 蔡文能 RMI-第 30頁
Java RMI
Test RPC -- Client Side
把第一個數加 1,
把第二個數減一
輸入兩列 : 57 89
交通大學資訊工程學系 蔡文能 RMI-第 31頁
Java RMI
Another example of rpcgen file
struct readargs {FileIdentifier f;FilePointer position;Length length;
};
program FILEREADWRITE { version VERSION {
void WRITE(writeargs)=1;Data READ(readargs)=2;2
}=2;} = 9999;
const MAX = 1000;typedef int FileIdentifier;typedef int FilePointer;typedef int Length;struct Data {
int length;char buffer[MAX];
};struct writeargs {
FileIdentifier f;FilePointer position;Data data;
};
交通大學資訊工程學系 蔡文能 RMI-第 32頁
Java RMI
High-Level Library Limitation
The High-Level RPC library calls support UDP only (no TCP).
You must use lower-level RPC library functions if you want to use TCP.
The High-Level library calls do not support any kind of authentication.
交通大學資訊工程學系 蔡文能 RMI-第 33頁
Java RMI
Low-level RPC Library
Full control over all IPC options TCP & UDP Timeout values Asynchronous procedure calls
Multi-tasking Servers
Broadcasting
IPC : Inter-Process Communication
交通大學資訊工程學系 蔡文能 RMI-第 34頁
Java RMI
The General RMI Architecture
The server must first bind its name to the registry
The client lookup the server name in the registry to establish remote references.
The Stub serializing the parameters to skeleton, the skeleton ( 框架 ) invoking the remote method and serializing the result back to the client stub ( 存根 ).
RMI Server
skeleton
stub
RMI Client
Registry
bind
lookupreturn call
Local Machine
Remote Machine
交通大學資訊工程學系 蔡文能 RMI-第 35頁
Java RMI
The Stub ( 存根 ) and Skeleton (框架 )
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.Java RMI is NOT an all-purpose ORB architecture like CORBA
Stu
b
RMI Client RMI Server
skeleton
return
call
交通大學資訊工程學系 蔡文能 RMI-第 36頁
Java RMI
Stub
Stub ( 存根 ; 客戶端代理 ) Client side Acts as an implementation of a remote interface Communicates with the real object over the network The stub class is generated from corresponding remote
class by the RMI compiler rmic
Note: As of the J2SE 5.0 release, stub classes for remote objects no longer need to be pregenerated using the rmic stub compiler, unless the remote object needs to support clients running in pre-5.0 VMs.
交通大學資訊工程學系 蔡文能 RMI-第 37頁
Java RMI
skeleton
Skeleton ( 框架 ; 服務端代理 ) Server side Carries on a conversation with the stub; Reads the parameters for the method call from the link Call the real remote service Writes the return value from the service back to the stub
Note: Before J2SE 5.0 (i.e., JDK 1.4 and older version,
rmic is required to generate the skeleton ???_Skel.classAnd ???_Stub.class for client (Where ??? Is your server Class name)
交通大學資訊工程學系 蔡文能 RMI-第 38頁
Java RMI
JVM Asociated
to ActivationGroup
RMI (in Java)
Client Code
network
NamingService
Server Object
ActivationDaemonClient
Stub
ServerSkeleton
Implement “Factories” using declarative descriptions of activatable objects
One JVM per ActivationGroup. Automatically launched by Activation daemon and contains (potentially) many small scale, semi-independent servers which can share resources (like connection pools) and which live under the same security restrictions
“Flat” directory structure which attempts to provide some notion of location transparency-- client code uses a single name to find a server
交通大學資訊工程學系 蔡文能 RMI-第 39頁
Java RMI
Java Interfaces
Similar to ClassNo implementation! All methods are abstract (virtual function for C++ ).Everything is public.No constructoran Interface is an API that can be implemented by a Class.
In Java a class can only extend a single superclass (single inheritence). But a Java class can implement any number of interfaces.
交通大學資訊工程學系 蔡文能 RMI-第 40頁
Java RMI
Serializable interface
In Java a class can only extend a single superclass (single inheritence).
A class can implement any number of interfaces. end result is very similar to multiple inheritence.
A class is Serializable if it implements the interface Serializable. A Serializable class is one whose instances can be marshaled (turned into a linear sequence of bits). Serializable objects can be transmitted from one computer to another, as well as be stored into a file.
交通大學資訊工程學系 蔡文能 RMI-第 41頁
Java RMI
Java RMI classesJava.rmi.Remote Interface supporting remote objects
java.rmi.server.UnicastRemoteObject Continuously running server
java.rmi.activation.Activatable Server started by rmid daemon
java.rmi.Naming Lookup: Returns stub given a name
Java.rmi.registry.Registry , LocateRegistryjava.rmi.RMISecurityManager Validates rights to access downloaded object
交通大學資訊工程學系 蔡文能 RMI-第 42頁
Java RMI
RMI Adds a few layers to TCP/IP
Server App.
Skeleton
Remote Reference
Transport
Client App.
Stubs
Remote Reference
Transport
交通大學資訊工程學系 蔡文能 RMI-第 43頁
Java RMI
Remote reference layer
Defines and supports the invocation semantics of the RMI connection
Provides a RemoteRef object that represents the link to the remote service implementation object
The stub objects use the invoke( ) method in RemoteRef to forward the method call
交通大學資訊工程學系 蔡文能 RMI-第 44頁
Java RMI
Transport layer
Provides basic connectivity makes the connection between JVMs
Based on TCP/IP connections between machines in a network
The network works are done by the client stub and the server Skelton.
交通大學資訊工程學系 蔡文能 RMI-第 45頁
Java RMI
Finding Remote Objects
It would be awkward if we needed to include a hostname, port and protocol with every remote method invocation.
RMI provides a Naming Service through the RMI Registry that simplifies how programs specify the location of remote objects. This naming service is a JDK utility called rmiregistry that runs at a well known address (by default).
交通大學資訊工程學系 蔡文能 RMI-第 46頁
Java RMI
Find Servers using Naming Service
Simple interface to registry
Implemented via 5 static methods on an object:
public static String[] list(String name) public static Remote lookup(String name) public static void bind(String name, Remote obj) public static void rebind(String name, Remote obj) public static void unbind(String name)
交通大學資訊工程學系 蔡文能 RMI-第 47頁
Java RMI
java.rmi.Naming
交通大學資訊工程學系 蔡文能 RMI-第 48頁
Java RMI
java.rmi.registry.LocateRegistry
交通大學資訊工程學系 蔡文能 RMI-第 49頁
Java RMIjava.rmi.registry.Registry
交通大學資訊工程學系 蔡文能 RMI-第 50頁
Java RMI
Steps for Developing an RMI System
1. Define the remote interface extends java.rmi.Remote that declares the methods that will be available remotely.
2. Develop the remote server class by implementing the remote interface. The server program must create a remote object and register it with the naming service.
3. Develop the client program.4. Compile the Java source files.5. Use rmic to Generate the client stubs and server skeletons.6. Start the RMI registry.7. Start the remote server objects.8. Run the client
交通大學資訊工程學系 蔡文能 RMI-第 51頁
Java RMI
RMI Deployment
RMI Deployment( 佈署 ): Where does the server program finds it’s classes? Where does the client program find it’s classes? How are classes loaded from client to server and vice-versa?
Remember that Object Serialization does not send the classes, only the data
Deployment on client two ways to get the class files to the client
Copy class files for all stub classes to the client manually
Client dynamically download stub class from Web server
交通大學資訊工程學系 蔡文能 RMI-第 52頁
Java RMI
Dynamic Loading on Client (1/2)
In principle, modifying your RMI application to allow dynamic loading of stub classes is now straightforward: Install the stub classes in a Web Server document directory. Set the java.rmi.server.codebase property for the server application, to
reference that Web Server directory. (see below) Create a security policy file on the client. Set the java.security.policy property for the client application. Set a security manager in the client.
This also works for any classes (not just stubs) whose serialized form may be communicated via remote method calls. You just need to reinterpret “server” and “client” application according to
the direction the serialized object moves—as “source” and “destination” application.
javaw –Djava.rmi.server.codebase=http://www.mit.edu/ggyy/ HelloServer
交通大學資訊工程學系 蔡文能 RMI-第 53頁
Java RMI
Dynamic Loading on Client (2/2) Usual CLASSPATH variable “local codebase”
Set this while running both the server and the client but not rmiregistry RMI client needs stubs from server
Stubs downloaded from the server to the client using the java.rmi.server.codebase property
RMI server may need classes from the clientClasses downloaded from the client to the server using the java.rmi.server.codebase property setup by the client
RMI registry needs to find stub classesIf it finds them from CLASSPATH it will not convey the “true” code base associated with the stub class even if the server sets it.
Searches “local” code base initially, then searches the “java.rmi.server.codebase”
交通大學資訊工程學系 蔡文能 RMI-第 54頁
Java RMI
Setting the Security Manager
In an RMI application, if no security manager is set, stubs and classes can only be loaded from the local CLASSPATH.To enable dynamic loading, issue the command: System.setSecurityManager(new RMISecurityManager()) ;
at the start of the program.You should do this in any application that may have to download code—in the simple examples considered so far this means RMI clients that need to download stubs.This isn’t the end of the story. You also have to define a new property: the java.security.policy property. In simple cases this java.security.policy property is needed for
clients, whereas java.rmi.server.codebase is needed for servers.
交通大學資訊工程學系 蔡文能 RMI-第 55頁
Java RMI
Defining a Security Policy
The simplest security policy you can define is a plain text file with contents: grant { permission java.security.AllPermission "", "" ; } ;
This policy allows downloaded code to do essentially anything the current user has privileges to do: Read, write and delete arbitrary files; open, read and write to arbitrary
Internet sockets; execute arbitrary UNIX/Windows commands on the local machine, etc.
It is a dangerous policy if there is any chance you may download code from untrustworthy sources (e.g. the Web).
For now you can use this policy, but please avoid dynamically loading code you cannot trust!
交通大學資訊工程學系 蔡文能 RMI-第 56頁
Java RMI
The java.security.policy Property
If the text file containing our security policy is called (for example) policy.all, the original HelloClient example might now be run as follows:
java –Djava.security.policy=policy.all HelloClient
Alternatively this property can be set inside the program using System.setProperty().
交通大學資訊工程學系 蔡文能 RMI-第 57頁
Java RMI
RMI scenario (1/2)Downloading Stubs
交通大學資訊工程學系 蔡文能 RMI-第 58頁
Java RMI
RMI scenario (2/2)
Downloading Classes
交通大學資訊工程學系 蔡文能 RMI-第 59頁
Java RMI
Creating Remote object
1. Define an interface which extends Remote interface2. Create the server program which implements that interface3. Server class should extend UnicastRemoteObject or you
can use use UnicastRemoteObject.exportObject(svrObj, 0);4. Compile the Java program5. Create the Stub for client using rmic command or other tools
Note: As of the J2SE 5.0 release, stub classes for remote objects no longer need to be pregenerated using the rmic stub compiler, unless the remote object needs to support clients running in pre-5.0 VMs.
交通大學資訊工程學系 蔡文能 RMI-第 60頁
Java RMI
Create the Stub
A. In JBuilder use “JNI/RMI” tab in class properties to generate it automatically
B. By hand: use rmic tool:
rmic ComputeEngine
Note: As of the J2SE 5.0 release, stub classes for remote objects no longer need to be pregenerated using the rmic stub compiler, unless the remote object needs to support clients running in pre-5.0 VMs.
交通大學資訊工程學系 蔡文能 RMI-第 61頁
Java RMI
Server Details – extending Remote
Create an interface the extends the java.rmi.Remote interface. This new interface includes all the public methods that
will be available as remote methods.
import java.rmi.*;
public interface MyRemote extends Remote { public int foo(int x) throws RemoteException;
public String blah(int y) throws RemoteException;
. . .
}
交通大學資訊工程學系 蔡文能 RMI-第 62頁
Java RMI
How the interface will be used
Class for your Remote Object
Your Interface UnicastRemoteObject
Remote Interface Class RemoteServer
extends
implementsextends
extendsprovides methods needed by
交通大學資訊工程學系 蔡文能 RMI-第 63頁
Java RMI
Server Details – Implementation Class
Create a class that implements the interface. The class should also extend UnicastRemoteObject; or you
can create the server object svrObj and then use the static function UnicastRemoteObject.exportObject(svrObj, 0);
This class needs a constructor that throws RemoteException !
This class is now used by rmic to create the stub and skeleton code.
Note: As of the J2SE 5.0 release, stub classes for remote objects no longer need to be pregenerated using the rmic stub compiler, unless the remote object needs to support clients running in pre-5.0 VMs.
交通大學資訊工程學系 蔡文能 RMI-第 64頁
Java RMI
Generating stubs and skeleton
Compile the remote interface and implementation:
> javac MyRemote.java MyRemoteImpl.java
Use rmic to generate MyRemoteImpl_stub.class, MyRemoteImpl_skel.class
> rmic MyRemoteImpl
Note: As of the J2SE 5.0 release, stub classes for remote objects no longer need to be pregenerated using the rmic stub compiler, unless the remote object needs to support clients running in pre-5.0 VMs.
交通大學資訊工程學系 蔡文能 RMI-第 65頁
Java RMI
Server Detail – main( )
The server main( ) needs to: create a remote object. register the object with the Naming service.
public static void main(String args[]) {
try {
MyRemoteImpl r = new MyRemoteImpl();
javaNaming.bind(“joe”,r);
} catch (RemoteException e) {
. . .
交通大學資訊工程學系 蔡文能 RMI-第 66頁
Java RMI
Client DetailsThe client needs to ask the Naming service for a reference to a remote object. The client needs to know the hostname or IP address
of the machine running the server. The client needs to know the name of the remote
object.
The Naming service uses URLs to identify remote objects.
rmi://hostname/objectname
交通大學資訊工程學系 蔡文能 RMI-第 67頁
Java RMI
Using The Naming service
Naming.lookup() method takes a string parameter that holds a URL indicating the remote object to lookup.
rmi://hostname/objectname
Naming.lookup( ) returns an Object!
Naming.lookup( ) can throw RemoteException MalformedURLException
交通大學資訊工程學系 蔡文能 RMI-第 68頁
Java RMI
交通大學資訊工程學系 蔡文能 RMI-第 69頁
Java RMI
交通大學資訊工程學系 蔡文能 RMI-第 70頁
Java RMI
交通大學資訊工程學系 蔡文能 RMI-第 71頁
Java RMI
交通大學資訊工程學系 蔡文能 RMI-第 72頁
Java RMI
交通大學資訊工程學系 蔡文能 RMI-第 73頁
Java RMI
RMI registry (1/2)
A naming service Maps names to remote objects Provides clients with a mechanism to find remote services
running on RMI serversEssential operations: bind/rebind, unbind, lookup Bind adds a service entry to the registry Unbind removes a service entry from the registry Lookup allows clients to find the service’s address using
service nameNames in the registry use unique names Recommend the name of the remote class that implements
the remote interface
交通大學資訊工程學系 蔡文能 RMI-第 74頁
Java RMI
RMI registry (2/2)
To send a message to a remote “server object,” The “client object” has to find the object
Do this by looking it up in a registry The client object then has to marshal the parameters (prepare them for
transmission)Java requires Serializable parametersThe server object has to unmarshal its parameters, do its computation, and marshal its response
The client object has to unmarshal the responseFor accessing a remote registry, use the following URL form rmi://host:port/serviceName host is the machine on which the registry is running The registry is listening on the port (default 1099)
交通大學資訊工程學系 蔡文能 RMI-第 75頁
Java RMI
交通大學資訊工程學系 蔡文能 RMI-第 76頁
Java RMI
交通大學資訊工程學系 蔡文能 RMI-第 77頁
Java RMI
交通大學資訊工程學系 蔡文能 RMI-第 78頁
Java RMI
Start the Java RMI registryBy default, the registry runs on TCP port 1099. To start a registry on a different port, specify the port number from the command line. For example, to start the registry on port 2001 on a Windows platform:
start rmiregistry 2001 If the registry will be running on a port other than 1099, you'll need to specify the port number in the calls to LocateRegistry.getRegistry in the Server and Client classes. For example, if the registry is running on port 2001 in this example, the call to getRegistry in the server would be: Registry registry =
LocateRegistry.getRegistry(2001);
交通大學資訊工程學系 蔡文能 RMI-第 79頁
Java RMI
交通大學資訊工程學系 蔡文能 RMI-第 80頁
Java RMI
Stateful/Stateless Servers
Stateful servers: Servers keep track of client information. RPC/RMI reply depends on that client information. Pros: Simplify client design Cons: A server crash loses client information. A client crash leaves old
client information at server. At-most-once invocation semantics (Java RMI takes this design.)
Stateless servers: Clients must maintain Inter-call information. RPC/RMI reply is always the same. At-least-once invocation semantics (Some RPC implementations take
this design.)
交通大學資訊工程學系 蔡文能 RMI-第 81頁
Java RMI
Other Technologies CORBA XML based
SOAP / Web Service J2EE/EJB MicroSoft’s COM, DCOM MicroSoft’s .NET
Has Common Language RuntimeTight Integration of Web Services and XMLMultiple language integration
However only one platform Windows
交通大學資訊工程學系 蔡文能 RMI-第 82頁
Java RMI
Reference RMI docs
java.sun.com/products/jdk/rmi/ Java Tutorial on RMI:
http://java.sun.com/j2se/1.5.0/docs/guide/rmi
JavaIDLjava.sun.com/docs/books/tutorial/idl
java.sun.com/products/jdk/idl/
www.omg.org/news/begin.htm
Jini -- http://www.jini.org/www.artima.com/jini/resources
交通大學資訊工程學系 蔡文能 RMI-第 83頁
Java RMI
Programming Paradigms
Imperative Programming (FORTRAN, C, Pascal, …) The most common programming paradigm
Functional Programming (LISP, …)
Logic Programming (Prolog)
(Declarative programming language; 宣告式語言 )
Object-Oriented Programming
(Smalltalk, C++, Java, …)
Simply using C++/Java constructs does not automatically lead to well-organized Object-Oriented Programs.
交通大學資訊工程學系 蔡文能 RMI-第 84頁
Java RMI
Why OO Programming?Better concepts and tools to model and represent the real world as closely as possible (including concurrency, e.g., in Windows GUI)=> model of reality=> behavior modelingBetter reusability & extensibility (inheritance)=> reduce the time/cost of development
Enhanced maintainability & improved reliability – “Encapsulation” and “Information Hiding” Object only accessible through the external interface Internal implementation details are not visible outside Localized changes to implementation of classes Completeness: all required operations are defined Independent testing and maintenance
Help writing good program more easily
交通大學資訊工程學系 蔡文能 RMI-第 85頁
Java RMI
From function to Distributed computingFunction, Subroutine, ProcedureDLL (share Library)RPC, RMICORBA (Common Object Request Broker Architecture)XML, SOAP, Web serviceODBC, JDBCJava EE (J2EE), EJBDCOM, .NET (dot NET), C# ( 請寫出 C# 要如何唸 ?)parallel computingpervasive computing(普及計算 )、 ubiquitous computingGrid computing(網格運算 )Cloud computing(雲端運算 )
JINI: Jini Is Not Initials GNU: GNU Is Not Unix
交通大學資訊工程學系 蔡文能 RMI-第 86頁
Java RMI
RMI example from Sun Java(1/4)C:\jtest\RMI>java lineno < Hello.java 1 //Hello.java 2 //package example.hello; 3 import java.rmi.Remote; 4 import java.rmi.RemoteException; 5 public interface Hello extends Remote { 6 String sayHello() throws RemoteException; 7 }// interface HelloC:\jtest\RMI>java lineno < Server.java 1 //Server.java 2 //package example.hello; 3 import java.rmi.registry.Registry; 4 import java.rmi.registry.LocateRegistry; 5 import java.rmi.RemoteException; 6 import java.rmi.server.UnicastRemoteObject; 7 public class Server implements Hello { 8 public Server( ) {} 9 public String sayHello() { 10 return "Hello, world!"; 11 }
交通大學資訊工程學系 蔡文能 RMI-第 87頁
Java RMI
RMI example from Sun Java(2/4)
12 public static void main(String args[]) { 13 try { 14 Server obj = new Server(); 15 Hello stub = (Hello)
UnicastRemoteObject.exportObject(obj, 0); 16 17 // Bind the remote object's stub in the registry 18 Registry registry = LocateRegistry.getRegistry(); 19 registry.bind("Hello", stub); 20 21 System.err.println("Server ready"); 22 } catch (Exception e) { 23 System.err.println("Server exception: " +
e.toString()); 24 e.printStackTrace(); 25 } 26 } // main( 27 }//class Server
交通大學資訊工程學系 蔡文能 RMI-第 88頁
Java RMI
RMI example from Sun Java(3/4)C:\jtest\RMI>java lineno < Client.java 1 //Client.java 2 //package example.hello; 3 import java.rmi.registry.LocateRegistry; 4 import java.rmi.registry.Registry; 5 public class Client { 6 private Client() {} 7 public static void main(String[] args) { 8 String host = (args.length < 1) ? null : args[0]; 9 try { 10 Registry registry = LocateRegistry.getRegistry(host); 11 Hello stub = (Hello) registry.lookup("Hello"); 12 String response = stub.sayHello( ); 13 System.out.println("response: " + response); 14 } catch (Exception e) { 15 System.err.println("Client exception: " + e.toString()); 16 e.printStackTrace(); 17 } 18 }//main( 19 }// class Client
交通大學資訊工程學系 蔡文能 RMI-第 89頁
Java RMI
RMI example from Sun Java(4/4)C:\jtest\RMI>javac *java
C:\jtest\RMI>start rmiregistryC:\jtest\RMI>javaw Server
C:\jtest\RMI>java Clientresponse: Hello, world!
C:\jtest\RMI>java Client 192.168.1.2response: Hello, world!
C:\jtest\RMI>java Client 192.168.1.1Client exception: java.rmi.ConnectException: Connection refused to host:
192.168.1.1; nested exception is: java.net.ConnectException: Connection timed out: connect
交通大學資訊工程學系 蔡文能 RMI-第 90頁
Java RMI
Hint to deploy RMI
JDK 1.4 and Older version Compile all *.java rmic Server Copy *stub*class to Client side Copy *skel* to Server Server side: start rmiregistry Server side: javae Server Client side: java Client
JDK 1.5 and later version ( rmic is no longer needed ) Compile all *.java Server side: start rmiregistry Server side: javae Server Client side: java Client
Server requires: Hello.java, Server.javaClient requires: Hello.java, Client.java
交通大學資訊工程學系 蔡文能 RMI-第 91頁
Java RMI
Web servicesA collection of XML-based technologies developed by the e-business community to address issues of: Service discovery : UDDI + WSDL Interoperable data exchange and/or application invocation :
HTTP + XML + SOAP (Simple Object Access Protocol) Service compositions (workflow, business processes)
The programming effort and maintainability is roughly the same both for Web Services and CORBAMajor developers include: Apache, IBM, HP, SUN & Microsoft (.NET)
http://www.webservices.org/
交通大學資訊工程學系 蔡文能 RMI-第 92頁
Java RMI
W3C (working group) Web service definition
"A Web service is a software application identified by a URI, whose interfaces and bindings are capable of being defined, described and discovered as XML artefacts. A Web service supports direct interactions with other software agents using XML based messages exchanged via internet-based protocols."
http://www.w3c.org/TR/2002/WD-wsa-reqs-20020819
交通大學資訊工程學系 蔡文能 RMI-第 93頁
Java RMI
Web Services Protocol Stack
交通大學資訊工程學系 蔡文能 RMI-第 94頁
Java RMI
SOAPSimple Object Access Protocol http://www.w3c.org/TR/SOAP/
A lightweight protocol for exchange of information in a decentralised, distributed environmentTwo different styles to use: to encapsulate RPC calls using the extensibility and
flexibility of XML …or to deliver a whole document without any method
calls encapsulated
交通大學資訊工程學系 蔡文能 RMI-第 95頁
Java RMI
WSDL
Web Services Definition Language http://www.w3.org/TR/wsdl/
An XML-based language for describing Web Services what the service does (description) how to use it (method signatures) where to find the service
WSDL does not depend on the underlying protocol
交通大學資訊工程學系 蔡文能 RMI-第 96頁
Java RMI
UDDI (and alternatives)
Universal Description, Discovery and Integration http://www.uddi.org
UDDI creates a platform-independent, open framework & registry for: Describing services Discovering businesses Integrating business services
The UDDI may be less used than predicted, especially on the Internet levelBioMoby - an alternative for Life Sciences domain?
交通大學資訊工程學系 蔡文能 RMI-第 97頁
Java RMI
Sending requests,
getting results
Sending requests,
getting results
Waiting for requests
(known location,known port)
Waiting for requests
(known location,known port)
Data as name/value pairs
Traditional CGI-based approach
cgi-bin scripts: Data transmitted as name-value pairs (HTML forms) Transport over (state-less) HTTP protocol no standards for keeping user sessions (state-fullness) server side: a script is called
交通大學資訊工程學系 蔡文能 RMI-第 98頁
Java RMI
Sending requests,
getting results
Sending requests,
getting results
Waiting for requests
(known location,known port)
Waiting for requests
(known location,known port)
Data in binary format
CORBA-based approach
CORBA: (Common Object-Request-Broker Architecture) Data transmitted as objects (at least it looks like that) Transport (usually) over well standardised IIOP protocol user sessions (state-fullness) very inter-operable server side: an RPC call is made
交通大學資訊工程學系 蔡文能 RMI-第 99頁
Java RMI
Sending requests,
getting results
Sending requests,
getting results
Waiting for requests
(known location,known port)
Waiting for requests
(known location,known port)
Data in XML format
SOAP-based communication(Web Service)
SOAP: (Simple Object Access Protocol) Data in a well-defined XML format Transport over various protocols
HTTP, SMTP are the most used, perhaps because they are firewall-friendly
server side: either an RPC call or a message delivered
交通大學資訊工程學系 蔡文能 RMI-第 100頁
Java RMI
RPC / RMI
謝謝捧場http://www.csie.nctu.edu.tw/~tsaiwn/java/
蔡文能