带着问题看源码4-NodeRed中消息路由实现

lxmuyu

已于 2022-03-10 11:47:28 修改

阅读量463

点赞数

分类专栏： NodeRed 文章标签：前端 node.js javascript

于 2022-03-10 08:38:10 首次发布

本文链接：https://blog.csdn.net/lxmuyu/article/details/123392105

版权

NodeRed 专栏收录该内容

31 篇文章 25 订阅

订阅专栏

本文详细阐述了NodeRed中的Hook模块如何影响消息路由，包括其工作原理、NodeRed中消息的流转过程、优势与设计决策。重点讲解了堆栈式与Hook式路由的区别，以及Hook模块在处理、触发和参与者之间的交互作用。

摘要由CSDN通过智能技术生成

博客迁移

不恰饭的小站

NodeRed 提供了一个 Hook 模块，此模块向消息生命周期的节点注册，控制消息的流转。

1. 消息路由是什么？有几种实现方式？

消息路由即通过路由规则动态规划消息的传输路径，使消息按照过滤条件，从消息源路由到目标节点。通过消息路由，可实现对数据路由的灵活控制和提高数据安全性。

主要有两种方式：

堆栈式
类 Express 的 middleware，每新增加一个处理模块，会在处理堆栈的顶端，最终形成一个消息处理堆栈。
Hook 式
以 Hook（钩子）的形式实现，这需要在特定的节点处，增加对事件的回调，在有事件触发时，按序执行回调。

2. NodeRed 中消息如何流转

2.1. NodeRed 消息流转图

message-router-events
从消息发送到处理完毕，有以下几个事件：

onSend
preRoute
preDeliver
postDeliver
onReceive
postReceive
onComplete

2.2. SendEvent object

{
    "msg": "<message object>",
    "source": {
        "id": "<node-id>",
        "node": "<node-object>",
        "port": "<index of port being sent on>",
    },
    "destination": {
        "id": "<node-id>",
        "node": undefined,
    },
    "cloneMessage": "true|false"
}

2.3. ReceiveEvent object

{
    "msg": "<message object>",
    "destination": {
        "id": "<node-id>",
        "node": "<node-object>",
    }
}

2.4. CompleteEvent object

{
    "msg": "<message object>",
    "node": {
        "id": "<node-id>",
        "node": "<node-object>"
    },
    "error": "<error passed to done, otherwise, undefined>"
}

2.5. 有哪些参与者

2.5.1. packages/node_modules/@node-red/util/lib/hooks.js

新增 Hook（以链表存储 Hook ）

function add(hookId, callback) {
    ...
    let tailItem = hooks[id];
    if (tailItem === undefined) {
        hooks[id] = hookItem;
    } else {
        while(tailItem.nextHook !== null) {
            tailItem = tailItem.nextHook
        }
        tailItem.nextHook = hookItem;
        hookItem.previousHook = tailItem;
    }

    if (label) {
        labelledHooks[label] = labelledHooks[label]||{};
        labelledHooks[label][id] = hookItem;
    }

    ...
}

触发消息流
支持回调方式，Promise 方式

function trigger(hookId, payload, done) {
    let hookItem = hooks[hookId];
    if (!hookItem) {  //没有钩子执行回调或返回
        if (done) {
            done();
            return;
        } else {
            return Promise.resolve();
        }
    }
    if (!done) { //有钩子没有回调，以微任务方式处理所有Hook
        return new Promise((resolve,reject) => {
            invokeStack(hookItem,payload,function(err) {
                if (err !== undefined && err !== false) {
                    if (!(err instanceof Error)) {
                        err = new Error(err);
                    }
                    err.hook = hookId
                    reject(err);
                } else {
                    resolve(err);
                }
            })
        });
    } else { //有钩子有回调，处理所有Hook
        invokeStack(hookItem,payload,done)
    }
}

处理 Hook

function invokeStack(hookItem,payload,done) {
    function callNextHook(err) {
        if (!hookItem || err) {
            done(err);
            return;
        }
        if (hookItem.removed) {
            hookItem = hookItem.nextHook;
            callNextHook();
            return;
        }
        const callback = hookItem.cb;
        if (callback.length === 1) { //回调函数一个参数
            try {
                let result = callback(payload);
                if (result === false) {
                    // Halting the flow
                    done(false);
                    return
                }
                if (result && typeof result.then === 'function') {
                    result.then(handleResolve, callNextHook)
                    return;
                }
                hookItem = hookItem.nextHook;
                callNextHook();
            } catch(err) {
                done(err);
                return;
            }
        } else { //回调函数两个参数
            try {
                callback(payload,handleResolve)
            } catch(err) {
                done(err);
                return;
            }
        }
    }
    function handleResolve(result) {
        if (result === undefined) {
            hookItem = hookItem.nextHook;
            callNextHook();
        } else {
            done(result);
        }
    }
    callNextHook();
}