建造者模式_建造者模式中客户类直接与建造者联系-CSDN博客

本文链接：https://blog.csdn.net/Phoegel/article/details/109477526

建造者模式

案例

生活中有一个常见的例子，没有人买车会只买一个轮胎或者方向盘，大家买的都是一辆包含轮胎和方向盘等多个部件的完整汽车。如何将这些部件组装成一辆完整的汽车并返回给用户呢，下面我们用程序来模拟一下这一过程。

1.首先是汽车、轮胎和方向盘三个实体类：

汽车类

/**
 * 汽车
 */
public class Car {
    // 方向盘
    private SteeringWheel steeringWheel;
    // 轮胎
    private Doughnut doughnut;

    @Override
    public String toString() {
        return "汽车{" +
                "方向盘=" + steeringWheel +
                ", 轮胎=" + doughnut +
                '}';
    }
    // 省略getter/setter
}

轮胎类：

/**
 * 轮胎
 */
public class Doughnut {
    // 大小
    private String size;
    // 类型
    private String type;

    public Doughnut(String size, String type) {
        this.size = size;
        this.type = type;
    }

    @Override
    public String toString() {
        return " 轮胎{" +
                "大小='" + size + '\'' +
                ", 类型='" + type + '\'' +
                '}';
    }
}

方向盘类：

/**
 * 方向盘
 */
public class SteeringWheel {
    // 大小
    private String size;
    // 类型
    private String type;

    public SteeringWheel(String size, String type) {
        this.size = size;
        this.type = type;
    }

    @Override
    public String toString() {
        return " 方向盘{" +
                "大小='" + size + '\'' +
                ", 类型='" + type + '\'' +
                '}';
    }
}

2.然后我们直接生成汽车：

public class Main {
    public static void main(String[] args) {
        // 生成一个轿车
        // 制造汽车方向盘
        SteeringWheel steeringWheel1 = new SteeringWheel("中号", "三幅");
        // 制造轮胎
        Doughnut doughnut1 = new Doughnut("中号", "轿车轮胎");
        // 制造汽车
        Car car1 = new Car();
        car1.setSteeringWheel(steeringWheel1);
        car1.setDoughnut(doughnut1);
        System.out.println(car1);
        
        // 生成一个货车
        SteeringWheel steeringWheel2 = new SteeringWheel("大号", "三幅");
        // 制造轮胎
        Doughnut doughnut2 = new Doughnut("大号", "货车轮胎");
        // 制造汽车
        Car car2 = new Car();
        car2.setSteeringWheel(steeringWheel2);
        car2.setDoughnut(doughnut2);
        System.out.println(car2);
    }
}

可以看到生成汽车的过程直接由我们客户端来完成了，这样就使得客户端和各个类都有耦合。同时我们，可以看出生产汽车的过程其实是一个比较流程化的事。而建造轮胎、方向盘等组件有可能是不尽相同的。并且，实际上建造轮胎和方向盘是较为麻烦的。基于此，接下来介绍建造者模式用于解决这一类问题。

模式介绍

建造者模式是设计模式的一种（创建型），将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

角色构成：

**Builder（抽象建造者）：**它为创建一个产品Product对象的各个部件指定抽象接口，在该接口中一般声明两类方法，一类方法是buildPartX()，它们用于创建复杂对象的各个部件；另一类方法是getResult()，它们用于返回复杂对象。Builder既可以是抽象类，也可以是接口。
**ConcreteBuilder（具体建造者）：**它实现了Builder接口，实现各个部件的具体构造和装配方法，定义并明确它所创建的复杂对象，也可以提供一个方法返回创建好的复杂产品对象。
**Product（产品角色）：**它是被构建的复杂对象，包含多个组成部件，具体建造者创建该产品的内部表示并定义它的装配过程。
**Director（指挥者）：**指挥者又称为导演类，它负责安排复杂对象的建造次序，指挥者与抽象建造者之间存在关联关系，可以在其construct()建造方法中调用建造者对象的部件构造与装配方法，完成复杂对象的建造。客户端一般只需要与指挥者进行交互，在客户端确定具体建造者的类型，并实例化具体建造者对象（也可以通过配置文件和反射机制），然后通过指挥者类的构造函数或者Setter方法将该对象传入指挥者类中。

