建造者设计模式学习

1.介绍

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

• Builder（建造者接口）：界说创建对象差别部分的抽象接口。
  
• ConcreteBuilder（详细建造者）：实现 Builder 接口，负责构建复杂对象的各个部分，并终极返回完备对象。
  
• Director（指挥者）：指定复杂对象的构建顺序和步骤，协调 Builder 的调用。【指挥者可以大略】
  
• Product（产品）：由多个部件构成的复杂对象，是建造的终极结果。
  

2.简朴例子

标准的例子：

1. #include <iostream>
2. #include <string>
4. // Product: 复杂对象
5. class Computer {
6. private:
7.     std::string CPU;
8.     std::string GPU;
9.     std::string RAM;
10.     std::string Storage;
12. public:
13.     void setCPU(const std::string& cpu) { CPU = cpu; }
14.     void setGPU(const std::string& gpu) { GPU = gpu; }
15.     void setRAM(const std::string& ram) { RAM = ram; }
16.     void setStorage(const std::string& storage) { Storage = storage; }
18.     void show() const {
19.         std::cout << "Computer Configuration:\n"
20.                   << "CPU: " << CPU << "\n"
21.                   << "GPU: " << GPU << "\n"
22.                   << "RAM: " << RAM << "\n"
23.                   << "Storage: " << Storage << "\n";
24.     }
25. };
27. // Builder: 抽象建造者
28. class ComputerBuilder {
29. public:
30.     virtual ~ComputerBuilder() = default;
31.     virtual void buildCPU() = 0;
32.     virtual void buildGPU() = 0;
33.     virtual void buildRAM() = 0;
34.     virtual void buildStorage() = 0;
35.     virtual Computer* getResult() = 0;
36. };
38. // ConcreteBuilder: 具体建造者
39. class GamingComputerBuilder : public ComputerBuilder {
40. private:
41.     Computer* computer;
43. public:
44.     GamingComputerBuilder() { computer = new Computer(); }
45.     ~GamingComputerBuilder() { delete computer; }
47.     void buildCPU() override { computer->setCPU("Intel i9"); }
48.     void buildGPU() override { computer->setGPU("NVIDIA RTX 4090"); }
49.     void buildRAM() override { computer->setRAM("32GB DDR5"); }
50.     void buildStorage() override { computer->setStorage("2TB SSD"); }
52.     Computer* getResult() override {
53.         Computer* result = computer;
54.         computer = nullptr; // 防止重复释放
55.         return result;
56.     }
57. };
59. // Director: 指挥者
60. class Director {
61. private:
62.     ComputerBuilder* builder;
64. public:
65.     void setBuilder(ComputerBuilder* b) { builder = b; }
67.     Computer* construct() {
68.         builder->buildCPU();
69.         builder->buildGPU();
70.         builder->buildRAM();
71.         builder->buildStorage();
72.         return builder->getResult();
73.     }
74. };
76. // 客户端代码
77. int main() {
78.     Director director;
79.     GamingComputerBuilder gamingBuilder;
81.     // 设置建造者
82.     director.setBuilder(&gamingBuilder);
84.     // 构建计算机
85.     Computer* gamingComputer = director.construct();
87.     // 显示结果
88.     gamingComputer->show();
90.     delete gamingComputer;
91.     return 0;
92. }

复制代码

// 其实director有点死板，它每次都要使用差别的builder，才气创建差别的对象，直接把创建产品的使命交给builder自己也行。
2.1 链式编程

https://zhuanlan.zhihu.com/p/143101326
关键点是builder的函数直接返回产品对象。

1. // 产品类
2. public class KFC {
3.     //套餐必点
4.     private String hamburger;
5.     private String chips;
7.     //套餐选点
8.     private String chicken;
9.     private String cola;
10.     private String pizza;
11.     public KFC(String hamburger,String chips){
12.         this.hamburger = hamburger;
13.         this.hamburger = chips;
14.     }
15.     public void setChicken(String chicken) {
16.         this.chicken = chicken;
17.     }
19.     public void setCola(String cola) {
20.         this.cola = cola;
21.     }
23.     public void setPizza(String pizza) {
24.         this.pizza = pizza;
25.     }
26. };
28. // 抽象builder
29. public abstract class Builder {
30.         abstract Builder setChicken();
31.         abstract Builder setCola();
32.         abstract Builder setPizza();
33.         abstract KFC getKFC();
34. }
36. // 具体builder
37. public class ConcreteBuilder extends Builder {
38.     KFC kfc;
39.     public ConcreteBuilder(String hamburger,String chips){
40.         kfc = new KFC(hamburger,chips);
41.     }
42.     @Override
43.     Builder setChicken() {
44.         kfc.setChicken("鸡腿");
45.         return this; // 返回自己，可以链式调用
46.     }
48.     @Override
49.     Builder setCola() {
50.         kfc.setCola("可乐");
51.         return this;
52.     }
54.     @Override
55.     Builder setPizza() {
56.         kfc.setPizza("披萨");
57.         return this;
58.     }
60.     @Override
61.     KFC getKFC() {
62.         return kfc;
63.     }
64. }
66. // main函数
67. public class BTest {
68.     public static void main(String[] args) {
69.                 // 实例化一个具体的builder类，通过它返回一个具体对象
70.        KFC kfc = new ConcreteBuilder("汉堡","薯条").setChicken().setCola().getKFC();
71.     }
72. }

复制代码

3.项目实例

gRPC通过builder构建server对象，

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

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。