^-^
后端技术_结构型设计模式
最近更新：2024-09-23   |   字数总计：4.3k   |   阅读估时：19分钟   |   阅读量：次
  1. 单例模式
  2. 工厂模式
    1. 举例
  3. 抽象工厂
    1. 背景
  4. 责任链
    1. 举例
  5. 装饰器
    1. 举例
  6. 组合模式
    1. 举例

单例模式

  • 保证一个类仅有一个实例，并且提供一个该实例的全局访问点
  • 解决了什么问题：
    • 稳定点：类只有一个实例，提供全局的访问点（抽象）
    • 变化点：有多个类都是单例，能不能复用代码（扩展：组合、继承）
  • 代码结构
    • 私有的构造和析构
    • 禁掉拷贝构造、拷贝赋值、移动构造、移动赋值
    • 静态类成员函数
    • 静态私有成员变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
// 版本一
// 问题：_instance存在栈上，但是它指向的区域存在堆上，且该对象的析构函数并没有做任何处理而且还不会被调用，那么假如有需要释放的资源（比如未写入完全的文件等），会有问题。
class Singleton {
public:
    static Singleton * GetInstance() {
        if (_instance == nullptr) {
            _instance = new Singleton();
        }
        return _instance;
    }
private:
    Singleton(){}; //构造
    ~Singleton(){};
    Singleton(const Singleton &) = delete; //拷⻉构造
    Singleton& operator=(const Singleton&) = delete;//拷贝赋值构造
    Singleton(Singleton &&) = delete;//移动构造
    Singleton& operator=(Singleton &&) = delete;//移动拷贝构造
    static Singleton * _instance;
};
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化

// 版本二
// 还可以使⽤ 内部类，智能指针来解决； 此时还有线程安全问题
##include <cstdlib>
class Singleton {
public:
static Singleton * GetInstance() {
    if (_instance == nullptr) {
        _instance = new Singleton();
        atexit(Destructor); // 当程序退出的时候会回调方法
    }
    return _instance;
}
private:
    static void Destructor() {
        if (nullptr != _instance) { //
            delete _instance;
            _instance = nullptr;
        }
    }
    Singleton(){}; //构造
    ~Singleton(){};
    Singleton(const Singleton &) = delete; //拷⻉构造
    Singleton& operator=(const Singleton&) = delete;//拷贝赋值构造
    Singleton(Singleton &&) = delete;//移动构造
    Singleton& operator=(Singleton &&) = delete;//移动拷贝构造
    static Singleton * _instance;
};
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化


// 版本三
// 还有问题： _instance = new Singleton()这个语句可能会有cpu指令重排的问题，下面的123顺序可能会先走13，然后另一个线程进来发现已经有地址了，然后直接拿该地址去用，但是此时构造函数都没有执行，会出问题。
##include <mutex>
class Singleton { // 懒汉模式 lazy load
public:
    static Singleton * GetInstance() {
        // std::lock_guard<std::mutex> lock(_mutex); // 3.1 切换线程 , 加在这里效率低
        if (_instance == nullptr) { // 双重检测技术
            std::lock_guard<std::mutex> lock(_mutex); // 3.2
            if (_instance == nullptr) {
                _instance = new Singleton();
                // 1. 分配内存
                // 2. 调用构造函数
                // 3. 返回指针
                // 多线程环境下 cpu reorder操作
                atexit(Destructor);
            }
        }
        return _instance;
    }
private:
    static void Destructor() {
        if (nullptr != _instance) {
            delete _instance;
            _instance = nullptr;
        }
    }
    Singleton(){}; //构造
    ~Singleton(){};
    Singleton(const Singleton &) = delete; //拷⻉构造
    Singleton& operator=(const Singleton&) = delete;//拷贝赋值构造
    Singleton(Singleton &&) = delete;//移动构造
    Singleton& operator=(Singleton &&) = delete;//移动拷贝构造
    static Singleton * _instance;
    static std::mutex _mutex;
};
Singleton* Singleton::_instance = nullptr;//静态成员需要初始化
std::mutex Singleton::_mutex; //互斥锁初始化

