Implement the Builder Pattern in Java

1. Introduction

In our journey through software development, we often encounter scenarios where creating objects with numerous properties becomes intimidating. Cluttering our constructors is making our code less readable. This is precisely where the Builder Pattern shines. The Builder Pattern is a creational design pattern that separates the construction of complex objects from their representation, offering a cleaner and more flexible approach to object creation.

2. Advantages of Builder Pattern

Before we dive into coding, let’s quickly recap the advantages of utilizing the Builder Pattern:

• Flexibility – by decoupling the construction process from the actual object representation, the Builder Pattern allows us to create objects with varying configurations without cluttering our codebase with multiple constructors or setters
• Readability – the Builder Pattern provides fluent interfaces, making our code more readable; this enables us and fellow developers to understand the construction process of complex objects at a glance.
• Immutability – builders can enforce immutability by creating immutable objects once the construction is complete; this ensures thread safety and prevents unintended modification.

Now, let’s roll up our sleeves and delve into the code.

3. Classic Builder Pattern

public class Post {

    private final String title;

    private final String text;

    private final String category;

    Post(Builder builder) {
        this.title = builder.title;
        this.text = builder.text;
        this.category = builder.category;
    }

    public String getTitle() {
        return title;
    }

    public String getText() {
        return text;
    }

    public String getCategory() {
        return category;
    }

    public static class Builder {
        private String title;
        private String text;
        private String category;

        public Builder title(String title) {
            this.title = title;
            return this;
        }

        public Builder text(String text) {
            this.text = text;
            return this;
        }

        public Builder category(String category) {
            this.category = category;
            return this;
        }

        public Post build() {
            return new Post(this);
        }
    }
}

Now, we can use the Builder to create a new object:

Post post = new Post.Builder()
  .title("Java Builder Pattern")
  .text("Explaining how to implement the Builder Pattern in Java")
  .category("Programming")
  .build();

4. Generic Builder Pattern

In Java 8, lambda expressions and method references opened up new possibilities, including a more generic form of the Builder Pattern. Our implementation introduces a GenericBuilder class, which can construct various types of objects by leveraging generics:

public class GenericBuilder<T> {
    private final Supplier<T> supplier;

    private GenericBuilder(Supplier<T> supplier) {
        this.supplier = supplier;
    }

    public static <T> GenericBuilder<T> of(Supplier<T> supplier) {
        return new GenericBuilder<>(supplier);
    }

    public <P> GenericBuilder<T> with(BiConsumer<T, P> consumer, P value) {
        return new GenericBuilder<>(() -> {
            T object = supplier.get();
            consumer.accept(object, value);
            return object;
        });
    }

    public T build() {
        return supplier.get();
    }
}

This class follows a fluent interface, starting with the of() method to create the initial object instance. Then, the with() method sets object properties using lambda expressions or method references.

The GenericBuilder offers flexibility and readability, allowing us to construct every object concisely while ensuring type safety. This pattern showcases Java 8’s expressive power and is an elegant solution for complex construction tasks.

However, a big drawback is that this solution is based on class setters. This implies that our attributes can no longer be final as in the previous example, thus losing the immutability offered by the Builder Pattern.

For our next example we’ll create a new GenericPost class consisting of a default no-args constructor, getters, and setters:

public class GenericPost {

    private String title;

    private String text;

    private String category;

    // getters and setters

}

Now, we can use our GenericBuilder to create a GenericPost:

Post post = GenericBuilder.of(GenericPost::new)
  .with(GenericPost::setTitle, "Java Builder Pattern")
  .with(GenericPost::setText, "Explaining how to implement the Builder Pattern in Java")
  .with(GenericPost::setCategory, "Programming")
  .build();

5. Lombok Builder

Lombok is a library that simplifies Java code by automatically generating common methods such as getters, setters, equals, hashCode, and even constructors.

One of the most appreciated features of Lombok is its support for the Builder Pattern. By annotating a class with @Builder, Lombok generates a builder class with fluent methods for setting properties. This annotation eliminates the need for manual builder class implementation, significantly reducing verbosity

To use Lombok, we need to import the dependency from the Maven central repository:

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.32</version>
</dependency>

Now, we can create a new LombokPost class using the @Builder annotation:

@Builder
@Getter
public class LombokPost {
    private String title;
    private String text;
    private String category;
}

We also used @Setter and @Getter annotations to avoid the boilerplate code. We can then use the builder pattern out of the box to create new objects:

LombokPost lombokPost = LombokPost.builder()
  .title("Java Builder Pattern")
  .text("Explaining how to implement the Builder Pattern in Java")
  .category("Programming")
  .build();

6. Conclusion

The Builder Pattern in Java 8 offers streamlined object construction and improved code readability. With variants like Classic, Generic, and Lombok Builder Patterns, we can tailor our approach to our specific needs. By embracing this pattern and leveraging tools like Lombok, we can write cleaner, more efficient code, driving innovation and success in software development.