一、什么是代理模式

代理模式指代理控制对其他对象的访问，也就是代理对象控制对原对象的引⽤。在某些情况下，⼀个对象不适合或者不能直接被引⽤访问，⽽代理对象可以在客⼾端和⽬标对象之间起到中介的作⽤。

二、为什么使用代理模式

模式作用：控制和管理对目标对象的访问。

增加额外功能：在不修改真实对象代码的前提下，可以通过代理在访问真实对象时添加额外的功能，如缓存、日志记录、延迟加载、性能监测等。

接口隔离：如果某个对象的接口过于复杂或不希望暴露给客户端，可以使用代理模式提供一个简单的接口进行访问，从而隔离复杂性。

智能引用：代理可以控制对象的生命周期，实现智能指针的功能，比如引用计数，自动释放不再使用的对象等。

代理模式的作用: AOP实现，拦截器，中介，黄牛，解耦，专人做专事。

AOP:面向切面编程,通过预编译方式和运行期间动态代理实现程序功能的统一维护的一 种技术。

三、模式的角色

抽象角色：声明真实对象和代理对象的共同接口
代理角色：
1.代理对象角色内部含有对真实对象的引用，从而可以操作真实对象
2.代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象
3.代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装
真实角色：代理角色所代表的真实对象，是我们最终要引用的对象
 

四、代理模式的实现步骤如下：

• 提供一个抽象主题角色:真实主题与代理主题的共同接口
• 提供一个真实主题角色:定义了代理角色所代表的真实对象
• 提供一个代理主题角色:含有对真实主题角色的引用

【解释说明】

代理模式的结构包括⼀个是真正的你要访问的对象(⽬标类)、⼀个是代理对象。⽬标对象与代理对象实现同⼀个接⼝，先访问代理类再通过代理类访问⽬标对象。

五、静态代理和动态代理

静态代理

在编译时就已经确定好了代理类和被代理类的关系。也就是说，在编译时就已经确定了代理类要代理的是哪个被代理类。

真实角色必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实角色必须对应一个代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？这个问题可以通过Java的动态代理类来解决。

动态代理

在运⾏时才动态⽣成代理类，并将其与被代理类绑定。这意味着，在运⾏时才能确定代理类要代理的是哪个被代理类。

通过这种方式，被代理的对象(RealSubject)可以在运行时动态改变，需要控制的接口(Subject接口)可以在运行时改变，控制的方式(DynamicSubject类)也可以动态改变，从而实现了非常灵活的动态代理关系

代理模式分为静态代理、动态代理：

静态代理指的是，在编译时就已经确定好了代理类和被代理类的关系。也就是说，在编译时就已经确定了代理类要代理的是哪个被代理类。
动态代理指的是，在运⾏时才动态⽣成代理类，并将其与被代理类绑定。这意味着，在运⾏时才能确定代理类要代理的是哪个被代理类。

#include<iostream>
using namespace std;

/* 抽象角色 */
class Subject {
public:
	virtual void request() = 0;
};

/* 真实的角色 */
class RealSubject :public Subject {
public:
	void request() override {
		cout << "RealSubject: request" << endl;
	}
};

/* 静态代理，对具体真实对象直接引用
*  代理角色，代理角色需要有对真实角色的引用，代理做真实角色想做的事情
*/
class ProxySubject :public Subject {
public:
	//除了代理真实角色做该做的事情，代理角色也可以提供附加操作，
	//如：preRequest()和postRequest()
	void request() override {
		preRequest();  
		if (realSubject == NULL) {
			realSubject = new RealSubject(); // 延迟加载：只有在调用方法的时候，才会去new对象
		}
		realSubject->request();
		postRequest(); 
	}
	void preRequest() { }//真实角色操作前的附加操作 
	void postRequest() { }//真实角色操作后的附加操作
private:
	RealSubject *realSubject = NULL;
};

int main() {
	Subject *subject = new ProxySubject();
	subject->request();  //代理者代替真实者做事情
	return 0;
}

六、应用场景（重要！）

1.远程代理（本地执行远程服务）：对一个位于不同的地址空间对象提供一个局域代表对象。适用于服务对象位于远程服务器上的情形。
2.虚拟代理（延迟初始化）：根据需要将一个资源消耗很大或者比较复杂的对象，延迟加载，在真正 需要的时候才创建；在真实对象创建成功之前虚拟代理 扮演真实对象的替身，而当 真实对象创建之后，虚拟代理将用户的请求转发给真实对象。此时可使用代理模式。

