建造者模式

假如我们要创建一个复杂的产品，比如手机，飞船。这些产品由很多的组件装配而成。 

建造者模式：

        分离对象子组件的单独结构（Builder负责）和装配（Director负责），从而构件复杂的对象。实现了构造与装配的解耦。

注释：OrbitalModule（轨道舱），Engine（发动机），EscapeTower（逃逸塔）三组件。 

AirShipBuilder（飞船建造器），AirShipDirector（飞船装配器），AirShip（飞船）。

1.飞船模型及其组件模型：

public class AirShip {
    private OrbitalModule orbitalModule;
    private Engine engine;
    private EscapeTower escapeTower;

    public void launch(){
        System.out.println(orbitalModule.getName()+"+"+
        engine.getNaem()+"+"+escapeTower.getName()+"的火箭，发射");
    }

    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 OrbitalModule() {
    }

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

    public String getName() {
        return name;
    }

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

/**
 * 发动机类
 */
class Engine{
    private String naem;

    public Engine() {
    }

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

    public String getNaem() {
        return naem;
    }

    public void setNaem(String naem) {
        this.naem = naem;
    }
}

/**
 * 逃逸仓类
 */
class EscapeTower{
    private String name;

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

    public EscapeTower() {
    }

    public String getName() {
        return name;
    }

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

2.飞船组件建造器，MyAirShipBuilder类及其接口：

public interface AirShipBuilder {
    OrbitalModule builderOrbitalModule();
    Engine builderEngine();
    EscapeTower builderEscapeTower();
}

public class MyAirShipBuilder implements AirShipBuilder{
    @Override
    public OrbitalModule builderOrbitalModule() {
        return new OrbitalModule("轨道舱");
    }

    @Override
    public Engine builderEngine() {
        return new Engine("发动机");
    }

    @Override
    public EscapeTower builderEscapeTower() {
        return new EscapeTower("逃逸塔");
    }
}

飞船建造器帮助飞船建造组件，可以理解为组件工厂，new 组件。

3.飞船装配器，MyAirShiDirector类及其接口：

/**
 * 组装飞船的装配者对象
 */
public interface AirShipDirector {
    AirShip createAirShip();
}

public class MyAirShiDirector implements AirShipDirector {
   /**
    *  用于存储对象的引用,MyAirShipBuilder向上转型（多态）
    */
    private AirShipBuilder builder;

    public MyAirShiDirector(AirShipBuilder builder) {
        this.builder = builder;
    }

    @Override
    public AirShip createAirShip() {
        OrbitalModule orbitalModule = builder.builderOrbitalModule();
        Engine engine = builder.builderEngine();
        EscapeTower escapeTower = builder.builderEscapeTower();
        //装配
        AirShip airShip=new AirShip();
        airShip.setOrbitalModule(orbitalModule);
        airShip.setEngine(engine);
        airShip.setEscapeTower(escapeTower);
        return airShip;
    }
}

将建造器建造好的组件装配到飞船模型上。

最后测试：

public class TestApp {
    public static void main(String[] args) {
        MyAirShiDirector myAirShiDirector = new MyAirShiDirector(new MyAirShipBuilder());
        AirShip airShip = myAirShiDirector.createAirShip();
        airShip.launch();
    }
}

结果：轨道舱+发动机+逃逸塔的火箭，发射

builderString,PreparedStatement,DomBuilder,SAXBuilder就是使用建造者模式