Lombok Patterns

This skill provides guidance on using Project Lombok to reduce boilerplate code in Java applications, covering annotations, best practices, and integration patterns.

Note: This guide targets Java 21+ projects. Some Lombok features are now obsolete due to modern Java features (Records, var, try-with-resources). See Java 21+ Considerations below.

Overview

Lombok is a Java library that automatically generates common code like getters, setters, constructors, builders, and more during compilation. It helps create cleaner, more maintainable code.

Java 21+ Considerations

Some Lombok features are now redundant with modern Java:

When Lombok Still Adds Value

• JPA Entities: Records don't work with JPA (need no-arg constructor, mutable state)
• @Builder: Records don't have built-in builder support
• @Slf4j: No Java equivalent for logger generation
• @RequiredArgsConstructor: Useful for Spring dependency injection
• Inheritance: Records can't extend classes

Annotation Categories

Core Annotations (Still Valuable)

Consider Java Records Instead

// ✅ Prefer Java Record for simple value objects
public record Money(BigDecimal amount, String currency) {}

// ✅ Prefer Java Record for simple DTOs
public record CustomerDTO(String name, String email) {}

// ✅ Use Lombok for JPA entities (records don't work with JPA)
@Entity
@Getter
@Setter
@NoArgsConstructor
public class Customer {
    @Id private Long id;
    private String name;
}

Logging Annotations

Field & Method Annotations

Quick Reference

JPA Entities (Lombok Recommended)

@Entity
@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode(onlyExplicitlyIncluded = true)
public class Product {
    @Id
    @EqualsAndHashCode.Include
    private Long id;

    private String name;
    private BigDecimal price;
}

Spring Services

@Service
@RequiredArgsConstructor
@Slf4j
public class OrderService {
    private final OrderRepository orderRepository;
    private final PaymentService paymentService;

    public Order process(Order order) {
        log.info("Processing order: {}", order.getId());
        return orderRepository.save(order);
    }
}

Builder Pattern (Lombok Adds Value)

// Records don't have builder support - use Lombok
@Builder
public record Email(
    String to,
    String subject,
    String body,
    @Singular List<String> attachments
) {}

// Usage
Email email = Email.builder()
    .to("user@example.com")
    .subject("Hello")
    .body("Content")
    .attachment("file1.pdf")
    .build();

Best Practices

✅ Do

• Use Java Records for simple value objects and DTOs
• Use @RequiredArgsConstructor with final fields for dependency injection
• Use @Slf4j for logging instead of manual logger creation
• Use @Builder for classes with many optional fields
• Be explicit with @EqualsAndHashCode on JPA entities

❌ Avoid

• Using @Data or @Value when a Java Record would suffice
• Using @Data on JPA entities (use individual annotations)
• Using @EqualsAndHashCode with lazy-loaded JPA relationships
• Overusing @SneakyThrows (makes exception handling unclear)

Common Pitfalls

Cookbook Index

Core Annotations

• data-annotation - @Data (consider Records instead)
• value-annotation - @Value (consider Records instead)
• getter-setter - @Getter and @Setter
• constructor-annotations - Constructor generation
• builder-annotation - Builder pattern with @Builder
• logging-annotations - Logger generation

Field & Method Annotations

• non-null - Null checking with @NonNull
• with-annotation - Immutable setters with @With
• sneaky-throws - Checked exception handling
• synchronized-annotation - Thread safety

Integration Patterns

• entity-patterns - JPA/Hibernate best practices
• equals-hashcode-jpa - Entity identity
• dependency-injection - Spring constructor injection
• configuration-properties - Spring Boot configuration