生成器(Builder)模式 - 建造者(Builder)模式 - 《前端杂记》

一、什么是建造者模式
- 1.1 生活中的建造者模式
- 1.2 程序中的建造者模式
二、建造者模式的举例
四、建造者模式的优缺点
- 优点
- 缺点
五、建造者模式的使用场景
六、建造者模式 VS 简单工厂模式

原文链接:

作者: TigerChain, 本文出自 TigerChain 简书人人都会设计模式

教程简介

阅读对象本篇教程适合新手阅读，老手直接略过
教程难度初级，本人水平有限，文章内容难免会出现问题，如果有问题欢迎指出，谢谢
Demo 地址：github.com/githubchen0…

一、什么是建造者模式

1.1 生活中的建造者模式

盖房子

我们在生活中盖房子，一般就是打地基，盖框架「用砖头或钢筋混凝土」，然后是粉刷。基本上就是这个路子。当然我们这些工作全部可以自己做，可也以找几个工人去干，当然还可以可以直接找一个设计师，直接说我就要这样的房子，然后就不管了，最后向设计师「设计师给一张纸给工人，工人就啪啪的干了」验收房子即可「至于你是如何建的过程我不关心，我只要结果」—-这就是建造者模式

组装电脑

我们买的电脑都是由主板、内存、cpu、显卡等组成，如何把这些东西组装起来给用户这就是建造者模式的作用，不同的人对电脑的配置需求不一样的「打游戏的对显卡要求高」，但是电脑构成部件是固定的，我们找电脑城的装机人员把电脑装起来这一过程就是建造者模式

软件开发

我们开发一款产品，需要技术主管、产品经理、苦逼的程序员。在这里，产品经理就是指挥者「Director」和客户沟通，了解产品需求，技术主管是抽象的建造者[Builder]，让猿们杂做就杂做，而程序员就是体力劳动者「即具体的建造者，按照技术主管下发的任务去做」—- 这就是一个接近完美的建造者模式「为什么说接近呢？因为没有百分之百，靠：又忘记吃药了」

1.2 程序中的建造者模式

建造者模式的定义
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示，这是官方定义。通俗的说就是：建造者模式就是如何一步步构建一个包含多个组成部件的对象，相同的构建过程可以创建不同的产品。

建造者模式的特点
建造者模式是一种创建型模式，适用于那些流程固定「顺序不一定固定」，建造的目标对象会有所改变这种场景。「比如画一条狗，这个目标不变，但是不同的是有黄狗，胖狗，瘦狗等」，还有一种场景是代替多参数构造器。

建造者模式的作用

用户不知道对象的建造过程和细节就可以创建出复杂的对象「屏蔽了建造的具体细节」
用户只需给出复杂对象的内容和类型可以创建出对象
建造者模工按流程一步步的创建出复杂对象

建造者模式的结构

角色	类别	说明
Builder	接口或抽象类	抽象的建造者，不是必须的
ConcreateBuilder	具体的建造者	可以有多个「因为每个建造风格可能不一样」
Product	普通的类	具体的产品「即被建造的对象」
Director	导演也叫指挥者	统一指挥建造者去建造目标，导演不是必须的

建造者模式简单的 UML
建造者(Builder)模式 - 图1

二、建造者模式的举例

2.1 组装电脑

小明想组装一个台式电脑，小明对电脑配置一窍不通，就直接跑到电脑城给装机老板说我要一台打游戏非常爽的电脑，麻烦你给装一下「配置什么的你给我推荐一下吧」，于是老板就让它的员工「小美」按小明的要求装了一个性能灰常牛 B 的电脑，1 个小时后电脑装好了，小明交钱拿电脑走人。不一会儿小张又来了，要一个满足平时写文章就可以的电脑，老板针对小张的要求给不同的装机配置。不同的人有不同的配置方案「但是装机流程是一样的」，这就是一个典型的建造者模式。

组装电脑简单的 UML
建造者(Builder)模式 - 图2

