1. Auflage 2013

Alle Rechte, auch für die Übersetzung, vorbehalten. Kein Teil des Werkes darf in irgendeiner Form (Druck, Fotokopie, Mikrofilm oder einem anderen Verfahren) ohne schriftliche Genehmigung des Verlages reproduziert, vervielfältigt oder verbreitet werden.

Alle technischen Angaben und Programme in diesem Buch wurden vom Autor mit größter Sorgfalt erarbeitet bzw. zusammengestellt. Trotzdem sind Fehler nicht ganz auszuschließen. Verlag und Autor übernehmen keine Gewähr für die Funktion einzelner Programme oder Teile derselben. Insbesondere wird keinerlei Haftung übernommen für eventuelle aus dem Gebrauch resultierende Folgeschäden.

Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenzeichen usw. in diesem Werk berechtigen auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutzgesetzgebung als frei zu betrachten wären und daher von jedermann benutzt werden dürften.

Da es nicht möglich ist, in allen Fällen zeitnah zu ermitteln, ob ein Markenschutz besteht, wird das ®-Symbol in diesem Buch nicht verwendet.

Impressum:

Web Services mit Apache CXF
Axel Eberhard Leistner
published by: epubli GmbH, Berlin
www.epubli.de
Copyright: © 2013 Axel Eberhard Leistner
ISBN 978-3-8442-5250-7

Inhaltsverzeichnis

Vorwort 5

Web Service Tutorium - Erstellung eines Gästebuchs 6

Service-Projekt erstellen. 14

XSD: Gästebuch-Schema erstellen. 16

WSDL: Gästebuch-Service-Schnittstelle erstellen. 22

Generierung der Java-Klassen. 32

Service: Implementierung des Gästebuch-Web Services 53

Implementierung des Gästebuch-Clients 60

Grundlagen für das Verständnis eines Web Services 94

Die XSD – Typen-Entwicklung in XML. 94

Die WSDL – Aufbau eines SOAP Services 101

Apache CXF – automatische Erstellung eines Web Services 109

Servlets - Die Grundlagen. 125

Servlet-Container 125

Packages 126

Häufig verwendete Interfaces und Klassen. 127

HTTP-Grundlagen. 130

Aufbau der URLs 131

HTTP-Methoden. 131

Wichtige HTTP-Statuscodes 133

JSP – Grundlagen. 136

Die Syntax von JSPs und ihre Bestandteile. 137

Implizite Objekte. 141

Client-Anfragen. 147

Beans in JSPs 149

JSP-Standardaktionen. 154

Fehler- und Ausnahmebehandlung. 157

Expression Language. 160

Java Standard Tag Library (JSTL) 164

Internationalisierung. 165

Servlet-Filter 167

Abbildungsverzeichnis 170

Vorwort

Web Services begegnen uns öfter als wir vermuten. Meist verbergen sie sich hinter anderen Begriffen wie „App“ oder „Cloud“. Wie man das Kind auch letztlich nennt: Es geht hier immer darum, dass ein Server, der aus dem Internet leicht erreichbar ist, einen Dienst bereitstellt, der von Clients genutzt werden kann. Diese Clients sind oft erkennbar als „Webbrowser“ oder aber Anwendungen, die im Internet Anfragen stellen können und auf eine Antwort warten.

Ziel dieses Buches ist es zu zeigen, was hinter einem Web Service steckt. Wir wollen mit einfachen Mitteln einen Service aufbauen, der auf einem Application Server wie Tomcat laufen kann. Dann wollen wir verschiedene Clients ausprobieren, um den Service zu testen.

Da es uns nicht darum geht, eine besonders interessante Spezialanwendung zu entwickeln, haben wir uns entschieden, das gute alte Beispiel eines Gästebuches neu zu beleben. Das hat einfache Gründe. Alles, was wir brauchen, um einen Dienst mit Eingaben über ein Formular und Ausgaben auf einem Bildschirm zu entwickeln, lässt sich hier leicht darstellen. Und unser Ziel ist letztlich nicht das Gästebuch, sondern die Kenntnis über den Bau eines Web Services.

