Java设计模式之创建型模式-建造者模式（Builder）

　　最近情绪有点低落，所以学习的效率也不是很高。写这篇文章也有点磨磨蹭蹭，有什么问题还请多担待。
　　废话也不多说了，今天就来讲讲另一种创建型模式－建造者模式。
　　

建造者模式： 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

四个要素

1. 产品类： 既可以是具体实现，也可以是抽象类与其具体实现组成。
2. 抽象建造者: 抽象接口或者类，将具体实现过程交给子类，易扩展。
3. 具体建造者： 实现抽象接口（抽象建造者），构建产品。
4. 指挥者： 调用合适的建造者来构建产品。

实现过程

最近自己的笔记本老是动不动就罢工，心心念想换台mac，无奈负债累累。虽然买不起，但我用来举例子还是可以的（以下价格纯属虚构）。

　　首先创建一个具体的产品类 MacPro

public class MacPro {

    private List parts = new ArrayList<>();
    private List prices = new ArrayList<>();

    public void addPart(String part) {
        parts.add(part);
    }

    public void addPrice(Double price) {
        prices.add(price);
    }

    public void showMacPro() {
        System.out.print("config info：");
        for (String part : parts) {
            System.out.print(part + " ");
        }
        System.out.print("\nprice:");
        Double total = 0d;
        for (Double price : prices) {
            total += price;
        }
        System.out.println(total);
    }
}

　　再者建立一个为了方便扩展的抽象建造者类 Builder

public interface Builder {
    void buildProcessor();
    void buildMemory();
    void buildStorage();
    void buildBar();
    MacPro getResult();
}

　　然后依次建立所需要的具体的建造者类，我这里就写两个例子MacProFirstBuilde、MacProSecondBuilder

public class MacProFirstBuilder implements Builder{

    private MacPro macPro = new MacPro();

    @Override
    public void buildProcessor() {
        macPro.addPart("i5");
        macPro.addPrice(1500d);
    }

    @Override
    public void buildMemory() {
        macPro.addPart("8GB");
        macPro.addPrice(400d);
    }

    @Override
    public void buildStorage() {
        macPro.addPart("128GB");
        macPro.addPrice(1500d);
    }

    @Override
    public void buildBar() {
        macPro.addPart("with Bar");
        macPro.addPrice(1200d);
    }

    @Override
    public MacPro getResult() {
        return macPro;
    }

}

public class MacProSecondBuilder implements Builder {

    private MacPro macPro = new MacPro();

    @Override
    public void buildProcessor() {
        macPro.addPart("i7");
        macPro.addPrice(1800d);
    }

    @Override
    public void buildMemory() {
        macPro.addPart("16GB");
        macPro.addPrice(1000d);
    }

    @Override
    public void buildStorage() {
        macPro.addPart("256GB");
        macPro.addPrice(2800d);
    }

    @Override
    public void buildBar() {
        macPro.addPart("non Bar");
        macPro.addPrice(0d);
    }

    @Override
    public MacPro getResult() {
        return macPro;
    }

}

　　最后，写个指挥者类 Director 来调用建造者构建产品

public class Director {

    public void construct(Builder builder) {
        builder.buildProcessor();
        builder.buildMemory();
        builder.buildStorage();
        builder.buildBar();
    }
}

　　写个测试类 BuilderTest

public class BuilderTest {

    public static void main(String[] args) {
        Director d = new Director();
        MacProFirstBuilder mpfb = new MacProFirstBuilder();
        MacProSecondBuilder mpsb = new MacProSecondBuilder();

        d.construct(mpfb);
        mpfb.getResult().showMacPro();

        d.construct(mpsb);
        mpsb.getResult().showMacPro();
    }
}

　　运行的结果如下:

config info：i5 8GB 128GB with Bar 
price:4600.0
config info：i7 16GB 256GB non Bar 
price:5600.0

优点

通过上述代码，可以发现：
1. 易扩展： 拥有抽象的建造者，且具体的建造者之间是相互独立的。在增加新的需求时，通过增加一个具体的建造者类就可以达到目的。
2. 细节风险可控： 对扩展开放，对修改关闭，基本上不用修改之前测试通过的代码，对原功能就不会引入风险。

缺点

　　当所构建的产品内部复杂变化的时候，就会有很多的建造类。

与工厂模式的区别

　　从大体上看，建造者模式与工厂模式还是比较相似的。
　　有区别的是，工厂模式中对象的所有创建过程封装在工厂类当中，且由工厂类向客户端提供最终的产品；而在建造者模式当中，具体的建造过程是交付给指挥者类来实现的，具体的建造者类一般只是负责产品类各个部件的构造，指挥者类将这些部件按规则组成产品交付给客户端。