5、建造者模式

5.1 介绍

• 建造者模式（Builder）又称为生成器模式，主要用于对复杂对象的构建、初始化
  • 它可以将多个简单的组件对象按顺序一步步组装起来，最终构建成一个复杂的成品对象
• 所构建的对象一定是庞大而复杂的，并且一定是按照既定的制造工序将组件组装起来的。我们通常将负责构建这些大型对象的工程师称为建造者
• 建造者模式的主要目的在于把烦琐的构建过程从不同对象中抽离出来，使其脱离并独立于产品类与工厂类
  • 最终实现用同一套标准的制造工序能够产出不同的产品
• 测试类文件
  

5.2 建造步骤的重要性

• 建造者面对着什么样的产品模型
  • 玩家选定角色后需要对其进行初始化，假设整个过程分3个步骤完成
    • 第一步，玩家需要为角色选择形象以及分配力量、灵力、体力、敏捷等属性值
    • 第二步，玩家可以为角色配备不同的衣服或铠甲，低于所需力量值的铠甲则不能穿戴；
    • 第三步，玩家选择手持的武器与盾牌，它同上一步一样需要满足一定的条件
  • 成型的游戏角色是依靠角色对象、装备对象组装而成的，对于这种复杂对象的构建一定要依赖建造者来完成
  • 建造者的制造过程不仅要分步完成，还要按照顺序进行
• 建造者的各制造步骤与逻辑都应该被抽离出来独立于数据模型
• 复杂的游戏角色设定还需交给专业的建造团队去完成

5.3 地产开发商的困惑

• 严谨的设计与施工流程的把控
• 建筑物本身应该由多个组件组成，且各组件按一定工序建造，缺一不可
• 为了简化其数据模型，我们将组成建筑物的模块归纳为3个组件，分别是地基、墙体、屋顶，将它们组装起来就能形成一座建筑物
  • 以List承载各组件，模拟复杂对象中各组件的顺序组装
  • 分别定义各组件对应的建造方法
  • 用字符串对象String来模拟各个组件对象
  • 重写了toString()方法，按从大到小的组件索引顺序组装各组件，后组装的组件应先展示出来，如屋顶应该首先输出

package builder.entity;

import java.util.ArrayList;
import java.util.List;

/**
 * 数据模型-建筑物类
 **/
public class Building {

    /**
     * 用list来模拟建筑物组件的组装
     *      以List承载各组件，模拟复杂对象中各组件的顺序组装
     */
    private List<String> buildingComponents = new ArrayList<>();


    // 地基
    public void setBasement(String basement) {
        this.buildingComponents.add(basement);
    }

    // 墙体
    public void setWall(String wall) {
        this.buildingComponents.add(wall);
    }

    // 屋顶
    public void setRoof(String roof) {
        this.buildingComponents.add(roof);
    }


    /**
     * 重写了toString()
     *      按从大到小的组件索引【顺序】组装各组件，后组装的组件应先展示出来，如屋顶应该首先输出
     * @return
     */
    @Override
    public String toString() {
        String buildingStr = "";
        for (int i = buildingComponents.size() -1; i >= 0; i--) {
            buildingStr += buildingComponents.get(i);
        }

        return buildingStr;
    }
}

• 下一步思考
  • 怎样才能用这个复杂的类构建出一个房子对象呢？
  • 首先应该调用哪个建造方法才能保证正确的建造工序，而不至于屋顶在下面，地基却跑到天上去呢
  • 地基、墙体、屋顶，这些组件都去哪里找，如何建造？

5.4 建筑施工方

• 开发商规定施工方都应该至少具备三大组件的建造能力，于是施工标准公布
  • 施工方接口Builder:规定了3个施工标准, 具备三大组件的建造能力
  • 别墅施工方类HouseBuilder
  • 多层公寓施工方类ApartmentBuilder

package builder;

import builder.entity.Building;

/**
 * 施工方接口: 规定了3个施工标准, 具备三大组件的建造能力
 *         建造地基
 *         建造墙体
 *         建造屋顶
 *         获取建筑物，以供产品的交付
 **/
public interface Builder {

    /**
     * 建造地基
     */
    public void buildBasement();

    /**
     * 建造墙体
     */
    public void buildWall();

    /**
     * 建造屋顶
     */
    public void buildRoof();

    /**
     *  获取建筑物，以供产品的交付
     * @return
     */
    public Building getBuilding();
}

package builder.impl;

import builder.Builder;
import entity.Building;

/**
 *  别墅施工方类
 **/
public class HouseBuilder implements Builder {

    private Building house;

    public HouseBuilder() {
        house = new Building();
    }

    @Override
    public void buildBasement() {
        System.out.println("挖土方，部署管道、线缆，水泥加固，搭建围墙、花园。");
        house.setBasement("╬╬╬╬╬╬╬╬\n");
    }

