MACRO NEPAL
Lombok for Reducing Boilerplate in Java
awiskar acharya
November 6, 2025
3:00 pm

Introduction

Lombok is a Java library that automatically plugs into your editor and build tools, spicing up your Java code. It helps eliminate boilerplate code like getters, setters, constructors, equals, hashCode, and toString methods through annotations, making your code cleaner and more maintainable.

Maven Dependencies

<!-- Lombok dependency -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.30</version>
<scope>provided</scope>
</dependency>
<!-- For Spring Boot -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<!-- Annotation processor for IDEs -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.30</version>
<scope>provided</scope>
<optional>true</optional>
</dependency>

Core Annotations

@Data - The Complete Package

import lombok.Data;
// Without Lombok - 50+ lines of boilerplate
public class UserWithoutLombok {
private Long id;
private String username;
private String email;
private int age;
private boolean active;
// Constructors, getters, setters, equals, hashCode, toString...
}
// With Lombok - Just 7 lines!
@Data
public class User {
private Long id;
private String username;
private String email;
private int age;
private boolean active;
}
// Usage example
public class UserService {
public void processUser() {
User user = new User();
user.setId(1L);
user.setUsername("john_doe");
user.setEmail("[email protected]");
user.setAge(30);
user.setActive(true);
System.out.println(user); // Auto-generated toString()
User anotherUser = new User();
anotherUser.setId(1L);
System.out.println(user.equals(anotherUser)); // Auto-generated equals()
}
}

@Getter and @Setter

import lombok.Getter;
import lombok.Setter;
public class Product {
// Field-level annotations
@Getter @Setter
private Long id;
@Getter @Setter
private String name;
// Class-level annotations with access levels
@Getter
@Setter
public static class Category {
private Long id;
private String name;
private String description;
// Lombok generates:
// public Long getId() { return this.id; }
// public void setId(Long id) { this.id = id; }
// ... and so on for other fields
}
// Configuring access levels
@Getter(AccessLevel.PROTECTED)
@Setter(AccessLevel.PRIVATE)
private String internalCode;
@Getter(AccessLevel.PUBLIC)
@Setter(AccessLevel.NONE) // No setter generated
private final String sku;
public Product(String sku) {
this.sku = sku;
}
}
// Usage
class ProductService {
public void demonstrateGettersSetters() {
Product product = new Product("SKU123");
Product.Category category = new Product.Category();
category.setId(1L);
category.setName("Electronics");
// product.setSku("NEW123"); // Compile error - no setter for final field
String sku = product.getSku(); // This works
// String code = product.getInternalCode(); // Compile error - protected getter
// product.setInternalCode("CODE"); // Compile error - private setter
}
}

Constructors Made Easy

import lombok.AllArgsConstructor;
import lombok.NoArgsConstructor;
import lombok.RequiredArgsConstructor;
@NoArgsConstructor
@AllArgsConstructor
public class Employee {
private Long id;
private String name;
private String department;
private double salary;
// Lombok generates:
// public Employee() {}
// public Employee(Long id, String name, String department, double salary) {
//     this.id = id;
//     this.name = name;
//     this.department = department;
//     this.salary = salary;
// }
}
@RequiredArgsConstructor
public class Customer {
private final Long id;
private final String customerCode;
@NonNull
private String name;
private String email;
private String phone;
// Lombok generates:
// public Customer(Long id, String customerCode, String name) {
//     if (name == null) throw new NullPointerException("name is marked non-null but is null");
//     this.id = id;
//     this.customerCode = customerCode;
//     this.name = name;
// }
}
// Static factory methods
@AllArgsConstructor(staticName = "of")
public class Point {
private final int x;
private final int y;
// Usage: Point point = Point.of(10, 20);
}
// Builder pattern with constructor
@AllArgsConstructor
@NoArgsConstructor
@Builder
public class Address {
private String street;
private String city;
private String zipCode;
private String country;
}
class ConstructorExamples {
public void demonstrateConstructors() {
// No-args constructor
Employee emp1 = new Employee();
// All-args constructor
Employee emp2 = new Employee(1L, "John Doe", "IT", 75000.0);
// Required args constructor
Customer customer = new Customer(1L, "CUST001", "Jane Smith");
// Customer invalid = new Customer(1L, "CUST001", null); // Throws NPE
// Static factory
Point point = Point.of(10, 20);
// Builder
Address address = Address.builder()
.street("123 Main St")
.city("New York")
.zipCode("10001")
.country("USA")
.build();
}
}

Advanced Lombok Features

@Builder - Fluent Object Creation

