《设计模式》建造者模式

《设计模式》设计模式的基本原则
《设计模式》单例模式
《设计模式》工厂模式
《设计模式》原型模式
《设计模式》建造者模式
《设计模式》适配器模式
《设计模式》桥接模式
《设计模式》装饰者模式
《设计模式》组合模式
《设计模式》外观模式
《设计模式》享元模式
《设计模式》代理模式
《设计模式》模板方法模式
《设计模式》命令模式

• 建造者模式又叫生成器模式，是一种对象构建模式。它可以将复杂对象的建造过程抽象出来（抽象类别），使这个抽象过程的不同实现方法可以构造出不同表现（属性）的对象。
• 建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。

建造者模式的四个角色：

• Product(产品角色)：一个具体的产品对象
• Builder(抽象建造者)：创建一个 Product 对象的各个部件指定的接口/抽象类
• ConcreteBuilder(具体建造者)：实现接口，构建和装配各个部件
• Director(指挥者)：构建一个使用 Builder 接口的对象，它主要用于创建一个复杂的对象，有两个作用：1. 隔离了客户与对象的生产过程 2. 负责控制产品对象的生产过程。

建造者模式的注意事项：

• 客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象
• 将复杂产品的创建步骤分解在不同的方法中，使得创建过程更为清晰，可以更精细地控制创建产品的过程
• 增加新的具体建造者无需修改原有类库代码，指挥者针对抽象建造者类编程，系统扩展方便符合开闭原则
• 建造者模式所创建的产品一般都具有较多的共同点，如果产品之间的差异性很大则不适合使用建造者模式，因此其使用范围受到限制
• 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者来实现这种变化，导致系统变得很庞大，因此这种情况下考虑是否还要选择建造者模式

建造者模式原理 UML 类图如下所示：

现在有一个盖房子的项目，需求如下：

• 盖房过程为打桩、砌墙、封顶
• 房子的类型很多，如普通房、高楼、别墅
• 各种类型的房子建造过程虽然相同，但是具体的要求不一样

传统的思维方式分析该项目，其 UML 图如下所示：

AbstractHouse 类

public abstract class AbstractHouse {
    public abstract void buildBasic();
    public abstract void buildWalls();
    public abstract void roofed();

    public void build() {
        buildBasic();
        buildWalls();
        roofed();
    }
}

CommonHouse 类

public class CommonHouse extends AbstractHouse{
    @Override
    public void buildBasic() {
        System.out.println("普通房子打地基");
    }

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

    @Override
    public void roofed() {
        System.out.println("普通房子封顶");
    }
}

Client 类

public class Client {
    public static void main(String[] args) {
        CommonHouse commonHouse = new CommonHouse();
        commonHouse.build();
    }
}

传统方式实现简单易于操作，但是由于过于简单没有设计缓存层对象，也就是说将房子和建房子的过程封装在了一起，增加了耦合性，导致程序的扩展性和维护性不是很好。

因此，使用建造者模式的设计思想，将房子和建房子的过程解耦，其 UML 类图如下所示：

House 类

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

    public String getBasic() {
        return basic;
    }

    public void setBasic(String basic) {
        this.basic = basic;
    }

    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;
    }
}

HouseBuilder 类

public abstract class HouseBuilder {
    protected House house = new House();

    public abstract void buildBasic();
    public abstract void buildWalls();
    public abstract void roofed();

    public House buildHouse() {
        return house;
    }
}

CommonHouse 类

public class CommonHouse extends HouseBuilder{
    @Override
    public void buildBasic() {
        System.out.println("普通房子打地基5米");
    }

    @Override
    public void buildWalls() {
        System.out.println("普通房子砌墙10公分");
    }

    @Override
    public void roofed() {
        System.out.println("普通房子封顶");
    }
}

HighBuilding 类

public class HighBuilding extends HouseBuilder{
    @Override
    public void buildBasic() {
        System.out.println("高楼打地基100米");
    }

    @Override
    public void buildWalls() {
        System.out.println("高楼砌墙20公分");
    }

    @Override
    public void roofed() {
        System.out.println("高楼封顶");
    }
}

HouseDirector 类

public class HouseDirector {
    HouseBuilder houseBuilder = null;

    public HouseDirector(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    public void setHouseBuilder(HouseBuilder houseBuilder) {
        this.houseBuilder = houseBuilder;
    }

    //房子的建造流程交给指挥者
    public House constructHouse() {
        houseBuilder.buildBasic();
        houseBuilder.buildWalls();
        houseBuilder.roofed();
        return houseBuilder.buildHouse();
    }
}

Client 类

public class Client {
    public static void main(String[] args) {
        CommonHouse commonHouse = new CommonHouse();
        HouseDirector houseDirector = new HouseDirector(commonHouse);
        houseDirector.constructHouse();
        System.out.println("--------------------------");
        HighBuilding highBuilding = new HighBuilding();
        houseDirector.setHouseBuilder(highBuilding);
        houseDirector.constructHouse();
    }
}

除此之外，建造者模式在 JDK 中也有应用，JDK 中的 StringBuilder 类：

• Appendable 接口定义多个 append 方法(抽象方法)，即 Appendable 为抽象建造者，定义了抽象方法
• AbstractStringBuilder 类实现了 Appendable 接口方法，这里的 AbstractStringBuilder 已经是建造者，但是不能实例化
• StringBuilder 既充当了指挥者角色又充当了具体的建造者，建造方法的实现是由 AbstractStringBuilder 完成，而 StringBuilder 继承了 AbstractStringBuilder