设计模式（三）------ 建造者模式

一、建造模式的本质

1、分离了对象子组件的单独构造（由Builder来负责）和装配（由Director负责）。从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况。

　　由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以作出不同的对象；相同的构建器，不同相同的装配顺序，也可以作出不同的对象；也就是实现了构建算法、装配算法的解耦，实现了更好的复用。

2、建造模式分成两个很重要的部分：
　　1. 一个部分是Builder接口，这里是定义了如何构建各个部件，也就是知道每个部件功能如何实现，以及如何装配这些部件到产品中去；
　　2. 另外一个部分是Director，Director是知道如何组合来构建产品，也就是说Director负责整体的构建算法，而且通常是分步骤地来执行。
　　不管如何变化，建造模式都存在这么两个部分，一个部分是部件构造和产品装配，另一个部分是整体构建的算法。认识这点是很重要的，因为在建造模式中，强调的是固定整体构建的算法，而灵活扩展和切换部件的具体构造和产品装配的方式。
　　再直白点说，建造模式的重心在于分离构建算法和具体的构造实现，从而使得构建算法可以重用。具体的构造实现可以很方便地扩展和切换，从而可以灵活地组合来构造出不同的产品对象。

二、建造者模式

1、构成产品的组件

public class Engine  //发动机
{
    private String name;
    public Engine(String name)
    {
        this.name = name;
    }
    // getter、setter方法省略
}

public class OrbitalModel //轨道舱
{
    private String name;
    public OrbitalModel(String name)
    {
        this.name = name;
    }

    // getter、setter方法省略
}

public class EscapeTower //逃逸塔
{
    private String name;
    public EscapeTower(String name)
    {
        this.name = name;
    }
    // getter、setter方法省略
}

2、产品

public class AirShip //宇宙飞船
{
    private OrbitalModel orbitalModel; //轨道舱
    private Engine engine;       //发动机
    private EscapeTower escapeTower;  //逃逸塔

    // 产品的其他操作方法

    //  getter、setter方法省略
}

3、构建者的接口（构建所有组件）

public interface AirShipBuilder
{
    Engine builderEngine();
    OrbitalModel builderOrbitalModel();
    EscapeTower builderEscapeTower();
}

4、装配者的接口（装配宇宙飞船的各个组件）

public interface AirShipDirector
{
    // 组装飞船对象
    AirShip directAirShip();
}

5、构建者的具体实现类

public class MyAirShipBuilder implements  AirShipBuilder
{
    @Override
    public Engine builderEngine()
    {
        System.out.println("构建发动机");
        return new Engine("自己的发动机"); //可以搭配工厂模式
    }

    @Override
    public OrbitalModel builderOrbitalModel()
    {
        System.out.println("构建轨道舱");
        return new OrbitalModel("自己的轨道舱");
    }

    @Override
    public EscapeTower builderEscapeTower()
    {
        System.out.println("构建逃逸塔");
        return new EscapeTower("自己的逃逸塔");
    }
}

6、装配者的具体实现类

public class MyAirShipDirector implements AirShipDirector
{
    private AirShipBuilder builder; //构建者
    public MyAirShipDirector(AirShipBuilder builder)
    {
        this.builder = builder;
    }

    @Override
    public AirShip directAirShip()
    {
        Engine engine = builder.builderEngine();  //根据构建者获取到组件
        OrbitalModel orbitalModel = builder.builderOrbitalModel();
        EscapeTower escapeTower = builder.builderEscapeTower();

        // 装配组件
        AirShip airShip = new AirShip();
        airShip.setEngine(engine);
        airShip.setOrbitalModel(orbitalModel);
        airShip.setEscapeTower(escapeTower);
        return airShip;
    }
}

7、Client测试类

public class Cilent
{
    public static void main(String[] args)
    {
        AirShipBuilder builder = new MyAirShipBuilder();
        AirShipDirector director = new MyAirShipDirector(builder);

        AirShip airShip = director.directAirShip();
        System.out.println(airShip.getEngine().getName());
    }
}

三、模式优缺点

优点

1、将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，使得我们能够更加精确的控制复杂对象的产生过程。

2、将产品的创建过程与产品本身分离开来，可以使用相同的创建过程来得到不同的产品。也就说细节依赖抽象。

3、每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。

缺点

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