建造者模式

建造者模式

定义

将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。

首先这是一个复杂的对象,也就是说对象的创建过程比较复杂,可能需要N多个组件来完成整个对象的创建,这个时候为了符合“单一职责”,我们将对象的构建过程分离出来,通过建造者来完成对象组件的创建,再通过一个指挥者类完成组装生成一个完整的产品。

UML图

四要素

根据UML图可知道,建造者模式有4个非常重要的角色

  • Builder:一个抽象接口,用于规范子类建造者的创建产品对象的各个组件。
  • ConcreteBuilder: 实现抽象类的所有未实现的方法,不同的建造者有不同的构建产品组件的方法。
  • Director:指挥者类,复杂完成整个产品的组装,不同的建造者创建一个产品不同的组件,通过指挥者类将整个产品组装完成。
  • Product:产品类,一般是一个比较复杂的对象,也就是说这个产品的创建过程比较复杂。


下面还是通过一个实例来认识一下建造者模式

实例

一软件公司欲开发一个音乐播放软件,为了给用户使用提供方便,该播放软件提供多种界面显示模式,如完整模式、精简模式、记忆模式、网络模式等。在不同的显示模式下主界面的组成元素有所差异,如在完整模式下将显示菜单、播放列表、主窗口、控制条等,在精简模式下只显示主窗口和控制条,而在记忆模式下将显示主窗口、控制条、收藏列表等。

UML图

根据需求我们可以设计UML图如下

代码

MusicPlayer类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class MusicPlayer {
private String type;
private String menu;
private String playerList;
private String mainWindows;
private String controlStrip;
private String collectionList;

@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("这是一个 ").append(type).append(" 音乐播放器\n\n");
sb.append("播放器拥有:\n");
if (menu != null) sb.append(menu).append("\n");
if (playerList != null) sb.append(playerList).append("\n");
if (mainWindows != null) sb.append(mainWindows).append("\n");
if (controlStrip != null) sb.append(controlStrip).append("\n");
if (collectionList != null) sb.append(collectionList).append("\n");
return sb.toString();
}

//get set方法
...
}

PlayerBuilder 抽象接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public abstract class PlayerBuilder {

protected MusicPlayer player = new MusicPlayer();

public abstract void buildType();
public abstract void buildMenu();
public abstract void buildPlayerList();
public abstract void buildMainWindows();
public abstract void buildControlStrip();
public abstract void buildCollectionList();

public MusicPlayer createPlayer(){
return player;
}

}

根据需求建立三个不同的建造者

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
// 完整模式
public class FullPlayerBuilder extends PlayerBuilder {
@Override
public void buildType() {
player.setType("完整模式");
}

@Override
public void buildMenu() {
player.setMenu("菜单");
}

@Override
public void buildPlayerList() {
player.setPlayerList("播放列表");
}

@Override
public void buildMainWindows() {
player.setMainWindows("主界面");
}

@Override
public void buildControlStrip() {
player.setControlStrip("控制条");
}

@Override
public void buildCollectionList() {
player.setCollectionList("收藏列表");
}
}
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
//精简模式
public class SimplePlayerBuilder extends PlayerBuilder {
@Override
public void buildType() {
player.setType("精简模式");
}

@Override
public void buildMenu() {
player.setMenu(null);
}

@Override
public void buildPlayerList() {
player.setPlayerList(null);
}

@Override
public void buildMainWindows() {
player.setMainWindows("主界面");
}

@Override
public void buildControlStrip() {
player.setControlStrip("控制条");
}

@Override
public void buildCollectionList() {
player.setCollectionList(null);
}
}
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 MemoryPlayerBuilder extends PlayerBuilder {

@Override
public void buildType() {
player.setType("记忆模式");
}

@Override
public void buildMenu() {
player.setMenu(null);
}

@Override
public void buildPlayerList() {
player.setPlayerList(null);
}

@Override
public void buildMainWindows() {
player.setMainWindows("主界面");
}

@Override
public void buildControlStrip() {
player.setControlStrip("控制条");
}

@Override
public void buildCollectionList() {
player.setCollectionList("收藏列表");
}
}

PlayerController类,也就是指挥者类

1
2
3
4
5
6
7
8
9
10
11
12
public class PlayerController {

public MusicPlayer construct(PlayerBuilder pb) {
pb.buildType();
pb.buildMenu();
pb.buildPlayerList();
pb.buildMainWindows();
pb.buildControlStrip();
pb.buildCollectionList();
return pb.createPlayer();
}
}

客户端测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Client {

public static void main(String[] args) {
MusicPlayer player;
PlayerBuilder builder;
PlayerController controller;

builder = new SimplePlayerBuilder();
controller = new PlayerController();

player = controller.construct(builder);

System.out.println(player.toString());
}
}