import lombok.Builder;
import lombok.Singular;
import lombok.ToString;
import java.util.List;
import java.util.Map;
@Builder
@ToString
public class Order {
private Long id;
private String orderNumber;
private String customerEmail;
private double totalAmount;
@Singular
private List<OrderItem> items;
@Singular
private Map<String, String> metadata;
@Builder.Default
private OrderStatus status = OrderStatus.PENDING;
@Builder.Default
private int priority = 1;
public enum OrderStatus {
PENDING, CONFIRMED, SHIPPED, DELIVERED, CANCELLED
}
}
@Builder
@ToString
class OrderItem {
private String productId;
private String productName;
private int quantity;
private double unitPrice;
}
class BuilderExamples {
public void demonstrateBuilder() {
// Basic builder
Order order = Order.builder()
.id(1L)
.orderNumber("ORD001")
.customerEmail("[email protected]")
.totalAmount(199.99)
.build();
// With singular collections
Order complexOrder = Order.builder()
.id(2L)
.orderNumber("ORD002")
.item(OrderItem.builder()
.productId("P001")
.productName("Laptop")
.quantity(1)
.unitPrice(999.99)
.build())
.item(OrderItem.builder()
.productId("P002")
.productName("Mouse")
.quantity(2)
.unitPrice(25.99)
.build())
.metadata("source", "web")
.metadata("campaign", "spring_sale")
.status(Order.OrderStatus.CONFIRMED)
.build();
System.out.println(complexOrder);
// Output includes all items and metadata
// ToBuilder for creating modified copies
Order modifiedOrder = complexOrder.toBuilder()
.totalAmount(1050.97)
.status(Order.OrderStatus.SHIPPED)
.build();
}
}

@Value - Immutable Classes

import lombok.Value;
import lombok.With;
import lombok.experimental.NonFinal;
@Value
public class ImmutableUser {
Long id;
String username;
String email;
@NonFinal
@With
String temporaryPassword;
// Lombok generates:
// - All fields are made private and final
// - Getter methods for all fields (no setters)
// - All-args constructor
// - equals(), hashCode(), toString()
// Custom constructor
public ImmutableUser(String username, String email) {
this.id = null;
this.username = username;
this.email = email;
this.temporaryPassword = null;
}
}
@Value
@Builder
public class ImmutableProduct {
String id;
String name;
String description;
double price;
@Builder.Default
boolean available = true;
}
class ValueExamples {
public void demonstrateImmutableObjects() {
// Using @Value
ImmutableUser user = new ImmutableUser(1L, "john", "[email protected]");
System.out.println(user.getUsername()); // john
// user.setUsername("new"); // Compile error - no setter
// Using @With for modification
ImmutableUser updatedUser = user.withTemporaryPassword("temp123");
System.out.println(updatedUser.getTemporaryPassword()); // temp123
// Builder with @Value
ImmutableProduct product = ImmutableProduct.builder()
.id("P001")
.name("Smartphone")
.description("Latest model")
.price(699.99)
.available(true)
.build();
System.out.println(product);
}
}

Logging Annotations

import lombok.extern.slf4j.Slf4j;
import lombok.extern.java.Log;
import lombok.extern.log4j.Log4j2;
import lombok.Cleanup;
import java.io.FileInputStream;
import java.util.logging.Logger;
@Slf4j
public class LoggingService {
public void processData(String data) {
log.trace("Entering processData with: {}", data);
if (data == null) {
log.warn("Null data received");
return;
}
try {
// Automatic resource management
@Cleanup FileInputStream input = new FileInputStream("config.properties");
// FileInputStream will be automatically closed at the end of the scope
log.info("Processing data: {}", data);
// Complex processing logic here
log.debug("Data processing completed successfully");
} catch (Exception e) {
log.error("Error processing data: {}", data, e);
}
}
}
@Log4j2
public class AdvancedLoggingService {
public void performOperation() {
log.info("Operation started");
try {
// Business logic
if (log.isDebugEnabled()) {
log.debug("Detailed debug information");
}
} catch (Exception e) {
log.error("Operation failed", e);
throw new RuntimeException("Operation failed", e);
}
log.info("Operation completed successfully");
}
}
// For java.util.logging
@Log
public class JavaUtilLoggingExample {
private static final Logger logger = Logger.getLogger(JavaUtilLoggingExample.class.getName());
public void demo() {
log.info("This uses java.util.logging");
}
}

Lombok in Spring Applications

Spring Boot Entities with Lombok

