23 DesignPatterns学习笔记：C++语言实现 --- 2.7 Proxy

23 DesignPatterns学习笔记：C++语言实现 --- 2.7 Proxy

 2016-07-18 

（www.cnblogs.com/icmzn）

---

模式理解

 

 1. Proxy 代理模式
    为其他对象提供一种代理可以间接控制这个对象的访问。
    又称为“委托模式”，其他设计模式也是在代理模式的基础上扩展的，如“策略模式”“状态模式”“访问者模式”，代理模式的特殊应用。
在Spring的AOP技术，以及Struts的From元素映射就是代理行为。
    一般代理具有多种版本（扩展）如：普通代理模式，强制代理模式，动态代理模式
    一般代理的角色：
    （1）CAbsSubject： 抽象对象，被代理对象的一类的行为，抽象类或者接口。
    （2）Proxy： 代理类，通过组合的方式（has a）拥有一个CabsSubject的指针或者引用，通过将抽象类的接口调用委托被真实对象实现，
    从而可以通过代理控制真实对对象接口的“预处理”“善后处理”工作。代理类必须要是想CAbsSubjecrt接口，这样才能和被代理者保持相似。
    （3）RealSubject： 具体的被代理的对象，具体的业务执行者。

2. 代理的优点
（1）职责清晰
    被代理的对象，真实的subject就是实际的业务逻辑，只完成本职责的事物。
（2）高扩展性
    具体的Subject随时都可能发生变化，只要接口不变，代理类能不变，及时Subject发生变换。
（3）智能化
    通过“动态代理”，完成智能完成多点接入操作。

3. 代理的适用场景
    在实际的编程中，代理的应用场景非常多，SpringAOP（面向切面编程）就是一个智能动态代理应用。
（1）当常见一个大的对象的时候，如创建一个大的图片，可以使用代理来完成创建的过程
（2）为网络上的一个对象创建一个局部的本地代理，我们将操作网络上对象的过程通过操作本地代理来完成。
（3）对对象进行不同的权限控制访问的时候，不同权限的用户提供不同的操作权限，把这一控制过程交给代理对象来完成。
（4）类似于智能指针的操作方法，也使用到了代理思想。
4. 代理的讨论与扩展

（1）代理的扩展
 普通代理模式：
    环境只能访问代Proxy角色，而不能访问真实的Subject。即环境不能new 具体的Subject对象，只能通过代理类操作相应的Subject。
    即代理角色管理真实角色，通过代理角色直接操作真实对象。
    （在实际项目中，一般是通过禁止new真实Subect来实现。）
 强制代理模式：
    强制环境必须通过真实角色来查找代理角色，然后才能访问真实角色的属性方法。即不支持直接new CrealSubject，以及不允许new CProxy
    都不能访问。强制使用CRealSubject指定的CProx类才能访问。即真实角色管理代理类。在CabsSubject中添加getProxy（）方法，返回指定的代理对象。
    并在真实对象实现的方法中进行检测代理对象是否有效来判定限制。
有个性的代理类：
    代理类Proxy不仅可以实现CAbsSubject接口，而且也可以实现其他不同的接口，通过对CRealSubject的借口进行“过滤”拦截，从而增强CRealSubject。
    也可以组合其他真实的角色，这种情况下，代理类的职责并不一定单一。增强CrealSubject的预处理、过滤过滤消息、消息转发、事后处理消息。
 动态代理模式：
    定义，实现阶段并不关心代理的对象是谁，而是在运行阶段才指定哪一个对象。前面自己写代理类的属于“静态代理类”。
    AOP（Aspect Oriented Programming）核心思想就是采用了动态代理机制。在Java语言环境下可以提供动态代理接口InvocationHandler。
    AOP编程，对于我们的日志、事物、权限等都可以在系统设计阶段不用考虑，而在设计之后通过AOP贬称该技术方法，简单实现负责的作用。
    动态代理是代理的职责，是一个通用类，不具有业务意义。具体的CRealsubject实现相关的逻辑功能，二者之间没有相互耦合的关系。

---

 程序实现（C++）

 Proxy.h

#pragma once
#include <iostream>

using namespace std;

/*
    1.0 最简化的proxy类型结构
    （1）CAbsSubject类抽象接口
    （2）CRealSubject ， CProxy都要实现CAbsSubject接口，这样二者维持相似
    （3）CProxy 组合拥有一个CAbsSubject的引用或者指针，通过此指针完成对真实实现的预处理以及售后处理。
*/
class CAbsSubject
{
public:
    virtual void methodInvoke() = 0;
};

class CRealSubject :public CAbsSubject
{
public:
    void methodInvoke() override
    {
        cout << "实际对象调用方法执行中..." << endl;
    }

};

class CProxy : public CAbsSubject
{
public:
    CProxy(CAbsSubject* p) :m_pSubject(p){};
    //不释放被代理的对象
    ~CProxy(){};
    void methodInvoke() override
    {
        cout << "对象预处理...." << endl;
        m_pSubject->methodInvoke();//真实调用的实现部分
        cout << "对象善后处理...." << endl;
    }

private:
    CAbsSubject* m_pSubject;
};

