mm_mongodb 1.4.3 → 1.4.5

package/cache.js

@@ -1,14 +1,20 @@
 /**
- * @fileOverview mongodb_cache缓存帮助类函数
+ * @fileOverview MongoDB缓存帮助类函数
  * @author <a href="http://qww.elins.cn">邱文武</a>
  * @version 1.2
  */
-const {
-	MongoDB
-} = require('./index.js');
+const { MongoDB } = require('./index.js');
 
-/* 创建Mongodb_cache帮助类函数 */
-/// 构造函数
+/**
+ * 确保全局$对象存在
+ */
+if (!global.$) {
+	global.$ = {};
+}
+
+/**
+ * @description MongoDB缓存帮助类
+ */
 class Mongodb_cache extends MongoDB {
 	/**
 	 * @description 创建Mongodb_cache帮助类函数 (构造函数)
@@ -18,127 +24,442 @@ class Mongodb_cache extends MongoDB {
 	 */
 	constructor(scope, dir, config) {
 		super(scope, dir, config);
+		// 默认使用键值对表
+		this.table = 'keyValue';
+		// 数据库连接状态
+		this.connected = false;
+		// 连接Promise缓存
+		this.connectPromise = null;
+		// 连接重试次数
+		this.connectAttempts = 0;
+		this.maxConnectAttempts = 3;
+	}
+	
+	/**
+	 * @description 确保数据库连接已建立
+	 * @private
+	 * @return {Promise<void>}
+	 */
+	async _ensureConnected() {
+		// 如果已有连接Promise，等待其完成
+		if (this.connectPromise) {
+			return this.connectPromise;
+		}
 		
-		// 消息订阅器
-		this.conn_rss;
-
-		// 订阅回调函数
-		this.func_list = {};
+		// 创建新的连接Promise
+		this.connectPromise = (async () => {
+			try {
+				// 检查连接状态
+				if (!this.db || !this.connected) {
+					// 记录连接尝试
+					this.connectAttempts++;
+					
+					// 尝试连接
+					await super.open();
+					
+					// 检查连接是否成功
+					if (this.db && this.db.collection) {
+						this.connected = true;
+						this.connectAttempts = 0;
+						
+						// 确保索引已创建
+						await this._ensureIndexes();
+						
+						$.log.info(`[MongoDB cache] 成功连接到数据库，表名: ${this.table}`);
+					} else {
+						throw new Error('数据库连接失败，db对象为空');
+					}
+				}
+			} catch (error) {
+				$.log.error(`[MongoDB cache] 连接失败 (尝试 ${this.connectAttempts}/${this.maxConnectAttempts}):`, error.message);
+				
+				// 重置连接Promise，允许下次重试
+				this.connectPromise = null;
+				
+				// 如果尝试次数未超过限制，抛出错误让上层处理
+				if (this.connectAttempts < this.maxConnectAttempts) {
+					throw error;
+				} else {
+					// 超过重试次数，记录严重错误
+					$.log.error('[MongoDB cache] 达到最大连接重试次数，连接失败');
+					throw new Error('数据库连接失败，已达到最大重试次数');
+				}
+			}
+		})();
+		
+		return this.connectPromise;
+	}
+	
+	/**
+	 * @description 确保索引已创建
+	 * @private
+	 * @return {Promise<void>}
+	 */
+	async _ensureIndexes() {
+		try {
+			// 确保db对象有效
+			if (!this.db || !this.db.collection) {
+				throw new Error('数据库连接无效，无法创建索引');
+			}
+			
+			// 创建TTL索引用于自动过期
+			await this.db.collection(this.table).createIndex(
+				{ expireAt: 1 },
+				{ expireAfterSeconds: 0 }
+			);
+			// 创建_id索引(通常自动创建，但显式指定更清晰)
+			await this.db.collection(this.table).createIndex({ _id: 1 });
+		} catch (error) {
+			// 忽略索引已存在的错误
+			if (error.code !== 85) {
+				$.log.error('[MongoDB cache] 创建索引失败:', error);
+			}
+		}
 	}
 }
 
 /**
- * 消息订阅
- * @param {String} channel 订阅的频道
- * @param {Function} func 操作回调函数，可判断成功与否
+ * @description 增加整数值
+ * @param {String} key 键
+ * @param {Number} value 增量值
+ * @return {Promise|Number} 增加后的值
  */
-Mongodb_cache.prototype.subscribe = function(channel, func) {
-	this.conn_rss.subscribe(channel);
-	this.func_list[channel] = func;
+Mongodb_cache.prototype.addInt = async function(key, value) {
+    try {
+        // 触发before事件
+        this.emit('addInt_before', { key, value });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || typeof value !== 'number' || !Number.isInteger(value)) {
+            throw new Error('参数无效：key不能为空且value必须是整数');
+        }
+        
+        // 使用$inc操作符增加整数值
+        const result = await this.db.collection(this.table).findOneAndUpdate(
+            { _id: key },
+            { $inc: { value: value } },
+            { upsert: true, returnDocument: 'after', projection: { value: 1 } }
+        );
+        
+        const returnValue = result.value ? result.value.value : value;
+        
+        // 触发after事件
+        this.emit('addInt_after', { key, value, result: returnValue });
+        
+        return returnValue;
+    } catch (error) {
+        // 触发error事件
+        this.emit('addInt_error', { key, value, error });
+        $.log.error('[MongoDB cache] 增加整数值失败:', error);
+        throw error;
+    }
 };
 
 /**
- * 取消订阅
- * @param {String} channel 订阅的频道
+ * @description 增加浮点数值
+ * @param {String} key 键
+ * @param {Number} value 增量值
+ * @return {Promise|Number} 增加后的值
  */
-Mongodb_cache.prototype.unsubscribe = function(channel) {
-	this.conn_rss.unsubscribe(channel);
-	delete this.func_list[channel];
+Mongodb_cache.prototype.addFloat = async function(key, value) {
+    try {
+        // 触发before事件
+        this.emit('addFloat_before', { key, value });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || typeof value !== 'number') {
+            throw new Error('参数无效：key不能为空且value必须是数字');
+        }
+        
+        // 使用$inc操作符增加浮点数值
+        const result = await this.db.collection(this.table).findOneAndUpdate(
+            { _id: key },
+            { $inc: { value: value } },
+            { upsert: true, returnDocument: 'after', projection: { value: 1 } }
+        );
+        
+        const returnValue = result.value ? result.value.value : value;
+        
+        // 触发after事件
+        this.emit('addFloat_after', { key, value, result: returnValue });
+        
+        return returnValue;
+    } catch (error) {
+        // 触发error事件
+        this.emit('addFloat_error', { key, value, error });
+        $.log.error('[MongoDB cache] 增加浮点数值失败:', error);
+        throw error;
+    }
 };
 
 /**
- * 发布消息
- * @param {String} channel 频道
- * @param {String} message 订阅的消息
- * @param {Function} func 消息发布成功回调函数
+ * @description 增加字符串值
+ * @param {String} key 键
+ * @param {String} value 要增加的字符串
+ * @return {Promise|String} 增加后的字符串
  */
-Mongodb_cache.prototype.publish = function(channel, message, func) {
-	this.conn.publish(channel, message, func);
+Mongodb_cache.prototype.addStr = async function(key, value) {
+    try {
+        // 触发before事件
+        this.emit('addStr_before', { key, value });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || typeof value !== 'string') {
+            throw new Error('参数无效：key不能为空且value必须是字符串');
+        }
+        
+        // 获取现有值
+        const current = await this.db.collection(this.table).findOne({ _id: key }, { projection: { value: 1 } });
+        const currentValue = current ? current.value : '';
+        
+        // 确保当前值是字符串
+        if (typeof currentValue !== 'string') {
+            throw new Error('现有值不是字符串类型，无法追加');
+        }
+        
+        // 更新字符串
+        const newValue = currentValue + value;
+        await this.db.collection(this.table).updateOne(
+            { _id: key },
+            { $set: { value: newValue } },
+            { upsert: true }
+        );
+        
+        // 触发after事件
+        this.emit('addStr_after', { key, value, result: newValue });
+        
+        return newValue;
+    } catch (error) {
+        // 触发error事件
+        this.emit('addStr_error', { key, value, error });
+        $.log.error('[MongoDB cache] 增加字符串值失败:', error);
+        throw error;
+    }
 };
 
 /**
- * 订阅消息处理, 如果没有订阅函数，则其他的订阅消息会进入该函数
- * @param {String} channel
- * @param {String} message
- */
-Mongodb_cache.prototype.main = async function(channel, message) {};
-
-/**
- * 消息通知
- * @param {String} channel 频道
- * @param {String} message 消息
- */
-Mongodb_cache.prototype.message = function(channel, message) {
-	// console.log("我接收到信息了" + message);
-	var func = this.func_list[channel];
-	if (func) {
-		func(message);
-	} else {
-		this.main(channel, message);
-	}
-};
-
-/**z
- * @description 增加整数值(负数为减)
+ * @description 删除缓存
  * @param {String} key 键
- * @param {Number} num 数值
- * @return {Promise|Number} 计算后的结果
+ * @return {Promise|Boolean} 成功返回true，失败返回false
  */