根据 UML 撸码

创建被建造的对象电脑 —- Computer.java

/**
* Created by TigerChain
* 产品类--被建造的对象
*/
public class Computer {
 private String cpu ; // cpu
 private String hardDisk ; //硬盘
 private String mainBoard ; // 主板
 private String memory ; // 内存
 ... 省略 getter 和 setter
}

抽象的建造者 —- Builder.java(注：只做 interface 定义)

/**
* Created by TigerChain
* 抽象的建造者，即装电脑的步骤
* 至于安装什么型号的主板，不是我关心，而是具体的建造者关心的
*/
public interface Builder {
 // 安装主板
 void createMainBoard(String mainBoard) ;
 // 安装 cpu
 void createCpu(String cpu) ;
 // 安装硬盘
 void createhardDisk(String hardDisk) ;
 // 安装内存
 void createMemory(String memory) ;
 // 组成电脑!!!!
 Computer createComputer() ;
}

具体的建造者，也就是装机工人小美 —- AssemblerBuilder.java

/**
* Created by TigerChain
* 具体的建造者，这里是商场的一个装机人员
*/
public class AssemblerBuilder implements Builder {
 private Computer computer = new Computer() ;
 @Override
 public void createCpu(String cpu) {
     computer.setCpu(cpu);
 }
 @Override
 public void createhardDisk(String hardDisk) {
     computer.setHardDisk(hardDisk);
 }
 @Override
 public void createMainBoard(String mainBoard) {
     computer.setMainBoard(mainBoard);
 }
 @Override
 public void createMemory(String memory) {
     computer.setMemory(memory);
 }
 @Override
 public Computer createComputer() {
     return computer;
 }
}

还有老板「”指手画脚的人”」安排装机工工作 —- Direcror.java

/**
* Created by TigerChain
* 声明一个导演类「指挥者，这里可以装电脑的老板」，用来指挥组装过程，也就是组装电脑的流程
*/
public class Director {
 private Builder builder ;
 // 使用多态，装机工非常多，我管你小美，小兰，小猪，我统统收了
 public Direcror(Builder builder){
     this.builder = builder ;
 }
 // 老板最后只想看到装成的成品---要交到客户手中
 public Computer createComputer(String cpu,String hardDisk,String mainBoard,String memory){
     // 具体的工作是装机工去做
     this.builder.createMainBoard(mainBoard);
     this.builder.createCpu(cpu) ;
     this.builder.createMemory(memory);
     this.builder.createhardDisk(hardDisk);
     return this.builder.createComputer();
 }
}

测试类

/**
* Created by TigerChain
* 测试类
*/
public class Test {
public static void main(String args[]){
   // 装机员小美
   Builder builder = new AssemblerBuilder() ;
   // 老板把小明的需求转给小美
   Direcror direcror = new Direcror(builder) ;
   // 老板最后拿到成品机子，工作全由小美去做
   Computer computer = direcror.createComputer("Intel 酷睿i9 7900X","三星M9T 2TB （HN-M201RAD）","技嘉AORUS Z270X-Gaming 7","科赋Cras II 红灯 16GB DDR4 3000") ;
   System.out.println("小明这台电脑使用的是：\n"+computer.getMainBoard()+" 主板\n"+computer.getCpu()+" CPU\n"+computer.getHardDisk()+"硬盘\n"+computer.getMainBoard()+" 内存\n");
}
}

运行查看结果

建造者(Builder)模式 - 图3
怎么样，至于小张，小猪要装机把自己要的配置给老板即可，然后老板如何装机不用你管，你就等着收装好的机子吧

2.2 盖房子

盖房子的基本步骤和流程是固定的无非就是打地基、盖框架、然后浇筑「至于盖平房、还是楼房那是每个客户的具体需求」。总体来说盖房子以有以三种方式：

