建造者设计模式学习

1.介绍

建造者模式是一种创建型设计模式 ,它将一个复杂对象的构建过程 与它的表示分离,使得相同的构建过程可以创建不同的表示。通过分步骤地构建对象,建造者模式提供了更细粒度的控制和灵活性,特别适合需要灵活创建复杂对象的场景。

  • Builder(建造者接口):定义创建对象不同部分的抽象接口。
  • ConcreteBuilder(具体建造者) :实现 Builder 接口,负责构建复杂对象的各个部分,并最终返回完整对象
  • Director(指挥者):指定复杂对象的构建顺序和步骤,协调 Builder 的调用。【指挥者可以简略】
  • Product(产品):由多个部件组成的复杂对象,是建造的最终结果。

2.简单例子

标准的例子:

cpp 复制代码
#include <iostream>
#include <string>

// Product: 复杂对象
class Computer {
private:
    std::string CPU;
    std::string GPU;
    std::string RAM;
    std::string Storage;

public:
    void setCPU(const std::string& cpu) { CPU = cpu; }
    void setGPU(const std::string& gpu) { GPU = gpu; }
    void setRAM(const std::string& ram) { RAM = ram; }
    void setStorage(const std::string& storage) { Storage = storage; }

    void show() const {
        std::cout << "Computer Configuration:\n"
                  << "CPU: " << CPU << "\n"
                  << "GPU: " << GPU << "\n"
                  << "RAM: " << RAM << "\n"
                  << "Storage: " << Storage << "\n";
    }
};

// Builder: 抽象建造者
class ComputerBuilder {
public:
    virtual ~ComputerBuilder() = default;
    virtual void buildCPU() = 0;
    virtual void buildGPU() = 0;
    virtual void buildRAM() = 0;
    virtual void buildStorage() = 0;
    virtual Computer* getResult() = 0;
};

// ConcreteBuilder: 具体建造者
class GamingComputerBuilder : public ComputerBuilder {
private:
    Computer* computer;

public:
    GamingComputerBuilder() { computer = new Computer(); }
    ~GamingComputerBuilder() { delete computer; }

    void buildCPU() override { computer->setCPU("Intel i9"); }
    void buildGPU() override { computer->setGPU("NVIDIA RTX 4090"); }
    void buildRAM() override { computer->setRAM("32GB DDR5"); }
    void buildStorage() override { computer->setStorage("2TB SSD"); }

    Computer* getResult() override {
        Computer* result = computer;
        computer = nullptr; // 防止重复释放
        return result;
    }
};

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

public:
    void setBuilder(ComputerBuilder* b) { builder = b; }

    Computer* construct() {
        builder->buildCPU();
        builder->buildGPU();
        builder->buildRAM();
        builder->buildStorage();
        return builder->getResult();
    }
};

// 客户端代码
int main() {
    Director director;
    GamingComputerBuilder gamingBuilder;

    // 设置建造者
    director.setBuilder(&gamingBuilder);

    // 构建计算机
    Computer* gamingComputer = director.construct();

    // 显示结果
    gamingComputer->show();

    delete gamingComputer;
    return 0;
}

// 其实director有点死板,它每次都要使用不同的builder,才能创建不同的对象,直接把创建产品的任务交给builder自己也行。

2.1 链式编程

https://zhuanlan.zhihu.com/p/143101326

关键点是builder的函数直接返回产品对象

cpp 复制代码
// 产品类
public class KFC {
    //套餐必点
    private String hamburger;
    private String chips;

    //套餐选点
    private String chicken;
    private String cola;
    private String pizza;
    public KFC(String hamburger,String chips){
        this.hamburger = hamburger;
        this.hamburger = chips;
    }
    public void setChicken(String chicken) {
        this.chicken = chicken;
    }

    public void setCola(String cola) {
        this.cola = cola;
    }

    public void setPizza(String pizza) {
        this.pizza = pizza;
    }
};

// 抽象builder
public abstract class Builder {
        abstract Builder setChicken();
        abstract Builder setCola();
        abstract Builder setPizza();
        abstract KFC getKFC();
}

// 具体builder
public class ConcreteBuilder extends Builder {
    KFC kfc;
    public ConcreteBuilder(String hamburger,String chips){
        kfc = new KFC(hamburger,chips);
    }
    @Override
    Builder setChicken() {
        kfc.setChicken("鸡腿");
        return this; // 返回自己,可以链式调用
    }

    @Override
    Builder setCola() {
        kfc.setCola("可乐");
        return this;
    }

    @Override
    Builder setPizza() {
        kfc.setPizza("披萨");
        return this;
    }

    @Override
    KFC getKFC() {
        return kfc;
    }
}

// main函数
public class BTest {
    public static void main(String[] args) {
                // 实例化一个具体的builder类,通过它返回一个具体对象
       KFC kfc = new ConcreteBuilder("汉堡","薯条").setChicken().setCola().getKFC();
    }
}

3.项目实例

gRPC通过builder构建server对象,

这里的builder也不是一个抽象建造者,而是一个具体的类,所以它是只有具体建造者和产品类,也可以理解为将director和builder合二为一了,都合到builder里面了。设计模式是可以简化的,不是那么死板的。

相关推荐
我先去打把游戏先40 分钟前
ESP32学习笔记(基于IDF):ESP32连接MQTT服务器
服务器·笔记·单片机·嵌入式硬件·学习·esp32
deng-c-f4 小时前
Linux C/C++ 学习日记(29):IO密集型与CPU密集型、CPU的调度与线程切换
linux·学习·线程·cpu·io密集·cpu密集
四谎真好看5 小时前
Java 黑马程序员学习笔记(进阶篇18)
java·笔记·学习·学习笔记
洋洋的笔记5 小时前
银行测试学习计划
学习
Allan_20256 小时前
数据库学习
数据库·学习
报错小能手6 小时前
linux学习笔记(43)网络编程——HTTPS (补充)
linux·网络·学习
报错小能手7 小时前
linux学习笔记(45)git详解
linux·笔记·学习
百锦再7 小时前
Vue Scoped样式混淆问题详解与解决方案
java·前端·javascript·数据库·vue.js·学习·.net
Larry_Yanan7 小时前
QML学习笔记(四十四)QML与C++交互:对QML对象设置objectName
开发语言·c++·笔记·qt·学习·ui·交互
Mr_WangAndy8 小时前
C++设计模式_行为型模式_策略模式Strategy
c++·设计模式·策略模式·依赖倒置原则