XML-Datei für Web Service auslesen und schreiben

Transkript

1 XML-Datei für Web Service auslesen und schreiben Einleitung Anliegen dieses Tutorials ist das Einbinden einer XML-Datei als Datenquelle für den AutoKauf Web Service. Wenn der Web Service z. B. auf die Anfrage alleautosanzeigen die Liste AutoArrayItems (also ein Array) an den SOAP-Client zurückgibt, müssen die Daten (also die Arrayeinträge) ja irgendwo herkommen. Im Normalfall wird das eine SQL- Datenbank sein, aus der die Daten zur Laufzeit geholt werden. Im Fall unseres Praktikums ist es einfachheitshalber eine XML-Datei, die zur Laufzeit vom Web Service eingelesen (geparst), ggf. geändert und wieder gespeichert wird. Das Tutorial schließt an das Tutorial Java-basierten Web Service erstellen an. Inhaltsverzeichnis 1 IMPORTIEREN DES WEB SERVICE AUTOKAUF 1 2 XML-DATENBASIS XML Schema erstellen XML-Datei erstellen XML-Datei und Schema in Eclipse-Projekt integrieren 6 3 WEB-SERVICE KLASSE AUTOKAUFSOAPBINDINGIMPL Methode alleautosanzeigen Methoden kaufeauto und verkaufeauto Methode generierexmldateipfad Methode lesedatensaetze Methode schreibedatensaetze Testen des XML-Dateizugriffs 14 4 ERSTELLEN DES ARCHIVS AKWS1011GXX.WAR 16

2 1 Importieren des Web Service AutoKauf Die Vorrausetzung für dieses Tutorial ist, dass der Web Service AutoKauf schon implementiert ist. Um den Web Service in die Testumgebung zu integrieren, importieren wir das Archiv in Eclipse als Projekt. Dies geschieht mit File -> Import -> Web -> WAR file. Mit Rechtsklick auf das importierte Projekt AKWS1011GXX Run As -> Run on Server wird dem Server der Web-Kontext hinzugefügt. 1

3 Der Service ist also immer verfügbar, wenn das Tomcat-Plugin gestartet ist. Mit der folgenden URL kann getestet werden, ob der Service aktiv ist. 2 XML-Datenbasis Bei der Beispiel-Implementierung des Web Service Tutorials wären Änderungen an den Daten innerhalb der Klasse AutoKaufImpl, hervorgerufen durch einen Webservice Aufruf, nur temporär und bei der nächsten Anfrage wieder vergessen. Wir müssen diese Änderungen also auf einer für alle Web Service Nutzer einheitlichen Datenbasis persistent schrieben. Dazu verwenden wir eine XML-Datei. Diese XML-Datei kann beliebig viele Einträge von Autos haben. 2.1 XML Schema erstellen Das XML Schema ist eine Art Bildungsvorschrift für die XML-Datei. Um später bei der Erstellung der XML-Datei auf Fehler hingewiesen zu werden (unter Verwendung entsprechender XML-Editoren wie XMLSpy), werden XML-Dateien mit einem Schema verknüpft und bei Änderungen gegen das Schema validiert. Mit dieser Technik wird verhindert, dass in der späteren Implementation der Clients unerklärliche Seiteneffekte aufgrund einer fehlerhaften XML-Datei auftreten. Bevor wir bei der Frage wie solch ein XML Schema aussehen soll ins Schwitzen geraten, schauen wir uns schnell noch einmal die im Tutorial Java-basierten Web Service erstellen erstellte WSDL-Datei AKWS1011GXX.wsdl an und zwar speziell den Abschnitt Types. Da steht nämlich schon fast alles drin was wir brauchen. 2

4 <?xml version="1.0" encoding="utf-8"?> <types> <xsd:schema > <xsd:complextype name="autoarray"> <xsd:sequence> <xsd:element name="autoarrayitem" type="typesns:auto" minoccurs="1" /> </xsd:sequence> </xsd:complextype> <xsd:complextype name="auto"> <xsd:sequence> <xsd:element name="autoid" type="xsd:long"/> <xsd:element name="farbe" type="xsd:string"/> <xsd:element name="anzahlsitze" type="xsd:int"/> <xsd:element name="gekauft" type="xsd:boolean"/> </xsd:sequence> </xsd:complextype> </types> Um ein korrektes XML Schema zu erhalten, mit dem wir XML-Dokument-Instanzen erstellen können, müssen wir nur wenig ändern. - den types-tag löschen - überflüssige Namespaces löschen - das Root-Element AutoArrayItems definieren Das Root-Element umschließt den gesamten Inhalt einer XML-Datei. In einer wohlgeformten XML-Datei gibt es nur ein Root-Element. 3

