事件传播机制 与 责任链模式

云中飞鸿2024-06-20 19:18

1、基本概念

责任链模式（Chain of Responsibility Pattern）是一种行为型设计模式，将请求沿着处理链传递，直到有一个对象能够处理为止。

2、实现的模块有：

Handler（处理者）：定义一个处理请求的接口。

ConcreteHandler（具体处理者）：实现了处理者接口，判断自己是否能够处理请求，如果不能将请求传递给下一个处理者。

Request（请求）：封装了请求的信息，通常作为处理者方法的参数传递。
3、使用场景

当需要将请求的发送者和接收者进行解耦时。

当有多个对象可以处理同一请求，但不确定哪个对象应该处理时。

当需要动态指定处理请求的顺序时。

4、责任链模式的C++实现：

#include <iostream>  
#include <memory>  
#include <string>  

// 抽象处理器类  
class Handler {  
public:  
    virtual ~Handler() {}  

    // 处理请求的方法  
    virtual void HandleRequest(const std::string& request) {  
        if (successor_) {  
            successor_->HandleRequest(request);  
        }  
    }  

    // 设置后继处理器  
    void setSuccessor(std::shared_ptr<Handler> successor) {  
        successor_ = successor;  
    }  

protected:  
    std::shared_ptr<Handler> successor_;  
};  

// 具体处理器类A  
class ConcreteHandlerA : public Handler {  
public:  
    void HandleRequest(const std::string& request) override {  
        if (request == "A") {  
            std::cout << "ConcreteHandlerA handles the request: " << request << std::endl;  
        } else {  
            Handler::HandleRequest(request);  
        }  
    }  
};  

// 具体处理器类B  
class ConcreteHandlerB : public Handler {  
public:  
    void HandleRequest(const std::string& request) override {  
        if (request == "B") {  
            std::cout << "ConcreteHandlerB handles the request: " << request << std::endl;  
        } else {  
            Handler::HandleRequest(request);  
        }  
    }  
};  

// 具体处理器类C  
class ConcreteHandlerC : public Handler {  
public:  
    void HandleRequest(const std::string& request) override {  
        if (request == "C") {  
            std::cout << "ConcreteHandlerC handles the request: " << request << std::endl;  
        } else {  
            Handler::HandleRequest(request);  
        }  
    }  
};  

int main() {  
    std::shared_ptr<Handler> handlerA = std::make_shared<ConcreteHandlerA>();  
    std::shared_ptr<Handler> handlerB = std::make_shared<ConcreteHandlerB>();  
    std::shared_ptr<Handler> handlerC = std::make_shared<ConcreteHandlerC>();  

    // 设置责任链  
    handlerA->setSuccessor(handlerB);  
    handlerB->setSuccessor(handlerC);  

    // 发送请求  
    handlerA->HandleRequest("A");  
    handlerA->HandleRequest("B");  
    handlerA->HandleRequest("C");  
    handlerA->HandleRequest("D");  

    return 0;  
}

在上述示例中，Handler是抽象处理器类，定义了处理请求的方法。ConcreteHandlerA、ConcreteHandlerB和ConcreteHandlerC是具体处理器类，分别处理请求A、B和C。在创建这些处理器对象时，按照责任链的顺序将它们连接起来。在main函数中，程序创建了一个责任链，将请求依次发送给处理器A、B、C，如果没有任何处理器能够处理请求，则请求不会被处理。

总之，责任链模式是一种非常有用的设计模式，它可以将请求和处理请求的对象解耦，从而提高系统的灵活性和可扩展性。在实际应用中，它可以帮助我们解决很多复杂的问题，提高系统的处理能力和吞吐量，同时也提高了代码的可维护性和可读性。

5、Qt事件传播机制

QT源码：事件系统

QT的事件处理系统同样用到了事件处理系统，其中事件通过事件队列发送到对应的对象，每个对象都可以处理该事件，如果该对象无法处理，将会发给下一个对象。

以下是 QAppliaction 发送鼠标事件给 QWidget 的部分源码：

//接收鼠标事件的对象w
QWidget* w = static_cast<QWidget *>(receiver);
//鼠标事件e
QMouseEvent* mouse = static_cast<QMouseEvent*>(e);
 
......
 
