建造者模式

简介

Separate the construction of a complex object from its representation so that the same construction process can create different representations.
将一个复杂对象的构建与它的表示进行分离，使得同样的构建过程可以创建不同的表示。

简单理解：建造者模式（Builder Pattern） 具备两层含义：

• 构建与表示分离：构建 代表对象创建，表示 代表对象行为/方法，也就是对象的创建与行为进行分离（对应到 java 代码，其实就是使用 接口 规定行为，然后由具体的实现类进行构建）。
• 创建不同的表示：也就是具备同样的行为，但是却由于构建的行为顺序不同或其他原因可以创建出不同的表示。

我们看完上述 建造者模式 的定义，就知道它与 工厂模式 是非常相似的。构建与表示分离 和 创建不同的表示 对于 工厂模式 同样具备。建造者模式 唯一区别于 工厂模式 主要是针对 复杂对象的构建。

也就是说，如果是创建简单对象，我们通常都是使用 工厂模式 进行创建；而如果是创建复杂对象，那么此时就可以考虑使用 建造者模式。

主要解决

当需要构建的产品具备 复杂创建 过程时，可以抽取出共性构建过程，然后交由具体实现类自定义构建流程，使得同样的构建行为可以生产出不同的产品，分离了构建与表示，使构建产品灵活性大大增加。

使用场景

• 需要生成的产品对象有复杂的内部结构，这些产品对象具备共性；
• 隔离复杂对象的创建和使用，并使得相同的构建过程可以创建不同的产品。

建造者模式 讲解

我们先来看下 建造者模式 类图 UML 表示：

建造者模式

从 UML 图中，我们可以看到，建造者模式 主要包含四种角色：

• 抽象建造者（Builder）：主要用于规范产品类的各个组成部分，并提供一个返回完整产品的接口。
• 具体建造者（Concrete Builder）：实现 抽象建造者 规定的各个方法，返回一个组件好的具体产品。
• 产品（Product）：构建相当复杂的类型，建造者最终创建的产品类型。
• 导演者（Director）：指导 建造者（Builder） 以特定行为构建出产品，并将其返回给客户。

总结：理解了 建造者模式 的四种角色，其实就已经掌握了 建造者模式 的真谛：建造者模式 最终返回一个具体的构建复杂的产品；系统中产品可能只有一种类型或多种类型，但对某些产品族来说，它们具备相同的行为，因此对这些共性行为进行抽象，抽离出 抽象建造者（Builder）；而对这些行为的具体构建过程，则交由 具体建造者（Concrete Builder） 负责，不同的 具体建造者 会构建出不同表示的产品；而具体要构建出哪种产品，由 导演者（Director） 决定。导演者 会选择不同的 具体建造者，指导它构建出产品。

上文说过，建造者模式 与 工厂模式 的唯一区别就在于 构建复杂对象，这其实是它们的本质区别。而从表现形式上看，建造者模式 比 工厂模式 多了一个 导演者（Director）的角色。如果忽略 导演者，那么 建造者模式 与 工厂模式 几乎是一样的。那么 导演者 的出现究竟有什么含义呢？

从上文 建造者模式 UML 类图中可以看到，导演者 是负责沟通 客户 与 具体建造者 的桥梁，也就是说，导演者 解耦了 客户 与 具体建造者。因为 具体建造者 属于细节实现，是底层模块，业务经常变换，不稳定；而 客户 属于上层模块，是业务逻辑部分，相对稳定；如果不设置 导演者 作为中间人，直接把 具体建造者 嵌入到业务逻辑（客户）中，会导致当业务改变（产品改变）时，需要更换 具体建造者，侵入了业务逻辑（客户）代码，不符合设计模式的迪米特法则。

而 工厂模式 之所以没有 导演者 这个角色，是因为 工厂 本身就担当了该角色。因为 导演者 最终的作用就是提供一个组装好的对象给到 客户，与 工厂 的作用一致。只是由于 工厂 生产的都是简单对象，因此 工厂 直接提供给 客户 就行了；而 建造者模式 提供的是复杂对象，需要专门的构建过程，因此借助 导演者 去沟通 具体的建造者 构建出相应的复杂对象，然后由 导演者 返回给 客户。

代码展示

这里，假设我们（客户）想要盖一间房子，主要是盖卧室（bedroom）和厕所（toilet），我们希望可以盖不同的卧室和厕所。

为了简单，我们直接以大卧室，小卧室，大厕所，小厕所来表示卧室和厕所的不同。

