建造者模式(Builder模式)

一、模式的定义与特点

建造者模式(Builder)：指将一个复杂对象的构造与它的表示分离，使同样的构建过程可以构建不同的表示

优点

• 各个具体的建造者相互独立，有利于系统的扩展
• 客户端不必知道产品内部组成的细节，便于控制细节风险

缺点

• 产品的组成部分必须相同，这限制了其使用范围
• 如果产品的内部变化复杂，该模式会增加很多的建造者类

二、模式的结构与实现

建造者(Builder)模式由产品、抽象建造者、具体建造者和指挥者4个要素构成

模式的结构

• 产品角色(Product): 它是包含多个组成部件的复杂对象，由具体建造者来创建其各个部件
• 抽象建造者(builder): 它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法getResult()
• 具体建造者(Concrete Builder):实现Builder接口，完成复杂产品的各个部件的具体创建方法
• 指挥者(Director):它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息

模式的实现

• 产品角色：包含多个组成部分的复杂对象

class Product 
{
    private String partA;
    private string partB;
    private String partC;
    public void setPartA(String partA)
    {
        this.PartA = partA;
    }
    public void setPartB(String partB)
    {
        this.partB = partB;
    }
    public void setPartc(String partC)
    {
        this.PartC = partC;
    }
    public void show()
    {
        //显示产品的特征
    }
}

• 抽象创建者：包含创建产品各个子部件的抽象方法

abstract class Builder
{
    //创建产品对象
    protected Product product = new Product();
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    // 返回产品对象
    public Product getResult()
    {
        return product;
    }
}

• 具体创建者：实现了抽象创建者接口

public class ConcreteBuilder extends Builder
{
    public void buildPartA()
    {
        product.setPartA("建造 PartA");   
    }
    public void buildPartB()
    {
        product.setPartB("建造 PartB");
    }
    public void buildPartC()
    {
        product.setPartC("建造 PartC");
    }
}

• 指挥者

class Director
{
    private Builder builder;
    public Director(Builder builder)
    {
        this.builder = builder;
    }
    //产品构建与组装方法
    public Product construct()
    {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

• 客户端

public class Client
{
    public static void main(String[] args)
    {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        Product product = director.construct();
        product.show();
    }
}

三、Golang实现建造者模式

package builder

type Builder interface {
    Part1()
    Part2()
    Part3()
} 

type Director struct {
    builder Builder
}

func NewDirector(builder Builder) *Director {
    return &Director{
        builder: builder,
    }
}

func (d *Director) Construct() {
    d.builder.Part1();
    d.builder.Part2();
    d.builder.Part3();
}

type Builder struct {
    result string
}

func (b *Builder) Part1() {
    b.result += "1"
}

func (b *Bulder) Part2() {
    b.result += "2"
}

func (b *Builder) Part3() {
    b.result += "3"
}

func (b *Builder) GetResult() string {
    return b.result
}