Fork me on GitHub

设计模式之建造者模式

字数统计: 2.1k字   |   阅读时长≈ 7分

定义

建造者模式将构造一个复杂对象的构建过程隐藏了起来，使得表面相同的构建过程可以构建不同的表示

  • 用户只需指定需要建造的类型就可以得到它们，建造过程及细节不需要知道。
  • 类型：创建型

适用场景

  • 如果一个对象有非常复杂的内部结构（很多属性）
  • 想把复杂对象的创建和使用分离
    建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
    一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

主要作用

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

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

解决的问题

  • 方便用户创建复杂的对象（不需要知道实现过程）

例子：造汽车 & 买汽车。

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

模式原理

UML类图

img

模式讲解

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

实例

背景

小成希望去电脑城买一台组装的台式主机

  1. 电脑城老板（Diretor）和小成（Client）进行需求沟通（买来打游戏？学习？） 通用操作，买电脑嘛，只要是用这个，都是买电脑，就属于通用了。
  2. 了解需求后，电脑城老板将小成需要的主机划分为各个部件（Builder）的建造请求（CPU、主板blabla）
    • 如需要 i7-9900,16G内存，RTX2080 （具体背景的特殊操作）
  3. 指挥装机人员（ConcreteBuilder）去构建组件； 通用操作，因为不管买什么型号器件，都需要这个步骤去构建，只是构建的组件多少不同
  4. 将组件组装起来成小成需要的电脑（Product） 通用操作，不管买什么型号器件，都需要组装起来

实现步骤

步骤主要分为两类，一类是对于通用背景都需要的，第二类是针对于每次的具体背景的特殊操作
步骤1（背景步骤）
定义产品类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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(“电脑组装完成，请验收”); 
    }

}

定义抽象建造者，抽象建造者中定义了通用背景中需要用到的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public  abstract class Builder {  

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

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

//第三步：装硬盘
//声明为抽象方法，具体由子类实现 
    public abstract void BuildHD（）；
    
//第四步：装内存
//声明为抽象方法，具体由子类实现 
    public abstract void BuildMemory（）；

//返回产品的方法：获得组装好的电脑
    public abstract Computer GetComputer（）；
}

步骤2：创建具体的建造者（ConcreteBuilder）:装机人员
根据具体的应用场景创建具体的建造者，具体的建造者需要继承之前的抽象建造者；由于抽象建造者中我们定义的全是抽象方法，所以具体建造者继承之后，需要单独实现其中的抽象方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//装机人员1
  public class ConcreteBuilder extend  Builder{
    //创建产品实例
    Computer computer = new Computer();

    //组装产品
    @Override
    public void  BuildCPU(){  
       computer.Add("组装CPU");
    }  

    @Override
    public void  BuildMainboard（）{  
       computer.Add("组装主板");
    }  

    @Override
    public void  BuildHD（）{  
       computer.Add("组装硬盘");
    }
    @Override
    public void  BuildMemory（）{  
       computer.Add("组装内存");
    }    

    //返回组装成功的电脑
    @Override
    public  Computer GetComputer（）{  
      return computer;
    }  
}

步骤3、电脑城老板委派任务给装机人员（Director）
这里是具体操作，因为针对这一次的购买，需要指定具体的配件型号与数量
这个例子只要了 CPU、主板和硬盘

1
2
3
4
5
6
7
8
public class Director{
    //指挥装机人员组装电脑，实际中，Construct方法这里应该可以接受具体的参数，以便于创建具体的产品
    public void Construct(Builder builder){                         
        builder. BuildCPU();
        builder.BuildMainboard（）;
        builder. BuildHD（）;
        }
 }

步骤4、客户端调用-小成到电脑城找老板买电脑

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Test{
  public static void main(String[] args){

    //逛了很久终于发现一家合适的电脑店
    //找到该店的老板和装机人员
      Director director = new Director();
      Builder builder = new ConcreteBuilder();
    
    //沟通需求后，老板叫装机人员去装电脑，这里其实应该有具体的需求参数，然后才会根据具体需求参数去构造具体产品
    director.Construct(builder);
    
    //装完后，组装人员搬来组装好的电脑
    Computer computer = builder.GetComputer();
    //组装人员展示电脑给小成看
    computer.Show()；

    }
        
}

对于具体的产品构造，需要Director类做出不同的指令，或者直接在程序入口main方法中根据不同指令使用具体建造者。
一般来说，产品的所有变量属性，都已经被抽象建造者和建造者所包含，所以产品的不同变量组合的具体构造，通过建造者的不同方法就可以构造了。
当产品出现了新的变量属性，就需要改变抽象建造者和建造者了

建造者模式的动机

无论是在现实世界中还是在软件系统中，都存在一些复杂的对象，它们拥有多个组成部分，如汽车，它包括车轮、方向盘、发送机等各种部件。而对于大多数用户而言，无须知道这些部件的装配细节，也几乎不会使用单独某个部件，而是使用一辆完整的汽车，可以通过建造者模式对其进行设计与描述，建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。

在软件开发中，也存在大量类似汽车一样的复杂对象，它们拥有一系列成员属性，这些成员属性中有些是引用类型的成员对象。而且在这些复杂对象中，还可能存在一些限制条件，如某些属性没有赋值则复杂对象不能作为一个完整的产品使用；有些属性的赋值必须按照某个顺序，一个属性没有赋值之前，另一个属性可能无法赋值等。

复杂对象相当于一辆有待建造的汽车，而对象的属性相当于汽车的部件，建造产品的过程就相当于组合部件的过程。由于组合部件的过程很复杂，因此，这些部件的组合过程往往被“外部化”到一个称作建造者的对象里，建造者返还给客户端的是一个已经建造完毕的完整产品对象，而用户无须关心该对象所包含的属性以及它们的组装方式，这就是建造者模式的模式动机。

参考

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

xczll：
努力打工中
Golang后台开发、摄影爱好者

很惭愧

只做了一点微小的工作，希望能帮助到你
谢谢大家