自己盖房子「没有办法有的人就是牛 B，自己设计，自己动手，当然这属于小房子，你让一个人盖个32 层让我看看」
想盖房子的人是一个包工头，自己找一帮工人自己就把房子搞定了
想盖房子的人就是一个普通人，啥也不会，找一个设计师说“我就要盖个房子，南北通透，四秀常春”，设计师说没有问题，设计师把设计出来的图纸扔给包工头说：“就照这个样子盖”，包工头拿着图纸给工人们分工派活，最后完工

盖房子建造者模式简单的 UML
建造者(Builder)模式 - 图4

根据 UML 撸码

房子对象 —- House.java

/**
* Created by TigerChain
* 最终的产品---房子
*/
public class House {
 // 打地基
 private String foundation ;
 // 盖框架
 private String frame ;
 // 浇筑
 private String pouring ;
 ... 省略 setter 和 getter 
}

抽象建造者「包工头」—- HouseBuilder.java

public interface HouseBuilder {
 // 打地基
 void doFoundation() ;
 // 盖框架
 void doFrame() ;
 // 浇灌
 void dpPouring() ;
 // 房子建成 
 House getHouse() ;
}

具体建造者「工人」— 盖平房 PingFangBuilder.java

/**
* Created by TigerChain
* 盖平房
*/
public class PingFangBuilder implements HouseBuilder {
 private House house = new House() ;
 @Override
 public void doFoundation() {
     house.setFoundation("盖平房的地基");
 }
 @Override
 public void doFrame() {
     house.setFrame("盖平房的框架");
 }
 @Override
 public void dpPouring() {
     house.setPouring("盖平房不用浇灌，直接人工手刷就可以");
 }
 @Override
 public House getHouse() {
     return house;
 }
}

具体建造者「工人」— 盖楼房 LouFangBuilder.java

/**
* Created by TigerChain
* 盖楼房
*/
public class LouFangBuilder implements HouseBuilder {
 private House house = new House() ;
 @Override
 public void doFoundation() {
     house.setFoundation("盖楼房的地基就打十米深");
 }
 @Override
 public void doFrame() {
     house.setFrame("楼房的框架要使用非常坚固钢筋混凝土");
 }
 @Override
 public void dpPouring() {
     house.setPouring("楼房拿个罐车把框架拿混凝土灌满即可");
 }
 @Override
 public House getHouse() {
     return house;
 }
}

指挥者「设计师」 HouseDirector.java

/**
* Created by TigerChain
* 设计师
*/
public class HouseDirector {
 // 指挥包工头
 public void buildHouse(HouseBuilder houseBuilder){
     houseBuilder.doFoundation();
     houseBuilder.doFrame();
     houseBuilder.dpPouring();
 }
}

