Verteiltes Rechnen mit RMI

Verteiltes Rechnen
Verteilte Dienste mit Java Remote Method Invocation (RMI).
Prof. Dr. Nikolaus Wulff
Verteiltes Rechnen
• Anwendungen im WWW sind meist als Client-Server
Architekturen realisiert.
• Ein Client stellt Anfragen an einen entfernten Server.
– Per HTTP meistens als „primitive GET-Request“ mit einem
HTML Dokument als Rückgabewert.
– Programmierung „auf dem Draht“ mit primitiven
Datenstrukturen per Java (Server)Sockets.
• Java bietet zusätzlich die Möglichkeit höherwertige
Dienste als echte Java Objekte anzusprechen.
– HTTP basierte Web-Services via XML/SOAP und WSDL.
– Remote Method Invocation (RMI) mit Java generierten
Proxy und Adapter Klassen für Client und Server.
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
2
Verteilung und Nebenläufigkeit
• Neben des grundsätzlichen Vorteils, dass Client und
Server auf physisch getrennten Maschinen laufen,
bietet eine solche Architektur die Möglichkeit der
Parallelisierung und Lastverteilung.
• Der Preis hierfür ist der Geschwindigkeitsverlust
durch die Netzzugriffe und eine anfängliche
Lernkurve zum Erlernen dieser Technologie(n).
• RMI beinhaltet alle wesentlichen Bestandteile, die
auch in den weiterführenden J2EE Architekturen –
wie EJB oder Web-Services – Verwendung finden.
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
3
Architekturblaupause
• Der Service wird als (Java) Schnittstelle beschrieben.
• Serverseitig wird dieser Dienst implementiert.
• Der Client bekommt mit Hilfe eines Stellvertreterobjekts eine Referenz auf eine Implementierung der
Schnittstelle.
• Ein Naming-Service bietet eine Art „Telefonbuch“
(Yellow Pages) für registrierte Dienste an.
• Serverseitig registrieren sich die Dienste beim
Naming-Service, clientseitig werden sie gesucht.
• Client- und serverseitige Hilfsklassen werden passend
zur Schnittstellenbeschreibung mit RMIC generiert.
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
4
HelloWorld Pseudo Code
• Lokaler Methodenaufruf:
dauert ~ 1 - 4 NanoSec
HelloInterface h = new HelloImpl();
h.sayHello("HelloWorld");
• Remote Methodenaufruf:
dauert ~ 5 - 50 MilliSec !!!
HelloInterface h = HelloFactory.lookup("myServer","myObject");
h.sayHello("HelloWorld");
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
5
RMI Architektur
Remote
Interface
Client
Application
RMI
Stub
Class
Remote
Object
Skeleton
Class
Remote Reference Layer
Transport Layer (JRMP)
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
6
HelloWorld mit RMI
RMI
Framework
java.rmi.*
generated
by RMIC
Developer
defined
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
7
RMIC Generierung
• Seit JDK1.2 werden keine Quelltexte für die Stubund Proxy Klassen mehr auf der Platte oder im
Archive gespeichert.
• Mit den RMIC Parameter -v1.1 und -v.1.2 lässt sich
steuern für welches RMI Protokoll generiert wird.
• Werden beim Aufruf von RMIC die Parameter
-keepgenerated übergeben, so ist es möglich den
Quelltext dieser Klassen zu studieren.
– Seit 1.2 wird die java reflection API eingesetzt.
– -v1.1 generiert @deprecated Code.
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
8
Implementierung des Service
public class HelloImpl extends UnicastRemoteObject
implements HelloInterface {
/**
* Sole constructor.
* @throws RemoteException during remote IO binding
*/
protected HelloImpl() throws RemoteException {
super();
}
©
/* (non-Javadoc)
* @see de.lab4inf.rmi.HelloInterface#sayHello(java.lang.St
*/
@Override
public String sayHello(String msg) throws RemoteException {
String ret = format("[%s %s] msg: %s",this,
Thread.currentThread(),msg);
System.out.printf("sayHello %s\n",ret);
return ret;
}
Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
9
Gelbe Seiten
• Im Laufe der Zeit haben sich die Anforderungen an
die Registrierung von RMI Objekten verändert. Es
gibt inzwischen:
• Die java.rmi.registry.Registry
• Den java.rmi.Naming Service
• Und für Enterprise Anwendungen den JNDI –
Verzeichnisdienst das Java Naming and Directory
Interface, das in J2EE Anwendungen verwandt wird.
• Der Zweck bleibt gleich: Registriere ein Objekt unter
einer URL (bind) und mache es auffindbar im Netz
per (lookup)...
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
10
HelloClient mit RMI
public static void main(java.lang.String[] args)
throws Exception {
String url = “//localhost/hello“;
// 1. Referenz auf den Server per Naming Service
System.out.println("Suche Server "+url);
Remote ref = Naming.lookup(url);
// 2. Cast auf den gewünschten Typ
HelloInterface hello = (HelloInterface) ref;
System.out.println("Fand "+hello);
// 3. Remote Call ausführen
long time = System.currentTimeMillis();
hello.sayHello("Hello vom HelloClient "+time);
System.out.println("done ...");
}
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
11
Service Registrierung
public class HelloImpl extends UnicastRemoteObject
implements HelloInterface {
// ...
public static void main(java.lang.String[] args)
throws Exception {
String url = “//localhost/hello“;
// 1. Server Instanz erzeugen
System.out.println("Erzeuge Server");
HelloInterface hello = new HelloImpl();
// 2. Server Instanz beim Naming Service bekannt machen
System.out.println("Registriere Server "+hello);
Naming.rebind(url,hello);
System.out.println("Server "+url+" ready... “);
}
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
12
Testlauf
Wichtig: Vor dem Start des Servers muss die rmiregistry
mit entsprechendem Classpath gestartet sein, sonst
schlägt die Registrierung der Serverinstanz fehl.
$ java de.lab4inf.rmi.HelloImpl
verteilt
Erzeuge Server
multi-threaded
Registriere Server HelloImpl
[UnicastServerRef [liveRef: [endpoint:
[127.0.1.1:48796](local),objID:
[3ffe7dc9:134eaef05ce:-7fff, 6082581128767713112]]]]
Server rmi://localhost/hello ready...
sayHello [HelloImpl[UnicastServerRef [liveRef:
[endpoint:[127.0.1.1:48796](local),objID:
[3ffe7dc9:134eaef05ce:-7fff, 6082581128767713112]]]]
Thread[RMI TCP Connection(2)-127.0.0.1,5,RMI
Runtime]] msg: Hello vom HelloClient 1326791465704
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
13
Generierter Stub
public final class HelloImpl_Stub
extends java.rmi.server.RemoteStub
implements de.lab4inf.rmi.HelloInterface, java.rmi.Remote
{
private static final long serialVersionUID = 2;
private static java.lang.reflect.Method $method_sayHello_0;
de.lab4inf.rmi-Packagename entfernt ...
static {
try {
$method_sayHello_0 = HelloInterface.class.getMethod("sayHello",
new java.lang.Class[] {java.lang.String.class});
} catch (java.lang.NoSuchMethodException e) {
throw new java.lang.NoSuchMethodError("stub class initializ
}
}
• Der generierte Code verwendet die Reflection API,
um die Methodenzeiger zu finden/setzen....
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
14
Delegation an die Implementierung
// methods from remote interfaces
// implementation of sayHello(String)
public java.lang.String sayHello(java.lang.String $param_String_1)
throws java.rmi.RemoteException {
try {
Object $result = ref.invoke(this, $method_sayHello_0,
new java.lang.Object[] {$param_String_1}, 8370655165776887524L);
return ((java.lang.String) $result);
} catch (java.lang.RuntimeException e) {
throw e;
} catch (java.rmi.RemoteException e) {
throw e;
} catch (java.lang.Exception e) {
throw new java.rmi.UnexpectedException("undeclared checked exceptio
}
}
• Und per Reflection wird die implementierende
sayHello-Methode gerufen....
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
15
RMI wozu...?
• Mit RMI ist es möglich objektorientiert Dienste
verteilt anzubieten.
• Z.B. einen Script-Parser, den Differentiator oder …,
so dass rechenintensive Arbeiten auf entfernten
leistungsstarken Maschinen ausgeführt werden.
• Wird dies zusätzlich mit dem „Divide and Conquere“
Ansatz durchgeführt, so ist es möglich paralleles
Rechnen auf verteilten Maschinen durchzuführen.
• Dies lohnt sich immer dann, wenn der Zeitverlust
durch die Verteilung der Daten per Netz-IO geringer
ist als der Performanzvorteil der Parallelisierung.
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
16
RMI Pragmatik
• Es ist wichtig bei verteilten Anwendungen die richtige
Granularität der Aufrufe zu finden.
• Viele „kleine, verteilte“ Getter/Setter-Methoden
bremsen eine verteilte Anwendung komplett aus!
• Daher „Datenobjekte“ als verteilbare Container für
RMI Argumente verwenden. Diese sind dann meist
serialisierbar, werden „in einem Rutsch übertragen“
und für Enterprise-Anwendungnen zumeist generiert.
• Entsprechende Werkzeuge, wie z.B. XDoclet, Spring
und Hibernate unterstützen dies und es gibt zahlreiche
Architekturblaupausen für verteilte Anwendungen.
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
17
Zusammenfassung
• Java bietet mit den RMI Paketen eine Möglichkeit
verteilte objektorientierte Anwendungen mit
einfachen Mitteln zu entwickeln.
• Gegen eine Remote-Schnittstelle werden automatisch
Client-Proxies und Server-Adapter generiert.
• Ein Naming-Service liefert „Gelbe Seiten“.
• Lastverteilung und höherwertige Dienste wie z.B.
Autorisierung, Sicherheit, Transaktionen etc. fehlen.
• Diese Dienste werden mit der Java Enterprise Edition
(J2EE) zur Verfügung gestellt.
© Prof. Dr. Nikolaus Wulff
Höhere Programmierkonzepte
18

Download Report