[设计模式] 设计模式课程（十三）-- 代理模式

概述

• 属于结构型模式
• 提供代理作为对象的替代品或其占位符，代理控制对原对象的访问，并可对请求在提交给对象前后进行一些处理
• 由于某种原因（如对象创建开销很大，某种操作需要安全控制，或者需要进程外访问等）直接访问会给使用者或者系统结构带来很多麻烦
• 如何在不失去透明操作对象的同时来管理 / 控制这些对象特有的复杂性？增加一层间接层
• 为其他对象提供一种代理以控制（隔离，使用接口）对这个对象的访问
• “增加一层间接层”是软件系统中对很多复杂问题的一种常见解决方式，在面向对象系统中，直接使用某些对象会带来很多问题，作为间接层的proxy是解决这一问题的常用手段
• 具体实现方法、实现粒度都相差很大，有些可能对单个对象做细粒度的控制，如copy-on-write技术，有些可能对组件模块提供抽象代理层，在架构层次对对象做proxy
• Proxy并不一定要求保持接口完整的一致性，只要能够实现间接控制，有时损及一些透明性是可以接受的

场景

• 数据库对象非常巨大，查询操作缓慢，但并非总是用到。代理将自己伪装成数据库对象，可在客户端或实际数据库对象不知情的情况下处理延迟初始化和缓存查询结果的工作
• 信用卡是银行账户的代理
• Windows里的快捷方式
• 买火车票可以去车站买，也可以去代售点买
• spring aop

结构

• 服务接口：代理必须遵循该接口才能伪装成服务对象
• 服务类：提供业务逻辑
• 代理类：包含指向服务对象的引用成员变量，代理其完成任务（延迟初始化、日志、访问控制、缓存等）后将请求传递给服务对象
• 客户端：通过同一接口与服务或代理进行交互

示例1

client.cpp

class ISubject{
public:
    virtual void process();
};

class RealSubject: public ISubject{
public:
    virtual void process(){
        //....
    }
};

class ClientApp{
    
    ISubject* subject;
    
public:
    
    ClientApp(){
        subject=new RealSubject();
    }
    
    void DoTask(){
        //...
        subject->process();
        
        //....
    }
};

proxy.cpp

class ISubject{
public:
    virtual void process();
};

//Proxy的设计
class SubjectProxy: public ISubject{
    
    
public:
    virtual void process(){
        //对RealSubject的一种间接访问
        //....
    }
};

class ClientApp{
    
    ISubject* subject;
    
public:
    
    ClientApp(){
        subject=new SubjectProxy();
    }
    
    void DoTask(){
        //...
        subject->process();
        
        //....
    }
};

示例2

#include <string>
#include <iostream>
using namespace std;

// 定义接口 
class Interface{
    public:
        virtual void Request() = 0 ;
};
// 真实类 
class RealClass:public Interface{
    public:
        virtual void Request(){
            cout<<"真实的请求"<<endl;
        }
};
// 代理类 
class ProxyClass:public Interface{
    private:
        RealClass* m_realClass;
    public:
        virtual void Request(){
            m_realClass = new RealClass();
            m_realClass->Request();
            delete m_realClass;
        }
};
// 客户端
int main(){
    ProxyClass* test = new ProxyClass();
    test->Request();
    return 0;
} 

>>真实的请求

示例3

• 使用代理模式在腾讯视频（TencentVideo，记为TV）程序库中添加延迟初始化和缓存
• 程序库提供了下载类，但效率非常低，如果客户端多次请求下载同一视频，程序会反复下载，而不会将首次下载的文件缓存复用
• 代理类实现和原下载器相同的接口，并将工作委派给原下载器，但代理类会保存所有文件下载记录，如果程序请求同一文件，则返回缓存文件

// 远程服务接口。
interface ThirdPartyTVLib is
    method listVideos()
    method getVideoInfo(id)
    method downloadVideo(id)

// 服务连接器的具体实现。该类的方法可以向腾讯视频请求信息。请求速度取决于
// 用户和腾讯视频的互联网连接情况。如果同时发送大量请求，即使所请求的信息
// 一模一样，程序的速度依然会减慢。
class ThirdPartyTVClass implements ThirdPartyTVLib is
    method listVideos() is
        // 向腾讯视频发送一个 API 请求。

    method getVideoInfo(id) is
        // 获取某个视频的元数据。

    method downloadVideo(id) is
        // 从腾讯视频下载一个视频文件。

