The Builder Design Pattern in Java

Posted on by — No Comments ↓

Creating complex objects, like a custom Car, often involves juggling multiple attributes: engine, wheels, color, etc. Using a single constructor with many parameters is cumbersome and error-prone. How can we build such objects cleanly and flexibly? The Builder Design Pattern in Java provides a solution by separating the construction process from the object’s representation, enabling step-by-step assembly.

What is the Builder Pattern?

The Builder Pattern is a creational design pattern that constructs complex objects incrementally using a dedicated Builder class. This approach improves code readability, supports flexible configurations, and avoids bloated constructors.

Example in Java

Below is a Java implementation of the Builder Pattern for building a car object:

Create Car class. 

public class Car {

    private String engine;
    private int wheels;
    private String color;

    private Car() {}

    protected Car(CarBuilder builder) {
        this.engine = builder.engine;
        this.wheels = builder.wheels;
        this.color = builder.color;
    }

    @Override
    public String toString() {
        return "Car with " + engine + " engine, " + wheels + " wheels, and " + color + " color";
    }

    //get set
}

Create CarBuilder class in the same package of Car. 

public class CarBuilder {

    protected String engine;
    protected int wheels;
    protected String color;

    public CarBuilder setEngine(String engine) {
        this.engine = engine;
        return this;
    }

    public CarBuilder setWheels(int wheels) {
        this.wheels = wheels;
        return this;
    }

    public CarBuilder setColor(String color) {
        this.color = color;
        return this;
    }

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

Use CarBuilder to return a instance of Car. 

public class Main { 
    public static void main(String[] args) { 
        Car car = new CarBuilder()
                .setEngine("V8")
                .setWheels(4)
                .setColor("Red")
                .build();
        System.out.println(car); 
        // Output: Car with V8 engine, 4 wheels, and Red color 
    }
}

Advantages of the Builder Pattern

  1. Readability: Method chaining creates a clear, fluent API for object construction.
  2. Flexibility: Easily add or omit optional attributes without modifying the core class.
  3. Immutability: The Car object is immutable, as all fields are final, enhancing thread safety.
  4. Separation of Concerns: Construction logic is isolated in the Builder, keeping the Car class focused on its data.

Disadvantages of the Builder Pattern

  1. Increased Code: Requires a separate Builder class, adding boilerplate code.
  2. Overkill for Simple Objects: For objects with few attributes, the pattern may be unnecessarily complex.
  3. Maintenance: Changes to the Car class (e.g., adding new fields) require corresponding updates to the Builder.

Spring Boot Example with Builder

In Spring Boot, the Builder Pattern is commonly used in configuration classes. Below is an example of a RestTemplate configuration using a custom RestTemplateBuilder to configure HTTP client settings: 

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplateBuilder()
                .setConnectTimeout(Duration.ofSeconds(5))
                .setReadTimeout(Duration.ofSeconds(10))
                .build();
    }
}

Conclusion

The Builder Pattern in Java, including in Spring Boot, solves the problem of constructing complex objects by providing a clean, step-by-step approach. Whether building a Car or configuring a RestTemplate, it ensures readability, flexibility, and maintainability. While it introduces some code overhead, its benefits make it invaluable for complex systems, especially in Spring Boot applications where configuration objects are common.

Leave a Reply