23设计模式之代理模式-种类 实际应用场景

已于 2024-05-14 12:51:21 修改
阅读量100 收藏
点赞数 3
文章标签： 代理模式 设计模式
于 2024-05-14 12:49:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36038987/article/details/138850068
版权 
代理模式代码

#include <iostream>
#include <string>

// 抽象主题接口
class Subject {
public:
    virtual void request() const = 0;
};

// 具体主题类
class RealSubject : public Subject {
public:
    void request() const override {
        std::cout << "RealSubject: Handling request." << std::endl;
    }
};

// 代理类
class Proxy : public Subject {
public:
    Proxy(Subject* real_subject) : real_subject_(real_subject) {}

    void request() const override {
        if (checkAccess()) {
            real_subject_->request();
        } else {
            std::cout << "Proxy: Access denied." << std::endl;
        }
    }

private:
    bool checkAccess() const {
        // 检查权限...
        return true; // 这里简单返回true，表示有权限
    }

    Subject* real_subject_;
};

int main() {
    // 创建真实主题对象
    RealSubject real_subject;

    // 创建代理对象并传入真实主题对象
    Proxy proxy(&real_subject);

    // 通过代理对象调用请求
    proxy.request();

    return 0;
}
在这个示例中，我们有一个抽象主题类 Subject，定义了一个虚拟的请求方法 request。RealSubject 是具体的主题类，实现了 request 方法，用于处理真正的请求。

Proxy 是代理类，也实现了 Subject 接口。它包含了一个指向 RealSubject 对象的成员变量，并在请求方法中对权限进行了检查。如果权限通过，代理会将请求转发给真正的主题对象处理，否则拒绝访问。

在 main 函数中，我们创建了一个真实主题对象和一个代理对象，然后通过代理对象调用请求方法。代理对象会根据权限决定是否转发请求给真实主题对象。

代理类的作用

代理类在设计模式中扮演着重要的角色，它能够为其他对象提供一个代理或者占位符，以控制对这个对象的访问。代理类通常包含与被代理对象相同的接口，使得代理对象可以替代被代理对象，并对其进行额外的控制、管理或者增强。代理类的作用包括但不限于以下几个方面：

远程代理（Remote Proxy）： 在分布式系统中，代理类可以作为远程对象的本地代表，隐藏了真实对象存在于不同地址空间的事实，使得客户端可以像调用本地对象一样调用远程对象。

虚拟代理（Virtual Proxy）： 当创建对象需要大量资源或者时间时，代理类可以充当对象的占位符，延迟创建真实对象，直到真正需要使用它时才进行实例化，从而提高系统的性能和效率。

保护代理（Protection Proxy）： 代理类可以控制对真实对象的访问权限，只有经过授权的用户才能访问真实对象，从而保护真实对象免受未经授权的访问。

智能引用代理（Smart Reference Proxy）： 代理类可以在调用真实对象的方法前后执行额外的操作，比如记录日志、实现缓存、懒加载等，从而增强真实对象的功能。

缓存代理（Caching Proxy）： 代理类可以缓存真实对象的结果，以减少对真实对象的重复调用，提高系统的性能。

日志记录代理（Logging Proxy）： 代理类可以记录对真实对象的访问日志，用于跟踪和调试系统的运行情况。

总的来说，代理类可以根据具体的需求和场景，对被代理对象进行各种形式的控制、管理和增强，从而提高系统的灵活性、可维护性和可扩展性。


下面是一个简单的示例代码，演示了一个日志记录代理：

cpp
复制代码
#include <iostream>
#include <string>

// 抽象主题接口
class Subject {
public:
    virtual void request() const = 0;
};

// 具体主题类
class RealSubject : public Subject {
public:
    void request() const override {
        std::cout << "RealSubject: Handling request." << std::endl;
    }
};

// 日志记录代理类
class LoggingProxy : public Subject {
public:
    LoggingProxy(Subject* real_subject) : real_subject_(real_subject) {}