// 为了节省网络带宽，我们可以将请求结果缓存下来并保存一段时间。但你可能无
// 法直接将这些代码放入服务类中。比如该类可能是第三方程序库的一部分或其签
// 名是`final（最终）`。因此我们会在一个实现了服务类接口的新代理类中放入
// 缓存代码。当代理类接收到真实请求后，才会将其委派给服务对象。
class CachedTVClass implements ThirdPartyTVLib is
    private field service: ThirdPartyTVLib
    private field listCache, videoCache
    field needReset

    constructor CachedTVClass(service: ThirdPartyTVLib) is
        this.service = service

    method listVideos() is
        if (listCache == null || needReset)
            listCache = service.listVideos()
        return listCache

    method getVideoInfo(id) is
        if (videoCache == null || needReset)
            videoCache = service.getVideoInfo(id)
        return videoCache

    method downloadVideo(id) is
        if (!downloadExists(id) || needReset)
            service.downloadVideo(id)

// 之前直接与服务对象交互的 GUI 类不需要改变，前提是它仅通过接口与服务对
// 象交互。我们可以安全地传递一个代理对象来代替真实服务对象，因为它们都实
// 现了相同的接口。
class TVManager is
    protected field service: ThirdPartyTVLib

    constructor TVManager(service: ThirdPartyTVLib) is
        this.service = service

    method renderVideoPage(id) is
        info = service.getVideoInfo(id)
        // 渲染视频页面。

    method renderListPanel() is
        list = service.listVideos()
        // 渲染视频缩略图列表。

    method reactOnUserInput() is
        renderVideoPage()
        renderListPanel()

// 程序可在运行时对代理进行配置。
class Application is
    method init() is
        aTVService = new ThirdPartyTVClass()
        aTVProxy = new CachedTVClass(aTVService)
        manager = new TVManager(aTVProxy)
        manager.reactOnUserInput()

示例4

#include <iostream>
/**
 * The Subject interface declares common operations for both RealSubject and the
 * Proxy. As long as the client works with RealSubject using this interface,
 * you'll be able to pass it a proxy instead of a real subject.
 */
class Subject {
 public:
  virtual void Request() const = 0;
};
/**
 * The RealSubject contains some core business logic. Usually, RealSubjects are
 * capable of doing some useful work which may also be very slow or sensitive -
 * e.g. correcting input data. A Proxy can solve these issues without any
 * changes to the RealSubject's code.
 */
class RealSubject : public Subject {
 public:
  void Request() const override {
    std::cout << "RealSubject: Handling request.
";
  }
};
/**
 * The Proxy has an interface identical to the RealSubject.
 */
class Proxy : public Subject {
  /**
   * @var RealSubject
   */
 private:
  RealSubject *real_subject_;

  bool CheckAccess() const {
    // Some real checks should go here.
    std::cout << "Proxy: Checking access prior to firing a real request.
";
    return true;
  }
  void LogAccess() const {
    std::cout << "Proxy: Logging the time of request.
";
  }

  /**
   * The Proxy maintains a reference to an object of the RealSubject class. It
   * can be either lazy-loaded or passed to the Proxy by the client.
   */
 public:
  Proxy(RealSubject *real_subject) : real_subject_(new RealSubject(*real_subject)) {
  }

  ~Proxy() {
    delete real_subject_;
  }
  /**
   * The most common applications of the Proxy pattern are lazy loading,
   * caching, controlling the access, logging, etc. A Proxy can perform one of
   * these things and then, depending on the result, pass the execution to the
   * same method in a linked RealSubject object.
   */
  void Request() const override {
    if (this->CheckAccess()) {
      this->real_subject_->Request();
      this->LogAccess();
    }
  }
};
/**
 * The client code is supposed to work with all objects (both subjects and
 * proxies) via the Subject interface in order to support both real subjects and
 * proxies. In real life, however, clients mostly work with their real subjects
 * directly. In this case, to implement the pattern more easily, you can extend
 * your proxy from the real subject's class.
 */
void ClientCode(const Subject &subject) {
  // ...
  subject.Request();
  // ...
}

int main() {
  std::cout << "Client: Executing the client code with a real subject:
";
  RealSubject *real_subject = new RealSubject;
  ClientCode(*real_subject);
  std::cout << "
";
  std::cout << "Client: Executing the same client code with a proxy:
";
  Proxy *proxy = new Proxy(real_subject);
  ClientCode(*proxy);

  delete real_subject;
  delete proxy;
  return 0;
}

参考

https://refactoringguru.cn/design-patterns/proxy