测试一下 Test.java ```java /**
- Created by TigerChain
- 测试 */ public class Test { public static void main(String args[]){
  
  // 方式一、客户自己盖房子，亲力亲为 System.out.println(“========客户自己建房子，必须知道盖房的细节========”); House house = new House() ; house.setFoundation(“用户自己建造房子：打地基”); house.setFrame(“用户自己建造房子：盖框架”); house.setPouring(“用户自己建造房子：浇筑”);
  
  System.out.println(house.getFoundation()); System.out.println(house.getFrame()); System.out.println(house.getPouring());

    // 方式二、客户找一个建造者盖房子「充当包工头角色」，但是要知道如何盖房子「调用建造者盖房子的顺序」
    System.out.println("========客户直接找盖房子的工人「建造者」，客户要调用建造者方法去盖房子，客户必须得知道房子如何造========");
    HouseBuilder houseBuilder = new PingFangBuilder() ;
    houseBuilder.doFoundation();
    houseBuilder.doFrame();
    houseBuilder.dpPouring();
    House house1 = houseBuilder.getHouse() ;
    System.out.println(house1.getFoundation());
    System.out.println(house1.getFrame());
    System.out.println(house1.getPouring());
    // 方式三、使用建造者模式，找一个设计师「设计师拉一帮建造者去干活」，告诉他我想要什么样的房子，最后客户只问设计师要房子即可
    System.out.println("========客户直接找一个设计师，设计师统一指挥建造者盖房子，房子杂盖，客户不关心，最后只是找设计师要房子即可========");
    HouseBuilder pingFangBuilder = new PingFangBuilder() ;
    HouseDirector houseDirector = new HouseDirector() ;
    houseDirector.buildHouse(pingFangBuilder);
    House houseCreateByBuilder = pingFangBuilder.getHouse() ;
    System.out.println(houseCreateByBuilder.getFoundation());
    System.out.println(houseCreateByBuilder.getFrame());
    System.out.println(houseCreateByBuilder.getPouring());
}

}

我们对比了三种方式，自己盖房子，找工人盖房子，找设计师盖房子来逐步感受一下建造者模式的优点
7. 运行查看结果
![](https://cdn.nlark.com/yuque/0/2021/webp/216305/1632707116404-643fc5f4-1b36-4f42-b085-d5edb8e20905.webp#clientId=u9a614a09-087f-4&from=paste&id=u0c531dfe&margin=%5Bobject%20Object%5D&originHeight=241&originWidth=732&originalType=url&ratio=1&status=done&style=none&taskId=u6a1b3913-ae4c-4fa3-ae11-ea70248ae21)<br />可以看到最后一种最舒服，盖房子的时候直接外包给设计师自己就不用管了，到时候问设计师要建好的成品房子即可，这样对客户来说具体如何盖房子我不需要知道，屏蔽细节「只能说有钱就是任性」
<a name="rxBA3"></a>
### 2.3 替代多参数构造函数的建造者模式
> 以组装电脑为例
前面我们说了在建造者模式中** Director 不是必须的**，Director 的作用不是构造产品「建造产品是建造者的事情」而是指挥协调建造的步骤「当有一个新的建造者的时候直接实现抽象建造者，而不用关心具体的执行步骤，这就是 Director 干的事情」，我们直接看代码吧
1. 原始的 Computer.java
```java
public class Computer {
    private String mainBoard ;     // 主板
    private String cpu ;           // cpu
    private String hd ;            // 硬盘
    private String powerSupplier ; // 电源
    private String graphicsCard;   // 显卡
    // 其它一些可选配置
    private String mouse ; // 鼠标
    private String computerCase ; //机箱
    private String mousePad ;   //鼠标垫
    private String other ;  //其它配件
      // 不同参数不同构造函数
    public Computer(String mainBoard,String cpu,String hd,String powerSupplier,
                      String graphicsCard,String mouse,String computerCase,String mousePad,String other){
        this.mainBoard = mainBoard ;
        this.cpu = cpu ;
        this.hd = hd ;
        this.powerSupplier = powerSupplier ;
        this.graphicsCard = graphicsCard ;
        this.mouse = mouse ;
        this.computerCase = computerCase ;
        this.mousePad = mousePad ;
        this.other = other ;
    }
    public Computer(String mainBoard,String cpu,String hd,String powerSupplier,
                    String graphicsCard,String mouse,String computerCase,String mousePad){
        this.mainBoard = mainBoard ;
        this.cpu = cpu ;
        this.hd = hd ;
        this.powerSupplier = powerSupplier ;
        this.graphicsCard = graphicsCard ;
        this.mouse = mouse ;
        this.computerCase = computerCase ;
        this.mousePad = mousePad ;
    }
    ... 省略其它的构造方法和 setter 和 getter 方法
}

如果我们想要调用这个类就得在构参数方法中传递“无数个参数”「如果有的参是一些可选项，我们还得重写构造方法」，要么就要调用多个 setter 方法，才能给一个对象赋值，方法虽然可行，但是也太扯淡了「谁能记住那些参数呀」，那么建造者模式可以解决多参数构造方法来建造对象。

使用建造者建立 ComputerB.java

