设计模式->建造者模式

建造者模式属于创建类模式中的一种，它主要由Director，Builder，Product，Client四个角色组成。我们接下来以一个汽车制造的例子来一个一个分析这四个角色的作用。如果有什么理解不到位的地方，望大神们多多交流沟通。

Client：客户角色，负责提交想要的汽车的要求，并负责接收创建好的汽车。

Product：产品角色，在本例中为汽车对象。其中包含汽车的各个属性细节。

Builder：建造者角色，负责产品的创建，在本例中负责制造汽车。

Director：指挥者角色，负责指挥。只发号施令，并不需要去参与制造汽车。

下面是代码实现：

public class Car {

    private String engine;//引擎
    private String tire;//轮胎
    private String seat;//座椅
    private String frame;//框架

    public String getEngine() {
        return engine;
    }

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

    public String getTire() {
        return tire;
    }

    public void setTire(String tire) {
        this.tire = tire;
    }

    public String getSeat() {
        return seat;
    }

    public void setSeat(String seat) {
        this.seat = seat;
    }

    public String getFrame() {
        return frame;
    }

    public void setFrame(String frame) {
        this.frame = frame;
    }
}

public class Director {

    public Car buildCar(Builder builder){
        builder.builderEngine();
        builder.builderFrame();
        builder.builderSeat();
        builder.builderTire();
        return builder.getCar();
    }
}

public abstract class Builder {
    public abstract void builderEngine();
    public abstract void builderTire();
    public abstract void builderSeat();
    public abstract void builderFrame();
    public abstract Car getCar();
}

public class CommonCarBuilder extends Builder {

    Car car = new Car();

    @Override
    public void builderEngine() {
        car.setEngine("普通引擎");
        System.out.println("安装了普通引擎");
    }

    @Override
    public void builderTire() {
        car.setTire("普通轮胎");
        System.out.println("安装了普通轮胎");
    }

    @Override
    public void builderSeat() {
        car.setSeat("普通座椅");
        System.out.println("安装了普通座椅");
    }

    @Override
    public void builderFrame() {
        car.setFrame("普通框架");
        System.out.println("安装了普通框架");
    }

    @Override
    public Car getCar() {
        return car;
    }
}

public class AdvancedCarBuilder extends Builder {

    Car car = new Car();

    @Override
    public void builderEngine() {
        car.setEngine("高级引擎");
        System.out.println("安装了高级引擎");
    }

    @Override
    public void builderTire() {
        car.setTire("高级轮胎");
        System.out.println("安装了高级轮胎");
    }

    @Override
    public void builderSeat() {
        car.setSeat("高级座椅");
        System.out.println("安装了高级座椅");
    }

    @Override
    public void builderFrame() {
        car.setFrame("高级框架");
        System.out.println("安装了高级框架");
    }

    @Override
    public Car getCar() {
        return car;
    }
}

public static void main(String args[]){
        CommonCarBuilder commonCarBuilder = new CommonCarBuilder();//普通汽车的要求
        AdvancedCarBuilder advancedCarBuilder = new AdvancedCarBuilder();//高级汽车的要求
        Director director = new Director();
        Car car1 = director.buildCar(commonCarBuilder);//指挥者按照客户要求发出命令
        Car car2 = director.buildCar(advancedCarBuilder);
    }

通过代码我们对整个工作流程有了大致的认识，现在假设我们并不知道所谓的建造者模式。我们平常会怎么样创建呢？

我们会覆写Car类的构造方法，让用户直接创建Car对象，代码如下：

Car(String engine, String tire, String seat, String frame){
        this.engine = engine;
        this.tire = tire;
        this.seat = seat;
        this.frame = frame;
}

public static void main(String args[]){
        Car car1 = new Car("普通引擎", "普通轮胎", "普通座椅", "普通框架");
        Car car2 = new Car("高级引擎", "高级轮胎", "高级座椅", "高级框架");
}

是不是一眼看上去我们平常用的代码更加简单呢？接下来我们就来分析一下建造者模式的优点和不足。

建造者模式将一个复杂对象的表示和构建分离，之所以这么做的原因是，在构建一个复杂对象的时候，由于该对象的中的各个部分可能是由比较麻烦的算法构成，同时各个部分可能会随着用户需求的变化而不断变化，但是整体上将各个部分组合起来的算法却相对稳定。

设想，我们假如不采用建造者模式，那我们每次更改都会在Car类中的构造方法中更改一大堆的东西，代码冗余度极高。而采用建造者模式后，提炼出四个对象，用户并不需要知道复杂对象的具体实现细节，体现了设计原则中的封装性。同时将复杂对象的构建工作交给Builder角色，使得Builder对象易于扩展。也便于控制细节风险，由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。