// 版本四
// 没有问题，但是很复杂
##include <mutex>
##include <atomic>
class Singleton {
public:
    static Singleton * GetInstance() {
        Singleton* tmp = _instance.load(std::memory_order_relaxed);
        std::atomic_thread_fence(std::memory_order_acquire);//获取内存屏障
        if (tmp == nullptr) {
            std::lock_guard<std::mutex> lock(_mutex);
            tmp = _instance.load(std::memory_order_relaxed);
            if (tmp == nullptr) {
                tmp = new Singleton;
                std::atomic_thread_fence(std::memory_order_release);//释放内存屏障
                _instance.store(tmp, std::memory_order_relaxed);
                atexit(Destructor);
            }
        }
        return tmp;
    }
private:
    static void Destructor() {
        Singleton* tmp = _instance.load(std::memory_order_relaxed);
        if (nullptr != tmp) {
            delete tmp;
        }
    }
    Singleton(){}; //构造
    ~Singleton(){};
    Singleton(const Singleton &) = delete; //拷⻉构造
    Singleton& operator=(const Singleton&) = delete;//拷贝赋值构造
    Singleton(Singleton &&) = delete;//移动构造
    Singleton& operator=(Singleton &&) = delete;//移动拷贝构造
    static std::atomic<Singleton*> _instance;
    static std::mutex _mutex;
};
std::atomic<Singleton*> Singleton::_instance;//静态成员需要初始化
std::mutex Singleton::_mutex; //互斥锁初始化
// g++ Singleton.cpp -o singleton -std=c++11

// 版本五
// c++11 magic static 特性：如果当变量在初始化的时候，并发同时进⼊声明语句，并发线程将会阻塞等待初始化结束
// c++ effective
class Singleton
{
public:
    static Singleton& GetInstance() {
        static Singleton instance;
        return instance;
    }
private:
    Singleton(){}; //构造
    ~Singleton(){};
    Singleton(const Singleton &) = delete; //拷⻉构造
    Singleton& operator=(const Singleton&) =
    delete;//拷贝赋值构造
    Singleton(Singleton &&) = delete;//移动构造
    Singleton& operator=(Singleton &&) =
    delete;//移动拷贝构造
};
// 继承 Singleton
// g++ Singleton.cpp -o singleton -std=c++11
/*该版本具备 版本5 所有优点：
1. 利⽤静态局部变量特性，延迟加载；
2. 利⽤静态局部变量特性，系统⾃动回收内存，⾃动调⽤析构函数；
3. 静态局部变量初始化时，没有 new 操作带来的cpu指令reorder操作；
4. c++11 静态局部变量初始化时，具备线程安全；
*/

// 版本六
// 解决复用代码的问题
template<typename T>
class Singleton {
public:
    static T& GetInstance() {
        static T instance; // 这⾥要初始化DesignPattern，需要调⽤DesignPattern 构造函数，同时会调⽤⽗类的构造函数。
        return instance;
    }
protected: // protected修饰构造函数，才能让别⼈继承
    virtual ~Singleton() {}
    Singleton() {} 
private:
    Singleton(const Singleton &) = delete; //拷⻉构造
    Singleton& operator=(const Singleton&) = delete;//拷贝赋值构造
    Singleton(Singleton &&) = delete;//移动构造
    Singleton& operator=(Singleton &&) = delete;//移动拷贝构造
};

class DesignPattern : public Singleton<DesignPattern> {
    friend class Singleton<DesignPattern>; //friend 能让Singleton<T> 访问到 DesignPattern构造函数，因为GetInstance函数调用到了这里的构造函数
private:
    DesignPattern() {}
    ~DesignPattern() {}
};

