建造者模式

1.使用场景:
1.对象的建造非常复杂，需要很多的步骤处理。
2.构建过程的每一步都不是必须要执行的，但是建造出来的还是”同一个东西”，只是出来的产品有一些属性会稍微”弱”一些。
2.UML表示
在建造者模式中有如下的一些对象:
2.1 Builder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。
2.2 ConcreteBuilder：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。
2.3 Director：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
2.4 Product：要创建的复杂对象。

具体的UML示意图如下:

3.代码实现
这里我们通过组装一台汽车的例子，来理解这个设计模式：

首先是建造汽车的接口定义：

 

public interface CarBuilder {
    Engine buildEngine();
    Bettery buildbettery();
    Suspension buildSuspension();
}

装配零件的接口定义:

 

 

public interface CarDirector {
    Tesla createTesla();

}

Engine类:

 

 

public class Engine {
    private String power;

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

    public String getPower() {
        return power;
    }

    public void setPower(String power) {
        this.power = power;
    }
}

汽车类:

 

 

public class Tesla {
    private Engine engine;
    private Bettery bettery;
    private Suspension suspension;

    public Engine getEngine() {
        return engine;
    }

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

    public Bettery getBettery() {
        return bettery;
    }

    public void setBettery(Bettery bettery) {
        this.bettery = bettery;
    }

    public Suspension getSuspension() {
        return suspension;
    }

    public void setSuspension(Suspension suspension) {
        this.suspension = suspension;
    }
}

其他的几个汽车零部件代码的比较类似，这里省略。
下面是汽车的构建类:

 

 

public class TeslaBuilder implements CarBuilder {
    @Override
    public Engine buildEngine() {
        System.out.println("组装发动机中...");
        return new Engine("10000P");//实际使用中，这边通常和工厂模式搭配，通过工厂模式来返回一个对象
    }

    @Override
    public Bettery buildbettery() {
        System.out.println("安装电池中....");
        return new Bettery("1024");
    }

    @Override
    public Suspension buildSuspension() {
        System.out.println("安装悬挂中...");
        return new Suspension("112");
    }
}
最后是汽车的装配类，使用TeslaBuilder类中的build方法来进行装配。
public class TeslaDirector implements CarDirector {
    private TeslaBuilder teslaBuilder;

    public TeslaDirector(TeslaBuilder teslaBuilder) {
        this.teslaBuilder = teslaBuilder;
    }

    @Override
    public Tesla createTesla() {
        Engine e=teslaBuilder.buildEngine();
        Suspension s=teslaBuilder.buildSuspension();
        Bettery b=teslaBuilder.buildbettery();
        Tesla tesla=new Tesla();
        tesla.setBettery(b);
        tesla.setEngine(e);
        tesla.setSuspension(s);//看到没?一步一步装的
        return tesla;
    }
}

4.总结

 

建造者模式和前面讲的抽象工厂有点”像”,但本质是不一样的，建造者模式，它是通过一步一步的装配来完成对象的创建，而对于抽象工厂，这个装配的过程是不需要考虑的，它考虑的只是如何取不同的”原材料”然后组装成一个新东西。

 

项目链接:

https://github.com/MemoryExplosion/design_pattern_review/tree/master/src/java/builder