Nach dem zügigen Aufbau von Server- und Client-Programmen schauen wir uns die Theorie an, die hinter dem Ganzen steckt. Die Beleuchtung des Hintergrundes nimmt dabei den größten Teil des Buches ein.

Mit dem Gesamtverständnis, das dieses Buch vermitteln will, kann der interessierte Leser schnell selbst einen Web Service programmieren. Dabei ist es egal, ob er eine Suchmaschine im Internet anbieten will, einen neuen Webshop oder eine App für Smartphone – mit den passenden Tools und genauer Planung des Services sollte das sofort gelingen.

Web Service Tutorium - Erstellung eines Gästebuchs

Dieses Tutorium beschreibt, wie ein Gästebuch als Web Service erstellt wird. Dabei verwenden wir die Werkzeuge Eclipse, Apache CXF und Apache Tomcat 7.0. Zunächst bauen wir einen Dienst auf dem Server auf. Zum Test der Funktionsweise des Gästebuch-Web-Services entwickeln wir dann eine Java-Client-Applikation, die den Web Service benutzt. Wir verfolgen den sogenannten Top-Down-Ansatz (WSDL-to-Java). Dabei wird zuerst die Service-Schnittstelle festgelegt und anschließend auf Basis dieser Schnittstelle die Service-Implementierung angelegt.

Dieses Tutorium setzt voraus, dass die Java JDK (hier: jdk1.7.0_17-64bit) und Eclipse (hier: eclipse-4.3“ aus eclipse-jee-kepler-M5-win32-x86_64) installiert ist, und dass weiterhin Eclipse korrekt mit Tomcat (hier: apache-tomcat-7.0.37-64bit) verbunden wurde. Dazu nehmen wir eine Basiskonfiguration innerhalb von Eclipse vor.

Eclipse bietet die Möglichkeit Zeilennummern für Quellentexte auszugeben. Wir wählen im Eclipse-Menü Window -> Preferences -> General -> Editors -> Text Editors aus und setzen den Haken beim Parameter Show line numbers. Drücken Sie dann auf den Schalter Apply am Ende des Fensters.

Abbildung 1: Editor in Eclipse konfigurieren - Zeilennummern

Eclipse hat bereits eine Java-Umgebung als Standardumgebung eingetragen. Wir wollen aber die von uns installierte JDK 1.7.0 Version 17 verwenden. Dazu legen wir nun eine neue Java JRE in Eclipse an: Wir wählen im Eclipse-Menü die Kombination Window -> Preferences -> Java -> Installed JREs aus. Drücken Sie auf den Schalter Add… (Abbildung 2) und danach im folgenden Fenster auf Standard VM und Next. Wählen Sie mit Hilfe des Schalters Directory… eine JRE-Home aus und jetzt klicken Sie auf den Schalter Finish (Abbildung 3).

Abbildung 2: Neue JRE einfügen

Abbildung 3: JRE-Umgebung auswählen

Aktivieren Sie das Feld neben dem Namen der zu verwendenden JDK-Version (Abbildung 4). Klicken Sie dann auf den OK-Schalter, um diese Einstellung bereits zu speichern. Vergessen Sie außerdem nicht, die Umgebungsvariable JAVA_HOME in den Systemeinstellungen zu setzen.

Abbildung 4: Installierte JRE in Eclipse auswählen

Wir drücken im Eclipse-Menü Window -> Preferences -> Server -> Runtime Environment den Schalter Add..., um die Tomcat-Umgebung einfügen zu können (Abbildung 5). Wählen Sie Server Apache -> Apache Tomcat 7.0. Klicken Sie auf Next (Abbildung 6).

Abbildung 5: Server Runtime Environments in Eclipse konfigurieren

Abbildung 6: Apache Tomcat v7.0 auswählen

