What is the Builder Pattern and Why You Should Use It

If you have ever faced the problem of creating complex objects that require a lot of configuration and initialization steps, you might have wondered if there is a better way to do it. In this blog post, I will introduce you to the Builder pattern, a design pattern that can help you simplify and organize the construction of complex objects.

The Builder pattern is a creational design pattern that lets you construct complex objects step by step. The pattern allows you to produce different types and representations of an object using the same construction code. The pattern also separates the construction of a complex object from its representation, so that you can change the representation without affecting the construction process.

The Builder pattern involves two main components: a builder and a director. The builder is an abstract interface that defines the steps to create a complex object. The builder can also provide a method to get the final product. The director is a class that controls the order of the construction steps and uses the builder to create the product.

The Builder pattern can be useful when:

- You want to create different representations of a complex object (for example, a house with different styles and features).

- You want to hide the details of the construction process from the client code.

- You want to reuse the same construction code for different products.

Let's see an example of how to use the Builder pattern in Java. Suppose we want to create a Pizza class that represents a pizza with various toppings and sizes. We can use a PizzaBuilder interface that defines the steps to create a pizza:

public interface PizzaBuilder {
    public void buildDough();
    public void buildSauce();
    public void buildTopping();
    public Pizza getPizza();
}

Then we can implement different concrete builders that create different types of pizzas:

public class HawaiianPizzaBuilder implements PizzaBuilder {
    private Pizza pizza;

    public HawaiianPizzaBuilder() {
        pizza = new Pizza();
    }

    public void buildDough() {
        pizza.setDough("cross");
    }

    public void buildSauce() {
        pizza.setSauce("mild");
    }

    public void buildTopping() {
        pizza.setTopping("ham+pineapple");
    }

    public Pizza getPizza() {
        return pizza;
    }
}

public class SpicyPizzaBuilder implements PizzaBuilder {
    private Pizza pizza;

    public SpicyPizzaBuilder() {
        pizza = new Pizza();
    }

    public void buildDough() {
        pizza.setDough("pan baked");
    }

    public void buildSauce() {
        pizza.setSauce("hot");
    }

    public void buildTopping() {
        pizza.setTopping("pepperoni+salami");
    }

    public Pizza getPizza() {
        return pizza;
    }
}

Next, we can create a PizzaDirector class that uses a PizzaBuilder to create a pizza:

public class PizzaDirector {
    private PizzaBuilder pizzaBuilder;

    public void setPizzaBuilder(PizzaBuilder pizzaBuilder) {
        this.pizzaBuilder = pizzaBuilder;
    }

    public Pizza getPizza() {
        return pizzaBuilder.getPizza();
    }

    public void constructPizza() {
        pizzaBuilder.buildDough();

        pizzaBuilder.buildSauce();

        pizzaBuilder.buildTopping();
    }
}

Finally, we can use the director and the builders to create different pizzas in the client code:

public class Main {
    public static void main(String[] args) {
        PizzaDirector director = new PizzaDirector();

        // make Hawaiian pizza

        director.setPizzaBuilder(new HawaiianPizzaBuilder());

        director.constructPizza();

        Pizza hawaiian = director.getPizza();

        // make Spicy pizza

        director.setPizzaBuilder(new SpicyPizzaBuilder());

        director.constructPizza();

        Pizza spicy = director.getPizza();

        // print pizzas

        System.out.println(hawaiian);

        System.out.println(spicy);
    }
}

The output of this program is:

Pizza [dough=cross, sauce=mild, topping=ham+pineapple]

Pizza [dough=pan baked, sauce=hot, topping=pepperoni+salami]

As you can see, we have created two different pizzas using the same construction process but different builders. We have also hidden the details of how each pizza is made from the client code.

The Builder pattern has some advantages, such as:

- It allows creating complex objects step by step

- It encapsulates the construction logic and hides the internal representation of the product

- It provides a fluent and readable interface for building objects

- It enables varying the product's representation without changing the director's code

For further reference, you can check out these external sources:

What is the Builder Pattern and Why You Should Use It

Read More

Tags