设计模式：代理模式

代理模式是很常见的设计模式，即使没有专门学习过这种设计模式，在工作中也一定用过这种设计模式。在实际生活中，代理模式也是常见的，比如内阁首辅相对于皇帝，前者是后者的代理，内阁首辅收到奏折时，往往也要做一些预处理和后处理。

当我们需要给原始类增加一些功能、日志、性能监控时，通过修改原始类当然是可以实现的，但是这样就侵入了原来的逻辑，违背了开闭原则。并且新增的功能与原有的功能本来就属于不同范畴的功能。

在不修改原始类的基础上，增加新的功能，就需要用到代理模式。有些类也是无法修改的，这种情况下，只能使用代理模式。

在平时的开发中，为了代码使用方便，我们往往会对一些原始的接口进行封装。在原始接口的基础上增加一些功能或者日志。这样我们在使用对应功能的时候，就可以直接使用我们封装的接口，而不是原始接口，这就是代理模式。

如下是在std::thread的基础上封装的Thread类，通过该类可以设置线程的名字。为了在创建线程的时候指定线程的名字，封装了Thread类，Thread可以看作std::thread的代理类。

#include <iostream> #include <thread> #include <unistd.h> class Thread { public: template <class Function, class... Args> Thread(std::string const& name, Function&& f, Args&&... args) noexcept : internal_(std::forward<Function>(f), std::forward<Args>(args)...) { set_name(name); } virtual ~Thread() noexcept { if (internal_.joinable()) { internal_.join(); } } bool joinable() const noexcept { return internal_.joinable(); } void join() { if (joinable()) { internal_.join(); } } std::thread::native_handle_type native_handle() noexcept { return internal_.native_handle(); } private: void set_name(std::string const& name) noexcept { if (!name.empty()) { uint64_t const thread_name_max{15}; if (name.length() > thread_name_max) { pthread_setname_np(native_handle(), name.substr(0, thread_name_max).c_str()); } else { pthread_setname_np(native_handle(), name.c_str()); } } } private: std::thread internal_; }; int main() { Thread t("testthread", [](){ std::cout << "thread enter\n"; sleep(10); std::cout << "thread exit\n"; }); t.join(); return 0; } 1静态代理 

静态代理，就是针对一个原始类，实现一个代理类，这个代理类只能对这一个原始类起到代理的作用。如下代码，是代理模式的典型使用方式，代理类与原始类实现相同的接口，代理类中有一个属性是原始类。

#include <iostream> // 接口 class Subject { public: virtual void Request() const = 0; virtual ~Subject() = default; }; // 原始类 class RealSubject : public Subject { public: void Request() const override { std::cout << "RealSubject: 处理请求" << std::endl; } }; // 代理类 class Proxy : public Subject { private: RealSubject* real_subject_; public: Proxy() : real_subject_(new RealSubject()) {} ~Proxy() { delete real_subject_; } void Request() const override { std::cout << "Proxy: 预处理请求" << std::endl; real_subject_->Request(); std::cout << "Proxy: 后续处理" << std::endl; } }; int main() { Proxy proxy; proxy.Request(); return 0; } 2动态代理

使用静态代理，如果原始类很多的话，那么针对每一个原始类，都要实现一个代理类，这样会造成类的数量成倍的增加。为了解决这个问题，出现了动态代理。

如下代码，是动态代理的例子，动态代理类是一个类模板，该代理类代理的是那个类通过模板参数指定。原始类、预处理函数、后处理函数，均通过构造函数的的参数进行传递。

#include <iostream> #include <functional> #include <memory> // 抽象类 class IComponent { public: virtual void Operation() = 0; virtual ~IComponent() = default; }; // 原始类 class ConcreteComponent : public IComponent { public: void Operation() override { std::cout << "ConcreteComponent: 核心操作" << std::endl; } }; // 代理类 template <typename T> class DynamicProxy : public IComponent { private: std::unique_ptr<T> target_; std::function<void()> pre_handler_; std::function<void()> post_handler_; public: DynamicProxy(std::unique_ptr<T> target, std::function<void()> pre, std::function<void()> post) : target_(std::move(target)), pre_handler_(pre), post_handler_(post) {} void Operation() override { // 前置处理 if (pre_handler_) pre_handler_(); // 委托调用 target_->Operation(); // 后置处理 if (post_handler_) post_handler_(); } }; int main() { // 创建动态代理（可运行时配置） auto proxy = std::make_unique<DynamicProxy<ConcreteComponent>>( std::make_unique<ConcreteComponent>(), []() { std::cout << "DynamicProxy: 预处理" << std::endl; }, []() { std::cout << "DynamicProxy: 后续处理" << std::endl; } ); proxy->Operation(); return 0; }