大白帅1. 代理模式的核心概念与应用场景
在C++开发中，我们经常会遇到需要对对象访问进行控制的情况。代理模式（Proxy Pattern）就是一种结构型设计模式，它允许你提供一个代理对象来控制对原始对象的访问。这个代理对象与原始对象具有相同的接口，客户端代码无需修改就能同时处理代理和真实对象。
代理模式最常见的应用场景包括：
- 延迟初始化（虚拟代理）：当创建一个对象需要消耗大量资源时，可以使用代理来推迟实际对象的创建
- 访问控制（保护代理）：控制对原始对象的访问权限，例如权限验证
- 本地执行远程服务（远程代理）：适用于分布式系统，代理负责网络通信细节
- 日志记录（日志代理）：在访问实际对象前后进行日志记录
- 缓存结果（缓存代理）：为开销大的运算结果提供临时存储
提示：代理模式与装饰器模式在结构上相似，但目的不同。装饰器模式用于动态添加功能，而代理模式用于控制访问。
需要模型API调用？ 免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. C++中代理模式的实现方式
2.1 基础实现结构
在C++中实现代理模式通常包含以下核心组件：
cpp复制// 抽象接口
class Subject {
public:
virtual void Request() const = 0;
virtual ~Subject() = default;
};
// 真实对象
class RealSubject : public Subject {
public:
void Request() const override {
std::cout << "RealSubject: Handling the request.\n";
}
};
// 代理类
class Proxy : public Subject {
private:
RealSubject* real_subject_;
bool CheckAccess() const {
std::cout << "Proxy: Checking access prior to firing a real request.\n";
return true;
}
void LogAccess() const {
std::cout << "Proxy: Logging the time of request.\n";
}
public:
Proxy(RealSubject* real_subject) : real_subject_(new RealSubject(*real_subject)) {}
~Proxy() {
delete real_subject_;
}
void Request() const override {
if (this->CheckAccess()) {
this->real_subject_->Request();
this->LogAccess();
}
}
};
2.2 智能指针代理实现
现代C++中，我们可以使用智能指针来管理资源，避免内存泄漏：
cpp复制#include <memory>
class SmartProxy : public Subject {
private:
std::unique_ptr<RealSubject> real_subject_;
public:
SmartProxy(std::unique_ptr<RealSubject> real_subject)
: real_subject_(std::move(real_subject)) {}
void Request() const override {
if (!real_subject_) {
real_subject_ = std::make_unique<RealSubject>();
}
real_subject_->Request();
}
};
3. 代理模式的进阶应用
3.1 延迟加载代理
对于资源密集型对象，延迟加载可以显著提高程序启动速度：
cpp复制class HeavyResource {
public:
HeavyResource() {
// 模拟耗时初始化
std::this_thread::sleep_for(std::chrono::seconds(2));
std::cout << "HeavyResource initialized\n";
}
void Operation() {
std::cout << "HeavyResource operation performed\n";
}
};
class LazyProxy {
private:
mutable std::unique_ptr<HeavyResource> resource_;
public:
void Operation() const {
if (!resource_) {
resource_ = std::make_unique<HeavyResource>();
}
resource_->Operation();
}
};
3.2 线程安全代理
在多线程环境中，我们需要确保代理的线程安全性：
cpp复制#include <mutex>
class ThreadSafeProxy : public Subject {
private:
RealSubject* real_subject_;
mutable std::mutex mutex_;
public:
ThreadSafeProxy(RealSubject* real_subject) : real_subject_(real_subject) {}
void Request() const override {
std::lock_guard<std::mutex> lock(mutex_);
if (real_subject_) {
real_subject_->Request();
}
}
~ThreadSafeProxy() {
std::lock_guard<std::mutex> lock(mutex_);
delete real_subject_;
}
};
4. 代理模式在实际项目中的应用案例
4.1 数据库访问代理
在数据库操作中，代理可以用于连接管理和查询缓存：
cpp复制class Database {
public:
virtual std::vector<std::string> ExecuteQuery(const std::string& query) = 0;
virtual ~Database() = default;
};
class RealDatabase : public Database {
public:
std::vector<std::string> ExecuteQuery(const std::string& query) override {
// 实际数据库操作
std::cout << "Executing query: " << query << "\n";
return {"result1", "result2", "result3"};
}
};
class DatabaseProxy : public Database {
private:
RealDatabase* real_db_;
std::unordered_map<std::string, std::vector<std::string>> cache_;
public:
DatabaseProxy(RealDatabase* db) : real_db_(db) {}
std::vector<std::string> ExecuteQuery(const std::string& query) override {
if (cache_.find(query) != cache_.end()) {
std::cout << "Returning cached results for: " << query << "\n";
return cache_[query];
}
auto results = real_db_->ExecuteQuery(query);
cache_[query] = results;
return results;
}
~DatabaseProxy() {
delete real_db_;
}
};
4.2 图像加载代理
在图形应用程序中，代理可以优化图像加载过程：
cpp复制class Image {
public:
virtual void Display() = 0;
virtual ~Image() = default;
};
class HighResImage : public Image {
private:
std::string filename_;
void LoadFromDisk() {
std::cout << "Loading image: " << filename_ << "\n";
// 模拟耗时操作
std::this_thread::sleep_for(std::chrono::seconds(1));
}
public:
HighResImage(const std::string& filename) : filename_(filename) {}
void Display() override {
LoadFromDisk();
std::cout << "Displaying image: " << filename_ << "\n";
}
};
class ImageProxy : public Image {
private:
std::unique_ptr<HighResImage> real_image_;
std::string filename_;
public:
ImageProxy(const std::string& filename) : filename_(filename) {}
void Display() override {
if (!real_image_) {
real_image_ = std::make_unique<HighResImage>(filename_);
}
real_image_->Display();
}
};
5. 代理模式的性能考量与优化
5.1 代理引入的开销
代理模式虽然提供了很多好处，但也会引入一定的性能开销：
- 额外的间接层导致函数调用开销增加
- 访问控制检查带来的额外处理
- 内存占用增加（代理对象本身的内存）
5.2 优化策略
- 内联小型代理：对于简单的代理方法，可以使用inline关键字提示编译器内联
cpp复制class InlineProxy : public Subject {
private:
RealSubject* real_subject_;
public:
inline void Request() const override {
real_subject_->Request();
}
};
-
使用轻量级代理：避免在代理中存储不必要的数据
-
缓存频繁访问的结果：对于计算密集型操作，缓存结果可以显著提高性能
-
选择性代理：只为真正需要控制访问的方法实现代理
6. 代理模式与其他设计模式的比较
6.1 代理模式 vs 装饰器模式
虽然结构相似，但两者有本质区别：
- 代理：控制对对象的访问，通常管理其生命周期
- 装饰器：动态添加功能，不控制访问
6.2 代理模式 vs 适配器模式
- 代理：提供相同接口，控制访问
- 适配器：转换不同接口，使不兼容的类能一起工作
6.3 代理模式 vs 外观模式
- 代理：与目标对象接口相同，通常一对一关系
- 外观：简化复杂系统的接口，通常一对多关系
7. 现代C++中的代理模式实现技巧
7.1 使用模板实现通用代理
cpp复制template <typename T>
class GenericProxy {
private:
std::unique_ptr<T> real_object_;
public:
template <typename... Args>
GenericProxy(Args&&... args)
: real_object_(std::make_unique<T>(std::forward<Args>(args)...)) {}
// 转发所有成员函数调用
template <typename Method, typename... Args>
auto Call(Method method, Args&&... args) {
return (real_object_.get()->*method)(std::forward<Args>(args)...);
}
};
7.2 使用std::function实现动态代理
cpp复制class DynamicProxy {
private:
std::function<void()> real_operation_;
public:
template <typename F>
DynamicProxy(F&& f) : real_operation_(std::forward<F>(f)) {}
void Execute() {
std::cout << "Proxy: Before execution\n";
real_operation_();
std::cout << "Proxy: After execution\n";
}
};
7.3 使用CRTP实现静态代理
cpp复制template <typename Derived>
class ProxyBase {
public:
void Operation() {
static_cast<Derived*>(this)->PreOperation();
static_cast<Derived*>(this)->RealOperation();
static_cast<Derived*>(this)->PostOperation();
}
};
class ConcreteProxy : public ProxyBase<ConcreteProxy> {
private:
void PreOperation() { std::cout << "Pre-operation\n"; }
void RealOperation() { std::cout << "Real operation\n"; }
void PostOperation() { std::cout << "Post-operation\n"; }
public:
using ProxyBase<ConcreteProxy>::Operation;
};
8. 代理模式在大型项目中的实际应用经验
在实际项目中应用代理模式时，有几个关键点需要注意：
-
接口设计：确保代理和真实对象的接口完全一致，避免客户端代码需要区分两者
-
生命周期管理：明确代理对象是否拥有真实对象的所有权，使用智能指针可以简化资源管理
-
线程安全：如果代理会被多线程访问，需要确保所有成员函数的线程安全性
-
性能监控：代理是性能瓶颈的潜在位置，应该加入性能测量代码
-
日志记录：在代理中添加详细的日志记录，有助于调试和理解系统行为
注意：过度使用代理模式会导致系统复杂性增加。只有在真正需要控制访问或添加横切关注点（如日志、缓存等）时才应使用代理模式。