设计模式之建造者模式

设计模式之建造者模式

建造者模式 属于 创建型模式，提供一种创建对象的最佳方式。

创建型模式 指不是直接使用new的方法，提供另外一种创建对象的方式，并向调用者隐藏 创建对象的细节，该模式使创建对象更加的灵活。

建造者模式

简介

​ 将简单对象一步步的构建为复杂的对象。换句话说，就是将复杂的对象的构建与表示进行分离。

​ 有顺序的创建复杂对象。

模式原理

该模式有四个角色。

• Product：最终生成的对象 产品者
• Builder：构建者的抽象基类，定义创建产品的抽象步骤。一般为抽象类(有时会用接口代替)。在其中会有一个返回产品的方法。抽象建造者
• ConcreteBuilder：继承Builder类，实现抽象方法，该类实现产品的生成。 实际建造者
• Director:该类 指导实际建造者 如何生成产品。 指挥者

UML类图

​ 该图片引用于菜鸟教程。

生活实例

可能看这些术语懵懵的，我们来点与生活相关的实例。

既然 创建型模式 是创建对象，那我们也来创建一个对象。

比如说，我们现在要创建一个 自行车。

一个自行车 由很多部件组成

假设 是一个框架，一个座位，还有轮胎组成。

• 自行车 可能会有不同的厂家生产，需要定一个标准，让各大厂家遵守这个规则生产。
• 不同厂家，生产这些部件的方式 可能不同,但都需要实现上面的标准。
• 光生产这些部件不行，还要把他们组装起来才能够用，并且还需要按照一定的顺序才行。

这个例子 我们来一一对应四个角色。

• 自行车–>产品者
• 标准–>抽象建造者
• 不同的厂家–> 实际建造者。
• 部件组装–>指挥者。

代码实现

下面我们用代码来实现上面的思路。

自行车类 产品者

package create.builder.bike;
public class Bike {

    private String frame;
    private String seat;
    private String tire;

    public String getFrame() {
        return frame;
    }
    public void setFrame(String frame) {
        this.frame = frame;
    }
    public String getSeat() {
        return seat;
    }
    public void setSeat(String seat) {
        this.seat = seat;
    }
    public String getTire() {
        return tire;
    }
    public void setTire(String tire) {
        this.tire = tire;
    }

    @Override
    public String toString() {
        return "Bike{" +
                "frame='" + frame + '\'' +
                ", seat='" + seat + '\'' +
                ", tire='" + tire + '\'' +
                '}';
    }
}

行业标准 抽象建造者

//抽象建造者 定义了构建产品的步骤
public abstract class Builder {
    abstract void buildFrame();
    abstract void buildSeat();
    abstract void buildTire();
    abstract Bike createBike();//返回一个对象的方法
}

不同厂家 实际建造者

摩拜单车(摩拜打钱)

package create.builder.bike;
//摩拜单车
//实际真正的建造者
public class MobikeBuilder extends Builder {

    private Bike mBike = new Bike();
    @Override
    void buildFrame() {
        mBike.setFrame("mobike");
    }

    @Override
    void buildSeat() {
        mBike.setSeat("mobikeSeat");
    }

    @Override
    void buildTire() {
        mBike.setTire("mobikeTire");
    }

    @Override
    Bike createBike() {
        return mBike;
    }

    @Override
    public String toString() {
        return "MobikeBuilder{" +
                "mBike=" + mBike +
                '}';
    }
}

ofo单车(ofo打钱)

package create.builder.bike;

public class OfoBuilder extends Builder {
    private Bike oBike = new Bike();
    @Override
    void buildFrame() {
        oBike.setFrame("OfoBike");
    }
    @Override
    void buildSeat() {
        oBike.setSeat("OfoBikeSeat");
    }

    @Override
    void buildTire() {
        oBike.setTire("OfoBike");
    }

    @Override
    Bike createBike() {
        return oBike;
    }

    @Override
    public String toString() {
        return "OfoBuilder{" +
                "oBike=" + oBike +
                '}';
    }
}

部件组装 指挥者

public class Director {
    //传递过来真正的建造者。
    private Builder mBuilder ;
    public Director(Builder builder) {//注入真正的建造者
        mBuilder = builder;
    }
    public Bike construct() {
        //告诉具体建造者如何建造产品 最终决定 构建的顺序。
        //控制建造的先后顺序 以及返回产品。
        mBuilder.buildFrame();
        mBuilder.buildSeat();
        mBuilder.buildTire();
        return mBuilder.createBike();
    }
}

模拟客户 来要车

public class Client {
    public static void main(String[] args) {
        //客户 找 指挥者 要车，要什么车 就new 哪个工厂的车。
        //然后 生产一个车给客户。
        //客户完全不要关心 自行车是怎么创建出来的，只管找指挥者要就行了。
        //再次实现了 创建型模式 向调用者隐藏创建细节的要求。
        Director director = new Director(new MobikeBuilder());
        Bike bike = director.construct();
        System.out.println(bike.toString());

        Director director2 = new Director(new OfoBuilder());
        Bike bike2 = director2.construct();
        System.out.println(bike2.toString());
    }
}

实验结果

整理思路

我们再来理一遍思路。

• 客户 找 指挥者要车
• 指挥者 找 真正的建造者要车部件
• 真正的建造车 生产出车部件给指挥者
• 指挥者 将车部件 按照顺序组装，然后给客户。

重新思考

我们再来思考之前的那个简介

建造者模式 是将简单对象构建为复杂对象。

自行车的各个部件是一个简单对象。

自行车 是一个复杂对象。

在 这个实例中 我为了简化代码 是将Frame Seat Tire简化为String 类型。

实际上 他们也是一个类型。按照实际的话应该这样写

privat Frame frame;
privat Seat seat;
privat Tire tire;

我们组装自行车(复杂对象)，就像是搭积木一样，一个一个部件(简单对象)的往上面加，之后再构成我们想要的自行车（复杂对象）。

---

建议看完后 自己上手 实际敲一遍，这样印象更加深刻。

与抽象工厂模式的联系

• 抽象工厂也是生产产品的。它是工厂的工厂，生产的是一系列的独立的产品。而建造者模式 生产的是不同产品的组装，是一个组装好的完整产品。

• 我们可以将 不同厂家生产 自行车的部件(MobikeBuilder)，使用抽象工厂模式。配件生产工厂

而将自行车的组装 使用建造者模式。配件组装工厂

如果不懂抽象工厂，可以去看看我的这篇文章。

简单易懂的工厂模式

作业实践

使用建造者模式 生产一台笔记本电脑。

声明

本篇文章借鉴于 一篇文章就彻底弄懂建造者模式

特向原作者表示感谢！

如果有任何疑问，请在评论区留言，我将知无不言，言无不尽。

最后，码字不易。如果本篇文章对你有些许的帮助，还请帮我点个赞，评论一下。

你的赞同是我创作的最大动力。