设计模式之建造者模式

建造者模式属于创建型设计模式，我们经常需要创建一些对象，这个对象是由一些基本的部分组成的，但是考虑到各种情况，这些具体的部分会经常的发生改变，但是组织这些部件的顺序等等是不容易的变化的，这点类似乎模板方法模式遇到的使用场景，模板方法侧重点在于定义一个基本的算法骨架，建造者模式侧重点在于灵活的变更具体部件的实现。类图如下：

有三个角色需要解释：
1.Director类（导演类）：维护一个Builder对象获取这些组件，这里定义组装顺序等等操作。不设计这些具体部件的实现。
2.Builder类（创建者）：定义需要创建的组件的抽象方法。
3.ConcreteBuilder (具体的创建者)：生产具体的部件实现。
接下来我就来举个建造者的例子：

// 需要构建的对象Car
class Car {
    private String wheel;
    private String engine;
    private String 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 getBrand() {
        return brand;
    }

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

    @Override
    public String toString() {
        return "Car [wheel=" + wheel + ", engine=" + engine + ", brand="
                + brand + "]";
    }

}

// 建造车的接口
abstract class BuildCar {
    // 定义具体的需要制造的部件
    abstract String getWheel();

    abstract String getEngine();

    abstract String getBrand();
}

// 建造者具体的实现类BMWBuild
class BMWBuild extends BuildCar {

    @Override
    String getWheel() {
        return "bmw wheel";
    }

    @Override
    String getEngine() {
        return "bmw engine";
    }

    @Override
    String getBrand() {
        return "bmw";
    }

}

// 建造者具体的实现类BenzBuild
class BenzBuild extends BuildCar {

    @Override
    String getWheel() {
        return "benz wheel";
    }

    @Override
    String getEngine() {
        return "benz engine";
    }

    @Override
    String getBrand() {
        return "benz brand";
    }

}

// 导演类，负责组装这些零部件的顺序等等工作
class Factory {
    // 维护一个建造者的抽象类（接口）
    private BuildCar builder;

    /*
     * Factory (BuildCar builder) { this.builder = builder; }
     */
    // 定义顺序
    public Car finishCar() {
        // 首先装轮胎
        Car car = new Car();

        car.setWheel(builder.getWheel());
        car.setEngine(builder.getEngine());
        car.setBrand(builder.getBrand());

        return car;
    }

    public BuildCar getBuilder() {
        return builder;
    }

    // 设置具体的建造者
    public void setBuilder(BuildCar builder) {
        this.builder = builder;
    }

}

测试：

        Factory factory = new Factory();

        factory.setBuilder(new BMWBuild());
        Car car = factory.finishCar();
        System.out.println(car);

        factory.setBuilder(new BenzBuild());
        car = factory.finishCar();
        System.out.println(car);

运行结果：

Car [wheel=bmw wheel, engine=bmw engine, brand=bmw]
Car [wheel=banz wheel, engine=benz engine, brand=benz brand]

我们如果有的新的具体组件的实现类，只需要增加新的类去集成实现Build即可。Director的组装顺序不需要改变，而且也不用改动原有的逻辑，符合开闭原则，也符合里氏替换原则。