amqplib-init 1.1.6 → 1.1.8

package/demo.js

@@ -0,0 +1,5 @@
+const init = require('./index')
+init.init({
+  channelName: 'amqplib-test-query',
+  amqpLink: ``
+})

package/index.js

@@ -1,119 +1,110 @@
 const amqp = require('amqplib');
 const shelljs = require('shelljs');
-const chalk = require('chalk-style');
+const log = require('chalk-style')
+const happy = require('happy-help');
 
-const sleep = (time) => {
-  return new Promise(resolve => {
-    setTimeout(_ => resolve(), time * 1000)
-  })
-};
 module.exports = {
-  /**
-   * 消息队列设置
-   * @returns {Promise<unknown>}
-   * @param option
-   */
-  init (option){
+  // 初始化函数
+  init(option) {
     const {
-      channelName = 'node-test-channel',
-      prefetch = 1,
-      pmId = 0,
-      callback = ()=> {},
-      finish = ()=> {},
-      amqpLink = ``,
-      heartbeat = 5,
-      timeout = 120000,
-      delay = 0,
-      autoReload = 0,
-      queryHook = () => {},
-      init = () => {}
+      channelName = 'node-test-channel',    // 频道名称，默认为'node-test-channel'
+      prefetch = 1,                         // 预取计数，默认为1
+      pmId = 0,                             // PM2进程ID，默认为0
+      callback = () => {},                  // 消息处理回调，默认为空函数
+      finish = () => {},                    // 初始化完成回调，默认为空函数
+      amqpLink = '',                        // RabbitMQ连接地址
+      heartbeat = 5,                        // 心跳间隔，单位为秒，默认为2秒
+      timeout = 2000,                     // 连接超时时间，单位为毫秒，默认为10000毫秒
+      delay = 0,                            // 消息处理完成后延迟ack的时间，单位为毫秒，默认为0毫秒
+      autoReload = 0,                       // 自动重载间隔时间，单位为毫秒，默认为0毫秒（不自动重载）
+      queryHook = () => {},                 // 查询钩子，默认为空函数（用于判断是否有其他消息来源）
+      initHook = () => {}                   // 初始化钩子，默认为空函数（在连接成功后执行）
     } = option;
-    const durable = true;
-    chalk.log(`🚀 队列已执行...`);
-    let connect = null;
-    const amqpInit = async (reload = false) => {
-      await sleep(1); // 等待一秒钟
-      connect = await amqp.connect(amqpLink, {
-        heartbeat, // 心跳检测5秒
-        timeout, // 设置连接超时时间为120秒
-      });
-      if (pmId > 0 && reload){
-        chalk.log(`‼️ 服务即将重启`);
-        shelljs.exec(`pm2 reload ${pmId}`);
-      }
-    }
-    return new Promise(async (resolve) => {
-      await amqpInit();
-      chalk.log(`✳️->RabbitMQ链接成功`);
-      const channel = await connect.createChannel();
-      chalk.log(`✳️->数据队列名称`, channelName);
-      chalk.log(`✳️->是否持久化`, durable);
-      const { queue } = await channel.assertQueue(channelName, { durable });
-      // 从这里绑定交换机;
-      await init && init({ channel, connect });
-      // 一次性读取一条;
+    const durable = true;                   // 队列是否持久化，默认为true
+    let connection = null;                  // RabbitMQ连接
+    let channel = null;                    // RabbitMQ频道
+
+    // 重连函数
+    const reconnect = async () => {
+      log.error('连接丢失，正在尝试重连...');
+      await happy.sleep(2); // 重连前等待2秒
+      connection = await amqp.connect(amqpLink, { heartbeat, timeout });
+      channel = await connection.createChannel();
+      await channel.assertQueue(channelName, { durable });
       await channel.prefetch(prefetch);
-      chalk.log(`✳️->一次取多少条`, prefetch);
-      chalk.log(`✳️->消息队列: ${channelName} 正在运行中...`);
-      await channel.consume(queue, async (msg) => {
+      await initHook({ channel, connection }); // 执行初始化钩子
+      log.log(`已重新连接到RabbitMQ，频道: ${channelName}`);
+      await consumeMessages(); // 开始消费消息
+    };
+
+    // 消费消息函数
+    const consumeMessages = async () => {
+      log.log(`开始消费: ${channelName}`);
+      await channel.consume(channelName, async (msg) => {
         if (msg !== null) {
           try {
-            await channel.assertQueue(channelName, { durable });
-            const content = JSON.parse(msg?.content?.toString());
-            chalk.log(`✳️->队列收到新消息: ${channelName}`);
-            const startTime = new Date().getTime();
-            callback(content).then(()=> {
-              try {
-                setTimeout(_=> {
-                  const endTime = (new Date().getTime() - startTime);
-                  chalk.log(`✳️->消息处理完成, 需要延迟: ${delay}ms, 共耗时: ${endTime}ms`);
-                  channel.ack(msg);
-                }, delay)
-              } catch (e) {
-                chalk.warning(`队列消费遇到异常`, e);
-                channel.reject(msg,true);
-              }
-            }).catch(e => {
-              chalk.warning(`消息处理遇到异常`, e);
-              channel.reject(msg, true);
-            });
+            const content = JSON.parse(msg.content.toString());
+            log.log(`收到消息: ${JSON.stringify(content)}`);
+            const startTime = Date.now();
+            await callback(content); // 执行消息处理回调
+            const endTime = Date.now() - startTime;
+            log.log(`消息处理完成，延迟: ${delay}ms，总时间: ${endTime}ms`);
+            setTimeout(() => channel.ack(msg), delay); // 延迟ack
           } catch (e) {
-            chalk.error(`队列遇到异常`, e);
+            log.error('处理消息时出错:', e);
+            channel.reject(msg, true); // 拒绝消息并重新排队
           }
         } else {
-          chalk.log(`消息异常`, msg);
+          log.error('收到无效消息:', msg);
         }
       }, { noAck: false });
-      // 队列遇到错误
-      connect.on('error', (err) => {
-        chalk.log('Connection error', err.message);
-        amqpInit(true);
-      });
-      // 队列被关闭
-      connect.on('close', function() {
-        chalk.log('Connection to RabbitMQ is closed');
-        amqpInit(true);
-      });
-      chalk.log(`✳️-队列已启动: finish~`);
-      if (autoReload > 0) {
-        console.log(`❤️ 将在 ${autoReload}ms 秒后自动重启!!!`)
-        setInterval(async _=> {
-          try {
-            const result = await channel.checkQueue(channelName);
-            const messageCount = result.messageCount;
-            console.log(`MQ队列中有 ${messageCount} 条消息`);
-            const length = queryHook ? !!queryHook() : 0;
-            console.log(`REDIS队列中有 ${messageCount} 条消息`);
-            if (messageCount <= 0 && length === 0) {
-              console.log(`即将重启此服务~`);
-              shelljs.exec(`pm2 reload ${pmId}`);
+    };
+
+    // 启动函数
+    const start = async () => {
+      try {
+        connection = await amqp.connect(amqpLink, { heartbeat, timeout });
+        channel = await connection.createChannel();
+        await channel.assertQueue(channelName, { durable });
+        await channel.prefetch(prefetch);
+        await initHook({ channel, connection }); // 执行初始化钩子
+        log.log(`已连接到RabbitMQ，频道: ${channelName}`);
+        await consumeMessages(); // 开始消费消息
+        // 连接错误处理
+        connection.on('error', (err) => {
+          log.error('连接错误:', err.message);
+          reconnect(); // 尝试重连
+        });
+
+        // 连接关闭处理
+        connection.on('close', () => {
+          log.error('与RabbitMQ的连接已关闭');
+          reconnect(); // 尝试重连
+        });
+
+        // 自动重载逻辑
+        if (autoReload > 0) {
+          setInterval(async () => {
+            try {
+              const { messageCount } = await channel.checkQueue(channelName);
+              const hookResult = await queryHook()
+              log.log(`MQ队列中有 ${messageCount} 条消息，检测是否可以重启: ${hookResult?1:0}`);
+              if (messageCount === 0 && hookResult) {
+                log.log('队列中没有消息，正在重载服务...');
+                shelljs?.exec(`pm2 reload ${pmId}`); // 使用PM2重载服务
+              }
+            } catch (e) {
+              log.error('检查队列长度时出错:', e);
             }
-          } catch (e) {
-            console.log(`重启失败~`);
-          }
-        }, autoReload)
+          }, autoReload);
+        }
+
+        finish(); // 执行初始化完成回调
+      } catch (e) {
+        log.error('初始化RabbitMQ连接时出错:', e);
       }
-      finish && finish();
-    })
+    };
+    // 返回启动函数并立即执行
+    return start();
   }
-}
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amqplib-init",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "description": "消息队列初始化",
   "main": "index.js",
   "scripts": {
@@ -11,6 +11,7 @@
   "dependencies": {
     "amqplib": "^0.10.4",
     "chalk-style": "^1.0.0",
+    "happy-help": "^1.0.1",
     "js-base64": "^3.7.7",
     "shelljs": "^0.8.5"
   }