Visual Studio Code allows you to debug Java applications through the Debugger for Java extension. It’s a lightweight Java debugger based on Java Debug Server, which extends the Language Support for Java™ by Red Hat.
Here’s a list of supported debugging features:
- Launch/Attach
- Breakpoints
- Exceptions
- Pause & Continue
- Step In/Out/Over
- Variables
- Call Stacks
- Threads
- Debug Console
- Evaluation
- Hot Code Replace
Install
To get the complete Java language support in Visual Studio Code, you can install the Extension Pack for Java, which includes the Debugger for Java extension.
Configure
By default, the debugger will run out-of-box by automatically finding the main class and generating a default launch configuration in memory to launch your application.
If you would like to customize and persist your launch configuration, you can select the create a launch.json file link in the Run and Debug view.
The launch.json file is located in a .vscode folder in your workspace (project root folder).
For more details on how to create the launch.json, read Launch configurations; for more details on configuration options for Java, you can read Configuration options.
Run and Debug
The debugger extension provides multiple ways to run and debug your Java application.
Run from CodeLens
You will find Run|Debug on the CodeLens of your main() function.
Run from Editor menu
Another way to start debugging is to select Run Java or Debug Java menu from the top editor title bar.
Run from pressing F5
Pressing F5, the debugger will automatically find the entry point of your project and start debugging. You can also start a debugging session from the Run and Debug view from the side bar of VS Code
Debugging single files
In addition to support for debugging Java projects managed by build tools, VS Code also supports for debugging single Java files without any project.
Debug session inputs
The default Debug Console in VS Code doesn’t support inputs. If your program need inputs from a terminal, you can use the Integrated Terminal (Ctrl+`) within VS Code or an external terminal to launch it. You can also use the user setting java.debug.settings.console to configure a global console for all Java debug sessions.
Breakpoints
The Debugger for Java supports various breakpoints, such as line breakpoints, conditional breakpoints, data breakpoints, logpoints.
Breakpoint – Conditional breakpoint
With the help of expression evaluation, the debugger also supports conditional breakpoint. You can set your breakpoint to break when expression evaluates to true.
Breakpoint – Data breakpoint
You can have the debugger break when a variable changes its value. Note that the data breakpoint can only be set inside a debug session. This means you need to launch your application and break on a regular breakpoint first. You can then pick a field in the VARIABLES view and set a data breakpoint.
Breakpoint – Logpoints
Logpoints is also supported by Java Debugger. Logpoints allow you to send output to Debug Console without editing code. They’re different from breakpoints because they don’t stop the execution flow of your application.
Expression evaluation
The debugger also lets you evaluate expressions in the WATCH window as well as the Debug Console.
Hot Code Replace
Another advanced feature the debugger supports is ‘Hot Code’ replacement. Hot Code Replace (HCR) is a debugging technique whereby the Debugger for Java transmits the class changes over the debugging channel to another Java Virtual Machine (JVM). HCR facilitates experimental development and fosters iterative trial-and-error coding. With this new feature, you can start a debugging session and change a Java file in your development environment, and the debugger will replace the code in the running JVM. No restart is required, which is why it’s called “hot”. Below is an illustration of how you can use HCR with Debugger for Java in VS Code.
You may use the debug setting java.debug.settings.hotCodeReplace to control how to trigger Hot Code Replace. The possible setting values are:
manual– Click the toolbar to apply the changes (default).auto– Automatically apply the changes after compilation.never– Disable Hot Code Replace.
Step filtering
Step filter is supported by the extension to filter out types that you do not want to see or step through while debugging. With this feature, you can configure the packages to filter within your launch.json so they could be skipped when you step through.
Configuration options
There are many options and settings available to configure the debugger. For example, configuring the JVM arguments and environment variables is easily done with launch options.
Consult the documentation for the Language Support for Java™ by Red Hat extension for help with setting up your project.
For many commonly used setups, there are samples available in VS Code Java Debugger Configuration. The document explains how the Java debugger automatically generates configurations for you, and if you need to modify them, how to do so with Main class, different arguments, environment, attaching to other Java processes, and usage of more advanced features.