Geben Sie das Tomcat- Installationsverzeichnis ein sowie die JRE-Umgebung. Klicken Sie dann auf den Schalter Finish (Abbildung 7). Damit ist in Eclipse die Tomcat-Umgebung spezifiziert (Abbildung 8). Setzen Sie unbedingt für Tomcat auch die Umgebungsvariable CATALINA_HOME in den Systemeinstellungen.

Abbildung 7: Tomcat- Installationsverzeichnis und JRE-Umgebung konfigurieren

Abbildung 8: Tomcat-Konfiguration in Eclipse

Nun wird noch das Werkzeug für die Erstellung des Web Services benötigt. Laden Sie Apache CXF 2.x aus dem Internet herunter. Danach entpacken Sie das Archiv (apache-cxf-2.7.2.zip oder eine neuere Version). Merken Sie sich unbedingt das Installationsverzeichnis. Setzen Sie auch die Umgebungsvariable CXF_HOME auf das Root-Verzeichnis der CXF-Installation.

Abbildung 9: CXF 2.x Preferences in Eclipse konfigurieren

Wir wählen im Eclipse-Menü Window -> Preferences -> Web Services -> CXF 2.x Preferences -> Add... aus (Abbildung 9). Geben Sie das Apache CXF-Installationsverzeichnis ein und jetzt klicken Sie auf den Schalter Finish. Wenn Sie die Umgebungsvariable CXF_HOME korrekt eingegeben haben, dann findet Eclipse die Version und den Type selbständig (Abbildung 10).

Abbildung 10: CXF- Installationsverzeichnis und Version konfigurieren

Aktivieren Sie das Kontrollfeld der Version des Apache CXF und klicken Sie auf Apply am Ende des Unterfensters (Abbildung 11).

Abbildung 11: CXF 2.x Preferences in Eclipse bestätigen

Die Konfiguration Java2WS ist zur Erstellung der WSDL-Datei gedacht, wenn man zuerst den Java-Code erstellt. Hier aktivieren wir die Schalter Generate Client und Generate Server (Abbildung 12).

Abbildung 12: Konfiguration für Java2WS

Für unsere Zwecke benötigen wir die Konfiguration WSDL2Java (Abbildung 13). Außerdem aktivieren wir die ersten fünf Schalter im Reiter JAX-WS zur JAX-WS Annotation Generation (Abbildung 14).

Abbildung 13: Konfiguration für WSDL2Java

Abbildung 14: Konfiguration für JAX-WS

Jetzt bereiten wir die Tools für den Einsatz in Eclipse vor. Wählen Sie dazu im Menü die Kombination mit der Folge Window -> Preferences -> Web Services -> Server and Runtime aus (Abbildung 15). Wählen Sie die Tomcat- sowie die Apache CXF-Umgebung in den beiden Auswahlfeldern aus, klicken Sie auf den Schalter Apply und danach auf den Schalter OK.

Abbildung 15: Tomcat-Server und CXF-Umgebung in Eclipse setzen

Öffnen Sie die Ansicht Servers im Eclipse-Menü mit der Kombination Window -> Show View -> Servers (Abbildung 16). Dann legen Sie einen neuen Server in dieser Server-View an. Klicken Sie in der View die rechte Maustaste an und wählen Sie New -> Server aus. Wählen Sie den Apache Tomcat v7.0 Server aus und jetzt klicken Sie auf den Schalter Finish.

Abbildung 16: Server in Eclipse aktivieren

Damit sind alle vorbereitenden Konfigurationen in Eclipse abgeschlossen.

Service-Projekt erstellen

Die Erstellung eines Projektes beginnt in Eclipse mit der Auswahl und Einrichtung eines speziellen Projektes. Hierfür hat Eclipse einige Varianten zur Auswahl.

Erstellen Sie in Eclipse ein Web-Projekt. Dazu wählen Sie im Kontext-Menü der Projektansicht die Kombination File -> New -> Project... und danach die Kombination Web -> Dynamic Web Project (Abbildung 17). Klicken Sie auf den Schalter Next.