    void request() const override {
        log("Before request");
        real_subject_->request();
        log("After request");
    }

private:
    void log(const std::string& message) const {
        std::cout << "LoggingProxy: " << message << std::endl;
    }

    Subject* real_subject_;
};

int main() {
    // 创建真实主题对象
    RealSubject real_subject;

    // 创建日志记录代理对象并传入真实主题对象
    LoggingProxy proxy(&real_subject);

    // 通过代理对象调用请求
    proxy.request();

    return 0;
}
在这个示例中，我们定义了一个抽象主题类 Subject 和一个具体主题类 RealSubject，其功能是处理请求。

然后我们定义了一个日志记录代理类 LoggingProxy，它也实现了 Subject 接口。在 LoggingProxy 中，我们重载了 request 方法，在调用真实主题对象的 request 方法之前和之后，分别记录了日志。

在 main 函数中，我们创建了一个真实主题对象和一个日志记录代理对象，并通过代理对象调用了请求方法。代理对象在调用真实主题对象的方法前后，分别记录了日志。

远程代理
远程代理（Remote Proxy）用于在分布式系统中代表远程对象。它隐藏了真实对象存在于不同地址空间的事实，使得客户端可以像调用本地对象一样调用远程对象。下面是一个简单的示例代码：

cpp
复制代码
#include <iostream>
#include <string>

// 抽象主题接口
class Subject {
public:
    virtual void request() const = 0;
};

// 具体主题类
class RealSubject : public Subject {
public:
    void request() const override {
        std::cout << "RealSubject: Handling request." << std::endl;
    }
};

// 远程代理类
class RemoteProxy : public Subject {
public:
    RemoteProxy(const std::string& remote_address) : remote_address_(remote_address) {}

    void request() const override {
        // 在这里实现远程调用逻辑，这里只是简单地打印信息
        std::cout << "RemoteProxy: Making remote request to " << remote_address_ << std::endl;

        // 创建真实主题对象的代理
        RealSubject real_subject;
        real_subject.request();
    }

private:
    std::string remote_address_;
};

int main() {
    // 创建远程代理对象并指定远程地址
    RemoteProxy proxy("http://example.com/remote");

    // 通过代理对象调用请求
    proxy.request();

    return 0;
}
在这个示例中，我们定义了一个抽象主题类 Subject 和一个具体主题类 RealSubject，其功能是处理请求。

然后我们定义了一个远程代理类 RemoteProxy，它也实现了 Subject 接口。在 RemoteProxy 中，我们实现了 request 方法，其中包含了远程调用的逻辑。这里的远程调用逻辑只是简单地打印了一条信息，并创建了真实主题对象的代理来处理请求。

在 main 函数中，我们创建了一个远程代理对象，并通过代理对象调用了请求方法。代理对象在调用请求方法时会执行远程调用的逻辑。

虚拟代理（Virtual Proxy）延迟创建真实对象，直到真正需要使用它时才进行实例化。下面是一个简单的示例代码：

cpp
复制代码
#include <iostream>
#include <string>

// 抽象主题接口
class Subject {
public:
    virtual void request() const = 0;
};

// 具体主题类
class RealSubject : public Subject {
public:
    void request() const override {
        std::cout << "RealSubject: Handling request." << std::endl;
    }
};

// 虚拟代理类
class VirtualProxy : public Subject {
public:
    void request() const override {
        // 延迟创建真实主题对象
        if (!real_subject_) {
            real_subject_ = new RealSubject;
        }

        // 使用真实主题对象处理请求
        real_subject_->request();
    }

private:
    RealSubject* real_subject_{nullptr};
};

int main() {
    // 创建虚拟代理对象
    VirtualProxy proxy;

    // 通过代理对象调用请求
    proxy.request();

    return 0;
}
在这个示例中，我们定义了一个抽象主题类 Subject 和一个具体主题类 RealSubject，其功能是处理请求。

