amqplib-init 1.1.11 → 1.2.1

package/README.md

@@ -0,0 +1 @@
+ 

package/index.js

@@ -1,142 +1,153 @@
-const amqp = require('amqplib');
-const shelljs = require('shelljs');
-const log = require('chalk-style')
-const happy = require('happy-help');
-const axios = require('axios'); // 新增 axios 依赖
+const ConfigResolver = require('./module/ConfigResolver');
+const ConnectionManager = require('./module/ConnectionManager');
+const MessageProcessor = require('./module/MessageProcessor');
+const AutoReloader = require('./module/AutoReloader');
+const log = require('chalk-style');
 
-module.exports = {
-  // 初始化函数
-  async init(option) { // 改为 async 函数
-    const {
-      channelName = 'node-test-channel',    // 频道名称，默认为'node-test-channel'
-      prefetch = 1,                         // 预取计数，默认为1
-      pmId = 0,                             // PM2进程ID，默认为0
-      callback = () => {},                  // 消息处理回调，默认为空函数
-      finish = () => {},                    // 初始化完成回调，默认为空函数
-      amqpLink = '',                        // RabbitMQ连接地址
-      amqpAutoLink = '',                    // 自动获取连接信息的HTTPS链接
-      heartbeat = 5,                        // 心跳间隔，单位为秒，默认为2秒
-      timeout = 2000,                     // 连接超时时间，单位为毫秒，默认为10000毫秒
-      delay = 0,                            // 消息处理完成后延迟ack的时间，单位为毫秒，默认为0毫秒
-      autoReload = 0,                       // 自动重载间隔时间，单位为毫秒，默认为0毫秒（不自动重载）
-      queryHook = () => {},                 // 查询钩子，默认为空函数（用于判断是否有其他消息来源）
-      initHook = () => {}                   // 初始化钩子，默认为空函数（在连接成功后执行）
-    } = option;
-    const durable = true;                   // 队列是否持久化，默认为true
-    let connection = null;                  // RabbitMQ连接
-    let channel = null;                    // RabbitMQ频道
+/**
+ * AMQP初始化器主类
+ * 协调各个模块完成RabbitMQ的初始化和消息处理
+ */
+class AMQPInitializer {
+  constructor() {
+    this.configResolver = new ConfigResolver();
+    this.connectionManager = null;
+    this.messageProcessor = null;
+    this.autoReloader = null;
+    this.config = null;
+  }
+
+  /**
+   * 初始化AMQP连接和消息处理
+   * @param {Object} options - 配置选项
+   * @returns {Promise<void>}
+   */
+  async init(options = {}) {
+    try {
+      // 1. 解析配置
+      this.config = this.configResolver.resolveConfig(options);
+      log.log('配置解析完成');
+
+      // 2. 解析连接地址
+      const amqpLink = await this.configResolver.resolveAmqpLink(
+        this.config.amqpAutoLink,
+        this.config.amqpLink
+      );
+
+      // 3. 初始化各个模块
+      this.connectionManager = new ConnectionManager(this.config);
+      this.messageProcessor = new MessageProcessor(this.config);
+      this.autoReloader = new AutoReloader(this.config);
+
+      // 4. 设置连接地址并初始化连接
+      this.connectionManager.setAmqpLink(amqpLink);
+      const channel = await this.connectionManager.initialize();
+
+      // 5. 重新定义重连逻辑，确保重连后重新启动消息处理和自动重载
+      this._setupReconnectHandler();
 
-    // 处理 amqpAutoLink 自动获取连接信息
-    let finalAmqpLink = amqpLink; // 最终使用的连接地址
-    if (amqpAutoLink) {
+      // 6. 启动消息处理
+      await this.messageProcessor.startConsuming(channel);
+      log.log('消息处理器已启动');
+
+      // 7. 启动自动重载监控
+      this.autoReloader.start(channel);
+
+      // 8. 执行初始化完成回调
+      this.config.finish();
+      
+      log.log('AMQP初始化完成');
+    } catch (error) {
+      log.error('AMQP初始化失败:', error.message);
+      throw error;
+    }
+  }
+
+  /**
+   * 设置重连处理器
+   * 确保重连后各个模块能够正确重新启动
+   * @private
+   */
+  _setupReconnectHandler() {
+    const originalReconnect = this.connectionManager.reconnect.bind(this.connectionManager);
+    
+    this.connectionManager.reconnect = async () => {
       try {
-        log.log(`正在从 ${amqpAutoLink} 获取连接信息...`);
-        const response = await axios.post(amqpAutoLink);
-        const { info } = response.data;
+        // 执行原始重连逻辑
+        const newChannel = await originalReconnect();
+        
+        // 重连后重新启动消息处理
+        this.messageProcessor.clearProcessingMessages();
+        await this.messageProcessor.startConsuming(newChannel);
+        log.log('重连后消息处理器已重新启动');
+        
+        // 重连后重新启动自动重载监控
+        this.autoReloader.restart(newChannel);
+        log.log('重连后自动重载监控已重新启动');
         
-        if (info && info.AMQPLIB_USER && info.AMQPLIB_PWD && info.AMQPLIB_PUB && info.AMQPLIB_PORT) {
-          finalAmqpLink = `amqp://${info.AMQPLIB_USER}:${info.AMQPLIB_PWD}@${info.AMQPLIB_PUB}:${info.AMQPLIB_PORT}`;
-          log.log(`✅ 自动获取连接信息成功: ${finalAmqpLink}`);
-        } else {
-          log.error('❌ 获取的连接信息不完整，使用默认连接地址');
-        }
+        return newChannel;
       } catch (error) {
-        log.error('❌ 获取连接信息失败:', error.message);
-        log.log('使用默认连接地址继续...');
+        log.error('重连处理失败:', error.message);
+        throw error;
       }
-    }
-
-    // 重连函数
-    const reconnect = async () => {
-      log.error('连接丢失，正在尝试重连...');
-      await happy.sleep(2); // 重连前等待2秒
-      connection = await amqp.connect(finalAmqpLink, { 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(); // 开始消费消息
     };
+  }
 
-    // 消费消息函数
-    const consumeMessages = async () => {
-      log.log(`开始消费: ${channelName}`);
-      await channel.consume(channelName, async (msg) => {
-        if (msg !== null) {
-          try {
-            const content = JSON.parse(msg.content.toString());
-            log.log(`🪴 队列收到消息: ${JSON.stringify(content)}`);
-            const startTime = Date.now();
-            // 执行消息处理回调
-            callback(content).then(() => {
-              const endTime = Date.now() - startTime;
-              log.log(`☘️ 消息处理完成，延迟: ${delay}ms，总时间: ${endTime}ms`);
-              setTimeout(() => channel.ack(msg), delay); // 延迟ack
-            }).catch(async (e) => {
-              // 拒绝消息并重新排队
-              log.log('‼️ 处理消息返回错误:', e);
-              await happy.sleep(5);
-              channel.reject(msg, true);
-            });
-          } catch (e) {
-            // 拒绝消息并重新排队
-            log.log('‼️ 处理消息时出错:', e.message);
-            await happy.sleep(5);
-            channel.reject(msg, true);
-          }
-        } else {
-          // 直接消息此消息;
-          channel.ack(msg);
-          log.error('收到无效消息(自动消费):', msg);
-        }
-      }, { noAck: false });
+  /**
+   * 获取当前状态信息
+   * @returns {Object} 状态信息
+   */
+  getStatus() {
+    return {
+      isConnected: this.connectionManager ? this.connectionManager.isConnected() : false,
+      processingCount: this.messageProcessor ? this.messageProcessor.getProcessingCount() : 0,
+      autoReloaderActive: this.autoReloader ? this.autoReloader.isActive() : false,
+      channelName: this.config ? this.config.channelName : null
     };
+  }
 
-    // 启动函数
-    const start = async () => {
-      try {
-        connection = await amqp.connect(finalAmqpLink, { 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);
-            }
-          }, autoReload);
-        }
-        finish(); // 执行初始化完成回调
-      } catch (e) {
-        log.error('初始化RabbitMQ连接时出错:', e);
+  /**
+   * 优雅关闭
+   * @returns {Promise<void>}
+   */
+  async shutdown() {
+    try {
+      log.log('开始优雅关闭AMQP连接...');
+      
+      // 停止自动重载监控
+      if (this.autoReloader) {
+        this.autoReloader.stop();
       }
-    };
-    // 返回启动函数并立即执行
-    return start();
+      
+      // 清理消息处理状态
+      if (this.messageProcessor) {
+        this.messageProcessor.clearProcessingMessages();
+      }
+      
+      // 关闭连接
+      if (this.connectionManager) {
+        await this.connectionManager.close();
+      }
+      
+      log.log('AMQP连接已优雅关闭');
+    } catch (error) {
+      log.error('关闭AMQP连接时出错:', error.message);
+    }
   }
+}
+
+// 导出兼容的API
+module.exports = {
+  /**
+   * 初始化函数 - 保持向后兼容
+   * @param {Object} options - 配置选项
+   * @returns {Promise<void>}
+   */
+  async init(options) {
+    const initializer = new AMQPInitializer();
+    return await initializer.init(options);
+  },
+
+  // 导出类，供需要更多控制的用户使用
+  AMQPInitializer
 };

package/module/AutoReloader.js

@@ -0,0 +1,139 @@
+const shelljs = require('shelljs');
+const log = require('chalk-style');
+
+/**
+ * 自动重载器模块
+ * 负责监控队列状态并在满足条件时自动重载服务
+ */
+class AutoReloader {
+  constructor(config) {
+    this.config = config;
+    this.intervalId = null;
+    this.isRunning = false;
+  }
+
+  /**
+   * 启动自动重载监控
+   * @param {Object} channel - RabbitMQ频道
+   */
+  start(channel) {
+    const { autoReload, channelName, pmId, queryHook } = this.config;
+    
+    if (autoReload <= 0) {
+      log.log('自动重载功能未启用');
+      return;
+    }
+
+    if (this.isRunning) {
+      log.log('自动重载监控已在运行中');
+      return;
+    }
+
+    this.isRunning = true;
+    log.log(`启动自动重载监控，间隔: ${autoReload}ms`);
+
+    this.intervalId = setInterval(async () => {
+      try {
+        await this._checkAndReload(channel, channelName, pmId, queryHook);
+      } catch (error) {
+        log.error('自动重载检查时出错:', error.message);
+      }
+    }, autoReload);
+  }
+
+  /**
+   * 停止自动重载监控
+   */
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+      this.isRunning = false;
+      log.log('自动重载监控已停止');
+    }
+  }
+
+  /**
+   * 重启自动重载监控（用于重连后）
+   * @param {Object} channel - 新的RabbitMQ频道
+   */
+  restart(channel) {
+    this.stop();
+    this.start(channel);
+  }
+
+  /**
+   * 获取监控状态
+   * @returns {boolean} 是否正在运行
+   */
+  isActive() {
+    return this.isRunning;
+  }
+
+  /**
+   * 检查并执行重载
+   * @param {Object} channel - RabbitMQ频道
+   * @param {string} channelName - 频道名称
+   * @param {number} pmId - PM2进程ID
+   * @param {Function} queryHook - 查询钩子函数
+   * @private
+   */
+  async _checkAndReload(channel, channelName, pmId, queryHook) {
+    try {
+      // 检查队列中的消息数量
+      const { messageCount } = await channel.checkQueue(channelName);
+      
+      // 执行查询钩子，检查是否可以重启
+      const hookResult = await queryHook();
+      
+      log.log(`MQ队列中有 ${messageCount} 条消息，检测是否可以重启: ${hookResult ? 1 : 0}`);
+      
+      // 只有在队列为空且钩子函数返回true时才重载
+      if (messageCount === 0 && hookResult) {
+        await this._executeReload(pmId);
+      }
+    } catch (error) {
+      log.error('检查队列长度时出错:', error.message);
+    }
+  }
+
+  /**
+   * 执行服务重载
+   * @param {number} pmId - PM2进程ID
+   * @private
+   */
+  async _executeReload(pmId) {
+    try {
+      log.log('队列中没有消息，正在重载服务...');
+      
+      if (shelljs && typeof shelljs.exec === 'function') {
+        const result = shelljs.exec(`pm2 reload ${pmId}`);
+        
+        if (result.code === 0) {
+          log.log(`服务重载成功，PM2进程ID: ${pmId}`);
+        } else {
+          log.error(`服务重载失败，错误码: ${result.code}, 输出: ${result.stderr}`);
+        }
+      } else {
+        log.error('shelljs不可用，无法执行服务重载');
+      }
+    } catch (error) {
+      log.error('执行服务重载时出错:', error.message);
+    }
+  }
+
+  /**
+   * 获取当前配置信息
+   * @returns {Object} 配置信息
+   */
+  getConfig() {
+    return {
+      autoReload: this.config.autoReload,
+      pmId: this.config.pmId,
+      isRunning: this.isRunning,
+      intervalId: this.intervalId !== null
+    };
+  }
+}
+
+module.exports = AutoReloader; 

package/module/ConfigResolver.js

@@ -0,0 +1,87 @@
+const axios = require('axios');
+const log = require('chalk-style');
+
+/**
+ * 配置解析器模块
+ * 负责处理配置参数和自动获取RabbitMQ连接信息
+ */
+class ConfigResolver {
+  constructor() {
+    this.defaultConfig = {
+      channelName: 'node-test-channel',
+      prefetch: 1,
+      pmId: 0,
+      callback: () => {},
+      finish: () => {},
+      amqpLink: '',
+      amqpAutoLink: '',
+      heartbeat: 60,         // 增加心跳间隔到60秒，避免长时间处理时连接断开
+      timeout: 300000,       // 增加连接超时到5分钟（300秒）
+      delay: 0,
+      autoReload: 0,
+      queryHook: () => {},
+      initHook: () => {},
+      durable: true,
+      // 新增配置项 - 支持15分钟长任务
+      messageTimeout: 900000,  // 消息处理超时15分钟（900秒）
+      reconnectDelay: 5000,    // 重连延迟5秒
+      maxReconnectAttempts: 10 // 最大重连次数
+    };
+  }
+
+  /**
+   * 解析和合并配置参数
+   * @param {Object} options - 用户传入的配置选项
+   * @returns {Object} 合并后的完整配置
+   */
+  resolveConfig(options = {}) {
+    return { ...this.defaultConfig, ...options };
+  }
+
+  /**
+   * 自动获取RabbitMQ连接信息
+   * @param {string} amqpAutoLink - 自动获取连接信息的HTTPS链接
+   * @param {string} fallbackAmqpLink - 备用连接地址
+   * @returns {Promise<string>} 最终使用的连接地址
+   */
+  async resolveAmqpLink(amqpAutoLink, fallbackAmqpLink) {
+    if (!amqpAutoLink) {
+      return fallbackAmqpLink;
+    }
+
+    try {
+      log.log(`正在从 ${amqpAutoLink} 获取连接信息...`);
+      const response = await axios.post(amqpAutoLink);
+      const { info } = response.data;
+      
+      if (this._validateConnectionInfo(info)) {
+        const finalAmqpLink = `amqp://${info.AMQPLIB_USER}:${info.AMQPLIB_PWD}@${info.AMQPLIB_PUB}:${info.AMQPLIB_PORT}`;
+        log.log(`✅ 自动获取连接信息成功: ${finalAmqpLink}`);
+        return finalAmqpLink;
+      } else {
+        log.error('❌ 获取的连接信息不完整，使用默认连接地址');
+        return fallbackAmqpLink;
+      }
+    } catch (error) {
+      log.error('❌ 获取连接信息失败:', error.message);
+      log.log('使用默认连接地址继续...');
+      return fallbackAmqpLink;
+    }
+  }
+
+  /**
+   * 验证连接信息的完整性
+   * @param {Object} info - 连接信息对象
+   * @returns {boolean} 是否包含所有必要字段
+   * @private
+   */
+  _validateConnectionInfo(info) {
+    return info && 
+           info.AMQPLIB_USER && 
+           info.AMQPLIB_PWD && 
+           info.AMQPLIB_PUB && 
+           info.AMQPLIB_PORT;
+  }
+}
+
+module.exports = ConfigResolver; 

package/module/ConnectionManager.js

@@ -0,0 +1,183 @@
+const amqp = require('amqplib');
+const log = require('chalk-style');
+const happy = require('happy-help');
+
+/**
+ * 连接管理器模块
+ * 负责RabbitMQ连接管理、重连逻辑、频道管理
+ */
+class ConnectionManager {
+  constructor(config) {
+    this.config = config;
+    this.connection = null;
+    this.channel = null;
+    this.amqpLink = '';
+    this.reconnectInProgress = false; // 防止重复重连
+  }
+
+  /**
+   * 设置AMQP连接地址
+   * @param {string} amqpLink - RabbitMQ连接地址
+   */
+  setAmqpLink(amqpLink) {
+    this.amqpLink = amqpLink;
+  }
+
+  /**
+   * 初始化连接和频道
+   * @returns {Promise<Object>} 返回频道对象
+   */
+  async initialize() {
+    const { channelName, durable, prefetch, heartbeat, timeout, initHook, reconnectDelay } = this.config;
+    
+    try {
+      // 建立连接
+      this.connection = await amqp.connect(this.amqpLink, { heartbeat, timeout });
+      
+      // 创建频道
+      this.channel = await this.connection.createChannel();
+      
+      // 设置队列和预取
+      await this.channel.assertQueue(channelName, { durable });
+      await this.channel.prefetch(prefetch);
+      
+      // 执行初始化钩子
+      await initHook({ channel: this.channel, connection: this.connection });
+      
+      log.log(`已连接到RabbitMQ，频道: ${channelName}`);
+      
+      // 设置连接事件监听
+      this._setupConnectionEvents();
+      
+      return this.channel;
+    } catch (error) {
+      log.error('初始化RabbitMQ连接时出错:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 重连逻辑
+   * @returns {Promise<Object>} 返回新的频道对象
+   */
+  async reconnect() {
+    if (this.reconnectInProgress) {
+      log.log('重连已在进行中，跳过此次重连请求');
+      return this.channel;
+    }
+
+    this.reconnectInProgress = true;
+    
+    try {
+      log.error('连接丢失，正在尝试重连...');
+      
+      // 清理旧的channel状态
+      await this._cleanupOldChannel();
+      
+      // 等待重连间隔，使用配置的延迟时间
+      const delaySeconds = (this.config.reconnectDelay || 5000) / 1000;
+      await happy.sleep(delaySeconds);
+      
+      // 重新初始化连接
+      await this.initialize();
+      
+      log.log(`已重新连接到RabbitMQ，频道: ${this.config.channelName}`);
+      
+      return this.channel;
+    } catch (error) {
+      log.error('重连失败:', error.message);
+      // 如果重连失败，等待一段时间后重试
+      const retryDelay = this.config.reconnectDelay || 5000;
+      setTimeout(() => {
+        this.reconnectInProgress = false;
+        this.reconnect();
+      }, retryDelay);
+      throw error;
+    } finally {
+      this.reconnectInProgress = false;
+    }
+  }
+
+  /**
+   * 获取当前频道
+   * @returns {Object|null} 当前频道对象
+   */
+  getChannel() {
+    return this.channel;
+  }
+
+  /**
+   * 获取当前连接
+   * @returns {Object|null} 当前连接对象
+   */
+  getConnection() {
+    return this.connection;
+  }
+
+  /**
+   * 检查连接是否正常
+   * @returns {boolean} 连接状态
+   */
+  isConnected() {
+    return this.connection && this.channel && !this.connection.connection.destroyed;
+  }
+
+  /**
+   * 关闭连接
+   * @returns {Promise<void>}
+   */
+  async close() {
+    try {
+      if (this.channel) {
+        await this.channel.close();
+        this.channel = null;
+      }
+      if (this.connection) {
+        await this.connection.close();
+        this.connection = null;
+      }
+      log.log('RabbitMQ连接已关闭');
+    } catch (error) {
+      log.error('关闭连接时出错:', error.message);
+    }
+  }
+
+  /**
+   * 设置连接事件监听
+   * @private
+   */
+  _setupConnectionEvents() {
+    // 连接错误处理
+    this.connection.on('error', (err) => {
+      log.error('连接错误:', err.message);
+      this.reconnect().catch(error => {
+        log.error('重连失败:', error.message);
+      });
+    });
+
+    // 连接关闭处理
+    this.connection.on('close', () => {
+      log.error('与RabbitMQ的连接已关闭');
+      this.reconnect().catch(error => {
+        log.error('重连失败:', error.message);
+      });
+    });
+  }
+
+  /**
+   * 清理旧的频道状态
+   * @private
+   */
+  async _cleanupOldChannel() {
+    if (this.channel) {
+      try {
+        await this.channel.close();
+      } catch (e) {
+        log.log('关闭旧channel时出错:', e.message);
+      }
+      this.channel = null;
+    }
+  }
+}
+
+module.exports = ConnectionManager; 

package/module/MessageProcessor.js

@@ -0,0 +1,145 @@
+const log = require('chalk-style');
+const happy = require('happy-help');
+
+/**
+ * 消息处理器模块
+ * 负责消息处理、状态跟踪、ACK/REJECT逻辑
+ */
+class MessageProcessor {
+  constructor(config) {
+    this.config = config;
+    this.processingMessages = new Set(); // 跟踪正在处理的消息
+  }
+
+  /**
+   * 开始消费消息
+   * @param {Object} channel - RabbitMQ频道
+   * @returns {Promise<Function>} 返回清理函数
+   */
+  async startConsuming(channel) {
+    const { channelName, callback, delay } = this.config;
+    
+    log.log(`开始消费: ${channelName}`);
+    
+    await channel.consume(channelName, async (msg) => {
+      if (msg !== null) {
+        await this._handleMessage(msg, channel, callback, delay);
+      } else {
+        // ✅ 修复关键bug：null消息不需要ACK操作
+        log.log('收到null消息，队列可能为空或连接中断');
+        // 移除错误的 channel.ack(msg) 调用
+      }
+    }, { noAck: false });
+    
+    // 返回清理函数，用于重连时清理状态
+    return () => {
+      this.processingMessages.clear();
+      log.log('已清理消息处理状态');
+    };
+  }
+
+  /**
+   * 处理单条消息
+   * @param {Object} msg - RabbitMQ消息对象
+   * @param {Object} channel - RabbitMQ频道
+   * @param {Function} callback - 消息处理回调函数
+   * @param {number} delay - 延迟ACK时间
+   * @private
+   */
+  async _handleMessage(msg, channel, callback, delay) {
+    const deliveryTag = msg.fields.deliveryTag;
+    
+    // 检查消息是否已在处理中
+    if (this.processingMessages.has(deliveryTag)) {
+      log.log(`消息 ${deliveryTag} 已在处理中，跳过`);
+      return;
+    }
+    
+    this.processingMessages.add(deliveryTag);
+    
+    try {
+      const content = JSON.parse(msg.content.toString());
+      log.log(`🪴 队列收到消息: ${JSON.stringify(content)}`);
+      const startTime = Date.now();
+      
+      // 执行消息处理回调
+      callback(content)
+        .then(() => {
+          const endTime = Date.now() - startTime;
+          log.log(`☘️ 消息处理完成，延迟: ${delay}ms，总时间: ${endTime}ms`);
+          this._acknowledgeMessage(msg, channel, deliveryTag, delay);
+        })
+        .catch(async (e) => {
+          log.log('‼️ 处理消息返回错误:', e);
+          await this._rejectMessage(msg, channel, deliveryTag);
+        });
+    } catch (e) {
+      log.log('‼️ 处理消息时出错:', e.message);
+      await this._rejectMessage(msg, channel, deliveryTag);
+    }
+  }
+
+  /**
+   * 确认消息
+   * @param {Object} msg - RabbitMQ消息对象
+   * @param {Object} channel - RabbitMQ频道
+   * @param {string} deliveryTag - 消息标签
+   * @param {number} delay - 延迟时间
+   * @private
+   */
+  _acknowledgeMessage(msg, channel, deliveryTag, delay) {
+    // 确保消息还在处理集合中再进行ACK
+    if (this.processingMessages.has(deliveryTag)) {
+      setTimeout(() => {
+        try {
+          channel.ack(msg);
+          this.processingMessages.delete(deliveryTag);
+          log.log(`✅ 消息 ${deliveryTag} 已确认`);
+        } catch (ackError) {
+          log.error(`ACK消息 ${deliveryTag} 时出错:`, ackError.message);
+          this.processingMessages.delete(deliveryTag);
+        }
+      }, delay);
+    }
+  }
+
+  /**
+   * 拒绝消息并重新排队
+   * @param {Object} msg - RabbitMQ消息对象
+   * @param {Object} channel - RabbitMQ频道
+   * @param {string} deliveryTag - 消息标签
+   * @private
+   */
+  async _rejectMessage(msg, channel, deliveryTag) {
+    await happy.sleep(5);
+    
+    if (this.processingMessages.has(deliveryTag)) {
+      try {
+        channel.reject(msg, true);
+        this.processingMessages.delete(deliveryTag);
+        log.log(`❌ 消息 ${deliveryTag} 已拒绝并重新排队`);
+      } catch (rejectError) {
+        log.error(`拒绝消息 ${deliveryTag} 时出错:`, rejectError.message);
+        this.processingMessages.delete(deliveryTag);
+      }
+    }
+  }
+
+  /**
+   * 清理所有处理中的消息状态
+   */
+  clearProcessingMessages() {
+    this.processingMessages.clear();
+    log.log('已清理所有消息处理状态');
+  }
+
+  /**
+   * 获取当前处理中的消息数量
+   * @returns {number} 处理中的消息数量
+   */
+  getProcessingCount() {
+    return this.processingMessages.size;
+  }
+}
+
+module.exports = MessageProcessor; 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "amqplib-init",
-  "version": "1.1.11",
-  "description": "消息队列初始化",
+  "version": "1.2.1",
+  "description": "消息队列初始化 - 模块化架构版本 (支持15分钟长任务)",
   "main": "index.js",
   "scripts": {
     "start": "node index.js"