Java ausführen und debuggen

Visual Studio Code ermöglicht es Ihnen, Java-Anwendungen über die Debugger for Java-Erweiterung zu debuggen. Es handelt sich um einen leichten Java-Debugger, der auf dem Java Debug Server basiert und die Language Support for Java™ by Red Hat erweitert.

Hier ist eine Liste der unterstützten Debugging-Funktionen

• Starten/Anfügen
• Haltepunkte
• Ausnahmen
• Pause & Fortsetzen
• Schrittweise Ausführung (Ein/Aus/Über)
• Variablen
• Aufruflisten
• Threads
• Debug-Konsole
• Bewertung
• Hot Code Replace

Der Java-Debugger ist ein Open-Source-Projekt, das Mitwirkende zur Zusammenarbeit über GitHub-Repositorys willkommen heißt.

• Debugger for Java
• Java Debug Server für Visual Studio Code

Wenn bei der Verwendung der unten aufgeführten Funktionen Probleme auftreten, können Sie uns kontaktieren, indem Sie ein Problem melden.

Installation

Um die vollständige Java-Sprachunterstützung in Visual Studio Code zu erhalten, können Sie das Extension Pack for Java installieren, das die Debugger for Java-Erweiterung enthält.

Extension Pack for Java installieren

Details zur Einführung in das Extension Pack finden Sie im Tutorial Getting Started with Java.

Konfigurieren

Standardmäßig läuft der Debugger sofort, indem er die Hauptklasse automatisch findet und eine Standard-Startkonfiguration im Speicher generiert, um Ihre Anwendung zu starten.

Wenn Sie Ihre Startkonfiguration anpassen und dauerhaft speichern möchten, können Sie in der Ansicht **Run and Debug** den Link **create a launch.json file** auswählen.

Die Datei launch.json befindet sich in einem Ordner .vscode in Ihrem Arbeitsbereich (Projekt-Stammordner).

Weitere Details zur Erstellung von launch.json finden Sie unter Launch-Konfigurationen. Weitere Details zu Konfigurationsoptionen für Java finden Sie unter Konfigurationsoptionen.

Ausführen und Debuggen

Die Debugger-Erweiterung bietet mehrere Möglichkeiten, Ihre Java-Anwendung auszuführen und zu debuggen.

Aus CodeLens ausführen

Sie finden **Run|Debug** in der CodeLens Ihrer main()-Funktion.

Aus dem Editor-Menü ausführen

Eine weitere Möglichkeit, mit dem Debugging zu beginnen, ist die Auswahl des Menüs **Run Java** oder **Debug Java** aus der oberen Titelleiste des Editors.

Durch Drücken von F5 ausführen

Wenn Sie F5 drücken, findet der Debugger automatisch den Einstiegspunkt Ihres Projekts und beginnt mit dem Debugging. Sie können eine Debug-Sitzung auch aus der Ansicht **Run and Debug** in der Seitenleiste von VS Code starten. Mehr dazu erfahren Sie unter Debugging in VS Code.

Einzelne Dateien debuggen

Zusätzlich zur Unterstützung für das Debugging von Java-Projekten, die von Build-Tools verwaltet werden, unterstützt VS Code auch das Debugging einzelner Java-Dateien ohne Projekt.

Eingaben in Debug-Sitzungen

Die Standard-Debug-Konsole in VS Code unterstützt keine Eingaben. Wenn Ihr Programm Eingaben von einem Terminal benötigt, können Sie das integrierte Terminal (⌃` (Windows, Linux Ctrl+`)) innerhalb von VS Code oder ein externes Terminal verwenden, um es zu starten. Sie können auch die Benutzereinstellung java.debug.settings.console verwenden, um eine globale Konsole für alle Java-Debug-Sitzungen zu konfigurieren.

Haltepunkte

Der Debugger for Java unterstützt verschiedene Haltepunkte, wie z. B. Zeilenhaltepunkte, bedingte Haltepunkte, Datenhaltepunkte und Logpunkte.

Haltepunkt - Bedingter Haltepunkt

