理论：
在建造者模式中，通常有以下几个角色：
- Builder（建造者）：定义了构建对象的抽象接口，包含了构建对象的各个步骤。
- ConcreteBuilder（具体建造者）：实现了Builder接口，负责实现构建对象的各个步骤，并返回最终构建的对象。
- Director（指挥者）：负责调用具体建造者来构建对象，它并不知道具体的构建细节，只知道调用构建者的方法来构建对象。
- 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
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
|
package main
import "fmt"
// Product 表示正在构建的对象
type Product struct {
partA string
partB string
partC string
}
// Builder 定义创建产品的接口
type Builder interface {
buildPartA() Builder
buildPartB() Builder
buildPartC() Builder
getProduct() Product
}
var _ Builder = &ConcreteBuilder{}
// ConcreteBuilder 实现了Builder接口
type ConcreteBuilder struct {
product Product
}
func (b *ConcreteBuilder) buildPartA() Builder {
b.product.partA = "Part A"
return b
}
func (b *ConcreteBuilder) buildPartB() Builder {
b.product.partB = "Part B"
return b
}
func (b *ConcreteBuilder) buildPartC() Builder {
b.product.partC = "Part C"
return b
}
func (b *ConcreteBuilder) getProduct() Product {
return b.product
}
// Director 使用Builder来管理构建过程
type Director struct {
builder Builder
}
func (d *Director) construct() {
d.builder.buildPartA().buildPartB().buildPartC()
}
func main() {
builder := &ConcreteBuilder{}
director := &Director{builder: builder}
director.construct()
product := builder.getProduct()
fmt.Printf("产品部件: %s, %s, %s\n", product.partA, product.partB, product.partC)
}
|
这个案例中，我们定义了一个产品（Product）和一个建造者（Builder）接口。具体的建造者（ConcreteBuilder）实现了建造者接口，并负责构建产品的各个部分。Director（导演）负责使用建造者来构建产品。 接口返回本身接口，可以支持主流的流式编程
在主函数中，我们创建了一个具体的建造者和导演，并通过导演来构建产品。最后，我们打印出产品的各个部分。
运行以上代码将输出：
1
|
产品部件: Part A, Part B, Part C
|
这个案例展示了如何使用建造者模式来构建复杂对象，通过将对象的构建过程与表示分离，使得同样的构建过程可以创建不同的表示。
