当前位置：首页 > article >正文

23种设计模式-生成器(Builder)设计模式

article 2024/11/28 11:17:52

文章目录

一.什么是生成器设计模式？
二.生成器模式的特点
三.生成器模式的结构
四.生成器模式的优缺点
五.生成器模式的 C++ 实现
六.生成器模式的 Java 实现
七.代码解析
八. 总结

类图：生成器设计模式类图

一.什么是生成器设计模式？

生成器模式（Builder Pattern）是一种创建型设计模式，允许我们分步骤创建复杂对象，同时提供不同的构建方法来定制对象的各个部分。生成器模式将对象的构建过程与其表示分离，使同样的构建过程可以创建不同的表示。

二.生成器模式的特点

分步骤构建复杂对象：将构建过程分解为多个步骤。
产品结构清晰：对每个组件的创建都有明确的逻辑。
支持多样化配置：生成器可以创建不同的对象或表示。

三.生成器模式的结构

Builder（生成器接口）：定义构建对象的步骤。
ConcreteBuilder（具体生成器）：实现生成器接口，完成具体步骤并生成对象。
Director（指挥者）：控制对象构建的流程和顺序。
Product（产品）：表示最终创建的复杂对象。

四.生成器模式的优缺点

优点:
- 代码清晰：分离了构造逻辑和产品类，符合单一职责原则。
- 灵活性强：构造步骤可以灵活调整，支持多样化的产品表示。
- 可扩展性好：可以轻松增加新的生成器，而不影响已有代码。
缺点:
- 实现较复杂：需要引入多个类（生成器、指挥者、产品）。
- 使用场景有限：主要用于构建过程复杂的对象，对于简单对象不适用。

五.生成器模式的 C++ 实现

#include <iostream>
#include <string>
#include <memory>
using namespace std;

// 产品类
class Product {
private:
    string partA;
    string partB;
    string partC;

public:
    void SetPartA(const string& part) { partA = part; }
    void SetPartB(const string& part) { partB = part; }
    void SetPartC(const string& part) { partC = part; }

    void Show() const {
        cout << "Product built with: " << endl;
        cout << "  PartA: " << partA << endl;
        cout << "  PartB: " << partB << endl;
        cout << "  PartC: " << partC << endl;
    }
};

// 抽象生成器
class Builder {
public:
    virtual ~Builder() = default;

    virtual void BuildPartA() = 0;
    virtual void BuildPartB() = 0;
    virtual void BuildPartC() = 0;

    virtual shared_ptr<Product> GetResult() = 0;
};

// 具体生成器
class ConcreteBuilder : public Builder {
private:
    shared_ptr<Product> product;

public:
    ConcreteBuilder() { Reset(); }

    void Reset() { product = make_shared<Product>(); }

    void BuildPartA() override { product->SetPartA("Concrete PartA"); }
    void BuildPartB() override { product->SetPartB("Concrete PartB"); }
    void BuildPartC() override { product->SetPartC("Concrete PartC"); }

    shared_ptr<Product> GetResult() override {
        auto result = product;
        Reset(); // 重置生成器以备下次使用
        return result;
    }
};

// 指挥者
class Director {
private:
    Builder* builder;

public:
    void SetBuilder(Builder* b) { builder = b; }

    void ConstructMinimalProduct() {
        builder->BuildPartA();
    }

    void ConstructFullProduct() {
        builder->BuildPartA();
        builder->BuildPartB();
        builder->BuildPartC();
    }
};

// 客户端代码
int main() {
    ConcreteBuilder builder;
    Director director;

    director.SetBuilder(&builder);

    cout << "Building minimal product:" << endl;
    director.ConstructMinimalProduct();
    auto product1 = builder.GetResult();
    product1->Show();

    cout << "\nBuilding full product:" << endl;
    director.ConstructFullProduct();
    auto product2 = builder.GetResult();
    product2->Show();

    return 0;
}

六.生成器模式的 Java 实现

// 产品类
class Product {
    private String partA;
    private String partB;
    private String partC;

    public void setPartA(String partA) { this.partA = partA; }
    public void setPartB(String partB) { this.partB = partB; }
    public void setPartC(String partC) { this.partC = partC; }

    public void show() {
        System.out.println("Product built with:");
        System.out.println("  PartA: " + partA);
        System.out.println("  PartB: " + partB);
        System.out.println("  PartC: " + partC);
    }
}

// 抽象生成器
interface Builder {
    void buildPartA();
    void buildPartB();
    void buildPartC();
    Product getResult();
}

// 具体生成器
class ConcreteBuilder implements Builder {
    private Product product;

    public ConcreteBuilder() { reset(); }

    private void reset() { product = new Product(); }

    @Override
    public void buildPartA() { product.setPartA("Concrete PartA"); }

    @Override
    public void buildPartB() { product.setPartB("Concrete PartB"); }

    @Override
    public void buildPartC() { product.setPartC("Concrete PartC"); }

    @Override
    public Product getResult() {
        Product result = product;
        reset(); // 重置生成器以备下次使用
        return result;
    }
}

// 指挥者
class Director {
    private Builder builder;

    public void setBuilder(Builder builder) { this.builder = builder; }

    public void constructMinimalProduct() {
        builder.buildPartA();
    }

    public void constructFullProduct() {
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
    }
}

// 客户端代码
public class BuilderPatternExample {
    public static void main(String[] args) {
        ConcreteBuilder builder = new ConcreteBuilder();
        Director director = new Director();

        director.setBuilder(builder);

        System.out.println("Building minimal product:");
        director.constructMinimalProduct();
        Product product1 = builder.getResult();
        product1.show();

        System.out.println("\nBuilding full product:");
        director.constructFullProduct();
        Product product2 = builder.getResult();
        product2.show();
    }
}

七.代码解析

产品类（Product）：
- 包含产品的各个组成部分（PartA、PartB 和 PartC）。
- 提供 SetPartX 方法，用于设置对应组件值。
- 提供 Show 方法，展示产品的状态。
抽象生成器（Builder）：
- 定义了构建产品的各个步骤（BuildPartA、BuildPartB、BuildPartC）。
- 提供 GetResult 方法，返回构建完成的产品对象。
具体生成器（ConcreteBuilder）：
- 实现抽象生成器接口，提供具体的构建逻辑。
- 包括一个 Reset 方法，用于每次构建完成后重置状态
指挥者（Director）:
- 控制构建流程，按照特定顺序调用生成器的方法。
- 提供 ConstructMinimalProduct 和 ConstructFullProduct 方法，分别展示构建简单和完整产品的流程。
客户端代码：
- 创建 ConcreteBuilder 和 Director 对象。
- 指挥者调用生成器的方法，完成产品构建。
- 构建完成后，通过 GetResult 获取最终的产品对象，并调用 Show 方法展示产品。