Note when going straight for success of Mr.Wang

0%

建造者模式

发表于 更新于 分类于

设计模式之建造者模式

定义

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

了解

  建造者模式又称为生成器模式，它是一种较为复杂、使用频率也相对较低的创建型模式。建造者模式为客户端返回的不是一个简单的产品，而是一个由多个部件组成的复杂产品。
  建造者模式是较为复杂的创建型模式，它将客户端与包含多个组成部分（或部件）的复杂对象的创建过程分离，客户端无须知道复杂对象的内部组成部分与装配方式，只需要知道所需建造者的类型即可。它关注如何一步一步创建一个的复杂对象，不同的具体建造者定义了不同的创建过程，且具体建造者相互独立，增加新的建造者非常方便，无须修改已有代码，系统具有较好的扩展性。

结构图

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

alt

  • Builder（抽象建造者）：它为创建一个产品Product对象的各个部件指定抽象接口，在该接口中一般声明两类方法，一类方法是buildPartX()，它们用于创建复杂对象的各个部件；另一类方法是getResult()，它们用于返回复杂对象。Builder既可以是抽象类，也可以是接口。
  • ConcreteBuilder（具体建造者）：它实现了Builder接口，实现各个部件的具体构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂产品对象。
  • Product（产品角色）：它是被构建的复杂对象，包含多个组成部件，具体建造者创建该产品的内部表示并定义它的装配过程。
  • Director（指挥者）：指挥者又称为导演类，它负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联关系，可以在其construct()建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造。客户端一般只需要与指挥者进行交互，在客户端确定具体建造者的类型，并实例化具体建造者对象（也可以通过配置文件和反射机制），然后通过指挥者类的构造函数或者Setter方法将该对象传入指挥者类中。

示例

alt

  在建造者模式中，客户端只需实例化指挥者类，指挥者类针对抽象建造者编程，客户端根据需要传入具体的建造者类型，指挥者将指导具体建造者一步一步构造一个完整的产品（逐步调用具体建造者的buildX()方法），相同的构造过程可以创建完全不同的产品。在游戏角色实例中，如果需要更换角色，只需要修改配置文件，更换具体角色建造者类即可；如果需要增加新角色，可以增加一个新的具体角色建造者类作为抽象角色建造者的子类，再修改配置文件即可，原有代码无须修改，完全符合“开闭原则”。

Director(指挥者)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 方式一：
abstract class ActorBuilder
{
       protected static Actor actor = new  Actor();

       public  abstract void buildType();
       public  abstract void buildSex();
       public  abstract void buildFace();
       public  abstract void buildCostume();
       public  abstract void buildHairstyle();

       public static Actor  construct(ActorBuilder ab)
       {
              ab.buildType();
              ab.buildSex();
              ab.buildFace();
              ab.buildCostume();
              ab.buildHairstyle();
              return actor;
       }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 方式二（更简单）
abstract class ActorBuilder
{
       protected  Actor actor = new Actor();

       public  abstract void buildType();
       public  abstract void buildSex();
       public  abstract void buildFace();
       public  abstract void buildCostume();
       public  abstract void buildHairstyle();

       public Actor construct()
       {
              this.buildType();
              this.buildSex();
              this.buildFace();
              this.buildCostume();
              this.buildHairstyle();
              return actor;
       }
}

  以上两种对Director类的省略方式都不影响系统的灵活性和可扩展性，同时还简化了系统结构，但加重了抽象建造者类的职责，如果construct()方法较为复杂，待构建产品的组成部分较多，建议还是将construct()方法单独封装在Director中，这样做更符合“单一职责原则”。

钩子方法的引入

  钩子方法的返回类型通常为boolean类型，方法名一般为isXXX()，钩子方法定义在抽象建造者类中。
  通过引入钩子方法，我们可以在Director中对复杂产品的构建进行精细的控制，不仅指定buildPartX()方法的执行顺序，还可以控制是否需要执行某个buildPartX()方法。
具体操作见下面具体代码！！！

总结

  建造者模式的核心在于如何一步步构建一个包含多个组成部件的完整对象，使用相同的构建过程构建不同的产品，在软件开发中，如果我们需要创建复杂对象并希望系统具备很好的灵活性和可扩展性可以考虑使用建造者模式。

优点

  1. 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
  2. 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。由于指挥者类针对抽象建造者编程，增加新的具体建造者无须修改原有类库的代码，系统扩展方便，符合“开闭原则”
  3. 可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

缺点

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

适用场景

  1. 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。
  2. 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。

code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * @author Wangzy
 * @Description: 客户端
 * @date 15:20 2019/12/27
 */
public class Client {

    public static void main(String[] args) {
        // 客户端直接操纵指挥者
        Director director = new Director();
        Role role = director.construct(new HeroBuilder());
        System.out.println("创建角色成功! role: " + role.toString());
    }
}
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
/**
 * @author Wangzy
 * @Description: 指挥者类
 * @date 15:36 2019/12/27
 */
public class Director {

