Java构建者模式

当我们要是使用一个复杂的对象（构造起来相当的麻烦）的时候，我们希望不要去关心这个对象是怎么被构建的，那么我们就要使用构建者模式，把使用和构建的工作分开。

角色分析：

1. 抽象的构建者

2. 被构建者

3. 具体的构建者

以构建一辆车为例：

首先我们需要定义规范，定义一样汽车如何构建：

public interface CarBuilder {

    void buildEngine();

    void buildWheel();

    void buildChassis();

    Car buildCar();
}

接下来我们需要被构建的对象：

public class Car {

    private String engine;

    private String chassis;

    private String wheel;

    public String getEngine() {
        return engine;
    }

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

    public String getChassis() {
        return chassis;
    }

    public void setChassis(String chassis) {
        this.chassis = chassis;
    }

    public String getWheel() {
        return wheel;
    }

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

接下来就是具体的构建者了：

public class CarBuilderImpl  implements CarBuilder {

    private Car car;

    public void buildEngine() {
        this.car.setEngine("引擎");
        System.out.println("汽车引擎构建完毕");
    }

    public void buildWheel() {
        this.car.setChassis("底盘");
        System.out.println("汽车底盘构建完毕");
    }

    public void buildChassis() {
        this.car.setWheel("轮子");
        System.out.println("汽车轮子构建完毕");
    }

    public Car buildCar() {
        this.car =  new Car();
        this.buildChassis();
        this.buildEngine();
        this.buildWheel();
        System.out.println("汽车建造完毕");
        return this.car;
    }
}

测试一下：

public class BuilderTest {

    public static void main(String[] args) {
        CarBuilder carBuilder = new CarBuilderImpl();
        Car car = carBuilder.buildCar();
    }
}

这个模式很简单，笔者只分析一下使用场景，当我们需要构建很复杂的对象的时候，比如一个Config配置，那么我们就能使用建造者模式，这样可以把对象的构建和使用分离