设计模式--建造者模式

设计模式 创建型模式

目录

本文的结构如下：

• 引言
• 什么是建造者模式
• 模式的结构
• 典型代码
• 代码示例
• Builder模式变种
• 建造者模式与抽象工厂模式
• 优点和缺点
• 适用环境
• 模式应用

一、引言

玩过游戏的应该清楚，游戏中有很多角色，这些角色往往都有不同的外形，不同的能量值，不同的服饰，不同的武器等等，所以要创造一个游戏角色，就要创造构成这个游戏角色不同组成；再比如电脑，电脑是由CPU，主板，内存，显示器等组成的，电脑生厂商需要用这些部件组装成一部完整的电脑。

在软件开发中，创建一个由多个部件组成的复杂产品，往往使用建造者模式。

二、什么是建造者模式

建造者模式又称为生成器模式，它是一种较为复杂、使用频率也相对较低的创建型模式，它将客户端与包含多个组成部分（或部件）的复杂对象的创建过程分离。

建造者模式关注如何一步一步创建一个的复杂对象，不同的具体建造者定义了不同的创建过程，且具体建造者相互独立，增加新的建造者非常方便，无须修改已有代码，系统具有较好的扩展性。

建造者模式定义如下：

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

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

三、模式的结构

建造者模式UML类图如下：

在建造者模式结构图中包含如下几个角色：

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

复杂对象是指那些包含多个成员属性的对象，这些成员属性也称为部件或零件，如汽车包括方向盘、发动机、轮胎等部件，电子邮件包括发件人、收件人、主题、内容、附件等部件。

四、典型代码

复杂对象类典型代码如下：

public class Product {
    //定义部件，部件可以是任意类型，包括值类型和引用类型
    private  String partA;
    private  String partB;
    private  String partC;
    public void setPartA(String partA) {
        this.partA = partA;
    }
    public void setPartB(String partB) {
        this.partB = partB;
    }
    public void setPartC(String partC) {
        this.partC = partC;
    }
}

抽象建造者类定义了产品部件的创建方法和复杂产品返回方法，典型代码如下：

public abstract class Builder {
    protected Product product = new Product();
    public abstract void buildPartA();
    public abstract void buildPartB();
    public abstract void buildPartC();
    public Product getResult(){
        return product;
    }
}

在ConcreteBuilder中实现了buildPartX()方法，通过调用Product的setPartX()方法可以给产品对象的成员属性设值。不同的具体建造者在实现buildPartX()方法时将有所区别，如setPartX()方法的参数可能不一样，在有些具体建造者类中某些setPartX()方法无须实现（提供一个空实现）。而这些对于客户端来说都无须关心，客户端只需知道具体建造者类型即可。

public class ConcreteBuilder extends Builder {
    public void buildPartA() {
        product.setPartA("part A");
    }
    public void buildPartB() {
        product.setPartA("part B");
    }
    public void buildPartC() {
        product.setPartA("part C");
    }
}

建造者模式的结构中还有一个指挥者类Director，该类主要有两个作用：一是它隔离了客户与创建过程；二是它控制产品的创建过程，包括某个buildPartX()方法是否被调用以及多个buildPartX()方法调用的先后次序等。指挥者针对抽象建造者编程，客户端只需要知道具体建造者的类型，即可通过指挥者类调用建造者的相关方法，返回一个完整的产品对象。在实际生活中也存在类似指挥者一样的角色，如一个客户去购买电脑，电脑销售人员相当于指挥者，只要客户确定电脑的类型，电脑销售人员可以通知电脑组装人员给客户组装一台电脑。指挥者类典型代码如下：

public class Director {
    private Builder builder;
    public Director(Builder builder){
        this.builder = builder;
    }
    public void setBuilder(Builder builder){
        this.builder = builder;
    }
    public Product construct(){
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

客户端:

public class Client {
    public static void main(String[] args) {
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);
        Product product = director.construct();
    }
}

在客户端代码中，无须关心产品对象的具体组装过程，只需指定具体建造者的类型即可。可以通过配置文件来存储具体建造者类ConcreteBuilder的类名，使得更换新的建造者时无须修改源代码，系统扩展更为方便。

五、代码示例

一款视频播放软件，为了给用户使用提供方便，不同场景下有不同界面，如完整界面、精简界面等。不同的界面该播放器的组成元素有所差异，如在完整界面下将显示菜单、播放列表、主窗口、控制条等，在精简界面下只显示主窗口和控制条。

复杂对象VideoPlayer:

public class VideoPlayer {
    private String type;
    private String menu;
    private String playerList;
    private String mainWindows;
    private String controlStrip;
    public void setType(String type) {
        this.type = type;
    }
    public void setMenu(String menu) {
        this.menu = menu;
    }
    public void setPlayerList(String playerList) {
        this.playerList = playerList;
    }
    public void setMainWindows(String mainWindows) {
        this.mainWindows = mainWindows;
    }
    public void setControlStrip(String controlStrip) {
        this.controlStrip = controlStrip;
    }
    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");
        return sb.toString();
    }
}

