生成器模式-代码的艺术系列（一）

前言

看代码"文档"，学设计模式

网上讲解设计模式都是基于现实生活场景举例，但作为 coder，还需要有将现实生活场景到代码实现场景的转化思维，所以我认为，了解设计模式简单，实践到对应代码场景中有难度。

so 我们的代码的艺术系列会以还原 coding 现场的方式，讲诉设计模式！

生成器模式

来看概念：

生成器模式是一种创建型设计模式，也叫建造者模式。它把对象的创建步骤抽象成生成器，并且可以通过指导类（director）对所有生成步骤的先后顺序进行控制。客户端使用指导类并传入相应的生成器，通过指导类的接口便可以得到相应的对象。

The intent of the Builder design pattern is to separate the construction of a complex object from its representation. By doing so the same construction process can create different representations. 将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示

概括的说：有些对象的创建流程是一样的，但是因为自身特性的不同，所以在创建他们的时候需要将创建过程和个性化的属性分离出来。

基本看不懂啥意思，赞！ 继续看结构~

来看结构:

1. 生成器 （ Builder ） 接口声明在所有类型生成器中通用的产品构造步骤。
2. 具体生成器 （ Concrete Builders ） 提供构造过程的不同实现。 具体生成器也可以构造不遵循通用接口的产品。
3. 产品 （ Products ） 是最终生成的对象。 由不同生成器构造的产品无需属于同一类层次结构或接口。
4. 主管 （ Director ） 类定义调用构造步骤的顺序， 这样你就可以创建和复用特定的产品配置。
5. 客户端 （ Client ） 必须将某个生成器对象与主管类关联。 一般情况下， 你只需通过主管类构造函数的参数进行一次性关联即可。 此后主管类就能使用生成器对象完成后续所有的构造任务。

实战学习

概念性描述你懂了么？不懂就对了，程序员先理解概念不如直接上代码来的刺激。

这里贯彻下我们前言中的宗旨：

1. 不要生活场景的举例，要产品需求的案例。
2. 不要纯图文的描述，要可阅读的代码。

上实战~

产品需求

没有产品思维的程序员不是好销售，此需求纯属虚构

pm 要在自家的电商网站电脑产品垂类下增加报价功能。

PRD 描述当用户进入 mac 品牌的详情页，他可以选择 I7 CPU，500G 内存，1T 磁盘的配置，查看报价。

不同品牌的部件价格不相同，并且不同品牌在同一时刻有不同的优惠折扣。

需求目标: 实时计算出用户选择的电脑配置折后价钱。

需求收益: 提高下单率 50%

技术文档

技术脑爆时刻到了!

乍一听感觉很简单，没什么复杂逻辑。

其实真的很简单。但是问题是不同品牌的部件配置价格不同，而且不同品牌的折扣也是不同的。用户选择了 A,B,C-Z 一坨配置，我的代码要这么写么？

var cpuPrice map[string]float { xxx : 100, xxxx : 200 } // 电脑有 N 个部件，我的函数入参就要有 N 个么？ // 这个函数谁敢用？ getMaxPrice(type= '', cpu='',mem='',ram='',disk=''...一堆配置){ if type == 'mac' { price := 0 if(cpu == '') { cpu="默认配置" } price += cpuPrice[cpu] if(mem == '') { mem="默认配置" } price += memPrice[mem] ... } elseif (type == 'huawei') { ... } } 

这样看这坨代码的代码量绝对高，并且大部分是重复代码，而且当电脑配置越来越多，getMaxPrice 函数入参也跟着变多，参数顺序谁能保证？有的产生是必填有的是非必填，怎么帮助必填的没有被漏掉？

这样的代码时间久了，逻辑看着很简单，但是没人敢用吧。

怎么办呢？

使用生成器模式来解决是不是好一点，每个部件作为一个生成步骤，每次执行一个步骤即添加一个部件配置，最终生成一个完整的电脑报价，并且设置部件、获取折扣、计数报价这些步骤本身是有序的，是可以通过生成器模式中的 Director 小干部来统一操作的。

好，来看代码吧！