Abbildung 17: Neues Projekt anlegen

Wir wollen den Service GuestBookService nennen. Die Target Runtime sollte bereits auf Apache Tomcat v7.0 stehen. Klicken Sie auf den Schalter Finish.

Nun kann die eigentliche Arbeit losgehen. In den folgenden Unterkapiteln wollen wir die Datentypen definieren und unseren Web Service spezifizieren. Im Anschluss daran lassen wir Eclipse den Quellcode generieren und passen diesen im Nachgang an unsere Anforderungen an.

Abbildung 18: Dynamic Web Projekt einrichten

XSD: Gästebuch-Schema erstellen

Für die XML-Dateien benötigen wir einen eigenen Ordner im Projektverzeichnis. Wählen Sie also im Kontextmenü der Projektansicht New -> Folder. Geben Sie den Ordnernamen als xml ein und klicken Sie auf den Schalter Finish (Abbildung 19). Im XML-Verzeichnis wollen wir unser XML-Schema ablegen. Wählen Sie aus dem Kontextmenü dieses XML-Ordners heraus die Kombination New -> Other… -> XML -> XML Schema File. Klicken Sie jetzt auf den Schalter Next (Abbildung 20).

Abbildung 19: Ordner für XML-Dateien anlegen

Abbildung 20: XML-Schema-Datei anlegen

Wir wollen unser Schema GuestBook.xsd nennen (Abbildung 21).

Abbildung 21: XML-Schema mit Namen GuestBook.xsd definieren

Abbildung 22: XML- Schema-Namespace verändern

Ändern Sie den Schema-Namespace mit Rechtsklick über dem Schema und Klick auf Show properties (Abbildung 22):

Abbildung 23: Schema-Namespace eingeben

Wir wollen nun ein Gästebuch-Schema-Typ namens GuestBookType erstellen, dazu klicken wir mit der rechten Maustaste über Types und wählen Add Complex Type aus.

Abbildung 24: Erstellen eines Gästebuch-Schema-Typs

Auf den neu erstellten Typ klicken wir doppelt und fügen dann ein Gästebucheintrag-Element zu diesem Gästebuch-Typ hinzu, indem wir mit der rechten Maustaste auf GuestBookType klicken und danach Add Element anklicken. Das Element soll nun den Namen entry erhalten.

Abbildung 25: Gästebucheintrag-Element hinzufügen

Erstellen Sie einen neuen Schema-Typ mit dem Namen GuestBookEntryType, klicken Sie dazu zunächst mit der rechten Maustaste und dann durch die Kombination string -> Set Type -> New... (Abbildung 26).

Abbildung 26: Neuen Schema-Type definieren

Fügen Sie dem GuestBookEntryType ein Attribut mit dem Namen ID (mittels Add Attribute) und Elemente (mittels Add Element) mit den Namen name, eMail und message hinzu.

Abbildung 27: Name des neuen Schema-Typs eingeben

Abbildung 28: Attribut und Elemente eintragen

Abbildung 29: Definitionen des Schema-Typs

Die Multiplizität des Gästebuch-Typs stellen Sie nun auf 0..* (Zero or more).

Abbildung 30: Multiplizität eingeben

Speichern Sie jetzt das Schema, wechseln Sie in die Übersicht (Kreis in Abbildung 31) und speichern Sie die Konfiguration des GuestBook.xsd ab.

Abbildung 31: Schema verlassen und anschließend speichern

Damit haben wir ein XSD-Schema eingerichtet, mit dem wir später in der WSDL arbeiten wollen.

Abbildung 32: Das fertige GuestBook.xsd Schema

Das Schema GuestBook.xsd hat damit folgendes Aussehen:

WSDL: Gästebuch-Service-Schnittstelle erstellen

Im XML-Ordner erstellen wir eine neue WSDL. Wählen Sie im Menü des XML-Ordners die Kombination New -> Other... -> Web Services -> WSDL File. Klicken Sie auf den Schalter Next (Abbildung 33). Geben Sie der WSDL-Datei den Namen GuestBook.wsdl (Abbildung 34).

