【设计模式】builder 创建者设计模式详解（包含电商应用场景及代码示例）

一、`builder` 简介

在常见的设计模式中，“Builder” 通常是指一种设计模式，而不是具体的类或方法。Builder 模式是一种创建型设计模式，其目的是通过提供一个独立的构建器类来构建一个复杂对象。

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

1、主要角色

产品（Product）：表示被构建的复杂对象。在建造过程完成后，该对象通常包含多个部件。
抽象建造者（Builder）：声明了创建产品各个部件的抽象接口。通常包含创建和返回产品的方法。
具体建造者（Concrete Builder）：实现了抽象建造者接口，负责实际构建产品的各个部件。具体建造者通常会有一个与产品相关的成员变量，用于保存当前产品的状态。
指导者（Director）：负责使用建造者对象构建产品。指导者通常不知道具体产品的类型和内部结构，仅仅负责按照一定的构建步骤调用建造者的方法。

在 Java 中，Builder 模式通常由一个包含所有构建步骤的内部静态类（称为 Builder 类）来实现。这个 Builder 类负责设置对象的各个属性，最后通过一个 build() 方法来构建目标对象。

总体而言，Builder 模式是通过一个独立的构建器类来创建对象，使得对象的构建过程更加灵活和清晰。

二、`builder` 用法及实现

1、手写builder类

一般来说，builder 的用法如下：

创建一个静态内部类作为建造者（Builder）：

    private String property1;
    private int property2;

    // 私有构造函数，限制直接实例化
    private MyClass() {
    }

    // Getter 方法省略...

    // 静态内部类作为建造者
    public static class Builder {
        private MyClass instance = new MyClass();

        public Builder withProperty1(String value) {
            instance.property1 = value;
            return this;
        }

        public Builder withProperty2(int value) {
            instance.property2 = value;
            return this;
        }

        public MyClass build() {
            return instance;
        }
    }

    // 其他静态工厂方法或实例方法...

    // 示例：使用 builder() 创建对象
    public static Builder builder() {
        return new Builder();
    }
 }

使用建造者设置属性：

MyClass myObject = MyClass.builder()
    .withProperty1("value1")
    .withProperty2(42)
    .build();

通过这种方式，你可以在创建对象的时候逐步设置属性，而不是通过构造函数传递参数。这样的设计使得代码更加清晰，易于维护，尤其当有多个可选属性时，建造者模式可以提供更好的灵活性。

2、Lombok实现

使用 Lombok 这样的工具，它提供了 @Builder 注解，该注解可以用于生成 Builder 模式相关的代码。下面是一个使用 Lombok 的 @Builder 注解的简单示例：详情参考【注解】@Builder、@SuperBuilder Lombok 中的建设者

import lombok.Builder;
import lombok.Getter;

@Getter
@Builder
public class Example {
    private final String name;
    private final int age;
}

// 在其他类中使用
Example example = Example.builder()
        .name("John")
        .age(25)
        .build();

在这个示例中，Builder 注解帮助生成了一个名为 builder 的静态内部类，该类用于创建 Example 对象的实例。这种方式使得对象的创建更加清晰和方便。

请注意，@Builder 是 Lombok 提供的功能，如果你没有使用 Lombok，你需要手动编写 Builder 模式的代码。

三、作用和优势

1、工作流程

客户端（Client）：创建指导者对象，并指定一个具体的建造者对象。
指导者（Director）：调用具体建造者的一系列方法，按照一定的步骤来构建产品。
具体建造者（Concrete Builder）：实现了具体的构建步骤，负责构建产品的各个部件。
产品（Product）：表示最终构建成功的对象。

2、优点

分离构建和表示：建造者模式将对象的构建和最终表示分离，使得相同的构建过程可以创建不同的表示。
更好的控制构建过程：通过指导者来控制构建过程，可以灵活地配置和改变产品的构建流程。
更好的复用性：可以通过不同的具体建造者来创建不同类型的产品，提高了代码的复用性。
更好的扩展性：增加新的具体建造者无需修改指导者的代码，符合开闭原则。