代码"文档"

Tips: 代码 + 注释。

自我要求：注释覆盖率 > 60%

1.先定义一个电脑报价的配置总类，即我们要生成的产品：Computer

package builder // 产品： 这个是我们的目标，computer 要有这些配置 // computer 可以理解成我们要制作一个什么产品 // 结构体字段 可以理解为我们要做的产品都要哪些配置，对应上文 生成函数的 N 多个入参 type Computer struct { name string // 电脑类型 比如 mac/华为 cpuModel CPU_MODEL // cpu 型号 gpuModel GPU_MODEL // gpu 型号 memorySize MEM_SIZE // 内存大小 diskSize DISK_SIZE // 磁盘大小 discount float64 // 折扣 price float64 // 整体报价 } 

2.再定义一个电脑生成的步骤规范接口

package builder // 生成器接口： 产品的生成器接口 // 可以理解为这个产品生成 必须要有哪些具体的步骤和行为, 后面每一个抽象的产品生成对象都要继承这个生成器接口 type builder interface { setCpuModel(CPU_MODEL) // 设置 cpu 型号 setGpuModel(GPU_MODEL) // 设置 gpu 型号 setMemorySize(MEM_SIZE) // 设置 内存型号 setDiskSize(DISK_SIZE) // 设置磁盘型号 setDiscount() // 设置折扣粒度, 这个折扣粒度是系统内置的，不需要客户端设置也就是说此功能不是给前台用户询价时自定义的。 calculatePrice() // 计算报价 getComputer() *Computer // 给主管(director)使用 } 

3.开始定义各个电脑品牌抽象生成器

先看 Mac 的

package builder import ( "time" ) // 抽象的产品生成器 // 可以理解为 computer 这个产品中某一类型产品的生成器 // 抽象生成器即包含了产品(computer)的所有配置，也继承了 builder 公共生成器的所有生成步骤 type MacComputerBuilder struct { c *Computer } // 实力化一个 Mac 电脑报价 func NewMacComputerBuilder() builder { return &MacComputerBuilder{ c: &Computer{name: "mac"}, } } // 返回*Computer func (mc *MacComputerBuilder) getComputer() *Computer { return mc.c } // 设置 CPU 型号 // 设置配置的时候要判断，如果客户端已经配置了，那么跳过 // 这块是因为 director 会在最后编译的时候统一整体执行一遍，防止客户端漏掉配置，走默认配置 func (mc *MacComputerBuilder) setCpuModel(m CPU_MODEL) { // demo if mc.c.cpuModel != "" { return } if price, ok := partsCpuPriceMap[m]; ok { mc.c.cpuModel = m mc.c.price += price } else { mc.c.cpuModel = MAC_CPU_I5 // 此为 mac 电脑默认 cpu 配置 mc.c.price += partsCpuPriceMap[MAC_CPU_I5] } } // 设置 GPU 型号 // 设置配置的时候要判断，如果客户端已经配置了，那么跳过 // 这块是因为 director 会在最后编译的时候统一整体执行一遍，防止客户端漏掉配置，走默认配置 func (mc *MacComputerBuilder) setGpuModel(m GPU_MODEL) { // demo if mc.c.gpuModel != "" { return } if price, ok := partsGpuPriceMap[m]; ok { mc.c.gpuModel = m mc.c.price += price } else { mc.c.gpuModel = MAC_GPU_NVIDIA // 此为 mac 电脑默认 gpu 配置 mc.c.price += partsGpuPriceMap[MAC_GPU_NVIDIA] } } // 设置内存大小 // 设置配置的时候要判断，如果客户端已经配置了，那么跳过 // 这块是因为 director 会在最后编译的时候统一整体执行一遍，防止客户端漏掉配置，走默认配置 func (mc *MacComputerBuilder) setMemorySize(s MEM_SIZE) { // demo if mc.c.memorySize != "" { return } if price, ok := partsMemPriceMap[s]; ok { mc.c.memorySize = s mc.c.price += price } else { mc.c.memorySize = MAC_MEM_8G // 此为 mac 电脑默认 内存 配置 mc.c.price += partsMemPriceMap[MAC_MEM_8G] } } // 设置 磁盘大小 // 设置配置的时候要判断，如果客户端已经配置了，那么跳过 // 这块是因为 director 会在最后编译的时候统一整体执行一遍，防止客户端漏掉配置，走默认配置 func (mc *MacComputerBuilder) setDiskSize(s DISK_SIZE) { // demo if mc.c.diskSize != "" { return } if price, ok := partsDiskPriceMap[s]; ok { mc.c.diskSize = s mc.c.price += price } else { mc.c.diskSize = MAC_DISK_500G // 此为 mac 电脑默认 磁盘 配置 mc.c.price += partsDiskPriceMap[MAC_DISK_500G] } } // 设置折扣 // 不同产品策略不一样 // 此操作为内置操作，不需要外部设置 func (mc *MacComputerBuilder) setDiscount() { // 2021-06-24 00:17:33 // 如果大于这个时间，那么 mac 电脑整体打 5 折 // 否则 整体打 8 折 if time.Now().Unix() > 1624465043 { mc.c.discount = 0.5 } else { mc.c.discount = 0.8 } } // 计数价格 // 注意看，这块就是需要时序的地方，需要先 setDiscount 才能进行报价 // 所以 需要通过 指挥者来统一进行构建，保证各个行为执行顺序 func (mc *MacComputerBuilder) calculatePrice() { mc.c.price = (mc.c.price * mc.c.discount) } 