Abbildung 33: WSDL-Datei anlegen

Klicken Sie auf Next (Abbildung 34).

Ändern Sie den Target Namespace zu

Alle anderen Einstellungen bleiben unverändert. Klicken Sie auf Finish.

Abbildung 34: Name der WSDL-Datei festlegen

Abbildung 35: Target Namespace angeben

Führen Sie auf den Port einen Rechtsklick aus und danach wählen Sie Show properties. Dadurch öffnen Sie die Properties-View (Abbildung 36). Die Port-Adresse des Service ändern Sie auf

(Abbildung 37). Unter dieser URL kann der Service später angesprochen werden.

Abbildung 36: Eigenschaften-Sicht öffnen

Abbildung 37: Port-Adresse ändern

Die Operationen getEntries und insertEntry stellen Sie mit einem Rechtsklick auf den portType GuestBook (Abbildung 38) und durch Verwendung von Add Operation bzw. durch Umbenennen der vorhandenen Operation dar.

Abbildung 38: Service-Operationen definieren

Entfernen Sie zur Operation insertEntry die Output-Nachricht. Dazu klicken Sie zunächst auf den Pfeil rechts zum dem Eintrag output (Abbildung 39).

Abbildung 39: Eintrag output von insertEntry auswählen durch Klick auf Pfeil

Löschen Sie insertEntryResponseType und insertEntryResponse durch Klick auf den Schalter Delete (Abbildung 40 und Abbildung 41).

Abbildung 40: Eintrag insertEntryResponseType löschen

Abbildung 41: Eintrag insertEntryResponse löschen

Speichern Sie jetzt die Änderungen. Schließen Sie danach den Inline Schema Editor. Löschen Sie nun den Eintrag output im GuestBook-Schema durch Klick auf den Schalter Delete (Abbildung 42).

Abbildung 42: Eintrag output löschen

Nun öffnen wir über die Output-Nachricht der Operation getEntries des getEntriesResponse-Elements den Inline Schema Editor. Klicken Sie dazu auf den Pfeil rechts zur Operation (Abbildung 43).

Abbildung 43: Wechsel zum Inline Schema Editor

Suchen Sie in der Design-Übersicht den GuestBookType-Schema-Typ aus unserer XSD, indem Sie auf die Kombination Set Type -> Browse... klicken (Abbildung 44). Klicken Sie auf den Schalter Enclosing Project, damit im gesamten Projekt nach den passenden Schema-Definitionen gesucht wird (Abbildung 45). Damit wird sofort unser Gästebuch-Typ aus unserer XSD-Datei gefunden. Aktivieren Sie diesen Typ mit Klick auf den Schalter OK. Nun speichern wir unsere Änderungen und schließen den Inline-Editor.

Abbildung 44: GuestBook-Schema-Typ suchen

Abbildung 45: Gästebuch-Typ aus der XSD auswählen

Damit haben wir den Typ des getEntriesResponse auf den Wert GuestBookType aus unserer XSD gesetzt.

Abbildung 46: Geänderter GuestBookType

Wechseln Sie wieder zum Inline Schema Editor. Nun bearbeiten Sie das Element insertEntry der Input-Nachricht zur Operation insertEntry. Aktivieren Sie den GuestBookEntryType (Abbildung 47).

Abbildung 47: Gästebucheintrag-Typ aus der XSD auswählen

Speichern Sie jetzt wieder die Änderungen und schließen Sie danach den Inline Schema Editor.

Abbildung 48: Zurück aus dem Editor

Wechseln Sie zum Inline Schema Editor des Elements getEntries und löschen Sie den getEntriesType (Abbildung 49).

Abbildung 49: getEntriesType löschen

Im Source-Fenster löschen Sie den wsdl-message Eintrag „insertEntryResponse“ (Abbildung 50).