3.保护代理（访问控制）：控制对目标对象的访问，给不同的用户提供不同的访问权限即提供不同的操作函数。如果你只希望特定客户端使用服务对象，这里的对象可以是操作系统中非常重要的部分，而客户端则是各种已启动的程序（包括恶意程序），此时可使用代理模式。

4.智能指引（Remote Proxy）：取代了简单的指针，它在访问对象时执行一些附加操作。 它的典型用途包括：

• 对指向实际对象的引用计数，这样当该对象没有引用时，可以自动释放它 (也称为Smart Pointers)。
• 当第一次引用一个持久对象时，将它装入内存。
• 在访问一个实际对象前，检查是否已经锁定了它，以确保其他对象不能改变它。

5.Copy-on-Write代理：它是虚拟代理的一种，把复制（克隆）操作延迟到只有在客户端真正需要时才执行。一般来说，对象的深克隆是一个开销较大的操作，Copy-on-Write代理可以让这个操作延迟，只有对象被用到的时候才被克隆。

6.记录日志请求（日志记录代理）。适用于当你需要保存对于服务对象的请求历史记录时。代理可以在向服务传递请求前进行记录。

七、根据应用场景举例（重要！）

7.1 远程代理实例：

我们在国内因为GFW，所以不能访问 facebook，我们可以用翻墙（设置代理）的方法访问。访问过程是：
1.用户把HTTP请求发给代理
2.代理把HTTP请求发给web服务器
3.web服务器把HTTP响应发给代理
4.代理把HTTP响应发回给用户

代理模式在C++中的一个常见应用场景是远程代理，用于在不同的地址空间对象之间进行交互，例如远程方法调用（RMI）。以下是一个简单的远程代理实现的例子：

#include <iostream>
#include <string>
 
// 远程接口
class RemoteService {
public:
    virtual ~RemoteService() {}
    virtual std::string requestData() = 0;
};
 
// 远程服务的具体实现
class ConcreteRemoteService : public RemoteService {
public:
    std::string requestData() override {
        // 实现数据请求的具体逻辑
        return "Data from the remote service";
    }
};
 
// 远程代理类
class RemoteServiceProxy : public RemoteService {
private:
    RemoteService* remoteService;
 
public:
    RemoteServiceProxy() {
        // 真实的远程服务可能需要通过网络或其他方式进行连接
        remoteService = new ConcreteRemoteService();
    }
 
    ~RemoteServiceProxy() {
        delete remoteService;
    }
 
    std::string requestData() override {
        // 在这里可以添加额外的逻辑，例如网络请求的处理
        return remoteService->requestData();
    }
};
 
int main() {
    // 使用代理类进行远程服务调用
    RemoteServiceProxy* proxy = new RemoteServiceProxy();
    std::string data = proxy->requestData();
    std::cout << "Data received: " << data << std::endl;
    delete proxy;
    return 0;
}

在这个例子中，RemoteService定义了远程服务的接口。ConcreteRemoteService是远程服务的具体实现。RemoteServiceProxy是一个代理，它可以连接到远程服务并代为请求数据。在main函数中，我们创建了一个代理实例，并通过它获取数据。这个简单的例子展示了如何使用代理模式来实现远程代理。

7.2 虚拟代理实例：

考虑一个可以在文档中嵌入图形对象的文档编辑器。有些图形对象的创建开销很大。但是打开文档必须很迅速，因此我们在打开文档时应避免一次性创建所有开销很大的对象。这里就可以运用代理模式，在打开文档时，并不打开图形对象，而是打开图形对象的代理以替代真实的图形。待到真正需要打开图形时，仍由代理负责打开。

class Image
{
public:
    Image(string name): m_imageName(name) {}
    virtual ~Image() {}
    virtual void Show() {}
protected:
    string m_imageName;
};
class BigImage: public Image
{
public:
    BigImage(string name):Image(name) {}
    ~BigImage() {}
    void Show() { cout<<"Show big image : "<<m_imageName<<endl; }
};
class BigImageProxy: public Image
{
private:
    BigImage *m_bigImage;
public:
    BigImageProxy(string name):Image(name),m_bigImage(0) {}
    ~BigImageProxy() { delete m_bigImage; }
    void Show() 
    {
        if(m_bigImage == NULL)
            m_bigImage = new BigImage(m_imageName);
        m_bigImage->Show();
    }
};

