0 生活案例
沙师弟 : “大师兄，车是怎么建成的啊？”
大师兄：“从外部看，车由车身、座椅和轮胎，从内部又有引擎、方向盘、电路系统、刹车系统、冷却系统等等组成，这些复杂的部件一般都不是一个厂商来完成的，而是将这些交付给汽车零部件制造商。不同的生产商来最终完成不同部件的生产，采购完整个零部件，最后在车间完成整个组装。”
汽车这个复杂的对象就可以通过建造者模式来将部件和组装过程分开，帮我们快速完成汽车的建造。
1 建造者模式
构建者模式帮助我们构建复杂的对象，而不需要直接实例化它们的结构，或编写它们所需的逻辑。想象一下，一个对象可能有几十个字段，它们本身就是比较复杂的结构。
现在，你有许多具有这些特征的对象，还可以有更多。我们不希望在包中写创建所有这些对象的逻辑，而只在需要使用这些对象的地方写好。
1.1 Go 中的对象实例
在 Go 语言中，实例的创建可以很简单，比如只是简单提供 {} ，然后让实例的值为零；也可以很复杂，比如一个对象需要进行一些 API 调用，检查状态，并为其字段创建对象。
你也可以有一个由多个对象组成的对象，这在 Go 中是非常常见的，因为 Go 不支持继承。
同时，你可以用同样的技术来创造许多类型的对象。例如，你将使用几乎相同的技术来建造一辆汽车和一辆公共汽车，只是它们的尺寸和座位数不同，所以我们为什么不重复使用建造过程呢？这就是建造者模式的用武之地了。
1.2 建造者模式的优点
1.3 交通工具制造的例子
建造者模式通常被描述为一个主管 director、几个 Builder 和他们所创建的产品之间的关系。
我们来看关于汽车的例子，创建一个车辆建造器 Builder，建造车（Product）的过程或许会有一些差异，但对每一种车辆来说，整体的过程可以归纳为如下步骤：
选择车辆类型
组装结构
安装车轮
放置座椅
如果你仔细思考，你可以重复通过这个步骤描述建造一辆骑车和一辆摩托车，在接下来的例子中，主管 director 的角色就是用 Manufacturing 变量进行表示。
1.4 设计思路
正如上述的描述那样，我们必须处理一些 Builder 变量和一个独立的 director . 主管 director 来领导实际建造者 Builder 的建造产品的过程。因此，对于一个车辆建造者的要求是：
需要有一个制造对象来制造交通工具的一切
当使用汽车建造者 Builder 时，返回的车辆产品必须带有 4 个轮子、5 个座椅和定义为 Car 的结构体
使用摩托车建造者时，返回的车辆产品必须带有 2 个轮子、供 2 个人的座位和定义为 Motorbike 的结构体
任何 BuilderProcess 建造者必须开放对车辆产品的修改功能
结构图如下：
2 测试驱动开发
根据前文的设计过程，我们将建造一个 director 变量：ManufacturingDirector , 以使用由汽车和摩托车产品建造器的建造过程。dierctor 是负责人，builder 是实际的建造者。
2.1 Builder 接口声明
Builder 声明如下：
package creational
type BuildProcess interface { SetWheels() BuildProcess SetSeats() BuildProcess SetStructure() BuildProcess GetVehicle() VehicleProduct}
复制代码
2.2 Director 主管接口
ManufacturingDirector 主管接口可以来自接收不同的 Builder:
// 制作主管type ManufacturingDirector struct{}
func (f *ManufacturingDirector) Construct() { // 建筑过程}
func (f *ManufacturingDirector) SetBuilder(b BuildProcess) { // 选择建造者}
复制代码
2.3 Product 产品结构体
产品是我们在制造出的最终对象。在上面的简易例子中，我们假设一辆交通工具是由车轮、座椅和结构组成的。
// 产品type VehicleProduct struct { Wheels int Seats int Structure string}
复制代码
2.4 Builder 具体建造者
第一个 Builder 为 Car 建造者 Builder，需要我们实现定义在 BuildProcess 接口的方法:
// 汽车建造者type CarBuilder struct{}
func (c *CarBuilder) SetWheels() BuildProcess { return nil}
func (c *CarBuilder) SetSeats() BuildProcess { return nil}
func (c *CarBuilder) SetStructure() BuildProcess { return nil}
func (c *CarBuilder) GetVehicle() VehicleProduct { return VehicleProduct{}}
复制代码
同理，摩托车建造者如下：
// 摩托车建造者type MotorBuilder struct{}
func (m *MotorBuilder) SetWheels() BuildProcess { return nil}
func (m *MotorBuilder) SetSeats() BuildProcess { return nil}
func (m *MotorBuilder) SetStructure() BuildProcess { return nil}
func (m *MotorBuilder) GetVehicle() VehicleProduct { return VehicleProduct{}}
复制代码
最终，我们得到完整的 creational.go 文件：
package creational
// 建造过程type BuildProcess interface { SetWheels() BuildProcess SetSeats() BuildProcess SetStructure() BuildProcess GetVehicle() VehicleProduct}
// 制作主管type ManufacturingDirector struct{}
func (f *ManufacturingDirector) Construct() { // 等待实现}
func (f *ManufacturingDirector) SetBuilder(b BuildProcess) { // 等待实现}
// 产品type VehicleProduct struct { Wheels int Seats int Structure string}
// 汽车建造者type CarBuilder struct{}
func (c *CarBuilder) SetWheels() BuildProcess { return nil}
func (c *CarBuilder) SetSeats() BuildProcess { return nil}
func (c *CarBuilder) SetStructure() BuildProcess { return nil}
func (c *CarBuilder) GetVehicle() VehicleProduct { return VehicleProduct{}}
// 摩托车建造者type MotorBuilder struct{}
func (m *MotorBuilder) SetWheels() BuildProcess { return nil}
func (m *MotorBuilder) SetSeats() BuildProcess { return nil}
func (m *MotorBuilder) SetStructure() BuildProcess { return nil}
func (m *MotorBuilder) GetVehicle() VehicleProduct { return VehicleProduct{}}
复制代码
2.5 编写测试用例
针对上面编写的建造过程，我们可以进行如下的测试，同目录下创建 creational_test.go 文件。
1、首先是测试汽车建造过程，假定最终生产的汽车是具有 4 个轮子，5 个座位，然后结构是 Car 类型，写入如下代码:
package creational
import "testing"
func TestBuilderPattern(t *testing.T) {
manufacturingComplex := ManufacturingDirector{}
carBuilder := &CarBuilder{} manufacturingComplex.SetBuilder(carBuilder) manufacturingComplex.Construct()
car := carBuilder.GetVehicle()
if car.Wheels != 4 { t.Errorf("Wheels on a car must be 4 and they were %d\n", car.Wheels) }
if car.Structure != "Car" { t.Errorf("Structure on a car must be 'Car' and was %s\n", car.Structure) }
if car.Seats != 5 { t.Errorf("Seats on a car must be 5 and they were %d\n", car.Seats) }
}
复制代码
我们写了 3 个简单的测试检查是否建造出汽车类型。运行单元测试，结果如下：
$ go test -v .=== RUN TestBuilderPattern creational_test.go:16: Wheels on a car must be 4 and they were 0 creational_test.go:20: Structure on a car must be 'Car' and was creational_test.go:24: Seats on a car must be 5 and they were 0--- FAIL: TestBuilderPattern (0.00s)FAILFAIL github.com/yuzhoustayhungry/GoDesignPattern/creational 0.860sFAIL
复制代码
如上显示，3 个测试单元都显示失败，接着我们来看一下摩托车的单元测试怎么写的。
2、摩托车 motorCycle 的单元测试如下：
motorBuilder := &MotorBuilder{}
manufacturingComplex.SetBuilder(motorBuilder) manufacturingComplex.Construct()
motorCycle := motorBuilder.GetVehicle()
if motorCycle.Wheels != 2 { t.Errorf("Wheels on a motorCycle must be 2 and they were %d\n", motorCycle.Wheels) }
if motorCycle.Structure != "MotorCycle" { t.Errorf("Structure on a motorCycle must be 'MotorCycle' and was %s\n", motorCycle.Structure) }
if motorCycle.Seats != 2 { t.Errorf("Seats on a motorCycle must be 2 and was %d\n", motorCycle.Seats) }
复制代码
建造过程跟 car 类似，我们只需要向 manufacturingComplex.SetBuilder(motorBuilder) 传递 motorBuilder 即可，我们假定摩托车有 2 个轮子，2 个座位，结构必须为 MotorCyle。
运行测试代码，得到如下结果：
$ go test -v .=== RUN TestBuilderPattern creational_test.go:16: Wheels on a car must be 4 and they were 0 creational_test.go:20: Structure on a car must be 'Car' and was creational_test.go:24: Seats on a car must be 5 and they were 0 creational_test.go:36: Wheels on a motorCycle must be 2 and they were 0 creational_test.go:41: Structure on a motorCycle must be 'MotorCycle' and was creational_test.go:46: Seats on a motorCycle must be 2 and was 0--- FAIL: TestBuilderPattern (0.00s)FAILFAIL github.com/yuzhoustayhungry/GoDesignPattern/creational 0.595sFAIL
复制代码
可以看到，单元测试也是失败的，因为我们还没有完成实现具体的建造者模式。接下来就是具体实现的过程。
3 建造者模式 Go 实现
为了实现建造者，想必你也开始有了一点点自己的思路吧。再来实现我们之前创建的 creation.go 文件，全新的 creational.go 文件代码如下：
package creational
// 建造过程type BuildProcess interface { SetWheels() BuildProcess SetSeats() BuildProcess SetStructure() BuildProcess GetVehicle() VehicleProduct}
// 制作主管type ManufacturingDirector struct { builder BuildProcess}
func (f *ManufacturingDirector) Construct() { // f.builder.SetSeats().SetStructure().SetWheels()}
func (f *ManufacturingDirector) SetBuilder(b BuildProcess) { // f.builder = b}
// 产品type VehicleProduct struct { Wheels int Seats int Structure string}
// 汽车建造者type CarBuilder struct { v VehicleProduct}
func (c *CarBuilder) SetWheels() BuildProcess { // return nil c.v.Wheels = 4 return c}
func (c *CarBuilder) SetSeats() BuildProcess { // return nil c.v.Seats = 5 return c}
func (c *CarBuilder) SetStructure() BuildProcess { // return nil c.v.Structure = "Car" return c}
func (c *CarBuilder) GetVehicle() VehicleProduct { // return VehicleProduct{} return c.v}
// 摩托车建造者type MotorBuilder struct { v VehicleProduct}
func (m *MotorBuilder) SetWheels() BuildProcess { // return nil m.v.Wheels = 2 return m}
func (m *MotorBuilder) SetSeats() BuildProcess { // return nil m.v.Seats = 2 return m}
func (m *MotorBuilder) SetStructure() BuildProcess { // return nil m.v.Structure = "MotorCycle" return m}
func (m *MotorBuilder) GetVehicle() VehicleProduct { // return VehicleProduct{} return m.v}
复制代码
更改后的 creational_test.go 文件如下：
package creational
import "testing"
func TestBuilderPattern(t *testing.T) {
manufacturingComplex := ManufacturingDirector{}
carBuilder := &CarBuilder{} manufacturingComplex.SetBuilder(carBuilder) manufacturingComplex.Construct()
car := carBuilder.GetVehicle()
if car.Wheels != 4 { t.Errorf("Wheels on a car must be 4 and they were %d\n", car.Wheels) }
if car.Structure != "Car" { t.Errorf("Structure on a car must be 'Car' and was %s\n", car.Structure) }
if car.Seats != 5 { t.Errorf("Seats on a car must be 5 and they were %d\n", car.Seats) }
motorBuilder := &MotorBuilder{}
manufacturingComplex.SetBuilder(motorBuilder) manufacturingComplex.Construct()
motorCycle := motorBuilder.GetVehicle()
if motorCycle.Wheels != 2 { t.Errorf("Wheels on a motorCycle must be 2 and they were %d\n", motorCycle.Wheels) }
if motorCycle.Structure != "MotorCycle" { t.Errorf("Structure on a motorCycle must be 'MotorCycle' and was %s\n", motorCycle.Structure) }
if motorCycle.Seats != 2 { t.Errorf("Seats on a motorCycle must be 2 and was %d\n", motorCycle.Seats) }
}
复制代码
实现完所有的方法之后，再看运行 go test -v . 执行后的测试结果：
$ go test -v .=== RUN TestBuilderPattern--- PASS: TestBuilderPattern (0.00s)PASSok github.com/yuzhoustayhungry/GoDesignPattern/creational 0.255s
复制代码
恭喜，至此，测试用例全部通过。你也可以看到，建造者模式是一个可重复的模式，但在 BuildProcess 接口的每个方法内，我们可以封装尽可能多的复杂对象，这样，用户其实并不知道关于对象创建的细节。
4 建造者模式总结
就像制作汽车一样，建造者模式的核心在于如何一步一步地构建一个包含多个组成部件的完整对象，使用相同的构建过程构建不同的产品。
在软件开发过程中，如果需要创建复杂对象，并希望系统具备很好的灵活性和可扩展性，可以考虑使用建造者模式。
希望本文能对你有所帮助，如果喜欢本文，可以点个关注。
这里是宇宙之一粟，下一篇文章见！
宇宙古今无有穷期，一生不过须臾，当思奋争。
评论