工厂模式

  • 定义一个用于创造对象的接口，让子类决定实例化哪一个类。工厂模式使得一个类的实例化延迟到子类。
  • 为什么要有工厂模式，为不直接使用new？
    • 除了new还有复杂的构造流程
  • 解决了什么问题
    • 稳定点：
      • 创建同类对象的接口——对象创建接口
      • 同类对象都有一个相同的职责——功能接口
    • 变化点：创建对象的扩展
  • 代码结构
    • 对象创建接口，其中创建具体对象，调用功能接口
    • 功能接口
  • 设计原则：
    • 最小知道原则
    • 面向接口编程
  • 如何扩展代码
    • 实现对象创建接口
    • 实现功能接口
    • 多态调用

举例

  • 实现一个导出数据的接口，让客户选择数据的导出方式。
  • 不使用设计模式
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    ##include <string>
    // 实现导出数据的接口, 导出数据的格式包含 xml，json，文本格式txt 后面可能扩展excel格式csv
    class IExport {
    public:
        virtual bool Export(const std::string &data) = 0;
        virtual ~IExport(){}
    };

    class ExportXml : public IExport {
    public:
        virtual bool Export(const std::string &data) {
            return true;
        }
    };

    class ExportJson : public IExport {
    public:
        virtual bool Export(const std::string &data) {
            return true;
        }
    };
    // csv
    class ExportTxt : public IExport {
    public:
        virtual bool Export(const std::string &data) {
            return true;
        }
    };
    int main() {
        std::string choose/* = */;
        if (choose == "txt") {
            /***/
            IExport *e = new ExportTxt();
            /***/
            e->Export("hello world");
        } else if (choose == "json") {
            /***/
            IExport *e = new ExportJson();
            /***/
            e->Export("hello world");
        } else if (choose == "xml") {
            IExport *e = new ExportXml();
            e->Export("hello world");
        } else if (choose == "csv") {
            IExport *e = new ExportXml();
            e->Export("hello world");
        }
    }
  • 使用设计模式
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    ##include <string>
    // 实现导出数据的接口, 导出数据的格式包含 xml，json，文本格式txt 后面可能扩展excel格式csv
    class IExport {
    public:
        virtual bool Export(const std::string &data) = 0;
        virtual ~IExport(){}
    };

    class ExportXml : public IExport {
    public:
        virtual bool Export(const std::string &data) {
            return true;
        }
    };

    class ExportJson : public IExport {
    public:
        virtual bool Export(const std::string &data) {
            return true;
        }
    };

    class ExportTxt : public IExport {
    public:
        virtual bool Export(const std::string &data) {
            return true;
        }
    };

    class ExportCSV : public IExport {
    public:
        virtual bool Export(const std::string &data) {
            return true;
        }
    };

    class IExportFactory {
    public:
        IExportFactory() {
            _export = nullptr;
        }
        virtual ~IExportFactory() {
            if (_export) {
                delete _export;
                _export = nullptr;
            }
        }
        bool Export(const std::string &data) {
            if (_export == nullptr) {
                _export = NewExport();
            }
            return _export->Export(data);
        }
    protected:
        virtual IExport * NewExport(/* ... */) = 0;
    private:
        IExport* _export;
    };

    class ExportXmlFactory : public IExportFactory {
    protected:
        virtual IExport * NewExport(/* ... */) {
            // 可能有其它操作，或者许多参数
            IExport * temp = new ExportXml();
            // 可能之后有什么操作
            return temp;
        }
    };
    class ExportJsonFactory : public IExportFactory {
    protected:
        virtual IExport * NewExport(/* ... */) {
            // 可能有其它操作，或者许多参数
            IExport * temp = new ExportJson;
            // 可能之后有什么操作
            return temp;
        }
    };
    class ExportTxtFactory : public IExportFactory {
    protected:
        IExport * NewExport(/* ... */) {
            // 可能有其它操作，或者许多参数
            IExport * temp = new ExportTxt;
            // 可能之后有什么操作
            return temp;
        }
    };

    class ExportCSVFactory : public IExportFactory {
    protected:
        virtual IExport * NewExport(/* ... */) {
            // 可能有其它操作，或者许多参数
            IExport * temp = new ExportCSV;
            // 可能之后有什么操作
            return temp;
        }
    };

    int main () {
        IExportFactory *factory = new ExportCSVFactory();
        factory->Export("hello world");
        return 0;
    }