/**
* Created by TigerChain
* 替代多参构造方法--建造者模式
*/
public class ComputerB {
 private String mainBoard ;     // 主板
 private String cpu ;           // cpu
 private String hd ;            // 硬盘
 private String powerSupplier ; // 电源
 private String graphicsCard;   // 显卡
 // 其它一些可选配置
 private String mouse ; // 鼠标
 private String computerCase ; //机箱
 private String mousePad ;   //鼠标垫
 private String other ;  //其它配件
 // ComputerB 自己充当 Director！！！
 private ComputerB(ComputerBuilder builder) {
     this.mainBoard = builder.mainBoard ;
     this.cpu = builder.cpu ;
     this.hd = builder.hd ;
     this.powerSupplier = builder.powerSupplier ;
     this.graphicsCard = builder.graphicsCard ;
     this.mouse = builder.mouse ;
     this.computerCase = builder.computerCase ;
     this.mousePad = builder.mousePad ;
     this.other = builder.other ;
 }
 // 声明一个静态内存类 Builder
 public static class ComputerBuilder{
     // 一个电脑的必须配置
     private String mainBoard ;     // 主板
     private String cpu ;           // cpu
     private String hd ;            // 硬盘
     private String powerSupplier ; // 电源
     private String graphicsCard;   // 显卡
     // 其它一些可选配置
     private String mouse ; // 鼠标
     private String computerCase ; //机箱
     private String mousePad ;   //鼠标垫
     private String other ;  //其它配件
     // 这里声明一些必须要传的参数「规定这些参数是必须传的，这里只是举例，现实中可能参数都是可选的」
     public ComputerBuilder(String mainBoard,String cpu,String hd,String powerSupplier,String graphicsCard){
         this.mainBoard = mainBoard ;
         this.cpu = cpu ;
         this.hd = hd ;
         this.powerSupplier = powerSupplier ;
         this.graphicsCard = graphicsCard ;
     }
     public ComputerBuilder setMainBoard(String mainBoard) {
         this.mainBoard = mainBoard;
         return this ;
     }
     public ComputerBuilder setCpu(String cpu) {
         this.cpu = cpu;
         return this ;
     }
        ... 其它的一些 setXXX() 方法
     // 生成最终的产品
     public ComputerB build(){
         return new ComputerB(this) ;
     }
 }
}

代码注释非常详细，乍一看好像和建造者模式没有毛关系，但是我们细细一分析这个确实是一个建造者模式，我们看一看：产品是—>ComputerB，具体的建造者是一个静态内存类—>ComputerBuilder，但是没有抽象的建造者和指挥者「其实 ComputerB 充当的就是指挥者的角色」，我们说过建造者模式中指挥者和抽象建造者都不是必须的，所以这是一个典型的建造者模式

如何调用来个测试类 Test.java ```java public class Test { public static void main(String args[]){

 // 不使用建造者模式
 Computer computer = new Computer("主板","cpu","hd","电源","显卡"
 ,"鼠标","机箱","鼠标垫") ;
 System.out.println("使用普通的构造方法组装电脑："+computer.toString());
 // 使用建造者模式
 ComputerB computerB = new ComputerB.ComputerBuilder("主板","cpu","hd","电源","显卡")
         .setMouse("鼠标").setMousePad("垫子").build() ;
 System.out.println("使用建造者模式组装电脑："+computerB.toString());

} }


我们分别使用普通构造方法「调用者能吐血」和建造者模式组装电脑，可以看到建造者模式调用 new ComputerB.ComputerBuilder(xxx).setxxx().setxxx().build() 调用方法直接打点调用「也叫**流式调用**，这样调用方便多了，想点那个就点那个」，如果使用过 rx 的话会非常有感觉。
4. 运行查看一下结果
![](https://cdn.nlark.com/yuque/0/2021/webp/216305/1632707116865-bc3b58c9-c442-441e-bdd9-f3e00c9e1736.webp#clientId=u9a614a09-087f-4&from=paste&id=ud6ec4d4e&margin=%5Bobject%20Object%5D&originHeight=239&originWidth=457&originalType=url&ratio=1&status=done&style=none&taskId=u31b023b4-adcc-4925-892d-29e0b0d4415)<br />如果在以后如果遇到多参数构造对象的时候不仿考虑使用建造者模式
<a name="NdsoN"></a>
## 三、Android 源码中的建造者模式
<a name="QaqBQ"></a>
### 3.1 AlertDialog
做 Android 的朋友一定不会对 AlertDialog 陌生，它是一个可以添加列表、单选列表、文本输入框，多选列表等弹窗组件，内部使用的是典型的建造者模式，我们看看 AlertDialog 的基本使用方法。
```java
// 创建构建器
AlertDialog.Builder builder = new AlertDialog.Builder(this);
// 使用建造者模式代替多参构造函数
Dialog dialog= builder.setTitle(XXX).setIcon(XXX).setXXX(xxx).create() ;
dialog.show() ;

