设计模式-建造者模式（Builder）

一、建造者模式概述

1.1 什么是建造者模式

建造者模式（Builder Pattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式。使用多个简单的对象一步一步构建成一个复杂的对象。建造者模式关注如何逐步创建一个复杂的对象，不同的建造者定义了不同的创建过程，且具体建造者相互独立，且更换建造者和增加建造者非常的方便。

1.2 适用场景

当需要创建一个复杂对象时，该对象的内部组成部分同样很复杂，这些组成部分的构建规则也相当复杂。在这种情况下，使用建造者模式可以更好地组织和管理对象的构建过程，使得代码更加清晰和易于维护。

1.3 优缺点

建造者模式的优点在于它可以将一个复杂的对象的构建过程分解成多个相对简单的步骤，从而使得代码更加清晰和易于维护。缺点在于如果对象的构建过程非常简单，那么使用建造者模式可能会引入不必要的复杂性。

1.4 建造者模式简单实现

在建造者模式中，主要有以下角色：

• 1、Builder：负责为创建一个产品对象的各个部件指定抽象接口。
• 2、ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的。
• 3、Director：指挥者，用于构造使用Builder接口的对象。
  以下是一个简单的建造者模式示例：

class Product:
    def __init__(self):
        self.parts = []

    def add_part(self, part):
        self.parts.append(part)

class Part:
    def __init__(self, name):
        self.name = name

class Builder:
    def build(self):
        product = Product()
        product.add_part(Part("Engine"))
        product.add_part(Part("Wheel"))
        product.add_part(Part("Battery"))
        return product

class Director:
    def construct(self, builder):
        return builder.build()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这个例子中，Product 是我们要构建的复杂对象，Part 是组成 Product 的部分，Builder 是用于构造 Product 的接口，Director 是指挥者，用于指导 Builder 如何构建 Product。

二、建造者模式的用途

建造者模式主要用于解决在创建复杂对象过程中的问题，它将一个复杂对象的构建过程分解成多个相对简单的步骤，使得代码更加清晰和易于维护。

其主要用途如下：

• 1、客户端不必知道产品内部组成的细节，产品的创建过程与产品本身解耦，相同的创建过程可以创建不同的产品对象。
• 2、具体的建造者之间相互独立，更换具体建造者或增加新的具体建造者非常方便，用户使用不同的具体建造者即可得到不同的产品对象。
• 3、增加新的具体建造者无须修改原有类库的代码，符合“开闭原则”，系统扩展方便。
• 4、可以更加精细的控制产品的创建过程，将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

三、建造者模式实现方式

3.1 抽象建造者模式

抽象建造者模式是一种行为设计模式，它允许你通过将对象的构建与其表示分离来创建一个复杂的对象。这种模式主要用于创建具有多个部分的对象，这些部分可以独立地构建和组合。

以下是一个简单的Java实现：

首先，我们创建一个抽象的Builder类，它定义了建造者的基本接口：

public abstract class Builder {
    // 建造产品的方法，由子类实现
    public abstract Product build();
}

1
2
3
4
5

然后，我们创建一个具体的Product类，它包含了产品的多个部分：

public class Product {
    private String partA;
    private String partB;
    private String partC;

    // getter and setter methods
}
1
2
3
4
5
6
7

接下来，我们为每个产品的部分创建一个具体的Builder类：

public class ConcreteBuilder1 extends Builder {
    private Product product = new Product();

    @Override
    public Product build() {
        product.setPartA("Part A");
        return product;
    }
}

public class ConcreteBuilder2 extends Builder {
    private Product product = new Product();

    @Override
    public Product build() {
        product.setPartB("Part B");
        return product;
    }
}

public class ConcreteBuilder3 extends Builder {
    private Product product = new Product();

