| Advanced Java Services | Tomcat Eclipse Integration |
|
Man geht zur Startseite von Tomcat und sucht sich in der Spalte ganz links unter Download die aktuelle Release Version (keine Betaversion). Stand März 2016 ist das 8.0.32 . Unter der Rubrik Binary Distributions sucht man sich die zum Betriebssystem passende Zip-Datei aus.
Man entpackt die Zip-Datei in ein neu angelegtes Verzeichnis, z.Bsp. C:\apache\tomcat. Dabei entstehen im gewählten Verzeichnis u.a. 7 Unterverzeichnisse. Im Verzeichnis /bin befinden sich Batchdateien startup.bat und shutdown.bat zum Starten und beenden von Tomcat. Damit diese arbeiten können müssen die beiden Umgebungsvariablen JAVA_HOME und CATALINA_HOME gesetzt werden. Sie müssen auf das jeweilige /bin-Verzeichnis zeigen und wobei die Pfadangabe am Ende KEIN Semikolon enthalten darf, also z.Bsp.
JAVA_HOME = C:\Program Files (x86)\Java\jdk1.8.0_74 CATALINA_HOME = C:\apache\tomcat
Auf Windowssystemen findet man den Ort zum Eintragen der Umgebungsvariablen unter
Control Panel -> All Control Panel Items -> System -> Advanced System Settings -> System Properties (neues Fenster) -> Advanced -> Environment Variables -> System variables
Ruft man nun das Startskript auf, sollte sich Tomcat im Browser unter http://localhost:8080 melden.
Hier kann man auf der Startseite von Tomcat in der linken Spalte unter Dokumentation die heruntergeladene Version von Tomcat anwählen und dann unter der Rubrik Reference sich die Javadoc von Servlet, JSP, usw einzeln herunterladen. Viel einfacher ist es jedoch auf der Startseite nochmal Download anzuwählen. Hier findet man unter Binary Distributions und Full documentation eine tar.gz Datei, die ALLE Javadocs enthält. in einem File
File -> new -> Other -> Server -> Server
Falls noch keine Web-Projekte existieren kann man den Dialog jetzt beenden. Der Server ist nun angelegt
Mit einem Doppelklick auf den Eintrag 'Tomcat v8.0 Server at localhost' im Servers Fenster erhält man eine Übersicht über die Konfiguration der Eclipse-eigenen Tomcat-Instanz.
Die folgende Anleitung beschreibt die Integration von Apache Tomcat mit der Entwicklungsumgebung Eclipse.
Um Servlets oder Java Server Pages zu entwickeln braucht man in Eclipse ein "Dynamic Web Project". Hier konfiguriert man
eine Eclipse-eigene Servletumgebung, die dem Aufbau einer Webapplikation unter Tomcat entspricht. Die folgenden Screenshots
werden das zeigen. Wir werden Eclipse im Laufe des Anlegens des Projektes auch den Server (Tomcat) bekanntmachen, ihn
dann aber erst später konfigurieren. Das hat den Vorteil, daß im Projekt sofort die beiden ServletPackages bekannt sind.
Ab der Version 4 von Tomcat ist es möglich, mehrere Instanzen von Tomcat anzulegen die in einer einzigen Installation laufen.
Jede Instanz arbeitet (zwangsläufig) mit einem eigenen Satz von Ports. Im zweiten Teil werden wir zeigen, wie man in Eclipse eine eigene
Serverinstanz anlegt. Man kann übrigens die Reihenfolge auch umdrehen und zuerst die Serverinstanz anlegen und dann die
Servletumgebung. In einem dritten Schritt gibt man der Eclipse-eigenen Tomcatinstanz das Servlet bekannt, sodann läßt es sich
über das Run-Menu starten und wird dann in einem in Eclipse integrierten Browser angezeigt. Hierfür kann man auch verschiedene
Browser auswählen. Auf diese Weise kann man alle Entwicklungsvorgänge mit Eclipse steuern.
Wir wollen eine einfache Hello World Servletanwendung mit Eclipse anlegen. Um alle Schritte deutlich zu sehen,
gehen wir dabei von einer frischen Eclipseinstallation und einem leeren workspace-Verzeichnis aus, sodaß noch
keine Metadaten angelegt worden sind.
Unter Target Runtime können wir hier bereits den Servernamen eintragen. Die Eintragung des Servernamens sollte man auf alle
Fälle vornehmen, da damit gleich die beiden Servletpackages dem Projekt bekanntgemacht werden. Es empfielt sich unbedingt
"Create a new local server" anzuhaken, denn dann wird so nebenbei auch noch eine Eclipseeigene Serverinstanz erzeugt.
Das geht natürlich auch noch später. Die eigentliche Konfiguration des Servers erfolgt hier nach dem Einrichten
des Dynamic Web Projekts.
Hier sehen wir nun die neuen Einträge von Target Runtime ab abwärts.
Wir gehen der Neugierde halber auf "Next".
Es gibt aber nichts einzutragen.
Hier setzt man den Haken für die web.xml. Anschließend gehen wir auf "Finish".
Nun erzeugt Eclipse eine ganze Reihe von Verzeichnissen und Dateien.
Hier zunächst die Ansicht in Eclipse. Für die Datei web.xml gibt es zwei verschiedenen Ansichten. Wir sind hier
auf das Kontextmenu zum Eintrag "Deployment Descriptor" im Project Explorer gegangen und haben dann mit "Open with"
Text Editor gewählt.
Wir sehen, daß im Projekt Explorer auch schon ein Server angezeigt wird. Wird werden ihn später noch konfigurieren
müssen.
Und so sieht das auf der Festplatte aus.
Über das Kontextmenu zum Eintrag "HelloWorldServlet" im Projekt Explorer wird uns unter "New" schon eine
Auswahl "Servlet" angeboten.
Wir überspringen die Möglichkeit ein Package anzugeben und geben sofort den Klassennamen ein. Da unser
Servlet nur das Vorgehen in Eclipse demonstrieren soll brauchen wir hier kein Package.
Wir verzichten auf eine Description und auf Initialisierungsparameter. Um die Möglichkeiten des Mappings
zu demonstrieren tragen wir aber einen nicht existierenden Namen ein. Dazu markieren wir den vorhanden
Eintrag und gehen dann auf "Edit".
Für unser Servlet brauchen wir weder doGet noch doPost. Wir beschränken uns auf die service-Methode.
Hier das von Eclipse erzeugte Servlet.
Hier das Bild mit den Änderungen im Servletcode.
Weiter unten sehen wir den Server im Projekt Explorer und auf dem dritten Tab neben "Markers" und "Properties"
das Tab "Servers", das hier bereits angewählt ist.
In diesem wichtigen letzten Konfigurationsschritt erstellen wir eine von der Hauptinstanz unabhängige Instanz
des Tomcat Servers für Eclipse. Durch einen Doppelclick auf den Eintrag "Tomcat v6.0 Server at localhost [Stopped]"
im Tab Server öffnet sich im Hauptfenster ein "Overxxxxx" Dialog. Es werden uns hier bereits die Parameter der
Eclips-eigenen Tomcatinstanz gezeigt. Diese Defaulteinstellung hat aber lediglich die Parameter aus der
Hauptinstanz übernommen. Wird die Hauptinstanz nicht von Hand gestoppt läßt sich die Eclipseinstanz nicht starten.
Um die Eclipseinstanz unabhängig von der Hauptinstanz zu machen müssen wir die drei unter "Ports" angegebenen
Ports ändern. Die restlichen Einstellungen brauchen nicht geändert zu werden. Man kann jedoch der Deutlichkeit halber
unter "General Information" den Sewrvernamen ändern. (Bemerkung: Da bei mir neben Tomcat auch noch Glassfish läuft,
habe ich den Tomcatport von 8080 auf 7070 geändert.)
Hier sind jetzt die neuen Ports eingetragen. Man kann auch andere wählen, nur frei müssen sie sein.
Das Speichern der Konfiguration nicht vergessen.
Nun läßt sich der Server problemlos starten und stoppen. Starten mit dem grünen umrandeten weißen Dreieck.
Stoppen mit dem kleinen roten Quadrat.
Wir öffnen das kleine Menu über das schwarze Dreieck neben dem linken grünumradneten Dreieck
Im Run on Server Dialog gehen wir neugierdehalber mal auf "Next".
und finden unser bereits eingetragenes Servlet.
"Finish" startet unser Servlet.
Nimmt man Änderungen am Quellcode vor, so wird man beim nächsten Start gefragt ob der Server neu gestartet werden soll. Der Tomcat Manager erübrigt sich also.
Nicht immer realisiert Eclipse Änderungen am Quellcode. Dann muß man einenn neuen Build erzwingen. Hierfür geht man am besten über Clean und wählt das Projekt aus.
Wenn wir unsere Webapplikation auf einem anderen Servletcontainer starten lassen wollen (anderer Tomcat, Glassfish, JBoss)
müssen wir unsere Applikation in eine war-Datei packen. Dazu gibt es das Konsoltool jar.exe, dessen Syntax sich an das
Kommando tar der Linuxwelt anlehnt. Aber natürlich kann das auch Eclipse.
Am einfachsten ist es, wenn wir uns im Project Explorer das Kontextmenu zum Eintrag "HelloWorldServlet" holen.
Im Dialog "WAR Export" trägt man die gewünschte Ausstattung ein.
Das Anlegen einer JSP verläuft sehr ähnlich zum Anlegen eines Servlets. Zunächst brauchen wir wieder ein
Dynamic Web Project. Deshalb gehen wir davon aus, daß die folgenden Screenshots nicht näher erläutert werden müssen.
Das Erstellen der war-Datei verläuft genauso wie bei Servlets.
Eine JSP-Bean ist eine Javaklasse die von einer Java Server Page verwendet wird. In der JSP-Datei
können Methoden dieser Klasse aufgerufen werden. Eine JSP-Beanklasse muß in einem Packageverzeichnis
unterhalb des classes-Verzeichnis des WEB-INF Verzeichnisses liegen, damit sie in der JSP-Datei erkannt wird.
Eclipse legt eine Beanklasse überraschenderweise nicht an diese Stelle, sondern verwaltet diese Datei in
einem anderen Verzeichnis. Obwohl die Beanklasse also nicht in einem Verzeichnis unterhalb des classes-Verzeichnisses
liegt wird sie von Eclipse beim Start einer JSP-Anwendung richtig zugordnet und von der JSP-Datei erkannt.
In einer realen Tomcat-Umgebung muß die Beanklasse jedoch in einem Packageverzeichnis unterhalb des classes-Verzeichnisses
liegen. Beim Erstellen einer war-Datei (siehe oben) wird dann von Eclipse die Bean an die richtige Stelle gelegt. Die so
erstellte war-Datei kann man dann von Tomcat problemlos entpacken lassen.
Über das Kontextmenu legt man eine neue Klasse in einem Packageverzeichnis an.
Die Klasse erscheint nicht unter WebContent sondern unter Java Resources, was ein wenig irreführend ist.
Als nächstes ergänzen wir die JSP-Datei um ihr die JSP-Bean bekannt zu machen:
Man beachte dazu die beiden Einträge vor <html> und den Aufruf der Methode im <body>.
Das nächste Bild zeigt das Ergebnis des Aufrufs der JSP-Datei.
Bekanntlich wird jede Java Server Page beim ersten Aufruf geparst und vom Servletcontainer in ein Servlet übersetzt.
Dieses Servlet wird dann gestartet. Bei der Entwicklung einer Java Server Page kommt es immer wieder vor, daß nach
Änderungen auf der Java Server Page das zugehörige Servlet nicht neu angelegt wird. Die Ansicht im Browser liefert
dann entweder eine lauffähige, aber alte Fassung oder es erscheinen die alten Fehlermeldungen. Hier hilft nur ein
manueller Eingriff, das zugehörige Servlet muß von Hand gelöscht werden, auf diese Weise wird der Servletcontainer
gezwungen die JSP-Datei neu zu parsen.
Schon bei Tomcat ist dieses Servlet nicht einfach zu finden, es befindet sich sehr gut vertseckt im sog. work-Verzeichnis.
Legt man etwa bei Tomcat eine Java Server Page ( hier hello.jsp) in ein Webapps-Verzeichnis
so befindet sich das zugehörige Servlet unter
Eclipse aber versteckt diese Datei nochmal "etwas" besser indem es das Workverzeichnis in den Metadaten anlegt.
Vom Workverzeichnis geht es dann analog wie bei Tomcat abwärts.
Hier muß man also evtl. eingreifen und die class-Datei von Hand löschen.
Es gibt die Möglichkeit, das gesamte Workverzeichnis an eine andere Stelle zu legen.
So bietet es sich etwa an, das Verzeichnis tmp0 an eine besser zugängliche
Stelle zu legen, z. Bsp. direkt in den workspace von Eclipse, den man ja auch selbst anlegt.
Dazu öffnet man das zum Server gehörende Übersichtsfenster mit einem Doppelclick auf den Servereintrag
im Servertab. Hier klickt man auf Open lauch configuration und öffnet das Tab Arguments
Unter VM Arguments sieht man die folgenden vier editierbaren Einträge:
Im ersten und dritten Eintrag könnten wir etwa
C:\eclipse-workspace\.metadata\.plugins\org.eclipse.wst.server.core\tmp0
ersetzen durch
C:\eclipse-workspace\tmp
|
|
|