    @Override
    public void buildWall() {
        System.out.println("搭建木质框架，石膏板封墙并粉饰内外墙。");
        house.setWall("｜田｜田 田|\n");
    }

    @Override
    public void buildRoof() {
        System.out.println("建造木质屋顶、阁楼，安装烟囱，做好防水。");
        house.setRoof("╱◥███◣\n");
    }

    @Override
    public Building getBuilding() {
        return house;
    }
}

package builder.impl;

import builder.Builder;
import builder.entity.Building;

/**
 * 多层公寓施工方类
 **/
public class ApartmentBuilder implements Builder {

    private Building apartment;

    public ApartmentBuilder() {
        apartment = new Building();
    }

    @Override
    public void buildBasement() {
        System.out.println("深挖地基，修建地下车库，部署管道、线缆、风道。");
        apartment.setBasement("╚═══════════╝\n");
    }

    @Override
    public void buildWall() {
        System.out.println("搭建多层建筑框架，建造电梯井，钢筋混凝土浇灌。");
        // 此处假设固定8层
        for (int i = 0; i < 8; i++) {
            apartment.setWall("║ □ □ □ □ ║\n");
       }
    }

    @Override
    public void buildRoof() {
        System.out.println("封顶，部署通风井，做防水层，保温层。");
        apartment.setRoof("╔═══════════╗\n");
    }

    @Override
    public Building getBuilding() {
        return apartment;
    }
}

5.5 工程总监

• 工程总监类Director: 指导施工，并把控整个施工流程

package builder;

import builder.entity.Building;

/**
 * 工程总监类: 指导施工，并把控整个施工流程
 **/
public class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void setBuilder(Builder builder) {
        this.builder = builder;
    }

    public Building direct() {
        System.out.println("=====工程项目启动=====");
        // 第一步，打好地基
        builder.buildBasement();
        // 第二步，建造框架、墙体
        builder.buildWall();
        // 第三步，封顶
        builder.buildRoof();
        System.out.println("=====工程项目竣工=====");
        return builder.getBuilding();
    }
}

• 从宏观上管理项目并指导整个施工队的建造流程
  • 依次调用施工方的打地基方法buildBasement()、建造墙体方法buildWall()及建筑物封顶方法buildRoof()，保证了建筑物自下而上的建造工序
  • 施工方是由外部注入的，所以工程总监并不关心是哪个施工方来造房子，更不关心施工方有什么样的建造工艺
  • 但他能保证对施工工序的绝对把控，也就是说，工程总监只控制施工流程
• 实际应用中的建造流程也许会更加复杂，且组装各个组件的流程有相对【固定】的逻辑，所以可以从施工方的建造方法中抽离出来并固化在director类中

5.6 项目实施

• 开发商客户端类Client: 组建了别墅施工队并安排给工程总监进行管理
  • 之后调用其指导方法拿到别墅产品
  • 开发商行将工程总监管理的施工队替换为多层公寓施工方
  • 最终拿到一栋八层公寓

package builder;

import builder.impl.ApartmentBuilder;
import builder.impl.HouseBuilder;

/**
 * 开发商客户端类: 组建了别墅施工队并安排=给工程总监进行管理
 **/
public class Client {
    public static void main(String[] args) {
        //组建别墅施工队
        Director director = new Director(new HouseBuilder());
        System.out.println(director.direct());

        //替换施工队，建造公寓
        director.setBuilder(new ApartmentBuilder());
        System.out.println(director.direct());
    }
}

• 工艺与工序
  • 施工方接口对施工标准的抽象化、标准化使建造者（施工方）的建造质量达到既定要求，且使各建造者的建造“工艺”能够个性化、多态化
  • 工程总监将*工作流程抽离出来独立于建造者，使建造“工序”得到统一把控

5.7 建造者模式的各角色定义

• Product（产品）：复杂的产品类，构建过程相对复杂，需要其他组件组装而成。如：建筑物类Building，需要地基、墙体、屋顶等组件组成。
• Builder（建造者）：建造者接口，定义了构成产品的各个组件的构建标准，通常有多个步骤。如：施工方接口Builder。
• ConcreteBuilder（建造者实现）：具体的建造者实现类，可以有多种实现，负责产品的组装但不包含整体建造逻辑，如：别墅施工方类HouseBuilder与多层公寓施工方类ApartmentBuilder
• Director（指导者）：持有建造者接口引用的指导者类，指导建造者按一定的逻辑进行建造。如：工程总监类Director。

5.8 建造者模式

• 复杂对象的构建显然需要专业的建造团队
• 建造标准的确立让产品趋向多样化
• 而建造工序则交由工程总监去全局把控
• 最终实现通过相同的构建过程生产出不同产品