设计模式-建造者模式

发表于 | 评论数： | 热度： ℃   |   字数统计: 2.2k字   |   阅读时长: ≈ 8分钟

模式定义

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

建造者模式一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。

主要作用

  1. 降低创建复杂对象的复杂度；
  2. 隔离了创建对象的构建过程 & 表示。

UML类图

建造者模式

角色

  • 抽象建造者（Builder）：主要用于规范产品Product对象的各个组成部分，并提供一个返回完整产品的接口，在该接口中一般声明两类方法，一类方法是buildPartX()，它们用于创建复杂对象的各个部件；另一类方法是getResult()，它们用于返回复杂对象。Builder既可以是抽象类，也可以是接口。

  • 具体建造者（Concrete Builder）：实现 抽象建造者 规定的各个方法，返回一个组建好的具体产品。

  • 产品（Product）：它是被构建的复杂对象，包含多个组成部件，具体建造者创建该产品的内部表示并定义它的装配过程。

  • 导演者（Director）：又称指挥者，它负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联关系，可以在其construct()建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造。客户端一般只需要与指挥者进行交互，在客户端确定具体建造者的类型，并实例化具体建造者对象（也可以通过配置文件和反射机制），然后通过指挥者类的构造函数或者Setter方法将该对象传入指挥者类中。

总结：

建造者模式 最终返回一个具体的构建复杂的产品；

系统中产品可能只有一种类型或多种类型，但对某些产品族来说，它们具备相同的行为，因此对这些共性行为进行抽象，抽离出 抽象建造者（Builder）；

而对这些行为的具体构建过程，则交由 具体建造者（Concrete Builder） 负责，不同的 具体建造者 会构建出不同表示的产品；

而具体要构建出哪种产品，由 导演者（Director） 决定。导演者 会选择不同的 具体建造者，指导它构建出产品。

模式优点

  1. 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。

  2. 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。由于指挥者类针对抽象建造者编程，增加新的具体建造者无须修改原有类库的代码，系统扩展方便，符合 “开闭原则”。

  3. 可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

模式缺点

  1. 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。

  2. 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

适用场景

  • 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。

  • 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。

  • 对象的创建过程独立于创建该对象的类。在建造者模式中通过引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类和客户类中。

  • 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

模式示例

以工厂制造电脑为例。

产品角色

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
package main.java.com.study.designPatterns.builder.demoOne;

/**
 * @author: whb
 * @description: 产品角色--电脑
 */
public class Computer {
    /**
     * 品牌
     */
    private String brand;
    /**
     * cpu
     */
    private String cpu;
    /**
     * 主板
     */
    private String mainBoard;
    /**
     * 硬盘
     */
    private String hardDisk;
    /**
     * 显卡
     */
    private String displayCard;
    /**
     * 电源
     */
    private String power;
    /**
     * 内存
     */
    private String memory;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getMainBoard() {
        return mainBoard;
    }

    public void setMainBoard(String mainBoard) {
        this.mainBoard = mainBoard;
    }

    public String getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }

    public String getDisplayCard() {
        return displayCard;
    }

    public void setDisplayCard(String displayCard) {
        this.displayCard = displayCard;
    }

    public String getPower() {
        return power;
    }

    public void setPower(String power) {
        this.power = power;
    }

    public String getMemory() {
        return memory;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "brand='" + brand + '\'' +
                ", cpu='" + cpu + '\'' +
                ", mainBoard='" + mainBoard + '\'' +
                ", hardDisk='" + hardDisk + '\'' +
                ", displayCard='" + displayCard + '\'' +
                ", power='" + power + '\'' +
                ", memory='" + memory + '\'' +
                '}';
    }
}

抽象建造者

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
32
33
34
35
package main.java.com.study.designPatterns.builder.demoOne;

/**
 * @author: whb
 * @description: 抽象建造者
 */
public abstract class Builder {
    /**
     * 产品角色
     */
    protected Computer computer = new Computer();

    public abstract void buildBrand();

    public abstract void buildCPU();

    public abstract void buildMainBoard();

    public abstract void buildHardDisk();

    public abstract void buildDisplayCard();

    public abstract void buildPower();

    public abstract void buildMemory();

    /**
     * 制造电脑
     *
     * @return
     */
    public Computer createComputer() {
        return computer;
    }
}

具体建造者

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
package main.java.com.study.designPatterns.builder.demoOne;

