Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
Refactor Java code safely — and automatically — with OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.
Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.
In distributed systems, managing multi-step processes (e.g., validating a driver, calculating fares, notifying users) can be difficult. We need to manage state, scattered retry logic, and maintain context when services fail.
Dapr Workflows solves this via Durable Execution which includes automatic state persistence, replaying workflows after failures and built-in resilience through retries, timeouts and error handling.
In this tutorial, we'll see how to orchestrate a multi-step flow for a ride-hailing application by integrating Dapr Workflows and Spring Boot:
1. Introduction to EJDK
The EJDK (Embedded Java Development Kit) was introduced by Oracle to solve the problem of providing binaries for all the available embedded platforms. We can download the latest EJDK from Oracle’s site here.
Simply put, it contains the tools for creating platform-specific JREs.
2. jrecreate
EJDK provides jrecreate.bat for Windows and jrecreate.sh for Unix/Linux platforms. This tool helps in assembling custom JREs for platforms we wish to use, and was introduced to:
- minimize the release of binaries by Oracle for every platform
- make it easy to create customized JREs for other platforms
The following syntax is used to execute the jrecreate command; in Unix/Linux:
$jrecreate.sh -<option>/--<option> <argument-if-any>And in Windows:
$jrecreate.bat -<option>/--<option> <argument-if-any>Note, we can add multiple options for a single JRE creation. Now, let’s take a look at some of the options available for the tool.
3. Options for jrecreate
3.1. Destination
The destination option is required and specifies the directory in which the target JRE should be created:
$jrecreate.sh -d /SampleJREOn running the above command, a default JRE will be created in the specified location. The command line output will be:
Building JRE using Options {
ejdk-home: /installDir/ejdk1.8.0/bin/..
dest: /SampleJRE
target: linux_i586
vm: all
runtime: jre
debug: false
keep-debug-info: false
no-compression: false
dry-run: false
verbose: false
extension: []
}
Target JRE Size is 55,205 KB (on disk usage may be greater).
Embedded JRE created successfullyFrom the above result, we can see that the target JRE is created in the specified destination directory. All the other options have taken their default values.
3.2. Profiles
The profile option is used to manage the size of the target JRE. The profiles define the functionality of the API to be included. If the profile option is not specified, the tool will include all the JRE APIs by default:
$jrecreate.sh -d /SampleJRECompact1/ -p compact1A JRE with a compact1 profile will be created. We can also use ––profile instead of -p in the command. The command line output will display the following result:
Building JRE using Options {
ejdk-home: /installDir/ejdk1.8.0/bin/..
dest: /SampleJRECompact1
target: linux_i586
vm: minimal
runtime: compact1 profile
debug: false
keep-debug-info: false
no-compression: false
dry-run: false
verbose: false
extension: []
}
Target JRE Size is 10,808 KB (on disk usage may be greater).
Embedded JRE created successfullyIn the above result, note that the runtime option has the value as compact1. Also note the size of the result JRE is just under 11MB, down from 55MB in the previous example.
There are three available options for the profile setting: compact1, compact2, and compact3.
3.3. JVMs
The jvm option is used to customize our target JRE with specific JVMs based on the user’s needs. By default, it includes all the available JVMs (client, server, and minimal) if both profile and jvm options are not specified:
$jrecreate.sh -d /SampleJREClientJVM/ --vm clientA JRE with a client jvm will be created. The command line output will display the following result:
Building JRE using Options {
ejdk-home: /installDir/ejdk1.8.0/bin/..
dest: /SampleJREClientJVM
target: linux_i586
vm: Client
runtime: jre
debug: false
keep-debug-info: false
no-compression: false
dry-run: false
verbose: false
extension: []
}
Target JRE Size is 46,217 KB (on disk usage may be greater).
Embedded JRE created successfullyIn the above result, note that the vm option has the value Client. We can also specify the other JVMs like server and minimal with this option.
3.4. Extension
The extension option is used to include various allowed extensions to the target JRE. By default, there are no extensions added:
$jrecreate.sh -d /SampleJRESunecExt/ -x sunecA JRE with an extension sunec (Security provider for Elliptic Curve Cryptography) will be created. We can also use ––extension instead of -x in the command. The command line output will display the following result:
Building JRE using Options {
ejdk-home: /installDir/ejdk1.8.0/bin/..
dest: /SampleJRESunecExt
target: linux_i586
vm: all
runtime: jre
debug: false
keep-debug-info: false
no-compression: false
dry-run: false
verbose: false
extension: [sunec]
}
Target JRE Size is 55,462 KB (on disk usage may be greater).
Embedded JRE created successfullyIn the above result, note that the extension option has the value sunec. Multiple extensions can be added with this option.
3.5. Other Options
Other than the major options discussed above, jrecreate also facilitates users with a few more options:
- ––help: displays summary of command line options for jrecreate tool
- ––debug: creates JRE that has debug support
- ––keep-debug-info: keeps the debug information from class and unsigned JAR files
- ––dry-run: performs a dry run without actually creating the JRE
- ––no-compression: creates a JRE with unsigned JAR files in uncompressed format
- ––verbose: displays verbose output for all jrecreate commands
4. Conclusion
In this tutorial, we learned the basics of EJDK, and how the jrecreate tool is used to generate platform-specific JREs.
