The Builder Design Pattern
The Builder pattern separates the construction of a complex object from its representation, enabling the same construction process to create different representations.
Use the Builder pattern when you need to construct a complex object step by step. It is particularly useful when an object needs to be constructed with numerous possible configurations.
- TypeCreational
- Time ComplexityO(1) Constant Time – The algorithm runs in constant time, irrespective of the input size. Operations like accessing an array element fall into this category.
- Efficiency5
-
Learning Effort
- Average5
- Conceptual6
- Debug and Maintain4
- Implementation5
- Prerequisites5
- Versatility7
Things you should know before you start
- Composition Understanding of object composition, where objects are composed to achieve more complex functionality.
- Interfaces Understanding of interfaces in object-oriented programming.
Minimal Example
Constructing a meal with multiple courses (starter, main course, dessert) in a restaurant application.
class MealBuilder {
buildStarter() {}
buildMainCourse() {}
buildDessert() {}
}
class Meal {
addStarter(starter) {}
addMainCourse(mainCourse) {}
addDessert(dessert) {}
}
const builder = new MealBuilder();
const director = new MealDirector(builder);
director.constructMeal();
const meal = builder.getMeal();
What’s happening in thie example
In this example, the MealDirector class uses a MealBuilder object to construct a Meal. The `clientCode` demonstrates the process of constructing a meal using both the Director and Builder.
How the Builder Works
The Builder pattern allows for the construction of a complex object step by step. It’s especially useful when an object has to be created with many optional components or configurations.
It provides clear separation between the construction and representation of an object. By doing so, the same construction process can produce different types of objects.
Entities in the Builder Design Pattern
-
BuilderThe Builder interface specifies methods for creating parts of a complex object.
- Builder has a one-to-many aggregates relationship with ProductPart
-
DirectorThe Director class constructs the complex object using the Builder interface.
- Director has a one-to-one uses relationship with Builder
What to watch out for when using or considering this design pattern.
Avoid using the Builder pattern for simple objects that don’t require multiple steps or configurations for their creation. It can overcomplicate the code for such scenarios.
Design patterns often confused with the Builder Design Pattern
The following design patterns are often confused with the Builder
for various resons.
If you’re exploring solutions, have a look through this list and see if
one of these might be a better fit for your problem.
-
Factory Method – The Factory Method pattern provides an interface for creating an object in a super class but allowing a subclass to alter the type of objects that will be created.
The Factory Method pattern is similar to the Builder in the following ways.
- Both are creational design patterns.
- Both aim to separate the client code from the code responsible for object creation.
- Builder pattern constructs a complex object step by step, whereas Factory Method deals with the instantiation of a single object.
- Builder pattern allows for configuring an object with multiple options, while Factory Method is generally used for simpler object creation.
-
Prototype – The Prototype pattern creates new instances by copying an existing instance, known as the ‘prototype’.
The Prototype pattern is similar to the Builder in the following ways.
- Both are creational design patterns.
- Both provide a mechanism for object creation.
- Builder pattern is used for constructing complex objects step by step, while Prototype is used for creating new instances through cloning.
- Builder pattern allows for a more controlled and detailed construction process, whereas Prototype focuses on quick object creation through cloning.