建造者（Builder）模式
GOF给出的定义为：建造者模式是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
应用场景
使用建造者模式是为了将构建复杂对象的过程和它的部件解耦。注意：是解耦过程和部件。
参与角色
建造者模式通常包括以下这几个角色： 1、Builder：给出一个抽象接口，规范建造者对于生产的产品的各个组成部分的建造。这个接口只是定一个规范，不涉及具体的建造，具体的建造让继承于它的子类（ConcreteBuilder）去实现。
2、ConcreteBuilder：实现builder接口，针对不同的商业逻辑，具体化各对象部分的建造，最后返回一个建造好的产品。
3、Director：导演，顾名思义，负责规范流程之用。在指导中不涉及产品的创建，只负责保证复杂对象各部分被创建或按某种顺序创建。
4、Product：复杂对象。
如何使用建造者模式
首先假设一个复杂对象是由多个部件组成的，Builder模式是把复杂对象的创建和部件的创建分别开来，分别用Builder类和Director类来表示。
首先,需要一个接口，它定义如何创建复杂对象的各个部件：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public
interface
Builder {
//创建部件A 比如创建汽车车轮
void
buildPartA();
//创建部件B 比如创建汽车方向盘
void
buildPartB();
//创建部件C 比如创建汽车发动机
void
buildPartC();
/**返回最后组装成品结果 (返回最后装配好的汽车)
* 成品的组装过程不在这里进行,而是转移到下面的Director类中进行
* 从而实现了解耦过程和部件
*/
Product getResult();
}
|
用Director构建最后的复杂对象，而在上面Builder接口中封装的是如何创建一个个部件(复杂对象是由这些部件组成的)，
也就是说Director的内容是如何将部件最后组装成成品：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
public
class
Director {
private
Builder builder;
public
Director(Builder builder){
this
.builder=builder;
}
/** 将部件partA partB partC最后组成复杂对象 */
public
void
construct(){
builder.buildPartA();
builder.buildPartB();
builder.buildPartC();
}
}
|
Builder的具体实现ConcreteBuilder：
通过具体完成接口Builder来构建或装配产品的部件；
定义并明确它所要创建的是什么具体东西；
提供一个可以重新获取产品的接口。
|
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
|
public
class
ConcreteBuilder
implements
Builder{
private
Product product;
@Override
public
void
buildPartA() {
/**
* 在此创建出部件
* 把partA传递给product
*/
PartA partA=
new
PartA();
product.setPartA(partA);
}
@Override
public
void
buildPartB() {
PartB partB=
new
PartB();
product.setPartB(partB);
}
@Override
public
void
buildPartC() {
PartC partC=
new
PartC();
product.setPartC(partC);
}
@Override
public
Product getResult() {
return
product;
}
}
|
复杂对象产品：
|
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
|
public
class
Product {
private
PartA partA;
private
PartB partB;
private
PartC partC;
public
PartA getPartA() {
return
partA;
}
public
void
setPartA(PartA partA) {
this
.partA = partA;
}
public
PartB getPartB() {
return
partB;
}
public
void
setPartB(PartB partB) {
this
.partB = partB;
}
public
PartC getPartC() {
return
partC;
}
public
void
setPartC(PartC partC) {
this
.partC = partC;
}
}
|
复杂对象的部件：
|
1
2
3
|
public
class
PartA {
}
|
|
1
2
3
|
public
class
PartB {
}
|
|
1
2
3
|
public
class
PartC {
}
|
如何应用：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
public
class
Test {
public
static
void
main(){
Builder builder=
new
ConcreteBuilder();
Director director=
new
Director(builder);
director.construct();
Product product = builder.getResult();
}
}
|
使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。
其次，建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。
本文转自邴越博客园博客，原文链接：http://www.cnblogs.com/binyue/p/3726840.html，如需转载请自行联系原作者