Abbildung 50: wsdl-message "insertEntryResponse" löschen

Aktualisieren Sie das Binding mit Rechtsklick auf das zugehörige Symbol und wählen Sie Generate Binding Content... aus (Abbildung 51). Dort wählen Sie nun Overwrite existing binding information und klicken anschließend auf den Schalter Finish (Abbildung 52).

Abbildung 51: Binding-Content erzeugen

Abbildung 52: Bestehende Binding-Informationen sollen überschrieben werden

Damit ist die Schnittstelle definiert:

Generierung der Java-Klassen

Nun kann Eclipse für uns automatisch Schema-Klassen, Service-Interface und Client-Stubs generieren. Klicken Sie im Verzeichnisbaum unterhalb xml zuerst einmal auf die WSDL-Datei GuestBook.wsdl. Mit Rechtsklick wählen Sie dann New -> Other... -> Web Services -> Web Service aus (Abbildung 53).

Abbildung 53: Aus der WSDL heraus einen Web Service anlegen

Wir wählen als Web service type den Top-Down-Ansatz, um aus einer WSDL den Java-Code zu erstellen. Die Service definition ist dabei unsere gerade erstellte WSDL-Datei unter dem Namen /GuestBookService/xml/GuestBook.wsdl.

In der Konfiguration sehen wir bereits den zu Beginn eingerichteten Server Tomcat 7.0 und das Werkzeug Apache CXF 2.x sowie das Service project mit dem Namen GuestBookService (Abbildung 54).

Abbildung 54: Top-Down Erstellung der Web Service Quellendateien

Damit wir den Dienst gleich testen können, legen wir hier auch einen Client an. Dabei werden alle notwendigen Projektdateien für einen Java-Client erstellt. Ziehen Sie dazu den Regler am linken Rand der Client-Konfiguration bis ganz nach oben. Klicken Sie zusätzlich den Schalter Monitor the web service an, um die Ergebnisse auch in einem TCP/IP-Monitor überprüfen zu können.

Klicken Sie dann dreimal auf den Schalter Next. Klicken Sie im danach geöffneten Fenster auf den Schalter Start Server und dann auf Finish.

Nachdem alle Dateien erstellt und übersetzt wurden, sehen Sie eine Darstellung des Web Service Explorer, von dem aus die Anwendung sofort getestet werden kann (Abbildung 55). Im Fenster Actions sehen Sie die eingerichteten Operations mit den Namen getEntries und insertEntry. Diese Operationen können Sie im Navigator unterhalb der GuestBookSOAP aufklappen und danach im Actions Fenster die Eingaben zum Test der Anwendungen eingeben.

Abbildung 55: Ergebnis der Erstellung von Interface etc.

Die Ausgaben sehen wir uns anschließend im Status-Fenster an sowie in der Tomcat-Server-Console und im TCP-Monitor.

Öffnen Sie also nun die Einträge im Navigator mit der Sicht des WSDL Main unterhalb des Eintrags GuestBookSOAP (Abbildung 55).

Geben Sie jetzt im Body-Fenster ein paar Daten ein, die Sie als Nachricht im Gästebuch ablegen möchten (Abbildung 56).

Im Status Fenster (Abbildung 57) sehen Sie nun die erstellte SOAP-Nachricht nach Klick auf den Schalter Source. Dabei interessieren uns hier die Angaben im Body-Block der XML-Struktur. Was wir hier sehen, ist die Nachricht, die ein Client an den Server des Web Services abgesendet hat. In den folgenden Bildschirmseiten werden wir die Wirkung des Web Service Dienstes weiter untersuchen.

Abbildung 56: Eingabedaten für Methode insertEntry

Abbildung 57: SOAP für die Eingabe der Daten

Auch auf der Console sehen Sie die Aktivitäten rund um diese Anwendung (Abbildung 58).

Abbildung 58: Ausgabe der Server-Console

Abbildung 59: Ausgabe des TCP/IP-Monitors