/**
 * @author: whb
 * @description: 具体建造者--戴尔
 */
public class DellComputerBuilder extends Builder {
    @Override
    public void buildBrand() {
        computer.setBrand("戴尔电脑");
    }

    @Override
    public void buildCPU() {
        computer.setCpu("i5-8300H 四核");
    }

    @Override
    public void buildMainBoard() {
        computer.setMainBoard("戴尔主板");
    }

    @Override
    public void buildHardDisk() {
        computer.setHardDisk("1T + 128GB SSD");
    }

    @Override
    public void buildDisplayCard() {
        computer.setDisplayCard("GTX1060 独立6GB");
    }

    @Override
    public void buildPower() {
        computer.setPower("4芯 锂离子电池 180W AC适配器");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("4G + 4G");
    }
}

package main.java.com.study.designPatterns.builder.demoOne;

/**
 * @author: whb
 * @description: 具体建造者--华硕电脑
 */
public class ASUSComputerBuilder extends Builder {
    @Override
    public void buildBrand() {
        computer.setBrand("华硕电脑");
    }

    @Override
    public void buildCPU() {
        computer.setCpu("Intel 第8代 酷睿");
    }

    @Override
    public void buildMainBoard() {
        computer.setMainBoard("华硕主板");
    }

    @Override
    public void buildHardDisk() {
        computer.setHardDisk("256GB SSD");
    }

    @Override
    public void buildDisplayCard() {
        computer.setDisplayCard("MX150 独立2GB");
    }

    @Override
    public void buildPower() {
        computer.setPower("3芯 锂离子电池 65W AC适配器");
    }

    @Override
    public void buildMemory() {
        computer.setMemory("1 x SO-DIMM  8GB");
    }
}

测试类

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
package main.java.com.study.designPatterns.builder.demoOne;

/**
 * @author: whb
 * @description: 测试类
 */
public class TestBuilder {
    public static void main(String[] args) {
        ComputerDirector director = new ComputerDirector();
        //华硕电脑
        Builder asusBuilder = new ASUSComputerBuilder();
        Computer asusComputer = director.construct(asusBuilder);
        System.out.println(asusComputer.toString());
        //戴尔电脑--通过反射机制创建具体建造者
        try {
            Class clazz = Class.forName("main.java.com.study.designPatterns.builder.demoOne.DellComputerBuilder");
            Builder dellBuilder = (DellComputerBuilder) clazz.newInstance();
            Computer dellComputer = director.construct(dellBuilder);
            System.out.println(dellComputer.toString());
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }
}

建造者模式与工厂模式的区别

建造者模式 与 工厂模式 的唯一区别就在于 构建复杂对象，这其实是它们的本质区别。而从表现形式上看，建造者模式 比 工厂模式 多了一个 导演者（Director）的角色。如果忽略 导演者，那么 建造者模式 与 工厂模式 几乎是一样的。

从上文 建造者模式 UML 类图中可以看到，导演者 是负责沟通 客户 与 具体建造者 的桥梁，也就是说，导演者 解耦了 客户 与 具体建造者。因为 具体建造者 属于细节实现，是底层模块，业务经常变换，不稳定；而 客户 属于上层模块，是业务逻辑部分，相对稳定；如果不设置 导演者 作为中间人，直接把 具体建造者 嵌入到业务逻辑（客户）中，会导致当业务改变（产品改变）时，需要更换 具体建造者，侵入了业务逻辑（客户）代码，不符合设计模式的迪米特法则。

而 工厂模式 之所以没有 导演者 这个角色，是因为 工厂 本身就担当了该角色。因为 导演者 最终的作用就是提供一个组装好的对象给到 客户，与 工厂 的作用一致。只是由于 工厂 生产的都是简单对象，因此 工厂 直接提供给 客户 就行了；而 建造者模式 提供的是复杂对象，需要专门的构建过程，因此借助 导演者 去沟通 具体的建造者 构建出相应的复杂对象，然后由 导演者 返回给 客户。

本文标题:设计模式-建造者模式

文章作者:王洪博

发布时间:2018年09月05日 - 11:09

最后更新:2019年09月12日 - 10:09

原始链接:http://whb1990.github.io/posts/2a48474d.html

▄︻┻═┳一如果你喜欢这篇文章，请点击下方"打赏"按钮请我喝杯 ☕
0%