抽象工厂

  • 提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定他们具有的类（实际上就是工厂模式的扩展，一个类有多个功能接口）
  • 解决了什么问题
    • 稳定点
      • 创建同类对象的接口——对象创建接口
      • 同类对象有多相同的职责——功能接口
    • 变化点
      • 创建对象的扩展
  • 代码结构
    • 对象创建接口，其中创建具体对象，提供多个功能接口来调用
    • 多个功能接口
  • 工程模式与抽象工厂的区别：功能是否是一个

背景

  • 实现一个拥有导入导出数据的接口，让客户选择数据导入导出的方式
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    ##include <string>
    // 实现导出数据的接口, 导出数据的格式包含 xml，json，文本格式txt 后面可能扩展excel格式csv
    class IExport {
    public:
        virtual bool Export(const std::string &data) = 0;
        virtual ~IExport(){}
    };

    class ExportXml : public IExport {
    public:
        virtual bool Export(const std::string &data) {
            return true;
        }
    };

    class ExportJson : public IExport {
    public:
        virtual bool Export(const std::string &data) {
            return true;
        }
    };

    class ExportTxt : public IExport {
    public:
        virtual bool Export(const std::string &data) {
            return true;
        }
    };

    class ExportCSV : public IExport {
    public:
        virtual bool Export(const std::string &data) {
            return true;
        }
    };

    class IImport {
    public:
        virtual bool Import(const std::string &data) = 0;
        virtual ~IImport(){}
    };

    class ImportXml : public IImport {
    public:
        virtual bool Import(const std::string &data) {
            return true;
        }
    };

    class ImportJson : public IImport {
    public:
        virtual bool Import(const std::string &data) {
            return true;
        }
    };

    class ImportTxt : public IImport {
    public:
        virtual bool Import(const std::string &data) {
            return true;
        }
    };

    class ImportCSV : public IImport {
    public:
        virtual bool Import(const std::string &data) {
            // ....
            return true;
        }
    };

    class IDataApiFactory {
    public:
        IDataApiFactory() {
            _export = nullptr;
            _import = nullptr;
        }
        virtual ~IDataApiFactory() {
            if (_export) {
                delete _export;
                _export = nullptr;
            }
            if (_import) {
                delete _import;
                _import = nullptr;
            }
        }
        bool Export(const std::string &data) {
            if (_export == nullptr) {
                _export = NewExport();
            }
            return _export->Export(data);
        }
        bool Import(const std::string &data) {
            if (_import == nullptr) {
                _import = NewImport();
            }
            return _import->Import(data);
        }
    protected:
        virtual IExport * NewExport(/* ... */) = 0;
        virtual IImport * NewImport(/* ... */) = 0;
    private:
        IExport *_export;
        IImport *_import;
    };

    class XmlApiFactory : public IDataApiFactory {
    protected:
        virtual IExport * NewExport(/* ... */) {
            // 可能有其它操作，或者许多参数
            IExport * temp = new ExportXml;
            // 可能之后有什么操作
            return temp;
        }
        virtual IImport * NewImport(/* ... */) {
            // 可能有其它操作，或者许多参数
            IImport * temp = new ImportXml;
            // 可能之后有什么操作
            return temp;
        }
    };

    class JsonApiFactory : public IDataApiFactory {
    protected:
        virtual IExport * NewExport(/* ... */) {
            // 可能有其它操作，或者许多参数
            IExport * temp = new ExportJson;
            // 可能之后有什么操作
            return temp;
        }
        virtual IImport * NewImport(/* ... */) {
            // 可能有其它操作，或者许多参数
            IImport * temp = new ImportJson;
            // 可能之后有什么操作
            return temp;
        }
    };
    class TxtApiFactory : public IDataApiFactory {
    protected:
        virtual IExport * NewExport(/* ... */) {
            // 可能有其它操作，或者许多参数
            IExport * temp = new ExportTxt;
            // 可能之后有什么操作
            return temp;
        }
        virtual IImport * NewImport(/* ... */) {
            // 可能有其它操作，或者许多参数
            IImport * temp = new ImportTxt;
            // 可能之后有什么操作
            return temp;
        }
    };

    class CSVApiFactory : public IDataApiFactory {
    protected:
        virtual IExport * NewExport(/* ... */) {
            // 可能有其它操作，或者许多参数
            IExport * temp = new ExportCSV;
            // 可能之后有什么操作
            return temp;
        }
        virtual IImport * NewImport(/* ... */) {
            // 可能有其它操作，或者许多参数
            IImport * temp = new ImportCSV;
            // 可能之后有什么操作
            return temp;
        }
    };

    // 相关性  依赖性    工作当中
    int main () {
        IDataApiFactory *factory = new CSVApiFactory();
        factory->Import("hello world");
        factory->Export("hello world");
        return 0;
    }

