建造者模式 | 8月更文挑战

前面几篇关于设计模式的文章:

《单例模式——8种实现方式》

《工厂模式：工厂方法模式和抽象工厂模式》

《原型模式：快速复制已有实例创建新的实例》

这些设计模式都可归为对象创建型模式。今天我们聊聊最后一种对象创建型模式：建造者模式（Builder Pattern）

建造者（Builder pattern）模式的定义：将一个复杂对象的构造与它的表示分离，使同样的构建过程可以创建不同的表示

建造者模式的核心是：将产品和产品建造过程解耦

通用建造者模式

建造者模式一般适用于创建复杂且由多个部分组成的对象的场景。通过建造者模式，可以把复杂对象的建造过程抽象出来（抽象类别），客户端使用时不必知道产品构建的细节。

建造者模式一般由产品、抽象建造者、具体建造者、指挥者等4个角色组成。

• Product（产品角色）： 一个具体的、被构造的复杂产品对象。
• Builder（抽象建造者）： 创建一个 Product 对象的各个部件指定的 接口/抽象类。
• ConcreteBuilder（具体建造者）： 实现接口，构建和装配各个部件。
• Director（指挥者）： 构建一个使用 Builder 接口的对象。它主要是用于创建一个复杂的对象。它主要有两个作用，一是：隔离了客户与对象的生产过程，二是：负责控制产品对象的生产过程。

下面用具体的场景来展示建造者模式：

现在我们要创建一辆自行车。

自行车有多个部件组成，通常有：轮子、脚踏板、车身、座椅、车手把

我们也可以建造不同的类型的自行车，比如山地自行车、共享单车（青桔单车）等

产品角色(自行车)：

public class Bicycle {
    //轮子
    private String wheel;

    // 脚踏板
    private String pedal;

    // 车身
    private String crossbar;

    // 座椅
    private String saddle;

    // 车手把
    private String handlebars;
    
    // getter和setter省略

    @Override
    public String toString() {
        return "Bicycle{" +
                "wheel='" + wheel + ''' +
                ", pedal='" + pedal + ''' +
                ", crossbar='" + crossbar + ''' +
                ", saddle='" + saddle + ''' +
                ", handlebars='" + handlebars + ''' +
                '}';
    }
}

抽象建造者（自行车建造者）

public interface BicycleBuilder {

    void builtWheel(String wheel);

    void builtPedal(String pedal);

    void builtCrossbar(String crossbar);

    void buildSaddle(String saddle);

    void buildHandlebars(String handlebars);

    Bicycle build();
}

具体建造者（青桔自行车建造者）（非广告，只因为今晚骑青桔了）

public class DiDiBicycleBuilder implements BicycleBuilder {

    private Bicycle bicycle;

    public DiDiBicycleBuilder() {
        bicycle = new Bicycle();
    }

    @Override
    public void builtWheel(String wheel) {
        this.bicycle.setWheel(wheel);
    }

    @Override
    public void builtPedal(String pedal) {
        this.bicycle.setPedal(pedal);
    }

    @Override
    public void builtCrossbar(String crossbar) {
        this.bicycle.setCrossbar(crossbar);
    }

    @Override
    public void buildSaddle(String saddle) {
        this.bicycle.setSaddle(saddle);
    }

    @Override
    public void buildHandlebars(String handlebars) {
        this.bicycle.setHandlebars(handlebars);
    }

    @Override
    public Bicycle build() {
        return bicycle;
    }
}

指挥者（自行车创建指挥者）

public class BicycleDirector {
    private BicycleBuilder builder;

    public BicycleDirector(BicycleBuilder builder) {
        this.builder = builder;
    }

    public Bicycle builtBicycle(String wheel, String pedal, String crossbar, String saddle, String handlebars) {
        builder.builtWheel(wheel);
        builder.builtPedal(pedal);
        builder.builtCrossbar(crossbar);
        builder.buildSaddle(saddle);
        builder.buildHandlebars(handlebars);
        return builder.build();
    }
}

客户端，使用建造者模式创建自行车对象

public class Main {
    public static void main(String[] args) {
        BicycleBuilder builder = new DiDiBicycleBuilder();
        BicycleDirector director = new BicycleDirector(builder);
        Bicycle bicycle = director.builtBicycle("青桔轮子", "青桔脚踏板", "青桔车身", "舒服的座椅", "青桔车手把");
        System.out.println(bicycle);
    }
}

链式调用建造对象

我们常见的链式调用创建对象，其实也是利用了建造者模式。这种建造者模式，没有具体的角色，而是把创建的过程封装在Builder构建器里了。

具体的代码：

public class Bicycle {
    //轮子
    private String wheel;

    // 脚踏板
    private String pedal;

    // 车身
    private String crossbar;

    // 座椅
    private String saddle;

    // 车手把
    private String handlebars;


    private Bicycle(BicycleBuilder bicycleBuilder) {
        this.wheel = bicycleBuilder.wheel;
        this.pedal = bicycleBuilder.pedal;
        this.crossbar = bicycleBuilder.crossbar;
        this.saddle = bicycleBuilder.saddle;
        this.handlebars = bicycleBuilder.handlebars;
    }


    // 建造者，静态内部类。将创建的过程封装在建造者中
    public static class BicycleBuilder{
        //轮子
        private String wheel;
        // 脚踏板
        private String pedal;
        // 车身
        private String crossbar;
        // 座椅
        private String saddle;
        // 车手把
        private String handlebars;

        public BicycleBuilder wheel(String wheel){
            this.wheel = wheel;
            return this;
        }

        public BicycleBuilder pedal(String pedal) {
            this.pedal = pedal;
            return this;
        }

        public BicycleBuilder crossbar(String crossbar) {
            this.crossbar = crossbar;
            return this;
        }

        public BicycleBuilder saddle(String saddle) {
            this.saddle = saddle;
            return this;
        }

        public BicycleBuilder handlebars(String handlebars) {
            this.handlebars = handlebars;
            return this;
        }

        public Bicycle built() {
            return new Bicycle(this);
        }

    }

    @Override
    public String toString() {
        return "Bicycle{" +
                "wheel='" + wheel + ''' +
                ", pedal='" + pedal + ''' +
                ", crossbar='" + crossbar + ''' +
                ", saddle='" + saddle + ''' +
                ", handlebars='" + handlebars + ''' +
                '}';
    }
}

客户端使用：

public class Main {
    public static void main(String[] args) {
        Bicycle bicycle = new Bicycle.BicycleBuilder().wheel("山地车轮子").crossbar("不锈钢车身").handlebars("减压车把").built();
        System.out.println(bicycle);
    }
}

// 输出结果：
Bicycle{wheel='山地车轮子', pedal='null', crossbar='不锈钢车身', saddle='null', handlebars='减压车把'}