Debuggen von JSP mit Lomboz

Vorwort
Jeder, der Erfahrung im JSP-Schreiben hat, kennt die Schwierigkeiten beim JSP-Debuggen. Aufgrund des Fehlens automatisierter Debugging-Tools müssen beim Debuggen von JSP eine große Anzahl von Druckanweisungen in Dateien verwendet werden. Dieser Ansatz ist eine einfache und effektive Methode zum Auffinden von Fehlern im JSP-Bereich, reicht jedoch nicht aus, um interne Fehler von in JSP aufgerufenen Objekten schnell und effektiv zu lokalisieren. Denn hierfür muss der Server häufig kompiliert, veröffentlicht, gestartet und gestoppt werden, was beim Debuggen große Unannehmlichkeiten mit sich bringt.

Das legendäre WYSIWYG-JSP-Debugging-Tool existiert nach derzeitigem Kenntnisstand des Autors nicht. Wenn Leser hierzu Informationen haben, lassen Sie es mich bitte wissen. Es gibt jedoch JSP-Debugging-Tools, und sie sind kostenlos! Es ist Lomboz. Download-Adresse: http://www.objectlearn.com/products/download.jsp

Dieser Artikel beginnt mit einem einfachen Beispiel, um zu beschreiben, wie Lomboz zum Debuggen von JSP verwendet wird. Die Entwicklungsumgebung dieses Beispiels ist wie folgt:

-JDK-Version: 1.4.1

;

-Lomboz: Plug-in für Eclipse2.1;

-JSP/Servlet-Container: Tomcat 4.1.18.

Einführung in Lomboz
Streng genommen ist lomboz ein J2EE-Plug-in für Eclipse. Es integriert viele Java-Anwendungsserver, J2EE-Komponenten und die Entwicklung von Webanwendungen in Eclipse, was Java-Entwicklern dabei helfen kann, Eclipse zum Erstellen, Testen und Bereitstellen von J2EE-Anwendungen zu verwenden. Für den Schwerpunkt dieses Artikels, das JSP-Debugging, gibt es auch entsprechende Unterstützung:

-Unterstützt das JSP-Schreiben, einschließlich: Syntaxfärbung und Syntaxprüfung;

-Unterstützt das JSP-Debugging.

Beim JSP-Debugging besteht das Prinzip von Lomboz darin, den von der zu debuggenden JSP-Seite generierten Java-Code zu debuggen. Der gesamte Debugging-Prozess ist derselbe wie bei einer Java-Anwendung, sodass sowohl das Debuggen der JSP selbst als auch das Debuggen des von der JSP aufgerufenen Objekts nahtlos miteinander verbunden sind.

Bevor wir mit den Beispielen in diesem Artikel beginnen, werfen wir einen Blick auf die Installation von Lomboz und die Konfiguration für die normale Verwendung seiner JSP-Debugging-Funktion.

Installation und Konfiguration
Der Installationsprozess von Lomboz ist sehr einfach. Die meisten Eclipse-Plug-In-Installationsprozesse sind wie folgt:

1. Laden Sie es von der Lomboz-Download-Adresse herunter ( http://www.objectlearn.com/products/download). jsp ), um Eclipse2 (oder andere Versionen von Eclipse) zu unterstützen.

2. Wenn Eclipse bereits läuft, schließen Sie es bitte zuerst.

3. Extrahieren Sie die heruntergeladene Datei in das Plugins-Verzeichnis im Eclipse-Installationsverzeichnis.

4. Starten Sie Eclipse neu und öffnen Sie „Über Eclipse-Plattform-Plug-ins“ (Hilfe -> Über Eclipse-Plattform -> Plug-in-Details). Wenn lomboz erfolgreich installiert wurde, werden Informationen dazu angezeigt. Wie unten gezeigt:

Hinweis: Wenn Sie Lomboz deinstallieren möchten, müssen Sie nur das Verzeichnis löschen, das Lomboz im Plugins-Verzeichnis entspricht.

5. Richten Sie die Lomboz J2EE-Ansicht ein, öffnen Sie Fenster -> Perspektive anpassen, wie in der Abbildung gezeigt:

1. Konfigurieren Sie das JDK, wählen Sie „Windows -> Einstellungen“, wählen Sie Lomboz und konfigurieren Sie das JDK. Wie in der Legende gezeigt:

2. Definieren Sie den Server. Wenn Ihr Server bereits in der Standardserverliste von Lomboz enthalten ist, kann dieser Schritt übersprungen werden. Die Lomboz-Standardserverliste erhalten Sie, indem Sie Lomboz in der Benutzeroberfläche des vorherigen Schritts erweitern und dann „Serverdefinitionen“ auswählen. Im Folgenden wird am Beispiel des Hinzufügens von Tomcat4.1.18 erläutert, wie ein Server hinzugefügt wird. Die relevanten Schritte sind wie folgt:

a) Geben Sie das Unterverzeichnis „server“ des Lomboz-Installationsverzeichnisses ein, kopieren Sie eine .server-Datei (z. B. tomcat410.server) und benennen Sie sie in tomcat418.server um.

