Yes, we're now running our Black Friday Sale. All Access and Pro are 33% off until 2nd December, 2025:
Lombok’s @RequiredArgsConstructor Annotation
Last updated: March 26, 2025
Modern software architecture is often broken. Slow delivery leads to missed opportunities, innovation is stalled due to architectural complexities, and engineering resources are exceedingly expensive.
Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.
With Orkes Conductor managed through Orkes Cloud, developers can focus on building mission critical applications without worrying about infrastructure maintenance to meet goals and, simply put, taking new products live faster and reducing total cost of ownership.
Try a 14-Day Free Trial of Orkes Conductor today.
Modern software architecture is often broken. Slow delivery leads to missed opportunities, innovation is stalled due to architectural complexities, and engineering resources are exceedingly expensive.
Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.
With Orkes Conductor managed through Orkes Cloud, developers can focus on building mission critical applications without worrying about infrastructure maintenance to meet goals and, simply put, taking new products live faster and reducing total cost of ownership.
Try a 14-Day Free Trial of Orkes Conductor today.
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:
Modern software architecture is often broken. Slow delivery leads to missed opportunities, innovation is stalled due to architectural complexities, and engineering resources are exceedingly expensive.
Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.
With Orkes Conductor managed through Orkes Cloud, developers can focus on building mission critical applications without worrying about infrastructure maintenance to meet goals and, simply put, taking new products live faster and reducing total cost of ownership.
Try a 14-Day Free Trial of Orkes Conductor today.
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.
Yes, we're now running our Black Friday Sale. All Access and Pro are 33% off until 2nd December, 2025:
1. Overview
Java is an object-oriented language, which means we must deal with constructors while initializing objects.
Project Lombok can help us generate the constructors by simply using different annotations for different types of constructors and thus reduce the effort of writing boilerplate code.
In this tutorial, we’ll look at how the @RequiredArgsConstructor annotation can help us auto-generate the constructor for our classes.
2. Setup
To use Project Lombok, let’s add the dependency in our pom.xml file:
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.30</version>
<scope>provided</scope>
</dependency>3. Usage
@RequiredArgsConstructor is a Lombok annotation that generates constructors for all final and non-null fields.
In our examples, we’ll define classes with differently-scoped member variables and see how the annotation behaves in different scenarios.
3.1. final Fields
final fields are the class members, which are initialized once before the constructor completes.
Let’s define a class with a final field and then test the @RequiredArgsConstructor annotation for the same:
@RequiredArgsConstructor
public class ClassWithFinalMembers {
private final String stringObject;
// standard getters
}The @RequiredAgrsConstructor annotation generates a parameterized constructor with the final member. Now we’ll execute a simple test to initialize the above class successfully:
@Test
void whenClassHasFinalMembers_thenGeneratedConstructorHasParameters() {
ClassWithFinalMembers classWithFinalMembers = new ClassWithFinalMembers("dummyString");
Assertions.assertNotNull(classWithFinalMembers);
Assertions.assertEquals("dummyString", classWithFinalMembers.getStringObject());
}3.2. Non-final Fields
When a class has non-final fields, the @RequierdArgsConstructor annotation doesn’t add them to the constructor parameters while generating the code.
If there are no final or non-null fields and only non-final fields, then we’ll get a constructor with no parameters generated.
Let’s see an example of the above scenario and subsequently validate the same with a simple test case:
@RequiredArgsConstructor
public class ClassWithNonFinalMembers {
private String stringObject;
// standard getters
}@Test
void whenClassHasNonFinalMembers_thenGeneratedConstructorHasNoParameters() {
ClassWithNonFinalMembers classWithNonFinalMembers = new ClassWithNonFinalMembers();
Assertions.assertNotNull(classWithNonFinalMembers);
}We’ve defined a class with a non-final member, therefore using @RequiredArgsConstructor doesn’t add the member to the generated constructor parameters. If we try to use the parametrized constructor, the compiler throws an error.
3.3. Non-null Fields
To generate a constructor with non-null fields, we can use the @NonNull Lombok annotation:
@RequiredArgsConstructor
public class ClassWithFinalNonNullMembers {
private final String finalStringObject;
@NonNull
private String nonNullStringObject;
private String nonFinalStringObject;
// standard getters
}Now, let’s see a simple test case:
@Test
void whenClassHasFinalAndNonNullMembers_thenGeneratedConstructorHasParameters() {
ClassWithFinalNonNullMembers classWithFinalNonNullMembers = new ClassWithFinalNonNullMembers("finalString", "nonNullString");
Assertions.assertNotNull(classWithFinalNonNullMembers);
Assertions.assertEquals("finalString", classWithFinalNonNullMembers.getFinalStringObject());
Assertions.assertEquals("nonNullString", classWithFinalNonNullMembers.getNonNullStringObject());
Assertions.assertNull(classWithFinalNonNullMembers.getNonFinalStringObject());
}We’ve defined a class with final, non-null, and non-final members. Therefore, the @RequiredArgsConstructor annotation generates the constructor, which initializes the non-null members in addition to the final ones.
4. Conclusion
In this article, we saw how @RequiredArgsConstructor generates the constructor to initialize the members of the class.
final members and members annotated as @NonNull are included in the constructor parameters and definition. However, the members which are neither final nor annotated with @NonNull aren’t initialized by the generated constructor.
The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