在看一个 huawei 的。

package builder import "C" // 抽象的产品生成器 // 可以理解为 computer 这个产品中某一类型产品的生成器 // 抽象生成器即包含了产品(computer)的所有配置，也继承了 builder 公共生成器的所有生成步骤 type HuaweiComputerBuilder struct { c *Computer } func NewHuaweiComputerBuilder() builder { return &HuaweiComputerBuilder{ c: &Computer{name: "huawei"}, } } func (hc *HuaweiComputerBuilder) getComputer() *Computer { return hc.c } /** * 以下设置各个配置方法和 Mac 逻辑一样，当然也可以自定义策略，不过 demo 就这样了，保证篇幅，所以就不写了 */ // 设置 CPU 型号 func (hc *HuaweiComputerBuilder) setCpuModel(m CPU_MODEL) {} // 设置 GPU 型号 func (hc *HuaweiComputerBuilder) setGpuModel(m GPU_MODEL) {} // 设置内存大小 func (hc *HuaweiComputerBuilder) setMemorySize(s MEM_SIZE) {} // 设置 磁盘大小 func (hc *HuaweiComputerBuilder) setDiskSize(s DISK_IZE) {} // 设置优惠折扣，这块是内部逻辑，不需要外部调用方定义，而且不同产品策略不一样 func (hc *HuaweiComputerBuilder) setDiscount() { // 华为机器不打折，国产赞。 这块就是和 mac 差异化的地方 hc.c.discount = 1 } // 既然华为不打折，那么直接输出就好了 func (hc *HuaweiComputerBuilder) calculatePrice() { } 

看到区别了吧，两个品牌生成器的优惠策略不同，计数价格方法不同，但是统一生成步骤一样，所以需要主管来统一调度执行

来看主管director

package builder // director 主管，负责整体 build 执行 // 可以理解为总指挥，他来负责计算报价 type director struct { builder builder } // 实例化一个主管 func NewDirector(b builder) *director { return &director{ builder: b, } } // 手动重置主管，方便进行多次不同产品生成构建 func (d *director) resetBuilder(b builder) { d.builder = b } // 执行编译生成，这块就是要严格统一管理编译的步骤和顺序 // 当前这个 demo , 因为时计算报价的例子而不是生成电脑配置的例子，所以前置的那些 setXXX 都在客户端自定义执行了 // 但是有可能前台用户没有选择某些配置，所以需要主管统一兜底 // 1. 兜底每个电脑配置 // 2. 根据当前时间选择折扣粒度 // 3. 计算报价 func (d *director) buildComputer() *Computer { // 第一步，兜底每一个电脑配置 d.builder.setCpuModel(DIRECTOR_CHECK_PARAMS) d.builder.setGpuModel(DIRECTOR_CHECK_PARAMS) d.builder.setMemorySize(DIRECTOR_CHECK_PARAMS) d.builder.setDiskSize(DIRECTOR_CHECK_PARAMS) // 第二步设置折扣 d.builder.setDiscount() // 第三步 计算报价 d.builder.calculatePrice() // 返回产品对象 return d.builder.getComputer() } 

