每日设计模式——建造者模式

建造者模式

建造者模式主要功能构建复杂的产品，而且是细化的，分步骤的构建产品，也就是建造者模式重在解决一步一步构造复杂对象的问题。更重要的是，这个构建过程是统一的，固定不变的，变化的部分放到生成器部分了，只要配置不同的生成器，那么同样的过程，就能构建出不同的产品来。建造者模式的通用类图如下：

在建造者模式中，有四个角色：Product产品类，Builder抽象建造者，ConcreateBuilder具体建造者和Director导演类。

产品类：通常是实现了模板方法模式。

抽象建造者类：规范产品组建，一般由子类实现。

具体建造者：实现抽象建造者定义的所有方法，并且返回一个组建好的对象。

导演类：负责安排已有模块的顺序，然后告诉Builder开始建造。

相关示例如下所示：

package com.designpattern.builder;

public class Test {

    public static void main(String[] args) {
        CarBuilder builder = new BMWCarBuilder();
        Director director = new Director(builder);
        Car car = director.getCar();
        System.out.println(car);

        builder = new ToyotaCarBuilder();
        director = new Director(builder);
        car = director.getCar();
        System.out.println(car);
    }
}

class Car {
    private String brand;
    private String wheel;
    private String engine;
    private String door;

    public Car(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getWheel() {
        return wheel;
    }

    public void setWheel(String wheel) {
        this.wheel = wheel;
    }

    public String getEngine() {
        return engine;
    }

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

    public String getDoor() {
        return door;
    }

    public void setDoor(String door) {
        this.door = door;
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", wheel='" + wheel + '\'' +
                ", engine='" + engine + '\'' +
                ", door='" + door + '\'' +
                '}';
    }
}

/**
 * 造车
 */
abstract class CarBuilder {
    /**
     * 造轮子
     */
    abstract void createWheel();

    /**
     * 造车门
     */
    abstract void createDoor();

    /**
     * 造引擎
     */
    abstract void createEngine();

    /**
     * 返回建好的Car
     *
     * @return
     */
    abstract Car getCar();
}

class BMWCarBuilder extends CarBuilder {

    Car car = new Car("BMW");

    @Override
    public void createWheel() {
        System.out.println("造宝马轮子");
        car.setWheel("宝马轮子");
    }

    @Override
    public void createDoor() {
        System.out.println("造宝马车门");
        car.setDoor("宝马车门");
    }

    @Override
    public void createEngine() {
        System.out.println("造宝马引擎");
        car.setEngine("宝马引擎");
    }

    @Override
    Car getCar() {
        return car;
    }

}

class ToyotaCarBuilder extends CarBuilder {
    Car car = new Car("Toyato");

    @Override
    public void createWheel() {
        System.out.println("造丰田轮子");
        car.setWheel("丰田轮子");
    }

    @Override
    public void createDoor() {
        System.out.println("造丰田车门");
        car.setDoor("丰田车门");
    }

    @Override
    public void createEngine() {
        System.out.println("造丰田引擎");
        car.setEngine("丰田引擎");
    }

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


class Director {
    private CarBuilder bulider;

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

    public Car getCar() {
        bulider.createEngine();
        bulider.createWheel();
        bulider.createDoor();
        return bulider.getCar();
    }
}

类图结构如下：

 

建造者模式的优点

使用建造者模式可以使客户端不必知道产品内部组成的细节，如例子中我们就没必要知道一辆具体的车是如何建造出来的，只需要知道产生的对象类型就是Car就行。 

建造者独立，容易扩展，BMWCarBuilder和ToyotaCarBuilder相互独立，假如现在需要创建一辆玛莎拉蒂的车，系统扩展也非常容易，只需要新建一个玛莎拉蒂的创建者类并继承CarBuilder类即可。

便于控制细节风险，由于具体点的建造者是相互独立的，因此可以对建造过程逐步细化，而不对其他模块产生影响。

建造者模式使用场景

1.相同的方法，不同的执行顺序，产生不同的事件结果时，可采用建造者模式；

2.多个部件或者零件，都可以装配到一个对象中，但是产生的结果又不相同时，可以使用建造者模式；

3.产品类非常复杂，或者产品中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适；