5 Die folgende Abbildung zeigt das fertige Schema. <?xml version="1.0" encoding="utf-8"?> <xsd:schema xmlns:xsd=" <xsd:element name="autoarrayitems" type="autoarray"/> <xsd:complextype name="autoarray"> <xsd:sequence> <xsd:element name="autoarrayitem" type="auto" minoccurs="1" maxoccurs="unbounded"/> </xsd:sequence> </xsd:complextype> <xsd:complextype name="auto"> <xsd:sequence> <xsd:element name="autoid" type="xsd:long"/> <xsd:element name="farbe" type="xsd:string"/> <xsd:element name="anzahlsitze" type="xsd:int"/> <xsd:element name="gekauft" type="xsd:boolean"/> </xsd:sequence> </xsd:complextype> </xsd:schema> Das Schema kann unter Autos.xsd gespeichert werden. 2.2 XML-Datei erstellen Mit dem erstellten Schema kann nun eine (oder auch mehrere) XML-Datei-Instanzen erzeugt werden. Es ist sinnvoll die XML-Datei im selben Verzeichnis wie die Schema-Datei abzulegen, denn beide Dateien werden zukünftig als Einheit betrachtet. Eine neue XML-Datei kann am einfachsten mit XMLSpy oder einem anderen validierenden XML-Editor erstellt werden. In XMLSpy gehen wir dazu wie folgt vor: Schema Autos.xsd in XMLSpy öffnen Mit DTD/Schema -> Generate Sample XML File erstellen wir die XML-Datei 4

6 Attribut xsi:nonamespaceschemalocation ändern zu Autos.xsd Überflüssige Kommentare löschen Nun können entsprechend dem Schema ein paar Listeneinträge geschrieben werden. Die fertige XML-Datei sollte dann etwa so aussehen. 5

7 <?xml version="1.0" encoding="utf-8"?> <AutoArrayItems <AutoArrayItem> <autoid>1</autoid> <farbe>rot</farbe> <anzahlsitze>4</anzahlsitze> <gekauft>false</gekauft> </AutoArrayItem> <AutoArrayItem> <autoid>2</autoid> <farbe>blau</farbe> <anzahlsitze>5</anzahlsitze> <gekauft>true</gekauft> </AutoArrayItem> <AutoArrayItem> <autoid>3</autoid> <farbe>dunkelorange</farbe> <anzahlsitze>8</anzahlsitze> <gekauft>true</gekauft> </AutoArrayItem> <AutoArrayItem> <autoid>4</autoid> <farbe>rosa</farbe> <anzahlsitze>3</anzahlsitze> <gekauft>true</gekauft> </AutoArrayItem> <AutoArrayItem> <autoid>5</autoid> <farbe>gruen</farbe> <anzahlsitze>5</anzahlsitze> <gekauft>true</gekauft> </AutoArrayItem> <AutoArrayItem> <autoid>6</autoid> <farbe>hellweiss</farbe> <anzahlsitze>2</anzahlsitze> <gekauft>true</gekauft> </AutoArrayItem> </AutoArrayItems> </AutoArrayItems> xmlns:xsi=" xsi:nonamespaceschemalocation="autos.xsd"> 2.3 XML-Datei und Schema in Eclipse-Projekt integrieren Das WAR-Archiv des Web Services soll später überall (auf verschiedenen Tomcats) laufen. Dafür ist es nötig, die XML-Datei Autos.xml und die zugehörige Schema-Datei Autos.xsd in das Web Service Projekt zu integrieren. In Eclipse erstellen wir unter WebContent einen Ordner data und ziehen dann aus dem Filesystem die beiden Dateien in diesen Ordner. 6

