1.介绍

1.1定义

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

1.2主要作用

在用户不知道对象的建造过程和细节的情况下就可以直接创建复杂的对象。

1. 用户只需要给出指定复杂对象的类型和内容；
2. 建造者模式隐藏了复杂对象的创建过程（把内部的建造过程和细节隐藏起来)，按顺序创建复杂对象

1.3解决的问题

• 方便用户创建复杂的对象（不需要知道实现过程）
• 代码复用性 & 封装性（将对象构建过程和细节进行封装 & 复用）

例子：造汽车 & 买汽车。

1. 工厂（建造者模式）：负责制造汽车（组装过程和细节在工厂内）
2. 汽车购买者（用户）：你只需要说出你需要的型号（对象的类型和内容），然后直接购买就可以使用了
   （不需要知道汽车是怎么组装的（车轮、车门、发动机、方向盘等等））

2.模式原理

2.1 UML类图 & 讲解

uml.png

讲解：

1. 指挥者（Director）直接和客户（Client）进行需求沟通；
2. 沟通后指挥者将客户创建产品的需求划分为各个部件的建造请求（Builder）；
3. 将各个部件的建造请求委派到具体的建造者（ConcreteBuilder）；
4. 各个具体建造者负责进行产品部件的构建；
5. 最终构建成具体产品（Product）。

2.2 实例讲解

接下来用一个实例来对建造者模式进行更深一步的介绍。

a. 实例概况

• 背景：小成希望去电脑城买一台组装的台式主机
• 过程：

1. 电脑城老板（Diretor）和小成（Client）进行需求沟通（买来打游戏？学习？看剧？）
2. 了解需求后，电脑城老板将小成需要的主机划分为各个部件（Builder）的建造请求（CPU、主板blabla）
3. 指挥装机人员（ConcreteBuilder）去构建组件；
4. 将组件组装成小成需要的电脑（Product）

b. 使用步骤

步骤1：定义具体产品类（Product）：电脑

public class Computer {
    //电脑组件的集合
    private List<String> parts = new ArrayList<String>();

    //用于将组件组装到电脑里
    public void Add(String part){
        parts.add(part);
    }

    public void show(){
        for (int i = 0;i<parts.size();i++){
            System.out.println("组件"+parts.get(i)+"装好了");
        }
        System.out.println("电脑组装完成，请验收");
    }
}

步骤2：定义组装的过程（Builder）：组装电脑的过程

public abstract class Builder {
    //第一步：装CPU
    //声明为抽象方法，具体由子类实现
    public abstract void  BuildCPU();

    //第二步：装主板
    //声明为抽象方法，具体由子类实现
    public abstract void BuildMainboard();

    //第三步：装硬盘
    //声明为抽象方法，具体由子类实现
    public abstract void BuildHD();

    //返回产品的方法：获得组装好的电脑
    public abstract Computer getComputer();
}

步骤3：创建具体的建造者（ConcreteBuilder）:装机人员1

//装机人员1
public class ConcreteBuilder1 extends Builder{
    //创建产品实例
    Computer computer = new Computer();

    //组装产品
    @Override
    public void  BuildCPU(){
        computer.Add("1型号CPU");
    }
    @Override
    public void  BuildMainboard(){
        computer.Add("1型号主板");
    }
    @Override
    public void  BuildHD(){
        computer.Add("1型号硬盘");
    }

    //返回组装成功的电脑
    @Override
    public  Computer getComputer(){
        return computer;
    }
}

步骤3：创建具体的建造者（ConcreteBuilder）:装机人员2，所用部件与人员1不同

//装机人员2
public class ConcreteBuilder2 extends Builder{
    //创建产品实例
    Computer computer = new Computer();

    //组装产品
    @Override
    public void  BuildCPU(){
        computer.Add("2型号CPU");
    }
    @Override
    public void  BuildMainboard(){
        computer.Add("2型号主板");
    }
    @Override
    public void  BuildHD(){
        computer.Add("2型号硬盘");
    }

    //返回组装成功的电脑
    @Override
    public  Computer getComputer(){
        return computer;
    }
}

步骤4：电脑城老板（Director）委派任务给装机人员进行电脑组装

public class Director {
    private Builder builder = null;

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

    //指挥装机人员组装电脑，按顺序构建出电脑
    public Computer build(){
        builder.BuildCPU();
        builder.BuildMainboard();
        builder.BuildHD();
        return builder.getComputer();
    }
}

步骤5：客户端调用，小成到电脑城找老板买电脑

public class Client {
    public static void main(String[] args){
        //逛了很久终于发现一家合适的电脑店
        //找到该店的老板，沟通需求后，老板叫装机人员1去装电脑(1型号比较适合小成)
        Builder builder = new ConcreteBuilder1();
        Director director = new Director(builder);
        //指挥装机人员1组装电脑
        Computer computer = director.build();
        //电脑组装完成，组装人员展示电脑给小成看
        computer.show();
    }
}

输出结果

组件1型号CPU装好了
组件1型号主板装好了
组件1型号硬盘装好了
电脑组装完成，请验收

3.优缺点

3.1优点

• 易于解耦
  将产品本身与产品创建过程进行解耦，可以使用相同的创建过程来得到不同的产品。也就说细节依赖抽象。
• 易于精确控制对象的创建
  将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰
• 易于拓展
  增加新的具体建造者无需修改原有类库的代码，易于拓展，符合“开闭原则”。

每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地
替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不
同的产品对象。

3.2缺点

• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
• 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

4.应用场景

• 需要生成的产品对象有复杂的内部结构，这些产品对象具备共性；
• 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

注：本篇文章参考了简书作者Carson_Ho的文章，文章链接