Download Java Course -- Get Started

Programming in Java
RMI
蔡文能
交通大學資訊工程學系
[email protected]
http://www.csie.nctu.edu.tw/~tsaiwn/java/
交通大學資訊工程學系
Java
RMI
Agenda
RMI Introduction
RPC vs. RMI
RMI Deployment
RMI Example
交通大學資訊工程學系 蔡文能
10-第2頁
Java
交通大學資訊工程學系 蔡文能
RMI
10-第3頁
Java
交通大學資訊工程學系 蔡文能
RMI
10-第4頁
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.
交通大學資訊工程學系 蔡文能
10-第5頁
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
交通大學資訊工程學系 蔡文能
10-第6頁
Java
RMI
RMI Overview
Remote Method Invocation
 Java version of RPC
Object
Client
ha.nctu.edu.tw
交通大學資訊工程學系 蔡文能
network
method invocation
Remote
Object
Server
hehe.nctu.edu.tw
10-第7頁
Java
RMI
Remote Procedure Call (RPC)
Client
Server
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);
}
10-第8頁
Java
RMI
Middleware Layers
Applications
RPC, RMI, and events
Request reply
protocol
eXternal Data Representation(XDR)
Middleware
layers
Operating System
分層負責, 分工合作
交通大學資訊工程學系 蔡文能
10-第9頁
Java
RMI
RPC – Remote Procedure Call
There 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.
交通大學資訊工程學系 蔡文能
10-第10頁
Java
RMI
Sun RPC
RPCGEN
 There is a tool for automating the creation of RPC clients and
servers.
 The program rpcgen does most of the work for you.
 The input to rpcgen is a protocol definition in the form of a list of
remote procedures and parameter types.
交通大學資訊工程學系 蔡文能
10-第11頁
Java
RMI
RPCGEN
Protocol
Description
Input File
rpcgen
Client Stubs
foo_clnt.c
foo.xx
% rpcgen –C foo.xx
XDR filters header file
foo_xdr.c
foo.h
Server skeleton
foo_svc.c
C Source Code
交通大學資訊工程學系 蔡文能
10-第12頁
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 Generator
rpcgen
交通大學資訊工程學系 蔡文能
10-第13頁
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.
交通大學資訊工程學系 蔡文能
10-第14頁
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.
交通大學資訊工程學系 蔡文能
10-第15頁
Java
RMI
Procedure Identification
Each procedure is identified by:
 Hostname (IP Address)
 Program Identifier (32 bit integer)
 Procedure Identifier (32 bit integer)
 Program Version identifier