/*
    1.1A 代理扩展：普通代理模式框架A
    环境只能访问代Proxy角色，而不能访问真实的Subject。即环境不能new 具体的Subject对象，只能通过代理类操作相应的Subject。
    （在代理内部实现真实Subject的创建，然后在真实Subject的沟站函数传入表示病判断）
    //或者直接将CRealSubject类构造声明为Protect：即可，但是太绝对
*/

class CAbsSubjectA
{
public:
    virtual void methodInvoke() = 0;

};

class CRealSubjectA : public CAbsSubjectA
{
public:
    CRealSubjectA(CAbsSubjectA* p = nullptr)
    {
        if (!p)
            throw "不能直接创建具体Subject使用，请借助于派生类...";
        
    }
    void methodInvoke() override
    {
        cout << "实际对象调用方法执行中..." << endl;
    }

};

class CProxyA : public CAbsSubjectA
{
public:
    CProxyA()
    {
        m_pSubject = new CRealSubjectA(this);
    }
    ~CProxyA()
    {
        delete m_pSubject;
    }
    //如果不继承基累的virtual纯虚拟方法，则不能创建对象this；
    void methodInvoke() override
    {
        cout << "对象预处理...." << endl;
        m_pSubject->methodInvoke();//真实调用的实现部分
        cout << "对象善后处理...." << endl;
    }

private:
    CAbsSubjectA* m_pSubject;
};

/*
1.1B 代理扩展：强制代理模式框架A
强制环境必须通过真实角色来查找代理角色，然后才能访问真实角色的属性方法。即不支持直接new CrealSubject，以及不允许new CProxy
都不能访问。强制使用CRealSubject指定的CProx类才能访问。即真实角色管理代理类。在CabsSubject中添加getProxy（）方法，返回指定的代理对象。
并在真实对象实现的方法中进行检测代理对象是否有效来判定限制。
    只要CRealSubject的getprox()没有调用，则成员一致为空，则方法就不能调用，所以必须在CREalSubject中的方法中进行代理类判定。
*/

class CAbsSubjectB
{
public:
    virtual void methodInvoke() = 0;
    virtual CAbsSubjectB* getTheProxy() = 0;
};

class CProxyB : public CAbsSubjectB
{
public:
    //代理特定的对象
    CProxyB(CAbsSubjectB* p)
    {
        m_pSubject = p;
    }
    //只使用，不清楚管理的指针
    ~CProxyB()
    {
    }
    //如果不继承基累的virtual纯虚拟方法，则不能创建对象this；
    void methodInvoke() override
    {
        cout << "对象预处理...." << endl;
        m_pSubject->methodInvoke();//真实调用的实现部分
        cout << "对象善后处理...." << endl;
    }
    //必须实现--没有意义
    CAbsSubjectB* getTheProxy()
    {
        return this;
    }
private:
    CAbsSubjectB* m_pSubject;
};

//智能使用真实对象指定的带来执行
class CRealSubjectB : public CAbsSubjectB
{
public:
    CRealSubjectB()
    {
        m_pProxy = nullptr;
    }
    void methodInvoke() override
    {
        if (isValidateProx())
        {
            //管理指定的具体对象的代理
            cout << "实际对象调用方法执行中..." << endl;
        }
        else
        {
            throw "强制使用(1)CrelSubject指定的(2)Cproxy对象调用...两个条件限制";
        }
    }
    //此方法不调用，m_pProxy永远为nullptr，则其方法永远不能调用
    CAbsSubjectB* getTheProxy()
    {
        m_pProxy = new CProxyB(this);
        return m_pProxy;
    }

private:
    bool isValidateProx()
    {
        if (m_pProxy)
            return true;
        else
            return false;
    }
private:
    CAbsSubjectB* m_pProxy;
};

/*
1.1B 代理扩展：C++实现动态代理机制实现？？？
*/

---

（1）模板应用

 main.cpp

// Proxys.cpp : 定义控制台应用程序的入口点。
//

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

#include "ProxyDef.h"
using namespace std;


int _tmain(int argc, _TCHAR* argv[])
{

    cout << "--------------------简单框架" << endl;
    CAbsSubject* p = new CRealSubject();
    CProxy* pProxy = new CProxy(p);
    pProxy->methodInvoke();


    cout << "--------------------普通代理类型框架：只允许使用代理类" << endl;
    try
    {
        CAbsSubjectA* pA = new CRealSubjectA();

    }
    catch (const char* error_c)
    {
        cout << "Error catched! ; " << error_c << endl;

    }

    CProxyA* pProxA = new CProxyA();
    pProxA->methodInvoke();


    cout << "--------------------强制代理框架：只允许使用CRealSubject" << endl;
    try
    {
        CAbsSubjectB* pB = new CRealSubjectB();
        CProxyB* pProxyB = new CProxyB(pB);
        //直接另外新建代理调用
        pProxyB->methodInvoke();

    }
    catch (const char* error_c)
    {
        cout << "Error catched! ; " << error_c << endl;

    }

    try
    {
        CAbsSubjectB* pB = new CRealSubjectB();
        //对象调用
        pB->methodInvoke();

    }
    catch (const char* error_c)
    {
        cout << "Error catched! ; " << error_c << endl;

    }
    //正常调用
    CRealSubjectB* pRealB = new CRealSubjectB();
    CAbsSubjectB* pB = pRealB->getTheProxy();
    pB->methodInvoke();

    cout << "--------------------动态代理框架" << endl;

    system("pause");
    return 0;
}

（2）输出展示