（一）什么是建造者模式

建造者（Builder）模式在百度百科上的定义：是一种将复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。

这段话在理解上十分抽象，简单来讲就是如果一个对象很复杂，使用建造者模式允许用户通过简单的方式构建这个对象，而不用关心对象具体构建的细节。且可以使用同样的构建过程可以创建出不同的对象。

接下来将会通过具体的代码实例去讲解建造者模式。

（二）建造者模式中的几个角色

建造者模式中定义了四个主要角色，现在看定义可以不太容易理解，等结合之后的代码就容易理解了。

抽象建造者Builder

建造者的抽象类或者接口，主要用来定义具体建造者需要实现的一些方法。

具体建造者 ConcreteBuilder

具体的建造者，是抽象建造者的实现类。

具体的对象Client

最终想要生成的对象。

引导者Director

实例的生成需要依赖Director角色，Director生成实例不依赖ConcreteBuilder，它只通过调用Builder角色中定义的方法。

（三）建造者模式的实践

光看上面的概念比较难理解建造者模式，接下来通过一个造车的例子讲解建造者模式。

为了简化逻辑，这里将一辆车定义为由轮子、能源和颜色组成。首先定义出具体要生成的对象，也就是角色中的Client角色：

public class Car {
    // 轮子
    private String wheel;
    // 能源
    private String energy;
    // 颜色
    private String color;
    public Car(){}
    public void setColor(String color) {
        this.color = color;
    }
    public void setEnergy(String energy) {
        this.energy = energy;
    }
    public void setWheel(String wheel) {
        this.wheel = wheel;
    }
    @Override
    public String toString() {
        return "Car{" +
                "wheel='" + wheel + '\'' +
                ", energy='" + energy + '\'' +
                ", color='" + color + '\'' +
                '}';
    }
}

造车的逻辑可以抽象为造轮子，造能源，喷颜色，最后生成一辆车，因此可以将Builder角色构建出来

public abstract class Builder {
    public abstract void buildWheel();
    public abstract void buildEnergy();
    public abstract void buildColor();
    public abstract Car getCar();
}

具体每种车都有每种车的造法，因此分别构建两种车型的构建实体类，也就是角色中的ConcreteBuilder

public class BMWCarBuilder extends Builder {
    private Car car;
    public BMWCarBuilder(){
        car = new Car();
    }
    @Override
    public void buildWheel() {
        car.setWheel("四个轮子");
    }

    @Override
    public void buildEnergy() {
        car.setEnergy("油箱");
    }

    @Override
    public void buildColor() {
        car.setColor("黑色");
    }

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

}

另一种具体建造者：

public class TeslaCarBuilder extends Builder {
    private Car car;
    public TeslaCarBuilder(){
        car = new Car();
    }
    @Override
    public void buildWheel() {
        car.setWheel("四个轮子");
    }

    @Override
    public void buildEnergy() {
        car.setEnergy("电池");
    }

    @Override
    public void buildColor() {
        car.setColor("白色");
    }

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

最后需要有一个引导者Director角色，通过引导者调用Builder中定义的方法。

public class Director {
    private Builder builder;
    public Director(Builder builder){
        this.builder = builder;
    }
    public void buildCar(){
        builder.buildWheel();
        builder.buildColor();
        builder.buildEnergy();
    }
}

使用方式如下：首先创建了TeslaCarBuilder实例对象，交给引导者，引导者角色调用buildCar方法后TeslaCarBuilder就可以通过调用getCar获取对应的Car了。BMWCarBuilder也是同样的方式。

public class Main {
    public static void main(String[] args) {
        TeslaCarBuilder teslaCarBuilder = new TeslaCarBuilder();
        Director director = new Director(teslaCarBuilder);
        director.buildCar();
        Car teslaCar = teslaCarBuilder.getCar();
        System.out.println(teslaCar.toString());

        BMWCarBuilder bmwCarBuilder = new BMWCarBuilder();
        director = new Director(bmwCarBuilder);
        director.buildCar();
        Car bmwCar = bmwCarBuilder.getCar();
        System.out.println(bmwCar.toString());
    }
}

还记得最开始对建造者模式的定义吗？使用建造者模式允许用户通过简单的方式构建这个对象，而不用关心对象具体构建的细节。且可以使用同样的构建过程可以创建出不同的对象。

在真正创建对象的过程中，已经不需要关注Car是如何build的，因此具体构建的细节都由各自的ConcreteBuilder去实现。并且同样的构建过程只要传入的ConcreteBuilder不同就可以创建不同的对象。

（四）建造者模式的变通

如果将具体建造者ConcreteBuilder、引导者Director、对象Client三种角色合为一种，那么建造者模式就会变得更加精简：首先还是要定义抽象方法Builder

public abstract class Builder {
    public abstract Builder buildWheel(String wheel);
    public abstract Builder buildEnergy(String energy);
    public abstract Builder buildColor(String color);
    public abstract Car getCar();
}

然后是将上面三种角色合一的类，在Car对象中，定义了一个内部的CarBuilder类，继承Builder类，具体的构建过程都由CarBuilder实现：

public class Car {
    // 轮子
    private String wheel;
    // 能源
    private String energy;
    // 颜色
    private String color;
    public Car(){}
    public Car(CarBuilder carBuilder){
        this.wheel = carBuilder.wheel;
        this.energy = carBuilder.energy;
        this.color = carBuilder.color;
    }

    @Override
    public String toString() {
        return "Car{" +
                "wheel='" + wheel + '\'' +
                ", energy='" + energy + '\'' +
                ", color='" + color + '\'' +
                '}';
    }

    public static class CarBuilder extends Builder {
        // 轮子
        private String wheel;
        // 能源
        private String energy;
        // 颜色
        private String color;
        @Override
        public CarBuilder buildWheel(String wheel) {
            this.wheel = wheel;
            return this;
        }

        @Override
        public CarBuilder buildEnergy(String energy) {
            this.energy = energy;
            return this;
        }

        @Override
        public CarBuilder buildColor(String color) {
            this.color = color;
            return this;
        }

        @Override
        public Car getCar() {
            return new Car(this);
        }
    }
}

使用时就更加方便了：

public class Main {
    public static void main(String[] args) {
        Car car = new Car.CarBuilder()
                .buildColor("白色")
                .buildEnergy("新能源")
                .buildWheel("四个轮子")
                .getCar();
        System.out.println(car.toString());
    }
}

（五）建造者模式在源码中的应用

StringBuilder就是建造者模式精简后的用法，StringBuilder继承了Appendable接口：

public interface Appendable {
    Appendable append(CharSequence csq) throws IOException;
    Appendable append(CharSequence csq, int start, int end) throws IOException;
    Appendable append(char c) throws IOException;
}

其具体的append方法和我们在第四章讲解的十分相似：

public final class StringBuilder extends AbstractStringBuilder implements java.io.Serializable, CharSequence{
    @Override
    public StringBuilder append(String str) {
        super.append(str);
        return this;
    }
}

在使用时，也是通过一路append实现链式编程。

stringBuilder.append("hello").append("world");

（六）总结

最传统的建造者模式体现着设计模式中“可替换性”的思想，Director不知道自己使用的具体是哪个Builder的实现类，所以Builder的实现类具备可替换性，也就可以理解为是一个个的组件。写代码时使用设计模式并不会让代码简单或者好写，反而会更复杂，但是在维护或者迭代时，就会省下很多精力。