构建者模式（Builder Pattern）是一种创建型设计模式，旨在将复杂对象的构建过程与其表示分离。通过这种模式，客户端无需知道对象构建的具体细节或顺序，可以通过使用构建者逐步创建对象。
一、构建者模式的主要思想
分离构建过程和表示：
构建者模式通过将复杂对象的构建步骤抽象出来，并由不同的构建者实现具体的步骤。这意味着你可以构建相同类型的对象，但具体的构建方式不同（比如同一个Computer，可以是游戏电脑或办公电脑）。分步骤的构建：
构建者模式允许你在对象创建时，分步骤设置对象的不同部分，而不是在一次构造函数调用中完成。这种分步骤的方式给了你更多的控制力，也让代码更加清晰和灵活。支持链式调用：
构建者模式通常支持链式调用，允许你通过链式的方式一步步设置对象的属性，最终调用build()或类似的方法生成最终对象。这提高了代码的可读性和流畅度。灵活多变的对象构建：
不同的构建者可以实现不同的配置。比如，构建者可以生成一个高性能的游戏电脑，也可以生成一个更为节能的办公电脑。每个构建者都可以根据需要以不同的方式构建对象。
二、构建者模式的主要组成部分
Builder（构建者接口）：
定义了用于构建对象的步骤（如设置 CPU、内存等）。ConcreteBuilder（具体构建者）：
实现 Builder 接口并负责构建具体的对象。Director（指挥者）：
控制构建的流程，决定哪些步骤按什么顺序调用。Product（产品）：
最终要构建的对象，它可能是一个复杂的对象，由多个部分组成。
三、示例
package main
import "fmt"
// 1. Product：我们要构建的复杂对象，即 Computer
// 这是要构建的复杂对象，包含了 CPU、GPU、RAM、存储和电源等属性。
type Computer struct {
CPU string
GPU string
RAM string
Storage string
Power string
}
func (c *Computer) Show() {
fmt.Printf("Computer Specifications:\nCPU: %s\nGPU: %s\nRAM: %s\nStorage: %s\nPower: %s\n",
c.CPU, c.GPU, c.RAM, c.Storage, c.Power)
}
// 2. Builder接口，定义构建过程的步骤
// 这是构建者的接口，定义了构建电脑的各个步骤方法，每个方法返回 ComputerBuilder 本身以实现链式调用
type ComputerBuilder interface {
SetCPU() ComputerBuilder
SetGPU() ComputerBuilder
SetRAM() ComputerBuilder
SetStorage() ComputerBuilder
SetPower() ComputerBuilder
Build() Computer
}
// 3. ConcreteBuilder：具体的构建者实现
// 具体的构建者实现，通过实现 ComputerBuilder 接口逐步为电脑设置各个部件
type GamingComputerBuilder struct {
computer Computer
}
func NewGamingComputerBuilder() *GamingComputerBuilder {
return &GamingComputerBuilder{}
}
func (b *GamingComputerBuilder) SetCPU() ComputerBuilder {
b.computer.CPU = "Intel i9"
return b
}
func (b *GamingComputerBuilder) SetGPU() ComputerBuilder {
b.computer.GPU = "NVIDIA RTX 4090"
return b
}
func (b *GamingComputerBuilder) SetRAM() ComputerBuilder {
b.computer.RAM = "32GB DDR5"
return b
}
func (b *GamingComputerBuilder) SetStorage() ComputerBuilder {
b.computer.Storage = "1TB NVMe SSD"
return b
}
func (b *GamingComputerBuilder) SetPower() ComputerBuilder {
b.computer.Power = "850W PSU"
return b
}
func (b *GamingComputerBuilder) Build() Computer {
return b.computer
}
// 4. Director：控制建造流程。这里配合依懒注入模式
// 负责控制构建步骤的顺序，调用构建者的不同方法来完成电脑的构建
type Director struct {
builder ComputerBuilder
}
// 构造函数
func NewDirector(b ComputerBuilder) *Director {
return &Director{
builder: b,
}
}
func (d *Director) BuildComputer() Computer {
return d.builder.SetCPU().
SetGPU().
SetRAM().
SetStorage().
SetPower().
Build()
}
func main() {
// 使用 GamingComputerBuilder 构建一个电脑
gamingBuilder := NewGamingComputerBuilder()
director := NewDirector(gamingBuilder)
gamingPC := director.BuildComputer()
// 显示电脑配置
gamingPC.Show()
}
四、解决的问题
1. 避免构造函数参数过多的问题（构造函数污染）
在许多场景中，创建一个对象可能需要很多参数。如果我们直接使用构造函数来创建对象，参数列表会变得非常冗长、混乱，难以理解。尤其是当有许多可选参数时，构造函数的设计会变得更复杂。
2. 处理复杂对象的创建过程
对于复杂对象，创建它可能需要分多个步骤进行。每个步骤都有可能有一些业务逻辑，或者顺序要求。直接通过构造函数一次性创建这样的对象，会导致构造过程复杂且难以维护。
3. 灵活处理对象的不同表示或配置
在某些情况下，同一个对象的不同实例可能有不同的构建方式。例如，我们可能需要创建一台高端游戏电脑和一台普通办公电脑。虽然它们都属于 Computer 类型，但它们的配置（如 CPU、GPU、内存等）完全不同。