测试结果如下

1
2
3
4
5
这是一个 精简模式 音乐播放器

播放器拥有:
主界面
控制条

选择不同的建造者即可以生产出不同模式的音乐播放器,建造者完成了创建播放器组件的过程,而指挥者类完成最后的组装。对于客户端来说不需要了解具体的创建步骤,只需要选择对应的建造者即可。

变种1:省略Director

Director类在建造者模式中扮演十分重要的作用,它按一定的顺序调用Builder的buildPartX()方法,像客户端返回一个完整的产品。

但是在有些情况下,为了简化系统,我们可以将Director和抽象建造者Builder进行合并,例如下面的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Product {

private String name;
private String price;

@Override
public String toString() {
return "Product{" +
"name='" + name + '\'' +
", price='" + price + '\'' +
'}';
}

...
}
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
public abstract  class Builder {

protected Product product = new Product();

public abstract void buildName();

public abstract void buildPrice();

public Product createProduct(){
this.buildName();
this.buildPrice();
return product;
}
}

public class Product1Builder extends Builder {
@Override
public void buildName() {
product.setName("product1");
}
@Override
public void buildPrice() {
product.setPrice("1234");
}
}

public class Product2Builder extends Builder {
@Override
public void buildName() {
product.setName("product2");
}

@Override
public void buildPrice() {
product.setPrice("6789");
}
}

客户端调用

1
2
3
4
5
6
7
8
9
10
11
12
public class Client {
public static void main(String[] args) {
Product product;
Builder builder;

builder = new Product1Builder();

product = builder.createProduct();

System.out.println(product.toString());
}
}

变种2:内部Builder

先给大家看一段代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Client {

public static void main(String[] args) {
Person.Builder builder = new Person.Builder();

Person person = builder.setAge(14)
.setCountry("中国")
.setName("张三")
.setSex("男")
.create();

System.out.println(person.toString());
}
}

这熟悉的内部类Builder,这风骚的链式调用,相信作为Android开发程序猿应该非常熟悉吧,不管是Android系统AlertDialog、Notification的创建还是第三方开源库Retrofit、Universal-Image-Loader的配置都是这熟悉的套路,没错这也是建造者模式的一个变种。

先看看上面示例中Person的代码

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

private String name;
private int age;
private String sex;
private String country;

private Person() {
}

private Person(String name, int age, String sex, String country) {
this.name = name;
this.age = age;
this.sex = sex;
this.country = country;
}

@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
", country='" + country + '\'' +
'}';
}

public static class Builder {
private String name;
private int age;
private String sex;
private String country;

public Builder setName(String name) {
this.name = name;
return this;
}

public Builder setAge(int age) {
this.age = age;
return this;
}

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

public Builder setCountry(String country) {
this.country = country;
return this;
}

public Person create() {
return new Person(name, age, sex, country);
}
}
}

从代码中我们可以知道,这种模式是对前一个变种的进一步简化,将Builder类置于Product类的内部,通过create()方法完成产品的组装。虽然代码简化只有一个类,但依旧符合建造者模式的思想,依然属于建造者模式的一种。有兴趣的同学可以扒一扒AlertDialog的源码看看,受益良多。

建造者模式与抽象工厂模式

有些同学可能会发现,建造者模式完成的事,我们都可以通过抽象工厂模式完成,那么他们有什么区别呢?

  • 与建造者模式相比,抽象工厂模式返回的是一系列相关的产品,这些产品位于不同的产品等级结构,构成产品族,而建造者模式返回的是一个组装好的完整产品。抽象工厂模式更像一个汽车零件生产商,生产不同品牌汽车的各种零件。而建造者模式更像一个汽车装配厂,通过一系列零件的组装,最终生产出的是一个完整的汽车。
  • 抽象工厂模式中,客户端需实例化工厂类,然后通过工厂类获取所需的产品对象。而建造者模式更侧重于将复杂的构造对象的方法交给建造者去做,而客户端只需要通过指挥者就能创建一个完整的产品实例。

小结

建造者模式将一个复杂对象的构建与它的表示分离,使得客户端通过创建不同的建造者即可创建出不同的对象。且通过分离的方式,将复杂的创建过程分离出来,符合“单一职责”规范。新的不同对象可以通过新增建造者类生成,符合“开闭原则”。但建造者类的使用范围也有一定的限制,建造者模式创建的产品都有一定的相似性,如果所创建的产品差异性很大,则不适合建造者模式。


源码:https://github.com/lichenming0516/DesignPattern

坚持原创技术分享,您的支持将鼓励我继续创作!