设计模式之代理模式（Proxy），以C++为例，实现远程代理、虚拟代理、保护代理等。

        兄弟姐妹们好，又是好久没有更新了，今天给大家简单介绍代理模式，一个很简单的设计模式，旨在不改变原对象的情况下通过代理对象来控制对原对象的访问。代理模式根据具体情况还可以分为远程代理、虚拟代理、保护代理等，下面来介绍一下。

目录

 一、代理模式基础介绍

1.1 基础

1.2 代码示例

二、远程代理（Remote proxy）

三、虚拟代理（Virtual Proxy）

四、保护代理（Protective Proxy）

五、缓存代理（Cache Proxy）

六、总结

---

 一、代理模式基础介绍

1.1 基础

        C++代理模式是一种结构型设计模式，其主要目的是为其他对象提供一种代理，以控制对这些对象的访问。代理对象可以充当原始对象的包装器，将请求转发到原始对象，并且可以在转发请求之前或之后执行一些额外的操作。

        代理模式通常用于以下几种情况：

1. 远程代理：用于在不同地址空间中的两个对象之间通信，将请求发送到远程对象。

2. 虚拟代理：用于延迟加载，即在需要时加载资源。

3. 保护代理：用于控制对对象的访问权限，例如，只有特定用户才能访问某个对象。

4. 缓存代理：用于缓存对象的访问结果，以避免重复执行计算密集型操作。

        在C++中实现代理模式可以使用抽象类和接口来定义代理和原始对象之间的通信协议，并使用具体类来实现它们。代理对象将请求转发给原始对象，并可以在转发请求之前或之后执行一些额外的操作。

1.2 代码示例

        以下是一个简单的C++代理模式的示例代码：

#include <iostream>
using namespace std;

// 定义抽象类 Subject，代表原始对象和代理对象共同的接口
class Subject {
public:
    virtual void request() = 0;
};

// 定义具体类 RealSubject，实现原始对象的功能
class RealSubject : public Subject {
public:
    void request() override {
        cout << "RealSubject: Handling request." << endl;
    }
};

// 定义代理类 Proxy，实现代理对象的功能
class Proxy : public Subject {
private:
    RealSubject* real_subject_;

    void check_access() const {
        cout << "Proxy: Checking access prior to handling request." << endl;
    }

public:
    Proxy(RealSubject* real_subject) : real_subject_(real_subject) {}

    void request() override {
        check_access();
        real_subject_->request();
    }
};

int main() {
    RealSubject* real_subject = new RealSubject;
    Proxy* proxy = new Proxy(real_subject);
    proxy->request();

    delete proxy;
    delete real_subject;
    return 0;
}

        在这个示例中，抽象类 Subject 定义了原始对象和代理对象共同的接口 request()，具体类 RealSubject 实现了原始对象的功能，代理类 Proxy 实现了代理对象的功能，并在转发请求之前执行了一个额外的操作 check_access()。在 main() 函数中，创建了一个 RealSubject 对象和一个 Proxy 对象，并通过 Proxy 对象调用了 request() 方法。

        类图如下：

 二、远程代理（Remote proxy）

        C++远程代理是一种设计模式，它允许客户端通过代理对象间接访问远程服务或对象。这个模式通常被用于网络编程中，比如RPC（远程过程调用）或分布式系统中。

// 假设这是远程服务端对象的头文件
class RemoteService {
public:
    virtual void foo() = 0;
};

// 代理类，用于访问远程服务端对象
class RemoteServiceProxy : public RemoteService {
public:
    RemoteServiceProxy(const std::string& host, int port) : m_host(host), m_port(port) {}

    void foo() override {
        // 连接远程服务端
        connect();

        // 向远程服务端发送请求
        sendRequest("foo");

        // 等待远程服务端响应
        std::string response = receiveResponse();

        // 关闭连接
        disconnect();

        // 处理响应
        processResponse(response);
    }

private:
    std::string m_host;
    int m_port;
    int m_socketFd;  // 保存套接字描述符，用于连接远程服务端

    void connect() {
        // 连接远程服务端代码
    }

    void sendRequest(const std::string& request) {
        // 向远程服务端发送请求代码
    }

    std::string receiveResponse() {
        // 从远程服务端接收响应代码
    }

    void disconnect() {
        // 关闭连接代码
    }

    void processResponse(const std::string& response) {
        // 处理响应代码
    }
};

// 客户端代码
int main() {
    RemoteServiceProxy proxy("127.0.0.1", 8080);
    proxy.foo();  // 通过代理对象间接访问远程服务端对象的foo()方法
    return 0;
}

        上述代码中，RemoteService是一个抽象基类，它定义了远程服务端对象的接口。RemoteServiceProxy是代理类，它通过套接字描述符连接远程服务端，并将客户端的请求转发给远程服务端。客户端只需要通过代理对象访问远程服务端的方法即可，而无需知道远程服务端的具体实现细节。

        类图如下：

三、虚拟代理（Virtual Proxy）

        C++虚拟代理（Virtual Proxy）模式是一种结构型设计模式，它允许你创建一个代理对象来代替一个真实对象。该代理对象可以控制对真实对象的访问，并在需要时才创建或加载真实对象。

        代码示例：

#include <iostream>
using namespace std;

// 定义一个抽象类Subject
class Subject {
public:
    virtual void request() = 0;
};

