结构型 - 代理(Proxy)
代理模式(Proxy pattern): 为另一个对象提供一个替身或占位符以控制对这个对象的访问。
抛砖引玉
Proxy 模式可以解决的常见问题：
创建开销大的对象时候，比如显示一幅大的图片，我们将这个创建的过程交给代理去完成， GoF 称之为虚代理（ Virtual Proxy）；
为网络上的对象创建一个局部的本地代理， 比如要操作一个网络上的一个对象（网络性能不好的时候，问题尤其突出），我们将这个操纵的过程交给一个代理去完成， GoF 称之为远程代理（ Remote Proxy）；
对对象进行控制访问的时候， 比如在 Jive 论坛中不同权限的用户（如管理员、普通用户等） 将获得不同层次的操作权限， 我们将这个工作交给一个代理去完成， GoF 称之为保护代理（ Protection Proxy）。
智能指针（Smart Pointer）
Proxy 模式典型的结构图为：
代码实现
#ifndef _PROXY_H_
#define _PROXY_H_
class Subject
{
public:
virtual ~Subject();
virtual void Request() = 0;
protected:
Subject();
private:
};
class ConcreteSubject : public Subject
{
public:
ConcreteSubject();
~ConcreteSubject();
void Request();
protected:
private:
};
class Proxy
{
public:
Proxy();
Proxy(Subject *sub);
~Proxy();
void Request();
protected:
private:
Subject *_sub;
};
#endif //~_PROXY_H_1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include "Proxy.h"
#include <iostream>
using namespace std;
Subject::Subject()
{
}
Subject::~Subject()
{
}
ConcreteSubject::ConcreteSubject()
{
}
ConcreteSubject::~ConcreteSubject()
{
}
void ConcreteSubject::Request()
{
cout << "ConcreteSubject......request...." << endl;
}
Proxy::Proxy()
{
}
Proxy::Proxy(Subject *sub)
{
_sub = sub;
}
Proxy::~Proxy()
{
delete _sub;
}
void Proxy::Request()
{
cout << "Proxy request...." << endl;
_sub->Request();
}1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include "Proxy.h"
#include <iostream>
using namespace std;
int main(int argc,char* argv[])
{
Subject* sub = new ConcreteSubject();
Proxy* p = new Proxy(sub);
p->Request();
return 0;
}1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
[root@VM-16-6-centos Proxy]# ./ProxyTest
Proxy request....
ConcreteSubject......request....
1
2
3
2
3
代码说明
Proxy 模式的实现很简单，这里不做多余解释。可以看到，示例代码运行后， p 的 Request 请求实际上是交给了 sub 来实际执行。
讨论
Proxy 模式最大的好处就是实现了逻辑和实现的彻底解耦。