设计模式之建造者模式

8 建造者模式

8.1 建造者模式简单概述

场景引入：

没有人买车会只买一个轮胎或者方向盘，大家买的都是一辆包含轮胎、方向盘和发动机等多个部件的完整汽车。

如何将这些部件组装成一辆完整的汽车并返回给用户，这是建造者模式需要解决的问题。

建造者模式又称为生成器模式，它是一种较为复杂、使用频率也相对较低的创建型模式。

建造者模式为客户端返回的不是一个简单的产品，而是一个由多个部件组成的复杂产品。

概念：

建造者模式是较为复杂的创建型模式，它将客户端与包含多个组成部分（或部件）的复杂对象的创建过程分离，客户端无须知道复杂对象的内部组成部分与装配方式，只需要知道所需建造者的类型即可。

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

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

8.2 建造者模式代码实现

需求：

建房子的例子，假设建房子有三个固定步骤，打地基、砌墙、封顶，房子类型多种多样，普通房子、高级房子、别墅…

• 房子模型

public class House {
    private String base;
    private String wall;
    private String roofed;

    public House() {
    }

    public House(String base, String wall, String roofed) {
        this.base = base;
        this.wall = wall;
        this.roofed = roofed;
    }

    public String getBase() {
        return base;
    }

    public void setBase(String base) {
        this.base = base;
    }

    public String getWall() {
        return wall;
    }

    public void setWall(String wall) {
        this.wall = wall;
    }

    public String getRoofed() {
        return roofed;
    }

    public void setRoofed(String roofed) {
        this.roofed = roofed;
    }

    @Override
    public String toString() {
        return "House{" +
                "base='" + base + '\'' +
                ", wall='" + wall + '\'' +
                ", roofed='" + roofed + '\'' +
                '}';
    }
}

• 抽象的建造者

// 抽象的建造者
public abstract class HouseBuilder {
    protected House house = new House();

    // 将建造的流程写出来
    public abstract void builderBasic();

    public abstract void builderWall();

    public abstract void Roofed();

    // 建造房子,将产品返回
    public House builderHouse() {
        return house;
    }
}

• 具体的房子类型

// 普通房子
public class CommHouse extends HouseBuilder {

    @Override
    public void builderBasic() {
        System.out.println("普通房子打地基---5M");
    }

    @Override
    public void builderWall() {
        System.out.println("普通房子砌墙---5M");
    }

    @Override
    public void Roofed() {
        System.out.println("普通房子屋顶建造");
    }
}

// 高级房子
public class HeightHouse extends HouseBuilder{


    @Override
    public void builderBasic() {
        System.out.println("高级房子打地基--20M");
    }

    @Override
    public void builderWall() {
        System.out.println("高级房子砌墙--20M");
    }

    @Override
    public void Roofed() {
        System.out.println("高级房子盖屋顶");
    }
}

• 包工头

// 指挥者动态指定制作流程，返回产品
public class HouseDirector {
    HouseBuilder houseBuilder = null;

    // 构造器传入
    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    // 通过setter  传入HouseBuilder
    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    // 如何处理建造房子的流程，交给指挥者
    public House constructHouse() {
        houseBuilder.builderBasic();
        houseBuilder.builderWall();
        houseBuilder.Roofed();
        return houseBuilder.builderHouse();
    }
}

• 客户端

public class Client {
    public static void main(String[] args) {
        //盖普通房子
        CommHouse commHouse = new CommHouse();
        //准备创建房子的指挥者
        HouseDirector houseDirector = new HouseDirector(commHouse);
        //完成盖房子，返回产品(普通房子)
        House house = houseDirector.constructHouse();
        //System.out.println("输出流程");
        System.out.println("--------------------------");
        //盖高楼
        HeightHouse highBuilding = new HeightHouse();
        //重置建造者
        houseDirector.setHouseBuilder(highBuilding);
        //完成盖房子，返回产品(高楼)
        houseDirector.constructHouse();
    }
}

8.3 建造者模式总结

1、主要优点

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

2、主要缺点

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

3、适用场景

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