使用 建造者模式 完成上述例子，代码如下：

• 首先，我们需要一个复杂产品类型。这里的产品就是房子：

class House {
    private String bedroom;
    private String toilet;

    void setBedroom(String bedroom) {
        this.bedroom = bedroom;
    }

    void setToilet(String toilet) {
        this.toilet = toilet;
    }

    public String toString() {
        return String.format("House[bedrrom:%s,toilet:%s]", this.bedroom, this.toilet);
    }
}

• 其次，我们需要抽象出盖房子的组装部分：

public interface IHouseBuilder {
    void buildBedromm();

    void buildToilet();

    House getHouse();
}

• 然后，来一个具体建造者（工人），这里我们构建一个小卧室，大厕所的房子：

class SamllBedroomBigToiletHouseBuilder implements IHouseBuilder {
    private House house = new House();

    @Override
    public void buildBedromm() {
        this.house.setBedroom("small");
    }

    @Override
    public void buildToilet() {
        this.house.setToilet("big");
    }

    @Override
    public House getHouse() {
        return this.house;
    }
}

• 最后，我们需要一个设计师（导演者），来设计一个房子，并让工人（建造者）按照他的要求建造房子：

class Designer {
    //具体建造者：工人
    private IHouseBuilder builder = new SamllBedroomBigToiletHouseBuilder();

    House design() {
        //指导工人设计一个大卧室，小厕所的房子
        this.builder.buildBedromm();
        this.builder.buildToilet();
        return builder.getHouse();
    }
}

• 现在，假设客户想要建造一个小卧室，大厕所的房子，那么设计师（导演者）就应当指导工人 （建造者）去建造：

public class Client {
    public static void main(String[] args) {
        //首先，客户需要一个设计师（导演者）
        Designer designer = new Designer();
        //设计师设计房子
        House house = designer.design();
        System.out.println(house); 
    }
}

结果：House[bedrrom:small,toilet:big]

可以看到，我们已经成功创建出一个小卧室，大厕所的房子了。

如果我们想设计另一种房子（比如大卧室，小厕所），那么我们只需改变 具体建造者 就行了。

静态内部类实现 建造者模式

事实上，在平常的代码中，我们通常都会忽略对象的复杂性，使用 工厂模式 创建对象，而不是 建造者模式。正如上文所讲，工厂模式 和 建造者模式 的作用都是用于创建一个产品对象，而 工厂模式 结构更加简洁直接（没有 Builder 和 Director），因此更常使用。

而 建造者模式，我们更加习惯使用 静态内部类 的方式进行实现，即一个 产品类 内部自动带有一个 具体建造者（Concrete Builder），由它负责该产品的组装创建。不再需要 抽象建造者（Builder） 和 导演者（Director），这样，使得产品与构建之间的联系更加紧密，结构更加紧凑，同时使得 建造者模式 形式更加简洁。

当我们采用 静态内部类 形式实现 建造者模式 时，上文中的例子就可以改写为如下：

• 首先需要有一个产品类（House），其内部维护一个 建造者：

class House {
    private String bedroom;
    private String toilet;

    public String toString() {
        return String.format("House[bedrrom:%s,toilet:%s]", this.bedroom, this.toilet);
    }

    public static class Builder {
        private House house = new House();

        public Builder setBedroom(String bedroom) {
            this.house.bedroom = bedroom;
            return this;
        }

        public Builder setToilet(String toilet) {
            this.house.toilet = toilet;
            return this;
        }

        public House build(){
            return this.house;
        }
    }
}

• 其次，来一个工厂类，封装产品的构建过程，解耦业务逻辑：

class HouseFactory {
    private HouseFactory() {
    }

    //构建一个小卧室，大厕所的房子
    static House getSmallBedroomBigToiletHouse() {
        return new House.Builder().setBedroom("small").setToilet("big").build();
    }
}

• 最后，客户直接盖房子：

public class Client {
    public static void main(String[] args) {
        //客户说：工程队，直接给我盖一个小卧室，大厕所的房子
        House house = HouseFactory.getSmallBedroomBigToiletHouse();
        System.out.println(house);
    }
}

上面的代码我们采用 简单工厂模式 生产一个 具体建造者，解耦了 客户 与 具体建造者 的耦合。 简单工厂模式 负责生产 Builder 对象，而 Builder 采用 建造者模式 生产复杂产品。两者结合，进一步解耦了业务逻辑与业务实现的耦合。