Advanced Lombok Annotations for Java Backend Development

This article demonstrates advanced Lombok annotations for Java backend development, focusing on how they can be combined with Spring to reduce boilerplate, manage resources, and create fluent builders.

@RequiredArgsConstructor with onConstructor

Using onConstructor, onMethod, and onParam you can inject custom annotations into generated code. A common use case is to combine it with Spring's @Autowired so that Lombok‑generated constructors are automatically annotated for dependency injection.

In a Spring component (e.g., @Service, @Controller, @Component, @Repository) you can write:

@Service
@RequiredArgsConstructor(onConstructor = @__(@Autowired))
public class MyService {
    private final AnotherService anotherService;
}

Lombok will generate a constructor that includes the @Autowired annotation, allowing Spring to inject the required AnotherService bean automatically.

@Delegate

The @Delegate annotation lets a class expose the methods of another class without writing forwarding code, improving readability and reducing tight coupling.

Example:

// A class with a method
public class A {
    public void sayHello() {
        System.out.println("Hello");
    }
}

// B delegates A's methods
public class B {
    @Delegate
    private A a = new A();

    public static void main(String[] args) {
        B b = new B();
        b.sayHello(); // Calls A.sayHello()
    }
}

@Cleanup

@Cleanup

automatically manages resources such as streams by generating a try‑finally block that calls the appropriate close or release method.

Basic usage:

@Cleanup InputStream in = new FileInputStream("some/file");

When the code finishes, Lombok inserts a try‑finally that calls in.close(). You can also specify a custom release method:

@Cleanup("release") MyResource resource = new MyResource();

@Builder and @Singular

@Builder

enables fluent object construction, while @Singular simplifies handling of collection fields by generating methods to add single elements or whole collections.

Example:

@Data
@Builder
public class User {
    private String name;
    private int age;
    @Singular
    private List<String> hobbies;
}

// Using the generated builder
User user = User.builder()
    .name("John Doe")
    .age(28)
    .hobby("basketball")
    .hobby("singing")
    .hobbies(Arrays.asList("dancing", "reading"))
    .build();

The generated collection is immutable after build(), ensuring thread safety. Note that if the class extends a parent, @Builder only includes fields declared in the current class.

Conclusion

While Lombok provides many convenient features, overusing or misusing them can make code harder to understand and maintain. Use these annotations judiciously and ensure the team is familiar with their behavior.