4. 建造者模式也没那么难 - 图1

1. 引言

说明：如果想要直接阅读定义等理论内容，可以直接跳转到第二大点

在生活中有很多场景与我们今天要说的 “建造者模式” 是非常匹配的，打个比方一台计算机是由 CPU、内存、显卡、内存、鼠标、键盘、显示器等等内容组合而成的，我们想要一台电脑，我们不会可能自己去做这些配件，一般都是通过告诉销售公司，然后其派生产技术人员给你做好指定的配件。

先不管，谁买，谁做，谁管理的问题，我们可以分析得到，建造电脑的这个 “过程” 是稳定的也就是说，不管什么配置的电脑，这些配件都是必须要有的，只是具体的细节不一样，例如你的配置更好，他的差一些

但是，我作为一个买家，我并不想管这些，我只告诉你，我要一台中等配置的电脑，你负责“建造”好给我就行了，这就是建造者模式比较通俗的讲法

下面我们通过这个计算机的例子，循序渐进的看一下：

2. 通过例子循序渐进认识建造者模式

首先，不管怎么建，怎么买，一个 Computer 电脑类是必须的，我们随便挑选三个组件来进行演示，CPU、内存、显示器，补充其 get set toString 方法

/**
 * 产品：电脑
 */
public class Computer {
    private String cpu; // CPU
    private String graphicsCard; // 内存
    private String displayScreen; // 显示器
    public String getCpu() {
        return cpu;
    }
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }
    public String getGraphicsCard() {
        return graphicsCard;
    }
    public void setGraphicsCard(String graphicsCard) {
        this.graphicsCard = graphicsCard;
    }
    public String getDisplayScreen() {
        return displayScreen;
    }
    public void setDisplayScreen(String displayScreen) {
        this.displayScreen = displayScreen;
    }
    @Override
    public String toString() {
        return "Computer{" +
                "cpu='" + cpu + '\'' +
                ", graphicsCard='" + graphicsCard + '\'' +
                ", displayScreen='" + displayScreen + '\'' +
                '}';
    }
}

2.1 最简单直白的方式（不好）

这种方法基本可以说没什么技术含量了，直接 new + set 就行了

public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.setCpu("英特尔酷睿 i5 处理器");
        computer.setGraphicsCard("4g内存");
        computer.setDisplayScreen("14寸 1080p 60hz显示器");
        System.out.println(computer.toString());
    }
}

打印一下结果：
Computer{cpu=’英特尔酷睿 i5 处理器’, graphicsCard=’4g’, displayScreen=’14寸 1080p 60hz显示器’}

2.2 客户直接联系生产技术人员

上面这种方式，不用说也知道不合适了，所以技术人员（建造者）他来了！但是不同的技术人员会制作的配件也不一样，例如有的会做 144hz 的显示器，而有的专攻 60hz 的显示器，有高低配置，不同型号之分

为此我们为其抽象出一个 ComputerBuilder 的抽象类

/**
 * 电脑的建造者
 */
public abstract class ComputerBuilder {
    abstract void buildCpu(); // 建造CPU
    abstract void buildGraphicsCard(); // 建造内存
    abstract void buildDisplayScreen(); // 建造显示器
    abstract Computer getComputer(); // 拿到这台电脑
}

下面就来写建造者的具体实现，例如先写一个低配置电脑建造的实现

/**
 * 低配置电脑
 */
public class LowConfigurationComputerBuilder extends ComputerBuilder {
    private Computer computer;
    public LowConfigurationComputerBuilder(){
        computer = new Computer();
    }
    @Override
    void buildCpu() {
        computer.setCpu("英特尔酷睿 i5 处理器");
        System.out.println("buildCpu: 英特尔酷睿 i5 处理器");
    }
    @Override
    void buildGraphicsCard() {
        computer.setGraphicsCard("8g内存");
        System.out.println("buildGraphicsCard: 8g内存");
    }
    @Override
    void buildDisplayScreen() {
        computer.setDisplayScreen("1080p 60hz显示器");
        System.out.println("buildDisplayScreen: 1080p 60hz显示器");
    }
    @Override
    Computer getComputer() {
        return computer;
    }
}

测试一下：

public class Test {
    public static void main(String[] args) {
        // 创建低配置电脑建造者
        LowConfigurationComputerBuilder builder = new LowConfigurationComputerBuilder();
        builder.buildCpu();
        builder.buildGraphicsCard();
        builder.buildDisplayScreen();
        Computer computer = builder.getComputer();
        System.out.println("建造出的电脑: " + computer );
    }
}

执行结果：
buildCpu: 英特尔酷睿 i5 处理器
buildGraphicsCard: 8g内存
buildDisplayScreen: 1080p 60hz显示器
建造出的电脑: Computer{cpu=’英特尔酷睿 i5 处理器’, graphicsCard=’8g内存’, displayScreen=’1080p 60hz显示器’}