Mithilfe der Auswertung von Ausdrücken unterstützt der Debugger auch bedingte Haltepunkte. Sie können Ihren Haltepunkt so einstellen, dass er unterbrochen wird, wenn der Ausdruck zu "true" ausgewertet wird.

Haltepunkt - Datenhaltepunkt

Sie können den Debugger anhalten lassen, wenn sich der Wert einer Variablen ändert. Beachten Sie, dass der Datenhaltepunkt nur innerhalb einer Debug-Sitzung gesetzt werden kann. Das bedeutet, Sie müssen Ihre Anwendung starten und zunächst einen regulären Haltepunkt setzen. Sie können dann ein Feld in der Ansicht **VARIABLEN** auswählen und einen Datenhaltepunkt setzen.

Haltepunkt - Logpunkte

Logpunkte werden ebenfalls vom Java Debugger unterstützt. Logpunkte ermöglichen es Ihnen, Ausgaben in die Debug-Konsole zu senden, ohne Code zu bearbeiten. Sie unterscheiden sich von Haltepunkten, da sie den Ausführungsfluss Ihrer Anwendung nicht stoppen.

Haltepunkt - Ausgelöste Haltepunkte

Ein ausgelöster Haltepunkt ist ein Haltepunkt, der automatisch aktiviert wird, sobald ein anderer Haltepunkt getroffen wird. Sie können sehr nützlich sein, um Fehlerfälle im Code zu diagnostizieren, die nur nach einer bestimmten Vorbedingung auftreten.

Ausgelöste Haltepunkte können durch Rechtsklick auf den Glyph-Rand gesetzt werden, indem Ausgelösten Haltepunkt hinzufügen ausgewählt und dann gewählt wird, welcher andere Haltepunkt den Haltepunkt aktiviert.

Auswertung von Ausdrücken

Der Debugger ermöglicht es Ihnen auch, Ausdrücke im **WATCH**-Fenster sowie in der Debug-Konsole auszuwerten.

Hot Code Replace

Eine weitere erweiterte Funktion, die der Debugger unterstützt, ist 'Hot Code' Replacement. Hot Code Replace (HCR) ist eine Debugging-Technik, bei der der Debugger for Java Klassenänderungen über den Debugging-Kanal an eine andere Java Virtual Machine (JVM) überträgt. HCR erleichtert die experimentelle Entwicklung und fördert iteratives Ausprobieren. Mit dieser neuen Funktion können Sie eine Debug-Sitzung starten und eine Java-Datei in Ihrer Entwicklungsumgebung ändern, und der Debugger ersetzt den Code in der laufenden JVM. Ein Neustart ist nicht erforderlich, weshalb es "hot" genannt wird. Unten ist eine Illustration, wie Sie HCR mit Debugger for Java in VS Code verwenden können.

Sie können die Debug-Einstellung java.debug.settings.hotCodeReplace verwenden, um zu steuern, wie Hot Code Replace ausgelöst wird. Die möglichen Einstellungswerte sind

• manual - Klicken Sie auf die Symbolleiste, um die Änderungen anzuwenden (Standard).
• auto - Wenden Sie die Änderungen nach der Kompilierung automatisch an.
• never - Deaktivieren Sie Hot Code Replace.

Schrittfilterung

Die Schrittfilterung wird von der Erweiterung unterstützt, um Typen zu filtern, die Sie während des Debuggens nicht sehen oder durch die Sie nicht steppen möchten. Mit dieser Funktion können Sie die Pakete in Ihrer launch.json konfigurieren, damit sie beim schrittweisen Durchlaufen übersprungen werden.

Konfigurationsoptionen

Es gibt viele Optionen und Einstellungen, um den Debugger zu konfigurieren. Zum Beispiel ist die Konfiguration von JVM-Argumenten und Umgebungsvariablen mit Startoptionen einfach möglich.

Konsultieren Sie die Dokumentation für die Language Support for Java™ by Red Hat-Erweiterung, um Hilfe beim Einrichten Ihres Projekts zu erhalten.

