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:
Handling concurrency in an application can be a tricky process with many potential pitfalls. A solid grasp of the fundamentals will go a long way to help minimize these issues.
Get started with understanding multi-threaded applications with our Java Concurrency 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.
Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.
Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.
In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:
Get up to speed with the core of Maven quickly, and then go beyond the foundations into the more powerful functionality of the build tool, such as profiles, scopes, multi-module projects and quite a bit more:
1. Overview
The Maven Wrapper is an excellent choice for projects that need a specific version of Maven (or for users that don’t want to install Maven at all). Instead of installing many versions of it in the operating system, we can just use the project-specific wrapper script.
In this quick article, we’ll show how to set up a Maven Wrapper for an existing Maven project.
2. Setting Up the Maven Wrapper
There’re two ways to configure it in a project, where the simplest one is to use an appropriate plugin to automate it or by applying the manual installation.
2.1. Plugin
Let’s use this Maven Wrapper plugin to make auto installation in a simple Spring Boot project.
First, we need to go in the main folder of the project and run this command:
mvn -N wrapper:wrapperWe can also specify the version of Maven:
mvn -N wrapper:wrapper -Dmaven=3.5.2The option -N means –non-recursive so that the wrapper will only be applied to the main project of the current directory, not in any submodules.
After executing the goal, we’ll have more files and directories in the project:
- mvnw: it’s an executable Unix shell script used in place of a fully installed Maven
- mvnw.cmd: it’s the Batch version of the above script
- mvn: the hidden folder that holds the Maven Wrapper Java library and its properties file
2.2. Manual
With a manual approach, we can copy files and folders seen above from another project to the main folder of the current project.
Afterwards, we need to specify the version of Maven to use in the wrapper properties file located in .mvn/wrapper/maven-wrapper.properties file.
For instance, our properties file has the following line:
distributionUrl=https://repo1.maven.org/maven2/org/apache/maven/apache-maven/3.5.2/apache-maven-3.5.2-bin.zipConsequently, the version 3.5.2 will be downloaded and used.
3. Use Cases
The wrapper should work with different operating systems such as:
- Linux
- OSX
- Windows
- Solaris
After that, we can run our goals like this for the Unix system:
./mvnw clean installAnd the following command for Windows:
mvnw.cmd clean installIf we don’t have the specified Maven in the wrapper properties, it’ll be downloaded and installed in the folder $USER_HOME/.m2/wrapper/dists of the system.
Let’s run our Spring-Boot project:
./mvnw spring-boot:runThe output is the same as for a fully installed Maven:
Note: we use the executable mvnw in place of mvn, which stands now as the Maven command line program.
Now that we know what Maven wrapper is, let’s answer one of the common questions: should mvnw files be added to our projects?
The short answer is no. mvnw files are not necessarily part of our projects. However, including them could be beneficial. For example, it will allow anyone cloning our project to build it without installing Maven.
4. Conclusion
In this tutorial, we’ve seen how to set up and use Maven Wrapper in a Maven project.