UML类图：

builder

特点：

建造者模式是较为复杂的创建型模式，它将客户端与包含多个组成部分（或部件）的复杂对象的创建过程分离，客户端无须知道复杂对象的内部组成部分与装配方式，只需要知道所需建造者的类型即可。它关注如何一步一步创建一个的复杂对象，不同的具体建造者定义了不同的创建过程，且具体建造者相互独立，增加新的建造者非常方便，无须修改已有代码，系统具有较好的扩展性。

代码改造

1.首先是三个实体类：因为和上面的实体类相同，就不贴代码了

2.抽象构造者和两个具体实现类：

/**
 * 抽象构造者
 */
public abstract class CarBuilder {
    //创建产品对象
    protected Car car = new Car();

    public abstract void buildSteeringWheel();

    public abstract void buildDoughnut();

    //返回产品对象
    public Car getCar() {
        return car;
    }
}

小轿车类：

/**
 * 具体构造者：构造小轿车
 */
public class SedanCarBuilder extends CarBuilder {
    public void buildSteeringWheel() {
        car.setSteeringWheel(new SteeringWheel("中号", "三幅"));
    }

    public void buildDoughnut() {
        car.setDoughnut(new Doughnut("中号", "轿车轮胎"));
    }
}

货车类：

/**
 * 具体构造者：构造货车
 */
public class FreightCarBuilder extends CarBuilder {
    public void buildSteeringWheel() {
        car.setSteeringWheel(new SteeringWheel("大号", "三幅"));
    }

    public void buildDoughnut() {
        car.setDoughnut(new Doughnut("大号", "货车轮胎"));
    }
}

3.汽车生产指挥者：

/**
 * 指挥者负责汽车的安装过程
 */
public class Director {
    private CarBuilder builder;

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

    public Car create() {
        builder.buildSteeringWheel();
        builder.buildDoughnut();
        return builder.getCar();
    }
}

3.客户端使用：

/**
 * 客户端通过指挥者来获取汽车
 */
public class Main {
    public static void main(String[] args) {
        // 制造汽车
        Car car1 = new Director(new SedanCarBuilder()).create();
        System.out.println(car1);
        // 制造货车
        Car car2 = new Director(new FreightCarBuilder()).create();
        System.out.println(car2);
    }
}

经过改造后，客户端只需实例化指挥者类，指挥者类针对抽象建造者编程，客户端根据需要传入具体的建造者类型，指挥者将指导具体建造者一步一步构造一个完整的产品（逐步调用具体建造者的buildX()方法），相同的构造过程可以创建完全不同的产品。

模式应用

当我们看到Builder这个单词的时候，很容易就能联想到在我们 JDK 中的 StringBuilder 也是 Builder 结尾，其实它的append()方法就蕴含着建造者模式的思想，下面我们分析一下它的组成结构。

平时我们使用的最多的就是append()方法了：

public class Main {
    public static void main(String[] args) {
        StringBuilder builder = new StringBuilder();
        builder.append("hello");
        System.out.println(builder);
    }
}

下面是它的 UML 类图结构：

builder-StringBuilder

通过上图我们可以分析出：

Appendable 接口定义了多个 append() 方法（抽象方法），即 Appendable 为抽象建造者，定义了抽象方法
AbstractStringBuilder实现了 Appendable 接口方法，这里的 AbstractStringBuilder
已经是就建造者，只是不能实例化
StringBuilder 即充当了指挥者角色，同时也充当了具体的建造者，建造方法的实现是由AbstractStringBuilder完成。

总结

1.主要优点：

在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者，用户使用不同的具体建造者即可得到不同的产品对象。由于指挥者类针对抽象建造者编程，增加新的具体建造者无须修改原有类库的代码，系统扩展方便，符合“开闭原则”
可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

2.主要缺点：