AlertDialog 简单的 UML
建造者(Builder)模式 - 图5

AlertDialog 核心代码剥离
建造者(Builder)模式 - 图6
上图明显的显示出了 AlertDialog 的建造者模式「AlertDialog.Builder 同时扮演了 Builder、ConcreateBuilder、Director 等角色」

3.2 Notification 的 setLatestEventInfo 方法「过时了，但是思想可以学习」

我们看看 Notification 的 setLatestEventInfo 一看便知道使用的是建造者模式，我们看下图
建造者(Builder)模式 - 图7
以上的方法被 Notification.Builder 替代了「setLatestEventInfo 从终也是调用 Notification.Builder」，真正的建造者模式是 Notification.Builder。

如果要支持到低版本可以使用 android.support.v4.app.NotificationCompat.Builder 来创建 Notification 名字一看又是一个建造者模式，感兴趣的可以看看 NotificationCompat.Builder 的源码

3.3 AnimatorSet.Builder

AnimatorSet 用作将一个动画集合按选定的顺序执行，我们可以使用 AnimatorSet.Builder 添加播放动画顺序「这只是其中一个方法」

使用方法举例

AnimatorSet animSet = new AnimatorSet();  
//AnimatorSet.Builder 不能直接建立 ，只能通过 play(Animation)
AnimatorSet.Builder builder = animSet.play(anim2);  
builder.with(anim3).after(anim1).before(anim4);// anim1先执行，然后再同步执行anim2、anim3，最后执行anim4  
animSet.setDuration(200);  
animSet.start();

核心代码
建造者(Builder)模式 - 图8

四、建造者模式的优缺点

优点

使创建产品的步骤「把创建产品步骤放在不同的方法中，更加清晰直观」和产品本身分离，即使用相同的创建过程可以创建出不同的产品
每个建造者都是独立的互不影响，这样就达到解耦的目的，所以如果想要替换现有的建造者那非常方便，添加一个实现即可。

缺点

只适用于产品具有相同的特点「过程和步骤」，如果产品之间差异非常大，则不适用「使用范围受限」
万一那天产品内部发生改变，那多个建造者都要修改，成本太大

五、建造者模式的使用场景

如果一个对象有非常复杂的内部结构「这些产品通常有很多属性」，那么使用建造者模式
如果想把复杂对象的创建和使用分离开来，那么使用建造者模式「使用相同的创建步骤可以创建不同的产品」

六、建造者模式 VS 简单工厂模式
相似点
它们都属于创建型模式「都是创建产品的」

区别

创建对象的粒度不同

工厂模式创建的对象都是一个鸟样子，而建造者模式创建的是一个复合产品，由各个复杂的部件组成，部件不同所构成的产品也不同

关注点不同

工厂模式注重只要把这个对象创建出来就 o 了「不关心这个产品的组成部分」，而建造者模式不似要创造出这个产品，还有知道这个产品的组成部分。

到此为止，我们就介绍完了建造者模式，一定要动手试一下，关注博主有更多精彩的文章等着你，顺便伸出你的小手点一个赞吧

建造者(Builder)模式