Für viele häufig verwendete Setups sind Beispiele in VS Code Java Debugger Configuration verfügbar. Das Dokument erklärt, wie der Java-Debugger automatisch Konfigurationen für Sie generiert und wie Sie diese bei Bedarf mit der Hauptklasse, verschiedenen Argumenten, der Umgebung, dem Anfügen an andere Java-Prozesse und der Verwendung fortgeschrittener Funktionen ändern können.

Unten finden Sie alle verfügbaren Konfigurationen für Launch und Attach. Weitere Informationen zur Erstellung der Datei launch.json finden Sie unter Debugging.

Starten

• mainClass (erforderlich) - Der vollständig qualifizierte Klassenname (z. B. [java-modulname/]com.xyz.MainApp) oder der Java-Dateipfad des Programmeinstiegs.
• args - Die Befehlszeilenargumente, die an das Programm übergeben werden. Verwenden Sie "${command:SpecifyProgramArgs}", um zur Eingabe von Programmargumenten aufgefordert zu werden. Akzeptiert einen String oder ein Array von Strings.
• sourcePaths - Die zusätzlichen Quellverzeichnisse des Programms. Der Debugger sucht standardmäßig nach Quellcode aus den Projekteinstellungen. Diese Option ermöglicht es dem Debugger, in zusätzlichen Verzeichnissen nach Quellcode zu suchen.
• modulePaths - Die Modulpfade zum Starten der JVM. Wenn nicht angegeben, wird der Debugger automatisch aus dem aktuellen Projekt aufgelöst.
  • $Auto - Modulpfade des aktuellen Projekts automatisch auflösen.
  • $Runtime - Modulpfade im 'runtime'-Bereich des aktuellen Projekts.
  • $Test - Modulpfade im 'test'-Bereich des aktuellen Projekts.
  • !/path/to/exclude - Den angegebenen Pfad von den Modulpfaden ausschließen.
  • /path/to/append - Den angegebenen Pfad an die Modulpfade anhängen.
• classPaths - Die Klassenpfade zum Starten der JVM. Wenn nicht angegeben, wird der Debugger automatisch aus dem aktuellen Projekt aufgelöst.
  • $Auto - Klassenpfade des aktuellen Projekts automatisch auflösen.
  • $Runtime - Klassenpfade im 'runtime'-Bereich des aktuellen Projekts.
  • $Test - Klassenpfade im 'test'-Bereich des aktuellen Projekts.
  • !/path/to/exclude - Den angegebenen Pfad von den Klassenpfaden ausschließen.
  • /path/to/append - Den angegebenen Pfad an die Klassenpfade anhängen.
• encoding - Die Einstellung file.encoding für die JVM. Wenn nicht angegeben, wird 'UTF-8' verwendet. Mögliche Werte finden Sie unter Unterstützte Encodings.
• vmArgs - Die zusätzlichen Optionen und Systemeigenschaften für die JVM (z. B. -Xms<size> -Xmx<size> -D<name>=<value>). Akzeptiert einen String oder ein Array von Strings.
• projectName - Das bevorzugte Projekt, in dem der Debugger nach Klassen sucht. Es kann doppelte Klassennamen in verschiedenen Projekten geben. Diese Einstellung funktioniert auch, wenn der Debugger beim Starten eines Programms nach der angegebenen Hauptklasse sucht. Sie ist erforderlich, wenn der Arbeitsbereich mehrere Java-Projekte hat, andernfalls funktionieren die Auswertung von Ausdrücken und bedingte Haltepunkte möglicherweise nicht.
• cwd - Das Arbeitsverzeichnis des Programms. Standardmäßig ${workspaceFolder}.
• env - Die zusätzlichen Umgebungsvariablen für das Programm.
• envFile - Absoluter Pfad zu einer Datei, die Umgebungsvariablen definiert.
• stopOnEntry - Das Programm nach dem Starten automatisch anhalten.
• console - Die angegebene Konsole zum Starten des Programms. Wenn nicht angegeben, wird die Konsole verwendet, die in den Benutzereinstellungen java.debug.settings.console angegeben ist.
  • internalConsole - VS Code Debug-Konsole (Eingabestrom nicht unterstützt).
  • integratedTerminal - VS Code Integrated Terminal.
  • externalTerminal - Externes Terminal, das in den Benutzereinstellungen konfiguriert werden kann.