for testing and migration.
交通大學資訊工程學系 蔡文能
10-第16頁
Java
RMI
Program Identifiers
Each remote program has a unique ID.
Sun divided up the IDs:
0x00000000 - 0x1fffffff Sun
0x20000000 - 0x3fffffff SysAdmin
0x40000000 - 0x5fffffff Transient
0x60000000 - 0xffffffff Reserved
交通大學資訊工程學系 蔡文能
10-第17頁
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.
交通大學資訊工程學系 蔡文能
10-第18頁
Java
RMI
Iterative Server
Sun 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...
交通大學資訊工程學系 蔡文能
10-第19頁
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
交通大學資訊工程學系 蔡文能
10-第20頁
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);
}
交通大學資訊工程學系 蔡文能
10-第21頁
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 */
交通大學資訊工程學系 蔡文能
10-第22頁
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 */
交通大學資訊工程學系 蔡文能
10-第23頁
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);
}
交通大學資訊工程學系 蔡文能
10-第24頁
Java
RMI
RPC example (6/7)
File : test.xx
rpcgen –C test.xx
program TEST_PROG
{
version TEST_VERS
{
int ADDD(int)=1;
int DECC(int)=2;
}=1;
}=0x31234567;
交通大學資訊工程學系 蔡文能
10-第25頁
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
交通大學資訊工程學系 蔡文能
10-第26頁
Java
RMI
rpcgen –C test.xx
交通大學資訊工程學系 蔡文能
10-第27頁
Java
RMI
Test RPC -- Server Side
交通大學資訊工程學系 蔡文能
10-第28頁
Java
RMI
Test RPC -- Client Side
輸入兩列:
57
89
把第一個數加 1,
把第二個數減一
交通大學資訊工程學系 蔡文能
10-第29頁
Java
RMI
Another example of rpcgen file
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;
};
交通大學資訊工程學系 蔡文能
struct readargs {
FileIdentifier f;
FilePointer position;
Length length;
};
program FILEREADWRITE {
version VERSION {
void WRITE(writeargs)=1;
Data READ(readargs)=2; 2
}=2;
} = 9999;
10-第30頁
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 to
use TCP.
The High-Level library calls do not support any
kind of authentication.
交通大學資訊工程學系 蔡文能
10-第31頁
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
交通大學資訊工程學系 蔡文能
10-第32頁
Java
RMI
The General RMI Architecture
Remote Machine
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 stub.
交通大學資訊工程學系 蔡文能
bind
RMI Server
Registry
skeleton
return
call
lookup
stub
RMI Client
Local Machine
10-第33頁
Java
RMI
The Stub and Skeleton
Stub
RMI Client
skeleton
call
RMI Server
return
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 serverside 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.
交通大學資訊工程學系 蔡文能
10-第34頁
Java
RMI
Stubs
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.
交通大學資訊工程學系 蔡文能
10-第35頁
Java
RMI
skeletons
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
交通大學資訊工程學系 蔡文能
10-第36頁
Java
RMI
RMI (in Java)
“Flat” directory structure which attempts to provide
some notion of location transparency-- client code
uses a single name to find a server
Client
Code
Client
Stub
Naming
Service
Activation
Daemon
Implement “Factories”
using declarative
descriptions of
activatable objects
network
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
交通大學資訊工程學系 蔡文能
Server
Skeleton
Server
JVM
Object
Asociated
to Activation
Group
10-第37頁
Java
RMI
RMI Layers
Java Virtual Machine
Java Virtual Machine
Client
Object
Remote
Object
Stub
Skeleton
Remote Reference Layer
Remote Reference Layer
Transport Layer
交通大學資訊工程學系 蔡文能
TCP
Copyright ?1997 Alex Chaffee
Transport Layer
10-第38頁
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
交通大學資訊工程學系 蔡文能
10-第39頁
Java
RMI
Transport layer
Provides basic connectivity
 makes the connection between JVMs
Based on TCP/IP connections between machines in a
network
交通大學資訊工程學系 蔡文能
10-第40頁
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).
交通大學資訊工程學系 蔡文能
10-第41頁
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)
交通大學資訊工程學系 蔡文能
10-第42頁
Java
java.rmi.Naming
交通大學資訊工程學系 蔡文能
RMI
10-第43頁
Java
java.rmi.registry.LocateRegistry
交通大學資訊工程學系 蔡文能
RMI
10-第44頁
Java
java.rmi.registry.Registry
交通大學資訊工程學系 蔡文能
RMI
10-第45頁
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
交通大學資訊工程學系 蔡文能
10-第46頁
Java
RMI
Steps for Developing an RMI System
1. Define the Remote interface
2. Develop the remote object by implementing the remote interface.
3. Develop the client program.
4. Compile the Java source files.
5. Generate the client stubs and server skeletons.
6. Start the RMI registry.
7. Start the remote server objects.
8. Run the client
交通大學資訊工程學系 蔡文能
10-第47頁
Java
RMI
RMI Class Loading
 It’s all in the codebase
Source from which to load classes into JVM
 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 client
Classes downloaded from the client to the server using the
java.rmi.server.codebase property setup by the client
 RMI registry needs to find stub classes