-Mongodb_cache.prototype.addInt = function(key, num) {
-	if (num > 0) {
-		return this.conn.incrby(key, num);
-	} else {
-		return this.conn.decrby(key, -num);
-	}
+Mongodb_cache.prototype.del = async function(key) {
+    try {
+        // 触发before事件
+        this.emit('del_before', { key });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const result = await this.db.collection(this.table).deleteOne({ _id: key });
+        const success = result.deletedCount > 0;
+        
+        // 触发after事件
+        this.emit('del_after', { key, result: success });
+        
+        return success;
+    } catch (error) {
+        // 触发error事件
+        this.emit('del_error', { key, error });
+        $.log.error('[MongoDB cache] 删除缓存失败:', error);
+        return false;
+    }
 };
 
 /**
- * @description 增加浮点数值(负数为减)
- * @param {String} key 键
- * @param {Number} num 数值
- * @return {Promise|Number} 计算后的结果
+ * @description 批量删除缓存 (Redis风格)
+ * @param {String[]} keys 键数组
+ * @return {Promise|Number} 删除的键数量
  */
-Mongodb_cache.prototype.addFloat = function(key, num) {
-	if (num > 0) {
-		return this.conn.incrbyfloat(key, num);
-	} else {
-		return this.conn.decrby(key, -num);
-	};
+Mongodb_cache.prototype.delKeys = async function(...keys) {
+    try {
+        // 触发before事件
+        this.emit('delKeys_before', { keys });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        if (!keys || keys.length === 0) {
+            // 触发after事件
+            this.emit('delKeys_after', { keys, result: 0 });
+            return 0;
+        }
+        
+        const result = await this.db.collection(this.table).deleteMany({
+            _id: { $in: keys }
+        });
+        
+        // 触发after事件
+        this.emit('delKeys_after', { keys, result: result.deletedCount });
+        
+        return result.deletedCount;
+    } catch (error) {
+        // 触发error事件
+        this.emit('delKeys_error', { keys, error });
+        $.log.error('[MongoDB cache] 批量删除缓存失败:', error);
+        return 0;
+    }
 };
 
 /**
- * @description 增加字符串值到指定缓存
+ * @description 修改缓存
  * @param {String} key 键
- * @param {String} str 添加的字符串
- * @return {Promise|String} 添加后的字符串
+ * @param {Object} value 值
+ * @param {Number} seconds 过期时间（秒）
+ * @return {Promise|Object} 修改后的值
  */
-Mongodb_cache.prototype.addStr = function(key, str) {
-	return this.conn.append(key, str);
+Mongodb_cache.prototype.set = async function(key, value, seconds) {
+    try {
+        // 触发before事件
+        this.emit('set_before', { key, value, seconds });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        // 准备更新数据
+        const updateData = { $set: { value } };
+        
+        // 设置过期时间
+        if (seconds) {
+            const expireAt = new Date(Date.now() + seconds * 1000);
+            updateData.$set.expireAt = expireAt;
+        } else {
+            // 如果没有设置过期时间，移除可能存在的expireAt字段
+            updateData.$unset = { expireAt: 1 };
+        }
+        
+        await this.db.collection(this.table).updateOne(
+            { _id: key },
+            updateData,
+            { upsert: true }
+        );
+        
+        // 触发after事件
+        this.emit('set_after', { key, value, seconds, result: value });
+        
+        return value;
+    } catch (error) {
+        // 触发error事件
+        this.emit('set_error', { key, value, seconds, error });
+        $.log.error('[MongoDB cache] 修改缓存失败:', error);
+        throw error;
+    }
 };
 
 /**
- * @description 删除缓存
+ * @description 条件设置缓存 (Redis SETNX)
  * @param {String} key 键
- * @return {Promise|Boolean} 成功返回true,失败返回false
+ * @param {Object} value 值
+ * @return {Promise|Boolean} 如果键不存在且设置成功返回true，否则返回false
  */
-Mongodb_cache.prototype.del = function(key) {
-	return this.conn.del(key);
+Mongodb_cache.prototype.setnx = async function(key, value) {
+    try {
+        // 触发before事件
+        this.emit('setnx_before', { key, value });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        // 检查键是否存在
+        const exists = await this.db.collection(this.table).findOne({
+            _id: key,
+            $or: [
+                { expireAt: { $exists: false } },
+                { expireAt: { $gt: new Date() } }
+            ]
+        }, { projection: { _id: 1 } });
+        
+        // 如果键存在，返回false
+        if (exists) {
+            // 触发after事件
+            this.emit('setnx_after', { key, value, result: false });
+            return false;
+        }
+        
+        // 否则设置值
+        await this.db.collection(this.table).insertOne({
+            _id: key,
+            value
+        });
+        
+        // 触发after事件
+        this.emit('setnx_after', { key, value, result: true });
+        
+        return true;
+    } catch (error) {
+        // 处理重复键错误
+        if (error.code === 11000) {
+            // 触发after事件
+            this.emit('setnx_after', { key, value, result: false });
+            return false;
+        }
+        // 触发error事件
+        this.emit('setnx_error', { key, value, error });
+        $.log.error('[MongoDB cache] 条件设置缓存失败:', error);
+        return false;
+    }
 };
 
 /**
- * @description 修改缓存
+ * @description 设置带过期时间的缓存 (Redis SETEX)
  * @param {String} key 键
+ * @param {Number} seconds 过期时间（秒）
  * @param {Object} value 值
- * @param {Number} seconds 秒
- * @return {Object} 值
+ * @return {Promise|Boolean} 是否设置成功
  */
-Mongodb_cache.prototype.set = async function(key, value, seconds) {
-	var ret;
-	ret = await this.conn.set(key, value);
-	if (seconds) {
-		ret = await this.conn.expire(key, seconds);
-	}
-	return ret
+Mongodb_cache.prototype.setex = async function(key, seconds, value) {
+    try {
+        // 触发before事件
+        this.emit('setex_before', { key, seconds, value });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || typeof seconds !== 'number' || seconds <= 0) {
+            throw new Error('参数无效：key不能为空且seconds必须是正数');
+        }
+        
+        const expireAt = new Date(Date.now() + seconds * 1000);
+        await this.db.collection(this.table).updateOne(
+            { _id: key },
+            { $set: { value, expireAt } },
+            { upsert: true }
+        );
+        
+        // 触发after事件
+        this.emit('setex_after', { key, seconds, value, result: true });
+        
+        return true;
+    } catch (error) {
+        // 触发error事件
+        this.emit('setex_error', { key, seconds, value, error });
+        $.log.error('[MongoDB cache] 设置带过期时间的缓存失败:', error);
+        return false;
+    }
 };
 
 /**
@@ -149,15 +470,51 @@ Mongodb_cache.prototype.set = async function(key, value, seconds) {
  * @return {Promise|Object} 值
  */
 Mongodb_cache.prototype.add = async function(key, value, seconds) {
-	var ret;
-	var has = await this.conn.exists(key);
-	if (!has) {
-		ret = await this.conn.set(key, value);
-	}
-	if (seconds) {
-		ret = await this.conn.expire(key, seconds);
-	}
-	return ret
+    try {
+        // 触发before事件
+        this.emit('add_before', { key, value, seconds });
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const exists = await this.db.collection(this.table).findOne({ _id: key }, { projection: { _id: 1, expireAt: 1 } });
+        
+        // 检查是否存在且未过期
+        if (exists) {
+            // 检查是否过期
+            if (exists.expireAt && new Date(exists.expireAt) < new Date()) {
+                // 过期则删除旧数据
+                await this.db.collection(this.table).deleteOne({ _id: key });
+            } else {
+                // 触发after事件
+                this.emit('add_after', { key, value, seconds, result: value });
+                // 未过期则返回现有值
+                return value;
+            }
+        }
+        
+        const data = { _id: key, value };
+        
+        // 设置过期时间
+        if (seconds) {
+            const expireAt = new Date(Date.now() + seconds * 1000);
+            data.expireAt = expireAt;
+        }
+        
+        await this.db.collection(this.table).insertOne(data);
+        
+        // 触发after事件
+        this.emit('add_after', { key, value, seconds, result: value });
+        
+        return value;
+    } catch (error) {
+        // 触发error事件
+        this.emit('add_error', { key, value, seconds, error });
+        $.log.error('[MongoDB cache] 添加缓存失败:', error);
+        throw error;
+    }
 };
 
 /**
@@ -165,8 +522,108 @@ Mongodb_cache.prototype.add = async function(key, value, seconds) {
  * @param {String} key 键
  * @return {Promise|Object} 查询值
  */
-Mongodb_cache.prototype.get = function(key) {
-	return this.conn.get(key);
+Mongodb_cache.prototype.get = async function(key) {
+    try {
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const result = await this.db.collection(this.table).findOne({ _id: key });
+        
+        let returnValue;
+        // 检查是否过期
+        if (result && result.expireAt && new Date(result.expireAt) < new Date()) {
+            // 过期则删除并返回null
+            await this.db.collection(this.table).deleteOne({ _id: key });
+            returnValue = null;
+        } else {
+            returnValue = result ? result.value : null;
+        }
+        
+        return returnValue;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 查询缓存失败:', error);
+        return null;
+    }
+};
+
+/**
+ * @description 批量查询缓存 (Redis MGET)
+ * @param {String[]} keys 键数组
+ * @return {Promise|Array} 值数组，顺序与键对应
+ */
+Mongodb_cache.prototype.mget = async function(...keys) {
+    try {
+        if (!keys || keys.length === 0) {
+            return [];
+        }
+        
+        const results = await this.db.collection(this.table).find({
+            _id: { $in: keys },
+            $or: [
+                { expireAt: { $exists: false } },
+                { expireAt: { $gt: new Date() } }
+            ]
+        }).toArray();
+        
+        // 创建结果映射
+        const resultMap = {};
+        results.forEach(item => {
+            resultMap[item._id] = item.value;
+        });
+        
+        // 按输入顺序返回结果
+        const resultArray = keys.map(key => resultMap[key] !== undefined ? resultMap[key] : null);
+        return resultArray;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 批量查询缓存失败:', error);
+        return [];
+    }
+};
+
+/**
+ * @description 批量设置缓存 (Redis MSET)
+ * @param {Object} keyValuePairs 键值对对象
+ * @return {Promise|Boolean} 是否设置成功
+ */
+Mongodb_cache.prototype.mset = async function(keyValuePairs) {
+    try {
+        // 触发before事件
+        this.emit('mset_before', { keyValuePairs });
+        
+        if (!keyValuePairs || typeof keyValuePairs !== 'object') {
+            // 触发after事件
+            this.emit('mset_after', { keyValuePairs, result: false });
+            return false;
+        }
+        
+        // 准备批量操作
+        const bulkOps = Object.entries(keyValuePairs).map(([key, value]) => ({
+            updateOne: {
+                filter: { _id: key },
+                update: { $set: { value }, $unset: { expireAt: 1 } },
+                upsert: true
+            }
+        }));
+        
+        if (bulkOps.length > 0) {
+            await this.db.collection(this.table).bulkWrite(bulkOps);
+        }
+        
+        // 触发after事件
+        this.emit('mset_after', { keyValuePairs, result: true });
+        
+        return true;
+    } catch (error) {
+        // 触发error事件
+        this.emit('mset_error', { keyValuePairs, error });
+        $.log.error('[MongoDB cache] 批量设置缓存失败:', error);
+        return false;
+    }
 };
 
 /**
@@ -174,8 +631,42 @@ Mongodb_cache.prototype.get = function(key) {
  * @param {String} key 键
  * @return {Promise|Boolean} 有返回true, 没有返回false
  */
-Mongodb_cache.prototype.has = function(key) {
-	return this.conn.exists(key);
+Mongodb_cache.prototype.has = async function(key) {
+    try {
+        // 触发before事件
+        this.emit('has_before', { key });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const result = await this.db.collection(this.table).findOne({ _id: key }, { projection: { _id: 1, expireAt: 1 } });
+        // 检查是否过期
+        if (result && result.expireAt && new Date(result.expireAt) < new Date()) {
+            // 过期则删除并返回false
+            await this.db.collection(this.table).deleteOne({ _id: key });
+            
+            // 触发after事件
+            this.emit('has_after', { key, result: false });
+            return false;
+        }
+        
+        const hasResult = !!result;
+        
+        // 触发after事件
+        this.emit('has_after', { key, result: hasResult });
+        
+        return hasResult;
+    } catch (error) {
+        // 触发error事件
+        this.emit('has_error', { key, error });
+        $.log.error('[MongoDB cache] 判断键是否存在失败:', error);
+        return false;
+    }
 };
 
 /**
@@ -185,8 +676,32 @@ Mongodb_cache.prototype.has = function(key) {
  * @param {Number} end 结束位置
  * @return {Promise|String} 查询值
  */
-Mongodb_cache.prototype.getrange = function(key, start, end) {
-	return this.conn.getrange(key, start, end);
+Mongodb_cache.prototype.getrange = async function(key, start, end) {
+    try {
+        // 触发before事件
+        this.emit('getrange_before', { key, start, end });
+        
+        // 验证参数
+        if (!key || typeof start !== 'number' || typeof end !== 'number') {
+            throw new Error('参数无效：key不能为空且start和end必须是数字');
+        }
+        
+        const value = await this.get(key);
+        let result = '';
+        if (typeof value === 'string') {
+            result = value.substring(start, end + 1);
+        }
+        
+        // 触发after事件
+        this.emit('getrange_after', { key, start, end, result: result });
+        
+        return result;
+    } catch (error) {
+        // 触发error事件
+        this.emit('getrange_error', { key, start, end, error });
+        $.log.error('[MongoDB cache] 查询字符串范围失败:', error);
+        return '';
+    }
 };
 
 /**
@@ -196,55 +711,238 @@ Mongodb_cache.prototype.getrange = function(key, start, end) {
  * @param {String} value 变更的值
  * @return {Promise|Number} 字符串长度
  */
-Mongodb_cache.prototype.setrange = function(key, index, value) {
-	return this.conn.getrange(key, index, value);
+Mongodb_cache.prototype.setrange = async function(key, index, value) {
+    try {
+        // 触发before事件
+        this.emit('setrange_before', { key, index, value });
+        
+        // 验证参数
+        if (!key || typeof index !== 'number' || typeof value !== 'string') {
+            throw new Error('参数无效：key不能为空，index必须是数字，value必须是字符串');
+        }
+        
+        // 获取当前值
+        let currentValue = await this.get(key) || '';
+        
+        // 确保当前值是字符串
+        if (typeof currentValue !== 'string') {
+            currentValue = '';
+        }
+        
+        // 处理index超出范围的情况
+        if (index > currentValue.length) {
+            // 补空格
+            currentValue = currentValue.padEnd(index, ' ');
+        }
+        
+        // 构建新字符串
+        const newValue = currentValue.substring(0, index) + value + currentValue.substring(index + value.length);
+        
+        // 保存新值
+        await this.set(key, newValue);
+        
+        const resultLength = newValue.length;
+        // 触发after事件
+        this.emit('setrange_after', { key, index, value, result: resultLength });
+        
+        return resultLength;
+    } catch (error) {
+        // 触发error事件
+        this.emit('setrange_error', { key, index, value, error });
+        $.log.error('[MongoDB cache] 设置字符串范围失败:', error);
+        return 0;
+    }
+};
+
+/**
+ * @description 获取字符串长度 (Redis STRLEN)
+ * @param {String} key 键
+ * @return {Promise|Number} 字符串长度，非字符串返回0
+ */
+Mongodb_cache.prototype.strlen = async function(key) {
+    try {
+        // 触发before事件
+        this.emit('strlen_before', { key });
+        
+        const value = await this.get(key);
+        const result = typeof value === 'string' ? value.length : 0;
+        
+        // 触发after事件
+        this.emit('strlen_after', { key, result: result });
+        
+        return result;
+    } catch (error) {
+        // 触发error事件
+        this.emit('strlen_error', { key, error });
+        $.log.error('[MongoDB cache] 获取字符串长度失败:', error);
+        return 0;
+    }
 };
 
 /**
  * @description 清空缓存
- * @param {String} key 键, 为空则清空所有
- * @return {Promise|Array} 执行结果
+ * @param {String} prefix 键前缀
+ * @return {Promise|Boolean} 成功返回true，失败返回false
  */
-Mongodb_cache.prototype.clear = function(key) {
-	if (key) {
-		return this.conn.del(key);
-	} else {
-		return this.conn.flushdb();
-	}
+Mongodb_cache.prototype.clear = async function(prefix) {
+    try {
+        // 触发before事件
+        this.emit('clear_before', { prefix });
+        
+        let query = {};
+        
+        // 如果提供了前缀，使用正则匹配
+        if (prefix) {
+            query._id = { $regex: `^${prefix}` };
+        }
+        
+        const result = await this.db.collection(this.table).deleteMany(query);
+        $.log.info(`[MongoDB cache] 清空缓存成功，删除了${result.deletedCount}条记录`);
+        
+        // 触发after事件
+        this.emit('clear_after', { prefix, result: true, deletedCount: result.deletedCount });
+        
+        return true;
+    } catch (error) {
+        // 触发error事件
+        this.emit('clear_error', { prefix, error });
+        $.log.error('[MongoDB cache] 清空缓存失败:', error);
+        return false;
+    }
 };
 
 /**
  * @description 排序
- * @param {String} key 键
- * @param {String} way = [asc|desc]排序方式, 可以为空
- * @param {String} obj_key 排序成员的键
- * @return {Promise|Array} 排序后的数组
+ * @param {String} prefix 键前缀
+ * @param {Number} count 数量
+ * @param {Number} type 类型 1: 从小到大，0: 从大到小
+ * @return {Promise|Array} 执行结果
  */
-Mongodb_cache.prototype.sort = function(key) {
-	return this.conn.sort(key);
+Mongodb_cache.prototype.sort = async function(prefix, count, type) {
+    try {
+        // 触发before事件
+        this.emit('sort_before', { prefix, count, type });
+        
+        // 验证参数
+        if (typeof count !== 'number' || (type !== 0 && type !== 1)) {
+            throw new Error('参数无效：count必须是数字，type必须是0或1');
+        }
+        
+        // 构建查询
+        let query = {};
+        if (prefix) {
+            query._id = { $regex: `^${prefix}` };
+        }
+        
+        // 排除过期的数据
+        query.$or = [
+            { expireAt: { $exists: false } },
+            { expireAt: { $gt: new Date() } }
+        ];
+        
+        // 执行查询并排序
+        const cursor = this.db.collection(this.table)
+            .find(query)
+            .sort({ value: type === 1 ? 1 : -1 })
+            .limit(count);
+        
+        const results = await cursor.toArray();
+        
+        // 转换为所需格式
+        const formattedResults = results.map(item => [item._id, item.value]);
+        
+        // 触发after事件
+        this.emit('sort_after', { prefix, count, type, result: formattedResults });
+        
+        return formattedResults;
+    } catch (error) {
+        // 触发error事件
+        this.emit('sort_error', { prefix, count, type, error });
+        $.log.error('[MongoDB cache] 排序失败:', error);
+        return [];
+    }
 };
 
 /**
- * @description 获取所有键名
- * @param {String} key 键 支持*号, 前面加*表示后面名称一致, 前后加*表示包含名称, 后面加*表示前面名称一致
- * @return {Promise|Array} 键数组
+ * @description 获取键名
+ * @param {String} pattern 匹配模式
+ * @return {Promise|Array} 键名数组
  */
-Mongodb_cache.prototype.keys = function(key) {
-	if (!key) {
-		key = "*";
-	}
-	return this.conn.keys(key);
+Mongodb_cache.prototype.keys = async function(pattern) {
+    try {
+        // 触发before事件
+        this.emit('keys_before', { pattern });
+        
+        // 构建查询
+        let query = {};
+        
+        // 处理通配符
+        if (pattern) {
+            // 将Redis风格的通配符转换为正则表达式
+            const regexPattern = pattern
+                .replace(/\*/g, '.*')  // * 转换为 .*
+                .replace(/\?/g, '.');  // ? 转换为 .
+            query._id = { $regex: `^${regexPattern}$` };
+        }
+        
+        // 排除过期的数据
+        query.$or = [
+            { expireAt: { $exists: false } },
+            { expireAt: { $gt: new Date() } }
+        ];
+        
+        // 只获取_id字段
+        const cursor = this.db.collection(this.table)
+            .find(query)
+            .project({ _id: 1 });
+        
+        const results = await cursor.toArray();
+        
+        // 提取键名
+        const keysList = results.map(item => item._id);
+        
+        // 触发after事件
+        this.emit('keys_after', { pattern, result: keysList });
+        
+        return keysList;
+    } catch (error) {
+        // 触发error事件
+        this.emit('keys_error', { pattern, error });
+        $.log.error('[MongoDB cache] 获取键名失败:', error);
+        return [];
+    }
 };
 
 /**
  * @description 修改数组缓存
  * @param {String} key 键
- * @param {Object} value 值
+ * @param {Array} value 值
  * @param {Number} seconds 秒
  * @return {Promise|Array} 执行结果
  */
-Mongodb_cache.prototype.list_set = function(key, value, seconds) {
-	return this.conn.rpush(key, value);
+Mongodb_cache.prototype.list_set = async function(key, value, seconds) {
+    try {
+        // 触发before事件
+        this.emit('list_set_before', { key, value, seconds });
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const finalValue = Array.isArray(value) ? value : [value];
+        const result = await this.set(key, finalValue, seconds);
+        
+        // 触发after事件
+        this.emit('list_set_after', { key, value: finalValue, seconds, result });
+        
+        return result;
+    } catch (error) {
+        // 触发error事件
+        this.emit('list_set_error', { key, value, seconds, error });
+        $.log.error('[MongoDB cache] 修改数组缓存失败:', error);
+        throw error;
+    }
 };
 
 /**
@@ -253,8 +951,186 @@ Mongodb_cache.prototype.list_set = function(key, value, seconds) {
  * @param {Object} value 值
  * @return {Promise|String} 追加后的数组
  */
-Mongodb_cache.prototype.list_push = function(key, value) {
-	return this.conn.rpush(key, value);
+Mongodb_cache.prototype.list_push = async function(key, value) {
+    try {
+        // 触发before事件
+        this.emit('list_push_before', { key, value });
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        // 获取现有值
+        let currentValue = await this.get(key);
+        
+        // 如果不存在或不是数组，则初始化为空数组
+        if (!Array.isArray(currentValue)) {
+            currentValue = [];
+        }
+        
+        // 追加新值
+        currentValue.push(value);
+        
+        // 保存更新后的值
+        await this.set(key, currentValue);
+        
+        // 触发after事件
+        this.emit('list_push_after', { key, value, result: currentValue });
+        
+        return currentValue;
+    } catch (error) {
+        // 触发error事件
+        this.emit('list_push_error', { key, value, error });
+        $.log.error('[MongoDB cache] 数组缓存追加对象失败:', error);
+        throw error;
+    }
+};
+
+/**
+ * @description 在数组头部添加元素 (Redis LPUSH)
+ * @param {String} key 键
+ * @param {Object} value 值
+ * @return {Promise|Array} 添加后的数组
+ */
+Mongodb_cache.prototype.lpush = async function(key, value) {
+    try {
+        // 触发before事件
+        this.emit('lpush_before', { key, value });
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        // 获取现有值
+        let currentValue = await this.get(key);
+        
+        // 如果不存在或不是数组，则初始化为空数组
+        if (!Array.isArray(currentValue)) {
+            currentValue = [];
+        }
+        
+        // 在头部添加新值
+        currentValue.unshift(value);
+        
+        // 保存更新后的值
+        await this.set(key, currentValue);
+        
+        // 触发after事件
+        this.emit('lpush_after', { key, value, result: currentValue });
+        
+        return currentValue;
+    } catch (error) {
+        // 触发error事件
+        this.emit('lpush_error', { key, value, error });
+        $.log.error('[MongoDB cache] 在数组头部添加元素失败:', error);
+        throw error;
+    }
+};
+
+/**
+ * @description 从数组尾部弹出元素 (Redis RPOP)
+ * @param {String} key 键
+ * @return {Promise|*} 弹出的元素，数组不存在或为空返回null
+ */
+Mongodb_cache.prototype.rpop = async function(key) {
+    try {
+        // 触发before事件
+        this.emit('rpop_before', { key });
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        // 获取现有值
+        let currentValue = await this.get(key);
+        
+        // 如果不存在或不是数组或为空，返回null
+        if (!Array.isArray(currentValue) || currentValue.length === 0) {
+            // 触发after事件
+            this.emit('rpop_after', { key, result: null });
+            return null;
+        }
+        
+        // 弹出最后一个元素
+        const popped = currentValue.pop();
+        
+        // 保存更新后的值
+        await this.set(key, currentValue);
+        
+        // 触发after事件
+        this.emit('rpop_after', { key, result: popped });
+        
+        return popped;
+    } catch (error) {
+        // 触发error事件
+        this.emit('rpop_error', { key, error });
+        $.log.error('[MongoDB cache] 从数组尾部弹出元素失败:', error);
+        return null;
+    }
+};
+
+/**
+ * @description 从数组头部弹出元素 (Redis LPOP)
+ * @param {String} key 键
+ * @return {Promise|*} 弹出的元素，数组不存在或为空返回null
+ */
+Mongodb_cache.prototype.lpop = async function(key) {
+    try {
+        // 触发before事件
+        this.emit('lpop_before', { key });
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        // 获取现有值
+        let currentValue = await this.get(key);
+        
+        // 如果不存在或不是数组或为空，返回null
+        if (!Array.isArray(currentValue) || currentValue.length === 0) {
+            // 触发after事件
+            this.emit('lpop_after', { key, result: null });
+            return null;
+        }
+        
+        // 弹出第一个元素
+        const popped = currentValue.shift();
+        
+        // 保存更新后的值
+        await this.set(key, currentValue);
+        
+        // 触发after事件
+        this.emit('lpop_after', { key, result: popped });
+        
+        return popped;
+    } catch (error) {
+        // 触发error事件
+        this.emit('lpop_error', { key, error });
+        $.log.error('[MongoDB cache] 从数组头部弹出元素失败:', error);
+        return null;
+    }
+};
+
+/**
+ * @description 获取数组长度 (Redis LLEN)
+ * @param {String} key 键
+ * @return {Promise|Number} 数组长度，不存在或不是数组返回0
+ */
+Mongodb_cache.prototype.llen = async function(key) {
+	try {
+		// 确保连接已建立
+		await this._ensureConnected();
+		
+		const value = await this.get(key);
+		return Array.isArray(value) ? value.length : 0;
+	} catch (error) {
+		$.log.error('[MongoDB cache] 获取数组长度失败:', error);
+		return 0;
+	}
 };
 
 /**
@@ -264,19 +1140,40 @@ Mongodb_cache.prototype.list_push = function(key, value) {
  * @return {Promise|Boolean} 存在返回true, 否则返回false
  */
 Mongodb_cache.prototype.list_has = async function(key, value) {
-	if (!value) {
-		throw '值不能为空';
-	}
-	var arr = await this.list_get(key);
-	var has = false;
-	var len = arr.length;
-	for (var i = 0; i < len; i++) {
-		if (value == arr[i]) {
-			has = true;
-			break;
-		}
-	}
-	return has;
+    if (!value) {
+        throw '值不能为空';
+    }
+    try {
+        // 触发before事件
+        this.emit('list_has_before', { key, value });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const arr = await this.get(key) || [];
+        if (!Array.isArray(arr)) {
+            // 触发after事件
+            this.emit('list_has_after', { key, value, result: false });
+            return false;
+        }
+        
+        const result = arr.some(item => item === value || JSON.stringify(item) === JSON.stringify(value));
+        
+        // 触发after事件
+        this.emit('list_has_after', { key, value, result });
+        
+        return result;
+    } catch (error) {
+        // 触发error事件
+        this.emit('list_has_error', { key, value, error });
+        $.log.error('[MongoDB cache] 判断成员是否存在失败:', error);
+        return false;
+    }
 };
 
 /**
@@ -286,41 +1183,1648 @@ Mongodb_cache.prototype.list_has = async function(key, value) {
  * @param {Number} end 结束位置
  * @return {Promise|Array} 查询到的数组
  */
-Mongodb_cache.prototype.list_get = function(key, start, end) {
-	if (start === undefined) {
-		start = 0;
-	}
-	if (end === undefined) {
-		end = -1;
-	}
-	return this.conn.lrange(key, start, end);
+Mongodb_cache.prototype.list_get = async function(key, start, end) {
+    try {
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const arr = await this.get(key) || [];
+        if (!Array.isArray(arr)) {
+            return [];
+        }
+        if (start === undefined) {
+            start = 0;
+        }
+        if (end === undefined) {
+            end = -1;
+        }
+        // 处理负数索引
+        if (start < 0) start = Math.max(0, arr.length + start);
+        if (end < 0) end = arr.length + end;
+        
+        const result = arr.slice(start, end + 1);
+        
+        return result;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 查询数组缓存失败:', error);
+        return [];
+    }
 };
 
 /**
  * @description 清空数组缓存
  * @param {String} key 键
  * @param {Array} value 新成员, 没有则删除数组
- * @return {Promise|Boolean} 成功返回true，是否返回false
+ * @return {Promise|Boolean} 成功返回true，失败返回false
  */
 Mongodb_cache.prototype.list_clear = async function(key, value) {
-	var ret;
-	if (key) {
-		if (value) {
-			// 如果有值则删除其他成员，保留新值
-			try {
-				var len = await this.list_push(key, value);
-				ret = this.conn.ltrim(key, len - value.length, len - 1);
-			} catch (e) {
+    try {
+        // 触发before事件
+        this.emit('list_clear_before', { key, value });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        if (!key) {
+            throw '键不能为空';
+        }
+        
+        let result;
+        if (value) {
+            // 设置新的数组值
+            await this.set(key, Array.isArray(value) ? value : [value]);
+            result = true;
+        } else {
+            // 直接删除键
+            result = await this.del(key);
+        }
+        
+        // 触发after事件
+        this.emit('list_clear_after', { key, value, result });
+        
+        return result;
+    } catch (error) {
+        // 触发error事件
+        this.emit('list_clear_error', { key, value, error });
+        $.log.error('[MongoDB cache] 清空数组缓存失败:', error);
+        return false;
+    }
+};
 
-			}
-		} else {
-			// 直接删除键
-			return await this.conn.del(key);
-		}
-	} else {
-		throw '键不能为空';
-	}
-	return ret
+/**
+ * @description 设置缓存过期时间
+ * @param {String} key 键
+ * @param {Number} seconds 过期时间（秒）
+ * @return {Promise|Boolean} 成功返回true，失败返回false
+ */
+Mongodb_cache.prototype.expire = async function(key, seconds) {
+    try {
+        // 触发before事件
+        this.emit('expire_before', { key, seconds });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || typeof seconds !== 'number' || seconds < 0) {
+            throw new Error('参数无效：key不能为空且seconds必须是非负数字');
+        }
+        
+        const expireAt = new Date(Date.now() + seconds * 1000);
+        const result = await this.db.collection(this.table).updateOne(
+            { _id: key },
+            { $set: { expireAt } }
+        );
+        
+        const success = result.modifiedCount > 0;
+        
+        // 触发after事件
+        this.emit('expire_after', { key, seconds, result: success });
+        
+        return success;
+    } catch (error) {
+        // 触发error事件
+        this.emit('expire_error', { key, seconds, error });
+        $.log.error('[MongoDB cache] 设置过期时间失败:', error);
+        return false;
+    }
+};
+
+/**
+ * @description 获取缓存剩余过期时间
+ * @param {String} key 键
+ * @return {Promise|Number} 剩余过期时间（秒），-1表示永不过期，-2表示不存在
+ */
+Mongodb_cache.prototype.ttl = async function(key) {
+    try {
+        // 触发before事件
+        this.emit('ttl_before', { key });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const result = await this.db.collection(this.table).findOne({ _id: key }, { projection: { expireAt: 1 } });
+        
+        let ttlValue;
+        if (!result) {
+            ttlValue = -2; // 键不存在
+        } else if (!result.expireAt) {
+            ttlValue = -1; // 永不过期
+        } else {
+            const now = new Date();
+            const expireTime = new Date(result.expireAt);
+            ttlValue = Math.ceil((expireTime - now) / 1000);
+            ttlValue = Math.max(0, ttlValue); // 返回剩余秒数，最少为0
+        }
+        
+        // 触发after事件
+        this.emit('ttl_after', { key, result: ttlValue });
+        
+        return ttlValue;
+    } catch (error) {
+        // 触发error事件
+        this.emit('ttl_error', { key, error });
+        $.log.error('[MongoDB cache] 获取过期时间失败:', error);
+        return -2; // 出错时默认返回不存在
+    }
+};
+
+/**
+ * @description 移除过期时间 (Redis PERSIST)
+ * @param {String} key 键
+ * @return {Promise|Boolean} 成功返回true，失败返回false
+ */
+Mongodb_cache.prototype.persist = async function(key) {
+    try {
+        // 触发before事件
+        this.emit('persist_before', { key });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const result = await this.db.collection(this.table).updateOne(
+            { _id: key },
+            { $unset: { expireAt: 1 } }
+        );
+        
+        const success = result.modifiedCount > 0;
+        
+        // 触发after事件
+        this.emit('persist_after', { key, result: success });
+        
+        return success;
+    } catch (error) {
+        // 触发error事件
+        this.emit('persist_error', { key, error });
+        $.log.error('[MongoDB cache] 移除过期时间失败:', error);
+        return false;
+    }
+};
+
+// 哈希操作方法
+
+/**
+ * @description 设置哈希字段 (Redis HSET)
+ * @param {String} key 键
+ * @param {String} field 字段名
+ * @param {*} value 字段值
+ * @return {Promise|Boolean} 是否设置成功
+ */
+Mongodb_cache.prototype.hset = async function(key, field, value) {
+    try {
+        // 触发before事件
+        this.emit('hset_before', { key, field, value });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || !field) {
+            throw new Error('参数无效：key和field不能为空');
+        }
+        
+        // 准备更新对象
+        const updateField = `fields.${field}`;
+        const updateData = { $set: {} };
+        updateData.$set[updateField] = value;
+        
+        // 执行更新
+        await this.db.collection(this.table).updateOne(
+            { _id: key },
+            updateData,
+            { upsert: true }
+        );
+        
+        // 触发after事件
+        this.emit('hset_after', { key, field, value, result: true });
+        
+        return true;
+    } catch (error) {
+        // 触发error事件
+        this.emit('hset_error', { key, field, value, error });
+        $.log.error('[MongoDB cache] 设置哈希字段失败:', error);
+        return false;
+    }
+};
+
+/**
+ * @description 获取哈希字段值 (Redis HGET)
+ * @param {String} key 键
+ * @param {String} field 字段名
+ * @return {Promise|null} 字段值，不存在返回null
+ */
+Mongodb_cache.prototype.hget = async function(key, field) {
+    try {
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || !field) {
+            throw new Error('参数无效：key和field不能为空');
+        }
+        
+        const result = await this.db.collection(this.table).findOne(
+            { _id: key },
+            { projection: { [`fields.${field}`]: 1 } }
+        );
+        
+        // 检查是否过期
+        if (result && result.expireAt && new Date(result.expireAt) < new Date()) {
+            // 过期则删除并返回null
+            await this.db.collection(this.table).deleteOne({ _id: key });
+            // 触发after事件
+            this.emit('hget_after', { key, field, result: null });
+            return null;
+        }
+        
+        // 确保字段存在才返回值，否则返回null
+        const fieldValue = result && result.fields && field in result.fields ? result.fields[field] : null;
+        
+        return fieldValue;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 获取哈希字段值失败:', error);
+        return null;
+    }
+};
+
+/**
+ * @description 获取哈希所有字段和值 (Redis HGETALL)
+ * @param {String} key 键
+ * @return {Promise|Object} 所有字段和值，不存在返回{}
+ */
+Mongodb_cache.prototype.hgetall = async function(key) {
+    try {
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const result = await this.db.collection(this.table).findOne(
+            { _id: key },
+            { projection: { fields: 1, expireAt: 1 } }
+        );
+        
+        // 检查是否过期
+        if (result && result.expireAt && new Date(result.expireAt) < new Date()) {
+            // 过期则删除并返回{}
+            await this.db.collection(this.table).deleteOne({ _id: key });
+            return {};
+        }
+        
+        const fieldsData = result && result.fields ? result.fields : {};
+        
+        return fieldsData;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 获取哈希所有字段和值失败:', error);
+        return {};
+    }
+};
+
+/**
+ * @description 删除哈希字段 (Redis HDEL)
+ * @param {String} key 键
+ * @param {String} field 字段名
+ * @return {Promise|null} 删除成功返回null
+ */
+Mongodb_cache.prototype.hdel = async function(key, field) {
+    try {
+        // 触发before事件
+        this.emit('hdel_before', { key, field });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || !field) {
+            throw new Error('参数无效：key和field不能为空');
+        }
+        
+        // 准备更新对象
+        const unsetField = `fields.${field}`;
+        const updateData = { $unset: {} };
+        updateData.$unset[unsetField] = '';
+        
+        // 执行更新
+        await this.db.collection(this.table).updateOne(
+            { _id: key },
+            updateData
+        );
+        
+        // 触发after事件
+        this.emit('hdel_after', { key, field, result: null });
+        
+        // 返回null以匹配Redis行为
+        return null;
+    } catch (error) {
+        // 触发error事件
+        this.emit('hdel_error', { key, field, error });
+        $.log.error('[MongoDB cache] 删除哈希字段失败:', error);
+        return null;
+    }
+};
+
+/**
+ * @description 判断哈希字段是否存在 (Redis HEXISTS)
+ * @param {String} key 键
+ * @param {String} field 字段名
+ * @return {Promise|Boolean} 存在返回true，不存在返回false
+ */
+Mongodb_cache.prototype.hexists = async function(key, field) {
+    try {
+        // 触发before事件
+        this.emit('hexists_before', { key, field });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || !field) {
+            throw new Error('参数无效：key和field不能为空');
+        }
+        
+        const result = await this.db.collection(this.table).findOne(
+            { 
+                _id: key,
+                $or: [
+                    { expireAt: { $exists: false } },
+                    { expireAt: { $gt: new Date() } }
+                ],
+                [`fields.${field}`]: { $exists: true }
+            },
+            { projection: { _id: 1 } }
+        );
+        
+        const exists = !!result;
+        
+        // 触发after事件
+        this.emit('hexists_after', { key, field, result: exists });
+        
+        return exists;
+    } catch (error) {
+        // 触发error事件
+        this.emit('hexists_error', { key, field, error });
+        $.log.error('[MongoDB cache] 判断哈希字段是否存在失败:', error);
+        return false;
+    }
+};
+
+/**
+ * @description 获取哈希所有字段名 (Redis HKEYS)
+ * @param {String} key 键
+ * @return {Promise|Array} 字段名数组
+ */
+Mongodb_cache.prototype.hkeys = async function(key) {
+    try {
+        // 触发before事件
+        this.emit('hkeys_before', { key });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const result = await this.db.collection(this.table).findOne(
+            { _id: key },
+            { projection: { fields: 1, expireAt: 1 } }
+        );
+        
+        // 检查是否过期
+        if (result && result.expireAt && new Date(result.expireAt) < new Date()) {
+            // 过期则删除并返回[]
+            await this.db.collection(this.table).deleteOne({ _id: key });
+            // 触发after事件
+            this.emit('hkeys_after', { key, result: [] });
+            return [];
+        }
+        
+        const fieldsList = result && result.fields ? Object.keys(result.fields) : [];
+        
+        // 触发after事件
+        this.emit('hkeys_after', { key, result: fieldsList });
+        
+        return fieldsList;
+    } catch (error) {
+        // 触发error事件
+        this.emit('hkeys_error', { key, error });
+        $.log.error('[MongoDB cache] 获取哈希所有字段名失败:', error);
+        return [];
+    }
+};
+
+/**
+ * @description 获取哈希字段数量 (Redis HLEN)
+ * @param {String} key 键
+ * @return {Promise|Number} 字段数量
+ */
+Mongodb_cache.prototype.hlen = async function(key) {
+    try {
+        // 触发before事件
+        this.emit('hlen_before', { key });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const result = await this.db.collection(this.table).findOne(
+            { _id: key },
+            { projection: { fields: 1, expireAt: 1 } }
+        );
+        
+        // 检查是否过期
+        if (result && result.expireAt && new Date(result.expireAt) < new Date()) {
+            // 过期则删除并返回0
+            await this.db.collection(this.table).deleteOne({ _id: key });
+            // 触发after事件
+            this.emit('hlen_after', { key, result: 0 });
+            return 0;
+        }
+        
+        const length = result && result.fields ? Object.keys(result.fields).length : 0;
+        
+        // 触发after事件
+        this.emit('hlen_after', { key, result: length });
+        
+        return length;
+    } catch (error) {
+        // 触发error事件
+        this.emit('hlen_error', { key, error });
+        $.log.error('[MongoDB cache] 获取哈希字段数量失败:', error);
+        return 0;
+    }
+};
+
+// 集合操作方法
+
+/**
+ * @description 向集合添加成员 (Redis SADD)
+ * @param {String} key 键
+ * @param {*} member 成员
+ * @return {Promise|Number} 添加的成员数量
+ */
+Mongodb_cache.prototype.sadd = async function(key, member) {
+    try {
+        // 触发before事件
+        this.emit('sadd_before', { key, member });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        // 准备更新数据
+        const updateData = {
+            $addToSet: { setMembers: member }
+        };
+        
+        // 执行更新
+        const result = await this.db.collection(this.table).updateOne(
+            { _id: key },
+            updateData,
+            { upsert: true }
+        );
+        
+        // 检查是否新增了成员
+        const doc = await this.db.collection(this.table).findOne(
+            { _id: key },
+            { projection: { setMembers: 1 } }
+        );
+        
+        const addedCount = 1; // MongoDB不直接返回是否添加成功，这里假设成功
+        
+        // 触发after事件
+        this.emit('sadd_after', { key, member, result: addedCount });
+        
+        return addedCount;
+    } catch (error) {
+        // 触发error事件
+        this.emit('sadd_error', { key, member, error });
+        $.log.error('[MongoDB cache] 向集合添加成员失败:', error);
+        return 0;
+    }
+};
+
+/**
+ * @description 从集合移除成员 (Redis SREM)
+ * @param {String} key 键
+ * @param {*} member 成员
+ * @return {Promise|Number} 移除的成员数量
+ */
+Mongodb_cache.prototype.srem = async function(key, member) {
+    try {
+        // 触发before事件
+        this.emit('srem_before', { key, member });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        // 准备更新数据
+        const updateData = {
+            $pull: { setMembers: member }
+        };
+        
+        // 执行更新
+        const result = await this.db.collection(this.table).updateOne(
+            { _id: key },
+            updateData
+        );
+        
+        const removedCount = result.modifiedCount;
+        
+        // 触发after事件
+        this.emit('srem_after', { key, member, result: removedCount });
+        
+        return removedCount;
+    } catch (error) {
+        // 触发error事件
+        this.emit('srem_error', { key, member, error });
+        $.log.error('[MongoDB cache] 从集合移除成员失败:', error);
+        return 0;
+    }
+};
+
+/**
+ * @description 获取集合所有成员 (Redis SMEMBERS)
+ * @param {String} key 键
+ * @return {Promise|Array} 成员数组
+ */
+Mongodb_cache.prototype.smembers = async function(key) {
+    try {
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const result = await this.db.collection(this.table).findOne(
+            { _id: key },
+            { projection: { setMembers: 1, expireAt: 1 } }
+        );
+        
+        // 检查是否过期
+        if (result && result.expireAt && new Date(result.expireAt) < new Date()) {
+            // 过期则删除并返回[]
+            await this.db.collection(this.table).deleteOne({ _id: key });
+            return [];
+        }
+        
+        const members = result && Array.isArray(result.setMembers) ? result.setMembers : [];
+        
+        return members;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 获取集合所有成员失败:', error);
+        return [];
+    }
+};
+
+/**
+ * @description 判断成员是否在集合中 (Redis SISMEMBER)
+ * @param {String} key 键
+ * @param {*} member 成员
+ * @return {Promise|Boolean} 存在返回true，不存在返回false
+ */
+Mongodb_cache.prototype.sismember = async function(key, member) {
+    try {
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const result = await this.db.collection(this.table).findOne(
+            { 
+                _id: key,
+                $or: [
+                    { expireAt: { $exists: false } },
+                    { expireAt: { $gt: new Date() } }
+                ],
+                setMembers: member
+            },
+            { projection: { _id: 1 } }
+        );
+        
+        const exists = !!result;
+        
+        return exists;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 判断成员是否在集合中失败:', error);
+        return false;
+    }
+};
+
+/**
+ * @description 获取集合成员数量 (Redis SCARD)
+ * @param {String} key 键
+ * @return {Promise|Number} 成员数量
+ */
+Mongodb_cache.prototype.scard = async function(key) {
+    try {
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        const result = await this.db.collection(this.table).findOne(
+            { _id: key },
+            { projection: { setMembers: 1, expireAt: 1 } }
+        );
+        
+        // 检查是否过期
+        if (result && result.expireAt && new Date(result.expireAt) < new Date()) {
+            // 过期则删除并返回0
+            await this.db.collection(this.table).deleteOne({ _id: key });
+            return 0;
+        }
+        
+        const count = result && Array.isArray(result.setMembers) ? result.setMembers.length : 0;
+        
+        return count;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 获取集合成员数量失败:', error);
+        return 0;
+    }
+};
+
+// 基本操作补充方法
+
+/**
+ * @description 原子递增 (Redis INCR)
+ * @param {String} key 键
+ * @return {Promise|Number} 递增后的值
+ */
+Mongodb_cache.prototype.incr = async function(key) {
+    try {
+        // 触发before事件
+        this.emit('incr_before', { key });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        // 使用$inc操作符增加1
+        const result = await this.db.collection(this.table).findOneAndUpdate(
+            { _id: key },
+            { $inc: { value: 1 } },
+            { upsert: true, returnDocument: 'after', projection: { value: 1 } }
+        );
+        
+        const newValue = result.value ? result.value.value : 1;
+        
+        // 触发after事件
+        this.emit('incr_after', { key, result: newValue });
+        
+        return newValue;
+    } catch (error) {
+        // 触发error事件
+        this.emit('incr_error', { key, error });
+        $.log.error('[MongoDB cache] 原子递增失败:', error);
+        throw error;
+    }
+};
+
+/**
+ * @description 原子递减 (Redis DECR)
+ * @param {String} key 键
+ * @return {Promise|Number} 递减后的值
+ */
+Mongodb_cache.prototype.decr = async function(key) {
+    try {
+        // 触发before事件
+        this.emit('decr_before', { key });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        // 使用$inc操作符减少1
+        const result = await this.db.collection(this.table).findOneAndUpdate(
+            { _id: key },
+            { $inc: { value: -1 } },
+            { upsert: true, returnDocument: 'after', projection: { value: 1 } }
+        );
+        
+        const newValue = result.value ? result.value.value : -1;
+        
+        // 触发after事件
+        this.emit('decr_after', { key, result: newValue });
+        
+        return newValue;
+    } catch (error) {
+        // 触发error事件
+        this.emit('decr_error', { key, error });
+        $.log.error('[MongoDB cache] 原子递减失败:', error);
+        throw error;
+    }
+};
+
+/**
+ * @description 原子递增指定值 (Redis INCRBY)
+ * @param {String} key 键
+ * @param {Number} value 递增值
+ * @return {Promise|Number} 递增后的值
+ */
+Mongodb_cache.prototype.incrby = async function(key, value) {
+    try {
+        // 触发before事件
+        this.emit('incrby_before', { key, value });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || typeof value !== 'number' || !Number.isInteger(value)) {
+            throw new Error('参数无效：key不能为空且value必须是整数');
+        }
+        
+        const result = await this.addInt(key, value);
+        
+        // 触发after事件
+        this.emit('incrby_after', { key, value, result });
+        
+        return result;
+    } catch (error) {
+        // 触发error事件
+        this.emit('incrby_error', { key, value, error });
+        $.log.error('[MongoDB cache] 原子递增指定值失败:', error);
+        throw error;
+    }
+};
+
+/**
+ * @description 原子递减指定值 (Redis DECRBY)
+ * @param {String} key 键
+ * @param {Number} value 递减值
+ * @return {Promise|Number} 递减后的值
+ */
+Mongodb_cache.prototype.decrby = async function(key, value) {
+    try {
+        // 触发before事件
+        this.emit('decrby_before', { key, value });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || typeof value !== 'number' || !Number.isInteger(value)) {
+            throw new Error('参数无效：key不能为空且value必须是整数');
+        }
+        
+        // 递减就是增加负值
+        const result = await this.addInt(key, -value);
+        
+        // 触发after事件
+        this.emit('decrby_after', { key, value, result });
+        
+        return result;
+    } catch (error) {
+        // 触发error事件
+        this.emit('decrby_error', { key, value, error });
+        $.log.error('[MongoDB cache] 原子递减指定值失败:', error);
+        throw error;
+    }
+};
+
+/**
+ * @description 追加字符串 (Redis APPEND)
+ * @param {String} key 键
+ * @param {String} value 要追加的字符串
+ * @return {Promise|Number} 追加后的字符串长度
+ */
+Mongodb_cache.prototype.append = async function(key, value) {
+    try {
+        // 触发before事件
+        this.emit('append_before', { key, value });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || typeof value !== 'string') {
+            throw new Error('参数无效：key不能为空且value必须是字符串');
+        }
+        
+        // 使用addStr方法追加字符串
+        const newValue = await this.addStr(key, value);
+        const length = newValue.length;
+        
+        // 触发after事件
+        this.emit('append_after', { key, value, result: length });
+        
+        return length;
+    } catch (error) {
+        // 触发error事件
+        this.emit('append_error', { key, value, error });
+        $.log.error('[MongoDB cache] 追加字符串失败:', error);
+        return 0;
+    }
+};
+
+/**
+ * @description 重命名键 (Redis RENAME)
+ * @param {String} oldKey 旧键名
+ * @param {String} newKey 新键名
+ * @return {Promise|Boolean} 是否重命名成功
+ */
+Mongodb_cache.prototype.rename = async function(oldKey, newKey) {
+    try {
+        // 触发before事件
+        this.emit('rename_before', { oldKey, newKey });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!oldKey || !newKey) {
+            throw new Error('参数无效：旧键和新键不能为空');
+        }
+        
+        // 获取旧键的值
+        const result = await this.db.collection(this.table).findOne({ _id: oldKey });
+        if (!result) {
+            // 触发after事件
+            this.emit('rename_after', { oldKey, newKey, result: false });
+            return false;
+        }
+        
+        // 创建新键
+        const newDoc = { ...result, _id: newKey };
+        delete newDoc._id; // 移除旧的_id字段
+        
+        // 先删除可能存在的新键
+        await this.db.collection(this.table).deleteOne({ _id: newKey });
+        
+        // 插入新键
+        await this.db.collection(this.table).insertOne({ ...newDoc, _id: newKey });
+        
+        // 删除旧键
+        await this.db.collection(this.table).deleteOne({ _id: oldKey });
+        
+        // 触发after事件
+        this.emit('rename_after', { oldKey, newKey, result: true });
+        
+        return true;
+    } catch (error) {
+        // 触发error事件
+        this.emit('rename_error', { oldKey, newKey, error });
+        $.log.error('[MongoDB cache] 重命名键失败:', error);
+        return false;
+    }
+};
+
+/**
+ * @description 条件重命名键 (Redis RENAMENX)
+ * @param {String} oldKey 旧键名
+ * @param {String} newKey 新键名
+ * @return {Promise|Boolean} 如果新键不存在且重命名成功返回true，否则返回false
+ */
+Mongodb_cache.prototype.renamenx = async function(oldKey, newKey) {
+    try {
+        // 触发before事件
+        this.emit('renamenx_before', { oldKey, newKey });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!oldKey || !newKey) {
+            throw new Error('参数无效：旧键和新键不能为空');
+        }
+        
+        // 检查新键是否存在
+        const newKeyExists = await this.db.collection(this.table).findOne({ _id: newKey }, { projection: { _id: 1 } });
+        if (newKeyExists) {
+            // 触发after事件
+            this.emit('renamenx_after', { oldKey, newKey, result: false });
+            return false;
+        }
+        
+        // 获取旧键的值
+        const result = await this.db.collection(this.table).findOne({ _id: oldKey });
+        if (!result) {
+            // 触发after事件
+            this.emit('renamenx_after', { oldKey, newKey, result: false });
+            return false;
+        }
+        
+        // 创建新键
+        const newDoc = { ...result };
+        delete newDoc._id; // 移除旧的_id字段
+        
+        // 插入新键
+        await this.db.collection(this.table).insertOne({ ...newDoc, _id: newKey });
+        
+        // 删除旧键
+        await this.db.collection(this.table).deleteOne({ _id: oldKey });
+        
+        // 触发after事件
+        this.emit('renamenx_after', { oldKey, newKey, result: true });
+        
+        return true;
+    } catch (error) {
+        // 触发error事件
+        this.emit('renamenx_error', { oldKey, newKey, error });
+        $.log.error('[MongoDB cache] 条件重命名键失败:', error);
+        return false;
+    }
+};
+
+/**
+ * @description 获取数据库中的键数量 (Redis DBSIZE)
+ * @return {Promise|Number} 键的数量
+ */
+Mongodb_cache.prototype.dbsize = async function() {
+    try {
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 查询有效（未过期）的键数量
+        const count = await this.db.collection(this.table).countDocuments({
+            $or: [
+                { expireAt: { $exists: false } },
+                { expireAt: { $gt: new Date() } }
+            ]
+        });
+        
+        return count;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 获取键数量失败:', error);
+        return 0;
+    }
+};
+
+// 列表操作补充方法
+
+/**
+ * @description 从右侧推入元素 (Redis RPUSH)
+ * @param {String} key 键
+ * @param {*} value 值
+ * @return {Promise|Array} 操作后的数组
+ */
+Mongodb_cache.prototype.rpush = async function(key, value) {
+    try {
+        // 触发before事件
+        this.emit('rpush_before', { key, value });
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        // 使用现有的list_push方法
+        const result = await this.list_push(key, value);
+        
+        // 触发after事件
+        this.emit('rpush_after', { key, value, result });
+        
+        return result;
+    } catch (error) {
+        // 触发error事件
+        this.emit('rpush_error', { key, value, error });
+        $.log.error('[MongoDB cache] 从右侧推入元素失败:', error);
+        throw error;
+    }
+};
+
+/**
+ * @description 获取列表指定范围的元素 (Redis LRANGE)
+ * @param {String} key 键
+ * @param {Number} start 起始位置
+ * @param {Number} stop 结束位置
+ * @return {Promise|Array} 指定范围的元素数组
+ */
+Mongodb_cache.prototype.lrange = async function(key, start, stop) {
+    try {
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        // 使用现有的list_get方法
+        const result = await this.list_get(key, start, stop);
+        
+        return result;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 获取列表范围失败:', error);
+        return [];
+    }
+};
+
+/**
+ * @description 获取列表指定索引的元素 (Redis LINDEX)
+ * @param {String} key 键
+ * @param {Number} index 索引
+ * @return {Promise|*} 索引处的元素，不存在返回null
+ */
+Mongodb_cache.prototype.lindex = async function(key, index) {
+    try {
+        // 验证参数
+        if (!key || typeof index !== 'number') {
+            throw new Error('参数无效：key不能为空且index必须是数字');
+        }
+        
+        // 获取列表
+        const list = await this.get(key) || [];
+        if (!Array.isArray(list)) {
+            return null;
+        }
+        
+        // 处理负数索引
+        if (index < 0) {
+            index = list.length + index;
+        }
+        
+        // 检查索引是否有效
+        let result = null;
+        if (index >= 0 && index < list.length) {
+            result = list[index];
+        }
+        
+        return result;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 获取列表索引元素失败:', error);
+        return null;
+    }
+};
+
+/**
+ * @description 设置列表指定索引的元素 (Redis LSET)
+ * @param {String} key 键
+ * @param {Number} index 索引
+ * @param {*} value 新值
+ * @return {Promise|Boolean} 是否设置成功
+ */
+Mongodb_cache.prototype.lset = async function(key, index, value) {
+    try {
+        // 触发before事件
+        this.emit('lset_before', { key, index, value });
+        
+        // 验证参数
+        if (!key || typeof index !== 'number') {
+            throw new Error('参数无效：key不能为空且index必须是数字');
+        }
+        
+        // 获取列表
+        let list = await this.get(key) || [];
+        if (!Array.isArray(list)) {
+            // 触发after事件
+            this.emit('lset_after', { key, index, value, result: false });
+            return false;
+        }
+        
+        // 处理负数索引
+        if (index < 0) {
+            index = list.length + index;
+        }
+        
+        // 检查索引是否有效
+        if (index < 0 || index >= list.length) {
+            // 触发after事件
+            this.emit('lset_after', { key, index, value, result: false });
+            return false;
+        }
+        
+        // 设置新值
+        list[index] = value;
+        
+        // 保存更新后的列表
+        await this.set(key, list);
+        
+        // 触发after事件
+        this.emit('lset_after', { key, index, value, result: true });
+        
+        return true;
+    } catch (error) {
+        // 触发error事件
+        this.emit('lset_error', { key, index, value, error });
+        $.log.error('[MongoDB cache] 设置列表索引元素失败:', error);
+        return false;
+    }
+};
+
+/**
+ * @description 从列表中删除指定元素 (Redis LREM)
+ * @param {String} key 键
+ * @param {Number} count 计数
+ * @param {*} value 要删除的元素
+ * @return {Promise|Number} 删除的元素数量
+ */
+Mongodb_cache.prototype.lrem = async function(key, count, value) {
+    try {
+        // 触发before事件
+        this.emit('lrem_before', { key, count, value });
+        
+        // 验证参数
+        if (!key || typeof count !== 'number') {
+            throw new Error('参数无效：key不能为空且count必须是数字');
+        }
+        
+        // 获取列表
+        let list = await this.get(key) || [];
+        if (!Array.isArray(list)) {
+            // 触发after事件
+            this.emit('lrem_after', { key, count, value, result: 0 });
+            return 0;
+        }
+        
+        let deletedCount = 0;
+        const valueStr = JSON.stringify(value);
+        const newList = [];
+        
+        if (count === 0) {
+            // 删除所有匹配元素
+            for (let i = 0; i < list.length; i++) {
+                if (JSON.stringify(list[i]) !== valueStr) {
+                    newList.push(list[i]);
+                } else {
+                    deletedCount++;
+                }
+            }
+        } else if (count > 0) {
+            // 从左侧删除count个匹配元素
+            for (let i = 0; i < list.length; i++) {
+                if (JSON.stringify(list[i]) === valueStr && deletedCount < count) {
+                    deletedCount++;
+                } else {
+                    newList.push(list[i]);
+                }
+            }
+        } else {
+            // 从右侧删除count的绝对值个匹配元素
+            count = Math.abs(count);
+            const tempList = [];
+            for (let i = list.length - 1; i >= 0; i--) {
+                if (JSON.stringify(list[i]) === valueStr && deletedCount < count) {
+                    deletedCount++;
+                } else {
+                    tempList.unshift(list[i]);
+                }
+            }
+            newList.push(...tempList);
+        }
+        
+        // 如果有元素被删除，更新列表
+        if (deletedCount > 0) {
+            await this.set(key, newList);
+        }
+        
+        // 触发after事件
+        this.emit('lrem_after', { key, count, value, result: deletedCount });
+        
+        return deletedCount;
+    } catch (error) {
+        // 触发error事件
+        this.emit('lrem_error', { key, count, value, error });
+        $.log.error('[MongoDB cache] 删除列表元素失败:', error);
+        return 0;
+    }
+};
+
+/**
+ * @description 修剪列表 (Redis LTRIM)
+ * @param {String} key 键
+ * @param {Number} start 起始位置
+ * @param {Number} stop 结束位置
+ * @return {Promise|Boolean} 是否修剪成功
+ */
+Mongodb_cache.prototype.ltrim = async function(key, start, stop) {
+    try {
+        // 触发before事件
+        this.emit('ltrim_before', { key, start, stop });
+        
+        // 验证参数
+        if (!key || typeof start !== 'number' || typeof stop !== 'number') {
+            throw new Error('参数无效：key不能为空且start和stop必须是数字');
+        }
+        
+        // 获取列表
+        let list = await this.get(key) || [];
+        if (!Array.isArray(list)) {
+            // 触发after事件
+            this.emit('ltrim_after', { key, start, stop, result: false });
+            return false;
+        }
+        
+        // 处理负数索引
+        if (start < 0) start = Math.max(0, list.length + start);
+        if (stop < 0) stop = list.length + stop;
+        
+        // 确保索引有效
+        start = Math.max(0, start);
+        stop = Math.min(list.length - 1, stop);
+        
+        // 修剪列表
+        const trimmedList = list.slice(start, stop + 1);
+        
+        // 保存修剪后的列表
+        await this.set(key, trimmedList);
+        
+        // 触发after事件
+        this.emit('ltrim_after', { key, start, stop, result: true });
+        
+        return true;
+    } catch (error) {
+        // 触发error事件
+        this.emit('ltrim_error', { key, start, stop, error });
+        $.log.error('[MongoDB cache] 修剪列表失败:', error);
+        return false;
+    }
+};
+
+// 集合操作补充方法
+
+/**
+ * @description 批量添加集合成员 (Redis SADD 多成员)
+ * @param {String} key 键
+ * @param {...*} members 成员列表
+ * @return {Promise|Number} 添加的成员数量
+ */
+Mongodb_cache.prototype.saddMulti = async function(key, ...members) {
+    try {
+        // 触发before事件
+        this.emit('saddMulti_before', { key, members });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || members.length === 0) {
+            // 触发after事件
+            this.emit('saddMulti_after', { key, members, result: 0 });
+            return 0;
+        }
+        
+        // 获取当前成员
+        const doc = await this.db.collection(this.table).findOne(
+            { _id: key },
+            { projection: { setMembers: 1 } }
+        );
+        const currentMembers = doc && Array.isArray(doc.setMembers) ? doc.setMembers : [];
+        
+        // 找出新成员
+        let addedCount = 0;
+        const newMembers = [];
+        
+        for (const member of members) {
+            if (!currentMembers.some(m => JSON.stringify(m) === JSON.stringify(member))) {
+                newMembers.push(member);
+                addedCount++;
+            }
+        }
+        
+        if (addedCount > 0) {
+            // 添加新成员
+            await this.db.collection(this.table).updateOne(
+                { _id: key },
+                { $addToSet: { setMembers: { $each: newMembers } } },
+                { upsert: true }
+            );
+        }
+        
+        // 触发after事件
+        this.emit('saddMulti_after', { key, members, result: addedCount });
+        
+        return addedCount;
+    } catch (error) {
+        // 触发error事件
+        this.emit('saddMulti_error', { key, members, error });
+        $.log.error('[MongoDB cache] 批量添加集合成员失败:', error);
+        return 0;
+    }
+};
+
+/**
+ * @description 批量移除集合成员 (Redis SREM 多成员)
+ * @param {String} key 键
+ * @param {...*} members 成员列表
+ * @return {Promise|Number} 移除的成员数量
+ */
+Mongodb_cache.prototype.sremMulti = async function(key, ...members) {
+    try {
+        // 触发before事件
+        this.emit('sremMulti_before', { key, members });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || members.length === 0) {
+            // 触发after事件
+            this.emit('sremMulti_after', { key, members, result: 0 });
+            return 0;
+        }
+        
+        // 批量移除成员
+        const result = await this.db.collection(this.table).updateOne(
+            { _id: key },
+            { $pull: { setMembers: { $in: members } } }
+        );
+        
+        // 触发after事件
+        this.emit('sremMulti_after', { key, members, result: result.modifiedCount });
+        
+        return result.modifiedCount;
+    } catch (error) {
+        // 触发error事件
+        this.emit('sremMulti_error', { key, members, error });
+        $.log.error('[MongoDB cache] 批量移除集合成员失败:', error);
+        return 0;
+    }
+};
+
+/**
+ * @description 获取两个集合的差集 (Redis SDIFF)
+ * @param {String} key1 第一个集合键
+ * @param {String} key2 第二个集合键
+ * @return {Promise|Array} 差集成员数组
+ */
+Mongodb_cache.prototype.sdiff = async function(key1, key2) {
+    try {
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key1 || !key2) {
+            throw new Error('参数无效：key1和key2不能为空');
+        }
+        
+        // 获取两个集合的成员
+        const set1 = await this.smembers(key1);
+        const set2 = await this.smembers(key2);
+        
+        // 计算差集
+        const set2Str = new Set(set2.map(item => JSON.stringify(item)));
+        const result = set1.filter(item => !set2Str.has(JSON.stringify(item)));
+        
+        return result;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 获取集合差集失败:', error);
+        return [];
+    }
+};
+
+/**
+ * @description 获取两个集合的交集 (Redis SINTER)
+ * @param {String} key1 第一个集合键
+ * @param {String} key2 第二个集合键
+ * @return {Promise|Array} 交集成员数组
+ */
+Mongodb_cache.prototype.sinter = async function(key1, key2) {
+    try {
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key1 || !key2) {
+            throw new Error('参数无效：key1和key2不能为空');
+        }
+        
+        // 获取两个集合的成员
+        const set1 = await this.smembers(key1);
+        const set2 = await this.smembers(key2);
+        
+        // 计算交集
+        const set2Str = new Set(set2.map(item => JSON.stringify(item)));
+        const result = set1.filter(item => set2Str.has(JSON.stringify(item)));
+        
+        return result;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 获取集合交集失败:', error);
+        return [];
+    }
+};
+
+/**
+ * @description 获取两个集合的并集 (Redis SUNION)
+ * @param {String} key1 第一个集合键
+ * @param {String} key2 第二个集合键
+ * @return {Promise|Array} 并集成员数组
+ */
+Mongodb_cache.prototype.sunion = async function(key1, key2) {
+    try {
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key1 || !key2) {
+            throw new Error('参数无效：key1和key2不能为空');
+        }
+        
+        // 获取两个集合的成员
+        const set1 = await this.smembers(key1);
+        const set2 = await this.smembers(key2);
+        
+        // 计算并集
+        const result = [];
+        const seen = new Set();
+        
+        for (const item of [...set1, ...set2]) {
+            const itemStr = JSON.stringify(item);
+            if (!seen.has(itemStr)) {
+                seen.add(itemStr);
+                result.push(item);
+            }
+        }
+        
+        return result;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 获取集合并集失败:', error);
+        return [];
+    }
+};
+
+/**
+ * @description 哈希操作补充方法 - 批量设置哈希字段 (Redis HMSET)
+ * @param {String} key 键
+ * @param {Object} fieldValuePairs 字段值对象
+ * @return {Promise|Boolean} 是否设置成功
+ */
+Mongodb_cache.prototype.hmset = async function(key, fieldValuePairs) {
+    try {
+        // 触发before事件
+        this.emit('hmset_before', { key, fieldValuePairs });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || !fieldValuePairs || typeof fieldValuePairs !== 'object') {
+            throw new Error('参数无效：key不能为空且fieldValuePairs必须是对象');
+        }
+        
+        // 准备更新对象
+        const updateData = { $set: {} };
+        Object.entries(fieldValuePairs).forEach(([field, value]) => {
+            updateData.$set[`fields.${field}`] = value;
+        });
+        
+        // 执行更新
+        await this.db.collection(this.table).updateOne(
+            { _id: key },
+            updateData,
+            { upsert: true }
+        );
+        
+        // 触发after事件
+        this.emit('hmset_after', { key, fieldValuePairs, result: true });
+        
+        return true;
+    } catch (error) {
+        // 触发error事件
+        this.emit('hmset_error', { key, fieldValuePairs, error });
+        $.log.error('[MongoDB cache] 批量设置哈希字段失败:', error);
+        return false;
+    }
+};
+
+/**
+ * @description 哈希操作补充方法 - 批量获取哈希字段值 (Redis HMGET)
+ * @param {String} key 键
+ * @param {...String} fields 字段名列表
+ * @return {Promise|Array} 字段值数组，顺序与字段名对应
+ */
+Mongodb_cache.prototype.hmget = async function(key, ...fields) {
+    try {
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || fields.length === 0) {
+            return [];
+        }
+        
+        // 获取所有字段值
+        const allFields = await this.hgetall(key);
+        
+        // 按字段名顺序返回值
+        const result = fields.map(field => allFields[field] !== undefined ? allFields[field] : null);
+        
+        return result;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 批量获取哈希字段值失败:', error);
+        return [];
+    }
+};
+
+/**
+ * @description 哈希操作补充方法 - 批量删除哈希字段 (Redis HDEL 多字段)
+ * @param {String} key 键
+ * @param {...String} fields 字段名列表
+ * @return {Promise|Number} 删除的字段数量
+ */
+Mongodb_cache.prototype.hdelMulti = async function(key, ...fields) {
+    try {
+        // 触发before事件
+        this.emit('hdelMulti_before', { key, fields });
+        
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key || fields.length === 0) {
+            // 触发after事件
+            this.emit('hdelMulti_after', { key, fields, result: 0 });
+            return 0;
+        }
+        
+        // 准备更新对象
+        const updateData = { $unset: {} };
+        fields.forEach(field => {
+            updateData.$unset[`fields.${field}`] = '';
+        });
+        
+        // 执行更新
+        const result = await this.db.collection(this.table).updateOne(
+            { _id: key },
+            updateData
+        );
+        
+        const deletedCount = result.modifiedCount ? fields.length : 0;
+        
+        // 触发after事件
+        this.emit('hdelMulti_after', { key, fields, result: deletedCount });
+        
+        return deletedCount;
+    } catch (error) {
+        // 触发error事件
+        this.emit('hdelMulti_error', { key, fields, error });
+        $.log.error('[MongoDB cache] 批量删除哈希字段失败:', error);
+        return 0;
+    }
+};
+
+/**
+ * @description 获取哈希所有值 (Redis HVALS)
+ * @param {String} key 键
+ * @return {Promise|Array} 值数组
+ */
+Mongodb_cache.prototype.hvals = async function(key) {
+    try {
+        // 确保连接已建立
+        await this._ensureConnected();
+        
+        // 验证参数
+        if (!key) {
+            throw new Error('参数无效：key不能为空');
+        }
+        
+        // 获取所有字段值
+        const fields = await this.hgetall(key);
+        
+        // 返回值数组
+        const result = Object.values(fields);
+        
+        return result;
+    } catch (error) {
+        $.log.error('[MongoDB cache] 获取哈希所有值失败:', error);
+        return [];
+    }
 };
 
 /**
@@ -331,6 +2835,9 @@ exports.Mongodb_cache = Mongodb_cache;
 /**
  * @description mongodb_cache连接池
  */
+if (!$.pool) {
+	$.pool = {};
+}
 if (!$.pool.mongodb_cache) {
 	$.pool.mongodb_cache = {};
 }
@@ -343,7 +2850,7 @@ if (!$.pool.mongodb_cache) {
  */
 function mongodb_cache_admin(scope, dir) {
 	if (!scope) {
-		scope = $.val.scope
+		scope = ($.val && $.val.scope) || 'default';
 	}
 	var obj = $.pool.mongodb_cache[scope];
 	if (!obj) {
@@ -356,4 +2863,4 @@ function mongodb_cache_admin(scope, dir) {
 /**
  * @description 导出mongodb_cache管理函数
  */
-exports.mongodb_cache_admin = mongodb_cache_admin;
+exports.mongodb_cache_admin = mongodb_cache_admin;