构建者模式（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、内存等）完全不同。

设计模式之构建者模式（Builder Pattern）