场景

建造一个复杂的产品
实际开发中，我们构建的对象非常复杂时

建造模式的本质

分离了对象子组件的单独构造（由Builder来负责）和装配（由Director负责），从而构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况下使用。
由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；相同的购建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。

白话解析

我们建造一个非常复杂的产品，比如说宇宙飞船时，为了在构建和组装飞船的时候‘不缺胳膊少腿’，我们需要将一个产品的内部表象和产品的生产过程分割（分批行动，较为稳妥），具体分为两步：

构建很多零件（Builder）
把零件组装起来（Director）

代码示例

生成实体类

先将宇宙飞船抽象化，假设有轨道舱，发动机和逃逸塔等部分，我们先定义实体类

/**
 * 宇宙飞船 实体类
 */
public class AirShip {
    private OrbitalModule orbitalModule;  //轨道舱
    private Engine engine;   //发动机
    private EscapeTower escapeTower;  //逃逸塔


    /**
     * 发动机
     */
    public void launch(){
        System.out.println("我是发动机");
    }

    public AirShip(){

    }
    public AirShip(OrbitalModule orbitalModule, Engine engine, EscapeTower escapeTower) {
        this.orbitalModule = orbitalModule;
        this.engine = engine;
        this.escapeTower = escapeTower;
    }

    public OrbitalModule getOrbitalModule() {
        return orbitalModule;
    }

    public void setOrbitalModule(OrbitalModule orbitalModule) {
        this.orbitalModule = orbitalModule;
    }

    public Engine getEngine() {
        return engine;
    }

    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    public EscapeTower getEscapeTower() {
        return escapeTower;
    }

    public void setEscapeTower(EscapeTower escapeTower) {
        this.escapeTower = escapeTower;
    }
}

/**
 * 轨道舱
 */
class OrbitalModule{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public OrbitalModule(String name) {
        this.name = name;
    }
}

/**
 * 发动机
 */
class Engine{
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Engine(String name) {
        this.name = name;
    }
}

/**
 * 逃逸舱
 */
class EscapeTower{
    private String name;

    public EscapeTower(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

构建零件

定义完实体类（此处我理解为：画好图纸）以后，我们开始构建对应的组件，即建造发动机、轨道舱、逃逸塔。此处定义了接口和实现类，便于扩展和维护。

/**
 * 构造方法
 * 构建子组件
 */
public interface AirShipBuilder {
    /**
     * 构建发动机
     * @return
     */
    Engine builderEngine();

    /**
     * 构建轨道舱
     * @return
     */
    OrbitalModule builderOrbitalModule();

    /**
     * 构建逃逸塔
     * @return
     */
    EscapeTower builderEscapeTower();
}



/**
 * 构建者实现类
 */
public class AirShipBuilderImpl implements AirShipBuilder {
    @Override
    public Engine builderEngine() {
        System.out.println("我是发动机");
        return new Engine("发动机");
    }

    @Override
    public OrbitalModule builderOrbitalModule() {
        System.out.println("我是轨道舱");
        return new OrbitalModule("轨道舱");
    }

    @Override
    public EscapeTower builderEscapeTower() {
        System.out.println("我是逃逸舱");
        return new EscapeTower("逃逸舱");
    }
}

装配

呐，如果我们是建宇宙飞船的指挥者，那我们就可以站在零件生产完毕后，指挥将他们安装一定规则组装。这样，就不会出错了。


/**
 * 装配(组装)
 */
public interface AirShipDirector {
    /**
     * 组装宇宙飞船
     * @return
     */
    AirShip directAirship();
}



/**
 * 装配者实现
 */
public class AirShipDirectorImpl implements AirShipDirector {

    private AirShipBuilder airShipBuilder;

    public AirShipDirectorImpl (AirShipBuilder airShipBuilder){
        this.airShipBuilder = airShipBuilder;
    }
    @Override
    public AirShip directAirship() {
        Engine e = airShipBuilder.builderEngine();
        OrbitalModule o =  airShipBuilder.builderOrbitalModule();
        EscapeTower et = airShipBuilder.builderEscapeTower();
        AirShip airShip = new AirShip();
        airShip.setEngine(e);
        airShip.setEscapeTower(et);
        airShip.setOrbitalModule(o);
        return airShip;
    }
}

调用


/**
 * 调用者
 * 建造者模式
 */
public class Client {
    public static void main(String[] args) {
        AirShipDirector director = new AirShipDirectorImpl(new AirShipBuilderImpl());
        AirShip airShip = director.directAirship();
        airShip.launch();
    }
}

uml 类图

开发中应用场景：

StringBuilder 类的append 方法
Sql中的PreparedStatement
JDOM中，DomBulider、SAXBuilder

在实际应用中，可以和和工厂模式搭配.先用工厂模式构建零件，再用建造者模式装配

注：该博文为学习总结，视频来源为高淇java300集