责任链

  • 使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处理它为止。
  • 解决的问题
    • 稳定点
      • 处理流程，请求按照链条传递，但是可打断
    • 变化点
      • 处理节点的个数
      • 处理节点的顺序
      • 处理条件
  • 代码结构
    • 单个节点出发，实现一个处理接口，实现一个构建链表关系的静态接口
  • 设计原则
    • 组合优于继承
    • 面向接口编程
    • 接口依赖
  • 扩展代码
    • 实现处理接口
    • 修改静态接口

举例

  • 请求流程，1天内需要主程序批准，3天内需要项目经理批准，3天以上需要老板批准

  • 不使用设计模式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    ##include <string>

    class Context {
    public:
        std::string name;
        int day;
    };

    class LeaveRequest {
    public:
        bool HandleRequest(const Context &ctx) {
            if (ctx.day <= 1)
                HandleByBeaty(ctx);
            if (ctx.day <= 1)
                HandleByMainProgram(ctx);
            else if (ctx.day <= 10)
                HandleByProjMgr(ctx);
            else
                HandleByBoss(ctx);
        }

    private:
        bool HandleByBeaty(const Context &ctx) {
            
        }
        bool HandleByMainProgram(const Context &ctx) {
            
        }
        bool HandleByProjMgr(const Context &ctx) {
            
        }
        bool HandleByBoss(const Context &ctx) {

        }
    };

  • 使用设计模式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    ##include <string>

    class Context {
    public:
        std::string name;
        int day;
    };

    // 稳定点 抽象  变化点 扩展 （多态）
    //  从单个处理节点出发，我能处理，我处理，我不能处理交给下一个人处理
    //  链表关系如何抽象

    class IHandler {
    public:
        virtual ~IHandler() : next(nullptr) {}
        void SetNextHandler(IHandler *next) { // 链表关系
            next = next;
        }
        bool Handle(const Context &ctx) {
            if (CanHandle(ctx)) {
                return HandleRequest(ctx);
            } else if (GetNextHandler()) {
                return GetNextHandler()->Handle(ctx);
            } else {
                // err
            }
            return false;
        }
        // 通过函数来抽象 处理节点的个数  处理节点顺序
        static bool handler_leavereq(Context &ctx) {
            IHandler * h0 = new HandleByBeauty();
            IHandler * h1 = new HandleByMainProgram();
            IHandler * h2 = new HandleByProjMgr();
            IHandler * h3 = new HandleByBoss();
            h0->SetNextHandler(h1);
            h1->SetNextHandler(h2);
            h2->SetNextHandler(h3);
            return h0->Handle(ctx);
        }
    protected:
        virtual bool HandleRequest(const Context &ctx) {return true};
        virtual bool CanHandle(const Context &ctx) {return true};
        IHandler * GetNextHandler() {
            return next;
        }
    private:
        IHandler *next; // 组合基类指针
    };

    // 能不能处理，以及怎么处理
    class HandleByMainProgram : public IHandler {
    protected:
        virtual bool HandleRequest(const Context &ctx){
            //
            return true;
        }
        virtual bool CanHandle(const Context &ctx) {
            //
            if (ctx.day <= 10)
                return true;
            return false;
        }
    };

    class HandleByProjMgr : public IHandler {
    protected:
        virtual bool HandleRequest(const Context &ctx){
            //
            return true;
        }
        virtual bool CanHandle(const Context &ctx) {
            //
            if (ctx.day <= 20)
                return true;
            return false;
        }
    };
    class HandleByBoss : public IHandler {
    protected:
        virtual bool HandleRequest(const Context &ctx){
            //
            return true;
        }
        virtual bool CanHandle(const Context &ctx) {
            //
            if (ctx.day < 30)
                return true;
            return false;
        }
    };

    class HandleByBeauty : public IHandler {
    protected:
        virtual bool HandleRequest(const Context &ctx){
            //
            return true;
        }
        virtual bool CanHandle(const Context &ctx) {
            //
            if (ctx.day <= 3)
                return true;
            return false;
        }
    };

    int main() {
        // IHandler * h1 = new HandleByMainProgram();
        // IHandler * h2 = new HandleByProjMgr();
        // IHandler * h3 = new HandleByBoss();
        // h1->SetNextHandler(h2);
        // h2->SetNextHandler(h3);
    // 抽象工厂
    // nginx http 处理 
        // 设置下一指针 
        Context ctx;
        if (IHander::handler_leavereq(ctx)) {
            cout << "请假成功";
        } else {
            cout << "请假失败";
        }
        
        return 0;
    }