四、应用场景

需要创建复杂对象：当对象的构建过程较为复杂，涉及多个部件组合，且这些部件可能存在多种组合方式时，可以考虑使用建造者模式。
对象的构建步骤顺序不固定：如果对象的构建步骤的顺序不固定，或者某些步骤可以省略，可以通过建造者模式更灵活地构建对象。
想要避免使用过多的构造方法：在类的构造方法中，参数的组合可能有多种情况，如果为每一种情况都提供一个构造方法，会导致构造方法的数量急剧增加。建造者模式可以通过一系列的方法来设置对象的不同部分，避免构造方法的爆炸性增长。
希望在创建对象时能够更好地控制对象的构建过程：通过使用指导者（Director）来封装对象的构建过程，客户端只需要指定具体的建造者和调用指导者的构建方法，而无需关心对象的具体构建过程。
想要避免在客户端暴露产品的内部表示：建造者模式将产品的构建和最终表示分离，客户端只需要关心产品的最终状态而不需要知道具体的构建细节，从而降低了客户端与产品的耦合度。

总的来说，建造者模式适用于需要创建复杂对象，且构建过程灵活多变的场景。在这种模式下，将对象的构建过程封装在具体建造者中，通过指导者来统一调度，使得客户端可以更方便地构建出所需的对象。

五、应用实例（电商）

在电商项目中，一个典型的场景是创建订单（Order）。订单通常包含多个部分，例如订单项、收货地址、支付信息等，而每个部分的构建可能涉及到多个步骤和参数。建造者模式在这种情况下可以很好地应用。

让我们考虑一个简化的订单创建过程，使用建造者模式来构建订单对象。假设订单包括订单号、订单项列表、收货地址、支付信息等。

1、首先，定义订单对象：

// 订单对象
public class Order {
    private String orderNumber;
    private List<OrderItem> orderItems;
    private String shippingAddress;
    private String paymentInfo;

    // 构造方法私有化，通过建造者来构建对象
    private Order() {
    }

    // 提供获取订单信息的方法
    // ...
}

2、然后，定义订单项对象：

// 订单项对象
public class OrderItem {
    private String productCode;
    private int quantity;

    // 构造方法
    public OrderItem(String productCode, int quantity) {
        this.productCode = productCode;
        this.quantity = quantity;
    }

    // 提供获取订单项信息的方法
    // ...
}

3、接下来，定义订单的建造者（OrderBuilder）：

// 订单建造者
public class OrderBuilder {
    private Order order;

    public OrderBuilder() {
        this.order = new Order();
    }

    public OrderBuilder setOrderNumber(String orderNumber) {
        order.orderNumber = orderNumber;
        return this;
    }

    public OrderBuilder addOrderItem(String productCode, int quantity) {
        if (order.orderItems == null) {
            order.orderItems = new ArrayList<>();
        }
        order.orderItems.add(new OrderItem(productCode, quantity));
        return this;
    }

    public OrderBuilder setShippingAddress(String shippingAddress) {
        order.shippingAddress = shippingAddress;
        return this;
    }

    public OrderBuilder setPaymentInfo(String paymentInfo) {
        order.paymentInfo = paymentInfo;
        return this;
    }

    public Order build() {
        return order;
    }
}

4、最后，在客户端中使用建造者模式来构建订单：

public class Main {
    public static void main(String[] args) {
        // 使用建造者构建订单
        Order order = new OrderBuilder()
                .setOrderNumber("123456")
                .addOrderItem("P001", 2)
                .addOrderItem("P002", 1)
                .setShippingAddress("123 Main St, City")
                .setPaymentInfo("Credit Card")
                .build();

        // 打印订单信息
        System.out.println("Order Number: " + order.getOrderNumber());
        System.out.println("Shipping Address: " + order.getShippingAddress());
        System.out.println("Payment Info: " + order.getPaymentInfo());
        System.out.println("Order Items: " + order.getOrderItems());
    }
}