Ein Blick auf den TCP/IP-Monitor zeigt den Request auf der linken Seite und die Erfolgsmeldung rechts: Accepted (Abbildung 59).

Nun versuchen wir, eine Ausgabe der in der Anwendung gespeicherten Nachrichten zu erhalten. Dazu wählen Sie die Anwendung getEntries und klicken auf den Schalter Go (Abbildung 60).

Abbildung 60: Test der Ausgabe von Daten

Die Ausgabe entspricht dabei wohl noch nicht dem, was Sie erwarten würden: Hier ist nicht die Nachricht zu sehen, die Sie gerade eingegeben haben, sondern die Testnachricht, die bei der Erstellung des Clients angelegt wurde. Zur Änderung der Ausgabe müssen wir zunächst den Source-Code bearbeiten.

Im Status-Fenster sehen wir eine formatierte Ausgabe der Rückantwort unseres Web Services (Abbildung 61).

Abbildung 61: Ausgabe der Ergebnisse aus Methode getEntries

Wenn Sie dann auf den Schalter Source rechts oben im Status-Fenster klicken, sehen Sie die XML-Darstellung der abgesendeten Anforderung sowie die Rückantwort (Abbildung 62).

Abbildung 62: Request und Response der Ausgabe-SOAP

Was wir aber bereits sehen können, ist die Darstellung der WSDL, wie diese in einem Browser angezeigt wird. Dazu geben wir im Browser des Eclipse die folgende URL ein:

In Abbildung 63 sehen wir unterhalb des Verzeichnis-Knotens WEB-INF ein von Eclipse erstelltes Unterverzeichnis wsdl mit einer WSDL- und einer XSD-Datei. Bei der Ausgabe in Abbildung 63 wird nun genau diese WSDL verwendet, nicht die Datei im von uns angelegten Unterverzeichnis xml. Bei einer Weitergabe einer WSDL an „Kunden“ dieses Dienstes, die danach ihre eigene Client-Anwendung beispielsweise als JSP-Client schreiben wollen, muss genau diese vom System erstellte WSDL-Datei weitergegeben werden.

Abbildung 63: WSDL im Browser-Fenster des Eclipse

Abbildung 64: Web Service Explorer aus WSDL-Umgebung aufrufen

Wenn Sie die Anwendung später erneut testen wollen, so erreichen Sie dies ebenfalls durch die neu erstellte WSDL-Datei. Mit Rechtsklick auf diese WSDL wählen Sie Web Services -> Test with Web Service Explorer (Abbildung 64), danach können Sie die gleichen Anwendungen ausprobieren wie bereits oben beschrieben.

Abbildung 65: Umgebung auswählen

Abbildung 66: Test des getEntries-Aufrufs

Nachfolgend werden alle Quell-Dateien wiedergegeben, die vom System angelegt wurden.

Klasse GuestBookEntryType.java in src\org\example\guestbook\schema:

Klasse GuestBookType.java innerhalb src\org\example\guestbook\schema:

Klasse ObjectFactory.java innnerhalb src\org\example\guestbook\schema:

Klasse package-info.java innerhalb src\org\example\guestbook\schema:

Die Klasse GuestBook_GuestBookSOAP_Server steht im Unterverzeichnis src\org\example\guestbook\service:

Klasse GuestBook_Service.java in src\org\example\guestbook\service:

Klasse GuestBook.java innnerhalb src\org\example\guestbook\service:

Klasse GuestBookImpl.java innerhalb src\org\example\guestbook\service:

Klasse ObjectFactory.java innerhalb src\org\example\guestbook\service:

Service: Implementierung des Gästebuch-Web Services

Nachdem wir nun ganz formal einen Service aufgebaut haben und wissen, dass er im Prinzip funktioniert, implementieren wir den Service und nehmen einige Änderungen an den Modellklassen vor.