然后我们定义了一个虚拟代理类 VirtualProxy，它也实现了 Subject 接口。在 VirtualProxy 中，我们实现了 request 方法，其中延迟创建了真实主题对象，直到真正需要使用它时才进行实例化。

在 main 函数中，我们创建了一个虚拟代理对象，并通过代理对象调用了请求方法。代理对象在调用请求方法时会延迟创建真实主题对象，并使用它来处理请求。


保护代理（Protection Proxy）控制对真实对象的访问权限，只有经过授权的用户才能访问真实对象。下面是一个简单的示例代码：

cpp
复制代码
#include <iostream>
#include <string>

// 抽象主题接口
class Subject {
public:
    virtual void request() const = 0;
};

// 具体主题类
class RealSubject : public Subject {
public:
    void request() const override {
        std::cout << "RealSubject: Handling request." << std::endl;
    }
};

// 保护代理类
class ProtectionProxy : public Subject {
public:
    ProtectionProxy(const std::string& user) : user_(user) {}

    void request() const override {
        // 检查权限
        if (checkAccess()) {
            // 如果权限通过，则使用真实主题对象处理请求
            real_subject_.request();
        } else {
            std::cout << "ProtectionProxy: Access denied for user " << user_ << "." << std::endl;
        }
    }

private:
    bool checkAccess() const {
        // 假设只有用户 "admin" 可以访问真实对象
        return user_ == "admin";
    }

    RealSubject real_subject_;
    std::string user_;
};

int main() {
    // 创建保护代理对象，指定用户为 "admin"
    ProtectionProxy proxy("admin");

    // 通过代理对象调用请求
    proxy.request();

    // 创建另一个保护代理对象，指定用户为 "guest"
    ProtectionProxy proxy2("guest");

    // 通过代理对象调用请求
    proxy2.request();

    return 0;
}
在这个示例中，我们定义了一个抽象主题类 Subject 和一个具体主题类 RealSubject，其功能是处理请求。

然后我们定义了一个保护代理类 ProtectionProxy，它也实现了 Subject 接口。在 ProtectionProxy 中，我们实现了 request 方法，其中检查了用户的权限。如果权限通过，则使用真实主题对象来处理请求，否则拒绝访问。

在 main 函数中，我们创建了两个保护代理对象，一个指定用户为 "admin"，另一个指定用户为 "guest"。只有第一个代理对象可以成功访问真实对象，因为只有用户 "admin" 才被授权访问。

缓存代理（Caching Proxy）用于缓存真实对象的结果，以减少对真实对象的重复调用，提高系统的性能。下面是一个简单的示例代码：

cpp
#include <iostream>
#include <unordered_map>

// 抽象主题接口
class Subject {
public:
    virtual std::string request(int key) const = 0;
};

// 具体主题类
class RealSubject : public Subject {
public:
    std::string request(int key) const override {
        std::cout << "RealSubject: Handling request for key " << key << "." << std::endl;
        // 模拟处理请求
        return "Result for key " + std::to_string(key);
    }
};

// 缓存代理类
class CachingProxy : public Subject {
public:
    std::string request(int key) const override {
        // 先尝试从缓存中获取结果
        auto it = cache_.find(key);
        if (it != cache_.end()) {
            std::cout << "CachingProxy: Returning cached result for key " << key << "." << std::endl;
            return it->second;
        }

        // 如果缓存中不存在，则调用真实主题对象处理请求，并缓存结果
        std::string result = real_subject_.request(key);
        cache_[key] = result;
        return result;
    }

private:
    RealSubject real_subject_;
    mutable std::unordered_map<int, std::string> cache_;
};

int main() {
    // 创建缓存代理对象
    CachingProxy proxy;

    // 第一次调用请求
    std::cout << proxy.request(1) << std::endl;

    // 第二次调用请求，应该从缓存中获取结果
    std::cout << proxy.request(1) << std::endl;

    // 第三次调用请求，使用不同的键，触发新的请求
    std::cout << proxy.request(2) << std::endl;

    return 0;
}
在这个示例中，我们定义了一个抽象主题类 Subject 和一个具体主题类 RealSubject，其功能是处理请求。