b) Öffnen Sie diese Datei und ändern Sie die folgenden Speicherorte dieser Datei:

- , ändern Sie den Wert von name in den gewünschten Namen (z. B. Apache Tomcat v4.1.8), dieser Name wird verwendet zur Anzeige im Serverlistenteil der Schnittstelle „Serverdefinitionen“

– , wobei der Standardwert in das Verzeichnis geändert wird, in dem sich Tomcat auf Ihrem Computer befindet Maschine, z. B. D:/Program Files/Java/tomcat- 4.1.18;

- , wobei der Standardwert in einen beliebigen Namen geändert wird (z. B. TOMCAT418). Wird verwendet, um den Standard-ClassPath-Variablennamen des Lomboz-Projekts darzustellen;

- , wobei der Standardwert in das Verzeichnis geändert wird, in dem sich Tomcat auf Ihrem Computer befindet, z. B. D:/Program Files/Java/tomcat-4.1.18;

c) jasper-runtime.jar hinzufügen. Standardmäßig enthält die Datei TomcatX.server nur zwei JAR-Dateien: servlet.jar und bootstrap.jar, aber jasper-runtime.jar fehlt. Diese JAR-Datei spielt eine sehr wichtige Rolle im JSP-Debugging-Prozess. Fügen Sie sie daher bitte hinzu. Es gibt zwei Möglichkeiten, ein JAR zu einem Server hinzuzufügen:

Methode 1:

Fügen Sie eine Zeile im Abschnitt der gerade bearbeiteten .server-Datei hinzu: ${classPathVariableName}/common/lib/ jasper-runtime.jar;

Methode 2: Verwenden Sie die Schnittstelle „Serverdefinitionen“, die hier nicht noch einmal beschrieben wird.

Der konfigurierte Server wird im Formular „Serverdefinitionen“ angezeigt, wie unten dargestellt:

Hinweis: Tomcat4.x-Server müssen gepatcht werden, damit Lomboz ordnungsgemäß funktioniert. Die Download-Adresse des Patches lautet:

http://www.sysdeo.com/

Zu diesem Zeitpunkt sind die Installation und Konfiguration von Lomboz abgeschlossen Wir erstellen ein „Hello World!“-Beispiel, um den Prozess des Lomboz-Debuggens von JSP zu erleben.

Debuggen von JSPs
Erstellen Sie ein Projekt. Um Lomboz zum Debuggen von JSP zu verwenden, müssen Sie zunächst ein Lomboz-Projekt erstellen. Die Schritte sind wie folgt:

1. Öffnen Sie Datei->Neu->Lomboz J2EE-Projekt und erstellen Sie ein Projekt mit dem Namen debugJsp.

2. Wählen Sie „Weiter“, um die Seite zur Auswahl der Lomboz-Projekteigenschaften aufzurufen und das Webmodul und den verwendeten Server hinzuzufügen. Da unsere Hauptaufgabe darin besteht, JSP zu debuggen, kann das EJB-Modul leer sein. Wie unten gezeigt:

3. Wählen Sie „Fertig stellen“ und das Lomboz-Projekt wird erstellt. Zu diesem Zeitpunkt sieht die von Lomboz generierte Dateistruktur wie folgt aus:

Als nächstes können wir die benötigten JSP-Dateien erstellen. In diesem Beispiel verwende ich direkt die Standarddatei index.jsp und ändere ihren Inhalt in:

Bisher sind unsere Vorbereitungen für das Debuggen von JSP ungefähr abgeschlossen, aber diejenigen, die Tomcat4.x verwenden, benötigen noch zusätzliche Schritte (diese Schritte werden hauptsächlich durch tomcat4.x selbst verursacht):

1. Fügen Sie in Tomcat die folgenden Zeilen hinzu die Datei server.xml im Konfigurationsverzeichnis (spezifische Speicherorte finden Sie in der Dokumentation zu server.xml):

