C++设计模式之代理模式(proxy)(结构型)

一 定义

代理模式：为其他对象提供一种代理以控制对这个对象的访问。

代理模式分类

（1）远程代理，也就是为一个对象在不同的地址空间提供局部代表。这样可以隐藏一个对象存在于不同地址空间的事实。

（2）虚拟代理，是根据需要创建开销很大的对象。通过他来存放实例化需要很长时间的真实对象。例如：图片加载的时候。

（3）安全代理，用来控制真是对象访问时的权限。

（4）智能指引，是指当调用真实的对象的时候，代理处理另外一些事。

根本原理：代理模式其实就是在访问对象的时候引入了一定程度的间接性，因为这种间接性，可以附加多种用途。

二 ULM图

Subject类：定义了RealSubject和Proxy的公用接口，这样就在任何使用RealSubject的地方都可以使用Proxy。

RealSubject类：定义Proxy所代表的真实实体。

Proxy类：保存一个引用使得代理可以访问实体，并提供一个与Subject的接口相同的接口，这样代理就可以用来替代实体。

1、代理模式的共同优点
能够协调调用者和被调用者，在一定程度上降低了系统的耦合度。

客户端可以针对抽象主题角色进行编程，增加和更换代理类无须修改源代码，符合开闭原则，系统具有较好的灵活性和可扩展性。

远程代理为位于两个不同地址空间对象的访问提供了一种实现机制，可以将一些消耗资源较多的对象和操作移至性能更好的计算机上，提高系统的整体运行效率。

虚拟代理通过一个消耗资源较少的对象来代表一个消耗资源较多的对象，可以在一定程度上节省系统的运行开销。

缓冲代理为某一个操作的结果提供临时的缓存存储空间，以便在后续使用中能够共享这些结果，优化系统性能，缩短执行时间。

保护代理可以控制对一个对象的访问权限，为不同用户提供不同级别的使用权限。

2、代理模式的缺点
由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢，例如保护代理。

实现代理模式需要额外的工作，而且有些代理模式的实现过程较为复杂，例如远程代理。

适用场景

当无法或者不想直接访问某个对象或访问直接某个对象消耗巨大时，可以采取通过一个代理对象来间接访问，为了保持对客户端透明，代理对象和被代理对象需要实现相同的接口。

当客户端对象需要访问远程主机中的对象时可以使用远程代理。

当需要用一个消耗资源较少的对象来代表一个消耗资源较多的对象，从而降低系统开销、缩短运行时间时可以使用虚拟代理，例如一个对象需要很长时间才能完成加载时。

当需要为某一个被频繁访问的操作结果提供一个临时存储空间，以供多个客户端共享访问这些结果时可以使用缓冲代理。通过使用缓冲代理，系统无须在客户端每一次访问时都重新执行操作，只需直接从临时缓冲区获取操作结果即可。

当需要控制对一个对象的访问，为不同用户提供不同级别的访问权限时可以使用保护代理。

当需要为一个对象的访问（引用）提供一些额外的操作时可以使用智能引用代理。

效果

Proxy模式在访问对象时引入了一定程度的间接性。根据代理的类型，附加的间接性有多种用途：
1) Remote Proxy可以隐藏一个对象存在于不同地址空间的事实。也使得客户端可以访问在远程机器上的对象，远程机器可能具有更好的计算性能与处理速度，可以快速响应并处理客户端请求。
2) Virtual Proxy 可以进行最优化，例如根据要求创建对象。即通过使用一个小对象来代表一个大对象，可以减少系统资源的消耗。
3) Protection Proxies和Smart Reference都允许在访问一个对象时有一些附加的内务处理（Housekeeping task） 。

Proxy模式还可以对用户隐藏另一种称之为写时复制（copy-on-write）的优化方式，该优化与根据需要创建对象有关。拷贝一个庞大而复杂的对象是一种开销很大的操作，如果这个拷贝根本没有被修改，那么这些开销就没有必要。用代理延迟这一拷贝过程，我们可以保证只有当这个对象被修改的时候才对它进行拷贝。在实现copy-on-write时必须对实体进行引用计数。拷贝代理仅会增加引用计数。只有当用户请求一个修改该实体的操作时，代理才会真正的拷贝它。在这种情况下，代理还必须减
少实体的引用计数。当引用的数目为零时，这个实体将被删除。copy-on-write可以大幅度的降低拷贝庞大实体时的开销。

 

三 虚拟代理

虚拟代理的优点
这种方法的优点是，在应用程序启动时，由于不需要创建和装载所有的对象，因此加速了应用程序的启动。

虚拟代理的缺点
因为不能保证特定的应用程序对象被创建，在访问这个对象的任何地方，都需要检测确认它不是空(null)。也就是，这种检测的时间消耗是最大的缺点。

虚拟代理的使用逐一实现
应用虚拟代理模式，需要设计一个与真实对象具有相同接口的单独对象（指虚拟代理）。不同的客户对象可以在创建和使用真实对象地方用相应的虚拟对象来代替。虚拟对象把真实对象的引用作为它的实例变量维护。代理对象不要自动创建真实对象，当客户需要真实对象的服务时，调用虚拟代理对象上的方法，并且检测真实对象是否被创建。如果真实对象已经创建，代理把调用转发给真实对象，如果真实对象没有被创建：

a、代理对象创建真实对象

b、代理对象把这个对象分配给引用变量。

c、代理把调用转发给真实对象

按照这种安排，验证对象存在和转发方法调用这些细节对于客户是不可见的。客户对象就像和真实对象一样与代理对象进行交互。因此客户从检测真实对象是否为null中解脱出来，另外，由于创建代理对象在时间和处理复杂度上要少于创建真实对象。因此，在应用程序启动的时候，用代理对象代替真实对象初始化。

