代理模式
代理模式是一种结构型设计模式，它的主要作用是为其他对象提供一种代理以控制对这个对象的访问。代理对象与被代理对象实现了相同的接口，客户端通过代理对象访问被代理对象，代理对象对客户端的请求进行处理并将请求转发给被代理对象，从而实现了对被代理对象的访问控制和增加功能。
代理模式主要的应用场景是：
保护目标对象：代理对象可以控制对目标对象的访问，例如可以检查客户端是否有足够的权限来访问目标对象，或者限制客户端对目标对象的访问次数等。这一般称为安全代理。
增强目标对象：代理对象可以在不改变目标对象的情况下，为目标对象增加一些额外的功能，例如缓存、懒加载、日志记录等，称为缓存代理，日志代理等。
远程访问对象：代理对象可以实现远程访问对象，例如通过网络访问远程服务器上的对象，或者通过远程代理来实现对象的序列化和反序列化等，称为远程代理。
减少系统开销：代理对象可以在目标对象还没有被完全创建时，先返回一个虚拟的占位给客户端，这样可以减少系统的开销，提高性能，或者提高界面的美观度（比如网页加载元素需要一些时间，这时候可以返回一个占位的框架图给前端页面），称为虚拟代理。
下面给出一个代理模式的C++程序示例：
#include <iostream>
#include <string>
#include <memory>
// 抽象主题类
class Subject
{
public:
virtual void request() = 0;
};
// 真实主题类
class RealSubject : public Subject
{
public:
RealSubject(const std::string& name)
{
this->name = name;
}
virtual void request()
{
std::cout << "RealSubject " << this->name << " is handling the request." << std::endl;
}
private:
std::string name;
};
// 代理类
class Proxy : public Subject
{
public:
Proxy(std::shared_ptr<RealSubject> realSubject)
{
this->realSubject = realSubject;
}
virtual void request()
{
// 在调用真实主题对象的方法之前，可以执行一些前置操作
std::cout << "Proxy is preparing to handle the request." << std::endl;
// 调用真实主题对象的方法
this->realSubject->request();
// 在调用真实主题对象的方法之后，可以执行一些后置操作
std::cout << "Proxy has finished handling the request." << std::endl;
}
private:
std::shared_ptr<RealSubject> realSubject;
};
// 客户端类
class Client
{
public:
Client()
{
this->proxy = nullptr;
}
void setProxy(std::shared_ptr<Proxy> proxy)
{
this->proxy = proxy;
}
void request()
{
if (this->proxy != nullptr)
{
this->proxy->request();
}
else
{
std::cout << "No proxy is set, cannot handle the request." << std::endl;
}
}
private:
std::shared_ptr<Proxy> proxy;
};
int main()
{
// 创建真实主题对象
auto realSubject = std::make_shared<RealSubject>("A");
// 创建代理对象，并将真实主题对象传入代理对象的构造函数中
auto proxy = std::make_shared<Proxy>(realSubject);
// 创建客户端对象
auto client = std::make_shared<Client>();
// 设置代理对象给客户端
client->setProxy(proxy);
// 通过客户端对象来调用代理对象的方法
client->request();
return 0;
}
在上面的示例代码中，抽象主题类 Subject 定义了一个抽象方法 request()，真实主题类 RealSubject 实现了 request() 方法，并在方法内部输出了一条消息。代理类 Proxy 继承了抽象主题类 Subject，并持有一个真实主题类 RealSubject 的指针，在代理类的 request() 方法内部调用真实主题对象的 request() 方法，并在方法之前和之后执行一些前置和后置操作。
在 main() 函数中，我们创建了一个真实主题对象 realSubject，并将它传入代理对象的构造函数中，创建了代理对象 proxy，并通过代理对象来调用真实主题对象的方法。然后，我们创建了一个客户端对象 client，并通过 setProxy() 方法将代理对象 proxy 设置给客户端对象。客户端对象通过 request() 方法来调用代理对象的方法，代理对象再转发请求给真实主题对象，从而实现了对目标对象的访问控制和增加功能。
Qt模型/视图（Model/View）框架中的代理模式
Qt的模型/视图（Model/View）框架就包含了代理模式。在模型/视图框架中，模型类（如QAbstractItemModel）存储数据，视图类（如QTableView）负责显示模型中的数据。此外，还有代理模型类（如QSortFilterProxyModel），它们同时实现了模型和视图的接口，充当了模型和视图之间的代理。
QSortFilterProxyModel就是一个很好的代理模式的例子。它是QAbstractItemModel的子类，主要作用是在不修改源模型的情况下，对源模型的数据进行排序和过滤。
在这种情况下，QSortFilterProxyModel类是代理类，QAbstractItemModel（或其任何具体的子类）是真实主题类，视图（如QTableView）是Client。QSortFilterProxyModel和QAbstractItemModel都继承自同一个抽象主题类QAbstractItemModel。在Qt开发中，这几个类的使用如程序示例所示：
#include <QApplication>
#include <QTableView>
#include <QStandardItemModel>
#include <QSortFilterProxyModel>
int main(int argc, char* argv[]) {
QApplication a(argc, argv);
// 创建模型并添加数据
QStandardItemModel model(30, 5);
for (int row = 0; row < model.rowCount(); ++row) {
for (int column = 0; column < model.columnCount(); ++column) {
QStandardItem* item = new QStandardItem(QString("Row:%0, Column:%1").arg(row).arg(column));
model.setItem(row, column, item);
}
}
// 创建代理模型并设置源模型
QSortFilterProxyModel proxyModel;
proxyModel.setSourceModel(&model);
// 对第一列列进行过滤
proxyModel.setFilterKeyColumn(1);
// 筛选含有2的列
proxyModel.setFilterRegExp(QRegExp("2", Qt::CaseInsensitive, QRegExp::FixedString));
// 创建视图并设置模型
QTableView view;
view.setModel(&proxyModel);
view.setSortingEnabled(true); // 启用排序功能
view.show();
return a.exec();
}
在这个例子中，我们创建了一个QStandardItemModel并添加了一些数据。然后我们创建了一个QSortFilterProxyModel，并将其源模型设置为我们之前创建的QStandardItemModel。然后，我们设置了过滤规则，只筛选第一列，只显示包含"2"的行。最后，我们创建了一个QTableView，并将其模型设置为我们的代理模型。注意，我们还启用了视图的排序功能，这样用户就可以通过点击列标题来对视图中的数据进行排序。
在运行这个程序后，你会看到一个表格视图，只显示了满足我们过滤规则的行，并且用户可以通过点击列标题来对视图中的数据进行排序。
介绍完类的使用方式，我们就要重回正题了，即模型/视图框架如何使用代理模式。下面这段程序描述了Qt源码中这几个类之间的关系和组织方式，虽然隐藏了许多细节，但相信还是能够体现出Qt源码如何使用代理模式的。
// 抽象主题类，定义模型接口
class QAbstractItemModel {
public:
virtual QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const = 0;
virtual QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const = 0;
virtual bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) = 0;
virtual int rowCount(const QModelIndex &parent = QModelIndex()) const = 0;
virtual int columnCount(const QModelIndex &parent = QModelIndex()) const = 0;
// 其他模型接口方法...
};
// 具体的模型类，实现模型接口
class QStandardItemModel : public QAbstractItemModel {
public:
QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override;
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override;
int rowCount(const QModelIndex &parent = QModelIndex()) const override;
int columnCount(const QModelIndex &parent = QModelIndex()) const override;
// 其他模型接口方法的实现...
};
// 代理类，继承自抽象主题类，扩展了排序和过滤功能
class QSortFilterProxyModel : public QAbstractItemModel {
public:
QSortFilterProxyModel() : sourceModel(nullptr), sortColumn(-1), sortOrder(Qt::AscendingOrder) {}
void setSourceModel(QAbstractItemModel *source) {
sourceModel = source;
}
QModelIndex index(int row, int column, const QModelIndex &parent = QModelIndex()) const override {
// 根据过滤和排序规则，返回修改后的索引
// ...
}
QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override {
// 在获取数据前，应用过滤规则
// ...
}
bool setData(const QModelIndex &index, const QVariant &value, int role = Qt::EditRole) override {
// 在设置数据前，应用过滤规则
// ...
}
void sort(int column, Qt::SortOrder order = Qt::AscendingOrder) {
sortColumn = column;
sortOrder = order;
// 在这里应用排序规则
// ...
}
void setFilterRegExp(const QRegExp ®Exp) {
filterRegExp = regExp;
}
void setFilterKeyColumn(int column) {
filterKeyColumn = column;
}
// 其他模型接口方法的实现...
private:
QAbstractItemModel *sourceModel; // 持有源模型的引用
QRegExp filterRegExp; // 过滤规则
int filterKeyColumn; // 过滤的列
int sortColumn; // 排序的列
Qt::SortOrder sortOrder; // 排序的方式
};
// Client类，用于显示模型中的数据
class QTableView {
public:
void setModel(QAbstractItemModel *model) {
this->model = model;
}
void setSortingEnabled(bool enable) {
// 设置是否启用排序
sortingEnabled = enable;
}
void sortByColumn(int column, Qt::SortOrder order) {
if (sortingEnabled && model != nullptr) {
model->sort(column, order);
}
}
void show() {
// 显示视图
// ...
}
// 其他与视图相关的方法...
private:
QAbstractItemModel *model; // 持有模型的引用
bool sortingEnabled; // 是否启用排序
};
有了前面的铺垫，相信读者可以很轻易的读懂上面这段程序了。在这个代码示例中，QSortFilterProxyModel类实现了排序和过滤功能。在sort方法中，我们将排序列和排序方式存储在类的成员变量中，并在适当的时候使用它们来排序数据。在QTableView类中，我们添加了sortByColumn方法，这个方法会调用模型的sort方法。Client（QTableView）通过代理（QSortFilterProxyModel）来操作真实的主题（QStandardItemModel），这是Qt源码中使用代理模式的一个很好的体现。
不过这里并没有使用Qt的模型/视图框架中的Delegate类，这个是Qt框架中对模型/视图框架的一个补充角色。当然，并不影响今天的主题，或许会在后续的文章中提到Delegate类。
总结
Qt中的模型/视图框架属于是Qt中比较难学难用的一块知识，其中涉及的类也使用了许多的设计模式和设计技巧，在后续的文章中我们还会提到Qt的模型/视图框架。把这块硬骨头啃下来，相信能大大提升程序员的C++开发能力。
