前言

建造者(Builder)模式的定义:指将一个复杂对象的构造与它的表示分离,使同样的构建过程可以创建不同的表示,这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象,然后一步一步构建而成。它将变与不变相分离,即产品的组成部分是不变的,但每一部分是可以灵活选择的。

意图

建造者模式主要用于解决软件系统中复杂对象的创建问题。例如复杂对象的创建通过各个部分的子对象用一定的算法构成,在需求变化时复杂对象面临大的改变,不利于系统的稳定,使用建造者将各个部分的算法包装起来,需求变化只需要将算法的顺序以及组合方式改变即可。

优缺点

优点

  1. 封装性好,构建和表示分离。
  2. 扩展性好,各个具体的建造者相互独立,有利于系统的解耦。
  3. 客户端不必知道产品内部组成的细节,建造者可以对创建过程逐步细化,而不对其它模块产生任何影响,便于控制细节风险。

缺点

  1. 产品的组成部分必须相同,这限制了其使用范围。
  2. 如果产品的内部变化复杂,如果产品内部发生变化,则建造者也要同步修改,后期维护成本较大。

实现

这里就用生产计算机为例,分别生产笔记本和主机两种不同类型的计算机;

首先我们要有个建造者接口

1
2
3
4
5
6
7
8
9
/**
* 建造者
*/
public interface Builder {
void buildCpu();
void buildMemory();
void buildSurface();
Computer buildComputer();
}

然后整个两个具体建造者实现建造者接口,笔记本建造者和pc主机建造者

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
/**
* 笔记本(具体建造者)
*/
public class NoteBookBuilder implements Builder{
private Computer computer;

public NoteBookBuilder(){
computer = new Computer();
}

@Override
public void buildCpu() {
computer.cpu="cpu: 酷睿i5";
}

@Override
public void buildMemory() {
computer.memory="内存: 8G";
}

@Override
public void buildSurface() {
computer.surface="外观: 笔记本";
}

@Override
public Computer buildComputer() {
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
/**
* pc主机(具体建造者)
*/
public class PCHostBuilder implements Builder {
private Computer computer;

public PCHostBuilder(){
computer = new Computer();
}

@Override
public void buildCpu() {
computer.cpu="cpu: 酷睿i7 HQ";
}

@Override
public void buildMemory() {
computer.memory="内存: 16G";
}

@Override
public void buildSurface() {
computer.surface="外观: PC主机";
}

@Override
public Computer buildComputer() {
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
/**
* 产品类
*/
public class Computer {
public String cpu;
public String memory;
public String surface;

public String getCpu() {
return cpu;
}

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

public String getMemory() {
return memory;
}

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

public String getSurface() {
return surface;
}

public void setSurface(String surface) {
this.surface = surface;
}

@Override
public String toString() {
return "Computer{" +
"cpu='" + cpu + '\'' +
", memory='" + memory + '\'' +
", surface='" + surface + '\'' +
'}';
}
}

最后来个产品总经理指挥技术员如何组装

1
2
3
4
5
6
7
8
9
10
11
/**
* 计算机组装指挥官
*/
public class ComputerDirector {
public Computer constructComputer(Builder builder){
builder.buildCpu();
builder.buildMemory();
builder.buildSurface();
return builder.buildComputer();
}
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
* 测试建造者模式
*/
public class TestBuilder {
public static void main(String[] args) {
//创建指挥官
ComputerDirector director = new ComputerDirector();
//指挥生产一个笔记本
Computer noteBook = director.constructComputer(new NoteBookBuilder());
System.out.println(noteBook);
//指挥生产一个PC主机
Computer pcHost = director.constructComputer(new PCHostBuilder());
System.out.println(pcHost);
}
}

结果输出

1
2
Computer{cpu='cpu: 酷睿i5', memory='内存: 8G', surface='外观: 笔记本'}
Computer{cpu='cpu: 酷睿i7 HQ', memory='内存: 16G', surface='外观: PC主机'}