概念

• 将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示；
• 分离了部件的构造（由Builder来负责）和装配(由Director负责)。从而可以构造出复杂的对象。这个模式适用于：某个对象的构造过程复杂的情况；
• 由于实现了构建和装配的解耦。不同的构建器，相同的装配，可以做出不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。
• 建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无需知道内部结构。

角色构成

• 抽象建造者(Builder)：这个接口抽象了复杂对象的部件的创建过程，并不涉及具体的创建细节；
• 具体建造者(ConcreteBuilder)：实现了Builder接口，完成复杂产品的各个部件的具体创建方法。在构建完成后，提供产品实例；
• 产品类(Product):要创建的复杂对象；
• 指挥者类(Director)：调用具体建造者来创建复杂对象的各个部分，这一部分不涉及产品的具体细节，只负责其中复杂产品中各个部分的创建和顺序。

示例代码

• 抽象建造者

public abstract class Builder {

    // 声明Bike类型的变量，并进行赋值
    protected Bike bike = new Bike();

    public abstract void buildFrame();

    public abstract void buildSeat();

    // 构建自行车的方法
    public abstract Bike createBike();
}

• 具体建造者

// MobileBuilder.java
public class MobileBuilder extends Builder{
    @Override
    public void buildFrame() {
        bike.setFrame("碳纤维车架");
    }

    @Override
    public void buildSeat() {
        bike.setSeat("真皮座位");
    }

    @Override
    public Bike createBike() {
        return bike;
    }
}

// OfoBuilder .java
public class OfoBuilder extends Builder{
    @Override
    public void buildFrame() {
        bike.setFrame("铝合金车架");
    }

    @Override
    public void buildSeat() {
        bike.setSeat("橡胶车座");
    }

    @Override
    public Bike createBike() {
        return bike;
    }
}

• 产品类

public class Bike {
    private String frame;
    private String seat;

    public String getFrame() {
        return frame;
    }

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

    public String getSeat() {
        return seat;
    }

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

• 指挥者类

public class Director {

    // 声明builder类型的变量
    private Builder builder;

    public Director(Builder builder){
        this.builder = builder;
    }

    // 组装自行车的功能
    public Bike construct(){
        builder.buildFrame();
        builder.buildSeat();
        return builder.createBike();
    }
}

优缺点

• 在建造者模式中，产品类和建造者类是相对稳定的，因此，将主要的业务分装在指挥者类中对整体而言可以取得比较好的稳定性；
• 客户端不必知道产品内部组成的细节。将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的对象；
• 建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，符合开闭原则；
• 建造者模式所创建的产品有较多的共同点，如果产品之间的差异很大，则不适合使用建造者模式，因此其使用受到一定的限制。

扩展

• 在开发中，当一个类的构造器需要传入很多参数时，如果创建这个类的实例，代码可读性会很差，而且很容易出错，此时就可以使用建造者模式进行重构。

// Phone.java
public class Phone {
    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;

    public static final class Builder{
        private String cpu;
        private String screen;
        private String memory;
        private String mainboard;

        public Builder cpu(String cpu){
            this.cpu = cpu;
            return this;
        }

        public Builder screen(String screen){
            this.screen = screen;
            return this;
        }

        public Builder memory(String memory){
            this.memory = memory;
            return this;
        }
        public Builder mainboard(String mainboard){
            this.mainboard = mainboard;
            return this;
        }

        public Phone build(){
            return new Phone(this);
        }
    }

    private Phone(Builder builder){
        this.cpu = builder.cpu;
        this.mainboard = builder.mainboard;
        this.memory = builder.memory;
        this.screen = builder.screen;
    }

    @Override
    public String toString() {
        return "Phone{" +
                "cpu='" + cpu + '\'' +
                ", screen='" + screen + '\'' +
                ", memory='" + memory + '\'' +
                ", mainboard='" + mainboard + '\'' +
                '}';
    }
}

// Client.java
public class Client {
    public static void main(String[] args) {
        //创建手机对象   通过构建者对象获取手机对象
        Phone phone = new Phone.Builder()
                .cpu("intel")
                .screen("三星屏幕")
                .memory("金士顿内存条")
                .mainboard("华硕主板")
                .build();
        System.out.println(phone);
    }
}