Technology Sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

The Builder Pattern in design patterns is a commonly used object creation design pattern, which is mainly used to solve the problem of building complex objects. The following is a detailed introduction to the Builder Pattern:

I. Definition

The Builder pattern separates the construction of a complex object from its representation, allowing the same construction process to create different representations. In other words, it breaks down the construction process of a complex object into a series of simple steps and allows users to create different objects by specifying the order and parameters of these steps.

2. Class Diagram and Structure

Class Diagram

In the builder mode, the following roles are usually included:

1. Product: Represents a complex object being constructed, usually consisting of multiple components.
2. Abstract Builder: Defines an abstract interface for creating the various components of a product object.
3. ConcreteBuilder: Implement the Builder interface, complete the specific creation methods of each component of the complex product, and define an interface to return the final product.
4. Director：Responsible for calling the component construction and assembly methods in the builder object to complete the creation of complex objects. It does not involve specific product information, but only decouples the client from the builder.

3. Applicable Scenarios

The builder pattern is applicable to the following scenarios:

1. Complex object structure: When the object to be built has a complex internal structure and contains multiple properties and methods, using the builder pattern can simplify the construction process.
2. The construction process is complex: When the object construction process involves multiple steps and the order and parameters of these steps may be different, the builder pattern can provide a clear construction process.
3. Decoupling creation and usage: The builder pattern is a good choice when you want to separate the creation and use processes of an object so that users only need to care about the final representation of the object without having to care about the details of object creation.

4. Advantages and Disadvantages

advantage

1. Good packaging：The construction process of complex objects is encapsulated inside the builder. The client only needs to specify the type and parameters of the construction to get the final product without knowing the details of the construction process.
2. Good scalability: If you need to add a new build type or modify the build process, you only need to add or modify the builder class, which will not affect the client code.
3. High flexibility: By changing the construction order or parameters of the builders, different product instances can be created flexibly.

shortcoming

1. Increase the number of classes: Since it is necessary to create multiple classes such as builder interface, specific builder class and commander class, the number of classes in the system may increase.
2. Difficult to modify internally: If the internal structure of the product changes, multiple builder classes may need to be modified, increasing the maintenance cost of the system.

5. Examples

In the following example, we will use the Builder pattern to design a house renovation system. We will define aHouseThe class is a complex object that contains multiple decoration components (such as ceiling, paint, floor, floor tiles, etc.). Then, we define aHouseBuilderInterface, which contains abstract methods for creating these components. Next, we create specific builder classes for each specific decoration style (such as luxurious European style, light luxury pastoral style, modern simplicity). Finally, we will pass aDirectorclass to guide the construction process, but it may not be necessary in this example because we can define the complete construction logic directly in the builder class.

However, to demonstrate the concept of the commander role, we will keep aDirectorClass, but it is only for illustration purposes, in fact the construction process can be done directly in the builder class.

// 房屋类  
public class House {  
    private String ceiling; // 吊顶  
    private String paint;   // 涂料  
    private String floor;   // 地板  
    private String tiles;   // 地砖  
  
    // 私有构造函数  
    private House() {}  
  
    // Getter 方法  
    public String getCeiling() {  
        return ceiling;  
    }  
  
    public String getPaint() {  
        return paint;  
    }  
  
    public String getFloor() {  
        return floor;  
    }  
  
    public String getTiles() {  
        return tiles;  
    }  
  
    // 建造者接口  
    public interface HouseBuilder {  
        HouseBuilder buildCeiling(String ceiling);  
        HouseBuilder buildPaint(String paint);  
        HouseBuilder buildFloor(String floor);  
        HouseBuilder buildTiles(String tiles);  
        House build();  
    }  
  
    // 豪华欧式建造者  ,注意是静态内部类
    public static class LuxuryEuropeanBuilder implements HouseBuilder {  
        private House house;  
  
        public LuxuryEuropeanBuilder() {  
            this.house = new House();  
        }  
  
        @Override  
        public HouseBuilder buildCeiling(String ceiling) {  
            house.ceiling = "豪华欧式吊顶: " + ceiling;  
            return this;  
        }  
  
        @Override  
        public HouseBuilder buildPaint(String paint) {  
            house.paint = "豪华欧式涂料: " + paint;  
            return this;  
        }  
  
        @Override  
        public HouseBuilder buildFloor(String floor) {  
            house.floor = "豪华欧式地板: " + floor;  
            return this;  
        }  
  
        @Override  
        public HouseBuilder buildTiles(String tiles) {  
            house.tiles = "豪华欧式地砖: " + tiles;  
            return this;  
        }  
  
        @Override  
        public House build() {  
            return house;  
        }  
    }  
  
    // ... 可以为其他风格创建类似的建造者类  
  
    // 指挥者类（可选，这里主要用于展示概念）  
    public static class Director {  
        private HouseBuilder builder;  
  
        public Director(HouseBuilder builder) {  
            this.builder = builder;  
        }  
  
        // 这里可以添加方法来指导建造过程，但在这个例子中，我们直接在建造者中完成了所有工作  
        public House constructHouse() {  
            // 假设这是由指挥者指导的步骤，但在这里我们直接返回建造者的结果  
            return builder  
                .buildCeiling("水晶吊灯")  
                .buildPaint("金色镶边涂料")  
                .buildFloor("大理石地板")  
                .buildTiles("马赛克地砖")  
                .build();  
        }  
    }  
  
    // 主函数，用于演示  
    public static void main(String[] args) {  
        HouseBuilder luxuryBuilder = new LuxuryEuropeanBuilder();  
        // Director director = new Director(luxuryBuilder); // 如果使用指挥者  
  
        House house = luxuryBuilder  
                .buildCeiling("水晶吊灯")  
                .buildPaint("金色镶边涂料")  
                .buildFloor("大理石地板")  
                .buildTiles("马赛克地砖")  
                .build();  
  
        System.out.println("Ceiling: " + house.getCeiling());  
        System.out.println("Paint: " + house.getPaint());  
        System.out.println("Floor: " + house.getFloor());  
        System.out.println("Tiles: " + house.getTiles());  
    }  
}

Note that in this example,DirectorThe class doesn't really add much value, since all the build logic is already encapsulated in theHouseBuilderBut in more complex applications,DirectorClasses can be used to encapsulate the order and logic of the build process, especially when the build process needs to span multiple builders.

VI. Conclusion

From the above introduction, we can see that the builder pattern has great advantages in building complex objects. It improves the encapsulation and extensibility of the code by separating the construction process from the representation, while also reducing the coupling between the client and the specific product.

If this article is helpful for your study, please like and collect it.