Zunächst brauchen wir etwas Logik in den Modellklassen. Wir wollen es uns hier einfacher machen und speichern die Einträge des Gästebuches nur in lokalen Klassenvariablen und nicht in einer externen Datenbank. Dadurch ist zwar der Inhalt unseres Gästebuchs nicht „persistent“ und der Web Service selbst wird zustandsbehaftet. Für unser Beispiel ist das aber ausreichend. Wir können den Web Service damit auf seine Funktionalität testen, ohne diese durch weiteren Quellcode „undurchsichtig“ zu machen. Wer sich mit Datenbank-Entwicklung auskennt, kann im Nachgang leicht die passenden Funktionen zum Web Service hinzufügen.

In GuestBookType.java im Schema-Package erzeugen wir zuerst einen Konstruktor, der die Eintragsliste mit den notwendigen Klassenvariablen initialisiert. Dazu ergänzen Sie in org.example.guestbook.schema die folgende Passage in der Datei GuestBookType.java:

Passen Sie die Methode getEntry() an, wie das im nächsten Block angeben ist, und erstellen Sie zusätzlich die Methode addEntry(GuestBookEntry).

Das Interface org.example.guestbook.service.GuestBook wird von der Klasse GuestBookImpl im Package org.example.guestbook.service implementiert. Hier fügen Sie nun die folgende Annotation ein:

Der Parameter name verweist dabei auf wsdl:portType, Parameter serviceName verweist auf wsdl:service, Parameter portName bestimmt den Wert für wsdl:port, Parameter targetNamespace bestimmt den Target-Namespace und schließlich Parameter endpointInterface den Endpoint-Interface-Namen.

Jetzt sieht die Klasse so aus (inklusive ein paar Debug-Ausgaben):

Diese Änderungen wollen wir sogleich testen. Starten Sie wieder den Web Service Explorer und speziell die Operation insertEntry (Abbildung 67). Überprüfen Sie dann die Ergebnisse (Abbildung 68).

Abbildung 67: Testeingabe

Abbildung 68: Testeingabe im Monitor

Die Ausgabe auf der Console sieht wieder so aus, wie wir dies beim ersten Client-Test gesehen hatten. Die Änderungen sehen wir dann aber, wenn die Anwendung getEntries ausgeführt wird (Abbildung 69). Wir erhalten nun keine Testdaten mehr, die vom automatisch erstellten Client stammen, sondern unsere eigenen Eingaben als Antwort im Status-Fenster.

Abbildung 69: Rückgabe der Methode getEntries

Sie können diese Funktionalität auch wieder auf der Tomcat Server Console überprüfen (Abbildung 70) sowie im TCP-Monitor (Abbildung 71).

Abbildung 70: Rückantwort in der Console

Abbildung 71: Rückantwort im Monitor

Mehr brauchen wir zunächst nicht mehr auf der Server-Seite des Web Service. Machen wir uns also an den Aufbau eines schönen Clients!

Implementierung des Gästebuch-Clients

Damit wir die Funktionen des Web Services auch in einfacher Weise nutzen können, brauchen wir natürlich einen Client. Zunächst wollen wir einen simplen Konsolen-Client aufbauen. Anschließend entwickeln wir eine Gästebuch-Webseite, die unsere Einträge in das Gästebuch über den Gästebuch-Web Service verwaltet.

Im Folgenden sehen wir die noch unveränderten Quell-Dateien des Clients.

Die Klasse GuestBookEntryType.java in org.example.guestbook.schema:

Die Klasse GuestBookType.java in org.example.guestbook.schema:

Die Klasse GuestBook_GuestBookSOAP_Client.java finden wir im Baum org.example.guestbook.service:

Die Klasse GuestBook_Service.java in org.example.guestbook.service:

Die Klasse GuestBook.java in org.example.guestbook.service:

Die Klasse GuestBookImpl.java in org.example.guestbook.service:

Jetzt wollen wir auch für den Client die Logik erweitern. String-Variablen der Klasse GuestBookEntryType.java sollen niemals den Wert null annehmen. Andernfalls würde auf der Webseite der String "null" ausgegeben werden. Wir erstellen