到这块是不是差不多看懂了？最后我们看下客户端是如何调用实现的：

package builder import "fmt" // 客户端询问报价 // 即用户在前台页面选择了 mac 电脑 // CPU i7 // GPU xxx func getPrice() { // 先实例化抽象生成器对象，即 mac 电脑 mcb := NewMacComputerBuilder() // 设置我想询问的配置 mcb.setCpuModel(MAC_CPU_I7) mcb.setGpuModel(MAC_GPU_NVIDIA) mcb.setMemorySize(MAC_MEM_16G) // 磁盘我不选了，用默认的 //mcb.setDiskSize() // 然后实例化一个主管，来准备生成报价 d := NewDirector(mcb) // 执行编译，生成最终产品 product := d.buildComputer() // ok 搞定了，我们可以看看最终这个产品的配置和报价 fmt.Printf("current computer name: %s\n", product.name) fmt.Printf("choose config cpuModel: %s\n", product.cpuModel) fmt.Printf("choose config gpuModel: %s\n", product.gpuModel) fmt.Printf("choose config memorySize: %s\n", product.memorySize) fmt.Printf("choose config diskSize: %s\n", product.diskSize) fmt.Printf("give you discount: %f\n", product.discount) fmt.Printf("final offer: %f\n", product.price) fmt.Printf("---------------询问下一个电脑---------------\n") // 下面 我们再生成一个华为的电脑报价 hwcb := NewHuaweiComputerBuilder() hwcb.setCpuModel(HW_CPU_I7) hwcb.setGpuModel(HW_GPU_ATI) hwcb.setMemorySize(HW_MEM_16G) hwcb.setDiskSize(HW_DISK_1T) d.resetBuilder(hwcb) // 执行编译，生成最终产品 product2 := d.buildComputer() // ok 搞定了，我们可以看看最终这个产品的配置和报价 fmt.Printf("current computer name: %s\n", product2.name) fmt.Printf("choose config cpuModel: %s\n", product2.cpuModel) fmt.Printf("choose config gpuModel: %s\n", product2.gpuModel) fmt.Printf("choose config memorySize: %s\n", product2.memorySize) fmt.Printf("choose config diskSize: %s\n", product2.diskSize) fmt.Printf("give you discount: %f\n", product2.discount) fmt.Printf("final offer: %f\n", product2.price) } 

上线效果

=== RUN TestGetPrice current computer name: mac choose config cpuModel: maci7 choose config gpuModel: mac-NVIDIA choose config memorySize: mac-16g choose config diskSize: mac-500g give you discount: 0.500000 final offer: 600.000000 ---------------询问下一个电脑--------------- current computer name: huawei choose config cpuModel: hwi7 choose config gpuModel: hw-ATI choose config memorySize: hw-16g choose config diskSize: hw-1t give you discount: 1.000000 final offer: 2800.000000 --- PASS: TestGetPrice (0.00s) PASS 

还是符合预期的！

Demo 源码：https://github.com/xiaoxuz/design-pattern/tree/main/create/builder

生成器优缺点

• 优点
  • 你可以分步创建对象，暂缓创建步骤或递归运行创建步骤。
  • 生成不同形式的产品时， 你可以复用相同的制造代码。
  • *单一职责原则*。 你可以将复杂构造代码从产品的业务逻辑中分离出来。
• 缺点
  • 由于该模式需要新增多个类， 因此代码整体复杂程度会有所增加。

思考

认识我们的职业，不是码农，是软件工程师！

收工

打完收工，感谢阅读!

** [点击] 关注再看，您的关注是我前进的动力~！**