设计模式之建造者模式

关于建造者模式，网上已经有很多比较完善的例子，这里为了完善自己对于设计模式的内容，再简单讲解一下吧，方便自己回顾，也为了设计模式专题不遗漏任何一个设计模式

基本介绍 :

建造者模式也叫做生成器模式，是一种用于构建对象的模式。它可以将复杂对象的构建过程抽象出来成为一个抽象类或者接口，是这个抽象的过程的不同实现方法可以构造出不同表现（具有不同属性）的子类或者实现类对象。

建造者模式是 一步一步创建 一个 复杂的对象 ，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部具体构建细节是怎么实现的.

包含角色：

Product(产品角色) 一个具体的产品对象

Builder(抽象建造者)  一个可以创建Product对象的各个零件的接口或者抽象类

ConcreteBuilder(具体建造者) Builder的实现类或者子类，用于具体细节地去创建Product对象的各个零件

Director （指挥者）内部会构建一个Builder实现类或者子类的对象，用于创建一个复杂的对象，其一是将用户与产品的生产过程进行隔离，其二是可以控制产品的生产过程

产品角色

public class CarProduct {

    private CarShell carShell;

    private Tire tire;

    private Engine engine;

    public CarShell getCarShell() {
        return carShell;
    }

    public CarProduct setCarShell(CarShell carShell) {
        this.carShell = carShell;
        return this;
    }

    public Tire getTire() {
        return tire;
    }

    public CarProduct setTire(Tire tire) {
        this.tire = tire;
        return this;
    }

    public Engine getEngine() {
        return engine;
    }

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

抽象建造者

public abstract class CarBuilder {

    protected abstract CarShell buildCarShell();

    protected abstract Tire buildTire();

    protected abstract Engine buildEngine();
}

具体建造者

public class ConcreteCarBuilder extends CarBuilder {
    @Override
    protected CarShell buildCarShell() {
        System.out.println("制造普通汽车外壳");
        return new CarShell();
    }

    @Override
    protected Tire buildTire() {
        System.out.println("制造普通汽车轮胎");
        return new Tire();
    }

    @Override
    protected Engine buildEngine() {
        System.out.println("制造普通汽车发动机");
        return new Engine();
    }
}

public class HighConcreteCarBuilder extends CarBuilder{
    @Override
    protected CarShell buildCarShell() {
        System.out.println("制造高配汽车外壳");
        return new CarShell();
    }

    @Override
    protected Tire buildTire() {
        System.out.println("制造高配汽车轮胎");
        return new Tire();
    }

    @Override
    protected Engine buildEngine() {
        System.out.println("制造高配汽车发动机");
        return new Engine();
    }
}

指挥者

public class Director {

    private CarBuilder carBuilder;

    public Director() {
    }

    public Director(CarBuilder carBuilder) {
        this.carBuilder = carBuilder;
    }

    public void setCarBuilder(CarBuilder carBuilder){
        this.carBuilder = carBuilder;
    }

    public CarProduct buildCarProduct(){
        //如何装配在这里实现，装配顺序也在这里
        CarShell carShell = carBuilder.buildCarShell();
        Engine engine = carBuilder.buildEngine();
        Tire tire = carBuilder.buildTire();
        CarProduct carProduct = new CarProduct();
        carProduct.setCarShell(carShell);
        carProduct.setEngine(engine);
        carProduct.setTire(tire);
        System.out.println("装配完毕");
        return carProduct;
    }
}

最后客户端调用

public class Client {
    public static void main(String[] args) {
        Director director = new Director(new ConcreteCarBuilder());
        director.buildCarProduct();
        Director director1 = new Director(new HighConcreteCarBuilder());
        director1.buildCarProduct();
    }
}

输出：

"C:\Program Files (x86)\Java\jdk1.8.0_101\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2018.3.3\lib\idea_rt.jar=54298:C:\Program Files\JetBrains\IntelliJ IDEA 2018.3.3\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files (x86)\Java\jdk1.8.0_101\jre\lib\charsets.jar;C:\Program Files (x86)\Java\jdk1.8.0_101\jre\lib\deploy.jar;C:\Program Files (x86)\Java\jdk1.8.0_101\jre\lib\ext\access-bridge-32.jar;C:\Program File
制造普通汽车外壳
制造普通汽车发动机
制造普通汽车轮胎
装配完毕
制造高配汽车外壳
制造高配汽车发动机
制造高配汽车轮胎
装配完毕
Process finished with exit code 0

优点: 客户端不必知道产品内部的组成细节，将产品与产品的创建过程解耦，使得相同的创建过程可以实现不同的具体产品， 每一个建造者相互独立,可以很方便替换原有建造者或者增加新的建造者，符合单一职能原则，指挥者使用聚合代替继承的方式去持有建造者，符合开闭原则和依赖倒置原则

建造者模式所创建的产品一般具有较多的共同特点，其组成部分相似，具有相似的组装步骤，如果产品之间的差异性很大，则不适合使用建造者模式。 如果产品的内部变化复杂，可能会导致定义多个具体的建造者去实现变化，导致系统变得很庞大，类的复杂度大大增加，这种情况也不适用建造者模式。

建造者模式和工厂模式区别：

建造者模式关注对象的创建过程或者步骤，而且必须是复杂对象，具有一定的构建步骤，这两点很关键

工厂模式关注创建不同类型的对象

总结：

我们需要在具体的场景去使用对应的设计模式，当我们不知道是否应该使用设计模式时，可以考虑一下不使用该设计模式有什么问题，使用该设计模式又有什么好处，两者比对，综合利弊去衡量使用设计模式