设计模式--Builder

设计模式–Builder

概念

建造者模式是较为复杂的创建模式,它将客户端与包含多个组成部分(或部件)的复杂对象的创建过程分离。

使用场景

当构造一个对象需要很多参数的时候,并且参数的个数或者类型不固定的时候

UML结构图分析

角色介绍:

  • Product:它是被构建的复杂对象,包含多个组成部件
  • Builder:它为创建一个产品 Product 对象的各个部件指定抽象接口
  • ConcreteBuilder:它实现了 Builder 接口,实现各个部件的具体构造和装配方法
  • Director:指挥者又称为导演类,它负责安排负责对象的建造次序,指挥者与抽象建造者之间存在关联关系

实际代码分析

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
public class Product {

private String partA;
private String partB;
private String partC;

public String getPartA() {
return partA;
}

public void setPartA(String partA) {
this.partA = partA;
}

public String getPartB() {
return partB;
}

public void setPartB(String partB) {
this.partB = partB;
}

public String getPartC() {
return partC;
}

public void setPartC(String partC) {
this.partC = partC;
}
}

//抽象 Builder 类
public abstract class Builder {

protected Product product;

public abstract void buildPartA(String part);
public abstract void buildPartB(String part);
public abstract void buildPartC(String part);

//创建 Product
public abstract Product getResult();
}

//具体的 Builder 类
public class ConcreteBuilder extends Builder {
private Product product = new Product();

@Override
public void buildPartA(String part) {
product.setPartA(part);
}

@Override
public void buildPartB(String part) {
product.setPartB(part);
}

@Override
public void buildPartC(String part) {
product.setPartC(part);
}

@Override
public Product getResult(){
return product;
}
}

public class Director {
private Builder builder;

public Director(Builder builder){
this.builder = builder;
}

public void setBuilder(Builder builder) {
this.builder = builder;
}

//构建对象
public Product construct(String partA, String partB, String partC){
builder.buildPartA(partA);
builder.buildPartB(partB);
builder.buildPartC(partC);
return builder.getResult();
}
}

public class Test {

public static void main(String args[]){
Builder builder = new ConcreteBuilder();
Director director = new Director(builder);
director.construct("partA", "partB", "partC");
}
}

上述示例中,通过具体的 ConcreteBuilder 来构建 Builder 对象,而 Director 封装了构建复杂产品对象的过程,对外隐藏构建细节。Builder 与 Director 一起将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的对象。
但我们实际开发过程中,Director 角色经常会被省略。而直接一个 Builder 来进行对象的组装,这样使得 Builder 通常为链式调用,它的关键点是每个 setter 方法都返回自身,也就是 return this,这样使得 setter 方法可以链式调用,代码大致如下:

1
new TestBuilder().setA("A").setB("B").create();

通过这种形式不仅去除了 Director 角色,整个结构也更加简单,也能对 Product 对象的组装过程有更精细的控制。

builder 模式优点

  • 松散耦合:生成器模式可以用同一个构建算法构建出表现上完全不同的产品,实现产品构建和产品表现上的分离
  • 可以很容易的改变产品的内部表示
  • 更好的复用性:生成器模式很好的实现构建算法和具体产品实现的分离

builder 模式缺点

  • 会产生多余的 Builder 对象以及 Director 对象,消耗内存
  • 对象的构建过程暴露