3.1 实例

实例1：追求女孩子

Pursuit(追求者)通过Proxy(代理)送礼物给SchoolGirl(被追求者)。

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

//SchoolGirl类
class SchoolGirl
{
private:
	std::string name;
public:
	SchoolGirl(const std::string& name) :name{ name }
	{
	}
	void setName(std::string name)
	{
		this->name = name;
	}
	std::string getName()
	{
		return name;
	}
};

//Subject类，定义了RealSubject和Proxy的共用接口，这样就可以在任何使用RealSubject的地方使用Proxy
class IGiveGift
{
public:
	virtual void GiveDolls() = 0;
	virtual void GiveFlowers() = 0;
	virtual void GiveChocolate() = 0;
};

//RealSubject类，定义了Proxy所代表的真实实体
class Pursuit :public IGiveGift
{
private:
	std::unique_ptr<SchoolGirl> mm;
public:
	Pursuit(std::unique_ptr<SchoolGirl> mm) :mm{std::move(mm)}
	{
	}
	void GiveDolls()
	{
		std::cout << mm->getName() << "❤送给你的洋娃娃" << std::endl;
	}
	void GiveFlowers()
	{
		std::cout << mm->getName() << "❤送给你的鲜花" << std::endl;
	}
	void GiveChocolate()
	{
		std::cout << mm->getName() << "❤送给你的巧克力" << std::endl;
	}
};

//Proxy类，保存一个引用是的代理可以访问实体，并提供一个与Subject的接口相同的接口，这样代理就可以用来替代实体
class Proxy :public IGiveGift
{
private:
	Pursuit* gg;
public:
	Proxy(std::unique_ptr<SchoolGirl> mm)
	{
		gg = new Pursuit(std::move(mm));
	}
	void GiveDolls()
	{
		gg->GiveDolls();
	}
	void GiveFlowers()
	{
		gg->GiveFlowers();
	}
	void GiveChocolate()
	{
		gg->GiveChocolate();
	}
};

//Client，客户端
int main()
{
	auto daili = std::make_unique<Proxy>(std::make_unique<SchoolGirl>("陈阿娇"));

	daili->GiveDolls();
	daili->GiveFlowers();
	daili->GiveChocolate();

	return 0;
}

实例2：图像代理

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

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

class Image
{
public:
	Image(const std::string& imageName) : imageName(imageName) {}
	virtual ~Image() = default;
	virtual void Show() = 0;
protected:
	std::string imageName;
};
class BigImage : public Image
{
public:
	BigImage(const std::string& imageName) :Image(imageName) {}

	void Show() 
	{ 
		std::cout << "Show big image : " << imageName << std::endl; 
	}
};
class BigImageProxy : public Image
{
private:
	std::unique_ptr<BigImage> bigImage;
public:
	BigImageProxy(const std::string& imageName):Image(imageName)
	{}
	void Show()
	{
		if (not bigImage)
		{
			bigImage = std::make_unique<BigImage>(imageName);
		}
		bigImage->Show();
	}
};

int main()
{
	auto imageProxy = std::make_unique<BigImageProxy>("proxy.jpg"); //代理
	imageProxy->Show(); //需要时由代理负责打开

	return 0;
}

 四 安全代理

摘自：https://blog.csdn.net/lxq1997/article/details/90413202

 

#include <iostream>
#include <memory>

//抽象主题角色AbstractPermission
class AbstractPermission 
{
public:
	virtual void modifyUserInfo() = 0;
	virtual void viewNote() = 0;
	virtual void publishNote() = 0;
	virtual void modifyNote() = 0;
	virtual void setLevel(int level) = 0;
};

//真实主题角色RealPermission
class RealPermission : public AbstractPermission 
{
public:
	void modifyUserInfo() 
	{
		std::cout << "修改用户信息!" << std::endl;
	}

	void viewNote() 
	{
		std::cout << "查看帖子!" << std::endl;
	}

	void publishNote() 
	{
		std::cout << "发布新帖!" << std::endl;
	}

	void modifyNote() 
	{
		std::cout << "修改帖子!" << std::endl;
	}

	void setLevel(int level) 
	{

	}
};

//代理主题角色PermissionProxy
class PermissionProxy : public AbstractPermission 
{
public:
	PermissionProxy() 
	{
		permission = std::make_shared<RealPermission>();
		level = 0;
	}

	void modifyUserInfo() 
	{
		if (level == 0) 
		{
			std::cout << "对不起,你没有权限!" << std::endl;
		}
		else if (level == 1) 
		{
			permission->modifyUserInfo();
		}
	}

	void viewNote() 
	{
		std::cout << "查看帖子!" << std::endl;
	}

	void publishNote() 
	{
		if (level == 0) 
		{
			std::cout << "对不起,你没有权限!" << std::endl;
		}
		else if (level == 1) 
		{
			permission->publishNote();
		}
	}

	void modifyNote() 
	{
		if (level == 0) 
		{
			std::cout << "对不起,你没有权限!" << std::endl;
		}
		else if (level == 1) {
			permission->modifyNote();
		}
	}

	void setLevel(int level) {
		this->level = level;
	}
private:
	std::shared_ptr<RealPermission> permission;
	int level;
};

//客户端测试 
int main(void) 
{
	std::shared_ptr<AbstractPermission> permission = std::make_shared<PermissionProxy>();

	//普通权限代理 
	permission->modifyUserInfo();
	permission->viewNote();
	permission->publishNote();
	permission->modifyNote();

	std::cout << "----" << std::endl;

	//提升代理权限 
	permission->setLevel(1);

	permission->modifyUserInfo();
	permission->viewNote();
	permission->publishNote();
	permission->modifyNote();

	return 0;
}

运行结果如下：