Qt源码中的设计模式：模型/视图框架与代理模式

作者: 饮茶先啦靓仔 | 来源:发表于2023-05-13 00:08 被阅读0次

代理模式

代理模式是一种结构型设计模式，它的主要作用是为其他对象提供一种代理以控制对这个对象的访问。代理对象与被代理对象实现了相同的接口，客户端通过代理对象访问被代理对象，代理对象对客户端的请求进行处理并将请求转发给被代理对象，从而实现了对被代理对象的访问控制和增加功能。

代理模式主要的应用场景是：

保护目标对象：代理对象可以控制对目标对象的访问，例如可以检查客户端是否有足够的权限来访问目标对象，或者限制客户端对目标对象的访问次数等。这一般称为安全代理。
增强目标对象：代理对象可以在不改变目标对象的情况下，为目标对象增加一些额外的功能，例如缓存、懒加载、日志记录等，称为缓存代理，日志代理等。
远程访问对象：代理对象可以实现远程访问对象，例如通过网络访问远程服务器上的对象，或者通过远程代理来实现对象的序列化和反序列化等，称为远程代理。
减少系统开销：代理对象可以在目标对象还没有被完全创建时，先返回一个虚拟的占位给客户端，这样可以减少系统的开销，提高性能，或者提高界面的美观度（比如网页加载元素需要一些时间，这时候可以返回一个占位的框架图给前端页面），称为虚拟代理。

代理模式UML类图

下面给出一个代理模式的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 &regExp) {
        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++开发能力。

Qt源码中的设计模式：模型/视图框架与代理模式

代理模式

Qt模型/视图（Model/View）框架中的代理模式

总结

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读