• shortenCommandLine - Wenn das Projekt eine lange classpath oder große VM-Argumente hat, kann die Befehlszeile zum Starten des Programms die von der Betriebssystem erlaubte maximale Längenbeschränkung überschreiten. Dieses Konfigurationselement bietet mehrere Ansätze, um die Befehlszeile zu kürzen. Standardmäßig auto.
  • none - Das Programm mit der Standardbefehlszeile 'java {options} classname {args}' starten.
  • jarmanifest - Die Klassenpfadparameter in eine temporäre `classpath.jar`-Datei generieren und das Programm mit der Befehlszeile 'java -cp classpath.jar classname {args}' starten.
  • argfile - Die Klassenpfadparameter in eine temporäre Argumentdatei generieren und das Programm mit der Befehlszeile 'java @argfile {args}' starten. Dieser Wert gilt nur für Java 9 und höher.
  • auto - Die Länge der Befehlszeile automatisch erkennen und festlegen, ob die Befehlszeile über einen geeigneten Ansatz gekürzt werden soll.
• stepFilters - Angegebene Klassen oder Methoden beim schrittweisen Durchgehen überspringen.
  • classNameFilters - [Veraltet - ersetzt durch skipClasses] Die angegebenen Klassen beim schrittweisen Durchgehen überspringen. Klassennamen müssen vollständig qualifiziert sein. Wildcards werden unterstützt.
  • skipClasses - Die angegebenen Klassen beim schrittweisen Durchgehen überspringen. Sie können eingebaute Variablen wie '$JDK' und '$Libraries' verwenden, um eine Gruppe von Klassen zu überspringen, oder einen spezifischen Klassennamen-Ausdruck hinzufügen, z. B. java.*, *.Foo.
  • skipSynthetics - Synthetische Methoden beim schrittweisen Durchgehen überspringen.
  • skipStaticInitializers - Statische Initialisierermethoden beim schrittweisen Durchgehen überspringen.
  • skipConstructors - Konstruktormethoden beim schrittweisen Durchgehen überspringen.

Anfügen

• hostName (erforderlich) - Der Hostname oder die IP-Adresse des Remote-Debuggers.
• port (erforderlich) - Der Debug-Port des Remote-Debuggers.
• processId - Prozessauswahl verwenden, um einen Prozess zum Anhängen auszuwählen, oder Prozess-ID als Integer.
  • ${command:PickJavaProcess} - Prozessauswahl verwenden, um einen Prozess zum Anhängen auszuwählen.
  • Eine Integer-PID - An den angegebenen lokalen Prozess anhängen.
• timeout - Zeitüberschreitungswert vor dem erneuten Verbinden in Millisekunden (Standard 30000 ms).
• sourcePaths - Die zusätzlichen Quellverzeichnisse des Programms. Der Debugger sucht standardmäßig nach Quellcode aus den Projekteinstellungen. Diese Option ermöglicht es dem Debugger, in zusätzlichen Verzeichnissen nach Quellcode zu suchen.
• projectName - Das bevorzugte Projekt, in dem der Debugger nach Klassen sucht. Es kann doppelte Klassennamen in verschiedenen Projekten geben. Es ist erforderlich, wenn der Arbeitsbereich mehrere Java-Projekte hat, andernfalls funktionieren die Auswertung von Ausdrücken und bedingte Haltepunkte möglicherweise nicht.
• stepFilters - Angegebene Klassen oder Methoden beim schrittweisen Durchgehen überspringen.
  • classNameFilters - [Veraltet - ersetzt durch skipClasses] Die angegebenen Klassen beim schrittweisen Durchgehen überspringen. Klassennamen müssen vollständig qualifiziert sein. Wildcards werden unterstützt.
  • skipClasses - Die angegebenen Klassen beim schrittweisen Durchgehen überspringen. Sie können eingebaute Variablen wie '$JDK' und '$Libraries' verwenden, um eine Gruppe von Klassen zu überspringen, oder einen spezifischen Klassennamen-Ausdruck hinzufügen, z. B. java.*, *.Foo.
  • skipSynthetics - Synthetische Methoden beim schrittweisen Durchgehen überspringen.
  • skipStaticInitializers - Statische Initialisierermethoden beim schrittweisen Durchgehen überspringen.
  • skipConstructors - Konstruktormethoden beim schrittweisen Durchgehen überspringen.

