When you run Open Liberty in dev mode, you can rapidly code, deploy, test, and debug applications directly from your integrated development environment (IDE) or text editor. You can enable dev mode to work with either Maven or Gradle build automation tools.
With dev mode, you can quickly iterate on changes to your code and get immediate feedback from on-demand or automatic unit and integration tests. You can also attach a debugger to step through your code at any time. Dev mode is available as a goal of the Liberty Maven plug-in or as a task of the Liberty Gradle plug-in. It integrates a set of capabilities for Open Liberty so that you can edit and monitor your application in real time, without restarting your running server. Dev mode addresses three primary focus areas: deploying changes, running tests, and debugging.
Dev mode can automatically detect, recompile, and deploy code changes whenever you save a new change in your IDE or text editor. Dev mode automatically detects the following changes to your application source:
Java source file and test file changes
Resource file changes
Configuration directory and configuration file changes
New dependency additions to your
pom.xmlfile for Maven users or
build.gradlefile for Gradle users
New feature additions in the Open Liberty server configuration
Resource file, configuration file, and configuration directory changes are copied into your target directory. New dependencies in your
pom.xml file or
build.gradle file are added to your class path.
When you turn on automatic feature generation, Liberty features that your application requires are automatically generated in your server configuration. New features, whether added manually or generated, are installed and enabled automatically. Automatic feature generation is turned off by default.
Some changes, such as adding certain configuration directories or files, do not take effect until you restart dev mode. To enable these changes, restart dev mode when prompted. To restart, first exit dev mode by pressing
CTRL+C, or by typing
q and pressing
Enter. Then, run the
mvn liberty:dev command or the
gradle libertyDev command to restart. After the server restarts, the changes are detected, recompiled, and picked up by the running server.
You can configure how dev mode handles changes to your code by specifying parameters when you start dev mode. After you start dev mode, you can also view a help menu of dev mode console actions by typing
h and pressing
Enter. For more information about configuration parameters and console actions, see the dev goal of the Liberty Maven plug-in or the libertyDev task of the Liberty Gradle plug-in.
When you turn on automatic feature generation, dev mode detects the Liberty features that your application requires based on API usage and generates a feature list in a new server configuration file. The file is named
generated-features.xml and is created in the
src/main/liberty/config/configDropins/overrides directory. Java source file changes, server configuration changes, and build file changes might result in new Liberty features being generated. Generated features are installed and enabled automatically.
Automatic feature generation is turned off by default. When dev mode is running, you can toggle the automatic generation of features on and off by typing
g and pressing
Alternatively, when you start dev mode from the command line, you can set the
generateFeatures parameter to
true. This setting, as shown in the following examples, enables automatic feature generation from dev mode startup.
mvn liberty:dev -DgenerateFeatures=true
gradle libertyDev --generateFeatures=true
When automatic feature generation is turned on, dev mode has a runtime dependency on IBM WebSphere Application Server Migration Toolkit for Application Binaries, which is separately licensed under IBM License Agreement for Non-Warranted Programs. For more information, see the IBM License Agreement.
You do not need to purchase a license or install IBM WebSphere Application Server Migration Toolkit for Application Binaries to use automatic feature generation.
You can run unit and integration tests on demand by pressing
Enter in the command window where dev mode is running. Dev mode runs the unit tests and integration tests that are configured for your project. If you add a test to your project, dev mode compiles and includes it the next time that you run tests.
You can get immediate feedback on your changes by configuring dev mode to run hot tests. Hot tests are unit or integration tests that run automatically whenever you start dev mode or make a code change. To configure hot testing, specify the hot test parameter when you start dev mode, as shown in the following examples:
mvn liberty:dev -DhotTests
gradle libertyDev --hotTests
You can also add parameters to specify whether to skip tests. For Maven, you can add parameters to skip unit tests, skip integration tests, or skip all tests. For Gradle, you can add a parameter to skip all tests. For more information about configuration parameters, see the dev goal of the Liberty Maven plug-in or the libertyDev task of the Liberty Gradle plug-in.
You can attach a debugger to the running server to step through your code at any time. You can specify breakpoints in your source code to locally debug different parts of your application. The default port for debugging is
7777. If the default port is not available, dev mode selects a random port to use as the port for debugging.
Liberty Tools for Eclipse, VS Code, and IntelliJ IDEA integrate dev mode functions directly into your chosen development environment. When you install these tools and enable either the Maven or Gradle plug-in, you can find your project name in the Liberty dashboard view in Eclipse IDE or Visual Studio Code, or to the Liberty Tools window in IntelliJ IDEA. You can access dev mode functions by right-clicking your project name and selecting a command from the drop-down menu. Liberty Tools also provides core language support for Liberty configuration files, MicroProfiles APIs, and Jakarta EE APIs.
For more information, see Develop with Liberty Tools.
If you are developing an application locally in a container, you can minimize differences between your development and production environments by running your containerized server in dev mode. With container support for dev mode, you can use the same
Dockerfile file for both development and production. You use the same base image and customizations, and specify the same configuration files in the
Dockerfile file that you use for your application in production.
Next, create a
Dockerfile file in your project root directory that includes
COPY commands for your application and configuration files. For more information, see Open Liberty container images.
To start dev mode with container support, run one of following commands in your project:
These commands compile your application, build the development image, and run the server in the container. You can edit your source code or configuration files while dev mode is running. For a comprehensive demo of dev mode with container support, see the devc branch of the demo-devmode project.
A multi-module Maven project is a project that consists of multiple modules that are specified in the
modules section of its
pom.xml file. You can run a multi-module Maven project in dev mode or dev mode with container support.
To start a multi-module project in dev mode, you can define the Liberty Maven plug-in in either the parent
pom.xml file of every module or in the
pom.xml of every module. Then, run the
mvn liberty:dev or
mvn liberty:devc command from the directory that contains the multi-module
pom.xml file. When you run a multi-module Maven project in dev mode, changes in all modules are detected and hot deployed according to the Maven Reactor build order.
Any modules that other modules rely on as a compile dependency must have a Java source folder that contains Java files before you start dev mode. Otherwise, the dependent modules might fail to compile. Open Liberty server configuration files, such as the
server.xml, are used from the module that does not have any other dependent modules. If more than one module without any dependent modules exists, you can specify which module configuration files to use by including the
-pl <_module-with-liberty-config_> -am parameters in your
mvn liberty:dev command. For example, to use Open Liberty configuration files from a module that is named
ear, you can run the
mvn liberty:dev -pl ear -am command.
For more information, see Multiple Modules.