while (w) {
    //创建一个新的鼠标事件对象，用于在对象树中传播鼠标事件
    QMouseEvent me(mouse->type(), relpos, mouse->windowPos(), mouse->globalPos(),
                   mouse->button(), mouse->buttons(), mouse->modifiers(), mouse->source());
 
......
 
    //如果鼠标事件被接受，打破循环
    eventAccepted = (w == receiver ? mouse : &me)->isAccepted();
    if (res && eventAccepted)
        break;
 
......
 
    //如果鼠标事件未被接受，将w设置为w的父组件，继续循环
    w = w->parentWidget();
}

可以看出， QApplication 将鼠标事件沿着对象树传递，直到有一个对象能够处理为止，符合责任链模式的思想，其中：

QObject： Handler（处理者），定义一个处理鼠标事件的接口。
QWidgt： ConcreteHandler（具体处理者），实现了 QObject 的接口，判断自己是否能够处理鼠标事件，如果不能将请求传递给父类 QWidget。
QMouseEvent： Request（请求），封装了鼠标事件的信息。
**QAppliaction：**客户端，是请求的发起者。

以上即可展现责任链模式在QT中应用。如果在意细节，可以看下方第6条**，否则，后面不用看！**

6、Qt事件传播机制 具体细节

事件传播机制和对象树机制共同构成了Qt中对象的一种管理方式和事件的一种传播方式。通过在对象之间建立处理请求的责任链，可以使请求的处理与请求的发起者解耦，提高代码的可扩展性和可维护性。另外，Qt还提供了QObject::installEventFilter方法，即可以安装一个事件过滤器来处理事件。事件过滤器是一个单独的对象，它可以拦截并处理一个或多个对象的事件。因此，事件过滤器也可以看作责任链模式中的一环。

下面给出Qt源码中如何实现事件传播机制，并且体现出责任链模式的一个示例。注意，这个示例省略了比较多的细节，但作为示例去描述Qt源码中如何体现责任链模式，应该是勉强足够的。

#include <iostream>

enum EventType { UnknownEvent, MouseButtonPressEvent };

class QEvent {
public:
    explicit QEvent(EventType type) : _type(type), _accepted(false) {}
    virtual ~QEvent() {}

    EventType type() const { return _type; }
    void accept() { _accepted = true; }
    void ignore() { _accepted = false; }
    bool isAccepted() const { return _accepted; }

private:
    EventType _type;
    bool _accepted;
};

class QObject {
public:
    virtual ~QObject() {}

    virtual bool event(QEvent *event) {
        // 默认实现，不处理任何事件
        return false;
    }

    virtual bool eventFilter(QObject *, QEvent *) {
        // 默认实现，不处理任何事件
        return false;
    }
};

class QWidget : public QObject {
public:
    virtual ~QWidget() {}

    bool event(QEvent *event) override {
        switch (event->type()) {
        case MouseButtonPressEvent:
            mousePressEvent(event);
            return true;
        default:
            return QObject::event(event);
        }
    }

    virtual void mousePressEvent(QEvent *event) {
        std::cout << "QWidget: Mouse button press event\n";
        event->accept();
    }
};

通过上面的示例，可以看到，QObject，QWidget和QEvent三个类的设计和实现，体现了责任链模式。

QWidget，继承自QObject，重写了event()方法，专门处理用户界面事件。例如，当按键事件发生，我们可以获取按下的键码，然后调用事件的accept()方法表示处理完成，从而阻止事件继续向上传递。如果QWidget无法处理事件，它会将事件传递给父对象。

QEvent是所有事件的基类，每个事件有独特的类型标识符。QEvent类还提供了isAccepted()、accept()和ignore()方法，标记事件是否被接受和处理。一旦事件被处理，我们可以通过调用accept()方法停止事件的传递，避免重复处理。

作为所有Qt对象的基类，QObject通过提供event()和eventFilter()两个虚函数，构建了事件处理的基础。其中event()负责处理自身接收到的事件，eventFilter()则处理需要过滤的事件。如果事件未被处理，它会被传递给父对象，形成责任链。那么传递给父对象的逻辑，在哪里呢？往QWidget::event()方法里打断点调试就会发现，调用栈会经过QApplication::notify(QObject *receiver, QEvent *e)，也就是说，事件的分发回经过里面QApplication::notify。切换到这个方法的调用点查看源代码，可以看到这么一段逻辑：