Benutzereinstellungen

• java.debug.logLevel: Mindestlevel der Debugger-Protokolle, die an VS Code gesendet werden, Standard ist warn.
• java.debug.settings.showHex: Zahlen im Hexadezimalformat in **Variablen** anzeigen, Standard ist false.
• java.debug.settings.showStaticVariables: Statische Variablen in **Variablen** anzeigen, Standard ist false.
• java.debug.settings.showQualifiedNames: Vollständig qualifizierte Klassennamen in **Variablen** anzeigen, Standard ist false.
• java.debug.settings.showLogicalStructure: Die logische Struktur für die Collection- und Map-Klassen in **Variablen** anzeigen, Standard ist true.
• java.debug.settings.showToString: 'toString()'-Wert für alle Klassen anzeigen, die die 'toString'-Methode überschreiben, in **Variablen**, Standard ist true.
• java.debug.settings.maxStringLength: Die maximale Länge von Strings, die in **Variablen** oder **Debug-Konsole** angezeigt werden. Strings, die länger als dieses Limit sind, werden gekürzt. Der Standardwert ist 0, was bedeutet, dass keine Kürzung erfolgt.
• java.debug.settings.hotCodeReplace: Geänderte Java-Klassen während des Debuggens neu laden, Standard ist manual. Stellen Sie sicher, dass java.autobuild.enabled nicht deaktiviert ist für die Java Language Support-Erweiterung. Informationen zu Verwendung und Einschränkungen finden Sie auf der Wiki-Seite zu Hot Code Replace.
  • manual - Klicken Sie auf die Symbolleiste, um die Änderungen anzuwenden.
  • auto - Wenden Sie die Änderungen nach der Kompilierung automatisch an.
  • never - Wenden Sie die Änderungen niemals an.
• java.debug.settings.enableHotCodeReplace: Hot Code Replace für Java-Code aktivieren. Stellen Sie sicher, dass der automatische Build für VS Code Java nicht deaktiviert ist. Informationen zu Verwendung und Einschränkungen finden Sie auf der Wiki-Seite zu Hot Code Replace.
• java.debug.settings.enableRunDebugCodeLens: Aktivieren Sie den CodeLens-Anbieter für die Schaltflächen "Run" und "Debug" über den Haupt-Einstiegspunkten, Standard ist true.
• java.debug.settings.forceBuildBeforeLaunch: Erzwingt das Erstellen des Arbeitsbereichs vor dem Starten des Java-Programms, Standard ist true.
• java.debug.settings.console: Die angegebene Konsole zum Starten eines Java-Programms, Standard ist integratedTerminal. Wenn Sie die Konsole für eine bestimmte Debug-Sitzung anpassen möchten, ändern Sie die Konfiguration console in launch.json.
  • internalConsole - VS Code Debug-Konsole (Eingabestrom nicht unterstützt).
  • integratedTerminal - VS Code Integrated Terminal.
  • externalTerminal - Externes Terminal, das in den Benutzereinstellungen konfiguriert werden kann.
