设计模式之建造者模式（五）

基本定义

• 建造者模式将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。
• 建造者模式构建复杂对象就像造汽车一样，是一个一个组件一个一个步骤创建出来的，它允许用户通过制定的对象类型和内容来创建他们，但是用户并不需要知道这个复杂对象是如何构建的，它只需要明白通过这样做我可以得到一个完整的复杂对象实例。

概括

用来创建复杂的复合对象。

模式结构

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

模式实现

Product 产品角色

@Setter
@Getter
public class Car {
    private String engine;//引擎
    private String seats;//座位
    private String wheels;//车轮
    private String frame; //车架

    @Override
    public String toString() {
        return "Car{" +
                "engine='" + engine + '\'' +
                ", seats='" + seats + '\'' +
                ", wheels='" + wheels + '\'' +
                ", frame='" + frame + '\'' +
                '}';
    }
}

Builder 抽象建造者

public interface CarBuilder {
    void createEngine();
    void createSeats();
    void createWheels();
    void createFrame();
    Car createCar();
}

ConcreteBuilder 具体建造者

卡车

@Slf4j
public class TruckBuilder implements CarBuilder {
    Car car = new Car();
    @Override
    public void createEngine() {
      log.info("制造1000马力发动机");
      car.setEngine("1000马力发动机");
    }

    @Override
    public void createSeats() {
        log.info("制造2个座位");
        car.setSeats("2个座位");
    }

    @Override
    public void createWheels() {
        log.info("制造12个车轮");
        car.setWheels("12个车轮");
    }

    @Override
    public void createFrame() {
        log.info("制造高强度车架");
        car.setFrame("高强度车架");
    }

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

巴士

@Slf4j
public class BusBuilder implements CarBuilder {
    Car car = new Car();
    @Override
    public void createEngine() {
      log.info("制造200马力发动机");
      car.setEngine("200马力发动机");
    }

    @Override
    public void createSeats() {
        log.info("制造19个座位");
        car.setSeats("19个座位");
    }

    @Override
    public void createWheels() {
        log.info("制造4个车轮");
        car.setWheels("4个车轮");
    }

    @Override
    public void createFrame() {
        log.info("制造高强度车架");
        car.setFrame("高强度车架");
    }

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

Director 指挥者

public class Director {
    public Car buildCar(CarBuilder builder){
        builder.createEngine();
        builder.createFrame();
        builder.createSeats();
        builder.createWheels();
        return builder.createCar();
    }
}

测试类

@Slf4j
public class Test {
    public static void main(String[] args) {
        Director worker = new Director();
        Car truck = worker.buildCar(new TruckBuilder());
        log.info("卡车制造完成：{}", truck);
        log.info("------------我是分割线------------");
        Car bus = worker.buildCar(new BusBuilder());
        log.info("巴士制造完成：{} ", bus);
    }
}

输出结果
INFO com.yanyuan.gof.build.builder.v2.TruckBuilder - 制造1000马力发动机
INFO com.yanyuan.gof.build.builder.v2.TruckBuilder - 制造高强度车架
INFO com.yanyuan.gof.build.builder.v2.TruckBuilder - 制造2个座位
INFO com.yanyuan.gof.build.builder.v2.TruckBuilder - 制造12个车轮
INFO com.yanyuan.gof.build.builder.v2.Test - 卡车制造完成：Car{engine=‘1000马力发动机’, seats=‘2个座位’, wheels=‘12个车轮’, frame=‘高强度车架’}
INFO com.yanyuan.gof.build.builder.v2.Test - ------------我是分割线------------
INFO com.yanyuan.gof.build.builder.v2.BusBuilder - 制造200马力发动机
INFO com.yanyuan.gof.build.builder.v2.BusBuilder - 制造高强度车架
INFO com.yanyuan.gof.build.builder.v2.BusBuilder - 制造19个座位
INFO com.yanyuan.gof.build.builder.v2.BusBuilder - 制造4个车轮
INFO com.yanyuan.gof.build.builder.v2.Test - 巴士制造完成：Car{engine=‘200马力发动机’, seats=‘19个座位’, wheels=‘4个车轮’, frame=‘高强度车架’}

优点

1. 将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，使得我们能够更加精确的控制复杂对象的产生过程。
2. 将产品的创建过程与产品本身分离开来，可以使用相同的创建过程来得到不同的产品。也就说细节依赖抽象。
3. 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。

缺点

1. 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。
2. 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

使用场景

1. 需要生成的产品对象有复杂的内部结构，这些产品对象通常包含多个成员属性。
2. 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

总结

1. 建造者模式是将一个复杂对象的创建过程给封装起来，客户只需要知道可以利用对象名或者类型就能够得到一个完整的对象实例，而不需要关心对象的具体创建过程。

2. 建造者模式将对象的创建过程与对象本身隔离开了，使得细节依赖于抽象，符合依赖倒置原则。可以使用相同的创建过程来创建不同的产品对象。

JDK源码

• AbstractStringBuilder 抽象建造类
• StringBuilder 具体建造类
• StringBuffer 具体建造类