Using Lombok to create builders for classes with required and optional attributes

Question

Searching for a plugin to avoid boilerplate code to implement Joshua Bloch's builder pattern I found the amazing Lombok Project which enables you to generate builders via annotations like this:

@Builder
public class Person {
    private String name;
    private String address;
    private String secondAddress;
}

PersonBuilder.builder().name("yourName").address("your Address").build();

As you can see, there is no boilerplate code, and you can easily create an instance of Person by calling the provided static builder() method, chaining setter-like-calls just like it works with JavaBeans-Pattern and end the chain with calling build();

One of the disadvantages of the JavaBeans-Pattern compared to builder pattern is (from Effective Java):

Because construction is split across multiple calls, a JavaBean may be in an inconsistent state partway through its construction.

Assuming that in the above example, the first two attributes, name and address, are mandatory for constructing an instance of Person, the way Lombok implements the builder pattern enables a developer to split/shorten the construction and do something with a possibly inconsistent instance of Person, like this:

Person p = PersonBuilder.builder().name("yourName").build();
...
System.out.println(p.getAddress());
...
p.setAddress("your address");

Joshua Bloch's solution prefers a builder method with the mandatory attributes as parameters, so that there is no possibility that the construction is split across multiple calls, like illustrated in Item 2: Consider a builder when faced with many constructor parameters.

My question is: Is there any convenient way like annotation parameters for @Builder or something like Springs @Required or @Mandatory on attribute level to enforce Lombok to avoid offering the parameterless builder constructor and to provide a constructor with the mandatory parameters, as Joshua Bloch proposes?

I've tried many options from @Builder documentation but couldn't find a desirable solution.

What works for me is described as follows:

• defining a constructor for Person with mandatory parameters,
• overriding the builder constructor with a parameterized signature for the mandatory parameters.

It's a bit of boilerplate, which could possibly be avoided. See my solution applied on Joshua Bloch's example bellow.

/**
 * Uncle Bobs builder example for constructors with many required & optional parameters,
 * realized by lombok.
 * 
 */
@AllArgsConstructor(access=AccessLevel.PRIVATE) // Let lombok generate private c-tor with all parameters, as needed by @Builder.
@Builder(
        builderClassName="Builder", // Cosmetic. Without this option, the builder class would have the name NutritionFactsBuilder.
        toBuilder=true // Enabling creation of a builder instance based on a main class instance: NutritionFacts. 
)
public class NutritionFacts {

    // Required parameters
    private int servingSize;
    private int servings;

    // Optional parameters
    private int calories;
    private int fat;
    private int sodium;
    private int carbohydrate;

    /**
     * A builder method demanding required parameters.
     */
    public static Builder builder(int servingSize, int servings) {
        return new NutritionFacts(servingSize, servings).toBuilder();
    }

    /**
     * eclipse-created C-tor with required parameters.
     * Can be public for instantiating, but doesn't have to.
     */
    public NutritionFacts(int servingSize, int servings) {
        super();
        this.servingSize = servingSize;
        this.servings = servings;
    }

    public static void main(String[] args) {
        NutritionFacts cocaCola = NutritionFacts.builder(240, 8)
                                                .calories(100)
                                                .sodium(35)
                                                .carbohydrate(27)
                                                .build();
    }
}

Answer 1

As per @Builder docs this annotation can work together with @NonNull. If the field marked @NonNull is null you will get an NullPointerException preventing creation of invalid object:

@Builder
static class Person {
  @NonNull
  private final String name;
  @NonNull
  private final Integer age;
}

public static void main(String[] args) {
  Person.builder()
        .name("Fred")
        .build(); // java.lang.NullPointerException: age is marked @NonNull but is null
}

To go further you can define the builder method yourself. If the method is present Lombok won't generate it and you can now force the arguments compile time.

@Builder
static class Person {
  @NonNull
  private final String name;
  @NonNull
  private final Integer age;

  public static PersonBuilder builder(String name, Integer age) {
    return new PersonBuilder().name(name).age(age);
  }
}

public static void main(String[] args) {
  Person.builder("Fred", 11)
        .build();
}

However one could still create a builder by writing new Person.PersonBuilder() because the builder class is still accessible.

Answer 2

Also, in extension can be used:

@Builder.Default <modifier><instanceVariable>=<default-value>,

like: @Builder.Default private String myVariable = "".

Please read this: @Builder default properties

Avoids compiler errors asking for required properties that won't be set in some scenarios such as persistence, indexing, etc. (update/deleteBy/findBy from id or reduced properties set, without having a full object graph).

It's an elegant solution for not overriding .build() or setters as suggested.