然后我们定义了一个缓存代理类 CachingProxy，它也实现了 Subject 接口。在 CachingProxy 中，我们实现了 request 方法，其中使用了一个 std::unordered_map 作为缓存，以存储已经处理过的请求结果。在处理请求时，先尝试从缓存中获取结果，如果缓存中不存在，则调用真实主题对象处理请求，并将结果缓存起来。

在 main 函数中，我们创建了一个缓存代理对象，并分别调用了几次请求方法，演示了缓存代理的工作原理。

QtC++ 开发从业者
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
iOS应用设计模式开发中对简单工厂和工厂方法模式的运用
09-02
同时，结合其他设计模式如单例、代理、观察者等，可以构建出更加优雅的iOS应用架构。 总的来说，简单工厂和工厂方法模式在iOS应用设计中扮演着重要的角色，帮助开发者以更加模块化和面向对象的方式组织代码，提高了...
PHP设计模式概论【概念、分类、原则等】
10-15
设计模式的分类主要分为三类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）和行为型模式（Behavioral Patterns）。 1. 创建型模式：这类模式主要关注对象的创建过程，如单例模式...
23 种设计模式详解（全23种）
热门推荐
人生智慧的博客
06-09 46万+
设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 A、创建...
呕心整理Java中的12种常用设计模式以及应用场景
只为code醉的博客
11-10 1万+
策略模式：策略模式是一种行为型模式，它将对象和行为分开，将行为定义为 一个行为接口 和 具体行为的实现。策略模式最大的特点是行为的变化，行为之间可以相互替换。每个if判断都可以理解为就是一个策略，可以使得算法可独立于使用它的用户而变化。使用场景：1. 假设现在某超市有三个等级的会员，普通会员，VIP1，VIP2。2. 在结账的时候，三个登记的会员购买了同一种商品，普通会员不打折，VIP1打9折，VIP2打8折。
Java中23种设计模式
呜呜老司机的博客家园
10-10 7万+
Java中23种设计模式，包括简单介绍，适用场景以及优缺点等
23种设计模式的分类和应用场景总结
qq_57125737的博客
04-27 370
23种设计模式的分类和应用场景总结
瑞_23种设计模式_代理模式
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
02-19 1797
本文章为瑞_系列专栏之《23种设计模式》的代理模式篇。在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。
spring框架常用的设计模式以及应用场景
m0_75031618的博客
04-22 638
Spring AOP就是基于动态代理的，如果要代理的对象，实现了某个接口，那么Spring AOP会使用JDK Proxy，去创建代理对象，而对于没有实现接口的对象，就无法使用JDK Proxy去进行代理了，这时候Spring AOP会使用Cglib，这时候Spring AOP会使用Cglib生成一个被代理对象的子类来作为代理。Resource接口本身没有提供访问任何底层资源的实现逻辑，针对不同的额底层资源，Spring将会提供不同的Resource实现类，不同的实现类负责不同的资源访问类型。
Java设计模式及应用场景之《代理模式》
晓呆同学的专栏
04-24 1405
代理对象夹在客户端和真实对象中间，相当于一个中转，那么在中转的时候，我们就可以实现很多的花招，比如，**权限控制**、**事务**、**记录日志**等。
Java设计模式---单例 工厂 代理模式
m0_69005620的博客
01-23 1614
意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。主要解决：一个全局使用的类频繁地创建与销毁所造成的资源浪费问题。何时使用：当您想控制实例数目，节省系统资源的时候。如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。关键代码：构造函数是私有的。简单工厂模式（Simple Factory Pattern）意图：提供一个用于创建对象的接口，让子类决定实例化哪一个类。结构：由一个工厂类负责创建不同类的产品对象。// 简单工厂角色} else {// 抽象产品角色。
设计模式的种类及其应用场景
AOMGyz的博客
06-09 1482
设计模式可以大致分为以下几类：创建型模式、结构型模式和行为型模式。每一类设计模式都有其独特的特点和应用场景。下面我将对这三类设计模式进行详细说明，并介绍它们各自的应用场景。
设计模式原理与应用之结构型模式.pptx
09-28
结构型模式是设计模式的一种分类，它关注如何组合类和对象，构建更大的结构。本篇主要讨论了七种结构型模式：Adapter、Bridge、Composite、Decorator、Façade、Flyweight和Proxy。 1. **Adapter模式**： - 适配器...
深入分析PHP设计模式
10-15
除此之外，PHP设计模式还有许多其他种类，如观察者模式、装饰器模式、代理模式、建造者模式等，它们在不同场景下各有优势。理解并灵活运用这些模式，能够提升代码的可读性、可维护性和扩展性，是成为一名专业PHP...
设计模式面试专题.docx
11-15
以下将详细讨论设计模式的六大原则以及它们在实际开发中的应用。 首先，我们来看单一职责原则。这个原则指出，一个类应该只有一个引起它变化的原因，即一个类只做一件事情。例如，在Android开发中，如果一个...
代理模式（静态代理/动态代理）
yuiezt的专栏
06-19 416
为其他对象提供一种代理，以控制对这个对象的访问。代理对象在客户端和目标对象之间起到了中介作用，起到保护或增强目标对象的作用。属于结构型设计模式。代理模式分为静态代理和动态代理。静态代理是显式声明被代理对象，即硬编码出来的代理结构；动态代理是动态配置和替换被代理对象，即通过在jvm中生成一个代理类来实现代理。
数据结构与算法笔记：基础篇 - 初始动态规划：如何巧妙解决“双十一”购物时的凑单问题？
chenjian723122704的专栏
06-20 864
淘宝的 “双十一” 购物节有各种促销活动，比如 “满 200 元减 50元”。假设你女朋友购物车中有 n 个（n > 100）想买的商品，它希望从里面选几个，在凑够满减条件的前提下，让选出来的商品价格总和最长成都接近满减条件（200 元），这样就可以极大限度地 “薅羊毛”。作为程序员的你，能不能编个代码来帮她搞定？要想高效地解决这个问题，就要用到本章讲的动态规划（Dynamic Programming）。
代理模式DDDDD+++++++boost io
最新发布
lusic01的专栏
06-20 217
这个简单的代码示例展示了如何使用Boost.Asio库来创建一个简单的TCP代理服务器。它接受客户端的连接请求，然后在新的线程中处理该连接。代理逻辑需要进一步实现，包括连接到目标服务器，以及双向数据的转发。这个示例只是展示了如何开始这样的工作，并没有完整实现代理的全部功能。以下是一个简化的C++网络代理服务器的核心代码示例，它展示了如何使用Boost.Asio库来实现一个简单的TCP代理。
Java多线程设计模式之保护性暂挂模式
weixin_42824596的博客
06-17 1106
多线程编程中，为了提高并发性，往往将一个任务分解为不同的部分。将其交由不同的线程来执行。这些线程间相互协作时，仍然可能会出现一个线程等待另一个线程完成一定的操作，其自身才能继续运行的情形。保护性暂挂模式（Guarded Suspension）可以帮助我们解决上述的等待问题。该模式的核心思想是如果某个线程执行特定的操作前需要满足一定的条件，则在该条件未满足时将该线程暂停运行（即暂挂线程，使其处于waiting状态，直到该条件满足时才继续运行）。
java23种设计模式应用场景
05-15
下面是Java 23种设计模式的应用场景： 1. 创建型模式： - 工厂方法模式：用于创建一些复杂的对象，例如工具类、数据库连接池等。 - 抽象工厂模式：用于创建一些相互依赖的对象，例如整个系统的主题、字体等。 - ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值