If 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”
交通大學資訊工程學系 蔡文能
10-第48頁
Java
RMI
RMI
Downloading Stubs
交通大學資訊工程學系 蔡文能
10-第49頁
Java
RMI
RMI
Downloading Classes
交通大學資訊工程學系 蔡文能
10-第50頁
Java
RMI
Java Interfaces
Similar to Class
No implementation! All methods are abstract
(virtual for C++ ).
Everything is public.
No constructor
an Interface is an API that can be implemented by
a Class .
交通大學資訊工程學系 蔡文能
10-第51頁
Java
RMI
Interfaces and Inheritence
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.
交通大學資訊工程學系 蔡文能
10-第52頁
Java
RMI
Creating Remote object
1.
2.
3.
4.
Define an interface which extends Remote interface
Create the server program which implements that interface
Compile the Java program
Create the Stub
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.
交通大學資訊工程學系 蔡文能
10-第53頁
Java
RMI
Create the Stub
A.
B.
In JBuilder use “JNI/RMI” tab in class properties to
generate it automatically
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.
交通大學資訊工程學系 蔡文能
10-第54頁
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;
. . .
}
交通大學資訊工程學系 蔡文能
10-第55頁
Java
RMI
How the interface will be used
Remote Interface
extends
Your Interface
Class RemoteServer
provides methods
needed by
extends
UnicastRemoteObject
implements
extends
Class for your
Remote Object
交通大學資訊工程學系 蔡文能
10-第56頁
Java
RMI
Server Details – Implementation Class
Create a class that implements the interface.
 The class should also extend UnicastRemoteObject*
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.
*It doesn’t have to extend UnicastRemoteObject, there is another way…
交通大學資訊工程學系 蔡文能
10-第57頁
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.
交通大學資訊工程學系 蔡文能
10-第58頁
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) {
. . .
交通大學資訊工程學系 蔡文能
10-第59頁
Java
RMI
Client Details
The 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
交通大學資訊工程學系 蔡文能
10-第60頁
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
交通大學資訊工程學系 蔡文能
10-第61頁
Java
交通大學資訊工程學系 蔡文能
RMI
10-第62頁
Java
交通大學資訊工程學系 蔡文能
RMI
10-第63頁
Java
交通大學資訊工程學系 蔡文能
RMI
10-第64頁
Java
交通大學資訊工程學系 蔡文能
RMI
10-第65頁
Java
交通大學資訊工程學系 蔡文能
RMI
10-第66頁
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 servers
Essential 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 name
交通大學資訊工程學系 蔡文能
10-第67頁
Java
RMI
RMI registry (2/2)
Names in the registry use unique names
 Recommend the name of the remote class that implements
the remote interface
For 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)
交通大學資訊工程學系 蔡文能
10-第68頁
Java
交通大學資訊工程學系 蔡文能
RMI
10-第69頁
Java
交通大學資訊工程學系 蔡文能
RMI
10-第70頁
Java
交通大學資訊工程學系 蔡文能
RMI
10-第71頁
Java
RMI
Start the Java RMI registry
By 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);
交通大學資訊工程學系 蔡文能
10-第72頁
Java
交通大學資訊工程學系 蔡文能
RMI
10-第73頁
Java
RMI
Java RMI classes
Java.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 , LocateRegistry
java.rmi.RMISecurityManager
 Validates rights to access downloaded object
交通大學資訊工程學系 蔡文能
10-第74頁
Java
RMI
Other Technologies
 CORBA
 XML based
SOAP / Web Service
 J2EE/EJB
 MicroSoft’s .NET
Has Common Language Runtime
Tight Integration of Web Services and XML
Multiple language integration
 However only one platform Windows
交通大學資訊工程學系 蔡文能
10-第75頁
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
 JavaIDL
java.sun.com/docs/books/tutorial/idl
java.sun.com/products/jdk/idl/
www.omg.org/news/begin.htm
 Jini
www.artima.com/jini/resources
交通大學資訊工程學系 蔡文能
10-第76頁
Java
交通大學資訊工程學系 蔡文能
RMI
10-第77頁
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.
交通大學資訊工程學系 蔡文能
10-第78頁
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 modeling
Better 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
交通大學資訊工程學系 蔡文能
10-第79頁
Java
RMI
RPC / RMI
謝謝捧場
http://www.csie.nctu.edu.tw/~tsaiwn/java/
蔡文能
交通大學資訊工程學系 蔡文能
10-第80頁