bool QApplication::notify(QObject* receiver, QEvent* e)
{
    //其他逻辑
    //...

    bool res = false;
    switch (e->type()) {
    //处理其他事件类型
    //...

    case QEvent::MouseButtonPress:
    case QEvent::MouseButtonRelease:
    case QEvent::MouseButtonDblClick:
    case QEvent::MouseMove:
    {
        QWidget* w = static_cast<QWidget*>(receiver);

        QMouseEvent* mouse = static_cast<QMouseEvent*>(e);
        QPoint relpos = mouse->pos();

        if (e->spontaneous()) {
            if (e->type() != QEvent::MouseMove)
                QApplicationPrivate::giveFocusAccordingToFocusPolicy(w, e, relpos);

            // ### Qt 5 These dynamic tool tips should be an OPT-IN feature. Some platforms
            // like OS X (probably others too), can optimize their views by not
            // dispatching mouse move events. We have attributes to control hover,
            // and mouse tracking, but as long as we are deciding to implement this
            // feature without choice of opting-in or out, you ALWAYS have to have
            // tracking enabled. Therefore, the other properties give a false sense of
            // performance enhancement.
            if (e->type() == QEvent::MouseMove && mouse->buttons() == 0
                && w->rect().contains(relpos)) { // Outside due to mouse grab?
                d->toolTipWidget = w;
                d->toolTipPos = relpos;
                d->toolTipGlobalPos = mouse->globalPos();
                QStyle* s = d->toolTipWidget->style();
                int wakeDelay = s->styleHint(QStyle::SH_ToolTip_WakeUpDelay, 0, d->toolTipWidget, 0);
                d->toolTipWakeUp.start(d->toolTipFallAsleep.isActive() ? 20 : wakeDelay, this);
            }
        }

        bool eventAccepted = mouse->isAccepted();

        QPointer<QWidget> pw = w;
        while (w) {
            QMouseEvent me(mouse->type(), relpos, mouse->windowPos(), mouse->globalPos(),
                mouse->button(), mouse->buttons(), mouse->modifiers(), mouse->source());
            me.spont = mouse->spontaneous();
            me.setTimestamp(mouse->timestamp());
            QGuiApplicationPrivate::setMouseEventFlags(&me, mouse->flags());
            // throw away any mouse-tracking-only mouse events
            if (!w->hasMouseTracking()
                && mouse->type() == QEvent::MouseMove && mouse->buttons() == 0) {
                // but still send them through all application event filters (normally done by notify_helper)
                d->sendThroughApplicationEventFilters(w, w == receiver ? mouse : &me);
                res = true;
            }
            else {
                w->setAttribute(Qt::WA_NoMouseReplay, false);
                res = d->notify_helper(w, w == receiver ? mouse : &me);
                e->spont = false;
            }
            eventAccepted = (w == receiver ? mouse : &me)->isAccepted();
            if (res && eventAccepted)
                break;
            if (w->isWindow() || w->testAttribute(Qt::WA_NoMousePropagation))
                break;
            relpos += w->pos();
            w = w->parentWidget();
        }

        mouse->setAccepted(eventAccepted);

        if (e->type() == QEvent::MouseMove) {
            if (!pw)
                break;

            w = static_cast<QWidget*>(receiver);
            relpos = mouse->pos();
            QPoint diff = relpos - w->mapFromGlobal(d->hoverGlobalPos);
            while (w) {
                if (w->testAttribute(Qt::WA_Hover) &&
                    (!QApplication::activePopupWidget() || QApplication::activePopupWidget() == w->window())) {
                    QHoverEvent he(QEvent::HoverMove, relpos, relpos - diff, mouse->modifiers());
                    d->notify_helper(w, &he);
                }
                if (w->isWindow() || w->testAttribute(Qt::WA_NoMousePropagation))
                    break;
                relpos += w->pos();
                w = w->parentWidget();
            }
        }

        d->hoverGlobalPos = mouse->globalPos();
    }
    break;
    //处理其他事件类型
    //...
    }

    return res;
}