8 3 Web-Service Klasse AutoKaufSoapBindingImpl Erinnern wir uns an die Implementierungsklasse AutoKaufSoapBindingImpl des Web Service Tutorials. Hier sind die drei Methoden alleautosanzeigen, kaufeauto und verkaufeauto bereits implementiert. Zum Testen hatten wir schon ein wenig Funktionalität hinterlegt. 3.1 Methode alleautosanzeigen In der Methode alleautosanzeigen wird z. B. ein Array von Autos erzeugt und bei einer Anfrage zurückgegeben. Das wird auch weiter so bleiben, mit dem Unterschied, dass wir die Array-Daten (genauer das gesamte Array) aus der XML-Datei holen. Mit leichten Änderungen sieht die Methode alleautosanzeigen nun wie folgt aus. 7

9 public AKWS1011GXX.AutoKauf.Types.Auto[] alleautosanzeigen() throws java.rmi.remoteexception { Auto[] autos = lesedatensaetze(); if(autos == null) return null; return autos; Interessant ist hier nur der Methodenaufruf lesedatensaetze. Er führt die entsprechende Methode aus, die das Array aus der XML-Datei erzeugt. private Auto[] lesedatensaetze() { return null; Diese Methode werden wir weiter unten im Tutorial implementieren. 3.2 Methoden kaufeauto und verkaufeauto Schauen wir uns die beiden Methoden kaufeauto und verkaufeauto an zunächst kaufeauto. Die Methode kaufeauto wird mit dem Parameter autoid aufgerufen. Diese ID muss natürlich in der XML-Datei eindeutig sein. Wir verwenden hier auch wieder die Methode lesedatensaetze um das Array zu bekommen. Wenn wir das Array erhalten haben, gehen wir es iterativ durch, bis zu dem Auto mit der entsprechenden ID. Ist der Verkaufsstatus dieses Autos bereits true (also gekauft), ist der Kauf nicht erfolgreich. Kann man es noch kaufen, wird hier der Status auf true gesetzt. Die Entscheidung, ob die Methode kaufeauto erfolgreich ist, hängt nun noch davon ab, ob das veränderte Array auch wieder als XML-Datei geschrieben werden kann. public boolean kaufeauto(long autoid) throws java.rmi.remoteexception { Auto[] autos = lesedatensaetze(); if (autos!=null) { for (int i=0; i<autos.length; i++){ Auto auto = autos[i]; if (auto.getautoid()!=autoid) continue; if (auto.isgekauft()) break; auto.setgekauft(true); return schreibedatensaetze(autos); return false; Das schreiben erledigt die Methode schreibedatensaetze, die wir uns auch weiter unten noch genauer ansehen. private boolean schreibedatensaetze(auto[] autos){ return false; Die Methode verkaufeauto kann nun analog implementiert werden. 8

10 3.3 Methode generierexmldateipfad Mit der Methode generierexmldateipfad generieren wir den absoluten Dateipfad relativ von der Class-Datei AutoKaufSoapBindingImpl.class. Die XML-Datei Autos.xml und das zugehörige Schema haben wir zwar weiter oben in diesem Tutorial in das Verzeichnis <ECLIPSE_WORKSPACE>\AKWS1011GXX\WebContent\data verschoben, aber wir können natürlich nicht davon ausgehen das dieser Pfad auch auf dem Zielsystem derselbe ist. Außerdem werden bereits bei unserem Eclipse-Projekt der gesamte Web Content für die Tomcat-Plugin-Ausführung in den temporären Ordner D:\\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\webapps\AKWS1011GXX\ kopiert. Kurz, wenn das WAR-Archiv später überall laufen soll, muss der Pfad der XML-Dateien dynamisch generiert werden. Das bedarf ein wenig Bastelaufwand, wie der folgende Code zeigt. private String generierexmldateipfad(string dateipfadrelativ) { String klassenname = this.getclass().getname(); String klassenpfadrelativ = "/" + klassenname.replace(".","/") + ".class"; String klassenpfadabsolut = getclass().getresource(klassenpfadrelativ).getfile(); String classespfad = klassenpfadabsolut.replace(klassenpfadrelativ, ""); String buildpfad = classespfad.substring(0, classespfad.lastindexof("/")); String projektpfad = buildpfad.substring(0, buildpfad.lastindexof("/")); dateipfadrelativ=dateipfadrelativ.replace("\\", "/"); if (dateipfadrelativ.charat(0)!='/') dateipfadrelativ = "/" + dateipfadrelativ; String dateipfadabsolut = projektpfad + dateipfadrelativ; dateipfadabsolut = dateipfadabsolut.replace("%20", " "); return dateipfadabsolut; Zuerst lassen wir uns den Klassennamen AKWS1011GXX.AutoKauf.AutoKaufSoapBindingImpl geben. Der Package-Name steckt schon mit drin. Daraus erzeugen wir den relativen Klassenpfad /AKWS1011GXX/AutoKauf/AutoKaufSoapBindingImpl.class Nun lassen wir uns den absoluten Klassenpfad geben und ziehen den relativen Klassenpfad davon ab und landen hier /D://.metadata/./tmp0/webapps/AKWS1011GXX/WEB- INF/classes. Nun hangeln wir uns noch zum Projekt-Verzeichnis /D://.metadata/./tmp0/ webapps/akws1011gxx das entspricht im Eclipse-Projekt dem Ordner WebContent. Als nächstes wird der relative Dateipfad einheitlich mit Slashs geschrieben (Bsp.: data\autos.xml data/autos.xml) und wir schreiben einen Slash voran, falls nicht schon da ( /data/autos.xml). Zum Schluss fügen wir den modifizierten relativen Pfad der XML-Datei hinzu (D://.metadata/./tmp0/webapps/AKWS1011GXX /data/autos.xml). 9

11 Dummerweise sind darin enthaltene Leerzeichen als %20 geschrieben. 20 entspricht dem Hexadezimal-Wert des ASCII-Codes 32 für das Leerzeichen. Das müssen wir also auch noch ändern. Die Methode werden wir nun verwenden um die XML-Datei auszulesen und zu speichern. 3.4 Methode lesedatensaetze Diese Methode liefert uns aus den Einträgen der XML-Datei (AutoArrayItems) ein Array mit Autos (Auto.java). Grob besteht die Methode aus 4 Teilen: - Validierendes Einlesen der XML-Datei - Erstellen des Arrays - Abfangen von Exceptions (Fehlerbehandlung) - Rückgabe des Arrays Validierendes Einlesen der XML-Datei Dieser Teil entspricht komplett der JAXP-API zur Erstellung eines DOM-Parsers, der in der Lage ist, die einzulesende XML-Datei gegen ein XML Schema zu validieren. private Auto[] lesedatensaetze() { Auto[] autos=null; try { DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setvalidating(true); factory.setnamespaceaware(true); factory.setattribute( " " DocumentBuilder builder = factory.newdocumentbuilder(); Document document = builder.parse( new File(generiereXMLDateipfad("/data/Autos.xml"))); Erstellen des Arrays Der im vorhergehenden Schritt erstellte Parser erzeugt eine XML-Dokumentenstruktur (document) im Speicher auf der wir nun arbeiten können. Dazu werden die Elemente iterativ durchgegangen und die entsprechenden Einträge herausgesucht. Jedes XML-Dokument besitzt exakt ein Root-Element. In diesem Fall heißt das Root-Element AutoArrayItems und deutet schon an, dass es mehrere AutoArrayItem-Kindelemente beinhalten kann. Im ersten Schritt wird also das Root-Element des Dokumentes (AutoArrayItems) zurückgegeben. Dieses wird iterativ durchgegangen und jedes AutoArrayItem herausgesucht. Nun könnte die Frage auftauchen, warum wir erst noch prüfen, ob es sich um ein AutoArrayItem handelt. Laut der Schema-Datei waren doch nur AutoArrayItem- Elemente als Kindknoten zugelassen. Und nach der Validierung müsste man doch erst recht davon ausgehen können. Das ist zwar richtig. Aber außer den offiziellen Elementen 10

12 schleichen sich immer noch Text-Knoten in das XML-Dokument hinein (mit Zeilenumbrüchen und Tabulatoren als Inhalt), die dafür sorgen, dass die XML-Datei schön gelesen werden kann (pretty-print). Im Normalfall bestände sonst so ein XML-Dokument aus nur einer Zeile. Wie auch immer, solche Textknoten müssen ignoriert werden. Element rootelement = document.getdocumentelement(); NodeList nodelist1 = rootelement.getchildnodes(); ArrayList<Auto> autoarray=null; autoarray = new ArrayList<Auto>(); Auto auto = null; for (int i=0;i<nodelist1.getlength();i++) { Node autoarrayitem = nodelist1.item(i); if (!autoarrayitem.getnodename().equals("autoarrayitem")) continue; auto = new Auto(); NodeList nodelist2 = autoarrayitem.getchildnodes(); for (int j=0;j<nodelist2.getlength();j++){ Node eigenschaft = nodelist2.item(j); if (eigenschaft.getnodename().equals("autoid")) auto.setautoid((long)long.valueof(eigenschaft.gettextcontent())); if (eigenschaft.getnodename().equals("farbe")) auto.setfarbe(eigenschaft.gettextcontent()); if (eigenschaft.getnodename().equals("anzahlsitze")) auto.setanzahlsitze((int)integer.valueof(eigenschaft.gettextcontent())); if (eigenschaft.getnodename().equals("gekauft")) auto.setgekauft((boolean)boolean.valueof(eigenschaft.gettextcontent())); autoarray.add(auto); autos = (Auto[]) autoarray.toarray( new Auto[0] ); In der zweiten for-schleife werden die (Unter-) Elemente eines jeden AutoArrayItem durchlaufen. Das sind natürlich genau die Eigenschaften der Bean-Klasse Auto (long autoid, String farbe, int anzahlsitze, boolean gekauft). Bei jedem gefundenen AutoArrayItem wird die ArrayList autoarray um ein Auto erweitert. Da zur Übergabe ein Array benötigt wird, muss am Ende dieses Abschnitts noch die ArrayList vom Typ Auto in ein Array vom Typ Auto[] umgewandelt werden. autos = (Auto[]) autoarray.toarray( new Auto[0] ); Leider gibt es in Java keine schönere Möglichkeit als diese. 11

13 Abfangen von Exceptions ParserConfigurationExceptions können beim Erstellen des DocumentBuilders auftreten, SAXExceptions und IOExceptions beim validierenden Einlesen (Parsen) der XML-Datei. catch (ParserConfigurationException pce) { pce.printstacktrace(); catch (SAXException se) { se.printstacktrace(); catch (IOException ioe) { ioe.printstacktrace(); Rückgabe des Arrays Dazu ist nicht viel zu sagen, außer dass wenn alles geklappt hat, wird ein Array vom Typ Auto[] zurückgegeben wenn nicht, null. return autos; 3.5 Methode schreibedatensaetze Diese Methode schreibt ein übergebenes Auto[]-Array in eine XML-Datei. Die Methode besteht grob aus 5 Teilen: - Erstellen einer XML-Baum-Struktur (im Speicher) - Erstellen des Root-Elements AutoArrayItems - Füllen des Root-Elements mit AutoArrayItem-Einträgen - Schreiben der XML-Datei - Abfangen der Exceptions / Rückgabewert Erstellen einer XML-Baum-Struktur (im Speicher) Die Datenstruktur Document bildet den Rahmen für alle XML-Elemente. private boolean schreibedatensaetze(auto[] autos){ if (autos==null) return false; try { DocumentBuilderFactory factory =DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newdocumentbuilder(); Document document = builder.newdocument(); Erstellen des Root-Elements Jedes XML-Dokument hat genau ein Root-Element. In diesem Fall ist es das Element AutoArrayItems. Im Root-Element des Dokumentes muss auch ein zugehöriges XML Schema festgelegt werden, wenn die XML-Datei später gegen ein Schema validiert werden soll. Dafür dienen die beiden setattribute-aufrufe. 12

14 Element root =document.createelement("autoarrayitems"); root.setattribute("xmlns:xsi", " root.setattribute("xsi:nonamespaceschemalocation","autos.xsd"); Füllen des Root-Elements mit Einträgen In diesem Abschnitt werden alle Elemente des übergebenen Arrays autos dem Root-Element als AutoArrayItem-Kindelemente angehängt. Dem Element AutoArrayItem werden wiederum die Attribute des Autos als Kind-Elemente angehängt. for (int i=0; i<autos.length; i++) { Auto auto = autos[i]; Node autoarrayitem; autoarrayitem = root.appendchild(document.createelement("autoarrayitem")); autoarrayitem.appendchild(document.createelement("autoid")).settextcontent(string.valueof(auto.getautoid())); autoarrayitem.appendchild(document.createelement("farbe")).settextcontent(auto.getfarbe()); autoarrayitem.appendchild(document.createelement("anzahlsitze")).settextcontent(string.valueof(auto.getanzahlsitze())); autoarrayitem.appendchild(document.createelement("gekauft")).settextcontent(string.valueof(auto.isgekauft())); document.appendchild(root); Schreiben der XML-Datei Nun wird das XML-Dokument document aus dem Speicher in das Filesystem geschrieben. Dazu wird ein XSLT-Transformer verwendet, der die XML-Struktur in einen serialisierten Outputstream umwandelt. Auch dieses Verfahren zur Speicherung der XML-Datei entspricht der JAXP-API. TransformerFactory transfactory = TransformerFactory.newInstance(); Transformer transformer = transfactory.newtransformer(); DOMSource source = new DOMSource(document); FileOutputStream fos = new FileOutputStream(new File(generiereXMLDateipfad("/data/Autos.xml"))); StreamResult result = new StreamResult(fos); transformer.transform(source,result); Leider unterstützt die JAXP-API derzeit kein Pretty-Print. Das bedeutet, dass die geschriebene XML-Datei aus einer Zeile bestehen wird. Die meisten Parser bieten aber eine entsprechende Funktion an. 13

15 Rückgebewert Konnte die Methode erfolgreich ausgeführt werden, liefert sie true zurück. Traten Exceptions auf, wird false zurückgeliefert. return true; catch( ParserConfigurationException pce ) { pce.printstacktrace(); catch( TransformerConfigurationException tce ) { tce.printstacktrace(); catch( TransformerException te ) { te.printstacktrace(); catch( FileNotFoundException fnfe ) { fnfe.printstacktrace(); return false; Schauen wir uns zum Abschluss alle in dieser Klasse verwendeten Imports an. import java.io.file; import java.io.filenotfoundexception; import java.io.fileoutputstream; import java.io.ioexception; import java.rmi.remoteexception; import java.util.arraylist; import javax.xml.parsers.documentbuilder; import javax.xml.parsers.documentbuilderfactory; import javax.xml.parsers.parserconfigurationexception; import javax.xml.transform.transformer; import javax.xml.transform.transformerconfigurationexception; import javax.xml.transform.transformerexception; import javax.xml.transform.transformerfactory; import javax.xml.transform.dom.domsource; import javax.xml.transform.stream.streamresult; import org.w3c.dom.document; import org.w3c.dom.element; import org.w3c.dom.node; import org.w3c.dom.nodelist; import org.xml.sax.saxexception; 3.6 Testen des XML-Dateizugriffs An dieser Stelle haben wir die Implementierung der Methoden abgeschlossen und können nun das gesamte Projekt testen. Zum testen der Methode lesedatensaetze können wir uns im Browser die Einträge der XML-Datei anzeigen lassen. 14

16 Das Ergebnis sollte nun das folgende sein. Aus diesem Ergebnis suchen wir uns einen Eintrag heraus wo gekauft gleich false ist - also ein Auto, das wir noch kaufen können (z.b. autoid=1). Mit dem folgenden Aufruf werden wir es kaufen. Das Ergebnis sollte das folgende sein. 15

17 Wir erhalten also den Wert true zurück und erkennen damit zum einen, dass das Auto erfolgreich gekauft werden konnte und zum anderen, dass die Methode schreibedatensaetze erfolgreich ausgeführt werden konnte diese hätte ja sonst den Wert false geliefert und somit zu dem Gesamtrückgabewert false der Methode kaufeauto geführt. Analog kann die Methode verkaufeauto getestet werden. 4 Erstellen des Archivs AKWS1011GXX.war Bevor wir abschließend das WAR-Archiv erstellen, schauen wir uns zum Vergleich im Package-Explorer die gesamte Dateistruktur noch einmal an. Mit Rechtsklick auf das Projekt AKWS1011GXX Export -> WAR file erstellen wir das entsprechende WAR-Archiv. 16

18 Zum Testen des Archivs können wir Eclipse beenden, die Datei AKWS1011GXX.war in den Tomcat-WebApps-Ordner (<TOMCAT_ROOT>\WebApps\) verschieben und Tomcat als Applikation (bzw. Dienst) starten. Im Browser können wir uns das Ergebnis ansehen. 17