简介

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

类似建房子，只需要把材料和设计图纸给工人，就能建成想要的房子，不关注工人建房子的过程，但对于细节，我们又可以自己设计。

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

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

解决问题

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

uml图

建造者模式 - 图1 模式讲解：

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

代码

定义产品

  1. class Computer {
  2.     //电脑组件的集合
  3.     private List<String> parts = new ArrayList<String>();
  5.     //用于将组件组装到电脑里
  6.     public void add(String part) {
  7.         parts.add(part);
  8.     }
  10.     public void show() {
  11.         for (int i = 0; i < parts.size(); i++) {
  12.             System.out.println("组件: " + parts.get(i) + "装好了");
  13.         }
  14.         System.out.println("电脑组装完成,请验收");
  15.     }
  16. }

定义建造者接口

  1. //定义组装的过程
  2. abstract class Builder {
  3.     //第一步: 装cpu
  4.     public abstract void BuildCPU();
  6.     //第二步: 装主板
  7.     public abstract void BuildMainboard();
  9.     //第三步: 装硬盘
  10.     public abstract void BuildHD();
  12.     //返回产品的方法, 获取组装好的电脑
  13.     public abstract Computer GetComputer();
  14. }

定义具体建造者

  1. //具体建造者: 装机人员
  2. class ConcreteBuilder extends Builder {
  4.     //创建产品实例
  5.     Computer computer = new Computer();
  7.     @Override
  8.     public void BuildCPU() {
  9.         computer.add("组装cpu");
  10.     }
  12.     @Override
  13.     public void BuildMainboard() {
  14.         computer.add("组装主板");
  15.     }
  17.     @Override
  18.     public void BuildHD() {
  19.         computer.add("组装硬盘");
  20.     }
  22.     @Override
  23.     public Computer GetComputer() {
  24.         return computer;
  25.     }
  26. }

定义装机人员

  1. //装机人员
  2. class Director {
  3.     //指挥装机人员组装电脑
  4.     public void Construct(Builder builder) {
  5.         builder.BuildCPU();
  6.         builder.BuildMainboard();
  7.         builder.BuildHD();
  8.     }
  9. }

客户调用

  1. class client {
  2.     public static void main(String[] args) {
  3.         //找到电脑店的老板和装机人员
  4.         Director director = new Director();
  5.         ConcreteBuilder builder = new ConcreteBuilder();
  7.         //沟通需求之后, 老板叫来了装机人员
  8.         director.Construct(builder);
  10.         //装完之后,搬来电脑
  11.         Computer computer = builder.GetComputer();
  12.         //展示
  13.         computer.show();
  14.     }
  15. }

使用lombok

  1. @Data
  2. @Builder   //使用链式建造者
  3. @NoArgsConstructor
  4. @AllArgsConstructor
  5. public class Phone {
  6.    // ……
  7. }

优缺点

优点

易于解耦
将产品本身与产品创建过程进行解耦，可以使用相同的创建过程来得到不同的产品。也就说细节依赖抽象。
易于精确控制对象的创建
将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰
易于拓展
增加新的具体建造者无需修改原有类库的代码，易于拓展，符合“开闭原则“。
每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。

缺点

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

应用场景

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