• java.debug.settings.exceptionBreakpoint.skipClasses: Die angegebenen Klassen beim Auslösen von Ausnahmen überspringen. Sie können eingebaute Variablen wie '$JDK' und '$Libraries' verwenden, um eine Gruppe von Klassen zu überspringen, oder einen spezifischen Klassennamen-Ausdruck hinzufügen, z. B. java.*, *.Foo.
• java.debug.settings.stepping.skipClasses: Die angegebenen Klassen beim schrittweisen Durchgehen überspringen. Sie können eingebaute Variablen wie '$JDK' und '$Libraries' verwenden, um eine Gruppe von Klassen zu überspringen, oder einen spezifischen Klassennamen-Ausdruck hinzufügen, z. B. java.*, *.Foo.
• java.debug.settings.stepping.skipSynthetics: Synthetische Methoden beim schrittweisen Durchgehen überspringen.
• java.debug.settings.stepping.skipStaticInitializers: Statische Initialisierermethoden beim schrittweisen Durchgehen überspringen.
• java.debug.settings.stepping.skipConstructors: Konstruktormethoden beim schrittweisen Durchgehen überspringen.
• java.debug.settings.jdwp.limitOfVariablesPerJdwpRequest: Die maximale Anzahl von Variablen oder Feldern, die in einer einzigen JDWP-Anfrage angefordert werden können. Ein höherer Wert bedeutet, dass der Debuggee beim Erweitern der Variablenansicht seltener angefragt wird. Eine große Zahl kann auch zu JDWP-Anfrage-Timeouts führen. Standard ist 100.
• java.debug.settings.jdwp.requestTimeout: Das Timeout (ms) für JDWP-Anfragen, wenn der Debugger mit der Ziel-JVM kommuniziert. Standard ist 3000.
• java.debug.settings.vmArgs: Die Standard-VM-Argumente zum Starten des Java-Programms. Verwenden Sie beispielsweise '-Xmx1G -ea', um die Heap-Größe auf 1 GB zu erhöhen und Assertions zu aktivieren. Wenn Sie die VM-Argumente für eine bestimmte Debug-Sitzung anpassen möchten, können Sie die Konfiguration 'vmArgs' in launch.json ändern.
• java.silentNotification: Steuert, ob Benachrichtigungen zur Berichterstattung über den Fortschritt verwendet werden können. Wenn true, wird stattdessen die Statusleiste zur Berichterstattung über den Fortschritt verwendet. Standard ist false.

Fehlerbehebung

Wenn Sie Probleme bei der Verwendung des Debuggers auftreten, finden Sie eine detaillierte Fehlerbehebungsanleitung im vscode-java-debug GitHub-Repository.

Häufige Probleme erklärt

• Die Java Language Support-Erweiterung startet nicht.
• Build fehlgeschlagen, möchten Sie fortfahren?
• *.java befindet sich nicht auf dem Klassenpfad. Nur Syntaxfehler werden gemeldet.
• Programmfehler: Hauptklasse X konnte nicht gefunden oder geladen werden.
• Programm wirft ClassNotFoundException.
• Hot Code Replace fehlgeschlagen.
• Bitte geben Sie den Hostnamen und den Port des Remote-Debuggers in der launch.json an.
• Auswertung fehlgeschlagen. Grund: Kann nicht auswerten, da der Thread fortgesetzt wird.
• Klasse mit der main-Methode konnte nicht gefunden werden.
• Kein delegateCommandHandler für vscode.java.startDebugSession beim Starten des Debuggers.
• Klassenpfad konnte nicht aufgelöst werden.
• Anforderungstyp "X" wird nicht unterstützt. Nur "launch" und "attach" werden unterstützt.

Feedback und Fragen

Die vollständige Liste der Probleme finden Sie im vscode-java-debug Repository. Sie können einen Fehler oder eine Funktionsanfrage einreichen und am Community-gesteuerten vscode-java-debug Gitter-Kanal teilnehmen.

Nächste Schritte

Lesen Sie weiter, um mehr über Folgendes zu erfahren:

• Debugging - Erfahren Sie, wie Sie den Debugger in VS Code mit Ihrem Projekt für jede Sprache verwenden.

Und für Java

• Java-Tests - Testen Sie Java innerhalb von VS Code mit der Java Test Runner-Erweiterung.
• Java-Erweiterungen - Erfahren Sie mehr über nützliche Java-Erweiterungen für VS Code.