我们在这里只关心鼠标事件（QEvent::MouseButtonPress,QEvent::MouseButtonRelease,QEvent::MouseButtonDblClick,QEvent::MouseMove:）的处理。下面分析一下关键的程序段：

  1. 在处理鼠标事件时，首先获取当前QWidget对象w。

    QWidget* w = static_cast<QWidget *>(receiver);

  2. 把事件循环遍历至最高级父窗口或直到一个处理了事件的窗口。在此过程中，对于没有成功处理鼠标事件的窗口，事件会沿着窗口的父链继续传递。

    while (w) {
    // 将事件发送给QWidget对象w，尝试让其处理
    // ...

     // 当事件已经被接收并得到处理，跳出循环
 if (res && eventAccepted)
     break;

 // 当到达顶层窗口或当前窗口标记为Qt::WA_NoMousePropagation (无鼠标事件传递)时，跳出循环
 if (w->isWindow() || w->testAttribute(Qt::WA_NoMousePropagation))
     break;

 // 获取父窗口，在while循环下一轮尝试让父窗口去处理
 w = w->parentWidget();

    }

在这个while循环中，就会不断地去获取父对象，尝试让其处理。事件得到处理，或者当到达顶层窗口，或者当前窗口标记为Qt::WA_NoMousePropagation (无鼠标事件传递)时，跳出循环。这里就体现出了事件处理的传递链。

可以继续解析上面的程序示例中，"将事件发送给QWidget对象w，尝试让其处理"部分没有展示出的代码：

  1. 根据收到的原始鼠标事件（mouse）创建一个新的鼠标事件（me），并使用正确的相对位置（relpos）更新它。同时设置一些其他属性，如是否自发、时间戳和鼠标事件标志。

    QMouseEvent me(mouse->type(), relpos, mouse->windowPos(), mouse->globalPos(),
    mouse->button(), mouse->buttons(), mouse->modifiers(), mouse->source());
    me.spont = mouse->spontaneous();
    me.setTimestamp(mouse->timestamp());
    QGuiApplicationPrivate::setMouseEventFlags(&me, mouse->flags());

  2. 对于没有鼠标跟踪并且是无按钮按下的鼠标移动事件（仅用于鼠标跟踪的事件），忽略这个事件，并将其传递给所有应用程序事件过滤器。设置结果变量res = true表示事件已被处理。

    if (!w->hasMouseTracking()
    && mouse->type() == QEvent::MouseMove && mouse->buttons() == 0) {
    // but still send them through all application event filters (normally done by notify_helper)
    d->sendThroughApplicationEventFilters(w, w == receiver ? mouse : &me);
    res = true;
    }

  3. 否则，尝试将mouse或me事件传递给QWidget对象（视情况而定）。更新事件的自发属性为false。

    else {
    w->setAttribute(Qt::WA_NoMouseReplay, false);
    res = d->notify_helper(w, w == receiver ? mouse : &me);
    e->spont = false;
    }

  4. 检查事件是否已被接受。这个步骤会影响后续窗口的事件传递。

    eventAccepted = (w == receiver ? mouse : &me)->isAccepted();

综上，QObject作为事件处理接口，QWidget实现具体的处理逻辑，而QEvent则扮演了请求的角色，QApplication参与了事件的分发和向上传递。这几个类的协作为Qt提供了一种高效、灵活且可扩展的事件处理机制，帮助开发者轻松处理各种事件和场景。

总结

至此，我们已经解析了Qt的对象树机制，构建在对象树机制之上的事件传递机制，以及它们背后的设计思想。在后续的文章中，我们可能还会继续解析Qt源码中事件机制相关的设计模式。事件机制确实是Qt中的核心机制之一，我们能够深挖的东西，恐怕还有很多。

原文链接：https://blog.csdn.net/buhuiCyvyan/article/details/138793057

原文链接：https://zhuanlan.zhihu.com/p/631330647

相关推荐
Funny-Boy10 小时前
Chain Responsibility Pattern
责任链模式
liufeismart202410 天前
Android 第三方框架：RxJava：源码分析：责任链模式
责任链模式·rxjava
岳轩子12 天前
23种设计模式之责任链模式
java·设计模式·责任链模式
Damon_041113 天前
责任链模式在Spring中的应用
java·spring·责任链模式
森伯41617 天前
行为型设计模式之《责任链模式》实践
java·设计模式·责任链模式
huaqianzkh18 天前
责任链模式的理解和实践
java·开发语言·责任链模式
姆路20 天前
责任链模式
责任链模式
问道飞鱼23 天前
【知识科普】设计模式之-责任链模式
java·设计模式·责任链模式
请你打开电视看看24 天前
行为型模式-责任链模式
责任链模式
Jack_abu24 天前
设计模式学习之——责任链模式
学习·设计模式·责任链模式
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问076个主流的工业3D管道设计软件08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明10树莓派 5 AI 套件（Hailo-8L）使用教程