import lombok.*;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import javax.persistence.*;
import javax.validation.constraints.Email;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;
import java.time.LocalDateTime;
// JPA Entity example
@Entity
@Table(name = "users")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@EqualsAndHashCode(onlyExplicitlyIncluded = true)
public class UserEntity {
@Id
@EqualsAndHashCode.Include
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@NotBlank
@Size(min = 3, max = 50)
@Column(unique = true, nullable = false)
private String username;
@Email
@NotBlank
@Column(unique = true, nullable = false)
private String email;
@NotBlank
@Size(min = 6)
@Column(nullable = false)
private String password;
@Builder.Default
private boolean enabled = true;
@Builder.Default
private LocalDateTime createdAt = LocalDateTime.now();
// Custom getter
public String getDisplayName() {
return username + " (" + email + ")";
}
}
// MongoDB Document example
@Document(collection = "products")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class ProductDocument {
@Id
private String id;
private String name;
private String description;
private Double price;
@Builder.Default
private Boolean active = true;
@Singular
private List<String> tags;
}
// Spring Service with Lombok
@Service
@RequiredArgsConstructor
@Slf4j
public class UserService {
private final UserRepository userRepository;
private final PasswordEncoder passwordEncoder;
private final EmailService emailService;
public UserEntity createUser(CreateUserRequest request) {
log.info("Creating user with username: {}", request.getUsername());
UserEntity user = UserEntity.builder()
.username(request.getUsername())
.email(request.getEmail())
.password(passwordEncoder.encode(request.getPassword()))
.build();
UserEntity savedUser = userRepository.save(user);
log.info("User created successfully with ID: {}", savedUser.getId());
return savedUser;
}
@Transactional
public UserEntity updateUser(Long userId, UpdateUserRequest request) {
return userRepository.findById(userId)
.map(user -> {
user.setEmail(request.getEmail());
if (request.getPassword() != null) {
user.setPassword(passwordEncoder.encode(request.getPassword()));
}
return userRepository.save(user);
})
.orElseThrow(() -> new UserNotFoundException(userId));
}
}
// DTOs with Lombok
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class CreateUserRequest {
@NotBlank
private String username;
@Email
@NotBlank
private String email;
@NotBlank
@Size(min = 6)
private String password;
}
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class UpdateUserRequest {
@Email
private String email;
@Size(min = 6)
private String password;
}

Configuration and Customization

Lombok Configuration File

# lombok.config
# Enable experimental features
lombok.anyConstructor.suppressConstructorProperties = true
# Add null checks in generated setters
lombok.setter.flagUsage = WARNING
# Make generated builders public
lombok.accessors.chain = true
# Configure logging
lombok.log.fieldName = LOG
# Exclude fields from toString
lombok.toString.exclude = [password, ssn]
# Customize field names
lombok.accessors.prefix += m_

Customizing Lombok Behavior

import lombok.AccessLevel;
import lombok.ToString;
import lombok.experimental.FieldDefaults;
// Field defaults for entire class
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
@ToString
public class ConfigurationExample {
String name; // Becomes: private final String name;
int value;   // Becomes: private final int value;
// No need to explicitly declare them as private final
}
// Customizing toString
@ToString(callSuper = true, 
includeFieldNames = false, 
exclude = {"password", "secretKey"})
public class SecureUser extends BaseEntity {
private String username;
private String email;
private String password;
private String secretKey;
// toString will include superclass and exclude password/secretKey
}
// Customizing equals and hashCode
@EqualsAndHashCode(callSuper = true, 
onlyExplicitlyIncluded = true)
public class Employee extends Person {
@EqualsAndHashCode.Include
private String employeeId;
private String department;
private double salary;
// Only employeeId is included in equals/hashCode
}

Best Practices and Patterns

Effective Lombok Usage

import lombok.*;
import lombok.experimental.Accessors;
// Builder with accessors chain
@Getter
@Setter
@Accessors(chain = true)
@NoArgsConstructor
@AllArgsConstructor
public class ChainableUser {
private Long id;
private String username;
private String email;
// Enables method chaining: user.setId(1L).setUsername("john").setEmail("[email protected]");
}
// Immutable configuration class
@Value
@Builder
public class AppConfig {
String databaseUrl;
String username;
String password;
int connectionTimeout;
@Builder.Default
int maxConnections = 10;
@Builder.Default
boolean cacheEnabled = true;
@Singular
List<String> allowedHosts;
}
// Service with constructor injection
@Service
@RequiredArgsConstructor
@Slf4j
public class OrderProcessingService {
private final OrderRepository orderRepository;
private final PaymentService paymentService;
private final NotificationService notificationService;
private final AppConfig appConfig;
@Transactional
public Order processOrder(OrderRequest request) {
log.info("Processing order for customer: {}", request.getCustomerEmail());
Order order = Order.builder()
.orderNumber(generateOrderNumber())
.customerEmail(request.getCustomerEmail())
.totalAmount(request.getTotalAmount())
.items(request.getItems())
.build();
Order savedOrder = orderRepository.save(order);
// Process payment
paymentService.processPayment(savedOrder);
// Send notification
notificationService.sendOrderConfirmation(savedOrder);
log.info("Order processed successfully: {}", savedOrder.getOrderNumber());
return savedOrder;
}
private String generateOrderNumber() {
return "ORD_" + System.currentTimeMillis();
}
}
// Exception classes with Lombok
@Getter
public class BusinessException extends RuntimeException {
private final String errorCode;
private final LocalDateTime timestamp;
public BusinessException(String errorCode, String message) {
super(message);
this.errorCode = errorCode;
this.timestamp = LocalDateTime.now();
}
}
// Record-like classes with Lombok (pre-Java 16)
@Value
@Builder
public class Point {
int x;
int y;
public double distanceTo(Point other) {
return Math.sqrt(Math.pow(x - other.x, 2) + Math.pow(y - other.y, 2));
}
}