装饰器

  • 动态地给一个对象增加一些额外的职责。就增加功能而言，装饰器模式比生产子类更为灵活。
  • 解决了什么问题
    • 稳定点：顺序无关地增加职责（组合的方式）
    • 变化点：增加
  • 设计原则
    • 组合优于继承
    • 接口依赖
    • 面向接口编程
  • 代码结构
  • 扩展代码
    • 继承，实现职责

举例

  • 普通员工有销售奖金，累计奖金，部门经理除此之外还有团队奖金；后面可能会增加环比增长奖金，同时可能针对不同的职位产生不同的奖金组合；
  • 不使用设计模式
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    // 普通员工有销售奖金，累计奖金，部门经理除此之外还有团队奖金；后面可能会添加环比增长奖金，同时可能产生不同的奖金组合；
    // 销售奖金 = 当月销售额 * 4%
    // 累计奖金 = 总的回款额 * 0.2%
    // 部门奖金 = 团队销售额 * 1%
    // 环比奖金 = (当月销售额-上月销售额) * 1%
    // 销售后面的参数可能会调整
    class Context {
    public:
        bool isMgr;
        // User user;
        // double groupsale;
    };

    class Bonus {
    public:
        double CalcBonus(Context &ctx) {
            double bonus = 0.0;
            bonus += CalcMonthBonus(ctx);
            bonus += CalcSumBonus(ctx);
            if (ctx.isMgr) {
                bonus += CalcGroupBonus(ctx);
            }
            return bonus;
        }
    private:
        double CalcMonthBonus(Context &ctx) {
            double bonus/* = */;
            return bonus;
        }
        double CalcSumBonus(Context &ctx) {
            double bonus/* = */;
            return bonus;
        }
        double CalcGroupBonus(Context &ctx) {
            double bonus/* = */;
            return bonus;
        }
    };

    int main() {
        Context ctx;
        // 设置 ctx
        Bonus *bonus = new Bonus;
        bonus->CalcBonus(ctx);
    }
  • 使用设计模式
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    ##include <iostream>
    // 普通员工有销售奖金，累计奖金，部门经理除此之外还有团队奖金；后面可能会添加环比增长奖金，同时可能产生不同的奖金组合；
    // 销售奖金 = 当月销售额 * 4%
    // 累计奖金 = 总的回款额 * 0.2%
    // 部门奖金 = 团队销售额 * 1%
    // 环比奖金 = (当月销售额-上月销售额) * 1%
    // 销售后面的参数可能会调整
    using namespace std;
    class Context {
    public:
        bool isMgr;
        // User user;
        // double groupsale;
    };

    class CalcBonus {    
    public:
        CalcBonus(CalcBonus * c = nullptr) : cc(c) {}
        virtual double Calc(Context &ctx) {
            return 0.0; // 基本工资
        }
        virtual ~CalcBonus() {}

    protected:
        CalcBonus* cc;
    };

    class CalcMonthBonus : public CalcBonus {
    public:
        CalcMonthBonus(CalcBonus * c) : CalcBonus(c) {}
        virtual double Calc(Context &ctx) {
            double mbonus /*= 计算流程忽略*/; 
            return mbonus + cc->Calc(ctx);
        }
    };

    class CalcSumBonus : public CalcBonus {
    public:
        CalcSumBonus(CalcBonus * c) : CalcBonus(c) {}
        virtual double Calc(Context &ctx) {
            double sbonus /*= 计算流程忽略*/; 
            return sbonus + cc->Calc(ctx);
        }
    };

    class CalcGroupBonus : public CalcBonus {
    public:
        CalcGroupBonus(CalcBonus * c) : CalcBonus(c) {}
        virtual double Calc(Context &ctx) {
            double gbnonus /*= 计算流程忽略*/; 
            return gbnonus + cc->Calc(ctx);
        }
    };

    class CalcCycleBonus : public CalcBonus {
    public:
        CalcCycleBonus(CalcBonus * c) : CalcBonus(c) {}
        virtual double Calc(Context &ctx) {
            double gbnonus /*= 计算流程忽略*/; 
            return gbnonus + cc->Calc(ctx);
        }
    };

    int main() {
        // 1. 普通员工
        Context ctx1;
        CalcBonus *base = new CalcBonus();
        CalcBonus *cb1 = new CalcMonthBonus(base);
        CalcBonus *cb2 = new CalcSumBonus(cb1);


        cb2->Calc(ctx1);
        // 2. 部门经理
        Context ctx2;
        CalcBonus *cb3 = new CalcGroupBonus(cb1);
        cb3->Calc(ctx2);
    }