    @Override
    public Product build() {
        product.setPartC("Part C");
        return product;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

最后，我们在客户端代码中使用这些建造者来创建产品：

public class Client {
    public static void main(String[] args) {
        Builder builder1 = new ConcreteBuilder1();
        Product product1 = builder1.build();

        Builder builder2 = new ConcreteBuilder2();
        Product product2 = builder2.build();

        Builder builder3 = new ConcreteBuilder3();
        Product product3 = builder3.build();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

这个例子中，我们使用了三个不同的建造者来创建同一个产品的不同部分。这种方式使得我们可以在不改变产品类的情况下，灵活地添加新的产品部分。

3.2 生成器模式

生成器模式是一种创建型设计模式，它提供了一种更灵活的方式来创建复杂对象。在建造者模式中，一个复杂对象的构建过程被分解成多个步骤，每个步骤都由一个生成器类来负责。

以下是一个简单的生成器模式实现建造者模式的 Java 示例：

// Product 类
public class Product {
    private String partA;
    private String partB;
    private String partC;

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }

    @Override
    public String toString() {
        return "Product{" +
                "partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                ", partC='" + partC + '\'' +
                '}';
    }
}

// Builder 接口
interface Builder {
    void buildPartA();
    void buildPartB();
    void buildPartC();
    Product getResult();
}

// ConcreteBuilder1 类
class ConcreteBuilder1 implements Builder {
    private Product product;

    public ConcreteBuilder1() {
        product = new Product();
    }

    @Override
    public void buildPartA() {
        product.setPartA("Part A");
    }

    @Override
    public void buildPartB() {
        product.setPartB("Part B");
    }

    @Override
    public void buildPartC() {
        product.setPartC("Part C");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

// ConcreteBuilder2 类
class ConcreteBuilder2 implements Builder {
    private Product product;

    public ConcreteBuilder2() {
        product = new Product();
    }

    @Override
    public void buildPartA() {
        product.setPartA("Part X");
    }

    @Override
    public void buildPartB() {
        product.setPartB("Part Y");
    }

    @Override
    public void buildPartC() {
        product.setPartC("Part Z");
    }

    @Override
    public Product getResult() {
        return product;
    }
}

// Director 类
class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void construct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
}

// Client 代码
public class Main {
    public static void main(String[] args) {
        Builder builder1 = new ConcreteBuilder1();
        Director director1 = new Director(builder1);
        director1.construct();
        Product product1 = builder1.getResult();
        System.out.println(product1);

        Builder builder2 = new ConcreteBuilder2();
        Director director2 = new Director(builder2);
        director2.construct();
        Product product2 = builder2.getResult();
        System.out.println(product2);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

在这个例子中，Product 是我们要构建的复杂对象，Part 是组成 Product 的部分，Builder 是用于构造 Product 的接口，ConcreteBuilder1 和 ConcreteBuilder2 是具体建造者，它们实现了 Builder 接口并提供了不同的构建步骤。客户端代码可以根据需要选择不同的具体建造者来构建产品对象。

3.3 默认建造者模式

默认建造者模式是一种简化版的建造者模式，它只包含一个建造者类和一个产品类。以下是一个简单的Java实现：

首先，我们创建一个产品类Product：

public class Product {
    private String partA;
    private String partB;
    private String partC;

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public void setPartC(String partC) {
        this.partC = partC;
    }

    @Override
    public String toString() {
        return "Product{" +
                "partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                ", partC='" + partC + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

接下来，我们创建一个建造者类Builder：

public class Builder {
    private Product product;

    public Builder() {
        product = new Product();
    }

    public Builder setPartA(String partA) {
        product.setPartA(partA);
        return this;
    }

    public Builder setPartB(String partB) {
        product.setPartB(partB);
        return this;
    }

    public Builder setPartC(String partC) {
        product.setPartC(partC);
        return this;
    }

    public Product build() {
        return product;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

最后，我们在客户端代码中使用建造者模式创建产品：

public class Client {
    public static void main(String[] args) {
        Product product = new Builder()
                .setPartA("Part A")
                .setPartB("Part B")
                .setPartC("Part C")
                .build();

        System.out.println(product);
    }
}
1
2
3
4
5
6
7
8
9
10
11

运行客户端代码，将输出以下结果：

Product{partA='Part A', partB='Part B', partC='Part C'}
1