Proxy（代理）模式

---

前言

        本周五参加了Proxy（代理）模式研讨会，本文的目的是对这个模式的总结和分享，希望对需要学习这个设计模式的同学有所帮助。本文一共分为两个部分，第一个部分是代理模式的基础知识总结；第二个部分是一个例子分享。

---

一、代理模式总结

        

1、模式意图

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

2、参与者

Proxy
-- 保存一个引用使得代理可以访问实体；
-- 提供一个与subject相同的接口，代理可以替代实体；
-- 控制对实体的存取，创建或销毁；
Subject
-- 定义realsubject和proxy的共用接口；
RealSubject
-- 定义proxy所代表的实体；

3、结构

结构图：

4、适用性

1）remote proxy（远程代理）：为一个不同地址空间的对象提供局部代理；
2）virtual proxy（虚代理）：根据需要创建开销很大的对象；
3）protection proxy：控制对原对象的访问；
4）smart reference：取代简单指针，它在访问对象时执行一些附加操作（引用计数、对象装载、保护锁）；

5、效果

1）remote proxy可以隐藏一个对象存在于不同地址空间的事实。
2）virtual proxy可以进行最优化，可根据需要创建对象。
3）protection proxy和smart reference都允许在访问一个对象时有一些附加的内务处理。

---

二、代理模式应用示例

         这里举的例子是C++的智能指针（SmartPointer），属于smart reference，它取代一个简单指针，并且在操作指针时，附带对指针做引用计数、负责把销毁指针等。在C++泛型编程中，智能指针被设计为一个模板类，这是因为指针的操作方式是不变的，跟指针具体的类型无关。下面是C++实现一个简单的智能指针源码示例：

template<typename T>
class SmartPointer {
private:
    T* proxy_ptr;
    size_t* count;
public:

    SmartPointer(T* ptr = nullptr);
    SmartPointer(const SmartPointer& ptr);
    SmartPointer& operator=(const SmartPointer& ptr);
    T& operator*();
    T* operator->();    
    size_t ref_count();
    ~SmartPointer();
};

template<typename T>
SmartPointer<T>::SmartPointer(T* ptr) : proxy_ptr(ptr) {
    if (this.proxy_ptr) {
        count = new size_t(1);
    }
    else {
        count = new size_t(0);
    }
}

template<typename T>
SmartPointer<T>::SmartPointer(const SmartPointer& ptr) {
    if (this != &ptr) {
        this->proxy_ptr = ptr.proxy_ptr;
        this->count = ptr.count;
        (*this->count)++;
    }
}

template<typename T>
SmartPointer<T>& SmartPointer<T>::operator=(const SmartPointer& ptr) {
    if (this->proxy_ptr == ptr.proxy_ptr) {
        return *this;
    }

    if (this->proxy_ptr) {
        (*this->count)--;
        if (this->count == 0) {
            delete this->proxy_ptr;
            delete this->count;
        }
    }

    this->proxy_ptr = ptr.proxy_ptr;
    this->count = ptr.count;
    (*this->count)++;
    return *this;
}

template<typename T>
T& SmartPointer<T>::operator*() {
    assert(this->proxy_ptr == nullptr);
    return *(this->proxy_ptr);

}

template<typename T>
T* SmartPointer<T>::operator->() {
    assert(this->proxy_ptr == nullptr);
    return this->proxy_ptr;
}

template<typename T>
size_t SmartPointer<T>::ref_count() {
    return *this->count;
}

template<typename T>
SmartPointer<T>::~SmartPointer() {
    (*this->count)--;
    if (*this->count == 0) {
        delete this->proxy_ptr;
        delete this->count;
    }
}

从上面的智能指针实现代码可以看到，SmartPointer重载了运算符*和->，我们在使用SmartPointer对象的时候，和直接使用指针的方式是一样的。SmartPointer转发了客户的请求到实际的被代理的对象，客户对SmartPointer对象的操作，就像直接操作被代理指针一样，没有区别。但是SmartPointer额外管理了被代理指针的生命周期，当被代理对象的引用计数为0后，智能指针会销毁被代理的指针所指向的对象。

---

总结

         代理模式是比较常见的模式，除了上面介绍的智能指针，它还广泛用于网络应用开发，比如远程代理服务器等。当我们想控制一个对象的访问时，可以使用代理模式把客户代码和实际对象隔离开来，提供一个中间层来管理对实际对象的访问，把客户和对象解耦合。
本文知识点：
1、简单智能指针的实现；
2、模板类、模板函数；
3、代理模式基础知识；