设计模式——建造者模式

设计模式——建造者模式

一、基本概念

1. 定义

建造者模式（英：Builder Pattern）是一种设计模式，又名：建造模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。

2. 优缺点

优点：

• 封装性好，构建和表示分离。
• 扩展性好，各个具体的建造者相互独立，有利于系统的解耦。
• 屏蔽细节，客户端不必知道产品内部组成的细节，建造者可以对创建过程逐步细化，而不对其它模块产生任何影响，便于控制细节风险。

缺点：

• 产品的组成部分必须相同，这限制了其使用范围。
• 如果产品的内部变化复杂，如果产品内部发生变化，则建造者也要同步修改，后期维护成本较大。

3. 结构

建造者（Builder）模式的主要角色如下：

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

二、代码实现

产品角色

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

package pers.designPattern.builder;

public 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() {
        System.out.println("Product{" +
                "partA='" + partA + '\'' +
                ", partB='" + partB + '\'' +
                ", partC='" + partC + '\'' +
                '}');
    }
}

抽象建造者

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

package pers.designPattern.builder;

public abstract class Builder {
    protected Product product = new Product();

    // 创建各个子部分
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();

    public Product getProduct() {
        // 返回产品对象
        return product;
    }
}

具体建造者

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

package pers.designPattern.builder;

public class ConcreteBuilder extends Builder {
    @Override
    public void buildPartA() {
        System.out.println("建造 PartA...");
        product.setPartA("PartA");
    }

    @Override
    public void buildPartB() {
        System.out.println("建造 PartB...");
        product.setPartB("PartB");
    }

    @Override
    public void buildPartC() {
        System.out.println("建造 PartC...");
        product.setPartC("PartC");
    }
}

指挥者

指挥者会调用建造者中的方法完成复杂对象的创建：

package pers.designPattern.builder;

public class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public Product construct() {
        System.out.println("开始制造产品...");
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        System.out.println("产品制造完成！");
        return builder.getProduct();
    }
}

客户类

package pers.designPattern.builder;

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

运行结果：

开始制造产品...
建造 PartA...
建造 PartB...
建造 PartC...
产品制造完成！
Product{partA='PartA', partB='PartB', partC='PartC'}

---

参考：

• 菜鸟教程
• C语言网
• Refactoring.Guru