抽象builder:

public abstract class PlayerBuilder {
    protected VideoPlayer player = new VideoPlayer();
    public abstract void buildType();
    public abstract void buildMenu();
    public abstract void buildPlayerList();
    public abstract void buildMainWindows();
    public abstract void buildControlStrip();
    public VideoPlayer getPlayer(){
        return player;
    }
}

具体builder:

public class FullPlayerBuilder extends PlayerBuilder {
    public void buildType() {
        player.setType("完整界面");
    }
    public void buildMenu() {
        player.setMenu("菜单");
    }
    public void buildPlayerList() {
        player.setPlayerList("播放列表");
    }
    public void buildMainWindows() {
        player.setMainWindows("主界面");
    }
    public void buildControlStrip() {
        player.setControlStrip("控制条");
    }
}
public class SimplePlayerBuilder extends PlayerBuilder {
    public void buildType() {
        player.setType("精简界面");
    }
    public void buildMenu() {
    }
    public void buildPlayerList() {
    }
    public void buildMainWindows() {
        player.setMainWindows("主界面");
    }
    public void buildControlStrip() {
        player.setControlStrip("控制条");
    }
}

指挥者BuilderDirector:

public class PlayerDirector {
    private PlayerBuilder builder;
    public PlayerDirector(PlayerBuilder builder){
        this.builder = builder;
    }
    public void setBuilder(PlayerBuilder builder){
        this.builder = builder;
    }
    public VideoPlayer construct(){
        builder.buildType();
        builder.buildMenu();
        builder.buildPlayerList();
        builder.buildMainWindows();
        builder.buildControlStrip();
        return builder.getPlayer();
    }
}

客户端测试：

public class Client {
    public static void main(String[] args) {
        PlayerBuilder builder = new FullPlayerBuilder();
        PlayerDirector director = new PlayerDirector(builder);
        VideoPlayer player = director.construct();
        System.out.println(player);
    }
}

六、Builder模式变种

6.1、省略Director

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

但是在有些情况下，为了简化系统，我们可以将Director和抽象建造者Builder进行合并。

如下：

public abstract class PlayerBuilder {
    protected VideoPlayer player = new VideoPlayer();
    public abstract void buildType();
    public abstract void buildMenu();
    public abstract void buildPlayerList();
    public abstract void buildMainWindows();
    public abstract void buildControlStrip();
    public VideoPlayer getPlayer(){
        buildType();
        buildMenu();
        buildPlayerList();
        buildMainWindows();
        buildControlStrip();
        return player;
    }
}
public class Client {
    public static void main(String[] args) {
        PlayerBuilder builder = new SimplePlayerBuilder();
        VideoPlayer player = builder.getPlayer();
        System.out.println(player);
    }
}

6.2、内部Builder

内部Builder用起来是链式调用的形式，在Effective Java中，第二条有提到遇到多个构造器参数时要考虑用构建器，应该还是比较熟悉的。

public class VideoPlayer {
    private final String type;
    private final String menu;
    private final String playerList;
    private final String mainWindows;
    private final String controlStrip;
    private VideoPlayer(Builder builder){
        type = builder.type;
        menu = builder.menu;
        playerList = builder.playerList;
        mainWindows = builder.mainWindows;
        controlStrip = builder.controlStrip;
    }
    public static class Builder{
        private String type;
        private String menu;
        private String playerList;
        private String mainWindows;
        private String controlStrip;
        public Builder setType(String type) {
            this.type = type;
            return this;
        }
        public Builder setMenu(String menu){
            this.menu = menu;
            return this;
        }
        public Builder setPlayerList(String playerList){
            this.playerList = playerList;
            return this;
        }
        public Builder setMainWindows(String mainWindows){
            this.mainWindows = mainWindows;
            return this;
        }
        public Builder setControlStrip(String controlStrip){
            this.controlStrip = controlStrip;
            return this;
        }
        public VideoPlayer build(){
            return new VideoPlayer(this);
        }
    }
    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");
        return sb.toString();
    }
}

客户端：

public class Client {
    public static void main(String[] args) {
        VideoPlayer player = new VideoPlayer.Builder()
                .setType("简单界面")
                .setMainWindows("主界面")
                .setControlStrip("控制条")
                .build();
        System.out.println(player);
    }
}

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

建造者模式完成的事，好像都可以通过抽象工厂模式完成，那么区别是什么？

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

八、优点和缺点

8.1、优点

建造者模式的主要优点如下：

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

8.2、缺点

建造者模式的主要缺点如下：

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

九、适用环境

在以下情况下可以考虑使用建造者模式：

• 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。
• 需要生成的产品对象的属性相互依赖，需要指定其生成顺序。
• 对象的创建过程独立于创建该对象的类。在建造者模式中通过引入了指挥者类，将创建过程封装在指挥者类中，而不在建造者类和客户类中。
• 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。