int main()
{
    Image *image = new BigImageProxy("proxy.jpg"); //代理
    image->Show(); //需要时由代理负责打开
    delete image;
    return 0;
}

7.3 保护代理（访问控制）实例：

使用代理模式控制数据库访问的一个简单C++示例如下：

dbSubject.h抽象主题

#ifndef _DBSUBJECT_H
#define _DBSUBJECT_H

#include <iostream>

// 抽象主题（Subject）
// 数据库接口
class IDatabase {
public:
  virtual void executeQuery(std::string sql) = 0; 
};


#endif

dbRealSubject.h真实主题

#ifndef _DBREALSUBJECT_H
#define _DBREALSUBJECT_H

#include <iostream>
#include "dbSubject.h"

// 真实主题:数据库
class Database : public IDatabase {
public:
  void executeQuery(std::string sql) override {
    // 执行SQL查询
	std::cout << " 执行SQL查询 " <<  sql << std::endl;
  }
};

#endif

dbProxy.h代理

#ifndef _DBPROXY_H
#define _DBPROXY_H

#include <iostream>
#include "dbSubject.h"
#include "dbRealSubject.h"

// 代理 
class DatabaseProxy : public IDatabase {
private:
    Database* db;

public:
    DatabaseProxy() {
        db = new Database();
    }

    void executeQuery(std::string sql) override {
        // 权限校验
        if(checkAccess()) {  
            std::cout << "权限校验: 通过" << std::endl;
            db->executeQuery(sql); 
        } else {
            // 没有访问权限异常 
            std::cout << "权限校验: 未通过" << std::endl;
        }
    }

    // 权限校验
    bool checkAccess() {
        return true;
    }

};

#endif

main.cpp

#include <iostream>
#include <string>

#include "dbSubject.h"
#include "dbProxy.h"

int main() {
    IDatabase* db = new DatabaseProxy();
    db->executeQuery("SELECT * FROM t1");

	return 0;
}

 在这个数据库访问控制的例子中,使用代理模式主要体现了以下几点优势:

1. 把访问控制逻辑从业务代码中抽象出来,避免了侵入业务逻辑。数据库、业务代码等都不需要变更。
2. 访问控制逻辑集中到了代理类中,便于维护、扩展和复用。如果要变更控制逻辑,只需要调整代理类的实现。
3. 使用代理类对数据库访问进行控制,可以进行优化和缓存。比如实现查询数据的缓存,避免每次都直接访问数据库。
4. 提高了灵活性。代理类可以拦截和控制对实体的访问,而不需要改变实体类的代码。
5. 可以在不修改原目标类接口的情况下,通过增强代理类扩展目标类的功能。

总结： 代理模式降低了客户端与目标实体之间的耦合,提高了灵活性、扩展性、维护性,使得访问控制逻辑的集中化和重用成为可能。

7.4 智能指针代理

代理模式在C++中的一个常见应用是通过智能指针实现对象的生命周期管理。智能指针可以用作代理来管理资源，比如动态分配的内存，文件句柄等。

以下是一个简单的智能指针代理的例子，它管理着一个动态分配的整数数组的生命周期：

#include <iostream>
#include <memory>
 
class IntArray {
public:
    IntArray(int size) : _size(size) {
        _data = new int[size];
    }
 
    ~IntArray() {
        delete[] _data;
    }
 
    int& operator[](int index)
        return _data[index];
    }
 
    int getSize() const {
        return _size;
    }
 
private:
    int* _data;
    int _size;
};
 
int main() {
    // 使用智能指针来管理动态分配的数组
    std::shared_ptr<IntArray> sp(new IntArray(10));
 
    // 使用数组
    sp->operator[](0) 10;
    std::cout << "First element: " << sp->operator[](0)< std::endl;
 
    return 0;
}

在这个例子中，std::shared_ptr<IntArray> 就是一个智能指针代理，它管理着一个 IntArray 对象的生命周期。当引用计数降为0时，代理会自动删除指向的 IntArray 对象。这样就避免了传统的内存泄漏问题，并且能够自动管理对象的生命周期。

            
参考原文链接：https://blog.csdn.net/m0_56069910/article/details/136674420