设计模式：代理模式

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

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

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

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

如下是在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;
}