    /**
     * @Description: 核心：指挥创建对象的步骤及顺序等
     * @author Wangzy
     * @date 15:38 2019/12/27
     */
    public Role construct(Builder builder) {
        builder.buildCostume();
        builder.buildFace();
        // 判断钩子方法结果确定有没有头发再做发型
        if (!builder.isHeadLight()) {
            builder.buildHairstyle();
        }
        builder.buildRole();
        builder.buildSex();
        builder.buildType();
        return builder.buildRole();
    }
}
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
/**
 * @author Wangzy
 * @Description: 复杂角色
 * @date 15:23 2019/12/27
 */
public class Role {

    private String type;
    private String sex;
    private String face;
    private String costume;
    private String hairstyle;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getFace() {
        return face;
    }

    public void setFace(String face) {
        this.face = face;
    }

    public String getCostume() {
        return costume;
    }

    public void setCostume(String costume) {
        this.costume = costume;
    }

    public String getHairstyle() {
        return hairstyle;
    }

    public void setHairstyle(String hairstyle) {
        this.hairstyle = hairstyle;
    }

    @Override
    public String toString() {
        return "Role{" +
                "type='" + type + '\'' +
                ", sex='" + sex + '\'' +
                ", face='" + face + '\'' +
                ", costume='" + costume + '\'' +
                ", hairstyle='" + hairstyle + '\'' +
                '}';
    }
}
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
/**
 * @author Wangzy
 * @Description: 抽象建造者
 * @date 15:21 2019/12/27
 */
public abstract class Builder {

    protected Role role = new Role();

    abstract void buildType();

    abstract void buildSex();

    abstract void buildFace();

    abstract void buildCostume();

    abstract void buildHairstyle();

    /**
     * @Description: 创建钩子方法来"定制产品"
     * @author Wangzy
     * @date 17:43 2019/12/27
     */
    boolean isHeadLight() {
        return false;
    }

    Role buildRole() {
        return role;
    }

}
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
/**
 * @author Wangzy
 * @Description: 具体建造者（天使角色）
 * @date 15:21 2019/12/27
 */
public class AngelBuilder extends Builder {

    @Override
    void buildType() {
        this.role.setType("angel type!");
        System.out.println("build angel type!");

    }

    @Override
    void buildSex() {
        this.role.setSex("angel sex!");
        System.out.println("build angel sex!");
    }

    @Override
    void buildFace() {
        this.role.setFace("angel face!");
        System.out.println("build angel face!");
    }

    @Override
    void buildCostume() {
        this.role.setCostume("angel costume!");
        System.out.println("build angel costume!");
    }

    @Override
    void buildHairstyle() {
        this.role.setHairstyle("angel hairstyle!");
        System.out.println("build angel hairstyle!");
    }
}

/**
 * @author Wangzy
 * @Description: 具体建造者（恶魔角色）
 * @date 15:21 2019/12/27
 */
public class DevilBuilder extends Builder {

    @Override
    void buildType() {
        this.role.setType("devil type!");
        System.out.println("build devil type!");

    }

    @Override
    void buildSex() {
        this.role.setSex("devil sex!");
        System.out.println("build devil sex!");
    }

    @Override
    void buildFace() {
        this.role.setFace("devil face!");
        System.out.println("build devil face!");
    }

    @Override
    void buildCostume() {
        this.role.setCostume("devil costume!");
        System.out.println("build devil costume!");
    }

    @Override
    void buildHairstyle() {
        this.role.setHairstyle("devil hairstyle!");
        System.out.println("build devil hairstyle!");
    }
}

/**
 * @author Wangzy
 * @Description: 具体建造者（英雄角色）
 * @date 15:21 2019/12/27
 */
public class HeroBuilder extends Builder {

    @Override
    void buildType() {
        this.role.setType("hero type!");
        System.out.println("build hero type!");

    }

    @Override
    void buildSex() {
        this.role.setSex("hero sex!");
        System.out.println("build hero sex!");
    }

    @Override
    void buildFace() {
        this.role.setFace("hero face!");
        System.out.println("build hero face!");
    }

    @Override
    void buildCostume() {
        this.role.setCostume("hero costume!");
        System.out.println("build hero costume!");
    }

    @Override
    void buildHairstyle() {
        this.role.setHairstyle("hero hairstyle!");
        System.out.println("build hero hairstyle!");
    }

    /**
     * @Description: 复写抽象建造者类中的钩子方法，英雄必须是光头!!!
     * @author Wangzy
     * @date 17:46 2019/12/27
     */
    @Override
    boolean isHeadLight() {
        return true;
    }

}

相关资料

https://blog.csdn.net/lovelion/article/details/7426015
https://blog.csdn.net/lovelion/article/details/7426323
https://blog.csdn.net/lovelion/article/details/7426855

-------------the end-------------