在有些情况下，一个客户不能或者不想直接访问另一个对象，这时需要找一个中介帮忙完成某项任务，这个中介就是代理对象。例如，购买火车票不一定要去火车站买，可以通过 12306 网站或者去火车票代售点买。又如找女朋友、找保姆、找工作等都可以通过找中介完成。
在软件设计中，使用代理模式的例子也很多，例如，要访问的远程对象比较大（如视频或大图像等），其下载要花很多时间。还有因为安全原因需要屏蔽客户端直接访问真实对象，如某单位的内部数据库等。
一、定义与特点
代理模式的定义：由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。
代理模式的主要优点有：
- 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用；
- 代理对象可以扩展目标对象的功能；
- 代理模式能将客户端与目标对象分离，在一定程度上降低了系统的耦合度，增加了程序的可扩展性。
其主要缺点是：
- 代理模式会造成系统设计中类的数量增加；
- 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢；
- 增加了系统的复杂度。
二、结构与实现
代理模式的结构比较简单，主要是通过定义一个继承抽象主题的代理来包含真实主题，从而实现对真实主题的访问，下面来分析其基本结构和实现方法。
1. 模式的结构
代理模式的主要角色如下：
- 抽象主题（Subject）类：通过接口或抽象类声明真实主题和代理对象实现的业务方法。
- 真实主题（Real Subject）类：实现了抽象主题中的具体业务，是代理对象所代表的真实对象，是最终要引用的对象。
- 代理（Proxy）类：提供了与真实主题相同的接口，其内部含有对真实主题的引用，它可以访问、控制或扩展真实主题的功能。
其结构图如下图所示：
在代码中，一般代理会被理解为代码增强，实际上就是在原代码逻辑前后增加一些代码逻辑，而使调用者无感知。
根据代理的创建时期，代理模式分为静态代理和动态代理。
- 静态：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。
- 动态：在程序运行时，运用反射机制动态创建而成。
2.模式的实现
代理模式的实现代码如下：
#include <iostream>
using namespace std;
// 抽象主题
class Subject {
public:
void Request();
};
// 真实主题
class RealSubject: public Subject {
public:
void Request() {
cout << "访问真实主题方法..." << endl;
}
};
// 代理
class Proxy: public Subject {
public:
void Request() {
if (realSubject == nullptr) {
realSubject = new RealSubject();
}
preRequest();
realSubject->Request();
postRequest();
}
void preRequest() {
cout << "访问真实主题之前的预处理。" << endl;
}
void postRequest() {
cout << "访问真实主题之后的后续处理。" << endl;
}
private:
RealSubject *realSubject;
};
int main()
{
// 客户端调用
Proxy *proxy = new Proxy();
proxy->Request();
return 0;
}
程序运行的结果如下：
访问真实主题之前的预处理。
访问真实主题方法...
访问真实主题之后的后续处理。
三、应用实例
现在我们有一个人类，他整天就只负责吃饭、睡觉：
#include <iostream>
using namespace std;
// 抽象主题：人类的接口
class IPerson {
public:
virtual void eat() {}
virtual void sleep() {}
};
// 真实主题：人类
class Person: public IPerson {
public:
// @Override
void eat() {
cout << "我在吃饭" << endl;
}
// @Override
void sleep() {
cout << "我在睡觉" << endl;
}
};
int main()
{
// 客户端调用
IPerson *person = new Person();
person->eat();
person->sleep();
return 0;
}
运行程序，输出如下：
我在吃饭
我在睡觉
我们可以把这个类包装到另一个类中，实现完全一样的行为，将客户端也修改为调用这个新的类：
// 代理
class PersonProxy: public IPerson {
public:
PersonProxy(Person *person) {
this->person = person;
}
// @Override
void eat() {
cout << "代理：我在吃饭" << endl;
}
// @Override
void sleep() {
cout << "代理：我在睡觉" << endl;
}
private:
Person *person;
};
int main()
{
// 客户端调用
Person *person = new Person();
PersonProxy *proxy = new PersonProxy(person);
person->eat();
person->sleep();
return 0;
}
运行程序，输出如下：
代理：我在吃饭
代理：我在睡觉
这就是代理模式。我们在客户端和 Person 类之间新增了一个中间件 PersonProxy，这个类就叫做代理类，他实现了和 Person 类一模一样的行为。
现在这个代理类还看不出任何意义，我们来模拟一下工作中的需求。在实际工作中，我们可能会遇到这样的需求：在网络请求前后，分别打印将要发送的数据和接收到数据作为日志信息。此时我们就可以新建一个网络请求的代理类，让它代为处理网络请求，并在代理类中打印这些日志信息。
#include <iostream>
using namespace std;
// 抽象主题：网络请求接口
class IHttp {
public:
virtual void request(string sendData) = 0;
virtual void onSuccess(string receivedData) = 0;
};
// 真实主题：Http请求工具类
class HttpUtil: public IHttp {
public:
// @Override
void request(string sendData) {
cout << "网络请求中..." << endl;
}
// @Override
void onSuccess(string receivedData) {
cout << "网络请求完成。" << endl;
}
};
// 代理：Http代理类
class HttpProxy: public IHttp {
public:
HttpProxy(HttpUtil *httpUtil) {
this->httpUtil = httpUtil;
}
// @Override
void request(string sendData) {
cout << "send: " << sendData << endl;
httpUtil->request(sendData);
}
// @Override
void onSuccess(string receivedData) {
cout << "receive: " << receivedData << endl;
httpUtil->onSuccess(receivedData);
}
private:
HttpUtil *httpUtil;
};
int main()
{
// 客户端调用
HttpUtil *person = new HttpUtil();
HttpProxy *proxy = new HttpProxy(person);
proxy->request("request data");
proxy->onSuccess("received result");
return 0;
}
运行程序，输出如下：
send: request data
网络请求中...
receive: received result
网络请求完成。
这就是代理模式的一个应用，除了 打印日志，它还可以用来做权限管理。读者看到这里可能已经发现了，这个代理类看起来和装饰模式的 FilterInputStream 一模一样，但两者的目的不同，装饰模式是为了 增强功能或添加功能，代理模式主要是为了加以控制。
上例中的代理被称之为静态代理，动态代理与静态代理的原理一模一样，只是换了一种写法。使用动态代理，需要把一个类传入，然后根据它正在调用的方法名判断是否需要加以控制。具体代码就不在这里赘述了。