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

已于 2024-05-14 12:51:21 修改
阅读量97 收藏
点赞数 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
    评论
Android设计模式与应用场景
Alien__Chao的博客
10-09 2754
Android 设计模式 设计模式的目的只有一个，降低对象之间的耦合，增强程序的复用性、拓展性、维护性 1.设计模式的分类 设计模式一般分为三类：创建型模式、结构型模式、行为型模式 1.1 创建型模式(5种) (口诀：单抽工建原) 用来创建对象的。一共有五种：单例模式、原型模式、建造者模式、工厂方法模式、抽象工厂模式、。 [单例模式] ： 确保某一个类只有一个实例，并且提供一个全局访问点。 [抽象工厂模式]： 创建多个产品族中的产品对象。 [工厂方法模式]： 定义：让子类来决定要创建哪个对象;适用于
23.日志收集和监控的必要性.zip
06-26
常见的爬虫系统应用场景和挑战 爬虫系统架构设计 分布式爬虫系统架构模式 爬取策略和调度器设计 去重和增量爬取的技术和算法 数据存储与管理 分布式存储系统的选择和设计 数据去重和数据合并 大规模数据存储的优化...
23 种设计模式详解（全23种）
热门推荐
人生智慧的博客
06-09 45万+
设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 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 364
23种设计模式的分类和应用场景总结
瑞_23种设计模式_代理模式
阿瑞——从事Java后端，喜欢研读源码、自研框架、分享经验
02-19 1778
本文章为瑞_系列专栏之《23种设计模式》的代理模式篇。在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式，前者采用继承机制来组织接口和类，后者釆用组合或聚合来组合对象。由于组合关系或聚合关系比继承关系耦合度低，满足“合成复用原则”，所以对象结构型模式比类结构型模式具有更大的灵活性。
Java设计模式及应用场景之《代理模式》
晓呆同学的专栏
04-24 1399
代理对象夹在客户端和真实对象中间，相当于一个中转，那么在中转的时候，我们就可以实现很多的花招，比如，**权限控制**、**事务**、**记录日志**等。
Java设计模式---单例 工厂 代理模式
m0_69005620的博客
01-23 1593
意图：保证一个类仅有一个实例，并提供一个访问它的全局访问点。主要解决：一个全局使用的类频繁地创建与销毁所造成的资源浪费问题。何时使用：当您想控制实例数目，节省系统资源的时候。如何解决：判断系统是否已经有这个单例，如果有则返回，如果没有则创建。关键代码：构造函数是私有的。简单工厂模式（Simple Factory Pattern）意图：提供一个用于创建对象的接口，让子类决定实例化哪一个类。结构：由一个工厂类负责创建不同类的产品对象。// 简单工厂角色} else {// 抽象产品角色。
代理模式的优缺点和使用场景
m0_51982191的博客
08-30 966
代理模式的优缺点和使用场景
2.案例-doubanbook爬虫改造(二).zip
06-26
常见的爬虫系统应用场景和挑战 爬虫系统架构设计 分布式爬虫系统架构模式 爬取策略和调度器设计 去重和增量爬取的技术和算法 数据存储与管理 分布式存储系统的选择和设计 数据去重和数据合并 大规模数据存储的优化...
3.案例-doubanbook爬虫改造(三).zip
06-26
常见的爬虫系统应用场景和挑战 爬虫系统架构设计 分布式爬虫系统架构模式 爬取策略和调度器设计 去重和增量爬取的技术和算法 数据存储与管理 分布式存储系统的选择和设计 数据去重和数据合并 大规模数据存储的优化...
4.案例-doubanbook爬虫改造(四).zip
06-26
常见的爬虫系统应用场景和挑战 爬虫系统架构设计 分布式爬虫系统架构模式 爬取策略和调度器设计 去重和增量爬取的技术和算法 数据存储与管理 分布式存储系统的选择和设计 数据去重和数据合并 大规模数据存储的优化...
1.案例-doubanbook爬虫改造(一).zip
06-26
常见的爬虫系统应用场景和挑战 爬虫系统架构设计 分布式爬虫系统架构模式 爬取策略和调度器设计 去重和增量爬取的技术和算法 数据存储与管理 分布式存储系统的选择和设计 数据去重和数据合并 大规模数据存储的优化...
279. 完全平方数
m0_63653444的博客
06-09 363
动态规划的转移方程就对应递归的过程，动态规划的初始条件就对应递归的出口。递归相当于先压栈压栈然后出栈出栈，动态规划可以省去压栈的过程。解法一超时，解法二优化通过使用 HashMap 保存。
代理模式与静态代理、动态代理的实现（Proxy.newProxyInstance、InvocationHandler）
李斯维的博客空间
06-12 876
代理模式是23种设计模式中比较常用的一种，属于结构型设计模式。在 Android 领域中，有大量的库都使用了代理模式，例如 Retrofit 使用动态代理来实现 API 接口的调用，Dagger 使用代码生成和反射机制来创建依赖注入的代理对象等等。本文将带你了解代理模式，并且介绍静态代理和动态代理的实现方式。
Java 代理模式
最新发布
weixin_42824596的博客
06-13 699
代理模式简单来说就是使用代理对象来代替对真实对象的访问，这样就可以在不修改原目标对象的前提下，提供额外的功能操作，扩展目标对象的功能。代理模式的主要作用是扩展目标对象的功能，比如说在目标对象的某个方法执行前后可以增加一些自定义操作。代理模式有静态代理和动态代理两种实现方式。
代码随想录算法训练营第36期DAY57
illuosion7的博客
06-11 799
想起来了，是贪心算法，sum<0会减小后一位数字，因此continue;同时记录过程中的maxres.记得记录过程中的最大值，并且注意res的初值。分析法和上一题的图片一样。今天的好消息：能去华五。
java23种设计模式应用场景
05-15
下面是Java 23种设计模式的应用场景： 1. 创建型模式： - 工厂方法模式：用于创建一些复杂的对象，例如工具类、数据库连接池等。 - 抽象工厂模式：用于创建一些相互依赖的对象，例如整个系统的主题、字体等。 - ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值