建造者模式

创建型模式对实例化进行抽象，将对象的创建和使用进行分离。外界只需知道对应的公共接口，不需要知道内部的具体实现细节。符合单一职责原则。

构建者模式

建造者模式(Builder Pattern)：又称为生成器模式，它属于类创建型模式。将一个复杂对象的构建与其表示相分离，使得同样的构建过程（稳定）可以创建不同的表示（变化）。主要用于创建一些复杂的对象，这些对象内部构建的建造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。

建造者模式包括以下角色：

• 产品（Product）：创建的目标。
• 抽象建造者（Builder）：声明建造者的公共接口（产品构建过程、获取产品），非必须；
• 具体建造者（ConcreteBuilder）：实现Builder接口来创建产品；
• 指挥者（Director）：创建使用Builder接口的对象，负责控制产品的建造，使客户与产品的创建过程分离（解耦），非必须；

例如，组装一台电脑，需要组件如下：主板、CPU、内存、硬盘、显示器等。

C++代码示例

/**
 * 产品类
 */
class Computer {
public:
    // setter
    void setMainBoard(string mainBoard) {
        m_mainBoard = mainBoard;
    }
    void setCPU(string cpu) {
        m_cpu = cpu;
    }
    void setRam(string ram) {
        m_ram = ram;
    }
    void setDisk(string disk) {
        m_disl = disk;
    }
    void setDisplay(string display) {
        m_display = display;
    }
    // getter 省略...
    string getMainBoard() {
        return m_mainBoard;
    }
private:
    string m_mainBoard; // 主板
    string m_cpu;       // CPU
    string m_ram;       // 内存
    string m_disk;      // 硬盘
    string m_display;   // 显示器
};

/**
 * 抽象建造者，非必要
 */
class Builder {
public:
    // 安装主板
    virtual void createMainBoard(string mainBoard) = 0;
    // 安装 cpu
    virtual void createCPU(string cpu) = 0;
    // 安装内存
    virtual void createRam(string ram) = 0;
    // 安装硬盘
    virtual void createDisk(string hardDisk) = 0;
    // 安装显示器
    virtual void createDisplay(string display) = 0;
    // 组成电脑
    virtual Computer build() = 0;
};

/**
 * 具体建造者
 */
class ConcreteBuilder : public Builder {
public:
    void createMainBoard(string mainBoard) {
        m_computer.setMainBoard(mainBoard);
    }
    void setCPU(string cpu) {
        m_computer.setCPU(cpu);
    }
    void createRam(string ram) {
        m_computer.setRam(ram);
    }
    void createDisk(string disk) {
        m_computer.setDisk(disk);
    }
    void createDisplay(string display) {
        m_computer.setDisplay(display);
    }

    Computer build() {
        return m_computer;
    }
private:
    Computer m_computer;
};

/**
 * 指挥者，非必要
 */
class Director {
public:
    Director(Builder builder) {
        m_builder = new Builder(builder);
    }
    
    Computer createComputer() {
        // 工作人员按顺序组装
        m_builder->createMainBoard("mainBoard");
        m_builder->createCpu("cpu") ;
        m_builder->createMemory("ram");
        m_builder->createhardDisk("disk");
        m_builder->createDisplay("display");

        return m_builder->build();
    }

private:
    Builder *m_builder;
};

Go代码示例

// 产品
type Computer struct {
	mainBoard string
	cpu string
	ram string
	disk string
	display string
}

func (c *Computer) setMainBoard(mainBoard string) {
	c.mainBoard = mainBoard
}
func (c *Computer) setCPU(cpu string) {
	c.cpu = cpu
}
func (c *Computer) setRam(ram string) {
	c.ram = ram
}
func (c *Computer) setDisk(disk string) {
	c.disk = disk
}
func (c *Computer) setDisplay(display string) {
	c.display = display
}

// 抽象建造者
type Builder interface {
	createMainBoard(mainBoard string)
	createCPU(cpu string)
	createRam(ram string)
	createDisk(disk string)
	createDisplay(display string)

	build() Computer
}

// 具体建造者
type ComputerBuilder struct {
	computer Computer
}

func (c *ComputerBuilder) createMainBoard(mainBoard string) {
	c.computer.setMainBoard(mainBoard)
}
func (c *ComputerBuilder) createCPU(cpu string) {
	c.computer.setCPU(cpu)
}
func (c *ComputerBuilder) createRam(ram string) {
	c.computer.setRam(ram)
}
func (c *ComputerBuilder) createDisk(disk string) {
	c.computer.setDisk(disk)
}
func (c *ComputerBuilder) createDisplay(display string) {
	c.computer.setDisplay(display)
}
func (c *ComputerBuilder) build() Computer {
	return c.computer
}

// 指挥者
type Director struct {
	builder Builder
}

func (d *Director) setBuilder(builder Builder)  {
	d.builder = builder
}

func (d *Director) createComputer() Computer {
	d.builder.createMainBoard("mainBoard")
	d.builder.createCPU("cpu")
	d.builder.createRam("ram")
	d.builder.createDisk("disk")
	d.builder.createDisplay("display")

	return d.builder.build()
}

参考：

• 《大话设计模式》 程杰