Unter diesen stellt path den URL-Namen der Webanwendung dar; docBase stellt den physischen Speicherort der Webanwendung dar; workDir stellt den Speicherort dar, an dem die Java-Datei generiert wird, die JSP entspricht. Sie müssen Erstellen Sie orgapachejsp wie folgt. Verzeichnisstruktur und Namen.

2. Erstellen Sie die entsprechende Unterverzeichnisstruktur im entsprechenden j2src-Verzeichnis gemäß orgapachejsp und legen Sie j2src als Quellverzeichnis des Projekts fest.

Syntaxprüfung Lassen Sie uns nun den Prozess des Debuggens von JSP genießen. Vor dem Debuggen sollte die JSP keine Syntaxfehler aufweisen. Lomboz bietet die Funktion der JSP-Syntaxprüfung. Der spezifische Vorgang ist:

1. Wählen Sie die JSP-Datei aus, deren Syntax überprüft werden soll, und klicken Sie mit der rechten Maustaste.

2. Wählen Sie Lomboz j2ee... -> Jsp-Syntax prüfen

. Der nächste Schritt besteht darin, die logischen Fehler zu beheben. Diese Art von Fehler kann nur durch Debuggen behoben werden. Der Prozess der Verwendung von Lomboz zum Debuggen von JSP ist dem Debuggen gewöhnlicher JAVA-Anwendungen sehr ähnlich, da sein Prinzip darin besteht, zunächst den Server zum Generieren von JAVA-Dateien entsprechend JSP zu verwenden und diese dann zu debuggen.

Die Schritte zum Debuggen von JSP sind wie folgt:

1. Öffnen Sie Lomboz J2EE View, wählen Sie den Server aus, klicken Sie mit der rechten Maustaste und wählen Sie „Server debuggen“. Wie im Bild gezeigt:

Wenn die .server-Datei korrekt definiert ist, wird Tomcat gestartet. Wenn Tomcat nicht wie erwartet startet, beheben Sie den Fehler bitte anhand dieser beiden Aspekte: Tomcat-Umgebungsvariablen und Lomboz-Serverdatei.

2. Öffnen Sie einen Browser, z. B. IE, und geben Sie http://127.0.0.1:8080/debugJsp/index.jsp in die Adressleiste ein. Wenn in der JSP-Datei kein Syntaxfehler vorliegt, wird die der JSP-Datei entsprechende JAVA-Datei im Verzeichnis j2srcorgapachejsp des Projekts generiert. Aktualisieren Sie das Projekt, um diese Dateien anzuzeigen. Wie im Bild gezeigt:

Dieser Schritt dient hauptsächlich dazu, den Server dazu zu veranlassen, Java-Dateien für das Debuggen basierend auf JSP zu generieren. Sie müssen sich nicht zu viele Gedanken darüber machen, ob die Ergebnisse korrekt sind. Denn sobald die Java-Datei generiert ist, können diese Fehler durch Debuggen behoben werden.

3. Öffnen Sie die Java-Datei, legen Sie einen Haltepunkt fest und geben Sie die URL erneut in die Adressleiste des IE ein. Zu diesem Zeitpunkt wird die Debugging-Funktion von Eclipse aktiviert. Zu diesem Zeitpunkt kann JSP gezielt debuggt werden. Die Situation ist zu diesem Zeitpunkt wie in der Abbildung dargestellt:

Was das Debuggen des von JSP aufgerufenen Objekts betrifft, erfolgt nach Abschluss der obigen Schritte das dem Objekt entsprechende Java

Setzen Sie einfach Haltepunkte in der Datei.

Fazit Obwohl das aktuelle Debuggen von JSP nicht so praktisch ist wie das Debuggen gewöhnlicher Java-Dateien, hat das Aufkommen von Tools wie Lomboz zumindest die Phase des manuellen Debuggens von JSP beendet. Von nun an müssen Entwickler von Java-Webanwendungen das Programm nicht mehr von Zeit zu Zeit stoppen, um Druckanweisungen manuell hinzuzufügen, um die Werte von Variablen aufgrund einiger Fehler zu beobachten. Im Gegenteil, sie können Änderungen dieser Werte beobachten während das Programm ausgeführt wird, genau wie beim Debuggen gewöhnlicher JAVA-Anwendungen. Dies erleichtert die Entwicklung WEB-basierter Anwendungen erheblich und reduziert die bisher für das Debuggen verschwendete Zeit.