2.3 客户联系销售公司

虽然上面的方法是比第一种强一些，但是客户自己去联系生产技术人员，显然不是很合理，正常的做法，我们都是先去联系销售公司，告诉他们我想要什么配置的电脑就可以了，细节我并不想管

public class SalesCompany {
    public Computer buildComputer(ComputerBuilder builder){
        builder.buildCpu();
        builder.buildGraphicsCard();
        builder.buildDisplayScreen();
        return builder.getComputer();
    }
}

测试代码

public class Test {
    public static void main(String[] args) {
        // 创建低配置电脑建造者
        LowConfigurationComputerBuilder builder = new LowConfigurationComputerBuilder();
        // 创建电脑销售中心
        SalesCompany salesCompany = new SalesCompany();
        // 指定具体的电脑建造者去完成 电脑 这个产品
        Computer computer = salesCompany.buildComputer(builder);
        System.out.println("建造出的电脑: " + computer );
    }
}

现在代码已经比较完善了，也就是我们买家通过联系电脑销售中心，然后销售中心去调用用户想要的配置的建造者，刚才我们创建的是一个“低配置电脑建造者”，如果我们想要换成中等配置的电脑，该怎么做呢？

现在只需要增加一个中等配置电脑建造者，实现Builder抽象类就可以了

/**
 * 低配置电脑
 */
public class MiddleConfigurationComputerBuilder extends ComputerBuilder {
    private Computer computer;
    public MiddleConfigurationComputerBuilder(){
        computer = new Computer();
    }
    @Override
    void buildCpu() {
        computer.setCpu("英特尔酷睿 i7 处理器");
        System.out.println("buildCpu: 英特尔酷睿 i7 处理器");
    }
    @Override
    void buildGraphicsCard() {
        computer.setGraphicsCard("16g内存");
        System.out.println("buildGraphicsCard: 16g内存");
    }
    @Override
    void buildDisplayScreen() {
        computer.setDisplayScreen("2k 144hz显示器");
        System.out.println("buildDisplayScreen: 2k 60hz显示器");
    }
    @Override
    Computer getComputer() {
        return computer;
    }
}

测试一下

public class Test {
    public static void main(String[] args) {
        MiddleConfigurationComputerBuilder builder = new MiddleConfigurationComputerBuilder();
        // 创建电脑销售中心
        SalesCompany salesCompany = new SalesCompany();
        // 指定具体的电脑建造者去完成 电脑 这个产品
        Computer computer = salesCompany.buildComputer(builder);
        System.out.println("建造出的电脑: " + computer );
    }
}

运行结果
buildCpu: 英特尔酷睿 i7 处理器
buildGraphicsCard: 16g内存
buildDisplayScreen: 2k 60hz显示器
建造出的电脑: Computer{cpu=’英特尔酷睿 i7 处理器’, graphicsCard=’16g内存’, displayScreen=’2k 144hz显示器’}

其实到这里一个建造者模式的实例就写完了，下面我们结合概念，来深入理解一下建造者模式

3. 建造者模式

3.1 概念

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

也就是说，产品的生成过程或者说组成，是不变的，而每一部分都是可以自行选择的，即其内部表象是可以变化的，这也就是所说的变与不变相分离
此种情况下，用户只需要指定建造的类型就可以得到他们，而具体的过程和细节就不需要知道了
3.2 优缺点
首先，此模式封装性好，构建和表示进行了分离，每一个建造者都是相互独立的，利于解耦和扩展，符合 “开闭原则” 同时客户调用时，不需要知道产品细节

但是也正是因为产品生成过程这个不变的部分，限制了它的使用范围，同时如果产品内部日后发生什么改变，则建造者也得同样修改，维护成本不小

3.3 结构

4. 建造者模式也没那么难 - 图2
根据上面的结构图，我们分别说明一下其中的四个角色（除 Client 调用者以外）

Product（产品角色）：多个组件构成的复杂对象，即上述例子中的电脑
Builder（抽象建造者）：一个包含创建产品各个子部件的抽象方法的接口/抽象类，一般还包含一个返回结果的方法，如上述中的 ComputerBuilder 类
ConcreteBuilder（具体建造者）：Builder 的具体实现类，如上述中具体的低配置电脑建造者和中等配置电脑建造者
Director（指挥者）：调用建造者对象中的部件构造与装配方法，以创建一个复杂对象
- 指挥者中不含具体产品信息
- 其隔离了客户与对象的生产过程
  3.4 适用场景
顺序会对同一方法的结果产生影响，例如建房子，应当先打地基，再架钢筋水泥
同一个对象可以装配不同的部件或者零件，同时结果不同
产品类有复杂的内部结构，且这些产品对象具有共性

4. 建造者模式也没那么难