Common Pitfalls and Solutions

Avoiding Lombok Issues

// Problem: Circular dependencies in equals/hashCode
@Data
public class Department {
private Long id;
private String name;
private List<Employee> employees; // Circular reference!
}
@Data
public class Employee {
private Long id;
private String name;
private Department department; // Circular reference!
}
// Solution: Use @EqualsAndHashCode.Exclude
@Data
public class Department {
private Long id;
private String name;
@EqualsAndHashCode.Exclude
private List<Employee> employees;
}
@Data
public class Employee {
private Long id;
private String name;
@EqualsAndHashCode.Exclude
private Department department;
}
// Problem: JPA relationships with Lombok
@Entity
@Data
public class Order {
@Id
@GeneratedValue
private Long id;
@OneToMany(mappedBy = "order", cascade = CascadeType.ALL)
@ToString.Exclude
@EqualsAndHashCode.Exclude
private List<OrderItem> items = new ArrayList<>();
// Helper method for bidirectional relationship
public void addItem(OrderItem item) {
items.add(item);
item.setOrder(this);
}
}
@Entity
@Data
public class OrderItem {
@Id
@GeneratedValue
private Long id;
@ManyToOne
@JoinColumn(name = "order_id")
@ToString.Exclude
private Order order;
private String productName;
private int quantity;
}

Testing with Lombok

Test Classes with Lombok

import lombok.val;
import lombok.var;
@Slf4j
@ExtendWith(MockitoExtension.class)
class UserServiceTest {
@Mock
private UserRepository userRepository;
@Mock
private PasswordEncoder passwordEncoder;
@InjectMocks
private UserService userService;
@Test
void shouldCreateUserSuccessfully() {
// given
val request = CreateUserRequest.builder()
.username("testuser")
.email("[email protected]")
.password("password123")
.build();
val encodedPassword = "encodedPassword123";
val savedUser = UserEntity.builder()
.id(1L)
.username("testuser")
.email("[email protected]")
.password(encodedPassword)
.build();
when(passwordEncoder.encode("password123")).thenReturn(encodedPassword);
when(userRepository.save(any(UserEntity.class))).thenReturn(savedUser);
// when
val result = userService.createUser(request);
// then
assertThat(result).isNotNull();
assertThat(result.getId()).isEqualTo(1L);
assertThat(result.getUsername()).isEqualTo("testuser");
verify(userRepository).save(any(UserEntity.class));
verify(passwordEncoder).encode("password123");
}
@Test
void shouldHandleUserNotFound() {
// given
val userId = 999L;
when(userRepository.findById(userId)).thenReturn(Optional.empty());
// when & then
assertThrows(UserNotFoundException.class, () -> 
userService.updateUser(userId, UpdateUserRequest.builder().build()));
}
}
// Using val and var for local variables
class TypeInferenceExample {
public void demonstrateValVar() {
val immutableList = List.of("a", "b", "c"); // final List<String>
var mutableList = new ArrayList<String>();  // ArrayList<String>
// val is final, so this won't compile:
// immutableList = new ArrayList<>();
// var can be reassigned
mutableList = new ArrayList<>(List.of("x", "y", "z"));
for (val item : immutableList) {
System.out.println(item); // item is final String
}
}
}

Conclusion

Lombok significantly reduces Java boilerplate code and improves developer productivity. Key benefits include:

  • Reduced Code Volume: Eliminates repetitive getters, setters, constructors
  • Improved Readability: Focus on business logic rather than boilerplate
  • Fewer Bugs: Auto-generated methods are consistent and well-tested
  • Better Maintenance: Changes in fields automatically reflect in generated methods

When to Use Lombok:

  • Entities and DTOs: Perfect for data classes
  • Configuration Classes: Great for builder patterns
  • Service Classes: Constructor injection with @RequiredArgsConstructor
  • Testing: Use val for cleaner test code

When to Be Cautious:

  • JPA Entities: Be careful with @ToString and @EqualsAndHashCode
  • Inheritance: Configure callSuper properly
  • Complex Business Logic: Sometimes explicit code is clearer

Lombok works best when used consistently across a project and when team members are familiar with its features and limitations.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper