【深入理解设计模式】建造者设计模式

建造者设计模式

建造者设计模式（Builder Pattern）是一种创建型设计模式，旨在通过将复杂对象的构建过程拆分成多个简单的步骤，使得相同的构建过程可以创建不同的表示。该模式允许您使用相同的构建过程来创建不同的对象表示。

概述

将一个复杂对象的构建与表示分离，使得同样的构建过程可以创建不同的表示。

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

结构

建造者（Builder）模式包含如下角色：

• 抽象建造者类（Builder）：这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的部件对象的创建。

• 具体建造者类（ConcreteBuilder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。

• 产品类（Product）：要创建的复杂对象。

• 指挥者类（Director）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

实现方式

链式调用：通过返回 Builder 对象本身来实现链式调用，使得可以在一个表达式中连续调用多个方法。
Fluent API：通过使得方法返回类型为 Builder 类型，从而允许在一个表达式中连续调用多个方法。

优点

• 分步构建：将对象的构建过程拆分成多个步骤，使得构建过程更加灵活，易于管理和维护。
• 复用性：相同的构建过程可以创建不同的对象表示，提高了代码的复用性。
• 隐藏复杂性：客户端不需要了解对象的具体构建过程，只需使用建造者和产品即可。

缺点

• 对象的创建过程被固定：一旦建造者创建的对象的构建过程被固定，就很难改变对象的构建过程。

• 造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。

使用场景

建造者设计模式通常适用于以下场景：

1. 创建复杂对象：当对象的构建过程比较复杂，包含多个步骤或者多个组成部分时，可以考虑使用建造者模式。例如，创建一个包含多个属性的对象，或者对象的构建需要进行复杂的初始化操作。

2. 创建对象的表示可以灵活变化：如果相同的构建过程可以创建不同的对象表示，可以使用建造者模式来封装对象的构建过程，从而根据需要创建不同的对象表示。

3. 隐藏构建过程细节：建造者模式可以将对象的构建过程与具体的构建细节分离，从而隐藏了对象的创建细节。客户端只需要关注建造者和产品即可，不需要了解对象的具体构建过程。

4. 链式调用：建造者模式通常通过返回建造者对象本身来实现链式调用，使得可以在一个表达式中连续调用多个方法，从而提高了代码的可读性和易用性。

5. 创建过程中需要参数化配置：如果对象的创建过程中需要根据不同的配置参数进行定制化配置，可以使用建造者模式来封装配置参数，并根据不同的配置参数创建不同的对象表示。

总的来说，建造者模式适用于对象构建过程比较复杂，需要进行灵活定制或者隐藏细节的场景，可以帮助简化对象的创建过程，提高代码的可维护性和可扩展性。

示例1：考虑一个创建共享单车对象的建造者模式示例：

/**
 * @author OldGj 2024/02/21
 * @version v1.0
 * @apiNote 复杂产品 - 自行车类
 */
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;
    }
}

/**
 * @author OldGj 2024/02/21
 * @version v1.0
 * @apiNote 抽象建造者 - 定义建造复杂对象各个部件的方法
 */
public abstract class Builder {

    protected Bike bike = new Bike();

    public abstract void buildFrame();

    public abstract void buildSeat();

    public abstract Bike creatBike();

}

/**
 * @author OldGj 2024/02/21
 * @version v1.0
 * @apiNote 具体建造者 - 摩拜单车
 */
public class MobikeBuilder extends Builder {


    @Override
    public void buildFrame() {
        bike.setFrame("碳纤维车座");
    }

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

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

/**
 * @author OldGj 2024/02/21
 * @version v1.0
 * @apiNote 具体建造者 - ofo单车
 */
public class OfoBuilder extends  Builder{


    @Override
    public void buildFrame() {
        bike.setFrame("铝合金车架");
    }

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

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

/**
 * @author OldGj 2024/02/21
 * @version v1.0
 * @apiNote 指挥者
 */
public class Direct {

    private final Builder builder;

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

    public Bike construct() {
        builder.buildFrame();
        builder.buildSeat();
        return builder.creatBike();
    }
}

/**
 * @author OldGj 2024/02/21
 * @version v1.0
 * @apiNote 客户端 - 测试类
 */
public class Client {
    public static void main(String[] args) {

        Direct direct = new Direct(new OfoBuilder());
        Bike bike = direct.construct();
        System.out.println(bike.getFrame());
        System.out.println(bike.getSeat());
    }
}

通过上述实例，我们将共享单车的构建过程分为多个步骤，在抽象构建者中分别定义了构建各个步骤的方法，在具体构建者中，我们只需要实现这些方法，就可以构建出复杂对象，并且我们可以通过创建不同的具体构建者来通过相同的构建过程构建不同的复杂对象。以上述例子为例，我们创建了两个具体构建者分别是：ofo共享单车构建者 和 摩拜共享单车构建者，在客户端我们只需要将我们希望构建的对象构建者传入指挥者中，即可构建出对应的对象，并且非常容易拓展，符合开闭原则。

示例2：考虑一个创建汽车对象的建造者模式示例：

// Product
class Car {
    private String make;
    private String model;
    private int year;
    
    // Constructor, getters and setters...
}

// Builder
interface CarBuilder {
    CarBuilder setMake(String make);
    CarBuilder setModel(String model);
    CarBuilder setYear(int year);
    Car build();
}

// Concrete Builder
class CarBuilderImpl implements CarBuilder {
    private Car car;
    
    public CarBuilderImpl() {
        car = new Car();
    }
    
    @Override
    public CarBuilder setMake(String make) {
        car.setMake(make);
        return this;
    }
    
    @Override
    public CarBuilder setModel(String model) {
        car.setModel(model);
        return this;
    }
    
    @Override
    public CarBuilder setYear(int year) {
        car.setYear(year);
        return this;
    }
    
    @Override
    public Car build() {
        return car;
    }
}

// Director
class CarDirector {
    public Car constructSportsCar(CarBuilder builder) {
        return builder.setMake("Audi")
                      .setModel("A6")
                      .setYear(2022)
                      .build();
    }
}

// Client
public class Main {
    public static void main(String[] args) {
        CarBuilder builder = new CarBuilderImpl();
        CarDirector director = new CarDirector();
        
        Car sportsCar = director.constructSportsCar(builder);
        System.out.println(sportsCar.getMake());   // Output: Audi
        System.out.println(sportsCar.getModel());  // Output: A6
        System.out.println(sportsCar.getYear());   // Output: 2022
    }
}

在上述示例中，通过建造者模式，我们将汽车对象的构建过程拆分成多个步骤，并且可以根据需要创建不同的汽车对象表示。

模式扩展(链式调用)

建造者模式除了上面的用途外，在开发中还有一个常用的使用方式，就是当一个类构造器需要传入很多参数时，如果创建这个类的实例，代码可读性会非常差，而且很容易引入错误，此时就可以利用建造者模式进行重构。

/**
 * @author OldGj 2024/02/21
 * @version v1.0
 * @apiNote 手机类
 */
public class Phone {

    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;

    // 构造器私有化
    private Phone(Builder builder) {
        cpu = builder.cpu;
        screen = builder.screen;
        memory = builder.memory;
        mainboard = builder.mainboard;
    }

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

        public Builder() {
        }

        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);
        }

    }

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

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getScreen() {
        return screen;
    }

    public void setScreen(String screen) {
        this.screen = screen;
    }

    public String getMemory() {
        return memory;
    }

    public void setMemory(String memory) {
        this.memory = memory;
    }

    public String getMainboard() {
        return mainboard;
    }

    public void setMainboard(String mainboard) {
        this.mainboard = mainboard;
    }
}

/**
 * @author OldGj 2024/02/21
 * @version v1.0
 * @apiNote 测试类
 */
public class Client {
    public static void main(String[] args) {
        Phone phone = new Phone.Builder()
                .cpu("英特尔")
                .mainboard("华硕")
                .memory("金士顿")
                .screen("三星")
                .build();
        System.out.println(phone);

    }
}

链式调用在某种程度上也可以提高开发效率。从软件设计上，对程序员的要求比较高。