World Map
Java Service Wrapper ist der einfachste Weg, um Ihr Produkt zuverlässiger, sicherer zu machen.
  • Free Trial
  • Buy Now

Problem

Wie kann ich die Remote-Fehlersuche meiner Anwendung innerhalb von Eclipse ausführen?

Arrow

Lösung!

Fügen Sie eine entfernte Java-Anwendung der Debug-Konfiguration in Eclipse hinzu.

Deadlock Eclipse(R) hat einen grossen Umfang an Tools, wie z.B. den Debugger. Ein Debugger erlaubt einem User, ein Programm während der Ausführung zu steuern. Die Nutzung eines Debuggers, um zu verstehen, wie ein Programm funktioniert, ist eine gute Methode, um potentielle Fehler zu finden. Der Debugger kann entfernt mit einer JVM verbunden sein, die innerhalb des Wrappers läuft und Sie können Schritt für Schritt sehen, was passiert. Im folgenden Beispiel sehen Sie, wie einfach es ist, den Debugger zu installieren.

Lösung

Download des Java Service Wrappers

In diesem Beispiel werden wir die zuletzt verfügbare Version des Wrappers benutzen: 3.5.26. Bitte laden Sie den Wrapper für Ihre Plattform herunter und speichern Sie ihn auf Ihrer Festplatte. Zum Beispiel: /home/tanuki/wrapper-3.5.26/

Download des Java-Quellcodes

Der Quellcode des Java Service Wrappers ist über SourceForge verfügbar. Bitte laden Sie den Quellcode hier herunter Download für die Version, die Sie gerade in dem vorhergehenden Schritt heruntergeladen haben. In diesem Beispiel werden wir den Quellcode der Version 3.5.26. nutzen.

Extrahieren Sie die Dateien irgendwo auf Ihrer Maschine, zum Beispiel: /home/tanuki/wrapper_3.5.26_src

NOTE

Der Java-Quellcode ist für alle Editionen des Wrappers (Community, Standard und Professional) der Gleiche.

Eclipse-Dateien

Erstellen Sie die folgenden zwei Dateien (genutzt von Eclipse) in dem Ordner: /home/tanuki/wrapper_3.5.26_src/src/java

.classpath
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
    <classpathentry kind="src" path="."/>
    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
</classpath>
.project
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
    <name>wrapper-code</name>
    <comment></comment>
    <projects>
    </projects>
    <buildSpec>
        <buildCommand>
            <name>org.eclipse.jdt.core.javabuilder</name>
            <arguments>
            </arguments>
        </buildCommand>
    </buildSpec>
    <natures>
        <nature>org.eclipse.jdt.core.javanature</nature>
    </natures>
</projectDescription>

Eclipse

Importieren Sie den Java-Quellcode in Eclipse:

  • Start von Eclipse
  • Klicken Sie auf Datei
  • Fahren Sie mit Import fort
  • Wählen Sie Allgemein> Existing Projects into Workspace
  • Gehen Sie zu Next
  • Wählen Sie den Ordner /home/tanuki/wrapper_3.5.26_src/src/java
  • Klicken Sie auf Beenden

So bald der Ordner importiert ist, werden Sie in Eclipse einen Fehler sehen. Um diesen zu beheben, folgen Sie bitte den folgenden Schritten:

  • Entfernen Sie die Dateiendung .in von der Datei org.tanukisoftware.wrapper.WrapperInfo.java.in
Öffnen Sie die Datei und führen Sie die folgenden Änderungen durch:
  • Ändern Sie @version.root@ auf 3.5.26
  • Ändern Sie @build.date@ auf 20131212
  • Ändern Sie @build.time@ auf 1200

Meine Anwendung

In Eclipse werden wir eine Anwendung "MyApplication" ausführen, die von dem Java Service Wrapper gestartet wird. Der Ordner für dieses Projekt ist /home/tanuki/workspace/MyApplication.

Erstellen Sie eine Klassemy.app.test.HelloWorld.

HelloWorld.java
package my.app.test;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import org.tanukisoftware.wrapper.WrapperManager;

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Enter your name: ");

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        String name = "";

        try {
            name = br.readLine();
        } catch (IOException ioe) {
            System.out.println("Could not read your name!");
            System.exit(1);
        }

        System.out.println("Hello, " + name + "!");
        
        String version = WrapperManager.getVersion();
        System.out.println("Wrapper Version: " + version);
    }
}

Eclipse wird ein paar Fehler über den WrapperManager anzeigen. Um diese zu beheben, öffnen Sie die Eigenschaften von MyApplication und fügen den Wrapper-Code in den Build-Path hinzu.

Verbinden Sie den Java Service Wrapper mit MyApplication

Öffnen Sie die Datei /home/tanuki/wrapper-3.5.26/conf/wrapper.conf und setzen Sie die folgenden Eigenschaften:

wrapper.conf
# information to run MyApplication
wrapper.java.mainclass=org.tanukisoftware.wrapper.WrapperSimpleApp

# set the path to your application
wrapper.java.classpath.3=/home/tanuki/workspace/MyApplication/bin
wrapper.app.parameter.1=my.app.test.HelloWorld

# set the Wrapper in debug mode
wrapper.java.additional.1=-Xdebug
wrapper.java.additional.2=-Xrunjdwp:transport=dt_socket,address=8001,server=y,suspend=y

NOTE

Port 8001 wird später von Eclipse genutzt.

In diesem Beispiel benutzen wir den Link Integrationsmethode 1, um MyApplication mit dem Java Service Wrapper zu integrieren.

Ausführen des Java Service Wrappers

Führen Sie den Java Service Wrapper über folgenden Befehl aus:

TestWrapper Example Application
bin/testwrapper console console

Sie sehen, dass der Prozess abgestürzt erscheint.

Warten auf einen Debugger
Listening for transport dt_socket at address: 8001
Tatsächlich wartet der Wrapper darauf, dass ein Debugger verbunden wird.

Ausführen des Debuggers

In Eclipse führen Sie die folgenden Schritte aus, um einen Remote-Debugger zu erstellen:

  • Wählen Sie im Menü Debug->Debug Configuration...->Remote Java Application.
  • Erstellen Sie eine neue Startkonfiguration.
  • Setzen Sie einen Namen (zum Beispiel "RemoteWrapper")
  • Wählen Sie das Projekt wrapper-code aus.
  • Stellen Sie den Host auf localhost ein.
  • Stellen Sie den Port auf 8001 ein(der gleiche Wert, den wir in der wrapper.conf gesetzt haben)
  • Klicken Sie auf das Register Quelle
  • Klicken Sie auf Hinzufügen, wählen Sie das Javaprojekt und wählen Sie beides MyApplication und Wrapper-Code.
  • Klicken Sie schließlich auf Debug

Von diesem Punkt an ist der Eclipse-Debugger mit MyApplication und dem Wrapper verbunden! Wenn Sie auf den Terminal schauen, sehen Sie, dass MyApplication läuft. Zurück im Quellcode können Sie einen Haltepunkt hinzufügen und die Anwendung debuggen. Sie können sehen, welche Zeile ausgeführt wird.