feat: Proxy

Implemented a demo for the Flyweight.

14_chain_of_responsibility.cpp

@@ -1,80 +0,0 @@
-#include <iostream>
-#include <memory>
-
-
-using namespace std;
-
-class Request {
-public:
-    int days;
-    enum {
-        PERSONAL_LEAVE,
-        ANNUAL_LEAVE,
-    } reason;
-};
-
-
-class Handler {
-    shared_ptr<Handler> next;
-public:
-    void next_handle(const Request& r) {
-        if (!next) {
-            cout << "Request unhandled" << endl;
-        }
-        next->handle(r);
-    }
-
-    void set_next(shared_ptr<Handler> n) {
-        next = n;
-    }
-
-    virtual void handle(const Request& r) = 0;
-};
-
-
-class LeaderHandler : public Handler {
-public:
-    virtual void handle(const Request& r) override {
-        if (r.days < 3) {
-            cout << "Leader: OK" << endl;
-        } else {
-            next_handle(r);
-        }
-    }
-};
-
-
-class SupervisorHandler : public Handler {
-public:
-    virtual void handle(const Request& r) override {
-        if (r.days < 7 || r.reason == Request::ANNUAL_LEAVE) {
-            cout << "Supervisor: OK" << endl;
-        } else {
-            next_handle(r);
-        }
-    }
-};
-
-class ManagerHandler : public Handler {
-public:
-    virtual void handle(const Request& r) override {
-        cout << "Manager: OK" << endl;
-    }
-};
-
-int main() {
-    auto lh = make_shared<LeaderHandler>();
-    auto sh = make_shared<SupervisorHandler>();
-    auto mh = make_shared<ManagerHandler>();
-
-    lh->set_next(sh);
-    sh->set_next(mh);
-
-    Request r1 {1, Request::PERSONAL_LEAVE};
-    Request r2 {4, Request::ANNUAL_LEAVE};
-    Request r3 {10, Request::PERSONAL_LEAVE};
-
-    lh->handle(r1);
-    lh->handle(r2);
-    lh->handle(r3);
-}

notes.md

@@ -89,11 +89,3 @@
 我们在使用一个类时，有时会觉得这个类的功能较简单，实际使用需要额外添加一些访问控制，缓存管理等功能。简单的想法是直接在这个类中添加这些功能，但这会使得这个类急剧膨胀，且核心功能变得不那么明确。
 
 代理模式解决了这个问题。通过一个代理类实现目标类相同接口，客户端使用代理时就像在直接操作目标类。代理类内部有目标类的指针，在处理缓存、权限等逻辑后再去调用目标类的相关函数，从而做到外围与核心逻辑的分离。
-
-## 责任链模式（Chain of Responsibility）
-
-有时我们会遇到如何处理用户请求的框架。一种做法是通过条件判断，得到不同条件下请求对应的处理函数。这样的话耦合严重，各个不同的 handler 需要放在一个函数或类中，每次扩展都需要改变这个类。
-
-责任链模式解决了这个问题。一个 handler 要么处理这个请求，要么交给下一个 handler 处理，增加处理逻辑时，只需要新增一个 handler，并且正确设置相应的 next 即可。这样，每个 handler 只关心自己的职责，所有 handler 处理清晰。当我们能将所有的 handler 组成一个链式或者树式的结构时，这会非常有用。
-
-但也正如前面提到的，这不自然支持“一个请求需多个处理者同时处理”的场景。此时可以通过责任链进一步推广成“责任网”，观察者模式，流程引擎式结构等，增强责任链模式的处理能力。