Client/Server-Programmierung - Betriebssysteme und verteilte

Client/Server-Programmierung
WS 2013/2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
.d
[email protected] e
rolanda
Tel.: 0271/740-4050, Büro: H-B 8404
Stand: 23. April 2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
i
Client/Server-Programmierung (1/12)
Inhaltsverzeichnis
0 Organisation
1
1 Grundlagen: Wiederholung
18
1.1 Architekturmodelle . . . . . . . . . . . . . . . . . . . . 20
1.2 Zeit und Zustand in verteilten Systemen . . . . . . . . . 26
1.3 Middleware . . . . . . . . . . . . . . . . . . . . . . . . 34
1.3.1 Kommunikationsorientierte Middleware . . . . . . 36
1.3.2 Anwendungsorientierte Middleware . . . . . . . . 43
1.4 Java RMI . . . . . . . . . . . . . . . . . . . . . . . . . 46
2 Java Database Connectivity (JDBC)
1-1
54
2.1 Überblick . . . . . . . . . . . . . . . . . . . . . . . . . 55
2.2 Relationale Datenbanken und SQL . . . . . . . . . . . . 56
2.3 Architektur von JDBC . . . . . . . . . . . . . . . . . . . 59
2.4 Ein Beispiel . . . . . . . . . . . . . . . . . . . . . . . . 64
2.5 Details zu JDBC . . . . . . . . . . . . . . . . . . . . . 67
2.6 Zusammenfassung . . . . . . . . . . . . . . . . . . . . 76
3 CORBA
77
3.1 Einführung . . . . . . . . . . . . . . . . . . . . . . . . 80
3.2 CORBA Architektur . . . . . . . . . . . . . . . . . . . . 81
3.2.1 Object Management Architecture (OMA)
. . . . . 81
3.2.2 Common Object Request Broker Architecture (CORBA) . . . . . . . . . . . . . . . . . . . . . . . . 85
1-2
3.2.3 CORBA-Dienste . . . . . . . . . . . . . . . . . . 92
3.3 Hello World mit CORBA . . . . . . . . . . . . . . . . . 95
3.4 CORBA im Detail . . . . . . . . . . . . . . . . . . . . . 112
3.4.1 OMG IDL und Java-Mapping
. . . . . . . . . . . 112
3.4.2 Name Service . . . . . . . . . . . . . . . . . . . 134
3.4.3 Factories . . . . . . . . . . . . . . . . . . . . . 138
3.4.4 Delegation und Tie-Klassen . . . . . . . . . . . . 142
3.4.5 Statische und dynamische Aufrufe . . . . . . . . . 147
3.4.6 Portable Object Adapter (POA) . . . . . . . . . . 150
3.4.7 GIOP, IIOP und IOR . . . . . . . . . . . . . . . . 165
3.4.8 Implementation Repository (IMR) . . . . . . . . . 170
3.4.9 Interface Repository (IR) . . . . . . . . . . . . . 174
1-3
3.4.10 Sicherheit . . . . . . . . . . . . . . . . . . . . 178
3.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . 179
4 RMI / IIOP
180
5 Java Komponenten-Modelle
190
5.1 Komponenten-Modelle . . . . . . . . . . . . . . . . . . 192
5.2 Komponentenmodelle in Java EE . . . . . . . . . . . . . 198
5.3 JavaBeans . . . . . . . . . . . . . . . . . . . . . . . . 200
5.3.1 Ereignisse . . . . . . . . . . . . . . . . . . . . . 209
5.3.2 Properties . . . . . . . . . . . . . . . . . . . . . 216
5.3.3 Persistenz . . . . . . . . . . . . . . . . . . . . . 220
5.3.4 Introspektion
. . . . . . . . . . . . . . . . . . . 221
1-4
5.3.5 Zusammenfassung . . . . . . . . . . . . . . . . 224
5.4 Enterprise Java Beans (EJB 3.0) . . . . . . . . . . . . . 225
5.4.1 Arten von EJBs . . . . . . . . . . . . . . . . . . 230
5.4.2 Anatomie einer EJB-Anwendung . . . . . . . . . 232
5.4.3 Einschub: Java Annotationen . . . . . . . . . . . 235
5.4.4 Beispiel Hello World . . . . . . . . . . . . . . . . 239
5.4.5 Einschub: OpenEJB . . . . . . . . . . . . . . . . 244
5.4.6 Dienste des EJB-Containers
. . . . . . . . . . . 251
5.4.7 Der Deployment-Deskriptor ejb-jar.xml . . . . . 254
5.4.8 Session Beans: Details . . . . . . . . . . . . . . 261
5.4.9 Entities: Details . . . . . . . . . . . . . . . . . . 275
5.4.10 Transaktionen . . . . . . . . . . . . . . . . . . 295
1-5
5.4.11 Zusammenfassung . . . . . . . . . . . . . . . . 303
6 Servlets und JSP
6.1 Servlets
304
. . . . . . . . . . . . . . . . . . . . . . . . . 306
6.1.1 Grundlagen . . . . . . . . . . . . . . . . . . . . 307
6.1.2 Einschub: Web-Server im Labor . . . . . . . . . . 310
6.1.3 Beispiel: Hello-World Servlet
. . . . . . . . . . . 312
6.1.4 Lebenszyklus eines Servlets
. . . . . . . . . . . 318
6.1.5 Wichtige Klassen und Methoden
6.1.6 Sitzungs-Management
. . . . . . . . . 319
. . . . . . . . . . . . . . 320
6.2 Java Server Pages (JSP) . . . . . . . . . . . . . . . . . 324
6.2.1 Spezielle Tags für JSP
. . . . . . . . . . . . . . 325
1-6
6.2.2 Vordefinierte Variablen
. . . . . . . . . . . . . . 328
6.2.3 Beispiele . . . . . . . . . . . . . . . . . . . . . 329
6.2.4 JSP Direktiven
. . . . . . . . . . . . . . . . . . 332
6.2.5 JSP und Java Beans
. . . . . . . . . . . . . . . 333
6.3 Zusammenfassung . . . . . . . . . . . . . . . . . . . . 334
7 Web Services
335
7.1 Einführung . . . . . . . . . . . . . . . . . . . . . . . . 338
7.2 Web-Service-Standards . . . . . . . . . . . . . . . . . 341
7.2.1 XML (Extensible Markup Language) . . . . . . . . 342
7.2.2 SOAP . . . . . . . . . . . . . . . . . . . . . . . 353
7.2.3 WSDL . . . . . . . . . . . . . . . . . . . . . . . 366
1-7
7.2.4 Nutzung von SOAP und WSDL . . . . . . . . . . 381
7.2.5 UDDI . . . . . . . . . . . . . . . . . . . . . . . 383
7.3 Web-Services und EJB . . . . . . . . . . . . . . . . . . 389
7.4 Web Services mit Axis2
. . . . . . . . . . . . . . . . . 390
7.4.1 Technisches zu Axis2 . . . . . . . . . . . . . . . 391
7.4.2 Beispiel: Hello-World mit Axis2
. . . . . . . . . . 393
7.4.3 Details zu den Axis2-Werkzeugen . . . . . . . . . 398
7.4.4 Sitzungs-Management mit Axis2
. . . . . . . . . 408
7.4.5 Axis2 Module . . . . . . . . . . . . . . . . . . . 416
7.5 Web Services und Sicherheit . . . . . . . . . . . . . . . 424
7.5.1 Nutzung von Tomcat6 mit TLS/SSL . . . . . . . . 425
7.5.2 Passwort-Authentifizierung mit Tomcat6 und Axis2 427
1-8
7.5.3 Nutzung der WS Security Paradigmen
. . . . . . 429
7.6 Zusammenfassung . . . . . . . . . . . . . . . . . . . . 436
8 Weitere Client/Server-Technologien
437
8.1 Technologien zur Netzwerkprogrammierung . . . . . . . 438
8.2 Technologien für dynamische WWW-Seiten
8.3 Microsoft .Net und DCOM
. . . . . . . 440
. . . . . . . . . . . . . . . . 442
1-9
Client/Server-Programmierung
WS 2013/2014
0
Organisation
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
1
Zu meiner Person
➥ Studium der Informatik an der Techn. Univ. München
➥ dort 1994 promoviert, 2001 habilitiert
➥ Seit Apr. 2004 Prof. für Betriebssysteme und verteilte Systeme an
der Univ. Siegen
➥ Forschung: Beobachtung, Analyse und Steuerung paralleler und
verteilter Systeme
➥ Mentor für die Bachelor-/Master-Studiengänge Informatik mit
Nebenfach/Vertiefung Mathematik
➥ e-mail: rolanda
.d
wismuellera
@duni-siegena
.d e
➥ Tel.: 0271/740-4050
➥ Büro: H-B 8404
➥ Sprechstunde: Mo., 14:15-15:15 Uhr
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
2
Zur Fachgruppe “Betriebssysteme / verteilte Systeme“
Andreas Hoffmann
Adrian Kacso
andreas.hoffmann@uni−siegen.de
adrian.kacso@uni−siegen.de
0271/740−4047
H−B 8405
0271/740−3966
H−B 8406
Elektronische Prüfungs− und
Übungssysteme an Hochschulen
IT−Sicherheit
Webtechnologien
Mobile Anwendungen
Kommunikationsprotokolle für
drahtlose Sensornetze
Kommunikation und Koordination
in verteilten Systemen
Betriebssysteme (RT, Embedded)
Julia Dauwe
Alexander Kordes
julia.dauwe@uni−siegen.de
0271/740−2967
H−B 8405
alexander.kordes@uni−siegen.de
0271/740−4011
H−B 8407
Context Aware Systems
Bring Your Own Device (BYOD)
Mobile Anwendungen und
Datenschutz
Roland Wismüller
Betriebssysteme / verteilte Systeme
Automotive Electronics
Fahrzeugnetzwerke
Robustheit, Fehleranalyse,
Fehlerdetektion
Client/Server-Programmierung (1/12)
3
Lehrangebot
Vorlesungen/Praktika
➥ Rechnernetze I, 5 LP (jedes SS)
➥ Rechnernetze II, 5 LP (jedes WS)
➥ Rechnernetze Praktikum, 5 LP (jedes WS)
➥ Betriebssysteme I, 5 LP (jedes WS)
➥ Parallelverarbeitung, 5 LP (jedes SS)
➥ Verteilte Systeme, 5 LP (jedes SS)
➥ alte BS II ohne Echtzeitsysteme, mit RMI-Programmierung
➥ Client/Server-Programmierung, 5 LP (jedes WS)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
4
Lehrangebot ...
Projektgruppen
➥ z.B. Werkzeug zur Algorithmen-Visualisierung
➥ z.B. Infrastruktur zum Analysieren des Android Market
Abschlussarbeiten (Bachelor, Master, Diplom)
➥ Themengebiete: Mobile Plattformen (iOS, Android), Sensornetze,
Parallelverarbeitung, Monitoring, ...
➥ z.B. Statische Analyse des Informationsflusses in Android Apps
Seminare
➥ Themengebiete: Webtechnologien, Sensornetze, Android, ...
➥ Ablauf: Blockseminare
➥ 30 Min. Vortrag, 5000 Worte Ausarbeitung
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
5
Zur Vorlesung
➥ Vorlesung: 2 SWS
➥ Fr., 12:30 - 14:00, H-F 116
➥ Praktikum: 2 SWS
➥ Terminvereinbarung: jetzt
➥ Information, Folien und Ankündigungen:
➥ http://www.bs.informatik.uni-siegen.de/www/lehre/
ws1314/csp
➥ vollständiger Foliensatz ist verfügbar
➥ Folien werden z.T. etwas aktualisiert
➥
Ziel: aktualisierte Folien stehen spätestens am Tag vor der
Vorlesung bereit (als PDF)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
6
Lernziele
➥ Wissen um die Grundlagen, Techniken, Methoden und
Werkzeuge der verteilten Programmierung
➥ insbesondere objektorientierte und serviceorientierte
Middleware, sowie Komponenten
➥ Praktische Erfahrungen in der Programmierung von
Client/Server-Anwendungen
➥ Praktische Erfahrungen im Umgang mit unterschiedlicher
Middleware
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
7
Methodik
➥ Vorlesung: Grundlagen
➥ theoretisches Wissen zur verteilten Systemen, Middleware
und Komponenten
➥ Code-Beispiele und Tutorials“
”
➥ Praktikum: praktische Anwendung
➥ Nachvollziehen der Tutorials
➥ eigenständige Programmierarbeit
➥
praktische Erfahrung, auch: Aufwerfen von Fragen
➥ Realisierung einer kleinen Börsenanwendung
➥ mit RMI, CORBA, EJB und Web Services
➥ zusätzlich kleinere einführende und weiterführende Aufgaben
➥ Programmierung ausschließlich in Java
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
8
Prüfung
➥ Mündliche Prüfung
➥ Dauer ca. 40 min.
➥ Stoff: Vorlesung und Praktikum!
➥ Prüfung erstreckt sich auch auf die praktischen Arbeiten
➥ aktive Teilnahme am Praktikum ist Zulassungs-Voraussetzung!
➥ Anmeldung:
➥ Terminabsprache im Sekretariat bei Fr. Baule
➥
per Email (andreaa
.d
baulea
@d
uni-siegena
.de)
➥ oder persönlich (H-B 8403, vormittags)
➥ Anmeldung beim Prüfungsamt
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
9
Organisatorisches zum Praktikum
➥ Zum Kartenschlüsselantrag:
➥ http://www.bs.informatik.uni-siegen.de/www/lehre/
ws1314/csp
➥ Abgabe bis bis 25.10. bei Fr. Baule, H-B 8403 (vormittags)
oder in der Vorlesung
➥ Praktikumsbeginn: nächste Woche
➥ Einführung in die Rechner-Umgebung (Linux)
➥ Ausgabe der Kennungen
➥
Benutzungsvereinbarung im WWW beachten!
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
10
Rechnerumgebung im Labor H-A 4111
➥ Linux-PCs, privates IP-Netz, beschränkter Internet-Zugang
Fachgruppennetz (bs.informatik.uni−siegen.de) / Internet
Server−Cluster
(je 2 x XEON
Dual Core, 64bit
2,66 GHz, 4 GB)
ssh (nur pubkey)
bvsclk01 bvsclk02 bvsclk03 bvsclk04
bsclk01 bsclk02 bsclk03 bsclk04
File
Server
Labornetz
(lab.bvs) 1 Gbit/s
http
00
11
00
00
11
00
11
00
11
00
11
... 11
...
ftp
00
11
00
11
00
11
00
11
00
11
00
11
HTTP
https Proxy bslab01−06,11−12,14−18 bslab07 − bslab10 bslab13, bslab19
13 Arbeitsplätze
(Core2 Duo mit HT
3,3 GHz, 4 GB)
Roland Wismüller
Betriebssysteme / verteilte Systeme
4 Arbeitsplätze
2 Arbeitsplätze
(AMD 64bit
(Core2 Duo, 64bit
2,4 GHz, 2/3GB) 2,33 GHz, 2/4GB)
Client/Server-Programmierung (1/12)
11
Inhalt der Vorlesung
➥ Grundlagen: Wiederholung
➥ Architekturmodelle
➥ Zeit und Zustand in verteilten Systemen
➥ Middleware
➥ Java RMI
➥ Java Datenbank-Schnittstelle JDBC
➥ CORBA
➥ Architektur, Dienste, IDL, ...
➥ Java Komponenten-Modelle
➥ Einführung
➥ Java Beans
➥ Enterprise Java Beans
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
12
Inhalt der Vorlesung ...
➥ Servlets und JSP
➥ Web Services
➥ XML, SOAP, WSDL, UDDI, ...
➥ Axis2
➥ Weitere Client/Server-Technologien
➥ u.a. .NET, DCOM
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
13
Grober Zeitplan
18.10.
25.10.
08.11. / 15.11. / 22.11. / 29.11.
06.12. / 13.12. / 10.01.
17.01. / 24.01. / 31.01.
07.02.
Roland Wismüller
Betriebssysteme / verteilte Systeme
Grundlagen
JDBC
CORBA
Komponenten-Modelle
Web Services
Weitere Client/Server-Technologien
Client/Server-Programmierung (1/12)
14
Literatur
Allgemeinere Literatur
➥ Ulrike Hammerschall, Verteilte Systeme und Anwendungen.
Pearson Studium, 2005.
➥ Robert Orfali, Dan Harkey, Client/Server-Programming with Java
and Corba. John Wiley & Sons, 1998.
Verteilte Systeme
➥ George Coulouris, Jean Dollimore, Tim Kindberg. Verteilte
Systeme – Konzepte und Design, 3. Auflage. Pearson Studium,
2002.
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
15
Literatur ...
Verteilte Programmierung mit Java
➥ Cay S. Horstmann, Gary Cornell. Core Java 2, Band 2 –
Expertenwissen. Sun Microsystems Press / Addison Wesley,
2008.
➥ Torsten Langner. Verteilte Anwendungen mit Java.
Markt+Technik, 2002.
➥ Jim Farley, William Crawford, David Flanagan. Java Enterprise in
a Nutshell, 3rd Edition. O’Reilly, 2005.
CORBA und COM
➥ Johann Hofmann, Fritz Jobst, Roland Schabenberger.
Programmieren mit COM und CORBA, Hanser, 2001.
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
16
Literatur ...
Enterprise JavaBeans
➥ Rima P. Sriganesh, Gerald Brose, Micah Silverman. Mastering
Enterprise JavaBeans 3.0. Wiley, 2006.
➥ Bill Burke, Richard Monson-Haefel. Enterprise JavaBeans 3.0,
5th Edition. O’Reilly, 2006.
Servlets
➥ Jason Hunter, William Crawford. Java Servlet Programmierung.
O’Reilly, 2002.
Web Services
➥ Manfred Hein, Henner Zeller. Java Web Services,
Addison-Wesley, 2003.
➥ Torsten Langner. Web Services mit Java, Markt+Technik, 2003.
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
17
Client/Server-Programmierung
WS 2013/2014
1
Grundlagen: Wiederholung
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
18
1 Grundlagen: Wiederholung ...
Inhalt
➥ Architekturmodelle
➥ Zeit und Zustand in verteilten Systemen
➥ Middleware
➥ Java RMI
Roland Wismüller
Betriebssysteme / verteilte Systeme
19
Client/Server-Programmierung (1/12)
1.1 Architekturmodelle
Client/Server-Modell
➥ Asymmetrisches Modell: Server stellen Dienste bereit, die von
(mehreren) Clients genutzt werden können
➥ Server verwalten i.a. Ressourcen (zentralisiert)
Client
Aufruf
Ergebnis
Client
Aufruf
Server
Server
Ergebnis
Prozeß
Rechner
Server kann selbst
wieder als Client agieren
➥ Häufigstes Modell für verteilte Anwendungen (ca. 80 %)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
20
1.1 Architekturmodelle ...
Client/Server-Modell ...
➥ I.A. nebenläufige Anfragen mehrerer Client-Prozesse an den
Server-Prozeß
Start
Client
Anfrage
(request)
Ende
Antwort
(reply)
Zeit
Server
Client
➥ Beispiele: Dateiserver, WWW-Server, DB-Server, DNS-Server, ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
21
1.1 Architekturmodelle ...
n-Tier-Architekturen
➥ Verfeinerungen der Client/Server-Architektur
➥ Modelle zur Verteilung einer Anwendung auf die Knoten einer
verteilten Systems
➥ Vor allem bei Informationssystemen verwendet
➥ Tier (engl. Schicht / Stufe) kennzeichnet einen unabhängigen
Prozeßraum innerhalb einer verteilten Anwendung
➥ Prozeßraum kann, muß aber nicht physischem Rechner
entsprechen
➥ mehrere Prozeßräume auf einem Rechner möglich
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
22
1.1 Architekturmodelle ...
2-Tier-Architektur
➥ Client- und Server-Tier
➥ Keine eigene Tier für die Anwendungslogik
Präsentation
Client−Tier
Anwendungslogik
(Verteilung auf Client−
und Server−Tier variiert)
Server−Tier
Datenhaltung
➥ Vorteil: einfach, performant
➥ Nachteil: schwer wartbar, schlecht skalierbar
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
23
1.1 Architekturmodelle ...
3-Tier-Architektur
Client−Tier
Präsentation
Middle−Tier
Anwendungslogik
Server−Tier
Datenhaltung
➥ Standard-Verteilungsmodell für einfache Web-Anwendungen:
➥ Client-Tier : Web-Browser zur Anzeige
➥ Middle-Tier : Web-Server mit Servlets / JSP / ASP
➥ Server-Tier : Datenbank-Server
➥ Vorteile: Anwendungslogik zentral administrierbar, skalierbar
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
24
1.1 Architekturmodelle ...
(Animierte Folie)
Beispiel: typische Internet-Anwendung
DMZ
Internet
1
0
Web−
Client
Firewall
1
0
0
1
00
11
00
11
00 1
11
00
11
0 11
1
0
00
00
11
0
1
0
1
00
11
00
11
000
111
000
111
0111
1
0000
1
000
000 111
111
000
111
Firewall
Web−
Client
Intranet
11
00
00
11
00
11
00
11
000
111
000
111
000
000 111
111
000 111
000
111
Web−
Server
Tier 1
Roland Wismüller
Betriebssysteme / verteilte Systeme
11
00
00
11
00
11
00
11
000
111
000
111
000
111
000
111
Web−
Server
Anwen−
dungs−
Server
Daten−
bank−
Server
Tier 2
Tier 3
Tier 4
Client/Server-Programmierung (1/12)
25
1.2 Zeit und Zustand in verteilten Systemen
Was ist der Unterschied zwischen einem verteilten System und
einem Ein-/Mehrprozessorsystem?
➥ Ein- bzw. Mehrprozessorsystem:
➥ nebenläufige Prozesse: pseudo-parallel durch time sharing
bzw. echt parallel
➥ globale Zeit: alle Ereignisse in den Prozessen lassen sich
zeitlich eindeutig ordnen
➥ globaler Zustand: zur jeder Zeit kann ein eindeutiger Zustand
des Systems angegeben werden
➥ Verteiltes System
➥ echte Parallelität
➥ keine globale Zeit
➥ kein eindeutiger globaler Zustand
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
26
1.2 Zeit und Zustand in verteilten Systemen ...
Globale Zeit
➥ Auf Ein-/Mehrprozessorsystem
➥ jedem Ereignis kann (zumindest theoretisch) ein eindeutiger
Zeitstempel derselben lokalen Uhr zugeordnet werden
➥ bei Mehrprozessorsystemen: Synchronisation am
gemeinsamen Speicher
➥ In verteilten Systemen:
➥ viele lokale Uhren (eine pro Knoten)
➥ exakte Synchronisation der Uhren (prinzipiell!) nicht möglich
➥ ⇒ Reihenfolge von Ereignissen auf verschiedenen Knoten
nicht (immer) eindeutig zu ermitteln
➥ (vgl. spezielle Relativitätstheorie)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
27
1.2 Zeit und Zustand in verteilten Systemen ...
Eine Auswirkung der Verteiltheit
➥ Szenario: zwei Prozesse beobachten zwei andere Prozesse
x
Beobachter A
Prozess 1
x
Prozess 2
Beobachter B
y
z
y
z
z x
y
➥ Die Beobachter sehen die Ereignisse ggf. in unterschiedlicher
Reihenfolge!
➥ Problem z.B., falls die Beobachter replizierte Datenbanken und
die Ereignisse Datenbank-Updates sind
➥ Replikate sind nicht mehr konsistent!
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
28
1.2 Zeit und Zustand in verteilten Systemen ...
Die Lamport’sche Kausalitätsrelation
➥ In zwei Fällen kann die Reihenfolge von Ereignissen auch ohne
globale Uhr bestimmt werden:
➥ falls die Ereignisse im selben Prozeß sind, reicht lokale Uhr
➥ das Senden einer Nachricht ist immer vor deren Empfang
➥ Definition der Kausalitätsrelation → (happened before)
➥ falls Ereignisse a, b im selben Prozeß i sind und ti (a) < ti (b)
(ti : Zeitstempel mit Uhr von i), so gilt a → b
➥ falls a das Senden einer Nachricht und b deren Empfang ist,
so gilt a → b
➥ falls a → b und b → c, so gilt auch a → c (Transitivität)
➥ a → b bedeutet, daß b kausal von a abhängen kann
Roland Wismüller
Betriebssysteme / verteilte Systeme
29
Client/Server-Programmierung (1/12)
1.2 Zeit und Zustand in verteilten Systemen ...
Beispiele
a
Prozeß 4
k
g
c
Prozeß 2
Prozeß 3
i
b
Prozeß 1
d
f
h
j
e
l
➥ Hier gilt u.a.:
➥ b → i und a → h (Ereignisse im selben Prozeß)
➥ c → d und e → f (Senden / Empfang einer Nachricht)
➥ c → k und a → i (Transitivität)
➥ g 6→ l und l 6→ g: l und g sind nebenläufig (concurrent)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
30
1.2 Zeit und Zustand in verteilten Systemen ...
Globaler Zustand: Ein Beispiel zur Motivation
➥ Szenario: Peer-to-Peer -Anwendung, Prozesse senden sich
gegenseitig Aufträge
➥ Frage: wann kann die Anwendung terminieren?
➥ Falsche Antwort: wenn kein Prozeß mehr einen Auftrag
bearbeitet
➥ Grund: Aufträge können noch in Nachrichten unterwegs sein!
Prozeß 1
Prozeß 2
Auftrag
idle
idle
➥ Weitere Anwendungen: verteilte Garbage-Collection, verteilte
Deadlock -Erkennung, ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
31
1.2 Zeit und Zustand in verteilten Systemen ...
➥ Wie bestimmt sich der Gesamtzustand eines verteilten Prozeßsystems?
➥ naiv: Summe der Zustände aller Prozesse (falsch!)
➥ Zwei Aspekte müssen beachtet werden:
➥ Nachrichten, die noch in Übertragung sind
➥
müssen mit in den Zustand aufgenommen werden
➥ Fehlen einer globalen Zeit
➥
ein Globalzustand zur Zeit t kann nicht definiert werden!
➥ Zustände der Prozesse beziehen sich immer auf lokale
(und damit unterschiedliche) Zeiten
➥ Frage: Bedingung an die lokalen Zeiten? ⇒ konsistente
Schnitte
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
32
1.2 Zeit und Zustand in verteilten Systemen ...
(Animierte Folie)
Konsistente Schnitte
➥ Ziel: bilde aus (nicht zeitgleich ermittelten) lokalen Zuständen
einen sinnvollen globalen Zustand
➥ Prozesse modelliert durch Folgen von Ereignissen:
Prozeß 1
Prozeß 2
Prozeß 3
konsistente Schnitte
inkonsistenter Schnitt
➥ Schnitt: betrachte in jedem Prozeß ein Präfix der Ereignisfolge
➥ Konsistenter Schnitt:
➥ falls der Schnitt den Empfang einer Nachricht beinhaltet, so
beinhaltet er auch das Senden dieser Nachricht
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
33
1.3 Middleware
Verteilte Anwendung (VA)
VA−
Komponente
VS−Knoten
VA−
Komponente
Netz
VS−Knoten
Verteiltes System (VS)
Verteilte Anwendung (VA)
VA−
VA−
Komponente
Komponente
Middleware Netz Middleware
VS−Knoten
VS−Knoten
Verteiltes System (VS)
➥ VA nutzt VS für Kommunikation zwischen ihren Komponenten
➥ VSe bieten i.a. nur einfache Kommunikationsdienste an
➥ direkte Nutzung: Netzwerkprogrammierung
➥ Middleware bietet intelligentere Schnittstellen
➥ verbirgt Details der Netzwerkprogrammierung
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
34
1.3 Middleware ...
➥ Middleware ist Schnittstelle zwischen verteilter Anwendung und
verteiltem System
➥ Ziel: Verbergen der Verteilungsaspekte vor der Anwendung
➥ u.a. Zugriffs- und Orts-Transparenz
➥ Middleware kann auch Zusatzdienste für Anwendungen bieten
➥ starke Unterschiede bei existierender Middleware
➥ Unterscheidung:
➥ kommunikationsorientierte Middleware
➥
(nur) Abstraktion von der Netzwerkprogrammierung
➥ anwendungsorientierte Middleware
➥
neben Kommunikation steht Unterstützung verteilter
Anwendungen im Mittelpunkt
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
35
1.3.1 Kommunikationsorientierte Middleware
➥ Fokus: Bereitstellung einer Kommunikationsinfrastruktur für
verteilte Anwendungen
➥ Aufgaben:
➥ Kommunikation
➥ Behandlung der Heterogenität
➥ Fehlerbehandlung
Anwendung
Kommunikationsorientierte
Middleware
Betriebssystem / verteiltes System
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
36
1.3.1 Kommunikationsorientierte Middleware ...
Entfernter Prozeduraufruf (RPC, Remote Procedure Call)
➥ Ermöglicht einem Client den Aufruf einer Prozedur in einem
entfernten Server-Prozeß
Client−
Prozeß
y = P(x);
Eingabeparameter
Resultate
P(a) {
Server−
...
return b; Prozeß
}
➥ Kommunikation nach Anfrage / Antwort-Prinzip
Entfernter Methodenaufruf (RMI, Remote Method Invocation)
➥ Ermöglicht einem Objekt, Methoden eines entfernten Objekts
aufzurufen
➥ Prinzipiell sehr ähnlich zu RPC
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
37
1.3.1 Kommunikationsorientierte Middleware ...
Gemeinsame Grundkonzepte entfernter Aufrufe
➥ Client und Server werden durch Schnittstellendefinition entkoppelt
➥ legt Namen der Aufrufe, Parameter und Rückgabewerte fest
➥ Einführung von Client-Stubs und Server-Stubs (Skeletons) als
Zugriffsschnittstelle
➥ werden automatisch aus Schnittstellendefinition generiert
➥
IDL-Compiler, Interface Definition Language
➥ sind verantwortlich für Marshalling / Unmarshalling
sowie für die eigentliche Kommunikation
➥ realisieren Zugriffs- und Ortstransparenz
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (1/12)
38
1.3.1 Kommunikationsorientierte Middleware ...
Funktionsweise der Client- und Server-Stubs (RPC)
Server−Prozeß
Client−Prozeß
Client−Stub
y=P(x)
Server−Skeleton
P(a) {
Argumente a in
Nachricht m1 packen
send(Server, m1);
receive(Server, m2) ;
Ergebnis b aus Nach−
richt m2 auspacken
}
return b;
Roland Wismüller
Betriebssysteme / verteilte Systeme
while (true) {
receive(m1);
client=sender(m1);
Argumente x aus Nach−
richt m1 auspacken
y = P(x) ;
Ergebnis y in Nach−
richt m2 packen
send(client, m2);
}
P(a) {
...
return b;
}
Client/Server-Programmierung (1/12)
39
Client/Server-Programmierung
WS 2013/2014
25.10.2013
Roland Wismüller
Betriebssysteme / verteilte Systeme
.d
[email protected] e
rolanda
Tel.: 0271/740-4050, Büro: H-B 8404
Stand: 23. April 2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (2/12)
i
1.3.1 Kommunikationsorientierte Middleware ...
Basis von RMI: Das Proxy-Pattern
➥ Client arbeitet mit Stellvertreterobjekt (Proxy) des eigentlichen
Serverobjekts
➥ Proxy und Serverobjekt implementieren dieselbe Schnittstelle
➥ Client kennt / nutzt lediglich diese Schnittstelle
<<interface>>
Schnittstelle
Client
Proxy
Roland Wismüller
Betriebssysteme / verteilte Systeme
Objekt
40
Client/Server-Programmierung (2/12)
1.3.1 Kommunikationsorientierte Middleware ...
Ablauf eines entfernten Methodenaufrufs
Client−Rechner
Server−Rechner
Client
Server
Selbe Schnitt−
stelle wie beim
Objekt
Client ruft
eine
Methode
auf
Proxy
Client−BS
Netzwerk
Roland Wismüller
Betriebssysteme / verteilte Systeme
Skeleton ruft
dieselbe
Methode für
das Objekt auf
Objekt
Status
Methode
Skeleton
Schnitt−
stelle
Server−BS
Verpackter Aufruf wird über das Netzwerk weitergegeben
(Objekt−ID, Methodenname, Parameter)
Client/Server-Programmierung (2/12)
41
1.3.1 Kommunikationsorientierte Middleware ...
Erstellung eines Client/Server-Programms
Server−
Prozeduren
Compiler
Server
Server−Skel.
Schnittstellen−
beschreibung
RPC/RMI
Laufzeit−
Bibliothek
IDL−
Compiler
Client−Stubs
Client−
Programm
Compiler
Client
➥ Gilt prinzipiell für alle Realisierungen entfernten Aufrufe
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (2/12)
42
1.3.2 Anwendungsorientierte Middleware
➥ Setzt auf kommunikationsorientierter Middleware auf
➥ Erweitert diese um:
➥ Laufzeitumgebung
➥ Dienste
➥ Komponentenmodell
Anwendungs− Anwendungs− Anwendungs−
komponente komponente komponente
Komponentenmodell
Dienste
Laufzeitumgebung
Dienste
Kommunikationsinfrastruktur
Betriebssystem / verteiltes System
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (2/12)
43
1.3.2 Anwendungsorientierte Middleware ...
Laufzeitumgebung
➥ Ressourcenverwaltung
➥ Pooling von Prozessen, Threads, Verbindungen
➥ Steuerung der Nebenläufigkeit
➥ Verbindungsverwaltung
➥ Verbesserung der Verfügbarkeit
➥ Replikation, Clustering
➥ Sicherheitsmechanismen
➥ Authentifizierung und Autorisierung
➥ Vertraulichkeit und Integrität
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (2/12)
44
1.3.2 Anwendungsorientierte Middleware ...
Dienste
➥ Namensdienst (Verzeichnisdienst)
➥ Zuordnung von Namen zu Referenzen (Adressen)
➥ Sitzungsverwaltung
➥ Transaktionsverwaltung
➥ Persistenzdienst
➥ z.B. objektrelationaler Mapper (OR-Mapper)
Komponentenmodell
➥ Komponentenbegriff, Schnittstellenverträge, Laufzeitumgebung
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (2/12)
45
1.4 Java RMI
➥ Java RMI ist fester Bestandteil von Java
➥ erlaubt Nutzung entfernter Objekte
➥ Stub- und Skeleton-Klassen werden automatisch aus Schnittstellendefinition (Java Interface) generiert
➥ ab JDK 1.5 dynamisch zur Laufzeit
➥ Namensdienst: RMI Registry
➥ Verteilte Garbage-Collection
Roland Wismüller
Betriebssysteme / verteilte Systeme
46
Client/Server-Programmierung (2/12)
1.4 Java RMI ...
Beispiel: Hello World
Client−JVM
Interface
interface Hello {
String sayHello();
}
Client−Klasse
class HelloClient {
...
Hello h;
...
s = h.sayHello();
...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Server−JVM
Server−Klasse
class HelloServer
implements Hello {
String sayHello() {
return "Hello World";
}
...
Client/Server-Programmierung (2/12)
47
1.4 Java RMI ...
Hello-World Interface
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface Hello extends Remote {
String sayHello() throws RemoteException;
}
Marker−Schnittstelle ,
enthält keine Methoden,
markiert Interface als
RMI−Schnittstelle
Roland Wismüller
Betriebssysteme / verteilte Systeme
RemoteException zeigt
Fehler im entfernten
Objekt bzw. bei Kommu−
nikation an
Client/Server-Programmierung (2/12)
48
1.4 Java RMI ...
Hello-World Server
import java.rmi.*;
import java.rmi.server.UnicastRemoteObject;
public class HelloServer extends UnicastRemoteObject
implements Hello {
public HelloServer() throws RemoteException {
super();
}
public String sayHello() {
return "Hello World!";
Remote Methode
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (2/12)
49
1.4 Java RMI ...
Hello-World Server ...
public static void main(String args[]) {
try {
HelloServer obj = new HelloServer();
Naming.rebind("rmi://localhost/Hello−Server", obj);
}
catch (Exception e) {
System.out.println("Error: " + e.getMessage());
e.printStackTrace();
}
}
}
Erzeugen des
Server−Objekts
Registrieren des Server−Objekts
unter dem Namen "Hello−Server"
beim Name−Server (RMI−Registry,
lokaler Rechner, Port 1099)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (2/12)
50
1.4 Java RMI ...
Hello-World Client
import java.rmi.*;
public class HelloClient {
public static void main(String args[]) {
Objektreferenz vom
try {
Name−Server holen
Hello obj =
(Hello)Naming.lookup("rmi://bspc02/Hello−Server");
String message = obj.sayHello();
System.out.println(message);
}
Aufruf der Methode
catch (Exception e) {
des entfernten Objekts
...
}
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (2/12)
51
1.4 Java RMI ...
Übersetzen und Starten des Systems
HelloClient.java
Hello.java
javac
javac
Hello.class
Hello.class
bis JDK 1.4
HelloClient.class
Client−Seite
Roland Wismüller
Betriebssysteme / verteilte Systeme
HelloServer.java
HelloServer.class
rmic
Server−Seite
HelloServer_Stub.class
Client/Server-Programmierung (2/12)
52
1.4 Java RMI ...
Parameterübergabe
➥ Übergabe von Parametern an Remote-Methoden erfolgt
➥ entweder über call-by-value
➥
für Werttypen und serialisierbare Objekte
➥ oder über call-by-reference
➥
für Objekte, die Remote implementieren
➥ Entscheidung wird z.T. erst zur Laufzeit getroffen!
➥ Rückgabe des Ergebnisses folgt selben Regeln wie Parameterübergabe
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (2/12)
53
Client/Server-Programmierung
WS 2013/2014
2
Java Database Connectivity (JDBC)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (2/12)
54
2 Java Database Connectivity (JDBC) ...
2.1 Überblick
➥ Java-API zum portablen Zugriff auf relationale DatenbankSysteme
➥ Unabhängig von konkreter Datenbank-Implementierung
➥ Funktionen:
➥ Verbindung zur Datenbank herstellen
➥ Ausführung von SQL-Anweisungen
➥ Zugriff auf Abfrage-Ergebnisse
➥ Vergleichbar mit ODBC, aber einfachere Schnittstelle
➥ Anschluß zur Datenbank über herstellerspezifische Treiber
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (2/12)
55
2 Java Database Connectivity (JDBC) ...
2.2 Relationale Datenbanken und SQL
➥ Relationale Datenbank = Menge von Tabellen
➥ jede Spalte hat Namen und Datentyp
➥ jede Zeile enthält i.a. ein Feld, dessen Wert die Zeile eindeutig
identifiziert (Primärschlüssel)
➥ Aufbau festgelegt in Datenbank-Schema
➥ Beispiel:
ag_name
ag_data
AG_ID AG_NAME
ID AG_ID DAY VALUE
1
2
3
BMW
Siemens
Thyssen
Roland Wismüller
Betriebssysteme / verteilte Systeme
7
9
12
3
1
2
9
9
8
102.30
99.10
30.45
Primär−
schlüssel
Client/Server-Programmierung (2/12)
56
2.2 Relationale Datenbanken und SQL ...
SQL
➥ Standardisierte Abfragesprache für relationale Datenbanken
➥ Erlaubt u.a.:
➥ Abfrage von Daten (SELECT)
➥ Erzeugung neuer Tabellen (CREATE TABLE)
➥ Einfügen von Datensätzen (Zeilen) (INSERT)
➥ Löschen von Datensätzen (DELETE)
➥ Ändern von Datensätzen (UPDATE)
➥ Auswahl der Datensätze i.d.R. über deren Inhalt
➥ häufig über Primärschlüssel
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (2/12)
57
2.2 Relationale Datenbanken und SQL ...
Beispiele für SQL-Anfragen
➥ SELECT AG_ID, AG_NAME
FROM ag_name
WHERE AG_NAME = ’Siemens’
➥ liefert die Zeile für Siemens aus der ag name-Tabelle
➥ SELECT ag_name.AG_NAME, ag_data.VALUE
FROM ag_name, ag_data
WHERE VALUE > 90 AND ag_name.AG_ID = ag_data.AG_ID
➥ liefert Name und Kurs aller Aktien mit Kurs über 90
➥ gibt Information aus zwei Tabellen zurück
➥
Verbindung der Einträge über den Primärschlüssel
(Natural Join)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (2/12)
58
Client/Server-Programmierung
WS 2013/2014
08.11.2013
Roland Wismüller
Betriebssysteme / verteilte Systeme
.d
[email protected] e
rolanda
Tel.: 0271/740-4050, Büro: H-B 8404
Stand: 23. April 2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
i
2 Java Database Connectivity (JDBC) ...
2.3 Architektur von JDBC
Java Anwendung
JDCB Treiber Manager
JDBC/ODBC
Brücke
Treiber für
mySQL
Treiber für
Oracle
ODBC
Treiber
MS
SQL−Server
mySQL
Roland Wismüller
Betriebssysteme / verteilte Systeme
Oracle
Client/Server-Programmierung (3/12)
59
2.3 Architektur von JDBC ...
Klassen des JDBC-Kerns
java.sql
<<interface>>
Statement
<<interface>>
ResultSet
DriverManager
<<interface>>
PreparedStatement
<<interface>>
ResultSetMetaData
DriverPropertyInfo
<<interface>>
CallableStatement
<<interface>>
Driver
<<interface>>
Connection
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
60
2.3 Architektur von JDBC ...
Klassen des JDBC-Kerns ...
➥ Interface Driver
➥ Schnittstelle, die alle JDBC-Treiber implementieren müssen
➥ neu geladener Treiber registriert sich bei DriverManager
➥ Klasse DriverManager
➥ verwaltet Driver-Objekte
➥ erzeugt Datenbank-Verbindungen (Connection)
➥ Klasse DriverPropertyInfo
➥ erlaubt Definition spezieller Parameter beim Aufbau der
Datenbank-Verbindung
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
61
2.3 Architektur von JDBC ...
Klassen des JDBC-Kerns ...
➥ Interface Connection
➥ repräsentiert Sitzung mit ausgewählter Datenbank
➥ erlaubt Erzeugung von Statement-Objekten
➥ verwaltet Informationen zum Zustand der Datenbank
➥ erlaubt Abfrage von Metadaten der Datenbank
(Methode getMetaData(), Resultat: DatabaseMetaData)
➥
z.B. unterstützte SQL-Versionen, Limitierungen des
Datenbank-Systems, ...
➥ Interface Statement
➥ zur Ausführung einer SQL-Anfrage
➥ verwaltet auch Ergebnis der Anfrage (ResultSet)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
62
2.3 Architektur von JDBC ...
Klassen des JDBC-Kerns ...
➥ Interface PreparedStatement
➥ zur Ausführung einer vorkompilierten SQL-Anfrage
➥ effizienter bei wiederholter Ausführung
➥ Interface CallableStatement
➥ erlaubt Aufruf von Stored Procedures
➥
SQL-Prozeduren, die in Datenbank selbst abgelegt sind
➥ Interface ResultSet
➥ Ergebnis-Relation einer Datenbank-Anfrage
➥ Interface ResultSetMetaData
➥ Metadaten zu den Spalten der Ergebnis-Relation
➥ z.B. Name, Typ, vorzeichenbehaftet, ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
63
2 Java Database Connectivity (JDBC) ...
2.4 Ein Beispiel
import java.sql.*;
import java.lang.*;
public class Beispiel {
public static void main(String[] args) {
try {
// Laden des JDBC−Treibers
Class.forName("com.mysql.jdbc.Driver");
}
catch (ClassNotFoundException e) {
System.out.println("Treiber nicht ladbar:" + e);
return;
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
64
2.4 Ein Beispiel ...
try {
// Verbindung zur Datenbank
Connection con = DriverManager.getConnection(
"jdbc:mysql://bslabserv01.lab.bvs/cspdb","","");
// Erzeuge SQL−Anweisung und führe sie aus
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(
"SELECT AG_ID, AG_NAME FROM ag_name");
// Ausgabe des Ergebnisses
while (rs.next()) {
System.out.println("" + rs.getInt("AG_ID") + ", "
+ rs.getString("AG_NAME"));
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
65
2.4 Ein Beispiel ...
// Alles schließen
rs.close();
stmt.close();
con.close();
}
catch (SQLException e) {
System.out.println("SQL Exception: "
+ e.getMessage());
e.printStackTrace(System.out);
}
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
66
2 Java Database Connectivity (JDBC) ...
2.5 Details zu JDBC
Laden der Treiber
➥ Vor Verwendung von JDBC müssen die Treiber geladen werden:
➥ try {
Class.forName("com.mysql.jdbc.Driver");
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
}
catch (ClassNotFoundException e) { ... }
➥ Alternativ: Setzen der jdbc.drivers Property
➥ java -Djdbc.drivers=com.mysql.jdbc.Driver:sun.jdbc.
odbc.JdbcOdbcDriver ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
67
2.5 Details zu JDBC ...
Verbindung zur Datenbank herstellen
➥ Verbindung wird durch Connection-Objekt repräsentiert
➥ Mehrere Datenbank-Verbindungen pro Anwendung möglich
➥ Erzeugung über
➥ Connection con = DriverManager.getConnection(
"url ", "user ", "password ");
➥ Variante von getConnection() erlaubt Definition von Properties
für die Datenbank-Verbindung
➥ Wenn Verbindung nicht mehr benötigt wird:
➥ explizites Schließen mit Methode con.close()
➥
Freigabe von Netzwerk- und Speicherressourcen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
68
2.5 Details zu JDBC ...
Ausführung einer SQL-Anweisung
➥ Erzeugung eines Statement-Objekts
➥ Statement stmt = con.createStatement();
➥ Ausführung der SQL-Anweisung
➥ ResultSet rs = stmt.executeQuery("SELECT ...");
➥ Methoden executeUpdate() für Anfragen ohne Ergebnis,
bzw. execute(), falls unbekannt, ob Ergebnis geliefert wird
➥ execute() liefert true, falls Ergebnis vorhanden
➥ Statement-Objekt repräsentiert eine einzige SQL-Anfrage
➥ ResultSet wird bei erneuter Anfrage über selbes
Statement-Objekt ungültig
➥ für simultane Anfragen: mehrere Statement-Objekte!
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
69
2.5 Details zu JDBC ...
Zugriff auf die Resultate
➥ Ergebnis einer SQL-Anfrage (SELECT) ist eine Tabelle
➥ Struktur gekapselt in ResultSet-Objekt
➥ Methoden u.a.:
➥ next(): setzt Lesezeiger“ auf nächste Zeile
”
zu Begin steht Zeiger vor der ersten Zeile
➥ Ergebnis false, falls keine Zeile mehr vorhanden
➥
➥ get...(String name) / get...(int nr): liefert Inhalt des
Feldes mit Spaltenname name bzw. Spaltennummer nr
➥ mehrere Methoden für die verschiedenen Datentypen
➥ getString() liefert immer String-Repräsentation
➥ close(): Ressourcenfreigabe
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
70
2.5 Details zu JDBC ...
SQL-Datentypen und Zugriffsmethoden (Auswahl)
SQL Typ(en)
CHAR, VARCHAR
NUMERIC, DECIMAL
BIT
TINYINT
SMALLINT
INTEGER
BIGINT
REAL
FLOAT, DOUBLE
BINARY, VARBINARY
DATE
Java Typ
String
java.math.BigDecimal
boolean
byte
short
int
long
float
double
byte[]
java.sql.Date
Roland Wismüller
Betriebssysteme / verteilte Systeme
Methode
getString()
getBigDecimal()
getBoolean()
getByte()
getShort()
getInt()
getLong()
getFloat()
getDouble()
getBytes()
getDate()
Client/Server-Programmierung (3/12)
71
2.5 Details zu JDBC ...
Ausführung vorkompilierter SQL-Anfragen
➥ Für wiederkehrende, ähnliche Aufgaben sind vorkompilierte
SQL-Anfragen (PreparedStatement) effizienter
➥ die Anfragen sind auch parametrisierbar
➥ Auch Sicherheitsvorteil gegen SQL Injection
➥ Erzeugung eines PreparedStatement-Objekts
➥ PreparedStatement stmt = con.prepareStatement(
"INSERT INTO Employees (Name, Phone) (?, ?)");
➥ ? als Platzhalter für Parameter
➥ Ausführung der Anfrage mit konkreten Parametern
➥ stmt.clearParameters();
stmt.setString(1, "Jimmy Dean"); // erster Param.
stmt.setString(2, "201 555-7685"); // zweiter Param.
stmt.executeUpdate();
// kein Ergebnis
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
72
2.5 Details zu JDBC ...
Ausführung von Stored Procedures
Oracle PL/SQL−Prozedur (Im
Datenbanksystem gespeichert)
CREATE OR REPLACE
PROCEDURE sp_interest
(id IN INTEGER
bal IN OUT FLOAT) is
BEGIN
SELECT balance
INTO bal
FROM accounts
WHERE account_id = id;
bal = bal + bal * 0.03;
UPDATE accounts
SET balance = bal
WHERE account_id = id;
END;
Roland Wismüller
Betriebssysteme / verteilte Systeme
Aufruf der Prozedur über JDBC
CallableStatement stmt
= con.prepareCall(
"{call sp_interest(?,?)}");
stmt.registerOutParameter(2,
Types.FLOAT);
stmt.setInt(1, accountID);
stmt.setFloat(2, 2343.23);
stmt.execute();
out.println("New Balance: "
+ stmt.getFloat(2));
Client/Server-Programmierung (3/12)
73
2.5 Details zu JDBC ...
Transaktionen
➥ Verantwortlich für Transaktionen: Connection-Objekt
➥ Methoden zur Steuerung von Transaktionen:
➥ setAutoCommit() - automatisches Festschreiben?
➥ Voreinstellung: jede SQL-Anweisung wird als individuelle
Transaktion ausgeführt
➥ commit() - Festschreiben der Transaktion
➥ rollback() - Abbruch der Transaktion
➥ setTransactionIsolation() - Isolationsebene festlegen
➥ TRANSACTION NONE, sowie die vier Isolations-Ebenen nach
ANSI/ISO-SQL99 (☞ VS, 7.4):
➥ read uncommitted, read commited, repeatable read,
serializable
➥ Voreinstellung ist vom Treiber abhängig
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
74
2.5 Details zu JDBC ...
Transaktionen ...
try {
// Höchste Isolationsebene
con.setTransactionIsolation(TRANSACTION_SERIALIZABLE);
// Transaktionen mit mehreren SQL−Anweisungen zulassen
con.setAutoCommit(false);
// SQL−Anweisungen
stmt.executeUpdate("UPDATE inv SET onhand = 10 WHERE id = 5");
stmt.executeUpdate("INSERT INTO shipping (qty) VALUES (5)");
// Commit aller Aktionen seit letztem Commit/Rollback
con.commit();
}
catch (SQLException e) {
// Rückgängigmachen aller Änderungen
con.rollback();
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
75
2 Java Database Connectivity (JDBC) ...
2.6 Zusammenfassung
➥ JDBC erlaubt portablen Zugriff auf relationale Datenbanken
➥ Abfragen über SQL
➥ Grundsätzlicher Ablauf:
➥ Laden des Treibers (Class.forName())
➥ Verbindung zur Datenbank herstellen (Connection)
➥ SQL-Anweisung erzeugen (Statement)
➥ SQL-Anweisung ausführen, Ergebnis auslesen (ResultSet)
➥ Daneben: Unterstützung für
➥ vorkompilierte SQL-Anweisungen und Stored Procedures
➥ Transaktionen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
76
Client/Server-Programmierung
WS 2013/2014
3
CORBA
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
77
3 CORBA ...
Inhalt
➥ CORBA-Architektur
➥ CORBA-Dienste
➥ Beispielprogramm
➥ CORBA im Detail
➥ IDL und IDL-Java-Mapping
➥ Namensdienst
➥ POA
➥ GIOP, IIOP und IOR
➥ Implementation- und Interface-Repository
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
78
3 CORBA ...
Literatur
➥ CORBA-Spezifikationen der OMG
➥ http://www.omg.org/technology/documents/
corba spec catalog.htm
➥ Farley / Crawford / Flanagan, Kap. 14
➥ Orfali / Harkey, Kap. 1, 4, 7-9, 17-22
➥ Hofmann / Jobst / Schabenberger, Kap. 2.2, 5, 6
➥ Michi Henning, Steve Vinoski: Advanced CORBA Programming
with C++. Addison-Wesley, 1999.
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
79
3.1 Einführung
➥ CORBA: Common Object Request Broker Architecture
➥ Ziel: Entwicklung und Integration verteilter objektorientierter
Anwendungen in heterogenen Umgebungen
➥ CORBA ist plattform- und sprachunabhängig
➥ Informeller Standard, definiert durch die OMG (Object
Management Group)
➥ 1989 gegründet, Ziel: Förderung objektorientierter Techniken
➥ heute über 700 Mitglieder (größtes IT-Industriekonsortium)
➥ CORBA ist nur eine Spezifikation
➥ verschiedenste Implementierungen, z.B. Orbix, ORB ACUS,
Java IDL (Teil des JDK), JacORB, ORBit (GNOME!) ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
80
3.2 CORBA Architektur
3.2.1 Object Management Architecture (OMA)
➥ Definiert Objekt- und Referenzmodell
➥ Objektmodell
➥ unterstützt Kapselung, (Mehrfach-)Vererbung, Polymorphie
➥ Objekte bieten Dienste mit definierter Schnittstelle an
➥ Client nutzt Dienste (lokal oder entfernt) über Schnittstelle, ist
vollständig von Server-Implementierung unabhängig
➥ Objektimplementierung mit beliebiger Programmiersprache
➥ Referenzmodell
➥ Interaktion zw. Objekten und dazu notwendige Komponenten
➥ Herzstück: Object Request Broker (ORB)
➥
Software-Bus“ für Kommunikation zw. Client und Server
”
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
81
3.2.1 Object Management Architecture (OMA) ...
Das OMA Referenzmodell
Application
Objects
Vertical CORBA
Facilities
Horizontal CORBA
Facilities
Client Server
Object Request Broker
...
Naming
Event
LifeCycle
Transactions
CORBA Services
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
82
3.2.1 Object Management Architecture (OMA) ...
Bestandteile des OMA Referenzmodells
➥ Object Request Broker (ORB)
➥ stellt Dienstanfragen an verteilte Objekte zu
➥ realisiert Ortstransparenz für die Client-Objekte
➥ CORBA Services (Object Services)
➥ domänenunabhängige (horizontale) Schnittstellen zu
wichtigen Basisdiensten, z.B. Namensdienst
➥ betriebssystem-ähnliche Funktion
➥ Horizontal CORBA Facilities (Common Facilities)
➥ Schnittstellen zu anwendungsorientierten, domänenüber-
greifenden Diensten
➥ z.B. Drucken, verteilte Dokumente, ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
83
3.2.1 Object Management Architecture (OMA) ...
Bestandteile des OMA Referenzmodells ...
➥ Vertical CORBA Facilities (Domain Interfaces)
➥ Schnittstellen zu anwendungsorientierten Diensten für
bestimmte Anwendungsdomänen
➥
z.B. Finanzwesen, Medizin, Telekommunikation, ...
➥ Application Objects
➥ anwendungsspezifische Schnittstellen
➥ im Ggs. zu Services und Facilities nicht von der OMG
standardisiert
➥ OMG spezifiziert nur die Schnittstellen, nicht die Implementierungen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
84
3.2 CORBA Architektur ...
3.2.2 Common Object Request Broker Architecture (CORBA)
➥ Zentrale Idee: transparente Kommunikation zwischen Client und
Server-Objekten über ORB
➥ ORB bietet Client eine lokale (Proxy-)Schnittstelle
➥ Vorteile beim Einsatz eines ORB:
➥ Zugriffs- und Ortstransparenz
➥ Transparenz der Implementierungssprache
➥ Transparenz der Objektaktivierung
➥
ORB übernimmt ggf. Aktivierung des Objekts
➥ Transparenz der Kommunikationstechnik
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
85
3.2.2 Common Object Request Broker Arch. ...
Objektreferenzen
➥ Zugriff auf Objekte erfolgt über Objektreferenzen
➥ Objektreferenzen
➥ identifizieren genau ein Objekt
➥
aber: verschiedene Referenzen für ein Objekt möglich
➥ können null sein, d.h. auf kein Objekt zeigen
➥ können hängen“, wenn Objekt nicht mehr existiert
”
➥ können persistent sein
➥ sind typsicher
➥ unterstützen spätes Binden (Polymorphismus)
➥ sind interoperabel, d.h. Aufbau ist standardisiert
➥ sind opak, d.h. Client darf Inhalt nicht betrachten
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
86
3.2.2 Common Object Request Broker Arch. ...
OMG Interface Definition Language (OMG IDL)
➥ OMG IDL erlaubt formale Beschreibung der Objekt-Schnittstellen
➥ unabhängig von Implementierung der Objekte (z.B.
Programmiersprache)
➥ Objekte können z.B. durch C++- oder Java-Objekte, aber auch
durch eigene Programme oder OO-Datenbanken
implementiert werden
➥ OMG definiert, wie IDL in verschiedene Sprachen abgebildet wird
(Language Mapping)
➥ derzeit für C, C++, Java, Smalltalk, Ada, Lisp, Phyton, Cobol
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (3/12)
87
Client/Server-Programmierung
WS 2013/2014
15.11.2013
Roland Wismüller
Betriebssysteme / verteilte Systeme
.d
[email protected] e
rolanda
Tel.: 0271/740-4050, Büro: H-B 8404
Stand: 23. April 2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
i
3.2.2 Common Object Request Broker Arch. ...
Modell des Object Request Brokers
Client
Object Implementation
1111 0000
1111000000000
11111 0000
1111
00000 0000
11111
11111111100000
Stub
Dynamic
Invocation
Interface
ORB
Interface
Skeleton
Dynamic
Skeleton
Interface
Object
Adapter
ORB−Core
Interface Repository
Implementation Repository
111
000
000Identische Schnittstelle für alle ORB−Implementierungen
111
Eine Schnittstelle pro Objekt−Typ
111Mehrere (unterschiedliche) Objekt−Adapter möglich
000
1111
0000
ORB−spezifische Schnittstelle
Roland Wismüller
Betriebssysteme / verteilte Systeme
mögliche
Rechnergrenze
Client/Server-Programmierung (4/12)
88
3.2.2 Common Object Request Broker Arch. ...
Komponenten des ORB
➥ ORB Core
➥ stellt Basisfunktionalität zur Verfügung
➥
Objekt-Repräsentation, Kommunikationsmechanismen
➥ ist i.d.R. verteilt implementiert
➥ Stub und Skeleton
➥ für entfernten Methodenaufruf
➥ vom IDL-Compiler aus Schnittstellendefinition erzeugt
➥ Dynamic Invocation Interface und Dynamic Skeleton Interface
➥ erlauben dynamische Methodenaufrufe/-implementierungen
➥ d.h. Schnittstelle muß zur Übersetzungszeit des Clients bzw.
Servers noch nicht festgelegt sein
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
89
3.2.2 Common Object Request Broker Arch. ...
Komponenten des ORB ...
➥ Object Adapter
➥ stellt Objektimplementierung Dienste des ORB zur Verfügung
➥ Funktionen u.a.:
➥
➥
➥
➥
➥
Methodenaufrufe (über Skeletons)
Abbildung von Referenzen auf Impementierungen
Registrierung von Implementierungen
Generierung und Interpretation von Objektreferenzen
Objektaktivierung und -deaktivierung
➥ unterschiedliche Objektadapter möglich
➥ ab CORBA 2.2: Portable Object Adapter (POA) als
Standard-Schnittstelle zum Objektadapter
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
90
3.2.2 Common Object Request Broker Arch. ...
Komponenten des ORB ...
➥ ORB Interface
➥ Schnittstelle für Dienste, die der ORB dem Client und allen
Objektimplementierungen zur Verfügung stellt
➥ Interface Repository
➥ Dienst, der zur Laufzeit persistente Information zu den
registrierten Objektschnittstellen zur Verfügung stellt
➥ Nutzung ggf. durch ORB und / oder Clients
➥ allgemein: jegliche Information zu Objekt-Schnittstellen
➥ Implementation Repository
➥ enthält Information, die es dem ORB erlaubt, Objekte zu
lokalisieren und zu aktivieren
➥ allgemein: jegliche Information zu Objekt-Implementierungen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
91
3.2 CORBA Architektur ...
3.2.3 CORBA-Dienste
➥ Von der OMG spezifiziert, erweitern ORB-Funktionalität
➥ realisiert durch CORBA-Objekte mit IDL-Schnittstelle
➥ Anbieter von ORB und Diensten können unterschiedlich sein
➥ Collection Service
➥ Container -Objekte, z.B. Map, Set, Queue
➥ Concurrency Control Service
➥ realisiert Sperren für wechselseitigen Ausschluß
➥ Event Service
➥ verteilt Ereignisse an interessierte Objekte
➥ Externalization Service
➥ (De-)Serialisierung von Objekten
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
92
3.2.3 CORBA-Dienste ...
➥ Licensing Service
➥ erfaßt Nutzung von Objekten für Abrechnung
➥ Life Cycle Service
➥ Erzeugen, Löschen, Kopieren und Verschieben von Objekten
➥ Naming Service
➥ Zuordnung von Namen zu Objektreferenzen
➥ Notification Service
➥ Event Service-Erweiterung: beliebige Daten als Ereignisse
➥ Persistent Object Service
➥ persistentes Speichern von Objekten in Datenbanken
➥ Property Service
➥ Verwaltet Name/Wert-Paare
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
93
3.2.3 CORBA-Dienste ...
➥ Query Service
➥ Anfrageoperationen an verteilte Objekte (SQL-Obermenge)
➥ Relationship Service
➥ Erzeugung / Traversierung von Assoziationen zw. Objekten
➥ Security Service
➥ Authentifizierung, Zugriffskontroll-Listen, Rechteweitergabe
➥ Time Service
➥ Zeit-Synchronisation
➥ Trading Service
➥ erlaubt CORBA-Objekte anhand ihrer Fähigkeiten zu finden
➥ Object Transaction Service
➥ flache und verschachtelte verteilte Transaktionen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
94
3.3 Hello World mit CORBA
Vorbemerkungen
➥ In der Vorlesung und Übung:
Verwendung zweier CORBA-Implementierungen
➥ Java IDL
➥
Seit JDK 1.2 fester Bestandteil der Java Entwicklungsumgebung
➥ wenig Dienste (nur Namensdienst)
➥ JacORB 2.3.1
➥
frei verfügbarer ORB, in Java implementiert
➥ mehr Dienste (u.a. Naming, Event, Notification, Transaction, Trading), sowie Interface- und Implementation Repository
➥ Wegen POA: Anwendungs-Quellcode ist für alle Implementierungen gleich
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
95
Vorgehen zur Erstellung der Anwendung
3.3 Hello World mit CORBA ...
Schnittstellen− 1
definitionen in IDL
5 IDL−zu−Java
Compiler
Java
Interfaces
6
Client−
Code
Client−
Stubs
Client Server
Hilfs−
Klassen
Java
Interfaces
4
7
javac
Compiler
Client−
Anwendung
IDL−zu−Java 2
Compiler
Objekt− POA
Skeletons
javac
Compiler
Hilfs−
Klassen
Objekt− 3
Impl.code
Objekt−
Implementierung
Skeleton POA
Stub
Object Request Broker
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
96
3.3 Hello World mit CORBA ...
IDL-Beschreibung der Schnittstelle
module HelloWorld
Paketname
{
interface Hello Schnittstelle
{
string sayHello(in string name); Methode
};
};
Eingabeparameter
➥ CORBA definiert eigene, C++/Java-ähnliche Sprache
➥ IDL-Compiler erzeugt Schnittstellen für jeweilige Implementierungssprache
➥ kann für Client und Server verschieden sein
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
97
3.3 Hello World mit CORBA ...
Vom IDL-Compiler generierte Dateien
Hello.idl
idlj (Java IDL)
idl (JacOrb)
Client
_HelloStub.java
Client−Stub
Schnittstelle
Hilfsfunktionen
für Client/Server
Hello.java
HelloOperations.java
HelloHelper.java
HelloHolder.java
Roland Wismüller
Betriebssysteme / verteilte Systeme
Server
POA (Basisklasse)
HelloPOA.java
HelloPOATie.java
POA (Tie−Klasse)
Hilfsklasse für
Ausgabeparameter
Client/Server-Programmierung (4/12)
98
3.3 Hello World mit CORBA ...
Aufruf des IDL-Compilers
➥ Java IDL:
➥ idlj -fall – erzeugt alle Dateien
➥ idlj -fclient – erzeugt Dateien für Client
➥ idlj -fserver – erzeugt Dateien für Server
➥
ohne Helper-Klassen!
➥ idlj -fallTie – erzeugt alle Dateien incl. Tie-Klassen
➥ JacORB:
➥ idl – erzeugt alle Dateien incl. Tie-Klassen
➥ idl -noskel – erzeugt Dateien nur für Client
➥ idl -nostub – erzeugt Dateien nur für Server
➥ Weiteres Argument: Name der IDL-Datei
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
99
3.3 Hello World mit CORBA ...
Vom IDL-Compiler erzeugte Java-Schnittstelle
➥ HelloWorld/Hello.java:
package HelloWorld;
public interface Hello extends HelloOperations,
org.omg.CORBA.Object, org.omg.CORBA.portable.IDLEntity
{
}
➥ HelloWorld/HelloOperations.java:
package HelloWorld;
public interface HelloOperations
{
String sayHello (String name);
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
100
3.3 Hello World mit CORBA ...
Objektimplementierung
// vom IDL−Compiler erzeuges Paket mit POA/Skeleton etc.
import HelloWorld.*;
public class HelloImpl extends HelloPOA
{
public String sayHello(String name)
{
return "The world says HELLO to " + name;
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
101
3.3 Hello World mit CORBA ...
Server-Programm
// vom IDL−Compiler erzeuges Paket mit Hilfsklassen
import HelloWorld.*;
// CORBA Namensdienst
import org.omg.CosNaming.*;
// Für Exceptions, die Namensdienst werfen kann
import org.omg.CosNaming.NamingContextPackage.*;
// Alle CORBA−Server benötigen diese Klassen
import org.omg.CORBA.*;
import org.omg.PortableServer.*;
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
102
3.3 Hello World mit CORBA ...
public class HelloServer {
public static void main(String args[]) {
try {
// Erzeuge und Initialisiere den ORB
ORB orb = ORB.init(args, null);
// Erzeuge das Servant−Objekt
HelloImpl helloRef = new HelloImpl();
// Aktivierung des POA
POA rootpoa = POAHelper.narrow(
orb.resolve_initial_references("RootPOA"));
rootpoa.the_POAManager().activate();
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
103
3.3 Hello World mit CORBA ...
// Registriere Servant und erzeuge (CORBA) Objektreferenz
org.omg.CORBA.Object ref =
rootpoa.servant_to_reference(helloRef);
// Konvertierung in Java−Objektreferenz
Hello href = HelloHelper.narrow(ref);
// Registriere Objektreferenz beim Namensdienst
org.omg.CORBA.Object objRef =
orb.resolve_initial_references("NameService");
NamingContextExt ncRef =
NamingContextExtHelper.narrow(objRef);
NameComponent path[] = ncRef.to_name("HelloWorld");
ncRef.rebind(path, href);
System.out.println("HelloServer is running...");
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
104
3.3 Hello World mit CORBA ...
// Starte ORB
orb.run();
} catch(Exception e) {
System.err.println("ERROR: " + e);
e.printStackTrace(System.out);
}
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
105
3.3 Hello World mit CORBA ...
Client-Programm
import HelloWorld.*;
import org.omg.CosNaming.*;
import org.omg.CORBA.*;
// Client Stubs
// Namensdienst
// CORBA Klassen
public class HelloClient {
public static void main(String args[]) {
try {
// Erzeuge und Initialisiere den ORB
ORB orb = ORB.init(args, null);
// Aufsuchen des Objekts beim Namensdienst
org.omg.CORBA.Object objRef =
orb.resolve_initial_references("NameService");
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
106
3.3 Hello World mit CORBA ...
NamingContextExt ncRef =
NamingContextExtHelper.narrow(objRef);
NameComponent path[] = ncRef.to_name("HelloWorld");
Hello helloRef =
HelloHelper.narrow(ncRef.resolve(path));
// Aufruf der Methode des CORBA−Objekts
System.out.println(helloRef.sayHello("Peter"));
} catch(Exception e) {
System.out.println("ERROR : " + e);
e.printStackTrace(System.out);
}
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
107
3.3 Hello World mit CORBA ...
Anmerkungen zum Code
➥ resolve initial references() dient der initialen Auflösung von
Namen, insbesondere:
➥ RootPOA: der Wurzel-POA des Servers (☞ 3.4.6)
➥ NameService: der Namensdienst
Ergebnis ist org.omg.CORBA.Object
➥ CORBA Objektreferenz
➥ narrow() dient zum Umwandeln einer CORBA-Objektreferenz in
eine Java Objektreferenz (des Stubs)
➥ to name() wandelt String in strukturierten Namen für Namensdienst um (s. später)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
108
3.3 Hello World mit CORBA ...
Starten der Anwendung (Java IDL)
➥ Starten des ORB-Daemons (Namensdienst)
➥ orbd -ORBInitialPort 12345 [ -port <port> ]
➥ startet Daemon auf Port 12345 (-port legt Port für
Objektaktivierung fest)
➥ Achtung: ~/orb.properties von JacORB darf nicht existieren!
➥ Starten des Servers
➥ java HelloServer -ORBInitialPort 12345
[ -ORBInitialHost <addr> ]
➥ Angabe von Host und Port des ORB-Daemons
➥ Starten des Clients
➥ java HelloClient -ORBInitialPort 12345
[ -ORBInitialHost <addr> ]
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
109
3.3 Hello World mit CORBA ...
Zur Nutzung von JacORB im Labor H-A 4111
➥ Umgebungsvariablen setzen (ggf. in $HOME/.profile):
➥ export JACORB_HOME=/opt/dist/JacORB
➥ export PATH=$JACORB_HOME/bin:$PATH
➥ Konfigurationsdatei einrichten:
➥ cp $JACORB_HOME/etc/jacorb_properties.template
$HOME/orb.properties
➥ in $HOME/orb.properties alle cspXXX durch eigenes Login
ersetzen
➥ JacORB verwendet bei uns eine Datei unter $HOME zum
Auflösen der initialen Referenzen
➥ setzt Netzwerk-Dateisystem (NFS) voraus
➥ auch möglich: Nutzung eines WWW-Servers
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
110
Anmerkungen zu Folie 110:
Für die Benutzung von Java IDL muss ggf. der Pfad zum JDK gesetzt werden. Auf den
PCs im Labor H-A 4111 ist dieser Pfad:
/usr/lib64/jvm/java-1.7.0-openjdk/bin/
3.3 Hello World mit CORBA ...
Starten der Anwendung (JacORB)
➥ Starten des Namensdienstes
➥ ns
➥ startet auf beliebigem freiem Port
➥ schreibt eigene Objektreferenz in Datei $HOME/.jaco_ns
➥ Starten des Servers
➥ jaco HelloServer
➥ jaco ist ein Hilfsskript von JacORB
➥
startet JVM mit nötigen Properties und Classpath
➥ Starten des Clients
➥ jaco HelloClient
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
111
3.4 CORBA im Detail
3.4.1 OMG IDL und Java-Mapping
➥ Struktur einer IDL-Datei:
module Identifikator {
Typ-Deklarationen;
Konstanten-Deklarationen;
Exception-Deklarationen;
interface Identifikator [ :Vererbung ] {
Typ-Deklarationen;
Konstanten-Deklarationen;
Exception-Deklarationen;
Attribut-Deklarationen;
Methoden-Deklarationen;
};
...
};
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
112
3.4.1 OMG IDL und Java-Mapping ...
module und interface
➥ module definiert einen neuen Namensraum
➥ ähnlich wie C++ Namespaces bzw. Java Packages
➥ verschachtelte Namensräume möglich
➥ interface definiert neue Schnittstelle
➥ ähnlich wie Java-Schnittstellen
➥ Schnittstelle kann Methoden und Attribute enthalten
➥
Attribute werden über automatisch generierte
Deklarationen von Get- und Set-Methoden realisiert
➥ Vererbung ist möglich, auch Mehrfachvererbung
➥
vererbt werden nur Schnittstellen, keine Implementierungen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
113
3.4.1 OMG IDL und Java-Mapping ...
Methoden-Deklarationen
➥ Syntax:
➥ [ oneway ] Typ Identifikator ( Parameterliste )
[ raises ( Exceptions ) ] [ Kontext ]
➥ Parameterliste: Liste von Parameterdeklarationen:
➥
{ in | out | inout } Typ Identifikator
➥ Klassifikation nach Ein- und Ausgabeparametern
➥ Kontext: Liste von Kontextvariablen
➥
ähnlich UNIX Umgebungsvariablen, werden an Server
übergeben
➥ oneway: asynchroner Methodenaufruf
➥
ohne Ergebnis / Ausgabeparameter
➥ Überladen von Methoden ist nicht erlaubt
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
114
3.4.1 OMG IDL und Java-Mapping ...
Wichtige Basis-Datentypen und ihre Java-Entsprechungen
IDL Datentyp
[unsigned] short
[unsigned] long
[unsigned] long long
float
double
char
string
boolean (TRUE, FALSE)
octet
any
Roland Wismüller
Betriebssysteme / verteilte Systeme
Beschreibung
Ganzzahl, 16 Bit
Ganzzahl, 32 Bit
Ganzzahl, 64 Bit
Gleitkomma, 32 Bit
Gleitkomma, 64 Bit
Zeichen, 8 Bit
Zeichenkette
Boole’scher Wert
Byte
beliebiger Typ
Java Datentyp
short
int
long
float
double
char
String
boolean (true, false)
byte
org.omg.CORBA.Any
Client/Server-Programmierung (4/12)
115
3.4.1 OMG IDL und Java-Mapping ...
Beispiel
module Beispiel {
interface Test1 {
void setName(in string name);
double getXY(out double y);
long encrypt(in string key, inout string msg);
};
interface Test2 {
string charToString(in char c1, in char c2);
};
};
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
116
3.4.1 OMG IDL und Java-Mapping ...
Vom IDL-Compiler erzeugte Klassen und Interfaces
Beispiel
<<interface>>
Test1Operations
setName()
getXY()
encrypt()
Test1Helper
narrow()
insert()
extract()
<<interface>>
Test2Operations
charToString()
Test1Holder
<<interface>>
Test1
<<interface>>
Test2
_Test1Stub
Roland Wismüller
Betriebssysteme / verteilte Systeme
Test2Helper
narrow()
insert()
extract()
Test2Holder
_Test2Stub
Client/Server-Programmierung (4/12)
117
3.4.1 OMG IDL und Java-Mapping ...
Erzeugte Java-Schnittstellen
➥ Beispiel/Test1Operations.java:
package Beispiel;
public interface Test1Operations {
void setName (String name);
double getXY (org.omg.CORBA.DoubleHolder y);
int encrypt (String key,
org.omg.CORBA.StringHolder msg);
}
➥ Beispiel/Test2Operations.java:
package Beispiel;
public interface Test2Operations {
String charToString (char c1, char c2);
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
118
3.4.1 OMG IDL und Java-Mapping ...
Holder-Klassen
➥ Java unterstützt keine Ausgabeparameter
➥ daher: Übergabe eines Objekts (per Referenz!), das den
Parameter enthält (Holder -Klasse)
➥ Z.B. Code für DoubleHolder:
public final class DoubleHolder ... {
public double value;
public DoubleHolder() {
}
public DoubleHolder(double initialValue)
value = initialValue;
}
...
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
119
3.4.1 OMG IDL und Java-Mapping ...
Helper-Klassen
➥ Hilfsmethoden für CORBA-Objekte
➥ Ausschließlich static-Methoden:
➥ narrow(): Typumwandlung (Down cast), wandelt u.a. CORBA
Objektreferenz in Java Objektreferenz um
➥ insert(): packt Objekt in Datentyp org.omg.CORBA.Any
➥ extract(): extrahiert Objekt aus org.omg.CORBA.Any
➥ id(): Schnittstellen-ID für Interface-Repository
➥ read(): Lesen eines Objekts aus einem Eingabestrom
➥ write(): Schreiben eines Objekts in einen Ausgabestrom
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
120
3.4.1 OMG IDL und Java-Mapping ...
Abgeleitete Datentypen
➥ OMG IDL erlaubt Definition abgeleiteter Datentypen
➥ Interfaces (Objekte)
➥ Sequenzen und Arrays
➥ Strukturen (Struct)
➥ Aufzählungen (Enum)
➥ Vereinigungen (Union)
➥ Daneben: Typdefinitionen (Typedefs)
➥ Syntax / Semantik stark an C/C++ angelehnt
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (4/12)
121
Client/Server-Programmierung
WS 2013/2014
22.11.2013
Roland Wismüller
Betriebssysteme / verteilte Systeme
.d
[email protected] e
rolanda
Tel.: 0271/740-4050, Büro: H-B 8404
Stand: 23. April 2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
i
3.4.1 OMG IDL und Java-Mapping ...
Typdefinitionen (Typedefs)
➥ IDL erlaubt es, neue Namen für existierende Typen zu definieren
➥ auf allen Ebenen (global, Modul, Schnittstelle)
➥ Beispiele:
typedef short Temperatur; // neuer Typname: Temperatur
typedef Test2 MyTest;
➥ CORBA legt nicht fest, ob neuer Typname nur Alias für
existierenden Typ ist, oder ob neuer Typ erzeugt wird
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
122
3.4.1 OMG IDL und Java-Mapping ...
Sequenzen
➥ Vektoren (eindimensionale Felder) variabler Länge
➥ beliebige IDL-Elementtypen
➥ Länge kann begrenzt oder unbegrenzt sein
➥ Beispiel: IDL
typedef sequence<Dog> MySeq;
typedef sequence<Dog, 60> MyBoundedSeq;
void seqtest(in MySeq par1, in MyBoundedSeq par2,
out MySeq par3);
➥ Umsetzung in Java:
void seqtest(Beispiel.Dog[] par1, Beispiel.Dog[] par2,
Beispiel.Test2Package.MySeqHolder par3);
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
123
3.4.1 OMG IDL und Java-Mapping ...
Arrays
➥ Ein- oder mehrdimensionale Felder fester Länge
➥ Beispiel: IDL
typedef Dog MyArray[60];
typedef Dog My2DArray[60][10];
void arraytest(in MyArray par1, in My2DArray par2,
out MyArray par3);
➥ Umsetzung in Java:
void arraytest(Beispiel.Dog[] par1,
Beispiel.Dog[][] par2,
Beispiel.Test2Package.MyArrayHolder par3);
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
124
3.4.1 OMG IDL und Java-Mapping ...
Strukturen (Structs)
➥ Zusammenfassung von mehrerer Variablen
➥ entspricht Klasse mit public-Attributen ohne Methoden
➥ Beispiel: IDL
struct MyStruct {
short age;
string name;
};
Roland Wismüller
Betriebssysteme / verteilte Systeme
➥ Umsetzung in Java:
public final class MyStruct {
public short age = (short)0;
public String name = null;
public MyStruct() {}
public MyStruct(short _age,
String _name) {
age = _age; name = _name;
}
}
Client/Server-Programmierung (5/12)
125
3.4.1 OMG IDL und Java-Mapping ...
Aufzählungen (Enums)
➥ Neuer Typ mit explizit aufgezählten Werten
➥ Beispiel: IDL
enum Color { red, green, blue };
➥ Umsetzung in Java:
➥ Klasse Color mit
➥
static final-Attributen für die Werte
➥ als int-Wert (z.B. red) und als Color-Objekt (z.B. red)
➥ Methode value(), liefert int-Wert zurück
➥ static-Methode from int() als Factory
➥ Verwendung z.B.:
Color mycol = Color.red;
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
126
3.4.1 OMG IDL und Java-Mapping ...
Vereinigungen (Unions)
➥ Beschreibt Daten, die verschiedene Typen haben können
➥ Typ wird durch Diskriminator zur Laufzeit festgelegt
➥ Beispiel: IDL
union Animal switch (short) {
case 1: Dog dog;
case 2: Cat cat;
default: Mouse mouse;
};
➥ Umsetzung in Java: Klasse Animal mit
➥ Methode discriminator() für Diskriminator
➥ Get- und Set-Methoden für die Felder des Union
➥ prüfen bzw. setzen auch Diskriminator-Wert
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
127
3.4.1 OMG IDL und Java-Mapping ...
Attribute
➥ In einem Interface können auch Attribute definiert werden:
➥ attribute string name;
readonly attribute long age;
➥ deklariert werden damit letztendlich nur Zugriffsmethoden zum
Lesen und ggf. auch zum Schreiben
➥ Erzeugte Java-Schnittstelle im Beispiel:
String name ();
void name (String newName);
int age ();
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
128
3.4.1 OMG IDL und Java-Mapping ...
Konstanten
➥ Konstanten können auf globaler, auf Modul- oder auf
Interface-Ebene definiert werden
➥ unterschiedlicher Gültigkeitsbereich
➥ Beispiel zur Syntax:
interface Test2 {
const short maxItems = 40;
const string myName = "Roland";
...
➥ Abbildung nach Java:
public interface Test2 extends Test2Operations ... {
public static final short maxItems = (short)(40);
public static final String myName = "Roland";
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
129
3.4.1 OMG IDL und Java-Mapping ...
Exceptions
➥ IDL erlaubt Definition eigener Exceptions
➥ daneben: jede Methode kann (implizit) eine Reihe von
System-Exceptions werfen, z.B. Marshaling-Fehler
➥ Beispiel:
exception SyntaxError {
unsigned short position;
};
void parse(in string command) raises (SyntaxError);
➥ Umsetzung in Java:
void parse (String command)
throws Beispiel.Test2Package.SyntaxError;
➥ plus Exception-Klasse SyntaxError, analog zu Struct
Roland Wismüller
Betriebssysteme / verteilte Systeme
130
Client/Server-Programmierung (5/12)
3.4.1 OMG IDL und Java-Mapping ...
Vererbung
➥ Methoden und Attribute von Schnittstellen können vererbt werden
➥ auch Mehrfachvererbung möglich
➥ kein Überladen / Überschreiben von Methoden erlaubt
➥ Beispiel:
➥ Umsetzung in Java:
interface Animal {
attribute short age;
void eat(in string what);
};
interface Dog : Animal {
string bark();
};
Roland Wismüller
Betriebssysteme / verteilte Systeme
AnimalOperations
short age()
void age(short)
void eat(String)
DogOperations
String bark()
Animal
Client/Server-Programmierung (5/12)
Dog
131
3.4.1 OMG IDL und Java-Mapping ...
Vererbung ...
➥ Methoden der Basisklasse org.omg.CORBA.Object (Java
Bindings):
➥ _is_a(): implementiert Objekt gegebenes Interface?
➥ _non_existent(): zugehöriges Server-Objekt zerstört?
➥ _is_equivalent(): verweisen zwei Referenzen auf dasselbe
Objekt? (soweit ORB das einfach bestimmen kann)
➥ _hash(): Hashwert der Objektreferenz
➥ _duplicate() / _release(): Kopie bzw. Freigabe einer
Objektreferenz (i.a. keine Garbage Collection im ORB)
➥ _get_interface_def(): liefert Schnittstellenbeschreibung aus
Interface Repository
➥ _create_request(): erzeugt Request für DII
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
132
3.4.1 OMG IDL und Java-Mapping ...
Parameterübergabe-Semantik
➥ Alle Parametertypen außer Interfaces: call-by-value
➥ Methoden dürfen in-Parameter jedoch nicht verändern
➥ Verhalten ist sonst undefiniert
➥ IDL unterstützt spezielle Typdeklarationen (valuetype), um
Objekte zu definieren, die per Wert übergeben werden
➥ analog zu interface, aber mit Angabe echter Attribute
(State Variables)
➥ Interfaces: call-by-reference
➥ übergeben wird die Objektreferenz (kein narrow() nötig)
➥ IDL unterstützt auch abstrakte Interfaces
➥ können von valuetype und interface geerbt werden
➥ damit: Übergabesemantik erst zur Laufzeit festgelegt
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
133
3.4 CORBA im Detail ...
3.4.2 Name Service
➥ Der CORBA Namensdienst definiert einen hierarchischen
Namensraum
Resorts
Mexico
Hyatt
Ixtapa
Greece
Hawaii
Club Med
Cancun
Playa Blanca
Naming Context
Object Name
➥ Aufbau eines Namens:
Resorts
Mexico
Club Med
Cancun
Context Name Context Name Context Name Simple Name
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
134
3.4.2 Name Service ...
➥ Darstellung von Namen (in IDL):
struct NameComponent {
string id;
// Eigentlicher Name
string kind; // Typ (analog zu Dateiendungen)
};
typedef sequence<NameComponent> Name;
➥ Wichtige Methoden des Namensdienstes (NamingContext)
➥ bind() / rebind() : Binden von Objektnamen
➥ bind_context() / rebind_context() : Binden eines Naming
Context unter einem (Kontext-)Namen
➥ new_context() : Erzeugen eines Naming Context
➥ unbind() : Namen entfernen
➥ list() : Ausgabe aller Namen
➥ resolve() : Namen in Objekt auflösen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
135
3.4.2 Name Service ...
➥ Erweiterte Schnittstelle NamingContextExt
➥ von NamingContext abgeleitet
➥ erlaubt u.a. Verwendung von Pfadnamen in Stringform
id
➥ z.B.: a /.c /d.e
kind
NameComponent
➥ wichtige Methoden:
➥
to_name() : wandelt Namen in Stringform in eine Sequenz
von NameComponents um
➥ resolve_str() : entspricht resolve(to_name("name"))
➥ (Java-)Referenz auf Wurzel-Naming Context:
NamingContextExt nc = NamingContextExtHelper.narrow(
orb.resolve_initial_references("NameService"))
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
136
3.4.2 Name Service ...
Beispiel
➥ Registrierung eines Objekts in einem neuen Kontext:
NamingContextExt nc = NamingContextExtHelper.narrow(
orb.resolve_initial_references("NameService");
// Erzeugen und Binden des Naming Contexts
nc.rebind_context(nc.to_name("Hello"),
nc.new_context());
// Binden der Objektreferenz an hierarchischen Namen
nc.rebind(nc.to_name("Hello/HelloWorld"), objRef);
➥ Auflösen des Namens (ohne NamingContextExt):
NameComponent path[] = { new NameComponent("Hello",""),
new NameComponent("HelloWorld", "") };
Hello obj = HelloHelper.narrow(nc.resolve(path));
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
137
3.4 CORBA im Detail ...
3.4.3 Factories
➥ Eine Factory kann auch eine Referenz auf ein neues
CORBA-Objekt zurückliefern, das durch einen eigenen Servant
implementiert wird
➥ Die Factory-Methode muß dazu:
➥ einen neuen Servant erzeugen
➥ diesen mit servant to reference() beim POA registrieren
➥ die CORBA-Referenz mit narrow() in eine Java-Referenz
umwandeln und als Ergebnis zurückliefern
➥ Eine Referenz auf den POA kann man u.a. über die von der
Klasse org.omg.PortableServer.Servant geerbten Methoden
default POA() oder poa() erhalten
➥ Beispiel: siehe WWW
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
138
3.4.3 Factories ...
Beispiel: IDL-Datei
module HelloWorld
{
// Schnittstelle der Objekte, werden vom Client über Factory erzeugt
interface Hello
{
string sayHello();
};
// Schnittstelle des Factory−Objekts
interface HelloFactory
{
Hello createHello(in string name);
};
};
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
139
3.4.3 Factories ...
Beispiel: Client (Ausschnitt)
// Resolve the object reference in naming
NameComponent path[] = ncRef.to_name("HelloWorld");
HelloFactory fact = HelloFactoryHelper.narrow(
ncRef.resolve(path));
// Erzeuge Objekte über Factory
Hello helloRef = fact.createHello("Klaus");
Hello helloRef2 = fact.createHello("Uwe");
// Rufe Methode für jedes Objekt auf
System.out.println(helloRef.sayHello());
System.out.println(helloRef2.sayHello());
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
140
3.4.3 Factories ...
Beispiel: Factory-Implementierung im Server
class HelloFactoryServant extends HelloFactoryPOA {
private POA rootpoa;
public HelloFactoryServant(POA rootpoa) {
this.rootpoa = rootpoa;
}
public Hello createHello(String name) {
try {
HelloServant helloRef = new HelloServant(name);
org.omg.CORBA.Object ref =
rootpoa.servant_to_reference(helloRef);
return HelloHelper.narrow(ref);
} catch(...) { ... }
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
141
3.4 CORBA im Detail ...
3.4.4 Delegation und Tie-Klassen
➥ In der Regel: Objekt-Implementierung erweitert die vom
IDL-Compiler erzeugte POA-Klasse, z.B.:
public class HelloImpl extends HelloPOA {
public String sayHello(String Name) {
...
➥ Falls dies nicht möglich ist: IDL-Compiler kann Tie-Klasse
erzeugen, die Aufrufe delegiert
➥ Objekt-Implementierung muß nur noch die Schnittstelle
implementieren, z.B.:
public class HelloImpl implements HelloOperations {
public String sayHello(String Name) {
...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
142
3.4.4 Delegation und Tie-Klassen ...
Aufbau der Tie-Klasse
public class HelloPOATie extends HelloPOA
{
private HelloOperations _delegate;
public HelloPOATie(HelloOperations delegate) {
_delegate = delegate;
}
// this() registriert den Servant auch beim RootPOA
public HelloWorld.Hello _this() {
return HelloWorld.HelloHelper.narrow(_this_object());
}
...
public java.lang.String sayHello(java.lang.String Name) {
return _delegate.sayHello(Name);
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
143
3.4.4 Delegation und Tie-Klassen ...
Server-Programm mit Tie-Klasse
ORB orb = ORB.init(args, null);
HelloImpl helloImpl = new HelloImpl();
HelloPOATie helloTie = new HelloPOATie(helloImpl);
Hello href = helloTie._this();
POA rootpoa = POAHelper.narrow(
orb.resolve_initial_references("RootPOA"));
rootpoa.the_POAManager().activate();
NamingContextExt ncRef = NamingContextExtHelper.narrow(
orb.resolve_initial_references("NameService"));
ncRef.rebind(ncRef.to_name("HelloWorld"), href);
orb.run();
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
144
3.4.4 Delegation und Tie-Klassen ...
Beispiel: Vererbung der Implementierung
➥ IDL-Schnittstelle:
module HelloWorld
{
interface Hello
{
string myName();
string sayHello(in string Name);
};
interface HelloToo : Hello
{
string sayHelloToo();
};
};
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
145
3.4.4 Delegation und Tie-Klassen ...
Beispiel: Vererbung der Implementierung ...
➥ Klassendiagramm der Implementierung:
HelloOperations
String myName()
String sayHello(String)
HelloPOA
HelloTooOperations
String sayHelloToo()
Hello
HelloToo
HelloTooPOA
HelloImpl
HelloTooImpl
_delegate
_delegate
HelloPOATie
HelloTooPOATie
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
146
3.4 CORBA im Detail ...
3.4.5 Statische und dynamische Aufrufe
➥ Statische Aufrufe:
➥ schnittstellenspezifische Stubs und Skeletons werden zur
Übersetzungszeit aus IDL generiert
➥ Dynamic Invocation Interface (DII):
➥ erlaubt dem Client Methoden aufzurufen, ohne daß
Schnittstelle zur Übersetzungszeit bekannt sein muß
➥
für generische Clients, z.B. Property-Editor, graphische
Entwicklungsumgebung
➥ Information zur Schnittstelle kann zur Laufzeit z.B. über
Interface Repository gewonnen werden
➥ Client muß Request explizit erzeugen und absenden
➥
auch asynchrone Aufrufe möglich
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
147
3.4.5 Statische und dynamische Aufrufe ...
➥ Dynamic Skeleton Interface (DSI):
➥ ermöglicht Objekt-Implementierungen, die zur Übersetzungs-
zeit die Schnittstelle nicht kennen, z.B.:
➥ Interpreter, Debugger, dynamisch getypte Sprachen wie
Lisp
➥ generische CORBA-Schnittstelle für Objekte einer
objektorientierten Datenbank
➥ generische Proxies (in Verbindung mit DII)
➥ Objektadapter reicht alle Aufrufe an dieselbe Methode
invoke() der Objektimplementierung weiter
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
148
3.4.5 Statische und dynamische Aufrufe ...
Beispiel für dynamischen Methodenaufruf über DII
NVList argList = orb.create_list(1); // Argumentliste aufbauen
Any arg = orb.create_any();
arg.insert_string("Roland");
NamedValue nv = argList.add_value("name", arg, ARG_IN.value);
Any res = orb.create_any(); // Ergebnisobjekt erzeugen
res.insert_string("");
NamedValue resv = orb.create_named_value("result", res,
ARG_OUT.value);
// Request erzeugen: result = sayHello(name)
Request req = helloRef._create_request(null, "sayHello",
argList, resv);
req.invoke(); // Request ausführen
// Alternativ: req.send deferred(); ...; req.get response();
String s = res.extract_string();
Roland Wismüller
Betriebssysteme / verteilte Systeme
// Ergebnis extrahieren
Client/Server-Programmierung (5/12)
149
3.4 CORBA im Detail ...
3.4.6 Portable Object Adapter (POA)
➥ Komponenten des POA-Modells:
➥ Servant:
➥
laufende Instanz einer Objektimplementierung
➥ Lebenszeit von Servant und Objekt entkoppelt, Objekt ggf.
nacheinander durch mehrere Servants realisiert
➥ Servant kann mehrere Objekte implementieren
➥ Objekt-ID:
➥
im Bereich eines POA eindeutige ID
➥ zur Zuordnung von Anfragen an Servants
➥ Objektreferenz:
➥
enthält eindeutige ID des POA und Objekt-ID
➥ zusätzlich ggf. Ort des Servers / POAs, ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
150
3.4.6 Portable Object Adapter (POA) ...
➥ Komponenten des POA-Modells: ...
➥ POA:
➥
Namensraum für Objekt-IDs
➥ bildet Objekt-IDs auf Servants ab
➥ bestimmt über POA Policies das Verhalten der von ihm
verwalteten Servants
➥ Active Object Map:
➥
Abbildung von Objekt-IDs auf Servants
➥ aktives Objekt: Objekt-ID steht in Active Object Map
➥ aktiver Servant: ist in Active Object Map eingetragen
➥ Default Servant:
➥
bearbeitet Anfragen für inaktive Objekte
➥ muß bei Bedarf von der Anwendung registriert werden
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (5/12)
151
Client/Server-Programmierung
WS 2013/2014
06.12.2013
Roland Wismüller
Betriebssysteme / verteilte Systeme
.d
[email protected] e
rolanda
Tel.: 0271/740-4050, Büro: H-B 8404
Stand: 23. April 2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
i
Client/Server-Programmierung (6/12)
3.4.6 Portable Object Adapter (POA) ...
➥ Komponenten des POA-Modells: ...
➥ Servant Manager :
➥
kann bei Bedarf von der Anwendung registriert werden
➥ übernimmt bei Anfragen an inaktive Objekte ggf.:
➥ Aktivierung eines neuen Servants
➥ Zuordnung der Objekt-ID zu vorhandenem Servant
➥ POA Manager :
➥
kapselt Zustand von POAs
➥ kann POA aktivieren oder veranlassen, daß Anfragen
(temporär) zwischengespeichert oder verworfen werden
➥ Adapter Activator :
➥
aktiviert (Kind-)POA, wenn Server Anfrage an nichtexistierenden POA erhält
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
152
3.4.6 Portable Object Adapter (POA) ...
POA-Architektur
POA A
Root POA
Active Object Map
Object ID
Default Servant
POA
Manager
Adapter
Activator
Objektreferenz
Servant−Zeiger
Roland Wismüller
Betriebssysteme / verteilte Systeme
Servant
Object ID
Object ID
Object ID
POA B
Servant
Default
Servant
Servant
Servant Manager
Servant
Manager
Object ID
Object ID
Servant
Adapter Activator
Servant
POA C
Object ID
Servant
Client/Server-Programmierung (6/12)
153
3.4.6 Portable Object Adapter (POA) ...
POA Policies
➥ Thread Policy : Multithreading im Server?
➥ SINGLE THREAD MODEL: POA ruft Methoden eines Servants
sequentiell auf
➥ ORB CRTL MODEL: implementierungsspezifisch, mehrere
Threads erlaubt
➥ Lifespan Policy : Lebensdauer der Objekte
➥ TRANSIENT: Objekte leben nur so lange wie POA
➥ PERSISTENT: Objekte können länger leben wie POA
➥
POA mit gegebenem Namen; bei Server-Neustart:
➥ Server muß wieder ursprünglichen Port benutzen
➥ Server muß POA gleichen Namens erzeugen
➥ (nicht: Objektzustand wird persistent gespeichert)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
154
3.4.6 Portable Object Adapter (POA) ...
POA Policies ...
➥ Object ID Uniqueness Policy
➥ UNIQUE ID: nur eine Objekt-ID pro Servant
➥ MULTIPLE ID: mehrere Objekt-IDs pro Servant erlaubt
➥ ID Assignment Policy : wer erzeugt Objekt-IDs?
➥ USER ID: Anwendung, SYSTEM ID: POA
➥ Request Processing Policy
➥ USE ACTIVE OBJECT MAP ONLY: Objekt-IDs werden nur über
Active Object Map (AOM) auf Servants umgesetzt
➥ USE DEFAULT SERVANT: Wenn Objekt-ID nicht in AOM ist:
Anfrage an registrierten Default Servant leiten
➥ USE SERVANT MANAGER: Wenn Objekt-ID nicht in AOM ist: über
registrierten Servant Manager neuen Servant erzeugen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
155
3.4.6 Portable Object Adapter (POA) ...
POA Policies ...
➥ Servant Retention Policy
➥ [NON ]RETAIN: Servants werden [nicht] in AOM aufgenommen
➥ Implicit Activation Policy
➥ IMPLICIT ACTIVATION: implizite Aktivierung von Servants
durch POA, z.B. bei
➥ POA.servant to reference(), POA.servant to id()
➥ ggf. Typkonvertierung von Servant nach Objektreferenz
➥ NO IMPLICIT ACTIVATION: Servant muß explizit aktiviert
werden
➥ POA.activate object(): POA generiert Objekt-ID
➥ POA.activate object with id(): Anwendung generiert
Objekt-ID
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
156
3.4.6 Portable Object Adapter (POA) ...
Standard-Policy des Root-POA
➥ Thread Policy : ORB CRTL MODEL
➥ Lifespan Policy : TRANSIENT
➥ Object ID Uniqueness Policy : UNIQUE ID
➥ ID Assignment Policy : SYSTEM ID
➥ Request Processing Policy : USE ACTIVE OBJECT MAP ONLY
➥ Servant Retention Policy : RETAIN
➥ Implicit Activation Policy : IMPLICIT ACTIVATION
➥ Policy kann nicht geändert werden, ggf. muß neuer POA erzeugt
werden
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
157
3.4.6 Portable Object Adapter (POA) ...
Beispiel: Leichtgewichtige Objekte ...
➥ Objekte mit kleinem“ Zustand
”
➥ Attribute können in Objekt-ID eincodiert werden
➥ Alle Objekte werden durch einen einzigen (Default-)Servant
realisiert
➥ Vorteil: Skalierbarkeit
➥ geringer Ressourcenverbrauch beim Server
➥ Anmerkung: mit DSI kann ein einziger Servant sogar Objekte
unterschiedlicher Klassen implementieren ...
➥ Vollständiger Code: siehe WWW
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
158
3.4.6 Portable Object Adapter (POA) ...
Beispiel: IDL-Datei
module HelloWorld
{
// Schnittstelle der Objekte, werden vom Client über Factory erzeugt
interface Hello
{
string sayHello();
};
// Schnittstelle des Factory−Objekts
interface HelloFactory
{
Hello createHello(in string name);
};
};
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
159
3.4.6 Portable Object Adapter (POA) ...
Beispiel: Client (Ausschnitt)
// Resolve the object reference in naming
NameComponent path[] = ncRef.to_name("HelloWorld");
HelloFactory helloFact = HelloFactoryHelper.narrow(
ncRef.resolve(path));
// Erzeuge Objekte über Factory
int i;
Hello hello[] = new Hello[100];
for (i=0; i<100; i++)
hello[i] = helloFact.createHello("Name" + i);
// Rufe Methode für jedes Objekt auf
for (i=0; i<100; i++)
System.out.println(hello[i].sayHello());
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
160
3.4.6 Portable Object Adapter (POA) ...
Beispiel: Server-Code
// Create and initialize the ORB
ORB orb = ORB.init(args, null);
POA rootpoa = POAHelper.narrow(
orb.resolve_initial_references("RootPOA"));
rootpoa.the_POAManager().activate();
// Create and activate a new POA with our policy
Policy[] policies = new Policy[3];
policies[0] = rootpoa.create_lifespan_policy(
LifespanPolicyValue.TRANSIENT);
policies[1] = rootpoa.create_id_assignment_policy(
IdAssignmentPolicyValue.USER_ID);
policies[2] = rootpoa.create_request_processing_policy(
RequestProcessingPolicyValue.USE_DEFAULT_SERVANT);
POA poa = rootpoa.create_POA("my_poa", null, policies);
poa.the_POAManager().activate();
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
161
3.4.6 Portable Object Adapter (POA) ...
// Create the factory object
HelloFactoryImpl helloRef = new HelloFactoryImpl();
poa.activate_object_with_id("Factory".getBytes(), helloRef);
org.omg.CORBA.Object ref =
poa.servant_to_reference(helloRef);
HelloFactory href = HelloFactoryHelper.narrow(ref);
// Create and register the default servant
HelloImpl hello = new HelloImpl();
poa.set_servant(hello);
// Register the factory object
org.omg.CORBA.Object objRef =
orb.resolve_initial_references("NameService");
NamingContextExt ncRef =
NamingContextExtHelper.narrow(objRef);
ncRef.rebind(ncRef.to_name("HelloWorld"), href);
orb.run();
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
162
3.4.6 Portable Object Adapter (POA) ...
Beispiel: Objekt-Implementierung
public class HelloImpl extends HelloPOA
{
public String sayHello()
{
// Extract name from our object ID
byte[] id = _object_id();
String name = new String(id);
return "The world says HELLO to " + name;
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
163
3.4.6 Portable Object Adapter (POA) ...
Beispiel: Factory-Implementierung
public class HelloFactoryImpl extends HelloFactoryPOA
{
public Hello createHello(String name)
{
// Encode the name in the object ID
byte[] id = name.getBytes();
POA poa = _poa();
// Create object reference(!) with given object ID
org.omg.CORBA.Object obj =
poa.create_reference_with_id(id, "IDL:Hello:1.0");
return HelloHelper.narrow(obj);
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
164
3.4 CORBA im Detail ...
3.4.7 GIOP, IIOP und IOR
➥ Seit CORBA 2.0: Kommunikationsprotokoll zwischen Objekten
bzw. ORBs ist standardisiert
➥ GIOP: General Inter-ORB Protocol
➥
Spezifikation, wie Protokolle auszusehen haben
➥ IIOP: Internet Inter-ORB Protocol
➥
konkretes Protokoll auf Basis von TCP/IP
➥ Damit: Interoperabilität zwischen verschiedenen ORB-Implementierungen
➥ IOR: Interoperable Object Reference
➥ Aufbau von Objektreferenzen ist ebenfalls standardisiert
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
165
3.4.7 GIOP, IIOP und IOR ...
GIOP
➥ Spezifiziert unter anderem:
➥ Annahmen über Transportschicht
➥
verbindungsorientiert, duplex, zuverlässig, stromorientiert
➥ binäres Übertragungsformat für IDL-Datentypen
➥
CDR: Common Data Representation
➥ unterstützt Little-Endian und Big-Endian
➥ über Tag, Empfänger konvertiert bei Bedarf
➥ keine Typ-Tags, d.h. Empfänger muß Datentyp kennen
(Problem ggf. bei dynamischen Aufrufen)
➥ acht Nachrichtenformate
➥
Request, Reply, CloseConnection, ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
166
3.4.7 GIOP, IIOP und IOR ...
IIOP und IOR
➥ Implementierung des GIOP auf Basis von TCP/IP
➥ Hauptaufgabe: Festlegung des konkreten Aufbaus von IORs
➥ Genereller Aufbau einer IOR:
Repository ID
(standardisiert)
Verbindungsendpunkt Object−Key
(standardisiert)
(proprietär)
Verb.
Obj.Key
...
➥ Object-Key enthält Objekt-ID und POA-Namen
➥ mehrere Einträge für Verbindungsendpunkt / Object-Key
möglich, damit z.B.
➥
Objekt über verschiedene GIOP-Protokolle erreichbar
➥ Objekt mehrfach vorhanden (Lastausgleich, Fehlertoleranz)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
167
3.4.7 GIOP, IIOP und IOR ...
IIOP und IOR ...
➥ Verbindungsendpunkt bei IIOP: Host / IP-Adresse und Port
➥ Beispiel für Inhalt einer IOR
TypeId : IDL:omg.org/CosNaming/NamingContextExt:1.0
TAG_INTERNET_IOP Profiles:
Profile Id:
0
IIOP Version : 1.2
Host:
141.99.179.102
Port:
33523
Object key (URL):
StandardNS/NameServer−POA/_root
Object key (hex):
0x53 74 61 6E 64 61 72 64 4E 53
2F 4E 61 6D 65 53 65 72 76 65
72 2D 50 4F 41 2F 5F 72 6F 6F 74
➥ Formatiert mit dem dior-Tool des JacORB
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
168
3.4.7 GIOP, IIOP und IOR ...
Nutzung von IORs
➥ IORs in String-Form können beliebig zwischen Objekten
ausgetauscht werden, z.B.
➥ als Methoden-Parameter oder -Ergebnis
➥ über Dateien, WWW, ...
➥ Damit: Objekte können auch ohne Name Service bekanntgegeben werden
➥ Relevante Methoden (in Klasse ORB):
➥ object_to_string() : Erzeugt String-Form einer CORBA-
Objektreferenz
➥ string_to_object() : Wandelt String wieder in CORBA-
Objektreferenz um
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
169
3.4 CORBA im Detail ...
3.4.8 Implementation Repository (IMR)
➥ ORBs unterstützen typischerweise zwei Methoden, wie IORs an
Servants gebunden werden:
➥ direktes Binden: IOR enthält Host/Port des Servers, in dem
Servant läuft
➥ indirektes Binden: IOR enthält Host/Port eines externen
Brokers, d.h. des IMR
➥ IMR kennt Ort (Host/Port) des Servers
➥ IMR unterstützt u.a.:
➥ automatischer Server-Startup
➥ Migration von Servern bzw. Objekten
➥ automatischer Lastausgleich
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
170
3.4.8 Implementation Repository (IMR) ...
➥ CORBA Spezifikation standardisiert nur Interaktion zwischen
Clients und IMR
➥ ausreichend um Interoperabilität zu sichern
➥ Realisierung und Funktionsumfang des IMR sowie Schnittstelle
zu Servern ist ORB-spezifisch
Roland Wismüller
Betriebssysteme / verteilte Systeme
171
Client/Server-Programmierung (6/12)
3.4.8 Implementation Repository (IMR) ...
Beispiel: Automatischer Server-Start
Client
5 sayHello()
Objektreferenz
[myPOA:hello1]
IDL:HelloWorld/Hello:1.0 frodo:2133 myPOA:hello1
Reply von
7 sayHello()
4
LOCATION_FORWARD
[bilbo:1799]
Server (bilbo: 1799)
myPOA
hello1
2
rsh bilbo java HelloServer
6
3
ready
[myPOA,
bilbo: 1799]
Implementation Repository (frodo:2133)
1
sayHello()
[myPOA:hello1]
Server−Tabelle
HelloWorld myPOA rsh bilbo java HelloServer bilbo:1799
Test
Print
gandalf: 1234
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
172
3.4.8 Implementation Repository (IMR) ...
Beispiel: Automatischer Server-Start ...
1. Client ruft Methode über IOR auf, Anfrage wird an IMR geleitet
2. IMR sieht in Server-Tabelle nach, ob POA existiert.
Falls nicht, wird Server (mit POA) gestartet
3. Server sendet Fertig-Meldung an IMR, mit Host/Port.
IMR trägt Information in Server-Tabelle ein
4. IMR konstruiert neue IOR, die Host/Port des Servers enthält
und sendet LOCATION FORWARD-Nachricht an Client
5. Client sendet Anfrage zum zweiten Mal, diesmal an Server
6. Server findet POA über POA-Namen. POA findet passenden
Servant über Objekt-ID und ruft Methode auf
7. Ergebnis wird an Client zurückgegeben
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
173
3.4 CORBA im Detail ...
3.4.9 Interface Repository (IR)
➥ Online Datenbank“ mit Schnittstellenbeschreibungen
”
➥ CORBA spezifiziert nur Zugriffsmethoden (lesen / schreiben)
➥ Implementierung ist ORB-spezifisch
➥ ebenso, wie IDL-Spezifikationen in das IR kommen
➥ IR nützlich u.a. für:
➥ Typprüfung der Parameter durch den ORB (auch bei DII)
➥ Verbindung mehrerer ORBs
➥ Metadaten für Clients und Server (für DII, DSI)
➥
z.B. Klassenbrowser, Anwendungsgeneratoren, ...
➥ selbstbeschreibende Objekte (Introspection)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
174
3.4.9 Interface Repository (IR) ...
Wichtige Klassen und Methoden
➥ IR definiert Klassen (genauer: Schnittstellen) für alle
IDL-Konstrukte, z.B.:
➥ ModuleDef, InterfaceDef, OperationDef, ParameterDef, ...
➥ Objekte der Klassen enthalten einander, entsprechend der
Verschachtelung in der IDL
➥ Basisklassen Container und Contained
➥ InterfaceDef enthält mehrere OperationDefs, ...
➥ Von Contained erbt jede Klasse die Methode describe()
➥ liefert Beschreibung des IDL-Konstrukts als Struct
➥
z.B. struct OperationDescription enthält Name, Repository-ID, Ergebnistyp, Parameterliste, Exceptions, ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
175
3.4.9 Interface Repository (IR) ...
Startpunkte für die IR-Information
➥ Methode _get_interface_def() liefert InterfaceDef eines
Objekts:
Hello helloRef = HelloHelper.narrow(ncRef.resolve(path));
org.omg.CORBA.Object c = helloRef._get_interface_def();
org.omg.CORBA.InterfaceDef id =
org.omg.CORBA.InterfaceDefHelper.narrow(c);
➥ Methode lookup_id() des IR liefert IR-Objekt zu einer
Repository-ID
➥ Repository-ID beschreibt IDL-Element eindeutig, z.B. im
Hello-World-Beispiel:
➥ IDL:HelloWorld/Hello:1.0 für Interface Hello
➥ IDL:HelloWorld/Hello/sayHello:1.0 für Operation
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
176
3.4.9 Interface Repository (IR) ...
Beispiel: Abfrage aller Methoden einer Schnittstelle
ORB orb = ORB.init( args, null );
Repository ir = RepositoryHelper.narrow(
orb.resolve_initial_references("InterfaceRepository"));
org.omg.CORBA.Contained c =
ir.lookup_id("IDL:HelloWorld/Hello:1.0");
org.omg.CORBA.InterfaceDef id =
org.omg.CORBA.InterfaceDefHelper.narrow(c);
org.omg.CORBA.InterfaceDefPackage.FullInterfaceDescription fid =
id.describe_interface();
System.out.println("Interface " + fid.name);
int i;
for (i=0; i<fid.operations.length; i++)
System.out.println(" Methode " + fid.operations[i].name);
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
Anmerkungen zu Folie 177:
Nutzung des IR unter JacORB (Beispiel: Hello-World)
➥ Erzeugen / Installieren der IDL-Information
➥ idl -ir Hello.idl
➥ javac HelloWorld/*.java
➥ cp -r HelloWorld $HOME/myClassDirectory
➥ Start des IR
➥ Eintrag in $HOME/orb.properties:
➥ ORBInitRef.InterfaceRepository=file:.../.jaco ir
(Statt ... Pfad des Heimatverzeichnisses)
➥ ir $HOME/myClassDirectory $HOME/.jaco ir
➥ Beim Übersetzen der Java-Programme:
➥ $JACORB HOME/lib/jacorb.jar in CLASSPATH aufnehmen
177
3.4 CORBA im Detail ...
3.4.10 Sicherheit
➥ CORBA-Spezifikation enthält Security Attribute Service
➥ Basis ist GIOP über (z.B.) SSL/TLS
➥ sichert Vertraulichkeit/Integrität der Nachrichten
➥ sichert Authentifizierung des Servers
➥ Security Attribute Service realisiert zusätzlich:
➥ Authentifizierung des Clients
➥
u.a. über Benutzername und Paßwort
➥ Weitergabe von Sicherheitsattributen (z.B. Identität,
Privilegien) des Clients an den Server
➥
damit: Delegation von Rechten möglich, d.h. Server kann
für Benutzer agieren
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
178
3 CORBA ...
3.5 Zusammenfassung
➥ CORBA definiert ein verteiltes, sprach- und plattformunabhängiges Objektmodell
➥ standardisiertes Protokoll (GIOP, IIOP) stellt Interoperabilität
sicher
➥ Zentral: Schnittstellenbeschreibung über OMG IDL
➥ automatische Erzeugung von Stubs und Skeletons
➥ Keine 1-zu-1 Beziehung zwischen Objekten und Objektimplementierungen (Servants)
➥ POA kann unterschiedliche Policies realisieren
➥ CORBA spezifiziert Schnittstellen zu etlichen Diensten
➥ Namensdienst, Ereignisdienst, Lebenszyklus, ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
179
Client/Server-Programmierung
WS 2013/2014
4
RMI / IIOP
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
180
4 RMI / IIOP ...
Inhalt
➥ RMI über IIOP
➥ Farley, Crawford, Flanagan: S. 88ff, Kap. 7
➥ http://java.sun.com/j2se/1.5.0/docs/guide/rmi-iiop
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
181
4 RMI / IIOP ...
RMI über IIOP
➥ Ziel:
➥ Verbindung von Java-RMI Objekten mit nicht-Java (CORBA)
Objekten
➥ Vorgehensweise:
➥ RMI nutzt CORBA IIOP-Protokoll zur Kommunikation
zwischen Objekten
➥ Damit:
➥ Java-Client kann CORBA Objekt über RMI nutzen
➥ CORBA-Client kann RMI-Objekt über CORBA nutzen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
182
4 RMI / IIOP ...
Vorgehen zur Nutzung von RMI/IIOP
➥ Basisklasse: Remote-Objekte müssen von
javax.rmi.PortableRemoteObject erben statt von
java.rmi.server.UnicastRemoteObject
➥ RMI Compiler: Stubs und Skeletons müssen über rmic -iiop
erzeugt werden
➥ Option -idl erzeugt zusätzlich OMG IDL Datei
➥ Namensdienst: statt RMI Registry muß JNDI benutzt werden,
um auf CORBA-Namensdienst zuzugreifen
➥ Downcast: vom Namensdienst erhaltene Objektreferenzen
müssen über PortableRemoteObject.narrow() in gültige
Referenzen umgewandelt werden
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
183
4 RMI / IIOP ...
Beispiel: Gemischtes“ Hello World
”
➥ Server mit RMI realisiert
➥ Schnittstelle:
import java.rmi.Remote;
import java.rmi.RemoteException;
public interface Hello extends Remote
{
String sayHello(String to) throws RemoteException;
}
➥ Client wahlweise mit RMI oder CORBA
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
184
4 RMI / IIOP ...
Server-Code
import
import
import
import
javax.naming.*;
java.rmi.*;
java.util.*;
javax.rmi.PortableRemoteObject;
public class HelloServer extends PortableRemoteObject
implements Hello {
public HelloServer() throws RemoteException {
super();
}
public String sayHello(String to) {
System.out.println("Hello-Server called");
return "Hello World to " + to + "!";
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
185
4 RMI / IIOP ...
Server-Code ...
public static void main(String args[]) {
try {
// Server−Objekt erzeugen
HelloServer obj = new HelloServer();
// Referenz über JNDI beim Namensdienst registrieren
Properties props = new Properties();
props.put("java.naming.factory.initial",
"com.sun.jndi.cosnaming.CNCtxFactory");
props.put("java.naming.provider.url",
"iiop://bspc02:5555");
Context ctx = new InitialContext(props);
ctx.rebind("HelloWorld", obj);
}
catch (Exception e) { ... }
} }
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
186
4 RMI / IIOP ...
RMI Client
public static void main(String args[]) {
try {
// Obektreferenz über JNDI vom Namensdienst besorgen
Properties props = new Properties();
props.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.cosnaming.CNCtxFactory");
props.put(Context.PROVIDER_URL, "iiop://bspc02:5555");
Context ctx = new InitialContext(props);
Hello obj = (Hello)
PortableRemoteObject.narrow(ctx.lookup("HelloWorld"),
Hello.class);
// Remote Methode aufrufen
System.out.println(obj.sayHello("Roland"));
}
catch (Exception e) { ...}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
187
4 RMI / IIOP ...
CORBA Client
public static void main(String args[]) {
try{
// ORB erzeugen und initialisieren
ORB orb = ORB.init(args, null);
// Root naming context holen
org.omg.CORBA.Object ns =
orb.resolve_initial_references("NameService");
NamingContextExt ncRef = NamingContextExtHelper.narrow(ns);
// Objektreferenz vom Namensdienst besorgen
NameComponent path[] = ncRef.to_name("HelloWorld");
Hello helloRef = HelloHelper.narrow(ncRef.resolve(path));
System.out.println(helloRef.sayHello("Peter"));
}
catch(Exception e) { ... }
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
188
4 RMI / IIOP ...
Code-Erzeugung mit RMI-Server / CORBA-Client
Client−Seite Server−Seite
_HelloStub.java
Hello.java
HelloHolder.java
HelloHelper.java
javac
idlj
Hello.class
Hello.java
HelloOperations.java
HelloClient.java
HelloClient.class
Roland Wismüller
Betriebssysteme / verteilte Systeme
HelloServer.java
HelloServer.class
rmic −iiop −idl
javac
...
Hello.idl
_Hello_Stub.class
_HelloServer_Tie.class
Client/Server-Programmierung (6/12)
189
Client/Server-Programmierung
WS 2013/2014
5
Java Komponenten-Modelle
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
190
5 Java Komponenten-Modelle ...
Inhalt
➥ Komponenten-Modelle
➥ Java Beans
➥ Enterprise Java Beans (EJB 3.0)
➥ Burke / Monson-Haefel
➥ Farley / Crawford / Flanagan, Kap. 6 (EJB 2.1!)
➥ Orfali / Harkey, Kap. 27-34 (EJB 2.1!)
➥ Sriganseh / Brose / Silverman
➥ http://java.sun.com/products/javabeans/reference/api/
➥ http://java.sun.com/products/ejb/
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
191
5 Java Komponenten-Modelle ...
5.1 Komponenten-Modelle
➥ Was sind Software-Komponenten?
Software-Komponenten sind ausführbare Software-Einheiten,
die unabhängig hergestellt, erworben und konfiguriert werden und
aus denen sich funktionierende Gesamtsysteme
zusammensetzen lassen.
➥ Im Vordergrund: Zusammensetzungsaspekt
➥ Eine Komponente ist:
➥ eine funktional und technisch abgeschlossene, ausführbare
Einheit
➥ unabhängig als Einheit entwickelbar und konfigurierbar
➥ wiederverwendbar
➥ nur über genau festgelegte Schnittstellen ansprechbar
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
192
5.1 Komponenten-Modelle ...
Begriffe
➥ Visuelle Komponente
➥ stellt etwas auf dem Bildschirm (der Anwendung) dar
➥ Nichtvisuelle Komponente
➥ ist für Benutzer der Anwendung nicht sichtbar
➥ Komponentenmodell: definiert
➥ Architektur der Komponenten u. Struktur ihrer Schnittstellen
➥ Mechanismen zur Zusammenarbeit mit Container und
anderen Komponenten
➥ Container: Ausführungsumgebung für Komponenten
➥ Kontext, in dem Komponenten gruppiert und miteinander
verbunden werden
➥ stellt Management- und Kontroll-Dienste zur Verfügung
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
193
5.1 Komponenten-Modelle ...
Software-Entwicklung mit Komponenten
➥ Zwei Arten von Programmierern:
➥ Komponenten-Entwickler (component developer )
➥
implementiert eine Komponente
➥ Komponenten-Anwendungsentwickler (component assembler )
➥
entwickelt eine Anwendung (oder neue Komponenten)
durch Zusammenfügen existierender Komponenten
➥ i.d.R. mit (graphischer) Werkzeug-Unterstützung!
➥ Bei Komponenten daher zwei verschiedene Nutzungsphasen:
➥ Design Time: während der Anwendungsentwicklung
➥ Run Time: während der Ausführung der Anwendung
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
194
5.1 Komponenten-Modelle ...
Software-Entwicklung mit Komponenten: Beispiel
➥ Zusammenbau einer Komponente aus Teilkomponenten:
public class MyEventAdapter {
{
private TextBean target;
MyEventAdapter(TaextBean t) {
target = t;
}
public void actionPerformed(
ActionEvent e) {
if (x < max)
val = x;
target.setValue(val);
}
}
➥ Verwendung der Komponente in einer Anwendung:
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
195
5.1 Komponenten-Modelle ...
Werkzeug-Unterstützung (Bsp: Visual Café)
Komponenten−
auswahl
Anwendung mit
Komponenten
Editor für
Komponenten−
Eigenschaften
Wizard zur
Komponenten−
Verknüpfung
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
196
5.1 Komponenten-Modelle ...
Vorteile eines Komponenten-Modells
➥ Wiederverwendung von Software
➥ Vereinfachte Designphase für Anwendungen
➥ Vereinfachte Implementierungsphase für Anwendungen
➥ Zusammenstecken“ von Komponenten
”
➥ Bessere Skalierbarkeit
➥ Unterstützung durch Entwicklungswerkzeuge
➥ Ziel: Aufbau eines Markts von Komponenten
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (6/12)
197
5 Java Komponenten-Modelle ...
5.2 Komponentenmodelle in Java EE
➥ Java EE: Java Enterprise Edition
➥ Java EE definiert Familie von Komponentenmodellen:
➥ für Client-Tier : JavaBeans, Applets
➥ für Webserver-Tier : Servlets, JSP
➥ für Anwendungsserver-Tier : Enterprise JavaBeans (EJB)
➥ Daneben bietet Java EE weitere Dienste, z.B.
➥ Namensdienst (JNDI)
➥ Nachrichten-Infrastruktur (Java Messaging Service, JMS)
➥ Datenbank-Zugriff (JDBC)
➥ Transaktionsdienste, Sicherheitsdienste, ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
198
Client/Server-Programmierung (6/12)
5.2 Komponentenmodelle in Java EE ...
Verteilte Anwendungen mit Java EE
Applet−Container
Applet
HTTP
/SSL
Web−Container
Java SE
EJB−Container
RMI/
IIOP
JSP
EJB
Servlet
Application−
Client−Container
Client
Standard Services
Java SE
HTTP
/SSL Standard Services
Java SE
Standard Services
Java SE
JDBC
RMI/IIOP
JDBC
Roland Wismüller
Betriebssysteme / verteilte Systeme
JDBC
Database
Client/Server-Programmierung (6/12)
199
Client/Server-Programmierung
WS 2013/2014
31.01.2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
.d
[email protected] e
rolanda
Tel.: 0271/740-4050, Büro: H-B 8404
Stand: 23. April 2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
i
Client/Server-Programmierung (7/12)
5 Java Komponenten-Modelle ...
5.3 JavaBeans
➥ JavaBeans ist Spezifikation eines Komponentenmodells für Java
➥ definiert mehrere neue Java-Klassen und Schnittstellen
➥ besteht aber i.W. nur aus Namenskonventionen bzw.
Entwurfsmustern
➥ Ziel: Zusammenfügen von Komponenten mit Hilfe von visueller
Programmierung
➥ graphische Werkzeuge zur Anwendungserstellung
➥ Im Prinzip ist jede Java-Klasse eine JavaBean!
➥ Kompositions- und Anpassungsfähigkeit aber nur garantiert,
wenn Konventionen eingehalten werden
➥ I.d.R. besteht eine Bean aber aus mehreren Klassen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
200
5.3 JavaBeans ...
Was bietet eine JavaBean?
➥ Methoden
➥ wie jede andere Java-Klasse auch ...
➥ Eigenschaften (Properties)
➥ Attribute, über die mit Get- und Set-Methoden zugegriffen
werden kann
➥ Ereignisse (Events)
➥ werden von der Bean erzeugt
➥ können über Event Listener an andere Beans weitergegeben
werden
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
201
5.3 JavaBeans ...
Was bietet eine JavaBean? ...
➥ Introspektion
➥ Bean stellt über eine BeanInfo-Klasse Information über ihre
Methoden, Eigenschaften und Ereignisse bereit
➥
automatisch oder manuell erzeugt
➥ Anpassung (Customization)
➥ erlaubt Konfiguration der Properties über graphische
Werkzeuge
➥ Persistenz
➥ Properties der Bean können dauerhaft gespeichert und bei
Erzeugung der Bean geladen werden
➥
serialisiertes Objekt in .ser-Datei
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
202
5.3 JavaBeans ...
Black-Box Sicht einer JavaBean
BeanInfo
Customizer
Methoden
Properties
Ereignisse
JavaBean
Komponente
JAR−Archiv
(incl. .ser−Dateien)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
203
5.3 JavaBeans ...
Design-Time und Run-Time-Beans
➥ Run-Time-Bean:
➥ Sammlung von Klassen mit Programmlogik
➥ plus ggf. serialisierte Objektzustände (.ser-Dateien)
➥ Design-Time-Bean:
➥ zusätzliche Klassen für
➥
Customizer bzw. Property -Editoren
➥ Introspektion (BeanInfo)
➥ Icons für die Bean
➥ diese Klassen und Icons werden nur von graphischen
Entwicklungsumgebungen benötigt
➥ Klassen (und .ser-Dateien) sind typischerweise in einem
Java-Archiv abgelegt
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
204
5.3 JavaBeans ...
JDK als Komponenten-Framework
➥ Für JavaBeans übernimmt JDK die Rolle des KomponentenFrameworks
➥ Dienste für JavaBeans:
➥ Graphisches Layout und Darstellung
➥
für visuelle Komponenten: AWT bzw. Swing
➥ visuelle Bean erbt von AWT Component;
AWT Container dient als Komponenten-Container
➥ Ereignismodell, Properties, Introspektion, Persistenz,
Customization
➥ Bereitstellung der benötigten Klassen / Interfaces
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
205
5.3 JavaBeans ...
Beispiel: Smiley-Bean
public class SmileyBean extends Canvas {
private boolean smile = true;
...
public SmileyBean() {
setSize(250,250);
}
public synchronized void toggleSmile() {
smile = !smile;
repaint();
}
public void paint(Graphics g) { ... }
}
➥ Vollständiger Code: Orfali / Harkey, Kap. 28 bzw. CD-ROM
➥ SmileyBean ist lediglich eine normale Java-Klasse
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
206
5.3 JavaBeans ...
Beispiel: Container für Smiley-Bean
public class SmileyPlace extends Frame ... {
SmileyPlace() {
SmileyBean smiley = null;
// instantiiere die Bean
try {
smiley = (SmileyBean)Beans.instantiate(null,
"SmileyBean");
}
catch (Exception e) { ... }
// füge Bean in Container ein
add(smiley);
...
}
static public void main(String args[]) { ... }
...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
207
5.3 JavaBeans ...
Konventionen für Beans
➥ Beans dürfen nicht mit new erzeugt werden
➥ stattdessen: Beans.instantiate(classloader, name)
➥ Beans müssen einen Default-Konstruktor (ohne Argumente)
besitzen
➥ Visuelle Beans sollten von java.awt.Component (oder einer
Unterklasse) abgeleitet werden
➥ Als Komponenten-Container sollte ein AWT Container dienen
➥ Hinzufügen der Beans über die Methode add()
➥ Cast-Operationen oder instanceof sollten nicht verwendet
werden
➥ stattdessen: Beans.getInstanceOf(obj, class) bzw.
Beans.isInstanceOf(obj, class)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
208
5.3 JavaBeans ...
5.3.1 Ereignisse
➥ JavaBeans können Ereignisse erzeugen bzw. Ereignisse
behandeln
➥ Ereignismodell: Publish-Subscribe-Modell
➥ identisch mit dem Ereignismodell des AWT
➥ Beans geben (über Introspection) bekannt, welche Ereignisse
sie auslösen können
➥ interessierte Beans registrieren sich bei der Ereignisquelle
➥ Ereignisse sind Objekte, die von EventObject abgeleitet sind
➥ beinhalten Ereignisquelle sowie beliebige andere Parameter
des Ereignisses
➥ Namenskonvention: Klassenname muß mit Event enden
➥
z.B. ButtonEvent
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
209
5.3.1 Ereignisse ...
Ereigniskonsumenten (Event Listener)
➥ Erhalten Ereignisbenachrichtigungen
➥ Müssen Schnittstelle implementieren, die von
java.util.EventListener abgeleitet ist
➥ Namenskonvention: Ereignisname mit Endung Listener
➥ pro Ereignistyp eine Methode, ohne Namenskonvention
➥
Methode erhält Ereignisobjekt als Parameter
➥ Beispiel (für Ereignis ButtonEvent):
public interface ButtonListener extends EventListener {
public void onPress(ButtonEvent e);
public void onRelease(ButtonEvent e);
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
210
5.3.1 Ereignisse ...
Ereignisquellen (Event Sources)
➥ Sind Beans, die Ereignisse erzeugen
➥ Ereignisse werden für Listener über zwei Methoden verfügbar
gemacht (Namenskonvention!):
➥ addListenerType (): Anmelden eines Listeners
➥ removeListenerType (): Abmelden eines Listeners
➥ z.B. für ButtonEvent:
void addButtonListener(ButtonListener l)
void removeButtonListener(ButtonListener l)
➥ Ereignisquelle ist für Verwaltung der Listener und Aufruf der
Methode zur Ereignismeldung (z.B. onPress()) verantwortlich
➥ typisch mittels Vector und Schleife über alle Listener
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
211
5.3.1 Ereignisse ...
Beispiel: Smiley und Button
➥ Button ist AWT-Element und auch JavaBean
➥ stellt Ereignis ActionEvent zur Verfügung:
public interface ActionListener extends EventListener {
public void actionPerformed(ActionEvent e);
}
➥ Button-Ereignis soll zum Umschalten des Smiley führen
➥ Einfachste Realisierung: direkte Verdrahtung“
”
➥ SmileyBean implementiert ActionListener-Interface
public class SmileyBean extends Canvas
implements ActionListener {
...
public void actionPerformed(ActionEvent e) {
toggleSmile();
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
212
5.3.1 Ereignisse ...
Beispiel: Container
public class SmileyPlace extends Frame ... {
SmileyPlace() {
SmileyBean smiley = null;
Button button = null;
try { // instantiiere die Beans
smiley = (SmileyBean)Beans.instantiate(null, "SmileyBean");
button = (Button)Beans.instantiate(null, "java.awt.Button");
}
catch (Exception e) { ... }
add(smiley, "North"); // füge Beans in Container ein
add(button, "South");
button.addActionListener(smiley); // verbinde die Beans
...
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
213
5.3.1 Ereignisse ...
Ereignis-Adapter
➥ Nachteil der direkten Verdrahtung:
➥ Listener muß passende Schnittstelle implementieren
➥ widerspricht Idee, Beans über Werkzeuge zu verdrahten“
”
Bean kann Ereignisse nicht a-priori kennen
➥ Code der Bean kann nicht geändert werden
➥
➥ Abhilfe: Verwendung eines Adapters (Indirektion)
➥ Adapter implementiert passende Listener -Schnittstelle
und ruft Methode in der Ziel-Bean auf
➥ Vorteile (u.a.):
➥
Beans bleiben vollständig unabhängig voneinander
➥ Adapter kann Schnittstellen ggf. anpassen
➥ Adapter kann Ereignis auch an Remote-Objekt leiten
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
214
5.3.1 Ereignisse ...
Beispiel: Smiley und Button
addActionListener()
action
Performed()
Toggle
Button
Smiley
Event
Adapter
toggle
Smile()
SmileyBean
public class SmileyEventAdapter implements ActionListener {
private SmileyBean target;
SmileyEventAdapter(SmileyBean t) {
target = t;
}
public void actionPerformed(ActionEvent e) {
target.toggleSmile();
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
215
5.3 JavaBeans ...
5.3.2 Properties
➥ Eigenschaften einer Komponente
➥ können zur Design-Zeit mit Entwicklungswerkzeugen
verändert werden
➥ und werden dann persistent gespeichert
➥ können zur Laufzeit abgefragt und/oder gesetzt werden
➥ Zugriff ausschließlich über Get- und Set-Methoden
➥ d.h. Implementierung nicht unbedingt 1-zu-1 als Attribut
➥ Arten von Properties:
➥ einfache und Indexed Properties (d.h. Arrays)
➥ Bound und Constrained Properties
➥
Benachrichtigungs-Ereignisse bei Änderungen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
216
5.3.2 Properties ...
Namenskonventionen für Get- und Set-Methoden
➥ Einfache Properties (Beispiel: int Age)
➥ public int getAge();
➥ public void setAge(int value);
➥ Einfache Boole’sche Properties
➥ public int isMarried();
➥ public void setMarried(boolean value);
➥ Indexed Properties (Beispiel: short[] TabStops)
➥
➥
➥
➥
public
public
public
public
short[] getTabStops();
short getTabStops(int index);
void setTabStops(short[] value);
void setTabStops(int index, short value);
➥ Alle Methoden sind optional
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
217
5.3.2 Properties ...
Bound Properties
➥ Eine Bean kann Änderungen von Properties als Ereignisse an
interessierte Beans weitermelden
➥ Dazu: Bean muß Ereignis PropertyChangeEvent unterstützen
public interface PropertyChangeListener extends EventListener {
public void propertyChange(PropertyChangeEvent e);
}
➥ D.h. Bean muß folgende Methoden besitzen:
void addPropertyChangeListener(PropertyChangeListener l)
void removePropertyChangeListener(PropertyChangeListener l)
➥ JDK bietet Klasse PropertyChangeSupport zur Verwaltung und
Benachrichtigung der Listener
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
218
5.3.2 Properties ...
Constrained Properties
➥ Wie Bound Properties, aber Listener haben die Möglichkeit, der
Änderung zu widersprechen (Veto)
➥ Dazu: Ereignis VetoableChangeEvent
public interface VetoableChangeListener extends EventListener {
public void vetoableChange(VetoableChangeEvent e);
}
➥ Listener kann in vetoableChange() eine PropertyVetoException werfen, um der Änderung zu widersprechen
➥ Hilfsklasse VetoableChangeSupport zur Verwaltung und
Benachrichtigung der Listener
➥ bei Veto: Benachrichtigung abbrechen, alle Listener mit
ursprünglichem Wert erneut benachrichtigen, liefert
PropertyVetoException an Aufrufer
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
219
5.3 JavaBeans ...
5.3.3 Persistenz
➥ Beans können wie normale Objekte serialisiert und in Dateien
gespeichert werden
➥ Bean (bzw. Oberklasse) muß Schnittstelle Serializable
implementieren
➥ Beispiel:
FileOutputStream fos = new FileOutputStream("Smiley.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(smiley);
➥ Beans.instantiate(classloader, name) sucht .ser-Datei mit
gegebenem Namen
➥ falls erfolgreich: erzeuge Bean mit dem serialisierten Zustand
aus der Datei
➥ sonst: erzeuge frische“ Bean der angegebenen Klasse
”
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
220
5.3 JavaBeans ...
5.3.4 Introspektion
➥ Über Methode java.beans.Introspector.getBeanInfo() kann
Information über eine Bean abgefragt werden:
➥ Methoden, Properties, Ereignisse, ...
➥ Information wird in BeanInfo-Objekt zurückgeliefert
➥ Bean kann Information explizit bereitstellen
➥
über eine Klasse BeanName BeanInfo (Namenskonvention!), die BeanInfo-Schnittstelle implementiert
➥ z.B. SmileyBeanBeanInfo für SmileyBean
➥ sonst: Introspector erzeugt die Information dynamisch
➥
setzt voraus, daß sich die Bean genau an die Namenskonventionen hält
➥ Erweiterung des Java Reflection-Mechanismus
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
221
5.3.4 Introspektion ...
Information in der BeanInfo
➥ BeanDescriptor: Bean-Klasse und Customizer -Klasse
➥ Customizer ist optional; implementiert Bean-spezifische GUI
(für Entwicklungswerkzeuge), um Eigenschaften der Bean
anzupassen
➥ PropertyDescriptor: Beschreibung der Properties
➥ Name, Typ (Klasse), Get- und Set-Methode,
Bound/Constrained Property?, ...
➥ Property Editor : optional; implementiert Bean-spezifische
Editor-Komponente (für Entwicklungswerkzeuge) für eine
Property (z.B. Farbe)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
222
5.3.4 Introspektion ...
Information in der BeanInfo ...
➥ EventSetDescriptor: Beschreibung der Ereignisse
➥ Listener -Klasse, Listener -Methoden, Add und
Remove-Methoden für Listener, ...
➥ MethodDescriptor: Beschreibung der Methoden
➥ Name, Method-Objekt (Java Reflection), Beschreibung der
Parameter, ...
➥ Icon zur Darstellung der Bean in Entwicklungswerkzeugen
➥ Default-Property und Default-Ereignis
➥ die am wahrscheinlichsten vom Benutzer eines
Entwicklungswerkzeugs ausgewählt werden
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
223
5.3 JavaBeans ...
5.3.5 Zusammenfassung
➥ Komponentenmodell für Java
➥ vorwiegend für clientseitige, visuelle Komponenten
➥ Ziel: werkzeugunterstützte Erstellung von Anwendungen
➥ Java Beans unterstützt:
➥ Methoden
➥ Eigenschaften (Properties)
➥
auch mit Ereignismeldung/Veto bei Änderung
➥ Ereignisse (über Listener -Interface)
➥ Introspektion (für Werkzeuge)
➥ Anpassung (Customization) (für Werkzeuge)
➥ Persistenz (Speicherung der konfigurierten Properties)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (7/12)
224
Client/Server-Programmierung
WS 2013/2014
06.12.2013
Roland Wismüller
Betriebssysteme / verteilte Systeme
.d
[email protected] e
rolanda
Tel.: 0271/740-4050, Büro: H-B 8404
Stand: 23. April 2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
i
Client/Server-Programmierung (8/12)
5 Java Komponenten-Modelle ...
5.4 Enterprise Java Beans (EJB 3.0)
➥ Was sind Enterprise Java Beans?
➥ serverseitige Komponenten-Architektur für Entwicklung und
Deployment von komponenten-basierten verteilten
Geschäftsanwendungen
➥ d.h.: Komponenten-Modell für Anwendungslogik einer
verteilten Anwendung
➥ EJBs werden immer in speziellem EJB-Container ausgeführt
➥ anwendungsunabhängiger Anwendungsserver
➥ Implementierungen von verschiedenen Anbietern
➥
z.B. JBoss, OpenEJB, IBM WebSphere, BEA WebLogic
➥ Schnittstelle zu EJBs ist standardisiert
➥ Zugriff auf EJBs erfolgt immer über EJB-Container
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
225
Anmerkungen zu Folie 225:
Dieser Abschnitt bezieht sich auf die Version 3.0 der EJB-Spezifikation. Gegenüber der
vorherigen Version 2.1 gibt es sehr große Unterschiede! Folien zu EJB 2.1 finden Sie
im Skript aus dem Wintersemester 2007/2008:
http://www.bs.informatik.uni-siegen.de/web/wismueller/vl/ws07/
csp/v 4.pdf
5.4 Enterprise Java Beans (EJB 3.0) ...
Ziel der EJB-Architektur
➥ Anwendungsprogrammierer erstellt nur Anwendungslogik
➥ und zwar komponentenbasiert ...
➥ Alle wichtigen, anwendungsunabhängigen Dienste werden vom
EJB-Container realisiert
➥ Nutzung der Dienste ist implizit
➥
wird nicht ausprogrammiert
➥ Spezifikation und Konfiguration der Dienste bei Erstellung
und/oder beim Deployment der EJB
➥ EJB-Container übernimmt Rolle eines Component Transaction
Monitors
➥ realisiert Komponentenmodell, Transaktions- und
Ressourcen-Management
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
226
5.4 Enterprise Java Beans (EJB 3.0) ...
Component Transaction Monitor
➥ Vereinigung von Transaktionsmonitor und ORB
➥ Aufgabe: automatisches Management von
➥ Transaktionen
➥ Persistenz von Objekten
➥ Sicherheit (insbes. Zugriffskontrolle)
➥ Ressourcenverwaltung (z.B. Pooling)
➥ Objektverteilung
➥ Nebenläufigkeit
➥ Fokus: zuverlässige, transaktionsorientierte Anwendungen mit
vielen Nutzern
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
227
5.4 Enterprise Java Beans (EJB 3.0) ...
Grundlegende Elemente in einer EJB-Umgebung
Business
Interface
Anwendungs−
Methoden
EJB Container
(Transaktionsmanagement
Zugriffskontrolle
Ressourcen−Pooling
Persistenz)
EJB
Client
EJB Instanzen
(Anwendungs−Methoden)
Antwort
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
228
5.4 Enterprise Java Beans (EJB 3.0) ...
Das EJB 3.0 Programmiermodell
EJB Container
Lokale
Sicht
Remote
Client
(8)
(1)
(8)
(1) Methoden−
aufruf
Remote
Sicht
Business
Interface
Lokaler
Client
(2) Aufruf der Methode
in der Wrapper Klasse
(7)
Wrapper−
Klasse*
(4) Aufruf der Methode
in der Bean Klasse
Container−
Dienste
(6) API−Aufrufe für Dienste
nach Methodenaufruf
(5)
EJB
Klasse
Roland Wismüller
Betriebssysteme / verteilte Systeme
(3) API−Aufrufe für Dienste
vor Methodenaufruf
* vom Container generiert
i.a. als EJB Objekt bezeichnet
Client/Server-Programmierung (8/12)
229
5.4 Enterprise Java Beans (EJB 3.0) ...
5.4.1 Arten von EJBs
➥ Entity Beans
➥ Daten-Objekte, die persistent (in Datenbank) gespeichert und
von mehreren Clients genutzt werden
➥ d.h. Objekte bzw. Beziehungen der Anwendungsmodellierung
➥
z.B. Kunde, Konto, Aktie, ...
➥ in EJB 3.0 nicht weiterentwickelt, aber weiterhin unterstützt
➥ (im folgenden nicht mehr behandelt, siehe Skript WS07/08)
➥ Entities (ab EJB 3.0, Java Persistence API)
➥ Ziele und Aufgaben wie bei Entity Beans, aber nur lokal
zugreifbar, leichtgewichtiger und besser standardisiert
➥ Persistenz wird automatisch durch Container realisiert
➥ auch unabhängig von Java EE verwendbar
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
230
5.4.1 Arten von EJBs ...
➥ Session Beans
➥ realisieren Aktionen, die mehrere Anwendungsobjekte
(Entities bzw. Entity Beans) betreffen
➥ d.h. die Geschäftslogik
➥ zustandslos (stateless) oder zustandsbehaftet (stateful)
➥ d.h. merkt sich die Bean Daten zwischen zwei Aufrufen
eines Clients?
➥ stateful Session Beans repräsentieren Client-Sitzungen
➥ kein persistenter Zustand
➥ Message Driven Beans (ab EJB 2.0)
➥ ähnlich wie Session Beans, aber asynchrone Schnittstelle
➥ Operationen werden über JMS-Nachrichten aufgerufen
statt über (entfernte) Methodenaufrufe
➥ (im folgenden nicht mehr behandelt)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
231
5.4 Enterprise Java Beans (EJB 3.0) ...
5.4.2 Anatomie einer EJB-Anwendung
➥ Eine EJB-Anwendung besteht aus:
➥ Session (bzw. Message Driven) Beans für die Anwendungslogik
➥ Session Beans sind normale Java-Klassen mit
Annotationen
➥ Local und Remote Business Interfaces der Session Beans
➥ normale Java-Interfaces, mit Annotationen
➥ i.d.R. durch zugehörige Session Bean implementiert
➥ Entities (bzw. Entity Beans) für das Datenmodell
➥ Entities sind normale Java-Klassen mit Annotationen
➥ Deployment-Deskriptoren
➥ XML-Dokumente
➥ beschreiben Beans und vom Container benötigte Dienste
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
232
5.4.2 Anatomie einer EJB-Anwendung ...
➥ Mehrere Beans werden mit gemeinsamen Deployment-Deskriptoren in ein JAR-Archiv gepackt
➥ Deployment-Deskriptoren im Verzeichnis META-INF
➥ META-INF/ejb-jar.xml kennzeichnet Archiv als EJB Archiv
➥ EJB-Anwendung besteht aus ein oder mehreren JAR-Archiven
➥ Alle weiteren benötigten Klassen werden zur Laufzeit generiert
➥ z.B.:
➥
Wrapper -Klassen für EBJ-Klassen bzw. Implementierungsklassen der Business Interfaces
➥ Stub-Klassen für die Clients
➥ Basis: generische Proxy-Klasse java.lang.reflect.Proxy
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
233
5.4.2 Anatomie einer EJB-Anwendung ...
Deployment-Deskriptoren
➥ ejb-jar.xml: für Session Beans (und andere)
➥ kann Annotationen in den EJB-Klassen überschreiben bzw.
ergänzen
➥
z.B. Kennzeichnung als EJB, Art der EJB, Verwaltung der
EJB zur Laufzeit (Transaktionen, Zugriffskontrolle), ...
➥ Arbeitsaufteilung zwischen EJB-Entwickler (Annotationen)
und Anwendungsentwickler (Deployment-Deskriptor)
➥ persistency.xml: für Entities
➥ analog zu ejb-jar.xml
➥ spezifiziert zusätzlich die Verbindung zur Datenbank
➥ Zusätzlich Container-spezifische Deskriptoren möglich
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
234
5.4.3 Einschub: Java Annotationen
➥ Eingeführt mit Java 5 (JDK 1.5)
➥ Erlauben die Spezifikation von beliebigen Metadaten für
Programm-Elemente
➥ z.B. für Typen, Methoden, Attribute, Parameter, Annotationen
➥ Annotationen werden vom Compiler übersetzt und sind getypt
➥ Typdefinition ähnlich wie bei Schnittstellen
➥ Die Annotationen eines Elements können zur Laufzeit über das
Reflection API abgefragt werden
➥ bei entsprechender Definition der Annotation
➥ Neben Annotationen des Java-Standards können auch eigene
Annotationen definiert werden
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
235
5.4.3 Einschub: Java Annotationen ...
Beispiel
➥ Definition einer Annotation:
import java.lang.annotation.*;
// Meta−Annotation: Annotation soll auch zur Laufzeit verfügbar sein
@Retention(RetentionPolicy.RUNTIME)
// Meta−Annotation: Annotation ist auf Klassen und Interfaces anwendbar
@Target(ElementType.TYPE)
// Definition der Annotation
public @interface CodeCategory {
boolean isTested();
String[] tester() default {};
boolean isReviewed() default false;
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
236
5.4.3 Einschub: Java Annotationen ...
Beispiel ...
➥ Verwendung der Annotation:
@CodeCategory(isTested = true, tester = {"joe","max"})
public class MyClass {
// ...
}
➥ Zugriff auf die Annotation zur Laufzeit:
MyClass obj = new MyClass();
CodeCategory cat =
obj.getClass().getAnnotation(CodeCategory.class);
System.out.println("is tested: " + cat.isTested());
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
237
5.4.3 Einschub: Java Annotationen ...
Anmerkungen zum Beispiel
➥ Bei Verwendung einer Annotation müssen die Attribut“-Werte mit
”
der Syntax <Name: > = <Wert> angegeben werden
➥ die Reihenfolge ist dabei beliebig
➥ Ausnahme: die Annotation hat nur ein (oder gar kein) Attribut
➥
z.B. @Retention und @Target
➥ Attribute können auch mit Default-Werten definiert werden
➥ z.B. tester und isReviewed
➥ bei Verwendung der Annotation brauchen dann keine Werte
angegeben zu werden
➥ eine leere Parameterliste kann auch ganz weggelassen werden
➥ Attribute können auch Arrays sein
➥ z.B. tester
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
238
5.4 Enterprise Java Beans (EJB 3.0) ...
5.4.4 Beispiel Hello World
Remote Business Interface
package org.Hello;
import javax.ejb.Remote;
// Java Annotation: markiert Schnittstelle als Remote EJB Interface
@Remote
public interface HelloRemote
{
public String sayHello();
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
239
5.4.4 Beispiel Hello World ...
EJB-Klasse
package org.Hello;
import javax.ejb.Stateless;
// Java Annotation: markiert Klasse als Stateless Session Bean
@Stateless
public class HelloImpl implements HelloRemote
{
public String sayHello()
{
return "Hallo? Jemand da?";
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
240
5.4.4 Beispiel Hello World ...
Deployment Deskriptor (ejb-jar.xml)
<?xml version="1.0" encoding="UTF-8"?>
<ejb-jar/>
➥ Leerer“ Deskriptor
”
➥ Zeigt lediglich an, daß es sich um eine EJB handelt
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
241
5.4.4 Beispiel Hello World ...
Client (OpenEJB)
import org.Hello.*;
import java.util.Properties;
import javax.naming.InitialContext;
public class HelloClient {
public static void main(String args[]) {
try {
// Properties für JNDI (hier: Nutzung von OpenEJB)
Properties p = new Properties();
p.put("java.naming.factory.initial",
"org.apache.openejb.client" +
".RemoteInitialContextFactory");
p.put("java.naming.provider.url",
"ejbd://127.0.0.1:4201");
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
242
5.4.4 Beispiel Hello World ...
Client (OpenEJB) ...
// User und Passwort sind optional!
p.put("java.naming.security.principal", "user");
p.put("java.naming.security.credentials", "password");
InitialContext ctx = new InitialContext(p);
Object obj = ctx.lookup("HelloImplRemote");
HelloRemote hello = (HelloRemote)obj;
System.out.println(hello.sayHello());
System.out.println(hello.sayHello());
}
catch (Exception e) { ... }
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
243
5.4.5 Einschub: OpenEJB
Nutzung von OpenEJB im Labor H-A 4111
➥ Private Installation (i.w. Konfigurationsdateien):
➥ Auf einem Rechner im Labor H-A 4111: Aufruf des Skripts
/opt/dist/tools/openejb_install.sh
➥
erzeugt private Verzeichnisse für Deployment der EJBs
➥ editiert Konfigurationsdateien so, daß jeder Benutzer
unterschiedliche Ports nutzt
➥ Umgebungsvariable und Pfad setzen (in $HOME/.profile):
export OPENEJB_HOME=$HOME/Soft/openejb-3.1.1
export PATH=$OPENEJB_HOME/bin:$PATH
➥ Start des Containers: openejb start
➥ Stoppen des Containers: ^C oder kill
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
244
5.4.5 Einschub: OpenEJB ...
Übersetzung / Deployment des Servers
➥ Übersetzung
➥ javac -cp $OPENEJB_HOME/lib/javaee-api-5.0-2.jar:.
org/Hello/*.java
➥ CLASSPATH muß nur gesetzt werden, wenn Java EE nicht
installiert ist (wegen EJB-Klassen)
➥ Erzeugung der JAR-Datei für die EJB
➥ jar cvf myHelloEjb.jar org/Hello/*.class META-INF
➥ Verzeichnis META-INF muß Deployment-Deskriptor
ejb-jar.xml enthalten
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
245
5.4.5 Einschub: OpenEJB ...
Übersetzung / Deployment des Servers ...
➥ Deployment der EJB
➥ openejb deploy -s ejbd://localhost:4201 myHelloEjb.jar
➥ OpenEJB-Container muß bereits laufen
➥
ggf. vorher starten: openejb start
➥ Optionen:
➥
-s: Angabe der URL des OpenEJB-Daemons
➥ z.Zt. nur localhost erlaubt
➥ kann entfallen, wenn Standard-Port 4201 benutzt wird
➥ -u: Undeploy und anschließendes Deploy
➥ -o: offline-Modus (wenn OpenEJB-Container nicht läuft)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
246
5.4.5 Einschub: OpenEJB ...
Übersetzung / Deployment des Servers ...
➥ Was passiert beim Deployment?
➥ JAR-Datei mit Bean wird in apps-Verzeichnis von OpenEJB
kopiert (damit Container sie findet)
➥ Business-Interface der Bean wird beim Namensdienst
registriert
➥ genauer: Objekt einer Klasse, die Interface implementiert
➥ Stub- und Implementierungsklassen werden dynamisch zur
Laufzeit erzeugt
➥ Undeployment
➥ openejb undeploy -s ejbd://localhost:4201
$OPENEJB_HOME/apps/myHelloEjb.jar
➥ bzw. falls Container nicht läuft:
rm $OPENEJB_HOME/apps/myHelloEjb.jar
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
247
5.4.5 Einschub: OpenEJB ...
Übersetzung / Start des Clients
➥ Vorbereitung
➥ Java-Datei für Business-Interface muß beim Client vorhanden
sein!
➥ Übersetzung
➥ javac -cp $OPENEJB_HOME/lib/javaee-api-5.0-2.jar:.
HelloClient.java
➥ Start
➥ java -cp $OPENEJB_HOME/lib/javaee-api-5.0-2.jar:
$OPENEJB_HOME/lib/openejb-client-3.1.1.jar:.
HelloClient
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
248
5.4.5 Einschub: OpenEJB ...
Ablauf des Programms
Client
Container−
System
Name
Service
EJB−
Objekt
Container
Class.newInstance()
bind()
lookup()
sayHello()
Class.newInstance()
Bean−
Instanz
sayHello()
sayHello()
Roland Wismüller
Betriebssysteme / verteilte Systeme
sayHello()
Client/Server-Programmierung (8/12)
249
Anmerkungen zu Folie 249:
➥ Der Begriff EJB-Objekt stammt eigentlich von EJB 2, er wird aber auch noch für
die Wrapper -Objekte (d.h. die Objekte der Wrapper-Klasse, die der Container zur
Laufzeit für eine Session-Bean erzeugt) von EJB 3 verwendet, z.B. im Buch von
Burke und Monson-Haefel.
➥ Der gezeigte Ablauf ist zum Teil spekulativ, da die interne Vorgehensweise des
Containers vom EJB-Standard nicht festgelgt und nach außen teilweise auch nicht
beobachtbar ist. Das betrifft vor allem die Details der Erzeugung und Registrierung des EJB-Objekts.
OpenEJB erzeugt bei einer stateless Session Bean die erste Bean-Instanz aber
tatsächlich erst beim ersten Aufruf einer Methode.
5.4.5 Einschub: OpenEJB ...
Weitere Informationen
➥ OpenEJB Home Page
➥ http://openejb.apache.org/
➥ Dokumentation zu OpenEJB
➥ http://openejb.apache.org/3.0/
➥ Dokumentation zu OpenJPA
➥ http://openjpa.apache.org/builds/1.1.0/
apache-openjpa-1.1.0/docs/manual/
➥ OpenJPA ist der Standard Persistence Provider von OpenEJB
➥ für Entities
➥ EJB 3.0 Spezifikationen
➥ http://jcp.org/aboutJava/communityprocess/final/
jsr220/
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
250
5.4 Enterprise Java Beans (EJB 3.0) ...
5.4.6 Dienste des EJB-Containers
➥ Ressourcen-Management
➥ Pooling: Container hält einen Pool von Bean-Instanzen vor
➥
z.B. bei stateless Session Beans: Aufrufe gehen an
beliebige Instanz im Pool
➥ Ziel u.a.: vermeide teuren Auf- und Abbau von DatenbankVerbindungen
➥ Passivierung und Aktivierung von stateful Session Beans
➥
Container kann Session Beans temporär passivieren
➥ z.B. wenn zuviele Bean-Instanzen vorhanden sind
➥ bei Passivierung wird Zustand der Bean auf Festplatte
gesichert und Bean-Instanz gelöscht
➥ bei nächster Client-Anfrage: neue Bean-Instanz wird
erzeugt und initialisiert
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
251
5.4.6 Dienste des EJB-Containers ...
➥ Namensdienst: Zugriff über JNDI-Schnittstelle
➥ Nebenläufigkeit
➥ Session Beans: immer nur von einem Client genutzt
➥ Entities: optimistisches Locking
➥
setzt Versions-Attribut in der Entity voraus
➥ Alternative: explizite Read und Write-Locks
➥ Persistenz (☞ 5.4.9)
➥ Datenfelder einer Entity werden automatisch mit dem Inhalt
einer Datenbank synchronisiert
➥ Transaktionen (☞ 5.4.10)
➥ Methoden von Session Beans können automatisch als
Transaktionen ausgeführt werden
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
252
5.4.6 Dienste des EJB-Containers ...
➥ Sicherheit
➥ Authentifizierung
➥
Vorgehen abhängig von EJB-Container-Implementierung
➥ oft: Benutzername / Paßwort als Properties über JNDI
übergeben
➥ Autorisierung
➥
Festlegung, wer welche Methoden aufrufen darf
➥ über Deployment-Deskriptor (☞ 5.4.7) oder
Annotationen
➥ rollenbasierte Zugriffskontrolle
➥ sichere Kommunikation
➥
abhängig von EJB-Container-Implementierung
➥ meist: Nutzung von TLS/SSL
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
253
5.4 Enterprise Java Beans (EJB 3.0) ...
5.4.7 Der Deployment-Deskriptor ejb-jar.xml
➥ Beschreibt
➥ aus welchen Klassen die EJB besteht
➥ wie die EJB zur Laufzeit verwaltet werden soll, z.B.:
➥ Art der EJB
➥ Transaktionsmanagement
➥ Zugriffskontrolle
➥ Ab EJB 1.1 ist der Deployment-Deskriptor in XML codiert
➥ wird als META-INF/ejb-jar.xml in JAR-Datei der EJB
abgelegt
➥ wird beim Deployment vom Container gelesen
➥ Ab EJB 3.0 kann Deployment-Deskriptor auch leer sein
➥ Metadaten auch als Annotationen im Java-Code möglich
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
254
5.4.7 Der Deployment-Deskriptor ejb-jar.xml ...
Aufbau des Deployment-Deskriptors
➥ Prinzipieller Aufbau:
<?xml version="1.0" encoding="UTF-8"?>
<ejb-jar>
<enterprise-beans>
...
</enterprise-beans>
<assembly-descriptor>
...
</assembly-descriptor>
</ejb-jar>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
255
5.4.7 Der Deployment-Deskriptor ejb-jar.xml ...
Elemente innerhalb von <ejb-jar>
➥ <enterprise-beans>
➥ Beschreibung der einzelnen EJBs innerhalb der JAR-Datei
➥ ab EJB 3.0 besser durch Annotationen
➥ <assembly-descriptor>
➥ Konfiguration der zusammengestellten Beans für eine
Anwendung
➥ z.B. Transaktionsverhalten, Zugriffskontrolle
➥ <description>
➥ Beschreibung der Beans-Sammlung in der JAR-Datei
➥ und noch einige weitere ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
256
5.4.7 Der Deployment-Deskriptor ejb-jar.xml ...
Elemente innerhalb von <assembly-descriptor>
➥ <container-transaction>
➥ Transaktions-Attribute für einzelne Methoden (☞ 5.4.10)
➥ ab EJB 3.0 auch besser durch Annotationen
➥ <security-role>
➥ Definiert Rollennamen für rollenbasierte Zugriffskontrolle
➥ Unterelemente: <description> und <role-name>
➥ <method-permission>
➥ legt fest, welche Rollen welche Methoden aufrufen dürfen
➥ Unterelemente: <description>, <role-name>, <method>
➥ statt <role-name> auch Element <unchecked> möglich: keine
Zugriffskontrolle
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
257
5.4.7 Der Deployment-Deskriptor ejb-jar.xml ...
Zur Zugriffskontrolle bei EJBs
➥ Deployment-Deskriptor (bzw. Annotationen) legt nur Abbildung
zwischen Rollennamen und aufrufbaren Methoden fest
➥ Verwaltung von Benutzern und Paßworten sowie Abbildung von
Benutzern auf Rollen muß durch EJB-Container erfolgen
➥ abhängig von jeweiliger Implementierung
➥ in OpenEJB 3.1:
➥
conf/users.properties: Benutzer und Paßwort
➥ z.B.: roland=myPassWd
➥ conf/groups.properties: Zuordnung Benutzer zu Rollen
➥ z.B.: Admin=roland
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
258
5.4.7 Der Deployment-Deskriptor ejb-jar.xml ...
Beispiel
➥ Session Bean zur Vorlesungsverwaltung
➥ jeder darf die Daten lesen, nur Administrator darf ändern
➥ Deployment-Deskriptor:
<ejb-jar>
<assembly-descriptor>
<security-role>
<description>Rolle fuer Administratoren</description>
<role-name>Admin</role-name>
</security-role>
<method-permission>
<role-name>Admin</role-name>
<method>
<ejb-name>VorlesungEJB</ejb-name>
<method-name>*</method-name>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
259
5.4.7 Der Deployment-Deskriptor ejb-jar.xml ...
</method>
</method-permission>
<method-permission>
<unchecked/>
<method>
<ejb-name>VorlesungEJB</ejb-name>
<method-name>getInfos</method-name>
</method>
</method-permission>
</assembly-descriptor>
</ejb-jar>
➥ Anmerkungen:
➥ der Deployment-Deskriptor wird i.d.R. über ein Konfigurations-
werkzeug erstellt
➥ Rollen und Zugriffsrechte können auch über Annotationen
festgelegt werden
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (8/12)
260
Client/Server-Programmierung
WS 2013/2014
13.12.2013
Roland Wismüller
Betriebssysteme / verteilte Systeme
.d
[email protected] e
rolanda
Tel.: 0271/740-4050, Büro: H-B 8404
Stand: 23. April 2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
i
5.4 Enterprise Java Beans (EJB 3.0) ...
5.4.8 Session Beans: Details
Stateless Session Beans
➥ Container verwaltet Pool
identischer Bean-Instanzen
➥ Erzeugung / Löschung
nur durch Container
➥ Aufrufe von Anwendungsmethoden werden an
beliebige Bean-Instanz im
Pool geleitet
➥ keine Passivierung /
Aktivierung
Roland Wismüller
Betriebssysteme / verteilte Systeme
Stateful Session Beans
➥ Erzeugung / Löschung (indirekt)
auf Veranlassung des Clients
➥ Bean-Instanzen werden ClientSitzungen (und damit EJBObjekten) fest zugeordnet
➥ Aufrufe eines Clients gehen
an dieselbe Bean-Instanz
➥ bei Bedarf: Passivierung /
Aktivierung durch Container
Client/Server-Programmierung (9/12)
261
5.4.8 Session Beans: Details ...
Annotationen für Schnittstellen und Bean-Implementierungen
➥ @Local und @Remote (aus javax.ejb)
➥ markieren ein Java-Interface als lokale bzw. remote
Schnittstelle einer EJB
➥ lokale Schnittstelle kann nur innerhalb des Containers (von
anderen EJBs) genutzt werden
➥ Zuordnung zur Bean-Klasse über implements-Beziehung
➥ @Stateless und @Stateful (aus javax.ejb)
➥ markieren eine Java-Klasse als entsprechende Session Bean
➥ @Remove (aus javax.ejb)
➥ markiert eine Methode in einer (stateful) Session Bean-
Klasse, nach deren Ausführung die Bean-Instanz gelöscht
werden soll
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
262
5.4.8 Session Beans: Details ...
Beispiel
➥ RemIf.java:
➥
@Remote
public interface RemIf {
public String sayHello();
public void bye();
}
LocIf.java:
@Local
public interface LocIf {
public String sayHello();
public void doIt();
}
➥ MyBean.java:
@Stateful
public class MyBean implements LocIf, RemIf {
public String sayHello() { ... }
@Remove public void bye() { ... }
public void doit() { ... }
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
263
5.4.8 Session Beans: Details ...
Lebenszyklus-Callbacks
➥ @PostConstruct bzw. @PreDestroy (aus javax.annotation)
➥ markiert Methode in einer Bean-Klasse, die nach Erzeugung
bzw. vor Löschung einer Bean-Instanz aufgerufen werden soll
➥ aber: keine Garantie, daß Bean-Instanz jemals gelöscht wird
➥ @PrePassivate bzw. @PostActivate (aus javax.ejb)
➥ markiert Methode, die vor Passivierung bzw. nach Aktivierung
einer Bean-Instanz aufgerufen werden soll
➥ Alle Callback-Methoden sollten wie folgt deklariert werden:
➥ public void name () { ... }
➥ Auch möglich: Definition einer eigenen Klasse für die Callbacks
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
264
5.4.8 Session Beans: Details ...
Interceptor-Methoden
➥ @AroundInvoke (aus javax.interceptor)
➥ markiert Methode, die alle Methodenaufrufe einer Bean
abfängt
➥ Deklaration der Methode:
➥
public Object name (InvocationContext c)
throws Exception { ... }
➥ InvocationContext erlaubt u.a.:
➥
Abfrage von Zielobjekt, Methodenname und Parameter
➥ Ausführung des abgefangenen Methodenaufrufs
➥ Einsatz z.B. Protokollierung, Zugriffskontrolle, ...
➥ Auch möglich: Definition einer eigenen Klasse für den Interceptor
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
265
5.4.8 Session Beans: Details ...
Dependency Injection
➥ Aufgabe: Beschaffung von Referenzen auf Ressourcen, die der
Container bereitstellt
➥ Lösung: passendes Attribut wird mit einer Annotation versehen
➥ Attribut wird dann automatisch vom Container initialisiert
➥ @Resource (aus javax.annotation)
➥ für beliebige Resourcen des Containers
➥ z.B. SessionContext: erlaubt Zugriff auf Benutzer-Name,
aktuelle Transaktion, ...
➥ @EJB (aus javax.ejb)
➥ speziell, um Referenzen auf EJBs zu holen
➥ (Alternative: explizite Nutzung von JNDI)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
266
5.4.8 Session Beans: Details ...
Beispiel
➥ MyBeanLocal.java:
@Local public interface MyBeanLocal {
public String getName();
}
➥ MyBean.java:
@Stateful
public class MyBean implements MyBeanLocal {
// Attribut wird vom Container initialisiert!
@Resource private SessionContext context;
public String getName() {
return context.getCallerPrincipal().getName();
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
267
5.4.8 Session Beans: Details ...
Beispiel ...
➥ HelloRemote.java:
@Remote public interface HelloRemote {
public String sayHello();
public String sayGoodBye();
}
➥ HelloImpl.java:
@Stateful
public class HelloImpl implements HelloRemote {
// Referenz auf MyBean wird vom Container eingetragen!
@EJB private MyBeanLocal myBean;
public String sayHello() {
return "Hallo " + myBean.getName();
}
@Remove public String sayGoodBye() { ... }
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
268
5.4.8 Session Beans: Details ...
Beispiel ...
➥ HelloImpl.java ...:
@PostConstruct public void start() {
System.out.println("@PostConstruct HelloImpl");
}
@PreDestroy public void stop() {
System.out.println("@PreDestroy HelloImpl");
}
@AroundInvoke
public Object inv(InvocationContext c)
throws Exception {
System.out.println("HelloImpl: Calling "
+ c.getMethod().getName());
return c.proceed();
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
269
5.4.8 Session Beans: Details ...
Lebenszyklus einer Stateless Session Bean
Container entscheidet,
daß mehr Bean−Instanzen
im Pool benötigt werden,
um Clients zu bedienen
Beliebiger Client
ruft Anwendungs−
methode auf. Abar−
beitung in beliebiger
EBJ.
Bean−Instanz
existiert nicht
1. Class.newInstance()
2. Injections
3. @PostConstruct
Anwendungs−
methode
Roland Wismüller
Betriebssysteme / verteilte Systeme
Container entscheidet,
daß nicht mehr so
viele Bean−Instanzen
benötigt werden
@PreDestroy
Pool äquivalenter
Instanzen, bereit
für Methodenaufrufe
Client/Server-Programmierung (9/12)
270
5.4.8 Session Beans: Details ...
Typische Abläufe bei Stateless Session Beans
Client
EJB−
Objekt
Container− Container
System
Class.newInstance() Bean−
Instanz
Injections
Hinzufügen einer
neuen Instanz
zum Pool
@PostConstruct
Methodenaufrufe
durch Client
businessMethod()
businessMethod()
Löschen
einer Instanz
aus dem Pool
@PreDestroy
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
271
5.4.8 Session Beans: Details ...
Lebenszyklus einer Stateful Session Bean
Client holt/nutzt
Referenz auf ein
Interface der
Session Bean
Client ruft Methode
auf, die mit @Remove
annotiert ist
oder: Timeout
Bean−Instanz
existiert nicht
1. Class.newInstance()
@PreDestroy
2. Injections
3. @PostConstruct
Anwendungs−
methode
Client ruft
Anwendungs−
methode der
Session Bean
Bereit
Timeout
@PrePassivate
Passiv
@PostActivate
Limit instantiierter
Beans ist erreicht.
Container muß
Bean auslagern
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client ruft Methode
der passivierten
Bean. Container muß
Bean wieder einlagern
Client/Server-Programmierung (9/12)
272
5.4.8 Session Beans: Details ...
Erzeugung/Löschung einer Stateful Session Bean
Client
Name Service
Container−
System
Container
lookup()
EJB−
Class.
newInstance() Objekt Class.newInstance() Bean−
Instanz
Injections
Erzeugung
@PostConstruct
EJB−Objekt
businessMethod()
businessMethod()
@Remove businessMethod2()
businessMethod2()
@ PreDestroy
Löschung
Roland Wismüller
Betriebssysteme / verteilte Systeme
273
Client/Server-Programmierung (9/12)
5.4.8 Session Beans: Details ...
Passivierung/Aktivierung einer Stateful Session Bean
Client
EJB−Objekt
Container
Container −
System
Passivierung
businessMethod()
Aktivierung
Roland Wismüller
Betriebssysteme / verteilte Systeme
Bean−Inst.
Festplatte
@PrePassivate
serialisiere Bean−Instanz
speichere Zustand ab
Class.newInstance()
Bean−Inst.
Lies Zustand ein
deserialisiere Bean−Instanz
@PostActivate
businessMethod()
Client/Server-Programmierung (9/12)
274
5.4 Enterprise Java Beans (EJB 3.0) ...
5.4.9 Entities: Details
➥ Entities realisieren persistente Datenobjekte einer Anwendung
➥ Basis: Java Persistence API (JPA)
➥ unabhängig von EJB und Java EE nutzbar
➥ Eigenschaften (Abgrenzung zu Session Beans):
➥ für den Client sichtbare, persistente Identität (Primärschlüssel)
➥
unabhängig von Objektreferenz
➥ persistenter, für Client sichtbarer Zustand
➥ nicht entfernt zugreifbar
➥ Lebensdauer völlig unabhängig von der der Anwendung
➥ Persistenz der Entities wird automatisch durch Persistence
Provider gesichert
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
275
5.4.9 Entities: Details ...
Beispiel
➥ Entity Account.java:
import javax.persistence.*;
@Entity // Markiert Klasse als Entity
public class Account implements java.io.Serializable {
@Id // Markiert Attribut als Primärschlüssel
private int accountNo;
private String name;
public int getAccountNo() { return accountNo; }
public String getName() { return name; }
public void setName(String nm) { name = nm; }
public Account(int no, String nm) {
accountNo = no; name = nm;
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
276
5.4.9 Entities: Details ...
Beispiel ...
➥ Deployment-Deskriptor META-INF/persistence.xml:
<persistence
xmlns="http://java.sun.com/xml/ns/persistence"
version="1.0">
<persistence-unit name="intro">
<jta-data-source>My DataSource</jta-data-source>
<non-jta-data-source>My Unmanaged DataSource
</non-jta-data-source>
<class>org.Hello.Account</class>
<properties>
<property name="openjpa.jdbc.SynchronizeMappings"
value="buildSchema(ForeignKeys=true)"/>
</properties>
</persistence-unit>
</persistence>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
277
Anmerkungen zu Folie 277:
Die Property openjpa.jdbc.SynchronizeMappings legt fest, daß OpenJPA das DatenbankSchema zur Laufzeit an das in den Entities vorgegebene Mapping anpassen soll.
Siehe http://openjpa.apache.org/builds/1.1.0/apache-openjpa-1.1.0/
docs/manual/ref guide mapping.html
5.4.9 Entities: Details ...
Beispiel ...
➥ OpenEJB Konfigurationsdatei conf/openejb.xml:
<Resource id="My DataSource" type="DataSource">
JdbcDriver org.hsqldb.jdbcDriver
JdbcUrl jdbc:hsqldb:file:data/hsqldb/hsqldb
UserName sa
Password
JtaManaged true
</Resource>
<Resource id="My Unmanaged DataSource" type="DataSource">
JdbcDriver org.hsqldb.jdbcDriver
JdbcUrl jdbc:hsqldb:file:data/hsqldb/hsqldb
UserName sa
Password
JtaManaged false
</Resource>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
278
5.4.9 Entities: Details ...
Anmerkungen zum Beispiel
➥ Eine Entity -Klasse muss Serializable nicht implementieren
➥ falls Sie es tut, können Objekte auch als Parameter / Ergebnis
von Remote-Methoden einer Session Bean auftreten
➥ übergeben wird dabei eine Kopie, die nicht mit der
Datenbank synchronisiert wird
➥ Abbildung von Klasse auf Datenbank-Tabelle und von Attributen
auf Spalten wird vom Persistence Provider vorgenommen
➥ kann durch Annotationen genau gesteuert werden
➥ Entity -Klasse muß ein Primärschlüssel-Attribut deklarieren (@Id)
➥ Primärschlüssel kann auch eigene Klasse sein
➥ Entity -Klasse darf auch Geschäftsmethoden besitzen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
279
5.4.9 Entities: Details ...
Anmerkungen zum Beispiel ...
➥ Beispiel verwendet Field Access
➥ Persistence Provider greift direkt auf die Attribute zu
➥ Mapping-Annotationen (hier: @Id) bei den Attributen
➥ Alternative: Property Access
➥ Persistence Provider greift auf den Zustand nur über get- und
set-Methoden zu
➥ Mapping-Annotationen bei den get-Methoden
➥ Achtung: es müssen immer get- und set-Methoden
implementiert werden
➥ Pro Entity ist nur eine der Alternativen erlaubt
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
280
5.4.9 Entities: Details ...
Anmerkungen zum Beispiel ...
➥ Deployment-Deskriptor legt fest:
➥ Name der Persistence Unit (zum Zugriff durch Session Bean)
➥
Persistence Unit: Einheit für Kapselung und Deployment
von Entities
➥ Namen der Datenquellen mit bzw. ohne Support für Java
Transaction API (JTA, ☞ 5.4.10)
➥ Properties für den Persistence Provider
➥
hier: OpenJPA passt Datenbank-Schema zur Laufzeit an
➥ OpenEJB-Konfiguration legt fest:
➥ JDBC Treiber und URL der Datenbank (☞ 2)
➥ Login-Name und Passwort
➥ Unterstützung für JTA
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
281
5.4.9 Entities: Details ...
Beispiel zur Nutzung der Entity in einer Session Bean
➥ Remote-Schnittstelle BankRemote.java:
import javax.ejb.Remote;
@Remote
public interface BankRemote
{
public Account create(int n, String name);
public String getName(int n);
public void close(int n);
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
282
5.4.9 Entities: Details ...
Beispiel zur Nutzung der Entity in einer Session Bean ...
➥ Bean-Implementierung BankImpl.java:
import javax.ejb.*;
import javax.persistence.*;
@Stateless
public class BankImpl implements BankRemote {
// Dependency Injection: Entity Manager für Persistenz−Einheit ’intro’
@PersistenceContext(unitName="intro")
private EntityManager manager;
public Account create(int n, String name) {
Account acc = new Account(n, name);
// Objekt ab jetzt durch Persistence Provider verwalten
manager.persist(acc);
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
283
5.4.9 Entities: Details ...
Beispiel zur Nutzung der Entity in einer Session Bean ...
➥ Bean-Implementierung BankImpl.java:
// Rückgabewert ist eine losgelöste Kopie des Objekts!
return acc;
}
public String getName(int n) {
// Findet Objekt mit gegebenem Primärschlüssel
Account acc = manager.find(Account.class, n);
return acc.getName();
}
public void close(int n) {
Account acc = manager.find(Account.class, n);
// Datenbank−Eintrag löschen
manager.remove(acc);
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
284
5.4.9 Entities: Details ...
Beispiel zur Nutzung der Entity in einer Session Bean ...
➥ Client BankClient.java:
...
Object obj = ctx.lookup("BankImplRemote");
BankRemote bank = (BankRemote)obj;
// Erzeugt neue Entity (und Datenbankeintrag)
Account acc = bank.create(n, args[1]);
// acc ist eine Kopie des Eintrags, lokale Methodenaufrufe
System.out.println(acc.getName());
acc.setName("Niemand");
// Remote−Aufrufe der Entity Bean
System.out.println(bank.getName(n));
bank.close(n);
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
285
5.4.9 Entities: Details ...
Persistence Context
➥ Verbindung zwischen Instanzen im Speicher und der Datenbank
➥ Methoden der Schnittstelle EntityManager u.a.:
➥ void persist(Object entity)
➥ Instanz verwalten und persistent machen
➥ <T> T find(Class<T> entityClass, Object primaryKey)
➥ Instanz zu gegebenem Primärschlüssel suchen
➥ void remove(Object entity)
➥ Instanz aus der Datenbank löschen
➥ void refresh(Object entity)
➥ Instanz aus Datenbank neu laden
➥ <T> T merge(T entity)
➥ Zustand der Instanz in Persistence Context hineinmischen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
286
5.4.9 Entities: Details ...
Lebenszyklus einer Entity
new
refresh()
new
persist()
remove()
managed
removed
Persistence
Context
endet
merge()
persist()
detached
Instanz wird mit Daten−
bank konsistent gehalten
Roland Wismüller
Betriebssysteme / verteilte Systeme
Instanz hat Datenbank−Eintrag,
ist aber nicht mit Persistence
Context verbunden (z.B.
Kopie einer managed Entity)
Client/Server-Programmierung (9/12)
287
5.4.9 Entities: Details ...
Lebenszyklus einer Entity ...
➥ Persistence Context endet per Voreinstellung mit dem Ende der
aktuellen Transaktion
➥ Einstellung über Attribut type von @PersistenceContext
➥ Synchronisation mit Datenbank i.a. am Ende jeder Transaktion
➥ einstellbar über setFlushMode() Methode von EntityManager
➥ ggf. auch explizite Synchronisation durch Methode flush()
➥ JPA verwendet standardmäßig ein optimistisches Sperrprotokoll
➥ Datensätze werden nicht gesperrt
➥ bei gleichzeitigen Änderungen durch zwei Transaktionen wird
eine davon zurückgesetzt
➥ dazu notwendig: Versionsattribut (Annotation @Version)
➥ Lebenszyklus-Callbacks analog zu Session Beans möglich
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
288
Anmerkungen zu Folie 288:
Wenn der Persistence Context endet, bedeutet das, daß alle Entities in den detachedZustand gehen, also nicht mehr mit der Datenbank synchronisiert werden. Für die
Programmierung heißt das, daß zu Beginn jeder Transaktion (d.h. i.a. zu Beginn jeder
Methode der Session Bean), die Entities per find-Methode neu aus der Datenbank
geholt werden müssen.
Um das zu vermeiden, kann man eine stateful Session Bean verwenden, die den Persistence Context mit dem zusätzlichen Attribut
type=PersistenceContextType.EXTENDED
in der Annotation definiert.
5.4.9 Entities: Details ...
Finden von Entities
➥ EntityManager erlaubt das Finden von Datensätzen über
Queries SQL und EJB-QL
➥ EJB-QL ist SQL-ähnlich, aber portabel
➥ Beispiel:
Query query
= manager.createQuery("SELECT a FROM Account a");
List<Account> = query.getResultList();
➥ Queries können auch mit Namen vordefiniert werden
➥ über Annotation @NamedQuery der Entity
➥ als named-query Element im Deskriptor META-INF/orm.xml
➥ Nutzung: query = manager.createNamedQuery("myQuery");
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
289
5.4.9 Entities: Details ...
Abbildung zwischen Objekten und Relationen (OR-Mapping)
➥ Default-Verhalten:
➥ jede Entity bekommt eine Tabelle
➥ jedes Attribut bekommt eine Tabellen-Spalte
➥ Namen werden in Großbuchstaben umgewandelt
➥ Verhalten anpaßbar über Annotationen (bzw. XML-Deskriptor), z.B.:
➥ @Table(name="..."): Tabellenname für Entity
➥ @Column(name="..."): Spaltenname für Attribut
➥ @Transient: Attribut wird nicht persistent gemacht
➥ Auch Abbildung von Assoziationen zwischen Klassen durch
entsprechende Annotationen möglich
➥ u.a. @OneToMany, @ManyToOne, @JoinColumn, siehe Beispiel
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (9/12)
290
Client/Server-Programmierung
WS 2013/2014
20.12.2013
Roland Wismüller
Betriebssysteme / verteilte Systeme
.d
[email protected] e
rolanda
Tel.: 0271/740-4050, Büro: H-B 8404
Stand: 23. April 2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (10/12)
i
5.4.9 Entities: Details ...
Beispiel zum OR-Mapping
➥ Datenbank-Tabellen für Konto und Zahlungen:
KONTO
KONTO_NR: INTEGER NAME: VARCHAR(255)
BUCHUNG
ID: INTEGER BETRAG: NUMERIC DATUM: TIMESTAMP KONTO: INTEGER
➥ Klassendiagramm für die Entities:
Payment
Account
accountNo: int
name: String
Roland Wismüller
Betriebssysteme / verteilte Systeme
payments
1
id: int
date: Date
* amount: double
Client/Server-Programmierung (10/12)
291
5.4.9 Entities: Details ...
Beispiel zum OR-Mapping ...
➥ Entity -Klasse Account.java
@Entity
@Table(name="KONTO")
public class Account {
@Id
@Column(name="KONTO_NR")
private int accountNo;
private String name;
@OneToMany(fetch=FetchType.LAZY, mappedBy="account")
private Set<Payment> payments;
public int getAccountNo() { return accountNo; }
public Set<Payment> getPayments() { return payments; }
public void addPayment(Payment p) { payments.add(p); }
...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (10/12)
292
5.4.9 Entities: Details ...
Beispiel zum OR-Mapping ...
➥ Entity -Klasse Payment.java
@Entity
@Table(name="BUCHUNG")
public class Payment {
@Id
private int id;
@ManyToOne
@JoinColumn(name="KONTO", nullable=false)
private Account account;
@Column(name="DATUM")
private Date date;
@Column(name="BETRAG")
private double amount;
...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (10/12)
293
5.4.9 Entities: Details ...
Anmerkungen zum Beispiel
➥ Bedeutung des Parameters type bei @OneToMany:
➥ EAGER: Payments werden beim Laden eines Account-Objekts
sofort mitgeladen
➥ LAZY: Payments werden erst beim Zugriff geladen
➥ Zugriff muß über get-Methode (getPayments()) erfolgen!
➥ mappedBy-Parameter von @OneToMany realisiert eine bidirektionale
Assoziation
➥ @JoinColumn definiert, welche Spalte der Tabelle BUCHUNG den
Primärschlüssel des zugehörigen Eintrags in KONTO enthält
➥ nullable gibt an, ob der Spalteneintrag leer sein darf
➥ Deskriptor META-INF/persistence.xml muss <class>-Tags für
beide Entities enthalten
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (10/12)
294
5.4 Enterprise Java Beans (EJB 3.0) ...
5.4.10 Transaktionen
➥ EJB-Container bieten Unterstützung für flache (evtl. verteilte)
Transaktionen
➥ EJB-Container kann
➥ automatisch Transaktionen um Client-Anfragen generieren
➥ vom Client oder einer EJB explizit definierte Transaktions-
Grenzen erkennen und an EJBs weitergeben
➥ EJB-Container regelt Weitergabe von Transaktionen bei
Methodenaufrufen
➥ z.B. wenn innerhalb einer Transaktion eine Methode gerufen
wird, die neue Transaktion definiert
➥ verschachtelte Transaktionen sind nicht erlaubt
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (10/12)
295
5.4.10 Transaktionen ...
Arten des Transaktions-Managements
➥ Festlegung durch Annotation der Session Bean
➥ @TransactionManagement (aus javax.ejb)
➥ Argument: TransactionManagementType.BEAN bzw.
CONTAINER
➥ Bean Managed Transactions
➥ Session Bean legt Transaktionsgrenzen selbst fest
➥ Container Managed Transactions
➥ Container legt Grenzen und Weitergabe von Transaktionen fest
➥ Verhalten durch Annotation der Methoden spezifiziert
➥ @TransactionAttribute (aus javax.ejb)
➥ Client Initiated Transactions
➥ Transaktionsgrenzen werden vom Client bestimmt
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (10/12)
296
5.4.10 Transaktionen ...
Bean Managed und Client Initiated Transactions mit JTA
➥ Verwendung des Java Transaction API (JTA)
➥ Klasse javax.transaction.UserTransaction
➥ Methoden begin(), commit(), rollback()
➥ Erzeugung eines UserTransaction-Objekts
➥ Im Client (oder einer Session Bean): über JNDI
➥
ut = (UserTransaction)ctx.lookup(
"java:comp/env/UserTransaction");
➥ In einer Session Bean:
➥
über SessionContext: Methode getUserTransaction()
➥ oder direkt über Dependency Injection:
➥ @Resource private UserTransaction ut;
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (10/12)
297
5.4.10 Transaktionen ...
Container Managed Transactions: Beispiel Ticket-Buchung
import javax.ejb.*;
@Stateless
@TransactionManagement(TransactionManagementType.CONTAINER)
public class TravelAgentBean implements TravelAgentRemote {
...
@TransactionAttribute(TransactionAttributeType.REQUIRED)
public Ticket bookPassage(CreditCard card, double price) {
try {
Reservation res = new Reservation(customer, cruise, price);
entityManager.persist(res);
pay.byCredit(customer, card, price);
return new Ticket(customer, cruise, price);
}
catch (Exception e) { throw new EJBException(e); }
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (10/12)
298
5.4.10 Transaktionen ...
Transaktionsverhalten des Beispiels
➥ Abarbeitung von bookPassage() soll immer innerhalb einer
Transaktion erfolgen
➥ Transaktionsattribut Required
➥ wenn Aufruf nicht in einer Transaktion erfolgt, wird automatisch
neue Transaktion erzeugt
➥ Transaktion wird an die Methoden der genutzten EJBs weitergegeben
➥ gemäß Transaktionsattribut der gerufenen Methode
➥ Falls bookPassage() eine System-Exception wirft: Rollback,
sonst: Commit am Ende der Methode
➥ alle Unterklassen von RuntimeException sind System-
Exceptions, insbes. EJBException
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (10/12)
299
5.4.10 Transaktionen ...
Container Managed Transactions: Transaktionsattribute
➥ NOT_SUPPORTED
➥ Methode unterstützt keine Transaktionen
➥ ggf. bereits existierende Transaktion wird bei Aufruf
suspendiert
➥ SUPPORTS
➥ Methode unterstützt Transaktionen, erzeugt aber keine eigene
Transaktion
➥ ggf. bei Aufruf existierende Transaktion wird übernommen
➥ REQUIRED
➥ Methode muß innerhalb einer Transaktion ausgeführt werden
➥ ggf. wird beim Aufruf eine neue Transaktion erzeugt
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (10/12)
300
5.4.10 Transaktionen ...
Container Managed Transactions: Transaktionsattribute ...
➥ REQUIRES_NEW
➥ beim Methodenaufruf wird immer eine neue Transaktion
erzeugt
➥ ggf. bereits existierende Transaktion wird suspendiert
➥ MANDATORY
➥ Methode muß innerhalb einer Transaktion ausgeführt werden
➥ ansonsten wird Exception geworfen
➥ NEVER
➥ Methode darf nicht innerhalb einer Transaktion ausgeführt
werden
➥ ansonsten wird Exception geworfen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (10/12)
301
5.4.10 Transaktionen ...
Container Managed Transactions: Transaktionsattribute ...
Transaktions−
Attribut
Transaktion des
Aufrufers
NOT_SUPPORTED
SUPPORTS
REQUIRED
REQUIRES_NEW
MANDATORY
NEVER
Roland Wismüller
Betriebssysteme / verteilte Systeme
keine
T1
keine
T1
keine
T1
keine
T1
keine
T1
keine
T1
Transaktion der
gerufenen Methode
keine
keine
keine
T1
T2
T1
T2
T2
Exception
T1
keine
Exception
Client/Server-Programmierung (10/12)
302
5.4 Enterprise Java Beans (EJB 3.0) ...
5.4.11 Zusammenfassung
➥ EJBs: Komponentenmodell für Anwendungsserver
➥ Entities für Datenmodell
➥ Persistenz und Transaktionen durch Container verwaltet
➥ Session Beans für Client-Sitzungen
➥ Transaktionen durch Client, Bean oder Container verwaltet
➥ Container realisiert daneben u.a. Ressourcenmanagement,
Namens- und Sicherheitsdienste
➥ Nicht besprochen: Entity Beans, Message Driven Beans, und
vieles andere mehr ...
➥ Web Services kommt später noch
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (10/12)
303
Client/Server-Programmierung
WS 2013/2014
24.01.2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
.d
[email protected] e
rolanda
Tel.: 0271/740-4050, Büro: H-B 8404
Stand: 23. April 2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
i
Client/Server-Programmierung
WS 2013/2014
6
Servlets und JSP
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
304
6 Servlets und JSP ...
Inhalt
➥ Servlets
➥ Java Server Pages (JSP)
➥ Hunter / Crawford
➥ Farley / Crawford / Flanagan, Kap. 5 und 6
➥ Langner (Verteilte Anwendungen mit Java), Kap. 6
➥ Orfali / Harkey, Kap. 12
➥ http://java.sun.com/javaee/5/docs/tutorial/doc/,
Kap. 4-9
➥ http://java.sun.com/products/servlet
➥ http://java.sun.com/products/jsp
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
305
6 Servlets und JSP ...
6.1 Servlets
➥ Java Software-Komponenten zur dynamischen Erweiterung von
Web-Servern
➥ Erzeugung dynamischer HTML-Seiten, z.B. aus
Datenbank-Inhalten
➥ Typische Architektur:
HTTP GET
HTTP−
Server
Servlet−
Container JDBC
Servlet
HTML−Seite
Web−Browser
Datenbank
Servlet
Web−Server
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
306
6.1 Servlets ...
6.1.1 Grundlagen
➥ Servlets sind Java-Klassen, die innerhalb eines Web-Servers
ausgeführt werden
➥ Web-Server muß servlet-fähig sein, d.h. über einen
Servlet-Container verfügen (z.B. Tomcat)
➥ Container lädt Servlets bei Bedarf dynamisch nach
➥ (HTTP-)Servlets werden (u.a.) über die HTTP-Anfragen GET bzw.
POST angesprochen
➥ Servlet bearbeitet die Anfrage und erzeugt eine HTML-Seite
➥ Bearbeitung erfolgt durch eigenen Thread im Adreßraum des
Web-Servers
➥ (Generische Servlets werden hier nicht behandelt)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
307
6.1.1 Grundlagen ...
Die HTTP-Methoden GET und POST
➥ Teil des HTTP-Protokolls: Browser-Anfragen an den Server
➥ Auch verwendet in HTML-Formularen
➥ GET-Methode
➥ zum Holen von Dokumenten über eine URL bestimmt
➥ URL kann auch weitere Parameter beinhalten, z.B.
➥
GET /buy.html?what=shoe&price=50.00 HTTP 1.0
➥ begrenzte Länge der URL!
➥ POST-Methode
➥ zum Senden von Daten an den Web-Server
➥ Parameter werden im Rumpf der HTTP-Anfrage übertragen,
sind in der URL nicht sichtbar
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
308
6.1.1 Grundlagen ...
Implementierung von HTTP-Servlets
➥ Ableiten einer Klasse von javax.servlet.http.HttpServlet
➥ I.d.R. Überschreiben einer der Methoden
➥ void doGet(HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException
➥
Behandlung von HTTP-GET-Anfragen
➥ void doPost(...): analog für HTTP-POST-Anfragen
➥ Bei Bedarf Überschreiben der Methoden
➥ void init() : gerufen, wenn Servlet geladen wird
➥ void destroy() : gerufen, wenn Servlet entfernt wird
➥ Einige weitere Methoden, siehe API-Dokumentation
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
309
6.1 Servlets ...
6.1.2 Einschub: Web-Server im Labor
➥ Im Labor H-A4111 kann/soll jeder Student einen eigenen
Web-Server verwenden
➥ tomcat-Server (für Servlets, Web-Services, ...)
➥ Private Installation (i.w. Konfigurationsdateien):
➥ Aufruf des Skripts
/opt/dist/tools/tomcat_install.sh
auf einem Rechner im Labor H-A 4111
➥ konfiguriert für jeden Benutzer eigene Ports
➥ Umgebungsvariablen setzen (in $HOME/.profile):
export CATALINA_BASE=$HOME/Soft/apache-tomcat-6.0.18
export CATALINA_HOME=/opt/dist/apache-tomcat-6.0.18
export PATH=$CATALINA_HOME/bin:$PATH
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
310
6.1.2 Einschub: Web-Server im Labor ...
Nutzung von Tomcat
➥ Start des tomcat-Servers mit catalina.sh run
➥ benutzte Port-Nummer wird beim Start ausgegeben:
INFO: Initializing Coyote HTTP/1.1 on http-8080
➥ Web-Seiten können unter $CATALINA_BASE/webapps/ROOT
angelegt werden
➥ Erreichbar dann unter der URL
http://rechnername:port/dateiname
➥ Im Labor H-A 4111 muß wegen des voreingestellten Web-
Proxies immer der vollständige Rechnername (FQDN)
angegeben werden
➥ z.B. bsclk01.lab.bvs
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
311
6.1 Servlets ...
6.1.3 Beispiel: Hello-World Servlet
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloSrv extends HttpServlet {
private int counter = 0;
// Wird bei HTTP−Get−Anfrage aufgerufen
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
counter++;
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
312
6.1.3 Beispiel: Hello-World Servlet ...
// Extrahiert Parameter ’name’ aus URL
String name = request.getParameter("name");
response.setContentType("text/html");
// Ausgabestrom für die erzeugte HTML−Seite
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<head><title>Hallo World</title></head>");
out.println("<body><b>" + counter + ". Hello to " + name +
"!</b></body>");
out.println("</html>");
out.close();
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
313
6.1.3 Beispiel: Hello-World Servlet ...
HTML-Seite zum Aufruf des Servlets
<HTML>
<HEAD><TITLE>Hello-World</TITLE></HEAD>
<BODY>
<P>
<A HREF="http://localhost:8080/test/hello?name=Roland">
Say Hello to Roland</A>
</P>
<P> Say Hello to:
<FORM METHOD="GET"
ACTION="http://localhost:8080/test/hello">
<INPUT TYPE="text" NAME="name" SIZE="10">
<INPUT TYPE="submit" VALUE="Submit">
</FORM>
</P>
</BODY>
</HTML>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
314
6.1.3 Beispiel: Hello-World Servlet ...
Deployment mit Tomcat-Server
➥ Übersetzen des Servlets
➥ javac -cp $CATALINA_HOME/lib/servlet-api.jar:.
HelloSrv.java
➥ CLASSPATH nur notwendig, wenn J2EE nicht installiert ist
➥ Erstellen eines Deployment-Deskriptors unter WEB-INF/web.xml
➥ Kopieren der class-Datei(en) nach WEB-INF/classes
➥ cp HelloSrv.class WEB-INF/classes
➥ Erzeugen eines WAR Archivs
➥ jar -cvf test.war WEB-INF
➥ Kopieren des WAR Archivs in das Tomcat-Verzeichnis
➥ cp test.war $CATALINA_BASE/webapps
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
315
6.1.3 Beispiel: Hello-World Servlet ...
Deployment-Deskriptor für das Servlet
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.2//EN"
"http://java.sun.com/j2ee/dtds/web-app_2_2.dtd">
<web-app>
<servlet>
<servlet-name>HelloWorld</servlet-name>
<servlet-class>HelloSrv</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloWorld</servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
</web-app>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
316
6.1.3 Beispiel: Hello-World Servlet ...
Deployment mit Tomcat-Server ...
➥ Servlet ist nun unter dieser URL ansprechbar:
➥ http://localhost:8080/test/hello
➥ HTML-Datei zum Aufruf des Servlets kann z.B. nach
$CATALINA_BASE/webapps/ROOT/hello.html kopiert werden
➥ URL dann http://localhost:8080/hello.html
➥ Anmerkungen:
➥ Servlet-Klassen dürfen nicht im CLASSPATH von Tomcat sein!
➥ Tomcat nie im Verzeichnis starten, in dem die ServletKlassen liegen!
➥ Tomcat 6.0 kann beim Deployment auch laufen
➥ WAR Archiv wird bei Änderung erneut ausgepackt, Klassen
werden neu geladen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
317
6.1 Servlets ...
6.1.4 Lebenszyklus eines Servlets
➥ Beim Start des Servers oder durch Client-Anfrage:
➥ Servlet-Klasse wird in Web-Server geladen
➥ eine Instanz der Servlet-Klasse wird erzeugt
➥ die init()-Methode wird aufgerufen
➥ Bei einer HTTP-Anfrage:
➥ Erzeugung eines neuen Threads, der die Methode doGet()
bzw. doPost() ausführt
➥ Implementierung der Methoden muß thread-sicher sein!
➥ Bei Entfernung des Servlets aus dem Server
➥ Aufruf der Methode destroy()
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
318
6.1 Servlets ...
6.1.5 Wichtige Klassen und Methoden
➥ HttpServletRequest: HTTP-Anfrage
➥ String getParameter(String name)
➥
liefert Wert des genannten Anfrage-Parameters
➥ z.B. bei GET /buy.html?what=shoe HTTP 1.0
➥ HttpSession getSession()
➥
liefert bzw. erzeugt Sitzungs-Objekt (☞ 6.1.6)
➥ HttpServletResponse: HTTP-Antwort
➥ void setContentType(String type)
➥
setzt MIME-Typ der Antwort (i.d.R. "text/html")
➥ PrintWriter getWriter()
➥
liefert PrintWriter zum Schreiben der Ausgabe
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
319
6.1 Servlets ...
6.1.6 Sitzungs-Management
➥ Methode getSession() erlaubt Management von
Client-Sitzungen
➥ erzeugt neue Sitzung, falls noch keine existiert
➥ liefert Sitzungs-Objekt HttpSession als Ergebnis
➥ Verfolgung von Sitzungen:
➥ Server erzeugt eindeutige Sitzungs-ID
➥ Sitzungs-ID wird als Cookie im Client gespeichert
➥ Cookie wird bei jeder erneuten Anfrage an Server übertragen
➥ (Alternativ kann Sitzungs-ID auch an URLs angefügt werden)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
320
6.1.6 Sitzungs-Management ...
Das HttpSession-Objekt
➥ Identifiziert eindeutig eine Client-Sitzung
➥ Erlaubt, beliebige Information sitzungs-lokal zu speichern
➥ Wichtige Methoden:
➥ String getId(): liefert Sitzungs-ID
➥ boolean isNew(): neue Sitzung?
➥ void setAttribute(String name, Object value)
➥
Speichern sitzungslokaler Daten unter gegebenem Namen
➥ Object getAttribute(String name)
➥
Auslesen sitzungslokaler Daten mit gegebenem Namen
➥ setMaxInactiveInterval(int interval)
➥
Einstellen des Sitzungs-Timeouts
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
321
6.1.6 Sitzungs-Management ...
Beispiel: Hello-World mit sitzungslokalem Zähler
public void doGet(HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
Integer counter;
HttpSession session = request.getSession();
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html>");
out.println("<head><title>Hallo World</title></head>");
out.println("<body>");
if (session.isNew()) {
out.println("<b>Welcome to new session</b><br>");
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
322
6.1.6 Sitzungs-Management ...
Beispiel: Hello-World mit sitzungslokalem Zähler ...
counter = (Integer)session.getAttribute("HelloSession.cntr");
if (counter == null) {
counter = 1;
}
else {
counter++;
}
session.setAttribute("HelloSession.cntr", counter);
String name = request.getParameter("name");
out.println("<b>" + counter + ". Hello to " + name + "!</b>");
out.println("<br>Session ID: " + session.getId() + "</body>");
out.println("</html>");
out.close();
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
323
6 Servlets und JSP ...
6.2 Java Server Pages (JSP)
➥ Ziel: einfachere Generierung dynamischer HTML-Seiten
➥ Probleme von Servlets:
➥ Ausgabe von HTML-Code in println()-Anweisungen ist
umständlich / fehleranfällig
➥ der größte Anteil davon ist statisch
➥ Installation und Deployment von Servlets ist schwierig
➥ verglichen mit statischen HTML-Seiten
➥ Lösungsidee:
➥ Einbetten von Java-Servlet-Code in statische HTML-Seiten
➥ beim ersten Aufruf der Seite wird über JSP-Compiler automatisch ein Servlet erzeugt und in WWW-Server geladen
➥ spätere Aufrufe nutzen dann direkt das Servlet
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
324
6.2 Java Server Pages (JSP) ...
6.2.1 Spezielle Tags für JSP
➥ Tag für Ausdrücke: <%= Ausdruck %>
➥ Wert des Java-Ausdrucks erscheint in HTML-Ausgabe
➥ Beispiel:
➥
<html><body> 17 + 4 = <%= 17+4 %> </body></html>
➥ Ergebnis: <html><body> 17 + 4 = 21 </body></html>
➥ Tag für Java-Code: <% Java-Code %>
➥ angegebener Java-Code wird in doGet() bzw. doPost()
Methode eines Servlets ausgeführt
➥ Ausgabe wird in HTML-Ausgabe eingefügt
➥ Java-Code kann auch mit regulärem HTML-Code gemischt
werden
➥ z.B. für bedingte HTML-Ausgaben
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
325
6.2.1 Spezielle Tags für JSP ...
➥ Tag für Java-Code: <% Java-Code %> ...
➥ Beispiel:
<html>
<body>
<%
java.util.Date date = new java.util.Date();
if (date.getHours() < 12) {
%>
Guten Morgen!
<% } else { %>
Guten Tag!
<% } %>
Es ist jetzt <%= date.toString() %>.
</body>
</html>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
326
6.2.1 Spezielle Tags für JSP ...
➥ Tag zur Deklaration globaler Variablen: <%! Deklaration %>
➥ globale Variable =
b Attribut der erzeugten Servlet-Klasse
➥ Wert bleibt über alle Aufrufe der JSP-Seite hinweg erhalten
➥
auch über verschiedene Client-Sitzungen hinweg
➥ Beispiel: Hit-Counter
<html>
<body>
<%! int hitCount = 0; %>
Hit Count: <%= ++hitCount %>
</body>
</html>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
327
6.2 Java Server Pages (JSP) ...
6.2.2 Vordefinierte Variablen
➥ Java-Code in JSP-Seiten kann u.a. folgende vordefinierte
Variablen nutzen:
➥ request
➥
HttpServletRequest-Parameter der Servlet-Methoden
doGet() bzw. doPost()
➥ response
➥
HttpServletResponse-Parameter
➥ out ( ≈ response.getWriter() )
➥
JSPWriter (≈ PrintWriter) für HTML-Ausgabe
➥ session ( = request.getSession() )
➥
HttpSession-Objekt für aktuelle Client-Sitzung
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
328
6.2 Java Server Pages (JSP) ...
6.2.3 Beispiele
➥ Hello-World (funktional identisch mit Beispiel aus 6.1.3)
<html>
<body>
<%! int counter = 0; %>
<%
counter++;
String name = request.getParameter("name");
%>
<b><%= counter%>. Hello to <%= name%>!</b>
</body>
</html>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
329
6.2.3 Beispiele ...
➥ Hello-World mit sitzungslokalem Zähler
(funktional identisch mit Servlet-Beispiel aus 6.1.6)
<html>
<body>
<%
Integer counter;
if (session.isNew()) {
out.println("<b>Welcome to new session</b><br>");
}
counter = (Integer)
session.getAttribute("HelloSession.cntr");
if (counter == null) {
counter = 1;
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
330
6.2.3 Beispiele ...
else {
counter++;
}
session.setAttribute("HelloSession.cntr", counter);
String name = request.getParameter("name");
out.println("<b>" + counter + ". Hello to "
+ name + "</b>");
out.println("<br>Session ID: " + session.getId());
%>
</body>
</html>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
331
6.2 Java Server Pages (JSP) ...
6.2.4 JSP Direktiven
➥ JSP bietet einige Direktiven, die das Verhalten der JSP-Seite
kontrollieren
➥ Allgemeine Syntax: <%@ Direktive %>
➥ Wichtige Beispiele:
➥ <%@ include file="copyright.html" %>
➥
Einfügen der Datei copyright.html in die JSP-Seite
➥ <%@ page import="javax.rmi.*, javax.naming.*" %>
➥
Importieren von Java-Paketen (komma-separierte Liste)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
332
6.2 Java Server Pages (JSP) ...
6.2.5 JSP und Java Beans
➥ JSP-Seiten können auch auf Java Beans zurückgreifen:
➥ <jsp:useBean id="product"
class="com.company.ProductBean"/>
➥ Erzeugt eine Bean-Instanz für alle Aufrufe der JSP-Seite
➥ Referenz in der globalen Variable product gespeichert
➥ Abfrage von Properties der Bean:
➥ <jsp:getProperty name="product" property="Price"/>
➥ entspricht <%= product.getPrice() %>
➥ Setzen von Properties der Bean:
➥ <jsp:setProperty name="product" property="Price"
value="12.50"/>
➥ Vorteil: Modularität, weniger / kein Java-Code in der JSP-Seite
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
333
6 Servlets und JSP ...
6.3 Zusammenfassung
➥ Servlets: Java-Klassen zur Bearbeitung von HTML-Anfragen in
WWW-Servern
➥ Erzeugung dynamischer HTML-Seiten
➥ Klassen: HttpServlet, HttpServletRequest,
HttpServletResponse
➥ Im Server: genau eine Instanz der Servlet-Klasse
➥ Sitzungs-Management kann/muß explizit programmiert
werden (HttpSession)
➥ JSP: Vereinfachter Umgang mit Servlets
➥ Mischung von statischem HTML-Code und Servlet-Code
➥ Servlet wird dynamisch aus JSP-Seite genieriert
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
334
Client/Server-Programmierung
WS 2013/2014
7
Web Services
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
335
Client/Server-Programmierung (11/12)
336
7 Web Services ...
Inhalt
➥ Einführung
➥ Web-Service-Standards
➥ XML, SOAP, WSDL, UDDI
➥ Web Services mit Axis2
➥ Sicherheit von Web Services
Roland Wismüller
Betriebssysteme / verteilte Systeme
7 Web Services ...
Literatur
➥ Hammerschall, Kap. 7
➥ Langner: Web Services mit Java
➥ Hein, Zeller: Java Web Services
➥ A. Eberhart, S. Fischer: Web Services, Hanser, 2003.
➥ M. P. Papagoglou: Web Servces: Principles and Technology,
Pearson, 2008.
➥ T. Frotscher, M. Teufel, D. Wang: Java Web Services mit Apache
Axis2, Entwickler.press, 2007
➥ Zu XML auch: Horstmann / Cornell, Kap. 12
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
337
7 Web Services ...
7.1 Einführung
➥ Im Web heute: Mensch-Maschine-Kommunikation
➥ statische und dynamische Web-Seiten (Servlets, JSP, ...)
➥ Ziel von Web-Services: Maschine-Maschine-Kommunikation
➥ Vision: Web-Services bieten komplexe Dienste an, suchen
dazu eigenständig nach Teildiensten im Netz
Hotel−
Service
Internet
Client−
Anwendung
Web Service
Internet
Reise−
Service
Flugbuchungs−
Service
Web Service
Web Service
Autobuchungs−
Service
Web Service
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
338
7.1 Einführung ...
➥ Ziel von Web Services:
➥ plattform- und sprachunabhängige Nutzung von Diensten auf
entfernten Rechnern
➥ Modell ist dienst-orientiert, nicht objekt-orientiert
➥ Web Services definieren kein verteiltes Objektmodell
➥ Dienste sind als zustandslos angenommen
➥
aber: Erweiterungen für Sitzungsbehandlung möglich
➥ Web Services kommunizieren durch den Austausch von XMLDokumenten
➥ I.a. synchrone Kommunikation mit Anfrage/Antwort-Muster
➥ aber auch allgemeinere Kommunikationsmuster möglich
➥
Anfragen ohne Antwort, Ereignismeldungen, ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
339
7.1 Einführung ...
➥ Web Services sind zunächst nur über zwei Standards definiert:
➥ das Kommunikationsprotokoll (SOAP)
➥ die Schnittstellenbeschreibung (WSDL)
➥ Diese reichen aus, um Interoperabilität zu gewährleisten
➥ vgl. IIOP und OMG-IDL bei CORBA
➥ Web Service Frameworks (z.B. Axis2) bieten darüberhinaus
(proprietäre) Werkzeuge und APIs für z.B.
➥ die Erzeugung von Client- und Server-Stubs
➥ die Erzeugung / Manipulation von SOAP-Nachrichten
➥ das Deployment von Web Services
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
340
7 Web Services ...
7.2 Web-Service-Standards
➥ Grundelemente zur Realisierung von Web Services:
➥ SOAP (Simple Object Access Protocol)
➥
zum Nachrichtenaustausch
➥ legt i.w. Codierung von Datenstrukturen fest
➥ WSDL (Web Service Description Language)
➥
Dienst- und Schnittstellenbeschreibung
➥ enthält u.a. auch Ort“ des Dienstes (Host / Port)
”
➥ UDDI (Universal Description and Discovery Interface)
➥ zur Registrierung und zum Auffinden von Diensteanbietern
und Diensten
➥ Alle drei Elemente basieren auf XML
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
341
7.2 Web-Service-Standards ...
7.2.1 XML (Extensible Markup Language)
➥ Deskriptive Sprache zur Beschreibung komplexer Datenstrukturen in einem Dokument
➥ vorwiegend zum Datenaustausch zwischen Systemen
➥ d.h. XML liefert ein vereinheitlichtes Datenfomat
➥ Technisch:
➥ XML-Dokument ist ein Textdokument mit Tags, die Nutzinfor-
mation umschließen (Elemente)
➥ Elemente können verschachtelt werden
➥
hierarchische Dokumenten-Struktur (mit Verweisen)
➥ Syntax ähnlich wie bei HTML, jedoch strikter
➥
aber: bei XML legen Tags die Bedeutung der Information
fest, bei HTML die Formatierung
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
342
7.2.1 XML (Extensible Markup Language) ...
Aufbau eines XML-Dokuments
➥ Ein XML-Dokument besteht aus zwei Teilen:
➥ Kopf (Header ): XML Version, Zeichensatz, ggf. Angabe des
Dokumententyps (DTD bzw. XML-Schema, s. Folie 348ff)
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE addressbook SYSTEM ¨addressbook.dtd¨>
➥ Rumpf (Body ): verschachtelte Folge von Elementen
<addressbook>
<mail-address category="professor">
<name>Roland Wismüller</name>
<email>rolanda
.d
wismuellera
@d
uni-siegena
.de</email>
</mail-address>
</addressbook>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
343
7.2.1 XML (Extensible Markup Language) ...
Wohlgeformte XML-Dokumente
➥ Ein XML-Dokument ist wohlgeformt, wenn es die syntaktischen
Regeln von XML einhält, u.a.:
➥ Struktur eines Elements: <name> ... </name>
➥
Ende-Tag muß immer vorhanden sein
➥ Abkürzung für leere Elemente: <leeresElement/>
➥ korrekte Verschachtelung der Elemente in Baumstruktur
➥
nicht: <name>...<email> </name>...</email>
➥ XML-Dokument muß genau ein Wurzelelement besitzen
➥ öffnende (und leere) Tags können auch Attribute besitzen
➥
z.B. <person name="Heinz" age="9">... </person>
➥ Kommentare: 
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
344
7.2.1 XML (Extensible Markup Language) ...
Gültige XML-Dokumente
➥ Nicht jedes wohlgeformte XML-Dokument beschreibt eine gültige
Datenstruktur
➥ der Datentyp muß ebenfalls berücksichtigt werden
➥ z.B. im Beispiel von Folie 343: ein Adreßbucheintrag muß aus
Name und Email-Adresse bestehen
➥ Dazu: XML erlaubt die Definition eines Dokumententyps bzw.
Schemas
➥ legt Namen, Verschachtelung, Abfolge, und möglichen Inhalt
der Elemente fest
➥ DTD (Document Type Definition): alte Methode
➥ XML Schema: aktuelle Methode
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
345
7.2.1 XML (Extensible Markup Language) ...
Namensräume in XML
➥ Um Tag-Namen aus verschiedenen DTDs bzw. Schematas
unterscheiden zu können, führt XML Namensräume ein
➥ Namensraum wird durch URI (meist: URL) identifiziert
➥ URI garantiert weltweite Eindeutigkeit
➥ Beispiel:
<bsp:myElem xmlns:bsp="http://www.uni-siegen.de/bsp">
<bsp:mySubElem>Hallo</bsp:mySubElem>
</bsp:myElem>
➥ der String bsp ist ein Alias für den Namensraum
➥
wird allen Elementen des Namensraums vorangestellt
➥ Ein Dokument kann auch mehrere Namensräume nutzen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
346
7.2.1 XML (Extensible Markup Language) ...
DTD (Document Type Definition)
➥ Beispiel: DTD für ein Email-Adreßbuch
XML Header
(aber: DTD ist kein
XML−Dokument)
Root−Element, enthält
0 oder mehr <mail−address>
Elemente
<mail−address> enthält erst
ein <name> Element und dann
ein oder mehr <email> Elemente
<?xml version="1.0" encoding="UTF−8"?>
<!ELEMENT addressbook (mail−address*)> <mail−address> kann
<!ELEMENT mail−address (name, email+)> ein Attribut category
haben, mit den Werten
<!ATTLIST mail−address category
"professor" oder
(professor | assistant) #IMPLIED>
"assistant"
<!ELEMENT name (#PCDATA)>
<!ELEMENT email (#PCDATA)>
Die Elemente <name>
und <email> enthalten Text
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
347
7.2.1 XML (Extensible Markup Language) ...
Anmerkungen zu Folie 347:
#IMPLIED bedeutet, daß das Attribut nicht vorhanden sein muß. Alternativ kann an
dieser Stelle sonst auch #REQUIRED stehen.
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
347
7.2.1 XML (Extensible Markup Language) ...
XML Schema
➥ Ein XML Schema ist ein XML-Dokument, das den Aufbau von
XML-Dokumenten beschreibt
➥ Prinzip: zulässige Struktur und Inhalt eines XML-Dokuments wird
als Datentyp beschrieben
➥ Bausteine:
➥ vordefinierte, einfache Datentypen
➥ ggf. mit Einschränkung von Wertebereich bzw. Syntax
➥ selbst definierte, einfache Datentypen (z.B. Aufzählung)
➥ komplexe (zusammengesetzte) Datentypen
➥ Sequenzen (feste Folge von Unterelementen)
➥ Alternativtypen (alternativ wählbare Unterelemente)
➥ Kardinalitäts-Angabe (wie oft muß/darf Element auftreten?)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
348
7.2.1 XML (Extensible Markup Language) ...
Beispiel: XML Schema für das Adressbuch
AddressBookType be−
steht aus 0 oder mehr
<mail−address> Elementen
Root−Element
Namensraum
<? xml version
version="1.0"
"1.0" encoding="UTF−8"
"UTF−8" ?>
<xsd:schema
xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
"http://www.w3.org/2001/XMLSchema"
<xsd:element
xsd:element name="addressbook"
"addressbook" type="AddressBookType"/>
"AddressBookType"
<xsd:complexType
xsd:complexType name="AddressBookType">
"AddressBookType"
<xsd:element
xsd:element name="mail−address"
"mail−address"
minOccurs="0"
"0" maxOccurs="unbounded">
"unbounded"
<xsd:complexType
"MailAddressType"
xsd:complexType name="MailAddressType">
<xsd:sequence>
xsd:sequence
xsd:element name="name"
"name" type="xsd:string"/>
"xsd:string"
<xsd:element
xsd:element name="email"
<xsd:element
"email" type="xsd:string"
"xsd:string"
"unbounded"
maxOccurs="unbounded"/>
xsd:sequence
</xsd:sequence>
<mail−address> enthält erst ein <name> Element
und dann ein oder mehr <email> Elemente
Roland Wismüller
Betriebssysteme / verteilte Systeme
Die Elemente <name>
und <email> enthalten Text
Client/Server-Programmierung (11/12)
349
7.2.1 XML (Extensible Markup Language) ...
Beispiel: XML Schema für das Adressbuch ...
<mail−address> kann
ein Attribut vom Typ
CategoryType haben
<xsd:attribute
"category" type="CategoryType"
"CategoryType"
xsd:attribute name="category"
use="optional"/>
"optional"
</xsd:complexType>
xsd:complexType
</xsd:element>
xsd:element
</xsd:complexType>
xsd:complexType
<xsd:simpleType
"CategoryType" base="xsd:string">
"xsd:string"
xsd:simpleType name="CategoryType"
<xsd:enumeration
"professor"
xsd:enumeration value="professor"/>
<xsd:enumeration
"assistant"
xsd:enumeration value="assistant"/>
xsd:simpleType
</xsd:simpleType>
CategoryType ist ein
String, der nur die Werte
</xsd:schema>
xsd:schema
"professor" oder "assistant"
haben kann
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
350
7.2.1 XML (Extensible Markup Language) ...
Beispiele für XML-Dokumente (nur Rumpf)
Gültig:
Ungültig:
<addressbook>
<addressbook>
<mail−address>
<mail−address>
<name>Hugo</name>
<email>[email protected]</email>
<email>[email protected]</email>
<name>Hugo</name>
</mail−address>
</mail−address>
<mail−address
<mail−address
category="assistant">
category="assistant">
<name>Fritz</name>
<name>Fritz</name>
<email>fr@home</email>
</mail−address>
<email>Hallo</email>
<name>Hans</name>
</mail−address>
</addressbook>
</addressbook>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
351
7.2.1 XML (Extensible Markup Language) ...
XML Parser
➥ Für XML existieren generische Parser, die zusätzlich auch die
Gültigkeit des Dokuments prüfen können
➥ Vorteil von XML gegenüber anderen Beschreibungssprachen
➥ Es gibt zwei Parsertypen:
➥ SAX-Parser erzeugen für jedes auftretende XML-Primitiv ein
Ereignis
➥
Anwendung muß zugehörige Handler definieren
➥ DOM-Parser setzen Dokument komplett in Datenstruktur um
➥
DOM: Document Object Model
➥ vorteilhaft, wenn Dokument manipuliert werden soll
➥ nachteilig bei großen Dokumenten (Speicherbedarf)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
352
7.2 Web-Service-Standards ...
7.2.2 SOAP
➥ XML-basiertes Protokoll zum Austausch strukturierter Daten
➥ Unabhängig vom darunterliegenden Transportprotokoll
➥ Bindungen für HTTP, SMTP, FTP, etc. möglich
➥ SOAP ist ein allgemeines Nachrichtenprotokoll
➥ SOAP 1.2 definiert mehrere Nachrichtenaustausch-Muster, u.a.:
➥ dialogorientierter (freier) Nachrichtenaustausch
➥ Anfrage/Antwort-Muster (für RPC)
➥ SOAP definiert i.W. ein Nachrichtenformat
➥ SOAP ist erweiterbar
➥ z.B. für Sicherheit (Verschlüsselung etc.)
➥ Aktuelle Version: 1.2 (April 2007)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
353
7.2.2 SOAP ...
Das SOAP-Nachrichtenformat
<?xml version="1.0" ?>
SOAP Envelope
<env:Envelope
xmlns:env="http://www.w3.org/2003/05/soap−envelope">
<env:Header>
SOAP Header
Header Block (anwendungsspezifisch)
Header Block (anwendungsspezifisch)
</env:Header>
<env:Body>
SOAP Body
Nachrichten−Rumpf (anwendungsspezifisch)
</env:Body>
</env:Envelope>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
354
7.2.2 SOAP ...
Das SOAP-Nachrichtenformat ...
➥ SOAP legt i.W. nur Struktur der Nachrichten fest
➥ Inhalt von Header und Body sind anwendungsspezifisch
➥
d.h. Schema läßt beliebige Elemente zu
➥ Header ist optional, enthält Metadaten
➥
z.B. Transaktionsnummern, Authentifizierungsdaten
➥ Body muß vorhanden sein, enthält Anwendungsdaten
➥ Elemente des Envelope liegen in eigenem Namensraum
➥ typisch: eigene Namensräume für Header -Blöcke und Body
➥ Hinzufügen weiterer Elemente im Envelope möglich
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
355
7.2.2 SOAP ...
Der SOAP-Header
➥ Enthält Anweisungen, die festlegen, wie ein SOAP-Knoten die
Nachricht verarbeiten soll
➥ SOAP-Knoten: Sender, Empfänger und Zwischenknoten (z.B.
Weiterleitung, Signierung, ...)
➥ Beispiele:
➥ Sicherheits-Header
➥
Zertifikat und Signatur für einige Body -Elemente
➥ anwendungsspezifische Metadaten
➥
z.B. Kundendaten des Clients
➥ Die Elemente des Headers werden von SOAP nicht festgelegt,
es gibt aber vorgeschriebene Attribute der Header -Elemente
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
356
7.2.2 SOAP ...
Der SOAP-Header ...
➥ Attribute von SOAP Header -Elementen:
➥ role: für wen ist der Header gedacht?
➥
Kodierung der Rollen durch URI (wg. Eindeutigkeit)
➥ einige vordefinierte URIs, u.a. für beliebige Empfangsknoten und endgültigen Empfänger
➥ mustUnderstand: der Knoten, für den der Header -Block
gedacht ist, muß ihn verstehen oder eine Fehlernachricht
zurückgeben
➥ relay: soll der Header -Block weitergereicht werden, falls er
nicht verarbeitet wurde?
➥ verarbeitete Header -Blöcke werden nie weitergereicht
(können aber erneut eingefügt werden)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (11/12)
357
Client/Server-Programmierung
WS 2013/2014
10.01.2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
.d
[email protected] e
rolanda
Tel.: 0271/740-4050, Büro: H-B 8404
Stand: 23. April 2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
i
Client/Server-Programmierung (12/12)
7.2.2 SOAP ...
Der SOAP Body
➥ Aufbau ist abhängig von Kommunikationsstil und Codierungsstil
➥ Kommunikationsstil (communication style / binding style):
➥ RPC: SOAP-Nachrichten speziell für RPCs
➥
Prozeduraufruf mit Parametern bzw. Rückgabewerte
➥ Aufbau des Body ist i.w. durch SOAP festgelegt
➥ document: SOAP-Nachrichten für allgemeine Dokumente
➥
für nachrichtenorientierte Kommunkation, wird aber auch
für RPCs verwendet
➥ Body kann beliebige XML-Daten enthalten
➥ Aufbau des Body ist nur durch XML-Schema im WSDLDokument festgelegt
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
358
7.2.2 SOAP ...
Der SOAP Body ...
➥ Codierungsstil (encoding style / use):
➥ encoded:
➥
SOAP-spezifische Typen
➥ Werte in der SOAP-Nachricht haben explizite Typangabe
➥ literal:
➥
Datentypen werden durch XML-Schema beschrieben
➥ bei RPC-Stil nur Parameter, bei document gesamter Body
➥ Definition eigener Datentypen mit XML-Schema möglich
➥
z.B. auch zusammengesetzte Datenstrukturen
➥ Relevante Kombinationen: RPC/encoded und document/literal
➥ encoded nicht konform zu WS-I (Web Services-Interoperability )
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
359
7.2.2 SOAP ...
Aufbau des SOAP Body beim RPC Stil
➥ Body enthält immer nur genau ein Element
➥ Bei Anfragenachricht:
➥ Name = Name der aufzurufenden Operation
➥ Kindelemente: Parameter der Operation (mit Namen)
➥ Bei Antwortnachricht:
➥ Name ist frei wählbar (meist: Operationsname + Response)
➥ Kindelemente:
➥
Rückgabewert (meist result), falls Ergebnistyp 6= void
➥ Ausgabeparameter der Operation (mit Namen)
➥ zum Melden von Fehlern: spezielles <fault>-Element
➥
Unterelemente für Fehlercode und -beschreibung
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
360
7.2.2 SOAP ...
Beispiel einer SOAP-Nachricht (RPC/encoded)
➥ Request-Nachricht für einen Aufruf der Java-Methode
String reserviere(String flugNr, int size, Date datum);
<?xml version=’1.0’ encoding=’UTF-8’?>
<env:Envelope
xmlns:env="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<env:Body>
<ns1:reserviere
env:encodingStyle="http://schemas.xmlsoap.org/soap/encoding
xmlns:ns1="http://www.web-air.de/axis/Buchung.jws">
<flugNr xsi:type="xsd:string">WA417</flugNr>
<sitze xsi:type="xsd:int">3</sitze>
<datum xsi:type="xsd:dateTime">2003-07-11</datum>
</ns1:reserviere>
</env:Body>
</env:Envelope>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
361
7.2.2 SOAP ...
Aufbau des SOAP Body beim document Stil
➥ Nach WS-I sollte Body nur ein Element enthalten
➥ ggf. Einwickeln“ der Argumente in ein neues Element
”
(wrapped Konvention)
➥ Problem bei RPCs: Name der Operation geht aus SOAP-Nachricht nicht zwangsläufig hervor
➥ Mögliche Abhilfen:
➥ bei document/wrapped : Elementname = Operationsname
➥ Spezifikation über das Transportprotokoll
➥
z.B. im HTTP-Header: SOAPAction (SOAP 1.1) bzw.
action Attribut von Content-Type (SOAP 1.2)
➥ WS-Addressing: Spezifikation im SOAP Header
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
362
7.2.2 SOAP ...
Beispiel einer SOAP-Nachricht (document/literal/wrapped)
➥ Request-Nachricht für einen Aufruf der Java-Methode
String reserviere(String flugNr, int size, Date datum);
<?xml version=’1.0’ encoding=’UTF-8’?>
<soapenv:Envelope
xmlns:soapenv="http://www.w3.org/2003/05/soap-envelope">
<soapenv:Body>
<reserviere xmlns="http://ws.apache.org/axis2">
<flugNr>WA417</flugNr>
<sitze>3</sitze>
<datum>2003-07-11</datum>
</reserviere>
</soapenv:Body>
</soapenv:Envelope>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
363
7.2.2 SOAP ...
Beispiel einer SOAP-Nachricht (document/literal/wrapped) ...
➥ Antwortnachricht
<?xml version=’1.0’ encoding=’UTF-8’?>
<soapenv:Envelope
xmlns:soapenv="http://www.w3.org/2003/05/soap-envelope">
<soapenv:Body>
<reserviereResponse xmlns="http://ws.apache.org/axis2">
<return>GHFTR89</return>
</reserviereResponse>
</soapenv:Body>
</soapenv:Envelope>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
364
7.2.2 SOAP ...
Die SOAP-HTTP-Bindung
➥ SOAP-Standard definiert zwei Methoden:
➥ Verwendung von HTTP POST:
➥
SOAP-Anfrage-Nachricht wird im Rumpf der HTTP-Anfrage
an den Server gesendet
➥ Antwort als SOAP-Nachricht in der HTTP-Antwort
➥ Verwendung von HTTP GET:
➥
Operation und Parameter werden in URL der HTTP-Anfrage
codiert (ohne SOAP)
➥ Antwort als SOAP-Nachricht in der HTTP-Antwort
➥ Empfehlung des Standards:
➥ GET-Methode (nur) verwenden bei Aufrufen ohne Seiteneffek-
te und ohne SOAP-Header
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
365
7.2 Web-Service-Standards ...
7.2.3 WSDL
➥ XML-basierte Sprache zur Beschreibung von Diensten
➥ also u.a. Schnittstellen-Beschreibungssprache
➥ zusätzlich aber auch: Ort (URL) des Dienstes und zu verwen-
dendes Protokoll
➥ Eigenschaften von WSDL
➥ unabhängig von Programmiermodell, Implementierungsspra-
chen und Transportprotokoll
➥ WSDL ist auch unabhängig von SOAP
➥ Unterstützung von XML Schema zur Definition von Typen
➥ WSDL ist selbst über XML Schema definiert
➥ Aktuelle Version: 2.0 (Juni 2007), verwendet häufig noch 1.1
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
366
7.2.3 WSDL ...
Aufbau eines WSDL-Dokuments
<?xml version="1.0" ?>
<wsdl:definitions
Wurzelelement
targetNamespace="http://www.web−air.de/Buchung/"
...
xmlns:wsdl="http://www.w3.org/2003/06/wsdl">
Spezifikation von Datentypen
Beschreibung der Nachrichtenformate (WSDL 1.1)
Beschreibung der Schnittstellen
Beschreibung der Bindungen
Beschreibung des Dienstes
</wsdl:definitions>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
367
7.2.3 WSDL ...
Zur Struktur eines WSDL-Dokuments
➥ Ein WSDL-Dokument beschreibt Dienste
➥ Ein Dienst wird über ein oder mehrere Endpunkte erreicht
➥ Ein Endpunkt beschreibt den Ort (URI) des Dienstes und ist mit
genau einer Bindung assoziiert
➥ Eine Bindung bindet die Operationen einer Schnittstelle an ein
bestimmtes Protokoll
➥ Eine Schnittstelle beschreibt mehrere Operationen
➥ Für jede Operation werden die Nachrichtenformate für Ein- und
Ausgabeparameter festgelegt (WSDL 1.1)
➥ Ein Nachrichtenformat besteht aus einer Sequenz von Feldern
mit gegebenen Datentypen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
368
7.2.3 WSDL ...
Beispiel zur allgemeinen Struktur eines Dienstes
Dienst
Endpunkt
mit URI 1
(SOAP)
Endpunkt
Endpunkt
mit URI 2
mit URI 3
(HTTP GET) (HTTP POST)
Schnittstelle 1
Operation 1
Operation 2
Operation 3
Roland Wismüller
Betriebssysteme / verteilte Systeme
Endpunkt
mit URI 4
(SOAP)
Endpunkt
mit URI 5
(HTTP GET)
Schnittstelle 2
Operation 4
Operation 5
Client/Server-Programmierung (12/12)
369
7.2.3 WSDL ...
Spezifikation von Datentypen
➥ Element <types>
➥ Erlaubt Definition eigener komplexer Datentypen
➥ Nutzung von XML Schema
➥ Beispiel: Datentyp für Parameter einer Flugreservierung
<wsdl:types>
<xs:schema targetNamespace="http://www.web-air.de/Buchung/">
<xs:element name="reservierung">
<xs:complexType>
<xs:sequence>
<xs:element name="flugNr" type="xs:string"/>
<xs:element name="sitze" type="xs:int"/>
<xs:element name="date" type="xs:date"/>
...
</wsdl:types>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
370
7.2.3 WSDL ...
Beschreibung der Nachrichtenformate (WSDL 1.1)
➥ Element <message>
➥ Für jede vom Dienst verwendete Nachricht (Anfrage, Antwort, ...)
wird das Format definiert:
➥ eine Nachricht besteht aus beliebig vielen Teilen mit festgelegtem Datentyp
➥ Standard XML-Datentyp oder in <types> definiert
➥ üblich: nur ein Teil mit einem complexType als Typ
➥ Beispiel (ohne Namensraumangabe für WSDL-Elemente):
<message name="reserviereRequest">
<part name="parameters" type="ns:reservierung"/>
</message>
<message name="reserviereResponse">
<part name="parameters" type="ns:reserviereResponse"/>
</message>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
371
7.2.3 WSDL ...
Beschreibung der Schnittstellen
➥ Element <portType> (WSDL 2.0: <interface>)
➥ Beschreibt beliebig viele Operationen mit
➥ ihren Eingabe-, Ausgabe- und ggf. Fehlernachrichtentypen
➥ ihrem Interaktionsmuster
➥
z.B. nur Eingabenachricht, Request/Response, ...
➥ definiert durch Reihenfolge der Nachrichtenspezifikationen
➥ Beispiel (ohne Namensraumangabe für WSDL-Elemente):
<portType name="BuchungPortType">
<operation name="reserviere">
<input message="ns:reserviereRequest" />
<output message="ns:reserviereResponse" />
</operation>
</portType>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
372
Anmerkungen zu Folie 372:
Bei WSDL 2.0 haben die input und output Elemente anstelle des Attributs message
ein Attribut element, das auf das Element des XML-Schemas (unter types) verweist,
das den Datentyp beschreibt.
7.2.3 WSDL ...
Beschreibung der Bindungen
➥ Element <binding>
➥ Zu jeder Schnittstelle kann es eine oder mehrere Bindungen
geben
➥ Die Bindung legt fest
➥ das Transportprotokoll (z.B. SOAP, HTTP PUT, HTTP GET)
➥ den Kommunikationsstil (rpc oder document)
➥ für jede Operation:
➥
URI für den Aufruf der Operation
➥ wird bei HTTP in das SOAPAction-Element bzw. actionAttribut im HTTP-Header übernommen
➥ wichtig bei document, vgl. Folie 362
➥ Codierung der Ein- und Ausgabe (encoded oder literal)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
373
7.2.3 WSDL ...
Beschreibung der Bindungen ...
➥ Beispiel (ohne Namensraumangabe für WSDL-Elemente):
<binding name="BuchungSoapBinding" type="ns:BuchungPortType">
<soap:binding transport=
"http://schemas.xmlsoap.org/soap/http" style="document" />
<operation name="reserviere">
<soap:operation soapAction="urn:reserviere" />
<input>
<soap:body use="literal" />
</input>
<output>
<soap:body use="literal" />
</output>
</operation>
</binding>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
374
7.2.3 WSDL ...
Beschreibung des Dienstes
➥ Beschreibung besteht aus Liste von Endpunkten
➥ Element <port> (WSDL 2.0: <endpoint>)
➥ jeweils mit Ortsangabe (URI) und zugehöriger Bindung
➥ Beispiel (ohne Namensraumangabe für WSDL-Elemente):
<service name="Buchung">
<port name="BuchungHttpSoapEndpoint"
binding="s0:BuchungSoapBinding">
<soap:address
location="http://www.web-air.de/Buchung/Buchung.asmx" />
</port>
</service>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
375
7.2.3 WSDL ...
Vollständiges Beispiel eines WSDL-Dokuments (WSDL 1.1)
➥ Dienst mit zwei Operation (als Java-Interface beschrieben):
public interface Test {
public String getIt();
public void putIt(String it);
}
➥ WSDL-Dokument für den entsprechenden Web-Service:
<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions xmlns:axis2="http://ws.apache.org/axis2"
xmlns:ns="http://ws.apache.org/axis2/xsd"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns:http="http://schemas.xmlsoap.org/wsdl/http/"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:mime="http://schemas.xmlsoap.org/wsdl/mime/"
xmlns:soap12="http://schemas.xmlsoap.org/wsdl/soap12/"
targetNamespace="http://ws.apache.org/axis2">
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
376
7.2.3 WSDL ...
<wsdl:types>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
attributeFormDefault="qualified" elementFormDefault="qualified"
targetNamespace="http://ws.apache.org/axis2/xsd">
<xs:element name="getItResponse">
<xs:complexType>
<xs:sequence>
<xs:element name="return" nillable="true" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:element name="putIt">
<xs:complexType>
<xs:sequence>
<xs:element name="param0" nillable="true" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
</xs:schema>
</wsdl:types>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
377
7.2.3 WSDL ...
<wsdl:message name="getItMessage" />
<wsdl:message name="getItResponseMessage">
<wsdl:part name="part1" element="ns:getItResponse" />
</wsdl:message>
<wsdl:message name="putItMessage">
<wsdl:part name="part1" element="ns:putIt" />
</wsdl:message>
<wsdl:portType name="TestPortType">
<wsdl:operation name="getIt">
<wsdl:input xmlns:wsaw="http://www.w3.org/2006/05/addressing/wsdl
wsaw:Action="urn:getIt" message="axis2:getItMessage"/>
<wsdl:output xmlns:wsaw="http://www.w3.org/2006/05/addressing/wsdl
message="axis2:getItResponseMessage" wsaw:Action="urn:getIt"/>
</wsdl:operation>
<wsdl:operation name="putIt">
<wsdl:input xmlns:wsaw="http://www.w3.org/2006/05/addressing/wsdl
wsaw:Action="urn:putIt" message="axis2:putItMessage"/>
</wsdl:operation>
</wsdl:portType>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
378
7.2.3 WSDL ...
<wsdl:binding name="TestSOAP11Binding" type="axis2:TestPortType">
<soap:binding transport="http://schemas.xmlsoap.org/soap/http"
style="document" />
<wsdl:operation name="getIt">
<soap:operation soapAction="urn:getIt" style="document" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
<wsdl:output>
<soap:body use="literal" />
</wsdl:output>
</wsdl:operation>
<wsdl:operation name="putIt">
<soap:operation soapAction="urn:putIt" style="document" />
<wsdl:input>
<soap:body use="literal" />
</wsdl:input>
</wsdl:operation>
</wsdl:binding>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
379
7.2.3 WSDL ...
<wsdl:binding name="TestSOAP12Binding" type="axis2:TestPortType">
<soap12:binding transport="http://schemas.xmlsoap.org/soap/http"
style="document" />
...
</wsdl:operation>
</wsdl:binding>
<wsdl:service name="Test">
<wsdl:port name="TestSOAP11port"
binding="axis2:TestSOAP11Binding">
<soap:address
location="http://localhost:8080/axis2/services/Test" />
</wsdl:port>
<wsdl:port name="TestSOAP12port"
binding="axis2:TestSOAP12Binding">
<soap12:address
location="http://localhost:8080/axis2/services/Test" />
</wsdl:port>
</wsdl:service>
</wsdl:definitions>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
380
7.2 Web-Service-Standards ...
7.2.4 Nutzung von SOAP und WSDL
➥ Programmierer von Web Services hat i.a. nicht direkt mit SOAP
und WSDL zu tun
➥ Web Service Frameworks enthalten Werkzeuge, die
➥ Stubs und Skeletons zum Erzeugen und Interpretieren von
SOAP-Nachrichten generieren
➥ WSDL-Beschreibungen aus z.B. Java Interfaces erzeugen
(und umgekehrt)
➥ Aber: Grundkenntnisse nützlich für
➥ Verständnis von Web Services
➥ Fehlersuche / Nutzung der Frameworks
➥ spezielle Funktionen wie z.B. Sicherheit
➥
benötigen Manipulation der SOAP-Nachrichten
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
381
7.2.4 Nutzung von SOAP und WSDL ...
Werkzeuge und Java-APIs für SOAP und WSDL
➥ Java-APIs
➥ JAXM: Erstellung, Verarbeitung und Versand von SOAP-
Nachrichten
➥ javax.xml.soap.*, javax.xml.messaging.*
➥ JAX-RPC: API und Werkzeuge für RPCs über SOAP
➥
javax.rpc.*
➥ u.a. auch Erstellung von WSDL und Stubs/Skeletons
➥ Frameworks für Web-Services
➥ in der Vorlesung: EJB 3 (☞ 7.3) und Axis2 (☞ 7.4)
➥ weitere z.B. IBM Web-Sphere, Microsoft Visual Studio .NET,
BEA WebLogic, Borland JBuilder, ...
➥ integrierte Programmentwicklungs-Umgebungen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
382
7.2 Web-Service-Standards ...
7.2.5 UDDI
➥ UDDI definiert einen standardisierten Verzeichnisdienst für Web
Services (UDDI Registry )
➥ öffentliche Registries: allgemein zugänglich
➥ nur (noch) wenige, z.B. http://uddi.sap.com
➥ private Registries: z.B. für Intranet
➥ viele Produkte (z.B. WASP, Win 2003 Server, jUDDI)
➥ Zusammenschluß zu UDDI Business Registries (UBR)
möglich: Daten werden untereinander synchronisiert
➥ Zugriff auf UDDI Registries
➥ über Web-Service-Schnittstelle (SOAP, standardisiert)
➥ über Web-Browser (HTTP, herstellerspezifisch)
➥ UDDI ist nicht primär für maschinelle Suche gedacht
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
383
7.2.5 UDDI ...
Kategorien von UDDI-Einträgen
➥ White Pages
➥ Grundlegende Information zu Unternehmen
➥ z.B. Name, Beschreibung, Adresse, Telefon, Fax,
Steuernummer, ...
➥ Yellow Pages
➥ (u.a.) nach Branchen kategorisiert
➥ erlaubt Suche nach bestimmten Arten von Diensten
➥ Green Pages
➥ technische Beschreibung von Diensten
➥ z.B. URI, WSDL-Dokument, textuelle Beschreibung der
Dienstsemantik
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
384
7.2.5 UDDI ...
Das UDDI Datenmodell
<businessEntry>
Beschreibung eines
Dienst−Anbieters:
− Kennzeichnung
− Name
2
− Kontakt
− Beschreibung
− Kategorisierung
<publisherAssertion>
Beziehungen zwischen
zwei <businessEntry>
* Elementen
<tModel>
Verweise auf technische
Beschreibung eines (Web)
*
Services, z.B. WSDL−Dok.
*
<businessService>
<bindingTemplate>
Beschreibung eines
(Web) Services
* Zugangspunkt zu einem
(Web) Service (i.a. URI)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
385
7.2.5 UDDI ...
Das UDDI Datenmodell ...
➥ Alle Datenstrukturen werden als XML-Dokumente repräsentiert
➥ Jedes Datenelement hat einen eindeutigen UDDI-Schlüssel
➥ 128-Bit-Zahl, wird bei Registierung vergeben
➥
z.B. uddi:4CD7E4BC-64BD-426D-9935-443ED39FAE23
➥ Referenzen zwischen Datenelementen erfolgen über diese
Schlüssel
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
386
7.2.5 UDDI ...
Zugriff auf UDDI Registries
➥ Mehrere Web-Service-Schnittstellen, mit WSDL spezifiziert
➥ Wichtige Schnittstellen:
➥ Abfrageschnittstelle (UDDI Inquiry )
➥
Funktionen find_xxx() und get_xxx()
➥ xxx ∈ { business, service, binding, tModel }
➥ find_xxx() liefert Basisinformation
➥ Name, UDDI-Schlüssel
➥ get_xxx() liefert vollständige Information
➥ Registrierungsschnittstelle (UDDI Publication)
➥
Funktionen save_xxx() zum Eintragen, delete_xxx() zum
Löschen von Einträgen
➥ Funktionen zur Authentifizierung
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
387
7.2.5 UDDI ...
Werkzeuge und Java-APIs für UDDI
➥ UDDI-Server (z.B. WASP, Win 2003 Server, jUDDI)
➥ UDDI-Client-APIs für Java
➥ direkt über SOAP (aufwendig, fehleranfällig)
➥ proprietäre APIs (nicht standardisiert)
➥
z.B. Microsoft UDDI SDK, UDDI4J (IBM / Open Source)
➥ bilden UDDI-Datenmodell auf Java-Klassen ab
➥ JAXR (Java API for XML Registries)
➥
javax.xml.registry.*
➥ standardisierte Schnittstelle zum Zugriff auf unterschiedliche XML-basierte Verzeichnisdienste
➥ z.B. UDDI oder ebXML
➥ ähnliches Vorgehen wie bei JNDI
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
388
7 Web Services ...
7.3 Web-Services und EJB
➥ Eine stateless Session Bean kann durch einfache Annotation zu
einem Web-Service gemacht werden:
@Stateless
@WebService
public class HelloImpl implements HelloRemote {
@WebMethod
public String sayHello() {
return "Hallo? Jemand da?";
}
}
➥ WSDL-Datei bei OpenEJB dann unter folgender URL verfügbar:
➥ http://<host> :<httpejbd-port> /HelloImpl?WSDL
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
389
7 Web Services ...
7.4 Web Services mit Axis2
➥ Axis2: Framework für Entwicklung und Deployment Java-basierter
Web Services
➥ Bestandteile von Axis2
➥ Web Service-Container
➥ Java API
➥ Werkzeuge für WSDL-Unterstützung und Deployment
➥ Funktionsumfang von Axis2
➥ Unterstützung von SOAP 1.1/1.2, WSDL 1.1/2.0
➥ Flexibles Deployment (Hot Deployment / Hot Update)
➥ WSDL-Unterstützung (Übersetzung WSDL ↔ Java)
➥ Fehlerbehandlung (Java Exception → <fault>-Nachricht)
➥ Erweiterbarkeit durch Plug-In Module
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
390
7.4 Web Services mit Axis2 ...
7.4.1 Technisches zu Axis2
➥ Der Web-Service-Container von Axis2 ist als Servlet realisiert
➥ meist in Verbindung mit dem Tomcat-Server
➥ Im Folgenden wird Kombination Axis2/Tomcat vorausgesetzt
➥ entspricht Installation im Labor H-A 4111
➥ Verzeichnisstruktur von Axis2 (wichtig für das Deployment)
$CATALINA_BASE
webapps
Wurzelverzeichnis von tomcat
ROOT
axis2
WEB−INF
services Zielverzeichnis für Deployment
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
391
7.4.1 Technisches zu Axis2 ...
Start des Axis2 Web-Service-Containers
➥ Wenn Axis2 korrekt installiert ist, muß nur der Tomcat-Server
gestartet werden:
➥ $CATALINA_HOME/bin/catalina.sh run
➥ Wenn Hot Update in Axis2 nicht aktiviert ist, muß Tomcat bei
einer Änderung deployter Web Services neu gestartet werden!
➥
alternativ: Reload von Axis2 im Tomcat-Manager
➥ Funktionstest:
➥ Aufruf der Axis2-Startseite im Browser
➥
URL: http://localhost:8080/axis2/
➥ enthält u.a. Links zu Validierungsseite und Liste deployter
Web Services
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
392
7.4 Web Services mit Axis2 ...
7.4.2 Beispiel: Hello-World mit Axis2
➥ Schritte zur Erstellung der WSDL-Beschreibung
1. Erstellung der Java-Schnittstelle HelloWorld.java
2. Übersetzen der Schnittstelle:
javac HelloWorld.java
3. Erzeugung einer WSDL-Datei aus dieser Schnittstelle:
java2wsdl.sh
-l http://localhost:8080/axis2/services/HelloWorld
-cn HelloWorld
➥ Schritte zur Erstellung des Web Services
1. Erzeugung von Implementierungsrahmen, Hilfsklassen,
Service-Deskriptor und Build-Skript aus der WSDL-Datei:
wsdl2java.sh -d adb -uw -ss -p hello -sd
-uri HelloWorld.wsdl
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
393
7.4.2 Beispiel: Hello-World mit Axis2 ...
➥ Schritte zur Erstellung des Web Services ...
2. Editieren von src/hello/HelloWorldSkeleton.java
➥
Implementieren der Operationen (Methoden)
3. ggf. Anpassen des Service-Deskriptors (☞ S. 406)
4. Übersetzen und Packen des Services:
ant jar.server
5. Kopieren des Archivs in das Axis2-Verzeichnis:
cp build/lib/HelloWorld.aar
$CATALINA_BASE/webapps/axis2/WEB-INF/services/
➥ Erster Test kann über folgende URL erfolgen:
➥ http://localhost:8080/axis2/services/HelloWorld/
sayHello?args0=Roland
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
394
7.4.2 Beispiel: Hello-World mit Axis2 ...
➥ Schritte zur Erstellung des Clients
1. Erstellung einer Java-Schnittstelle für den aufzurufenden Web
Service:
wsdl2java.sh -uri
http://localhost:8080/axis2/services/HelloWorld?wsdl
-d adb -uw -p hello
2. Erstellung des Client-Programms
src/hello/HelloClient.java
3. Übersetzung und Packen des Client-Programms:
ant jar.client
4. Start des Client-Programms:
axis2.sh -cp build/lib/HelloWorld-test-client.jar
HelloClient
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (12/12)
395
Client/Server-Programmierung
WS 2013/2014
17.01.2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
.d
[email protected] e
rolanda
Tel.: 0271/740-4050, Büro: H-B 8404
Stand: 23. April 2014
Roland Wismüller
Betriebssysteme / verteilte Systeme
i
Client/Server-Programmierung (13/12)
7.4.2 Beispiel: Hello-World mit Axis2 ...
➥ Die Schnittstelle HelloWorld.java:
public interface HelloWorld {
public String sayHello (String name);
}
➥ Der von Hand ergänzte Implementierungsrahmen
src/hello/HelloWorldSkeleton.java:
package hello;
public class HelloWorldSkeleton {
int cnt = 0;
public java.lang.String sayHello(java.lang.String args0)
{
return "Hello to " + args0 + " (" + ++cnt + ")";
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
396
7.4.2 Beispiel: Hello-World mit Axis2 ...
➥ Das Client-Programm HelloClient.java:
import hello.*;
public class HelloClient
{
public static void main(String[] args) throws Exception
{
HelloWorldStub stub;
// Referenz auf Stub holen
stub = new HelloWorldStub();
// Methoden des Dienstes aufrufen
System.out.println(stub.sayHello("Roland"));
System.out.println(stub.sayHello("Frank"));
}
}
➥ Vollständiger Beispielcode: siehe WWW
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
397
7.4 Web Services mit Axis2 ...
7.4.3 Details zu den Axis2-Werkzeugen
axis2.sh
➥ ruft java mit nötigem CLASSPATH und Java Properties auf
➥ nützlich zum Start von Clients
java2wsdl.sh
➥ erzeugt WSDL-Dokument aus Java-Schnittstelle
➥ wichtige Optionen:
➥ -l: gewünschte URL des Web Services (Endpunkt)
➥ -cn: (qualifizierter) Name der Klasse
➥ -of: Name der Ausgabedatei
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
398
7.4.3 Details zu den Axis2-Werkzeugen ...
java2wsdl.sh: Beispiel
public interface HelloWorld {
public String sayHello (String name);
}
java2wsdl.sh −cn HelloWorld
−l http://localhost:8080/axis2/services/Hello
...
<wsdl:message name="sayHelloRequest">
<wsdl:part name="parameters" element="ns:sayHello"/>
</wsdl:message>
...
<wsdl:portType name="HelloWorldPortType">
... <wsdl:operation name="sayHello">
<wsdl:binding name="HelloWorldSoap11Binding"
type="ns:HelloWorldPortType">
...
<wsdl:service name="HelloWorld">
<wsdl:port name="HelloWorldHttpSoap11Endpoint"
binding="ns:HelloWorldSoap11Binding">
<wsdlsoap:address
location="http://localhost:8080/axis2/services/Hello"/>
...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
399
7.4.3 Details zu den Axis2-Werkzeugen ...
wsdl2java.sh
➥ erzeugt aus einem WSDL-Dokument u.a.:
➥ Rahmen für die Java-Implementierungsklasse:
src/Paket /Service Skeleton.java
➥ Service-Deskriptor resources/services.xml
➥ Build-Skript build.xml für ant
➥
Target jar.server für Server-Archiv
➥ Target jar.client für Client-Archiv
➥ Client-Stub für den Web-Service:
src/Paket /Service Stub.java
➥
Default-Konstruktor: Endpunkt aus WSDL-Dokument
➥ weiterer Konstruktor erlaubt Angabe der Endpunkt-URL als
String
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
400
7.4.3 Details zu den Axis2-Werkzeugen ...
wsdl2java.sh ...
➥ wichtige Optionen:
➥ -d: Festlegung des Data Binding
➥ wie erfolgt die Umwandlung von XML-Dokumenten in
Java-Objekte? (adb, jibx, xmlbeans, jaxbri)
➥ -uw: Einschalten des Unwrapping
➥ das (einzige) XML-Element des SOAP-Body wird in
einzelne Parameter zerlegt
➥ -ss: Code-Erzeugung für Serverseite
➥ -sd: erzeuge Service-Deskriptor
➥ -p: Festlegung des Paketnamens
➥ -uri: Ort des WSDL-Dokuments
➥ -sn: Auswahl eines Services aus dem WSDL-Doument
➥ -pn: Auswahl eines Ports aus dem WSDL-Doument
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
401
7.4.3 Details zu den Axis2-Werkzeugen ...
Konstruktoren der Klasse Service Stub
➥ Service Stub()
➥ erzeugt Stub, der sich mit dem Endpunkt aus der WSDL-Datei
verbindet
➥ Festlegung ggf. über Option -pn von wsdl2java.sh
➥ Service Stub(String targetEndpoint)
➥ erzeugt Stub, der sich mit dem (als URL) gegebenen
Endpunkt verbindet
(Service ist der Name der Services aus der WSDL-Datei)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
402
7.4.3 Details zu den Axis2-Werkzeugen ...
Abbildung von Datentypen von XML auf Java durch Axis2
➥ XML-Schema aus WSDL muß in Java-Klassen umgesetzt werden
➥ prinzipiell: je eine Klasse für Anfrage- und Ergebnisnachricht
➥
mit get- und set-Methoden für einzelne Komponenten
➥ zusätzlich möglich: unwrapping
➥
entfernt Wrapper-Klasse von document/literal/wrapped
➥ Argumente können einzeln an Operation übergeben
werden
➥ wsdl2java.sh unterstützt mehrere Möglichkeiten (data bindings):
➥ adb: beste Integration mit Axis2
➥ xmlbeans: vollständigste Unterstützung von XML-Schema
➥ jibx: kann mit existierenden Java-Klassen arbeiten, beste
Unterstützung für unwrapping
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
403
7.4.3 Details zu den Axis2-Werkzeugen ...
Abbildung von Datentypen von XML auf Java durch Axis2 ...
➥ Falls WSDL-Datei durch java2wsdl.sh erzeugt wird:
wsdl2java.sh liefert auch mit unwrapping evtl. nicht mehr die
ursprüngliche Schnittstelle
➥ Umsetzung ist i.a. problemlos für
➥ einfache Datentypen (int, double, boolean, ...)
➥ Arrays und Strings
➥ Remote-Referenzen auf Objekte sind mit Axis2 (und SOAP) nicht
möglich!
➥ im Bedarfsfall muß ggf. mit selbst implementierten Objekt-IDs
gearbeitet werden
➥
Server muß Abbildung von Objekt-ID auf Objekt pflegen
➥ besser: WS-Resource Standard verwenden
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
404
7.4.3 Details zu den Axis2-Werkzeugen ...
Service-Deskriptor
<serviceGroup>
<service name="HelloWorld">
<messageReceivers>
<messageReceiver mep="http://www.w3.org/ns/wsdl/in-out"
class="hello.HelloWorldMessageReceiverInOut"/>
</messageReceivers>
<parameter name="ServiceClass">hello.HelloWorldSkeleton</parameter
<parameter name="useOriginalwsdl">true</parameter>
<parameter name="modifyUserWSDLPortAddress">true</parameter>
<operation name="sayHello"
mep="http://www.w3.org/ns/wsdl/in-out"
namespace="http://ws.apache.org/axis2">
<actionMapping>urn:sayHello</actionMapping>
<outputActionMapping>urn:sayHelloResponse</outputActionMapping
</operation>
</service>
</serviceGroup>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
405
7.4.3 Details zu den Axis2-Werkzeugen ...
Wichtige Elemente im Service-Deskriptor
➥ Parameter modifyUserWSDLPortAddress
➥ falls true: Axis2-Container ersetzt angegebene Port-Adresse
durch seine eigene
➥
Probleme z.B. mit NAT und Web-Proxies
➥ im Labor H-A 4111 auf false setzen
➥ Attribut scope des service-Tags
➥ für Sitzungsverwaltung
➥ mögliche Werte: request, soapsession, transportsession,
application
➥ siehe Abschnitt 7.4.4
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
406
7.4.3 Details zu den Axis2-Werkzeugen ...
Ablauf der Kommunikation
POST /axis2/services/HelloWorld HTTP/1.1
Content−Type: application/soap+xml;
charset=UTF−8; action="urn:sayHello"
...
<?xml version="1.0" encoding="UTF−8"?>
<soapenv:Envelope ...>...<soapenv:Body>
<sayHello
...><args0>Roland</args0></sayHello>
...
Client
HTTP/1.1 200 OK
Server: Apache−Coyote/1.1
Content−Type:application/soap+xml;action=
"urn:sayHelloResponse";charset=UTF−8
...
<?xml version="1.0" encoding="UTF−8"?>
<soapenv:Envelope ...>...<soapenv:Body>
<sayHelloResponse ...><return>Hello to
Roland</return></sayHelloResponse>
...
"Roland"
Roland Wismüller
Betriebssysteme / verteilte Systeme
Server
Tomcat
Web−
Server
<?xml version
<soapenv:Env
<sayHello ...>
...
doPost()
<?xml version
<soapenv:Env
<sayHelloRes
...
Axis2
Servlet
sayHello()
HelloWorld
"Hello to Roland"
Client/Server-Programmierung (13/12)
407
7.4 Web Services mit Axis2 ...
7.4.4 Sitzungs-Management mit Axis2
➥ Sitzungs-Management ermöglicht, in einem Web-Service einen
client-spezifischen Zustand zu verwalten
➥ Manuell programmiertes Sitzungs-Management:
➥ es gibt genau eine Instanz der Implementierungs-Klasse
➥ jede Operation erhält Sitzungs-ID als zusätzlichen Parameter
➥
Abbildung der Sitzungs-ID auf Sitzungsdaten z.B. über
Hash-Tabelle
➥ zusätzliche Methode zum Erzeugen einer Sitzungs-ID
➥ Sitzungs-Management mit Hilfe von Axis:
➥ eine Instanz der Implementierungs-Klasse pro Sitzung
➥ automatische Verfolgung der Sitzungen über generierte
Sitzungs-IDs in HTTP-Cookies oder im SOAP-Header
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
408
7.4.4 Sitzungs-Management mit Axis2 ...
Realisierung des Sitzungs-Managements
➥ Spezifikation des Session Scopes im Deployment-Deskriptor des
Dienstes, z.B.:
<serviceGroup>
<service name="HelloWorld" scope="soapsession">
...
➥ Mögliche Werte:
➥
request: keine Sitzungen, Dienst ist zustandslos
➥ transportsession: verwende Sitzung der Transport-Ebene
➥ soapsession: Sitzung durch SOAP realisiert
➥ application: genau eine Instanz für alle Nachrichten
➥ Einschalten des Sitzungs-Managements im Client:
HelloWorldStub stub = new HelloWorldStub();
stub._getServiceClient().getOptions().setManageSession(true);
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
409
7.4.4 Sitzungs-Management mit Axis2 ...
Beispiel zum Sitzungs-Management
➥ Implementierung des Dienstes:
public class HelloWorldSkeleton {
int cnt = 1; // Zählervariable als (sitzungslokaler) Zustand
public String sayHello(String to) {
return "Hello to " + to + " (" + cnt++ + ")";
}
// Lebenszyklus−Methoden: werden von Axis2 (über Reflection)
// aufgerufen, wenn Session erzeugt bzw. gelöscht wird
public void init(ServiceContext context) { ... }
public void destroy(ServiceContext context) { ... }
}
➥ Deployment-Deskriptor:
<serviceGroup>
<service name="HelloWorld" scope="transportsession">
...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
410
7.4.4 Sitzungs-Management mit Axis2 ...
Beispiel zum Sitzungs-Management ...
➥ Implementierung des Clients:
public class HelloClient {
public static void main(String[] args) throws Exception {
HelloWorldStub stub = new HelloWorldStub();
// Sitzungs-Verfolgung einschalten
stub. getServiceClient().getOptions()
.setManageSession(true);
System.out.println(stub.sayHello("Roland"));
System.out.println(stub.sayHello("Adrian"));
System.out.println(stub.sayHello("Andreas"));
}
}
➥ Vollständiges Beispiel im WWW
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
411
7.4.4 Sitzungs-Management mit Axis2 ...
Sitzungs-Management mit HTTP-Cookies
➥ Eintrag im Deployment-Deskriptor:
<service name="HelloWorld" scope="transportsession">
➥ Axis-Server setzt bei jeder Antwort über HTTP ein Cookie, das
der Client beim nächsten Aufruf zurückschickt
➥ Problem: Interoperabilität
➥ HTTP als Transportprotokoll vorausgesetzt
➥ Nicht-Java-Client kann evtl. Cookie nicht zurücksenden
➥
kein direkter Zugriff auf HTTP-Anfrage
➥ Vorteil: Sitzungen über Dienstgruppen hinweg möglich
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
412
7.4.4 Sitzungs-Management mit Axis2 ...
Ablauf der Kommunikation im Beispiel
Client
POST /axis2/services/HelloWorld HTTP/1.1
...
Server
<?xml . . .
Tomcat
Web−
Server
1
HTTP/1.1 200 OK
...
Set−Cookie: JSESSIONID=66CFAB...; Path=/axis2
...
doPost()
<?xml . . .
Axis2
Servlet
POST /axis2/services/HelloWorld HTTP/1.1
...
Cookie: JSESSIONID=66CFAB...; Path=/axis2
<?xml . . .
2
HelloWorld
HelloWorld
HelloWorld
HTTP/1.1 200 OK
...
<?xml . . .
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
413
7.4.4 Sitzungs-Management mit Axis2 ...
Sitzungs-Management über SOAP-Header
➥ Eintrag im Deployment-Deskriptor:
<service name="HelloWorld" scope="soapsession">
➥ Zusätzlich muß WS-Addressing Modul im Server und im Client
aktiviert sein (Standard bei Axis2)
➥ Handler modifizieren bzw. analysieren den SOAP-Header
➥ Server fügt bei jeder Antwort ServiceGroupId ein
➥ Client sendet diese bei Folgeanfragen zurück
➥ Vorteile:
➥ unabhängig vom Transportprotokoll
➥ Auslesen und Einfügen des SOAP-Headers notfalls per Hand
im Client implementierbar
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
414
7.4.4 Sitzungs-Management mit Axis2 ...
Ablauf der Kommunikation im Beispiel
POST /axis2/services/HelloWorld HTTP/1.1
...
<?xml . . .
Client
1
HTTP/1.1 200 OK
...
<?xml ...><Envelope ...><Header ...>
<wsa:ReplyTo>...<wsa:ReferenceParameters>
<axis2:ServiceGroupId ...>urn:uuid:4DE801025...
...
POST /axis2/services/HelloWorld HTTP/1.1
...
<?xml ...><Envelope ...><Header ...>
<axis2:ServiceGroupId ...>urn:uuid:4DE801025...
...
2
HTTP/1.1 200 OK
...
<?xml ...><Envelope ...><Header ...>
<wsa:ReplyTo>...<wsa:ReferenceParameters>
<axis2:ServiceGroupId ...>urn:uuid:4DE801025...
...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Server
Tomcat
Web−
Server
doPost()
Axis2
Servlet
HelloWorld
HelloWorld
HelloWorld
Client/Server-Programmierung (13/12)
415
7.4 Web Services mit Axis2 ...
7.4.5 Axis2 Module
➥ Bearbeitung von SOAP-Nachrichten in Axis2 ist über Module
erweiterbar
➥ Modul enthält einen oder mehrere Handler
➥ Handler inspizieren bzw. manipulieren SOAP-Nachrichten
➥ Anwendungen z.B.
➥
Sicherheit (WS-Security, Rampart-Modul)
➥ Authentifizierung, Verschlüsselung
➥ Adressierung (WS-Addressing)
➥ Zuverlässige Kommunikation (WS-ReliableMessaging)
➥ Debugging / Monitoring / Logging / Accounting ...
➥ Vorteil: Trennung von Verwaltungs-Aufgaben und Anwendungslogik
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
416
7.4.5 Axis2 Module ...
➥ Module können zur Laufzeit eingebunden (engaged) werden
➥ global
➥ für Dienstgruppen und einzelne Dienste
➥ für einzelne Operationen
➥ Definition über Axis2 Konfigurationsdatei, Deployment-Deskriptor
oder Axis2 Web Admin
➥ $CATALINA BASE/webapps/axis2/WEB-INF/conf/axis2.xml
➥ resources/services.xml
➥ http://localhost:8080/axis2/axis2-admin/
➥ Beim Engagement eines Moduls werden dessen Handler in
definierte Phasen der Nachrichtenverarbeitung eingebunden
➥ Spezifikation über Modul-Deskriptor META INF/module.xml
➥ Phasen sind in Axis2 Konfigurationsdatei festgelegt
Roland Wismüller
Betriebssysteme / verteilte Systeme
417
Client/Server-Programmierung (13/12)
7.4.5 Axis2 Module ...
Handler
Web
Service
SOAP
Message
Receiver
Handler
In Pipe
Transport
Listener
Out Pipe
Transport
Sender
Client−API
Client
Nachrichtenverarbeitung in Axis2
➥ Vier Datenflüsse: InFlow, OutFlow, InFaultFlow, OutFaultFlow
➥ Jeder Datenfluss wird in mehreren Phasen bearbeitet
➥ z.B. Transport, Pre-Dispatch, Dispatch, Message Processing
für InFlow
➥ Jede Phase besteht aus beliebig vielen Handlern
➥ Phasen legen Ausführungsreihenfolge der Handler fest
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
418
Anmerkungen zu Folie 418:
Siehe Axis2 Dokumentation: http://axis.apache.org/axis2/java/core/
docs/Axis2ArchitectureGuide.html#bmSOAPPM
7.4.5 Axis2 Module ...
Beispiel: Hello World mit Logging
➥ Vollständiger Code: siehe WWW
➥ Dienst-Implementierung bleibt unverändert
➥ Aber: Einführung eines Moduls mit Handler für Anfrage- und
Antwort-Nachrichten
➥ LOGHANDLER/logger/LogModule.java
➥
i.w. leere Implementierung der Axis2-Schnittstelle Module
➥ LOGHANDLER/logger/LogHandler.java
➥
gibt SOAP-Nachrichten auf Konsole aus
➥ Parameter im Deployment-Deskriptor gibt Präfix an, das
jeder Ausgabe vorangestellt wird
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
419
7.4.5 Axis2 Module ...
Beispiel: Hello World mit Logging ...
➥ Code des Handlers LOGHANDLER/logger/LogHandler.java:
public class LogHandler extends AbstractHandler {
public InvocationResponse invoke(MessageContext context)
throws AxisFault {
// Parameter aus Deployment−Deskriptor holen
String pre = "";
Parameter p = getParameter("prefix");
if (p != null)
pre = (String)p.getValue();
// SOAP−Nachricht ausgeben
System.out.println(pre + context.getEnvelope());
return InvocationResponse.CONTINUE;
}
}
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
420
7.4.5 Axis2 Module ...
Beispiel: Hello World mit Logging ...
➥ Deployment-Deskriptor des Moduls
(LOGHANDLER/META-INF/module.xml):
<module name="logger" class="logger.LogModule">
<InFlow>
<handler name="InFlowLogHandler" class="logger.LogHandler">
<order phase="loggingPhase" />
<parameter name="prefix">IN: </parameter>
</handler>
</InFlow>
...
➥ Voraussetzung: loggingPhase ist in Axis2 Konfiguration definiert
($CATALINA BASE/webapps/axis2/WEB-INF/conf/axis2.xml):
<phaseOrder type="InFlow">
<phase name="Transport"> ... </phase>
...
<phase name="loggingPhase"/>
...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
421
7.4.5 Axis2 Module ...
Beispiel: Hello World mit Logging ...
➥ Deployment des Moduls: Packen des Deployment-Deskriptors
und der Klassen in ein Archiv logger.mar und Kopie nach
$CATALINA BASE/webapps/axis2/WEB-INF/modules
➥ Engagement des Moduls im Deployment-Deskriptor des Services
(SERVER/resources/services.xml):
➥ für den kompletten Dienst:
...
<service name="HelloWorld">
<module ref="logger"/>
...
➥ für eine spezifische Operation:
...
<operation name="sayHello" mep="http://www.w3..." ...>
<module ref="logger"/>
...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
422
Anmerkungen zu Folie 422:
Das Engagement eines Handlers im Client erfolgt folgendermaßen:
➥ Kopieren des Archivs (im Beispiel logger.mar) in das Verzeichnis
$AXIS2 HOME/repository/modules
➥ ggf. in der Konfigurationsdatei $AXIS2 HOME/conf/axis2.xml die entsprechende
Phase einrichten
➥ Client-Code (im Beispiel) um folgende Anweisung ergänzen:
stub. getServiceClient().engageModule("logger");
Das Deployment-Verzeichnis und die Konfigurationsdatei sind dabei ggf. verschieden
von denen des Axis2-Servlets.
7.4.5 Axis2 Module ...
Anmerkungen zum Beispiel
➥ Handler erbt von org.apache.axis2.handlers.AbstractHandler
und überschreibt invoke(MessageContext context)
➥ Methode getParameter() von AbstractHandler erlaubt
Zugriff auf die im Deployment-Deskriptor gesetzten Parameter
➥ Methoden von org.apache.axis2.context.MessageContext:
➥ getEnvelope(): liefert Objekt-Repräsentation der SOAP
Nachricht
➥ getProperty(String name): liefert Wert einer gegebenen
Property aus MessageContext
➥ getPropertyNames(): liefert Iterator für alle Property-Namen
➥ etliche weitere Verwaltungsmethoden
➥
i.w. undokumentiert ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
423
7 Web Services ...
7.5 Web Services und Sicherheit
➥ Mögliche Maßnahmen zur Absicherung von Web Services:
➥ Nutzung von HTTP über TLS/SSL
➥
Verschlüsselung (⇒ Vertraulichkeit, Integrität)
➥ Authentifizierung des Servers über Zertifikat
➥ Authentifizierung des Clients (durch den Web-Server!)
➥ über Zertifikat möglich
➥ meist aber nur über Name und Paßwort
➥ Nutzung der WS Security Paradigmen
➥
Verschlüsselung von Teilen einer SOAP-Nachricht
➥ digitale Signatur über Teile einer SOAP-Nachricht
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
424
7.5 Web Services und Sicherheit ...
7.5.1 Nutzung von Tomcat6 mit TLS/SSL
➥ Zunächst: Erstellung eines Server-Zertifikats
➥ einfachste Möglichkeit: Verwendung des Java keytools:
➥
keytool -genkey -alias tomcat -keyalg RSA
➥ Key Paßwort und Keystore Paßwort müssen gleich sein!
➥ erzeugt selbstsigniertes Zertifikat (führt zu Warnung im
Web Browser)
➥ i.d.R. muß das Zertifikat von einer Zertifizierungsstelle signiert
werden
➥ dazu: Verwendung der OpenSSL Werkzeuge und
Exportieren des Zertifikats im PKCS12-Format
➥ siehe Dokumentation von Tomcat und OpenSSL
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
425
7.5.1 Nutzung von Tomcat6 mit TLS/SSL ...
➥ Anpassen der Datei $CATALINA_BASE/conf/server.xml:
➥ Einfügen eines <Connector>-Elements für den SSL Port:
<Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true"
maxThreads="150" scheme="https" secure="true"
clientAuth="false" sslProtocol="TLS"
keystoreFile="/home/wismueller/.keystore"
keystorePass="passwd1" />
➥
Vorlage bereits als Kommentar vorhanden
➥ Evtl. Löschen des <Connector>-Elements für den nicht-SSL
Port
➥ Web Services nun über https://host :8443/axis2/...
erreichbar
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
426
7.5 Web Services und Sicherheit ...
7.5.2 Passwort-Authentifizierung mit Tomcat6 und Axis2
➥ Zugriff auf Web-Service in Axis2 einschränken
($CATALINA BASE/webapps/axis2/WEB-INF/web.xml):
<security-constraint>
<web-resource-collection>
<web-resource-name>Axis services</web-resource-name>
<url-pattern>/services/HelloWorld</url-pattern>
</web-resource-collection>
<auth-constraint>
<role-name>manager</role-name>
</auth-constraint>
</security-constraint>
<login-config>
<auth-method>BASIC</auth-method>
<realm-name>Axis Services</realm-name>
</login-config>
<security-role>
<role-name>manager</role-name>
</security-role>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
427
7.5.2 Passwort-Authentifizierung mit Tomcat6 und Axis2 ...
➥ Rolle und Benutzer in Tomcat konfigurieren
($CATALINA BASE/conf/tomcat-users.xml):
<tomcat-users>
<role rolename="manager"/>
<user username="admin" password="s3cret" roles="manager"/>
</tomcat-users>
➥ Bentuzer und Paßwort im Client übergeben:
HelloWorldStub stub = new HelloWorldStub();
HttpTransportProperties.Authenticator auth
= new HttpTransportProperties.Authenticator();
auth.setUsername("admin");
auth.setPassword("s3cret");
auth.setPreemptiveAuthentication(true);
stub._getServiceClient().getOptions()
.setProperty(HTTPConstants.AUTHENTICATE, auth);
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
428
7.5 Web Services und Sicherheit ...
7.5.3 Nutzung der WS Security Paradigmen
➥ Probleme bei Verwendung von HTTP/SSL:
➥ keine Verbindlichkeit (keine digitale Signatur)
➥ Verschlüsselung der gesamten SOAP-Nachricht oft unnötig
➥ keine Ende-zu-Ende-Sicherheit (Verschlüsselung) bei
SOAP-Nachrichten über Zwischenknoten möglch
➥ Lösung: Verschlüsselung / Signierung von Teilen der SOAPNachricht mittels XML Encryption bzw. XML Signature
➥ WS Security ist ein Standard, der u.a. festlegt, wie
➥ kryptographische Information (z.B. Schlüssel, Zertifikate,
digitale Signaturen)
➥ Authentifizierungsinformation (z.B. Benutzername/Paßwort)
im SOAP-Header abgelegt werden
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
429
7.5.3 Nutzung der WS Security Paradigmen ...
Verschlüsselung von SOAP-Nachrichten
➥ Basis: XML Encryption, erlaubt die Verschlüsselung verschiedener Teile eines XML-Dokuments:
➥ das komplette XML-Dokument,
➥ einzelne Elemente mit ihren Unterelementen
➥ oder nur der Inhalt einzelner Elemente
➥ Verschlüsselte Teile werden durch <EncryptedData>-Elemente
ersetzt
➥ mögliche Unterelemente u.a. für Name des Verschlüsselungs-
algorithmus, Schlüsselinformation, Chiffretext
➥ SOAP-Header enthält Referenzen auf alle verschlüsselten Teile
des Body
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
430
7.5.3 Nutzung der WS Security Paradigmen ...
Beispiel für eine verschlüsselte SOAP-Nachricht
<env:Envelope xmlns:env="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:wsse="http://docs.oasis−open.org/wss/2004/01/oasis−200401−
wss−wssecurity−secext−1.0.xsd"
xmlns:ds="http://www.w3.org/2000/09/xmldsig#"
xmlns:xenc="http://www.w3.org/2001/04/xmlenc#">
<env:Header>
<wsse:Security>
Security−Header−Block
<xenc:ReferenceList>
zeigt an, daß Inhalt
<xenc:DataReference URI="#bodyID"/> des SOAP−Bodies
</xenc:ReferenceList>
verschlüsselt ist
</wsse:Security>
</env:Header>
Verschlüsselter Element−Inhalt
<env:Body>
<xenc:EncryptedData Id="bodyID">
<ds:KeyInfo>
<ds:KeyName>CN=Ali Baba, C=DE</ds:KeyName> Schlüsselname
</ds:KeyInfo>
<xenc:EncryptionMethod Algorithm="..."/> Verschlüsselungsalgorithmus
<xenc:CipherData>
<xenc:CipherValue>39kDeFAl...</xenc:CipherValue> Chiffretext
</xenc:CipherData>
</xenc:EncryptedData>
</env:Body>
</env:Envelope>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
431
7.5.3 Nutzung der WS Security Paradigmen ...
Signierung von SOAP-Nachrichten
➥ Basis: XML Signature, erlaubt das (gemeinsame) Signieren verschiedener Teile eines XML-Dokuments
➥ Signatur-Element wird in SOAP-Header eingebettet und verweist
auf signierte Elemente im Body
➥ Body bleibt unverändert, d.h. SOAP-Knoten können digitale
Signatur auch ignorieren
➥ Signatur-Element enthält u.a.:
➥ Referenz auf die signierte Information
➥ Angabe der verwendeten Algorithmen
➥ Zertifikat, einschließlich des öffentlichen Schlüssels
➥ die digitale Signatur selbst
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
432
7.5.3 Nutzung der WS Security Paradigmen ...
Beispiel für eine signierte SOAP-Nachricht
<env:Envelope ...>
<env:Header>
<wsse:Security>
X509−Zertifikat, binär, Base64−codiert
<wsse:BinarySecurityToken ValueType="...#X509v3"
EncodingType="...#Base64Binary" wsu:Id="X509Token">
MIIEZzCCA9CgAwIBA...
</wsse:BinarySecurityToken>
<ds:Signature>
<ds:SignedInfo>
<ds:CanonicalizationMethod Algorithm="..."/>
<ds:SignatureMethod Algorithm= ".../xmldsig#rsa−sha1"/>
<ds:Reference URI="#myBody">
Referenz auf signiertes
<ds:Transforms>
Element
<ds:Transform Algorithm="..."/>
</ds:Transforms>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
433
7.5.3 Nutzung der WS Security Paradigmen ...
Beispiel für eine signierte SOAP-Nachricht ...
<ds:DigestMethod Algorithm=".../xmldsig#sha1"/>
<ds:DigestValue>EULddytSo1...</ds:DigestValue>
</ds:Reference>
Hashwert für dieses Element
</ds:SignedInfo>
<ds:SignatureValue>BL8jdfTPOV...</ds:SignatureValue>
<ds:KeyInfo>
Signatur für dieses Element
<wsse:SecurityTokenReference>
<wsse:Reference URI="#X509Token"/> Angaben zum Signatur−
</wsse:SecurityTokenReference>
schlüssel (Verweis auf
</ds:KeyInfo>
obiges Zertifikat)
</ds:Signature>
</wsse:Security>
</env:Header>
<env:Body wsu:Id="myBody">
<tru:StockSymbol xmlns:...">IBM</tru:StockSymbol>
</env:Body>
</env:Envelope>
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
434
7.5.3 Nutzung der WS Security Paradigmen ...
Praktische Nutzung von WS Security mit Axis2
➥ Erweiterungs-Modul Rampart
➥ Definiert Axis2 Handler, die ein- und ausgehende SOAP-Nachrichten bearbeiten
➥ Ver- bzw. Entschlüsselung von Elementen
➥ Erzeugung bzw. Prüfung von Signaturen
➥ Rampart nutzt dazu die Bibliotheken der Apache-Projekte
➥ WSS4J (WS Security )
➥ XML Security (XML Encryption und XML Signature)
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
435
7 Web Services ...
7.6 Zusammenfassung
➥ Grundlage von Web Services: RPC-Mechanismus
➥ XML-basiertes Kommunikationsprotokoll: SOAP
➥ WSDL als IDL, definiert zusätzlich Adresse des Dienstes
➥ kein verteiltes Objektmodell
➥ unabhängig von Plattform, Implementierungssprache und
Transportprotokoll
➥ Axis2 als verbreitetes Web Service Framework
➥ automatische Erzeugung von WSDL-Dokumenten und
Client-Stubs
➥ Axis2 Handler erlauben direkten Zugriff auf SOAP-Nachrichten
➥
z.B. für Logging, Accounting, Sitzungsverwaltung,
Verschlüsselung und Signierung, ...
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
436
Client/Server-Programmierung
WS 2013/2014
8
Weitere Client/Server-Technologien
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
437
8 Weitere Client/Server-Technologien ...
8.1 Technologien zur Netzwerkprogrammierung
➥ Sockets: plattform- und netzwerkunabhängiges KommunikationsAPI (Basis jeglicher Client/Server-Kommunikation)
➥ Socket = Abstraktion für Kommunikations-Endpunkt
➥ Datagramm- und Stream-Sockets
➥
bei Verwendung der IP-Protokolle: direkte Kommunikation
über UDP bzw. TCP
➥ Java bietet vereinfachtes API zur Socket-Kommunikation
➥ Literatur:
➥
Folien-Skript ”Rechnernetze II”, Kap. 8.1
➥ W.R. Stevens: Programmieren von UNIX-Netzen, Hanser /
Prentice Hall, 1992.
➥ T. Langner: Verteilte Anwendungen mit Java, Markt + Technik, 2002. Kap. 3
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
438
8.1 Technologien zur Netzwerkprogrammierung ...
➥ Sun RPC: einfache RPC-Implementierung
➥ einfache IDL, Bindung i.W. nur für C
➥ sehr eingeschränkt (z.B. nur ein Parameter pro Prozedur)
➥ Literatur:
➥
Folien-Skript Rechnernetze II“ (WS 08/09), Kap. 9.2
”
➥ W.R. Stevens: Programmieren von UNIX-Netzen, Hanser /
Prentice Hall, 1992.
➥ DCE RPC: Weiterentwicklung, Basis von Microsoft DCOM
➥ IDL mit Bindung an verschiedene Programmiersprachen
➥ Schnittstellen an Objekte statt Maschinen gebunden
➥ weltweit eindeutige ID (UUID) für jede Schnittstelle
➥ Literatur: A. Tanenbaum, M. van Steen: Verteilte Systeme,
Pearson Studium, 2003, Kap. 2.2
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
439
8 Weitere Client/Server-Technologien ...
8.2 Technologien für dynamische WWW-Seiten
➥ CGI-Skripten (Common Gateway Interface)
➥ ausführbare Programme (in beliebigen Sprachen) werden
beim Web-Server für bestimmte URLs registriert
➥ bei Aufruf der URL startet Web-Server das CGI-Programm als
eigenen Prozeß
➥
Standard-Eingabe: Rumpf der HTTP-Anfrage
➥ d.h. Anfrage-Parameter bei POST-Methode
➥ Standard-Ausgabe: Rumpf der HTTP-Antwort
➥ Zusätzliche Information durch Umgebungsvariablen, z.B.
QUERY_STRING: Parameterstring in der URL nach dem ?
➥ Vorläufer von Servlets
➥ Literatur: Orfali/Harkey, Kap. 11
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
440
8.2 Technologien für dynamische WWW-Seiten ...
➥ PHP (PHP: Hypertext Preprocessor )
➥ Skript-Sprache, in HTML-Dokumente eingebettet
➥
innerhalb von Tags <?php ... ?>
➥ ab PHP 4 mit objektorientierten Konzepten
➥ ähnlich zu JSP, aber interpretierte Abarbeitung
➥ Literatur: http://www.php.net/
➥ ASP (Active Server Pages)
➥ Integration verschiedener Skript-Sprachen (u.a. VB Script,
JScript) in HTML-Dokumente
➥ innerhalb von Tags <% ... %> (Vorbild für JSP)
➥ ASP zunächst interpretiert, bei ASP.NET Vorkompilation des
Codes analog zu JSP
➥ Literatur: http://www.asp.net/
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
441
8 Weitere Client/Server-Technologien ...
8.3 Microsoft .Net und DCOM
➥ Konkurrenz / Analogie zu J2EE von Sun
➥ Das .Net-Framework definiert:
➥ einheitliche Laufzeitumgebung für alle Microsoft-Sprachen
(z.B. Visual Basic, Visual C++, C#)
➥ einheitliche Zwischensprache (CIL) mit JIT-Übersetzung
➥ einheitliches Typsystem, Garbage Collection, Threads,
Sandboxing, Ausnahmen ...
➥ gemeinsame Klassenbibliothek (etwa analog zu J2EE)
➥ u.a. Realisierung von ASP.Net und ADO.Net (Datenbank-Zugriff, vergleichbar zu JDBC)
➥ Zusätzlich: Komponentenmodell COM+
➥ DCOM mit MS Transaction und Message Queue Server
➥ Kommunikation: u.a. DCOM, .Net-Remoting, Web Services
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
442
8.3 Microsoft .Net und DCOM ...
COM / DCOM (Distributed Component Object Model)
➥ Sprachunabhängiges Komponentenmodell
➥ COM-Schnittstelle:
➥ binäres API einer Komponente (Array von Funktionszeigern)
➥ identifiziert durch GUID (Globally Unique Identifier )
➥
identisch mit UUID von DCE-RPC
➥ beschrieben in DCOM IDL
➥ unveränderbar, ggf. muß neue Schnittstelle erzeugt werden
➥ COM-Objekt:
➥ Instanz einer Komponente
➥ implementiert eine oder mehrere COM-Schnittstellen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
443
8.3 Microsoft .Net und DCOM ...
COM / DCOM (Distributed Component Object Model) ...
➥ Die Schnittstelle IUnknown:
➥ muß von jeder COM-Schnittstelle geerbt werden
➥ definiert die Methoden
➥
QueryInterface(): liefert zu einer über die GUID
gegebene Schnittstelle den Zeiger auf diese Schnittstelle
zurück
➥
➥
bzw. Fehler, falls Schnittstelle nicht unterstützt wird
AddRef() / Release(): Referenz-Zähler
➥ Für jede COM-Komponente muß eine Factory realisiert werden
➥ u.a. Methode CreateInstance() zur Erzeugung neuer
Komponenten-Instanzen
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
444
8.3 Microsoft .Net und DCOM ...
COM / DCOM (Distributed Component Object Model) ...
COM−Objekt
Client
Schnittstellen−
Zeiger
Interner Zeiger auf
Methoden−Tabelle
Zeiger auf Methode 1
Zeiger auf Methode 2
Zeiger auf Methode 3
QueryInterface() { ... }
AddRef() { ... }
Release() { ... }
"geerbt" von
IUnknown
➥ Aufbau einer COM-Schnittstelle:
sayHello() { ... }
Zeiger auf Methode 4
Zeiger auf Methode 5
Methoden−Tabelle
Roland Wismüller
Betriebssysteme / verteilte Systeme
sayGoodby() { ... }
Methoden−Code
Client/Server-Programmierung (13/12)
445
8.3 Microsoft .Net und DCOM ...
COM / DCOM (Distributed Component Object Model) ...
➥ COM-Server: ”Verpackungseinheit” von COM-Komponenten
➥ DLL, ausführbare Datei (*.exe), Java-Klasse, ...
➥ enthält Code einer / mehrerer Komponenten, Factories,
Registrierungs- und Verwaltungsinformation
➥ COM-Server kann lokalisiert sein:
➥ im lokalen Prozeß (realisiert als DLL)
➥ in eigenem Prozeß auf dem lokalen Rechner (COM-Server ist
ausführbares Programm)
➥ in eigenem Prozeß auf entferntem Rechner (bei DCOM)
➥
auch Remote-Instantiierung möglich
➥ DCOM realisiert Zugriffs- und Ortstransparenz
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
446
8.3 Microsoft .Net und DCOM ...
Unterschiede zw. COM-Objekten und üblichen Objekten
➥ In COM existiert keine Objekt-ID
➥ COM-Client erhält Referenz auf eine (zustandslose) Schnitt-
stelle, nicht auf ein Objekt
➥ Client kann sich nicht mit bestimmter Instanz einer Kompo-
nente verbinden (Problem, falls Instanz Zustand hat)
➥ Abhilfe durch COM Monikers
➥ In COM gibt es keine Mehrfach-Vererbung von Schnittstellen
➥ stattdessen: Komponente bietet mehrere Schnittstellen
➥ Wiederverwendung von Komponenten durch
➥ Containment/Delegation: Weitergabe von Aufrufen
➥ Aggregation: QueryInterface() gibt Schnittstellen der
inneren Objekte nach außen bekannt
Roland Wismüller
Betriebssysteme / verteilte Systeme
447
Client/Server-Programmierung (13/12)
8.3 Microsoft .Net und DCOM ...
Containment/Delegation und Aggregation
Containment/Delegation:
Aggregation:
IUnknown
A
Äußeres Objekt A
IUnknown
A
Äußeres Objekt A
B
B
B
B
C
C
C
C
QueryInterface() gibt Schnittstel−
len des äußeren Objekts zurück.
Implementierung von A gibt
Aufrufe an B bzw. C weiter.
Roland Wismüller
Betriebssysteme / verteilte Systeme
QueryInterface() gibt Schnittstel−
le A des äußeren und Schnitt−
stellen B und C der inneren
Objekte zurück.
Client/Server-Programmierung (13/12)
448
8.3 Microsoft .Net und DCOM ...
➥ Literatur:
➥ Hammerschall, Kap. 10
➥ Orfali / Harkey, Kap. 15
➥ Hofmann / Jobst / Schabenberger, Kap. 3 und 4
➥ http://www.microsoft.com/com/
Roland Wismüller
Betriebssysteme / verteilte Systeme
Client/Server-Programmierung (13/12)
449

Client/Server-Programmierung - Betriebssysteme und verteilte

Zugehörige Unterlagen

Produkte

Unterstützung

Client/Server-Programmierung - Betriebssysteme und verteilte

Zugehörige Unterlagen

Dieses Dokument Sammlung (en)

Dieses Dokument gespeichert

Schlagen Sie uns vor, wie wir StudyLib verbessern können