组合模式

  • 将对象组合成树型结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
  • 设计原则
    • 组合优于继承
    • 接口依赖
    • 面向接口编程
  • 解决的问题：
    • 稳定点：层次关系，对象和组合对象的使用一致性
    • 变化点：对象的职责变更，组合对象里的对象变更
  • 代码结构
    • 使用一个接口消除叶子节点和组合对象的差异
    • 维持一个容器来容纳组合对象

举例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
class IComponent
{
public:
    IComponent(/* args */);
    ~IComponent();
    virtual void Execute() = 0;
    virtual void AddChild(IComponent *ele) {}
    virtual void RemoveChild(IComponent *ele) {}
};

class Leaf : public IComponent
{
public:
    virtual void Execute() {
        cout << "leaf exxcute" << endl;
    }
};

class Composite : public IComponent
{
private:
    std::list<IComponent*> _list;
public:
    virtual void AddChild(IComponent *ele) {
        // ...
    }
    virtual void RemoveChild(IComponent *ele) {
        // ...
    }
    virtual void Execute() {
        for (auto iter = _list.begin(); iter != _list.end(); iter++) {
            iter->Execute();
        }
    }
};
2024-03-30 该篇文章被 Cleofwine 归为分类: 服务端

上一篇：后端技术_智能指针_正则表达式 下一篇：后端技术_创建型设计模式
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题