// 定义一个真实的Subject类RealSubject
class RealSubject : public Subject {
public:
    void request() {
        cout << "真实的请求" << endl;
    }
};

// 定义一个代理类Proxy
class Proxy : public Subject {
private:
    RealSubject *realSubject;

public:
    void request() {
        if (realSubject == nullptr) {
            realSubject = new RealSubject();
        }
        cout << "代理请求" << endl;
        realSubject->request();
    }
};

// 客户端代码
int main() {
    Proxy proxy;
    proxy.request();
    return 0;
}

        在上面的示例中，我们定义了一个抽象类Subject和一个具体的类RealSubject，它们都实现了request()方法。然后我们定义了一个代理类Proxy，它也实现了request()方法，但是它首先检查真实的主题是否已经创建，如果没有创建，则创建一个。然后代理类打印一条消息，表示代理请求。最后，它调用真实主题的request()方法。

        在客户端代码中，我们实例化了一个代理对象，并调用了request()方法。由于我们使用了代理模式，所以当我们调用代理对象的request()方法时，它将首先创建真实对象（如果没有创建），然后打印代理请求，最后调用真实对象的request()方法。

        这种模式的一个好处是，它可以延迟创建真实对象的时间，直到它真正需要使用。这可以节省资源，特别是当创建真实对象的代价很大时。

        类图：

四、保护代理（Protective Proxy）

        C++中的保护代理（Protective Proxy）是一种结构型设计模式，其目的是控制对对象的访问。它使用一个代理对象来控制原始对象的访问，代理对象通过限制或控制原始对象的访问来提供额外的安全性和保护。

#include <iostream>
#include <string>
#include <memory>

class Image {
public:
    Image(std::string name) : name_(name) {}
    virtual void Display() = 0;
    virtual ~Image() {}

protected:
    std::string name_;
};

class RealImage : public Image {
public:
    RealImage(std::string name) : Image(name) {
        LoadFromDisk();
    }

    void Display() override {
        std::cout << "Displaying " << name_ << std::endl;
    }

private:
    void LoadFromDisk() {
        std::cout << "Loading " << name_ << " from disk" << std::endl;
    }
};

class ImageProxy : public Image {
public:
    ImageProxy(std::string name) : Image(name) {}

    void Display() override {
        if (real_image_ == nullptr) {
            real_image_ = std::make_unique<RealImage>(name_);
        }
        real_image_->Display();
    }

private:
    std::unique_ptr<RealImage> real_image_;
};

int main() {
    // Create a real image object
    auto real_image = std::make_unique<RealImage>("image1.jpg");
    
    // Display the real image
    real_image->Display();

    // Create an image proxy object
    auto image_proxy = std::make_unique<ImageProxy>("image2.jpg");

    // Display the image proxy
    image_proxy->Display();

    // The real image is only loaded once, even though it is displayed twice
    return 0;
}

        在上面的示例代码中，Image 是一个抽象基类，RealImage 和 ImageProxy 是具体的类。RealImage 是一个真实的图像对象，它可以从磁盘中加载并显示图像。ImageProxy 是一个代理对象，它可以访问真实图像对象，并负责加载和显示真实图像对象。当我们调用 ImageProxy 对象的 Display() 方法时，它会首先检查是否已经加载了真实图像对象。如果没有加载，它将使用 RealImage 对象加载图像。这种方式可以减少对真实图像对象的频繁访问，从而提高程序的效率。

        类图：

五、缓存代理（Cache Proxy）

        缓存代理模式的基本思路是：为了避免每次调用一个函数或方法时都要进行重复的计算，我们可以将其结果缓存起来，下次需要时就可以直接返回缓存的结果，而不用再进行计算。

#include <iostream>
#include <unordered_map>

using namespace std;

// 定义一个全局的缓存代理类
class FactorialCacheProxy {
public:
    int getFactorial(int n) {
        if (cache_.find(n) != cache_.end()) {
            // 如果结果已经被缓存，直接返回缓存的结果
            cout << "Get result from cache: " << n << endl;
            return cache_[n];
        } else {
            // 如果结果没有被缓存，进行计算并缓存结果
            cout << "Calculate result: " << n << endl;
            int result = calculateFactorial(n);
            cache_[n] = result;
            return result;
        }
    }
private:
    // 计算阶乘的实际函数
    int calculateFactorial(int n) {
        int result = 1;
        for (int i = 1; i <= n; i++) {
            result *= i;
        }
        return result;
    }
    // 使用一个 unordered_map 来作为缓存
    unordered_map<int, int> cache_;
};

int main() {
    FactorialCacheProxy cacheProxy;
    for (int i = 5; i <= 7; i++) {
        int result = cacheProxy.getFactorial(i);
        cout << "Factorial of " << i << " is " << result << endl;
    }
    for (int i = 5; i <= 7; i++) {
        int result = cacheProxy.getFactorial(i);
        cout << "Factorial of " << i << " is " << result << endl;
    }
    return 0;
}

        计算结果，并将结果缓存起来。之后再次调用相同的方法时，直接从缓存中取出结果，不需要再进行计算，从而提高了程序的性能。

六、总结

        代理模式被代理的对象一定有奇特的地方，要么对象加载困难，要么计算困难，需要设计一个代理作为缓冲区，在必要时代理才唤醒真正的对象。一切符合上面特性的都可以使用代理模式，设计模式都是自然而然的，都是解决程序运行中的痛点应运而生的。

        博主祝大家周末愉快！