设计模式创建型——建造者模式

目录

什么是建造者模式

建造者模式的实现

建造者模式的角色

建造者模式类图

建造者模式代码实现

建造者模式的特点

优点

缺点

应用场景

注意事项

---

什么是建造者模式

        建造者模式（Builder Pattern）又叫生成器模式，使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

        一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

        在一些基本部件不会变，而其组合经常变化的时候，一般会使用到建造者模式。

        主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

建造者模式的实现

建造者模式的角色

1. 产品角色（Product）：包含多个组成部件的复杂对象，由具体建造者来创建其各个组成部件。
2. 抽象建造者（Builder）：是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法getResult()。规范具体建造者的方法，是多个规范相同的具体建造者的抽象。
3. 具体建造者（Concrete Builder）：实现Builder接口，完成复杂产品的各个部件的具体创建方法，定义并明确它所创建的表示，并提供一个检索产品的接口。
4. 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

建造者模式类图

建造者模式代码实现

产品角色（Product）

/**
 * @author Evan Walker 昂焱数据: https://www.ayshuju.com
 * @version 1.0
 * @desc 汽车产品角色
 * @date 2023/04/20 10:26:33
 */
public class Car {

    /**
     * 引擎
     */
    private String engine;
    /**
     * 底盘
     */
    private String chassis;
    /**
     * 变速箱
     */
    private String transmissionCase;
    /**
     * 轮胎
     */
    private String tire;

    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 getTransmissionCase() {
        return transmissionCase;
    }

    public void setTransmissionCase(String transmissionCase) {
        this.transmissionCase = transmissionCase;
    }

    public String getTire() {
        return tire;
    }

    public void setTire(String tire) {
        this.tire = tire;
    }

    @Override
    public String toString() {
        return "Car{" +
                "engine='" + engine + '\'' +
                ", chassis='" + chassis + '\'' +
                ", transmissionCase='" + transmissionCase + '\'' +
                ", tire='" + tire + '\'' +
                '}';
    }
}

抽象建造者（Builder）

/**
 * @author Evan Walker 昂焱数据: https://www.ayshuju.com
 * @version 1.0
 * @desc 抽象建造者
 * @date 2023/04/20 10:33:55
 */
public abstract class AbstractCarBuilder {

    private Car car = new Car();

    abstract void builderEngine();

    abstract void builderChassis();

    abstract void builderTransmissionCase();

    abstract void builderTire();

    public Car getCar() {
        return car;
    }
}

具体建造者（Concrete Builder）

/**
 * @author Evan Walker  昂焱数据: https://www.ayshuju.com
 * @version 1.0
 * @desc 奔驰汽车，建造者
 * @date 2023/04/20 10:37:43
 */
public class BenzCarBuilder extends AbstractCarBuilder {

    @Override
    void builderEngine() {
        super.getCar().setEngine("奔驰发动机");
    }

    @Override
    void builderChassis() {
        super.getCar().setChassis("奔驰底盘");
    }

    @Override
    void builderTransmissionCase() {
        super.getCar().setTransmissionCase("奔驰变速箱");
    }

    @Override
    void builderTire() {
        super.getCar().setTire("奔驰轮胎");
    }

    @Override
    public Car getCar() {
        return super.getCar();
    }
}
/**
 * @author Evan Walker 昂焱数据: https://www.ayshuju.com
 * @version 1.0
 * @desc 宝马汽车，建造者
 * @date 2023/04/20 10:37:43
 */
public class BMWCarBuilder extends AbstractCarBuilder {

    @Override
    void builderEngine() {
        super.getCar().setEngine("宝马发动机");
    }

    @Override
    void builderChassis() {
        super.getCar().setChassis("宝马底盘");
    }

    @Override
    void builderTransmissionCase() {
        super.getCar().setTransmissionCase("宝马变速箱");
    }

    @Override
    void builderTire() {
        super.getCar().setTire("宝马轮胎");
    }

    @Override
    public Car getCar() {
        return super.getCar();
    }
}

指挥者（Director）

/**
 * @author Evan Walker 昂焱数据: https://www.ayshuju.com
 * @version 1.0
 * @desc 指挥者 汽车组装者
 * @date 2023/04/20 10:44:22
 */
public class CarManager {

    private AbstractCarBuilder carBuilder;

    public CarManager(AbstractCarBuilder carBuilder) {
        this.carBuilder = carBuilder;
    }

    /**
     * 组装汽车
     * @return Car
     */
    public Car builderCar(){
        carBuilder.builderEngine();
        carBuilder.builderChassis();
        carBuilder.builderTransmissionCase();
        carBuilder.builderTire();
        return this.carBuilder.getCar();
    }

}

测试

/**
 * @author Evan Walker
 * @version 1.0
 * @desc 构建者测试类
 * @date 2023/04/20 10:48:41
 */
public class BuilderTest {

    public static void main(String[] args) {
        //构造宝马汽车
        BMWCarBuilder bMWCarBuilder = new BMWCarBuilder();
        CarManager carManager = new CarManager(bMWCarBuilder);
        System.out.println(carManager.builderCar().toString());
        //构造奔驰汽车
        BenzCarBuilder benzCarBuilder = new BenzCarBuilder();
        CarManager carManager1 = new CarManager(benzCarBuilder);
        System.out.println(carManager1.builderCar().toString());

    }
}

StringBuilder中也使用的建造者模式，有兴趣的小伙伴可以阅读下源码，此处只添加了类图

建造者模式的特点

优点

1. 易于解耦：客户端不需要知道内部的具体构建细节，将产品本身与创建过程进行解耦，允许用户只通过指定复杂对象的类型和内容就构建对象，使用相同的创建过程来得到不同的产品，符合依赖倒转原则
2. 易于精准控制对象的创建：将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰
3. 易于扩展：增加新的具体构建者无需修改原有的代码，易于扩展，符合开闭原则

缺点

1. 产品必须有共同点，范围有限制，其组成部分相似，适用建造者模式；产品差异性很大时，不适合使用建造者模式，其使用范围受到一定的限制。
2. 如内部变化复杂，会有很多的建造类，导致系统变得庞大。

应用场景

1. 需要生成的产品对象有复杂的内部结构，这些产品对象具备共性
2. 隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品
3. 需要生成的对象内部属性本身相互依赖

注意事项

1. 抽象工厂模式：实现对产品家族的创建，一个产品家族是一系列产品，具有不同分类维度的产品组合，采用抽象工厂模式不需要关心构建过程，只关心什么产品由什么工厂生产即可。
2. 建造者模式：要求按照指定的规范建造产品，主要目的是通过组装零配件而产生一个新产品。
3. 与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

更多消息资讯，请访问昂焱数据（https://www.ayshuju.com）