mm_mongodb 1.4.7 → 1.4.9

package/index.js

@@ -3,38 +3,25 @@
  * @author <a href="http://qww.elins.cn">邱文武</a>
  * @version 1.2.1
  */
-const eventEmitter = require('events');
-require('mm_logs');
+const {
+	BaseService
+} = require('mm_base_service');
 const MongoClient = require('mongodb').MongoClient;
 
-/**
- * 确保全局$对象存在
- */
-if (!global.$) {
-	global.$ = {};
-}
-
 /**
  * @description MongoDB帮助类
  */
-class MongoDB extends eventEmitter {
+class MongoDB extends BaseService {
 	/**
 	 * @description 创建MongoDB帮助类函数 (构造函数)
-	 * @param {String} scope 作用域
-	 * @param {String} dir 当前路径
+	 * @param {Object} config 配置参数
 	 * @constructor
 	 */
-	constructor(scope, dir, config) {
+	constructor(config) {
 		super();
-		// 作用域
-		this.scope = scope || ($.val && $.val.scope ? String($.val.scope) : 'default');
-		// 当前目录
-		this.dir = dir || __dirname;
 
-		// 从环境变量加载配置
-		const envConfig = this._loadEnvConfig();
-
-		this.config = Object.assign({
+		// 合并配置，确保使用对象扩展运算符正确合并
+		this.config = {
 			// 服务器地址
 			host: "localhost",
 			// 端口号
@@ -47,16 +34,10 @@ class MongoDB extends eventEmitter {
 			password: "",
 			// 连接选项
 			options: {
-				// 移除已废弃的选项
-				// 使用MongoDB驱动推荐的配置
-				// 连接池配置
 				minPoolSize: 5,
 				maxPoolSize: 20,
-				// 连接超时时间
 				connectTimeoutMS: 10000,
-				// 服务器选择超时
 				serverSelectionTimeoutMS: 5000,
-				// 重试策略
 				retryWrites: true
 			},
 			// 重试配置
@@ -64,10 +45,7 @@ class MongoDB extends eventEmitter {
 				maxAttempts: 3,
 				delayMS: 1000
 			}
-		}, envConfig, config);
-
-		// 验证配置
-		this._validateConfig();
+		};
 
 		// 连接地址
 		this.url = null;
@@ -92,1392 +70,2589 @@ class MongoDB extends eventEmitter {
 		// 连接重试次数
 		this.connectAttempts = 0;
 		this.maxConnectAttempts = 3;
-	}
-
-	/**
-	 * @private
-	 * @description 从环境变量加载配置
-	 * @return {Object} 配置对象
-	 */
-	_loadEnvConfig() {
-		const envConfig = {};
-
-		if (process.env.MONGODB_HOST) envConfig.host = process.env.MONGODB_HOST;
-		if (process.env.MONGODB_PORT) envConfig.port = parseInt(process.env.MONGODB_PORT, 10);
-		if (process.env.MONGODB_DATABASE) envConfig.database = process.env.MONGODB_DATABASE;
-		if (process.env.MONGODB_USER) envConfig.user = process.env.MONGODB_USER;
-		if (process.env.MONGODB_PASSWORD) envConfig.password = process.env.MONGODB_PASSWORD;
 
-		return envConfig;
+		this.setConfig(config);
+		// 验证配置
+		this._validateConfig();
 	}
+}
 
-	/**
-	 * @private
-	 * @description 验证配置有效性
-	 * @throws {Error} 配置无效时抛出错误
-	 */
-	_validateConfig() {
-		if (!this.config.host || typeof this.config.host !== 'string') {
-			throw new Error('MongoDB配置无效：host必须是有效的字符串');
-		}
+/**
+ * @private
+ * @description 验证配置有效性
+ * @throws {Error} 配置无效时抛出错误
+ */
+MongoDB.prototype._validateConfig = function () {
+	if (!this.config.host || typeof this.config.host !== 'string') {
+		throw new Error('MongoDB配置无效：host必须是有效的字符串');
+	}
 
-		if (!Number.isInteger(this.config.port) || this.config.port < 1 || this.config.port > 65535) {
-			throw new Error('MongoDB配置无效：port必须是1-65535之间的整数');
-		}
+	if (!Number.isInteger(this.config.port) || this.config.port < 1 || this.config.port > 65535) {
+		throw new Error('MongoDB配置无效：port必须是1-65535之间的整数');
+	}
 
-		if (!this.config.database || typeof this.config.database !== 'string') {
-			throw new Error('MongoDB配置无效：database必须是有效的字符串');
-		}
+	if (!this.config.database || typeof this.config.database !== 'string') {
+		throw new Error('MongoDB配置无效：database必须是有效的字符串');
 	}
+};
 
-	/**
-	 * @private
-	 * @description 执行带重试的操作
-	 * @param {Function} operation 要执行的操作
-	 * @param {String} operationName 操作名称
-	 * @return {Promise} 操作结果
-	 */
-	async _withRetry(operation, operationName) {
-		const maxAttempts = this.config.retry?.maxAttempts || 3;
-		const delayMS = this.config.retry?.delayMS || 1000;
-		let lastError;
+/**
+ * @private
+ * @description 执行带重试的操作
+ * @param {Function} operation 要执行的操作
+ * @param {String} operationName 操作名称
+ * @return {Promise} 操作结果
+ */
+MongoDB.prototype._withRetry = async function (operation, operationName) {
+	const maxAttempts = this.config.retry?.maxAttempts || 3;
+	const delayMS = this.config.retry?.delayMS || 1000;
+	let lastError;
 
-		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-			try {
-				return await operation();
-			} catch (error) {
-				lastError = error;
-				$.log.error(`[MongoDB] ${operationName} 第${attempt}次尝试失败:`, error.message);
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		try {
+			return await operation();
+		} catch (error) {
+			lastError = error;
+			$.log.error(`[MongoDB] ${operationName} 第${attempt}次尝试失败:`, error.message);
 
-				// 如果不是最后一次尝试，则等待后重试
-				if (attempt < maxAttempts) {
-					await new Promise(resolve => setTimeout(resolve, delayMS));
-				}
+			// 如果不是最后一次尝试，则等待后重试
+			if (attempt < maxAttempts) {
+				await new Promise(resolve => setTimeout(resolve, delayMS));
 			}
 		}
-
-		// 所有重试都失败，抛出最后一个错误
-		throw lastError;
 	}
 
-	/**
-	 * @description 确保数据库连接已建立
-	 * @private
-	 * @return {Promise<void>}
-	 */
-	async _ensureConnected() {
-		// 如果已有连接Promise，等待其完成
-		if (this.connectPromise) {
-			return this.connectPromise;
-		}
-
-		// 创建新的连接Promise
-		this.connectPromise = (async () => {
-			try {
-				// 检查连接状态
-				if (!this.db || !this.connected) {
-					// 记录连接尝试
-					this.connectAttempts++;
-
-					// 尝试连接
-					await this.open();
+	// 所有重试都失败，抛出最后一个错误
+	throw lastError;
+};
+/**
+ * @description 确保数据库连接已建立
+ * @private
+ * @return {Promise<void>}
+ */
+MongoDB.prototype._ensureConnected = async function () {
+	// 如果已有连接Promise，等待其完成
+	if (this.connectPromise) {
+		return this.connectPromise;
+	}
 
-					// 检查连接是否成功
-					if (this.db && this.db.collection) {
-						this.connected = true;
-						this.connectAttempts = 0;
+	// 创建新的连接Promise
+	this.connectPromise = (async () => {
+		try {
+			// 检查连接状态
+			if (!this.db || !this.connected) {
+				// 记录连接尝试
+				this.connectAttempts++;
+
+				// 尝试连接
+				await this.open();
+
+				// 检查连接是否成功
+				if (this.db && this.db.collection) {
+					$.log.debug(`[MongoDB] [_ensureConnected] 连接成功，db对象存在，开始初始化collection，table=${this.table}`);
+					this.connected = true;
+					this.connectAttempts = 0;
+
+					// 保存collection引用到实例变量
+					try {
+						this.collection = this.db.collection(this.table);
+						$.log.debug(`[MongoDB] [_ensureConnected] 成功初始化collection: ${this.table}`);
+					} catch (err) {
+						$.log.error(`[MongoDB] [_ensureConnected] 初始化collection失败:`, err.message);
+						this.collection = null;
+					}
 
-						// 确保索引已创建
+					// 确保索引已创建
+					if (this.collection) {
 						await this._ensureIndexes();
-
-						$.log.info(`[MongoDB] 成功连接到数据库，表名: ${this.table}`);
-					} else {
-						throw new Error('数据库连接失败，db对象为空');
 					}
-				}
-			} catch (error) {
-				$.log.error(`[MongoDB] 连接失败 (尝试 ${this.connectAttempts}/${this.maxConnectAttempts}):`, error.message);
-
-				// 重置连接Promise，允许下次重试
-				this.connectPromise = null;
 
-				// 如果尝试次数未超过限制，抛出错误让上层处理
-				if (this.connectAttempts < this.maxConnectAttempts) {
-					throw error;
+					$.log.info(`[MongoDB] 成功连接到数据库，表名: ${this.table}`);
 				} else {
-					// 超过重试次数，记录严重错误
-					$.log.error('[MongoDB] 达到最大连接重试次数，连接失败');
-					throw new Error('数据库连接失败，已达到最大重试次数');
+					$.log.error(`[MongoDB] [_ensureConnected] 连接失败，db对象为空或不具有collection方法`);
+					throw new Error('数据库连接失败，db对象为空');
 				}
 			}
-		})();
+		} catch (error) {
+			$.log.error(`[MongoDB] 连接失败 (尝试 ${this.connectAttempts}/${this.maxConnectAttempts}):`,
+				error.message);
 
-		return this.connectPromise;
-	}
+			// 重置连接Promise，允许下次重试
+			this.connectPromise = null;
 
-	/**
-	 * @description 确保索引已创建
-	 * @private
-	 * @return {Promise<void>}
-	 */
-	async _ensureIndexes() {
-		try {
-			// 确保db对象有效
-			if (!this.db || !this.db.collection) {
-				throw new Error('数据库连接无效，无法创建索引');
+			// 如果尝试次数未超过限制，抛出错误让上层处理
+			if (this.connectAttempts < this.maxConnectAttempts) {
+				throw error;
+			} else {
+				// 超过重试次数，记录严重错误
+				$.log.error('[MongoDB] 达到最大连接重试次数，连接失败');
+				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] 创建索引失败:', error);
-			}
+	return this.connectPromise;
+};
+
+/**
+ * @description 确保索引已创建
+ * @private
+ * @return {Promise<void>}
+ */
+MongoDB.prototype._ensureIndexes = async function () {
+	try {
+		// 确保db对象有效
+		if (!this.db || !this.db.collection) {
+			throw new Error('数据库连接无效，无法创建索引');
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 获取缓存值
-	 * @param {String} key 键名
-	 * @return {Promise<any>} 缓存值
-	 */
-	async get(key) {
-		try {
-			await this._ensureConnected();
-			const result = await this.findOne({ key: key });
-			return result ? result.value : null;
-		} catch (error) {
-			$.log.error('[MongoDB] 获取缓存失败:', error);
-			return null;
+		// 创建TTL索引用于自动过期
+		await this.db.collection(this.table).createIndex({
+			expire_at: 1
+		}, {
+			expireAfterSeconds: 0
+		});
+		// 创建_id索引(通常自动创建，但显式指定更清晰)
+		await this.db.collection(this.table).createIndex({
+			_id: 1
+		});
+	} catch (error) {
+		// 忽略索引已存在的错误
+		if (error.code !== 85) {
+			$.log.error('[MongoDB] 创建索引失败:', error);
 		}
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 清空所有缓存
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async clear() {
-		try {
-			await this._ensureConnected();
-			await this.del({});
-			return true;
-		} catch (error) {
-			$.log.error('[MongoDB] 清空缓存失败:', error);
-			return false;
-		}
+/**
+ * @description Redis兼容API - 获取缓存值
+ * @param {String} key 键名
+ * @return {Promise<any>} 返回键值，不存在返回undefined
+ */
+MongoDB.prototype.get = async function (key) {
+	try {
+		await this._ensureConnected();
+		const result = await this.findOne({
+			key: key
+		});
+		return result ? result.value : undefined;
+	} catch (error) {
+		$.log.error('[MongoDB] 获取缓存失败:', error);
+		throw error;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 获取所有键
-	 * @param {String} pattern 匹配模式
-	 * @return {Promise<Array>} 键名数组
-	 */
-	async keys(pattern = '*') {
-		try {
-			await this._ensureConnected();
-			let query = {};
-			if (pattern !== '*') {
-				// 简单的通配符支持
-				const regexPattern = pattern.replace(/\*/g, '.*').replace(/\?/g, '.');
-				query.key = { $regex: new RegExp(`^${regexPattern}$`) };
-			}
-			const results = await this.find(query, { projection: { key: 1 } });
-			return results.map(item => item.key);
-		} catch (error) {
-			$.log.error('[MongoDB] 获取键列表失败:', error);
-			return [];
+/**
+ * @description Redis兼容API - 清空所有缓存或匹配模式的缓存
+ * @param {string} pattern - 可选的键匹配模式
+ * @return {Promise<Boolean>} 是否成功
+ */
+MongoDB.prototype.clear = async function (pattern) {
+	try {
+		// 触发前置事件
+		this.emit('clear_before', {
+			pattern
+		});
+
+		await this._ensureConnected();
+
+		if (pattern) {
+			// 支持通配符匹配删除
+			const regex = new RegExp(pattern.replace(/\*/g, '.*'));
+			const result = await this.delete({
+				key: {
+					$regex: regex
+				}
+			});
+			this.emit('clear_after', {
+				pattern,
+				result
+			});
+			return result.acknowledged;
+		} else {
+			// 清空所有数据，直接使用deleteMany操作
+			const result = await this.db.collection(this.table).deleteMany({});
+			this.emit('clear_after', {
+				result
+			});
+			return result.acknowledged;
 		}
+	} catch (error) {
+		this.emit('clear_error', {
+			error,
+			pattern
+		});
+		$.log.error('[MongoDB] 清空缓存失败:', error);
+		return false;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 设置过期时间
-	 * @param {String} key 键名
-	 * @param {Number} seconds 过期时间（秒）
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async ttl(key, seconds) {
-		try {
-			await this._ensureConnected();
-			if (!seconds && seconds !== 0) {
-				// 获取剩余过期时间
-				const item = await this.findOne({ key: key });
-				if (!item || !item.expireAt) return -1;
-				const ttl = Math.floor((item.expireAt.getTime() - Date.now()) / 1000);
-				return ttl > 0 ? ttl : -2; // -2 表示已过期
-			} else {
-				// 设置过期时间
-				const expireAt = seconds === 0 ? null : new Date(Date.now() + seconds * 1000);
-				const result = await this._set({ key: key }, { expireAt: expireAt });
-				return result.modifiedCount > 0;
-			}
-		} catch (error) {
-			$.log.error('[MongoDB] 设置TTL失败:', error);
-			return false;
+/**
+ * @description Redis兼容API - 获取所有键
+ * @param {String} pattern 匹配模式
+ * @return {Promise<Array>} 键名数组
+ */
+MongoDB.prototype.keys = async function (pattern = '*') {
+	try {
+		await this._ensureConnected();
+		let query = {};
+		if (pattern !== '*') {
+			// 简单的通配符支持
+			const regexPattern = pattern.replace(/\*/g, '.*').replace(/\?/g, '.');
+			query.key = {
+				$regex: new RegExp(`^${regexPattern}$`)
+			};
 		}
+		const results = await this.find(query, {
+			projection: {
+				key: 1
+			}
+		});
+		return results.map(item => item.key);
+	} catch (error) {
+		$.log.error('[MongoDB] 获取键列表失败:', error);
+		return [];
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 添加缓存
-	 * @param {String} key 键名
-	 * @param {*} value 值
-	 * @param {Number} expire 过期时间（秒）
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async _add(key, value, expire) {
-		try {
-			await this._ensureConnected();
-			const data = {
-				key: key,
-				value: value
+/**
+ * @description Redis兼容API - 获取或设置过期时间
+ * @param {String} key 键名
+ * @param {Number} [seconds] 过期时间（秒），不传此参数则获取剩余过期时间
+ * @return {Promise<Number|Boolean>} 不传seconds时返回剩余过期时间（-1表示无过期设置，-2表示已过期或不存在），传seconds时返回是否设置成功
+ */
+MongoDB.prototype.ttl = async function (key, seconds) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return arguments.length === 1 ? -2 : false;
+		}
+
+		// 设置模式才需要触发事件
+		if (seconds !== undefined && seconds !== null) {
+			// 触发前置事件
+			const beforeEventData = {
+				key,
+				seconds,
+				cancel: false
 			};
+			this.emit('ttl_before', beforeEventData);
 
-			if (expire) {
-				data.expireAt = new Date(Date.now() + expire * 1000);
+			if (beforeEventData.cancel) {
+				return false;
 			}
 
-			// 检查是否已存在
-			const existing = await this.findOne({ key: key });
-			if (existing) {
-				await this._set({ key: key }, data);
-			} else {
-				await this.addObj(data);
+			let { key: finalKey, seconds: finalSeconds } = beforeEventData;
+
+			await this._ensureConnected();
+
+			// 确保连接和collection存在
+			if (!this.db) {
+				await this.open();
 			}
-			return true;
-		} catch (error) {
-			$.log.error('[MongoDB] 添加缓存失败:', error);
-			return false;
-		}
-	}
 
-	/**
-	 * @description Redis兼容API - 添加缓存
-	 * @param {String} key 键名
-	 * @param {*} value 值
-	 * @param {Number} expire 过期时间（秒）
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async add(key, value, expire) {
-		return this._add(key, value, expire);
-	}
+			// 直接尝试获取collection，使用实例的table属性
+			if (!this.collection && this.db && this.db.collection) {
+				$.log.debug(`[MongoDB] [ttl] 设置模式：直接获取collection, table=${this.table}`);
+				try {
+					this.collection = this.db.collection(this.table);
+					$.log.debug(`[MongoDB] [ttl] 设置模式：成功获取collection`);
+				} catch (err) {
+					$.log.error(`[MongoDB] [ttl] 设置模式：获取collection失败:`, err.message);
+					this.collection = null;
+				}
+			}
 
-	/**
-	 * @description Redis兼容API - 增加整数值
-	 * @param {String} key 键名
-	 * @param {Number} value 增加值
-	 * @return {Promise<Number>} 增加后的值
-	 */
-	async addInt(key, value = 1) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			let currentValue = 0;
+			// 检查collection是否存在
+			if (!this.collection) {
+				this.emit('ttl_after', {
+					key: finalKey,
+					seconds: finalSeconds,
+					result: false
+				});
+				return false;
+			}
 
-			if (item && typeof item.value === 'number') {
-				currentValue = item.value;
+			// 检查键是否存在
+			const count = await this.collection.countDocuments({ key: finalKey });
+			if (count === 0) {
+				this.emit('ttl_after', {
+					key: finalKey,
+					seconds: finalSeconds,
+					result: false
+				});
+				return false;
 			}
 
-			const newValue = currentValue + value;
-			await this._add(key, newValue);
-			return newValue;
-		} catch (error) {
-			$.log.error('[MongoDB] 增加整数值失败:', error);
-			return undefined;
+			// 设置过期时间
+			const updateData = {};
+			if (finalSeconds === 0 || finalSeconds === -1) {
+				// 移除过期时间
+				updateData.$unset = { expire_at: 1 };
+			} else if (finalSeconds > 0) {
+				// 设置新的过期时间
+				updateData.$set = { expire_at: new Date(Date.now() + finalSeconds * 1000) };
+			} else {
+				// 设置为已过期
+				updateData.$set = { expire_at: new Date(0) };
+			}
+
+			await this.collection.updateOne(
+				{ key: finalKey },
+				updateData,
+				{ upsert: false }
+			);
+
+			this.emit('ttl_after', {
+				key: finalKey,
+				seconds: finalSeconds,
+				result: true
+			});
+			return true;
 		}
-	}
+		// 获取模式：检查键的过期时间（不需要事件）
+		else {
+			await this._ensureConnected();
 
-	/**
-	 * @description Redis兼容API - 增加浮点数值
-	 * @param {String} key 键名
-	 * @param {Number} value 增加值
-	 * @return {Promise<Number>} 增加后的值
-	 */
-	async addFloat(key, value = 1.0) {
-		return this.addInt(key, value); // 复用addInt方法
-	}
+			// 确保连接和collection存在
+			if (!this.db) {
+				await this.open();
+			}
 
-	/**
-	 * @description Redis兼容API - 添加字符串
-	 * @param {String} key 键名
-	 * @param {String} value 字符串值
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async addStr(key, value) {
-		return this._add(key, String(value));
-	}
+			// 直接尝试获取collection，使用实例的table属性
+			if (!this.collection && this.db && this.db.collection) {
+				$.log.debug(`[MongoDB] [ttl] 直接获取collection, table=${this.table}`);
+				try {
+					this.collection = this.db.collection(this.table);
+					$.log.debug(`[MongoDB] [ttl] 成功获取collection`);
+				} catch (err) {
+					$.log.error(`[MongoDB] [ttl] 获取collection失败:`, err.message);
+					this.collection = null;
+				}
+			}
 
-	/**
-	 * @description Redis兼容API - 排序
-	 * @param {String} key 键名
-	 * @param {Object} options 排序选项
-	 * @return {Promise<Array>} 排序结果
-	 */
-	async sort(key, options = {}) {
-		try {
-			await this._ensureConnected();
-			// 假设value是数组
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) return [];
+			// 再次检查collection
+			if (!this.collection) {
+				return -2;
+			}
 
-			const sorted = [...item.value];
+			// 查询键是否存在及过期时间
+			const item = await this.collection.findOne({ key });
+			$.log.debug(`[MongoDB] [ttl] 查询键结果: item=${JSON.stringify(item)}`);
 
-			// 处理排序选项
-			if (options.desc) {
-				sorted.sort((a, b) => b - a);
-			} else {
-				sorted.sort((a, b) => a - b);
+			if (!item) {
+				// 键不存在返回-2
+				$.log.debug(`[MongoDB] [ttl] 键 ${key} 不存在，返回-2`);
+				return -2;
 			}
 
-			// 处理限制
-			if (options.limit) {
-				const offset = options.offset || 0;
-				return sorted.slice(offset, offset + options.limit);
+			if (!item.expire_at) {
+				// 没有过期时间返回-1
+				$.log.debug(`[MongoDB] [ttl] 键 ${key} 没有过期时间，返回-1`);
+				return -1;
 			}
 
-			return sorted;
-		} catch (error) {
-			$.log.error('[MongoDB] 排序失败:', error);
-			return [];
+			// 计算剩余过期时间
+			const expireTime = new Date(item.expire_at).getTime();
+			const currentTime = Date.now();
+			const remainingSeconds = Math.ceil((expireTime - currentTime) / 1000);
+
+			if (remainingSeconds <= 0) {
+				// 已过期返回-2
+				return -2;
+			}
+
+			// 返回剩余过期时间
+			return remainingSeconds;
 		}
+	} catch (error) {
+		this.emit('ttl_error', { key, seconds, error });
+		$.log.error(`[MongoDB] [ttl] 操作失败:`, error.message);
+		return arguments.length === 1 ? -2 : false;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 哈希表设置字段
-	 * @param {String} key 键名
-	 * @param {String} field 字段名
-	 * @param {*} value 值
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async hset(key, field, value) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			let hash = item && typeof item.value === 'object' && item.value !== null ? item.value : {};
-
-			hash[field] = value;
-			await this._add(key, hash);
-			return true;
-		} catch (error) {
-			$.log.error('[MongoDB] 哈希表设置失败:', error);
+/**
+ * @description Redis兼容API - 移除键的过期时间
+ * @param {String} key 键名
+ * @return {Promise<boolean>} 移除成功返回true，键不存在或没有过期时间返回false
+ */
+MongoDB.prototype.persist = async function (key) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
 			return false;
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 哈希表获取字段
-	 * @param {String} key 键名
-	 * @param {String} field 字段名
-	 * @return {Promise<any>} 字段值
-	 */
-	async hget(key, field) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || typeof item.value !== 'object' || item.value === null) {
-				return null;
-			}
-			return item.value[field] !== undefined ? item.value[field] : null;
-		} catch (error) {
-			$.log.error('[MongoDB] 哈希表获取失败:', error);
-			return null;
+		// 触发前置事件
+		const beforeEventData = {
+			key,
+			cancel: false
+		};
+		this.emit('persist_before', beforeEventData);
+
+		if (beforeEventData.cancel) {
+			return false;
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 哈希表获取所有字段和值
-	 * @param {String} key 键名
-	 * @return {Promise<Object>} 哈希表对象
-	 */
-	async hgetall(key) {
-		try {
-			const item = await this.findOne({ key: key });
-			if (!item || typeof item.value !== 'object' || item.value === null) {
-				return {};
-			}
-			return item.value;
-		} catch (error) {
-			$.log.error('[MongoDB] 哈希表获取全部失败:', error);
-			return {};
+		const { key: finalKey } = beforeEventData;
+
+		// 确保连接和collection存在
+		if (!this.db) {
+			await this.open();
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 哈希表删除字段
-	 * @param {String} key 键名
-	 * @param {String} field 字段名
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async hdel(key, field) {
-		try {
-			const item = await this.findOne({ key: key });
-			if (!item || typeof item.value !== 'object' || item.value === null) {
-				return false;
+		// 直接尝试获取collection，不依赖_ensureConnected的复杂逻辑
+		if (!this.collection && this.db && this.db.collection) {
+			$.log.debug(`[MongoDB] [persist] 直接获取collection, table=${this.table}`);
+			try {
+				this.collection = this.db.collection(this.table);
+				$.log.debug(`[MongoDB] [persist] 成功获取collection`);
+			} catch (err) {
+				$.log.error(`[MongoDB] [persist] 获取collection失败:`, err.message);
+				this.collection = null;
 			}
+		}
 
-			if (item.value[field] === undefined) {
-				return false;
-			}
+		// 再次检查collection
+		if (!this.collection) {
+			$.log.error('[MongoDB] persist: collection is undefined');
+			this.emit('persist_error', {
+				key: finalKey,
+				error: new Error('collection is undefined')
+			});
+			return false;
+		}
 
-			delete item.value[field];
-			await this._set({ key: key }, { value: item.value });
-			return true;
-		} catch (error) {
-			$.log.error('[MongoDB] 哈希表删除失败:', error);
+		// 检查键是否存在
+		const item = await this.collection.findOne({ key: finalKey });
+		if (!item) {
+			// 键不存在返回false
+			this.emit('persist_after', {
+				key: finalKey,
+				success: false
+			});
 			return false;
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 检查键是否存在
-	 * @param {String} key 键名
-	 * @return {Promise<Boolean>} 是否存在
-	 */
-	async has(key) {
-		try {
-			const result = await this.findOne({ key: key });
-			return result !== null;
-		} catch (error) {
-			$.log.error('[MongoDB] 检查键是否存在失败:', error);
+		// 如果没有过期时间，直接返回true
+		if (!item.expire_at) {
+			this.emit('persist_after', {
+				key: finalKey,
+				success: true
+			});
+			return true;
+		}
+
+		// 从文档中移除过期时间
+		const result = await this.collection.updateOne(
+			{ key: finalKey },
+			{ $unset: { expire_at: 1 } },
+			{ upsert: false }
+		);
+
+		// 检查更新是否成功
+		const success = result.modifiedCount > 0;
+
+		// 触发后置事件
+		this.emit('persist_after', {
+			key: finalKey,
+			success: success
+		});
+		return success;
+	} catch (error) {
+		$.log.error('[MongoDB] persist error:', error.message);
+		this.emit('persist_error', {
+			key,
+			error
+		});
+		return false;
+	}
+};
+
+/**
+ * @param {String} key 键名
+ * @param {*} value 值
+ * @param {Number} expire 过期时间（秒）
+ * @return {Promise<Boolean>} 是否成功
+ */
+MongoDB.prototype._add = async function (key, value, expire) {
+	try {
+		await this._ensureConnected();
+		const data = {
+			key: key,
+			value: value
+		};
+
+		if (expire) {
+			data.expire_at = new Date(Date.now() + expire * 1000);
+		}
+
+		// 检查是否已存在
+		const existing = await this.findOne({
+			key: key
+		});
+		if (existing) {
+			// 调用_set方法时传递过期时间参数
+			await this._set(key, value, expire);
+		} else {
+			await this.addObj(data);
+		}
+		return true;
+	} catch (error) {
+		$.log.error('[MongoDB] 添加缓存失败:', error);
+		return false;
+	}
+};
+
+/**
+ * @description 仅当键不存在时设置缓存
+ * @param {String} key 键
+ * @param {*} value 值
+ * @param {Number} seconds 过期时间（秒）
+ * @return {Promise<Boolean>} 操作结果，键不存在时设置成功返回true，键已存在返回false
+ */
+MongoDB.prototype.add = async function (key, value, seconds) {
+	try {
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			value,
+			ttl: seconds,
+			cancel: false
+		};
+		this.emit('add_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回false
+		if (beforeEventData.cancel) {
+			$.log.debug(`[MongoDB] add操作被事件处理器取消 [${key}]`);
 			return false;
 		}
+
+		// 使用可能被修改的值
+		let {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds
+		} = beforeEventData;
+
+		await this._ensureConnected();
+
+		// 检查键是否已存在
+		const existing = await this.findOne({
+			key: finalKey
+		});
+		if (existing) {
+			// 键已存在，返回false
+			this.emit('add_after', {
+				key: finalKey,
+				value: finalValue,
+				ttl: finalSeconds,
+				success: false
+			});
+			return false;
+		}
+
+		// 键不存在，设置值
+		const data = {
+			key: finalKey,
+			value: finalValue
+		};
+
+		if (finalSeconds) {
+			data.expire_at = new Date(Date.now() + finalSeconds * 1000);
+		}
+
+		await this.addObj(data);
+
+		// 触发后置事件
+		this.emit('add_after', {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds,
+			success: true
+		});
+		return true;
+	} catch (error) {
+		$.log.error(`[MongoDB] 添加缓存失败 [${key}]:`, error);
+		// 触发错误事件
+		this.emit('add_error', {
+			key,
+			value,
+			ttl: seconds,
+			error
+		});
+		return false;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 设置键过期时间（映射到ttl）
-	 * @param {String} key 键名
-	 * @param {Number} seconds 过期时间（秒）
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async expire(key, seconds) {
-		return this.ttl(key, seconds);
+
+/**
+ * @description Redis兼容API - 增加整数值
+ * @param {String} key 键名
+ * @param {Number} value 增加值
+ * @return {Promise<Number>} 增加后的值
+ */
+MongoDB.prototype._addNum = async function (key, value = 1) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		let currentValue = 0;
+
+		if (item && typeof item.value === 'number') {
+			currentValue = item.value;
+		}
+
+		const newValue = currentValue + value;
+		await this._add(key, newValue);
+		return newValue;
+	} catch (error) {
+		$.log.error('[MongoDB] 增加整数值失败:', error);
+		return undefined;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 递增（通过addInt模拟）
-	 * @param {String} key 键名
-	 * @return {Promise<Number>} 递增后的值
-	 */
-	async incr(key) {
-		try {
-			await this._ensureConnected();
-			const result = await this.addInt(key, 1);
-			return result !== undefined ? result : 0;
-		} catch (error) {
-			$.log.error('[MongoDB] 递增操作失败:', error);
+/**
+ * @description Redis兼容API - 增加整数值
+ * @param {String} key 键名
+ * @param {Number} value 增加值
+ * @return {Promise<Number>} 增加后的值
+ */
+/**
+ * @description Redis兼容API - 增加整数值
+ * @param {String} key 键名
+ * @param {Number} value 增加值
+ * @return {Promise<Number>} 增加后的值
+ */
+MongoDB.prototype.addInt = async function (key, value = 1, seconds = 0) {
+	try {
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			value,
+			seconds,
+			cancel: false
+		};
+		this.emit('addInt_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回默认值
+		if (beforeEventData.cancel) {
+			$.log.debug('[MongoDB] addInt操作被事件处理器取消');
+			return 0;
+		}
+
+		// 使用可能被修改的值
+		let {
+			key: finalKey,
+			value: finalValue,
+			seconds: finalSeconds
+		} = beforeEventData;
+
+		// 参数验证
+		if (!finalKey || typeof finalKey !== 'string') {
+			$.log.warn('[MongoDB] addInt: key必须是非空字符串');
 			return 0;
 		}
+
+		finalValue = Number(finalValue) || 0;
+
+		await this._ensureConnected();
+		// 获取当前值
+		const item = await this.findOne({
+			key: finalKey
+		});
+		let currentValue = 0;
+
+		if (item) {
+			// 确保转换为数字
+			currentValue = Number(item.value) || 0;
+		}
+
+		const newValue = Math.floor(currentValue + finalValue); // 确保返回整数
+		await this._add(finalKey, newValue, finalSeconds);
+
+		// 触发后置事件
+		this.emit('addInt_after', {
+			key: finalKey,
+			value: finalValue,
+			seconds: finalSeconds,
+			result: newValue,
+			success: true
+		});
+		return newValue;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('addInt_error', {
+			key,
+			value,
+			seconds,
+			error
+		});
+		$.log.error('[MongoDB] 增加整数值失败:', error);
+		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
+		return 0;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 递减（通过addInt模拟）
-	 * @param {String} key 键名
-	 * @return {Promise<Number>} 递减后的值
-	 */
-	async decr(key) {
-		try {
-			await this._ensureConnected();
-			const result = await this.addInt(key, -1);
-			return result !== undefined ? result : 0;
-		} catch (error) {
-			$.log.error('[MongoDB] 递减操作失败:', error);
+/**
+ * @description Redis兼容API - 增加浮点数值
+ * @param {String} key 键名
+ * @param {Number} value 增加值
+ * @return {Promise<Number>} 增加后的值
+ */
+MongoDB.prototype.addFloat = async function (key, value = 1.0, seconds = 0) {
+	try {
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			value,
+			seconds,
+			cancel: false
+		};
+		this.emit('addFloat_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回默认值
+		if (beforeEventData.cancel) {
+			$.log.debug('[MongoDB] addFloat操作被事件处理器取消');
+			return 0.0;
+		}
+
+		// 使用可能被修改的值
+		let {
+			key: finalKey,
+			value: finalValue,
+			seconds: finalSeconds
+		} = beforeEventData;
+
+		// 参数验证
+		if (!finalKey || typeof finalKey !== 'string') {
+			$.log.warn('[MongoDB] addFloat: key必须是非空字符串');
+			return 0.0;
+		}
+
+		finalValue = Number(finalValue) || 0.0;
+
+		await this._ensureConnected();
+		// 获取当前值
+		const item = await this.findOne({
+			key: finalKey
+		});
+		let currentValue = 0.0;
+
+		if (item) {
+			// 确保转换为数字
+			currentValue = Number(item.value) || 0.0;
+		}
+
+		const newValue = currentValue + finalValue;
+		await this._add(finalKey, newValue, finalSeconds);
+
+		// 触发后置事件
+		this.emit('addFloat_after', {
+			key: finalKey,
+			value: finalValue,
+			seconds: finalSeconds,
+			result: newValue,
+			success: true
+		});
+		return newValue;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('addFloat_error', {
+			key,
+			value,
+			seconds,
+			error
+		});
+		$.log.error('[MongoDB] 增加浮点数值失败:', error);
+		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
+		return 0.0;
+	}
+};
+
+/**
+ * @description Redis兼容API - 添加字符串
+ * @param {String} key 键名
+ * @param {String} value 字符串值
+ * @return {Promise<Number>} 添加后的字符串长度
+ */
+MongoDB.prototype.addStr = async function (key, value) {
+	try {
+		// 触发前置事件
+		this.emit('addStr_before', {
+			key,
+			value
+		});
+
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			throw new Error('key必须是非空字符串');
+		}
+
+		if (value === undefined || value === null) {
+			value = '';
+		}
+
+		await this._ensureConnected();
+		// 获取当前值
+		const item = await this.findOne({
+			key: key
+		});
+		const currentValue = item ? String(item.value) : '';
+		const newValue = currentValue + String(value);
+		// 设置新值
+		await this._add(key, newValue);
+
+		// 触发后置事件
+		this.emit('addStr_after', {
+			key,
+			value,
+			result: newValue.length
+		});
+		// 返回添加后的字符串长度
+		return newValue.length;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('addStr_error', {
+			key,
+			value,
+			error
+		});
+		$.log.error('[MongoDB] 添加字符串失败:', error);
+		return 0;
+	}
+};
+
+/**
+ * @description Redis兼容API - 排序
+ * @param {String} key 键名
+ * @param {Object} options 排序选项
+ * @return {Promise<Array>} 排序结果
+ */
+MongoDB.prototype.sort = async function (key, options = {}) {
+	try {
+		await this._ensureConnected();
+		// 假设value是数组
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value)) return [];
+
+		const sorted = [...item.value];
+
+		// 处理排序选项
+		if (options.desc) {
+			sorted.sort((a, b) => b - a);
+		} else {
+			sorted.sort((a, b) => a - b);
+		}
+
+		// 处理限制
+		if (options.limit) {
+			const offset = options.offset || 0;
+			return sorted.slice(offset, offset + options.limit);
+		}
+
+		return sorted;
+	} catch (error) {
+		$.log.error('[MongoDB] 排序失败:', error);
+		return [];
+	}
+};
+
+/**
+ * @description Redis兼容API - 哈希表设置字段
+ * @param {String} key 键名
+ * @param {String} field 字段名
+ * @param {*} value 值
+ * @return {Promise<number>} 返回1表示新建字段，0表示更新字段
+ */
+MongoDB.prototype.hset = async function (key, field, value) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		let hash = item && typeof item.value === 'object' && item.value !== null ? item.value : {};
+
+		// 检查字段是否存在，以确定是新建还是更新
+		const isNewField = !hash.hasOwnProperty(field);
+		hash[field] = value;
+		await this._add(key, hash);
+		return isNewField ? 1 : 0;
+	} catch (error) {
+		$.log.error('[MongoDB] 哈希表设置失败:', error);
+		throw error;
+	}
+};
+
+/**
+ * @description Redis兼容API - 哈希表获取字段
+ * @param {String} key 键名
+ * @param {String} field 字段名
+ * @return {Promise<any>} 返回字段值，不存在返回undefined
+ */
+MongoDB.prototype.hget = async function (key, field) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || typeof item.value !== 'object' || item.value === null) {
+			return undefined;
+		}
+		return item.value[field] !== undefined ? item.value[field] : undefined;
+	} catch (error) {
+		$.log.error('[MongoDB] 哈希表获取失败:', error);
+		throw error;
+	}
+};
+
+/**
+ * @description Redis兼容API - 哈希表获取所有字段和值
+ * @param {String} key 键名
+ * @return {Promise<Object>} 哈希表对象
+ */
+MongoDB.prototype.hgetall = async function (key) {
+	try {
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || typeof item.value !== 'object' || item.value === null) {
+			return {};
+		}
+		return item.value;
+	} catch (error) {
+		$.log.error('[MongoDB] 哈希表获取全部失败:', error);
+		return {};
+	}
+};
+
+/**
+ * @description Redis兼容API - 哈希表删除字段
+ * @param {String} key 键名
+ * @param {String|Array<String>} field 字段名或字段名数组
+ * @return {Promise<boolean>} 返回true表示成功删除，false表示未删除
+ */
+MongoDB.prototype.hdel = async function (key, fields) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return 0;
+		}
+
+		// 统一将fields转换为数组格式
+		const fieldArray = Array.isArray(fields) ? fields : [fields];
+		if (fieldArray.length === 0) {
+			return 0;
+		}
+
+		await this._ensureConnected();
+
+		// 查找是否存在该键
+		const item = await this.findOne({ key: key });
+
+		// 如果键不存在或不是哈希表格式，返回0
+		if (!item || typeof item.value !== 'object' || item.value === null || Array.isArray(item.value)) {
 			return 0;
 		}
+
+		// 计数删除的字段数量
+		let deletedCount = 0;
+		const updatedValue = { ...item.value };
+
+		// 遍历要删除的字段
+		fieldArray.forEach(field => {
+			if (field && Object.prototype.hasOwnProperty.call(updatedValue, field)) {
+				delete updatedValue[field];
+				deletedCount++;
+			}
+		});
+
+		// 如果删除了字段，更新数据库
+		if (deletedCount > 0) {
+			// 使用正确的方式更新数据库
+			await this.db.collection(this.table).updateOne(
+				{ key: key },
+				{ $set: { value: updatedValue, updated_at: new Date() } }
+			);
+		}
+
+		return deletedCount;
+	} catch (error) {
+		$.log.error('[MongoDB] hdel操作失败:', error);
+		return 0;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 检查键是否存在（别名）
-	 * @param {String} key 键名
-	 * @return {Promise<Boolean>} 是否存在
-	 */
-	async exists(key) {
-		try {
-			await this._ensureConnected();
-			return this.has(key);
-		} catch (error) {
-			$.log.error('[MongoDB] 检查键是否存在失败:', error);
+/**
+ * @description Redis兼容API - 检查键是否存在
+ * @param {String} key 键名
+ * @return {Promise<Boolean>} 是否存在
+ */
+MongoDB.prototype.has = async function (key) {
+	try {
+		const result = await this.findOne({
+			key: key
+		});
+		return result !== null;
+	} catch (error) {
+		$.log.error('[MongoDB] [has] 检查键是否存在失败:', error);
+		throw error;
+	}
+};
+
+/**
+ * @description Redis兼容API - 设置键过期时间（映射到ttl）
+ * @param {String} key 键名
+ * @param {Number} seconds 过期时间（秒）
+ * @return {Promise<Boolean>} 是否成功
+ */
+MongoDB.prototype.expire = async function (key, seconds) {
+	try {
+		// 参数验证
+		seconds = parseInt(seconds) || 0;
+
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			seconds,
+			cancel: false
+		};
+		this.emit('expire_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回默认值
+		if (beforeEventData.cancel) {
+			$.log.debug('[MongoDB] expire操作被事件处理器取消');
 			return false;
 		}
+
+		// 使用可能被修改的值
+		const {
+			key: finalKey,
+			seconds: finalSeconds
+		} = beforeEventData;
+
+		// 调用ttl方法设置过期时间
+		const result = await this.ttl(finalKey, finalSeconds);
+
+		// 触发后置事件
+		this.emit('expire_after', {
+			key: finalKey,
+			seconds: finalSeconds,
+			result
+		});
+
+		// 返回布尔值表示成功或失败
+		return result === true || (typeof result === 'number' && result >= -2);
+	} catch (error) {
+		// 记录错误日志
+		$.log.error('[MongoDB] expire方法执行错误', { error: error.message, key, seconds });
+
+		// 触发错误事件
+		this.emit('expire_error', {
+			key,
+			seconds,
+			error
+		});
+
+		return false;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 设置键值
-	 * @param {String} key 键名
-	 * @param {*} value 值
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async _set(key, value) {
-		try {
-			await this._ensureConnected();
-			// 直接使用已有的add方法，它已正确处理查询条件格式
-			return await this._add(key, value);
-		} catch (error) {
-			$.log.error('[MongoDB] 设置键值失败:', error);
-			return false;
+/**
+ * @description Redis兼容API - 递增（通过addInt模拟）
+ * @param {String} key 键名
+ * @return {Promise<Number>} 递增后的值
+ */
+MongoDB.prototype.incr = async function (key, seconds = 0) {
+	try {
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			seconds,
+			cancel: false
+		};
+		this.emit('incr_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回默认值
+		if (beforeEventData.cancel) {
+			$.log.debug('[MongoDB] incr操作被事件处理器取消');
+			return 0;
 		}
+
+		// 使用可能被修改的值
+		let {
+			key: finalKey,
+			seconds: finalSeconds
+		} = beforeEventData;
+
+		// 参数验证
+		if (!finalKey || typeof finalKey !== 'string') {
+			$.log.warn('[MongoDB] incr: key必须是非空字符串');
+			return 0;
+		}
+
+		await this._ensureConnected();
+		const result = await this.addInt(finalKey, 1, finalSeconds);
+		const returnResult = result !== undefined ? result : 0;
+
+		// 触发后置事件
+		this.emit('incr_after', {
+			key: finalKey,
+			seconds: finalSeconds,
+			result: returnResult,
+			success: true
+		});
+
+		return returnResult;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('incr_error', {
+			key,
+			seconds,
+			error
+		});
+		$.log.error('[MongoDB] 递增操作失败:', error);
+		return 0;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 设置键值
-	 * @param {String} key 键名
-	 * @param {*} value 值
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async set(key, value) {
-		return this._set(key, value);
+/**
+ * @description Redis兼容API - 递减（通过addInt模拟）
+ * @param {String} key 键名
+ * @return {Promise<Number>} 递减后的值
+ */
+MongoDB.prototype.decr = async function (key, seconds = 0) {
+	try {
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			seconds,
+			cancel: false
+		};
+		this.emit('decr_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回默认值
+		if (beforeEventData.cancel) {
+			$.log.debug('[MongoDB] decr操作被事件处理器取消');
+			return 0;
+		}
+
+		// 使用可能被修改的值
+		let {
+			key: finalKey,
+			seconds: finalSeconds
+		} = beforeEventData;
+
+		// 参数验证
+		if (!finalKey || typeof finalKey !== 'string') {
+			$.log.warn('[MongoDB] decr: key必须是非空字符串');
+			return 0;
+		}
+
+		await this._ensureConnected();
+		const result = await this.addInt(finalKey, -1, finalSeconds);
+		const returnResult = result !== undefined ? result : 0;
+
+		// 触发后置事件
+		this.emit('decr_after', {
+			key: finalKey,
+			seconds: finalSeconds,
+			result: returnResult,
+			success: true
+		});
+
+		return returnResult;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('decr_error', {
+			key,
+			seconds,
+			error
+		});
+		$.log.error('[MongoDB] 递减操作失败:', error);
+		return 0;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 哈希表批量设置
-	 * @param {String} key 键名
-	 * @param {Object} fieldValues 字段值对象
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async hmset(key, fieldValues) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			let hash = item && typeof item.value === 'object' && item.value !== null ? item.value : {};
+/**
+ * @description Redis兼容API - 按指定值递增
+ * @param {String} key 键名
+ * @param {Number} value 增加值
+ * @return {Promise<Number>} 递增后的值
+ */
+MongoDB.prototype.incrby = async function (key, value = 1, seconds = 0) {
+	try {
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			value,
+			seconds,
+			cancel: false
+		};
+		this.emit('incrby_before', beforeEventData);
 
-			// 合并字段值
-			Object.assign(hash, fieldValues);
-			await this._add(key, hash);
-			return true;
-		} catch (error) {
-			$.log.error('[MongoDB] 哈希表批量设置失败:', error);
-			return false;
+		// 如果事件处理器标记为取消，则返回默认值
+		if (beforeEventData.cancel) {
+			$.log.debug('[MongoDB] incrby操作被事件处理器取消');
+			return 0;
 		}
+
+		// 使用可能被修改的值
+		let {
+			key: finalKey,
+			value: finalValue,
+			seconds: finalSeconds
+		} = beforeEventData;
+
+		// 参数验证
+		if (!finalKey || typeof finalKey !== 'string') {
+			$.log.warn('[MongoDB] incrby: key必须是非空字符串');
+			return 0;
+		}
+
+		// 确保value是数字
+		finalValue = Number(finalValue) || 0;
+
+		await this._ensureConnected();
+		const result = await this.addInt(finalKey, finalValue, finalSeconds);
+		const returnResult = result !== undefined ? result : 0;
+
+		// 触发后置事件
+		this.emit('incrby_after', {
+			key: finalKey,
+			value: finalValue,
+			seconds: finalSeconds,
+			result: returnResult,
+			success: true
+		});
+
+		return returnResult;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('incrby_error', {
+			key,
+			value,
+			seconds,
+			error
+		});
+		$.log.error('[MongoDB] 递增操作失败:', error);
+		return 0;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 哈希表批量获取
-	 * @param {String} key 键名
-	 * @param {Array} fields 字段名数组
-	 * @return {Promise<Object>} 字段值对象
-	 */
-	async hmget(key, fields) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || typeof item.value !== 'object' || item.value === null) {
-				return {};
-			}
+/**
+ * @description Redis兼容API - 按指定值递减
+ * @param {String} key 键名
+ * @param {Number} value 减少值
+ * @return {Promise<Number>} 递减后的值
+ */
+MongoDB.prototype.decrby = async function (key, value = 1, seconds = 0) {
+	try {
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			value,
+			seconds,
+			cancel: false
+		};
+		this.emit('decrby_before', beforeEventData);
 
-			const result = {};
-			fields.forEach(field => {
-				result[field] = item.value[field] !== undefined ? item.value[field] : null;
-			});
-			return result;
-		} catch (error) {
-			$.log.error('[MongoDB] 哈希表批量获取失败:', error);
-			return {};
+		// 如果事件处理器标记为取消，则返回默认值
+		if (beforeEventData.cancel) {
+			$.log.debug('[MongoDB] decrby操作被事件处理器取消');
+			return 0;
 		}
+
+		// 使用可能被修改的值
+		let {
+			key: finalKey,
+			value: finalValue,
+			seconds: finalSeconds
+		} = beforeEventData;
+
+		// 参数验证
+		if (!finalKey || typeof finalKey !== 'string') {
+			$.log.warn('[MongoDB] decrby: key必须是非空字符串');
+			return 0;
+		}
+
+		// 确保value是数字
+		finalValue = Number(finalValue) || 0;
+
+		await this._ensureConnected();
+		const result = await this.addInt(finalKey, -finalValue, finalSeconds);
+		const returnResult = result !== undefined ? result : 0;
+
+		// 触发后置事件
+		this.emit('decrby_after', {
+			key: finalKey,
+			value: finalValue,
+			seconds: finalSeconds,
+			result: returnResult,
+			success: true
+		});
+
+		return returnResult;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('decrby_error', {
+			key,
+			value,
+			seconds,
+			error
+		});
+		$.log.error('[MongoDB] 递减操作失败:', error);
+		return 0;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 哈希表批量删除字段
-	 * @param {String} key 键名
-	 * @param {Array} fields 字段名数组
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async hdelMulti(key, fields) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || typeof item.value !== 'object' || item.value === null) {
-				return false;
+/**
+ * @description Redis兼容API - 按指定浮点值递增
+ * @param {String} key 键名
+ * @param {Number} value 浮点增加值
+ * @return {Promise<Number>} 递增后的值
+ */
+MongoDB.prototype.incrbyfloat = async function (key, value = 1.0, seconds = 0) {
+	try {
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			value,
+			seconds,
+			cancel: false
+		};
+		this.emit('incrbyfloat_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回默认值
+		if (beforeEventData.cancel) {
+			$.log.debug('[MongoDB] incrbyfloat操作被事件处理器取消');
+			return 0.0;
+		}
+
+		// 使用可能被修改的值
+		let {
+			key: finalKey,
+			value: finalValue,
+			seconds: finalSeconds
+		} = beforeEventData;
+
+		// 参数验证
+		if (!finalKey || typeof finalKey !== 'string') {
+			$.log.warn('[MongoDB] incrbyfloat: key必须是非空字符串');
+			return 0.0;
+		}
+
+		// 确保value是数字
+		finalValue = Number(finalValue) || 0.0;
+
+		await this._ensureConnected();
+		const result = await this.addFloat(finalKey, finalValue, finalSeconds);
+		const returnResult = result !== undefined ? result : 0.0;
+
+		// 触发后置事件
+		this.emit('incrbyfloat_after', {
+			key: finalKey,
+			value: finalValue,
+			seconds: finalSeconds,
+			result: returnResult,
+			success: true
+		});
+
+		return returnResult;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('incrbyfloat_error', {
+			key,
+			value,
+			seconds,
+			error
+		});
+		$.log.error('[MongoDB] 浮点递增操作失败:', error);
+		return 0.0;
+	}
+};
+
+/**
+ * @description Redis兼容API - 检查键是否存在
+ * @param {String|Array<String>} key 键名或键名数组
+ * @return {Promise<number>} 返回存在的键数量
+ */
+MongoDB.prototype.exists = async function (key) {
+	try {
+		await this._ensureConnected();
+
+		// 验证数组中的每个元素都是非空字符串
+		if (Array.isArray(key)) {
+			for (const k of key) {
+				if (typeof k !== 'string' || !k) {
+					throw new Error('all keys must be non-empty strings');
+				}
 			}
+		}
+
+		let existsCount = 0;
 
-			let deleted = false;
-			fields.forEach(field => {
-				if (item.value[field] !== undefined) {
-					delete item.value[field];
-					deleted = true;
+		// 检查输入类型并处理
+		if (Array.isArray(key)) {
+			// 处理多键检查
+			const results = await this.find({
+				key: {
+					$in: key
 				}
 			});
+			existsCount = results.length;
+		} else {
+			// 处理单键检查
+			const result = await this.findOne({
+				key: key
+			});
+			existsCount = result !== null ? 1 : 0;
+		}
+
+		return existsCount;
+	} catch (error) {
+		$.log.error('[MongoDB] 检查键是否存在失败:', error);
+		throw error;
+	}
+};
+
+/**
+ * @description Redis兼容API - 设置键值
+ * @param {String} key 键名
+ * @param {*} value 值
+ * @return {Promise<Boolean>} 是否成功
+ */
+MongoDB.prototype._set = async function (key, value, expire) {
+	try {
+		await this._ensureConnected();
+		// 准备更新操作
+		const updateData = { $set: { value: value } };
+
+		// 如果提供了过期时间，添加expire_at字段
+		if (expire && expire > 0) {
+			updateData.$set.expire_at = new Date(Date.now() + expire * 1000);
+		}
+
+		// 直接更新数据库，避免调用_add方法形成循环引用
+		const result = await this.db.collection(this.table).updateOne(
+			{ key: key },
+			updateData,
+			{ upsert: true }
+		);
+		return true;
+	} catch (error) {
+		$.log.error('[MongoDB] 设置键值失败:', error);
+		return false; // 与CacheBase保持一致，返回false而不是抛出异常
+	}
+};
+
+/**
+ * @description Redis兼容API - 设置键值
+ * @param {String} key 键名
+ * @param {*} value 值
+ * @param {Number} seconds 过期时间（秒）
+ * @return {Promise<Boolean>} 是否成功
+ */
+MongoDB.prototype.set = async function (key, value, seconds = 0) {
+	return this._set(key, value, seconds);
+};
+
+/**
+ * @description Redis兼容API - 哈希表批量设置
+ * @param {String} key 键名
+ * @param {Array} fieldValues 字段值对数组，格式: [field1, value1, field2, value2, ...] 或对象格式 {field1: value1, field2: value2}
+ * @return {Promise<Number>} 设置的字段数量
+ */
+MongoDB.prototype.hmset = async function (key, ...fieldValues) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			$.log.warn('[MongoDB] hmset: 键名无效');
+			return 0;
+		}
 
-			if (deleted) {
-				await this._set({ key: key }, { value: item.value });
+		// 处理可变参数或对象参数
+		let hashData = {};
+		if (fieldValues.length === 1 && typeof fieldValues[0] === 'object' && fieldValues[0] !== null && !Array
+			.isArray(fieldValues[0])) {
+			// 单个对象参数格式 {field1: value1, field2: value2}
+			hashData = fieldValues[0];
+		} else {
+			// 可变参数格式 field1, value1, field2, value2...
+			for (let i = 0; i < fieldValues.length; i += 2) {
+				if (i + 1 < fieldValues.length) {
+					hashData[fieldValues[i]] = fieldValues[i + 1];
+				}
 			}
-			return deleted;
-		} catch (error) {
-			$.log.error('[MongoDB] 哈希表批量删除失败:', error);
-			return false;
 		}
+
+		const fieldsCount = Object.keys(hashData).length;
+
+		// 确保连接
+		await this._ensureConnected();
+
+		// 直接创建或更新哈希数据，不使用事件系统
+		const data = {
+			key: key,
+			value: hashData
+		};
+
+		const existing = await this.findOne({
+			key: key
+		});
+		if (existing) {
+			// 如果存在，合并现有数据
+			if (typeof existing.value === 'object' && existing.value !== null && !Array.isArray(existing
+				.value)) {
+				data.value = {
+					...existing.value,
+					...hashData
+				};
+			}
+			await this._set({
+				key: key
+			}, data);
+		} else {
+			await this.addObj(data);
+		}
+
+		return fieldsCount;
+	} catch (error) {
+		$.log.error('[MongoDB] [hmset] 哈希表批量设置失败:', error);
+		return 0;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 哈希表获取所有值
-	 * @param {String} key 键名
-	 * @return {Promise<Array>} 值数组
-	 */
-	async hvals(key) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || typeof item.value !== 'object' || item.value === null) {
-				return [];
+/**
+* @description Redis兼容API - 哈希表批量获取
+* @param {String} key 键名
+* @param {Array} fields 字段名数组
+* @return {Promise<Array>} 与字段名顺序对应的数组值，不存在返回undefined
+*/
+MongoDB.prototype.hmget = async function (key, fields) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return Array.isArray(fields) ? fields.map(() => null) : [null];
+		}
+
+		await this._ensureConnected();
+		const item = await this.findOne({ key: key });
+
+		// 确保fields是数组
+		const fieldArray = Array.isArray(fields) ? fields : [fields];
+
+		// 如果键不存在或不是哈希表格式，返回与字段数量相同的null数组
+		if (!item || typeof item.value !== 'object' || item.value === null || Array.isArray(item.value)) {
+			return fieldArray.map(() => null);
+		}
+
+		// 返回与字段名顺序对应的数组值，不存在的字段返回null
+		const values = fieldArray.map(field => {
+			// 严格检查字段是否存在于对象中
+			return Object.prototype.hasOwnProperty.call(item.value, field) ? item.value[field] : null;
+		});
+
+		return values;
+	} catch (error) {
+		$.log.error('[MongoDB] hmget操作失败:', error);
+		// 错误时返回与fields长度相同的null数组
+		const fieldArray = Array.isArray(fields) ? fields : [fields];
+		return fieldArray.map(() => null);
+	}
+};
+
+/**
+ * @description Redis兼容API - 哈希表批量删除字段
+ * @param {String} key 键名
+ * @param {Array} fields 字段名数组
+ * @return {Promise<Boolean>} 是否成功
+ */
+MongoDB.prototype.hdelMulti = async function (key, fields) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || typeof item.value !== 'object' || item.value === null) {
+			return false;
+		}
+
+		let deleted = false;
+		fields.forEach(field => {
+			if (item.value[field] !== undefined) {
+				delete item.value[field];
+				deleted = true;
 			}
-			return Object.values(item.value);
-		} catch (error) {
-			$.log.error('[MongoDB] 哈希表获取所有值失败:', error);
+		});
+
+		if (deleted) {
+			await this._set({
+				key: key
+			}, {
+				value: item.value
+			});
+		}
+		return deleted;
+	} catch (error) {
+		$.log.error('[MongoDB] 哈希表批量删除失败:', error);
+		return false;
+	}
+};
+
+/**
+ * @description Redis兼容API - 哈希表获取所有值
+ * @param {String} key 键名
+ * @return {Promise<Array>} 值数组
+ */
+MongoDB.prototype.hvals = async function (key) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || typeof item.value !== 'object' || item.value === null) {
 			return [];
 		}
+		return Object.values(item.value);
+	} catch (error) {
+		$.log.error('[MongoDB] 哈希表获取所有值失败:', error);
+		return [];
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 哈希表获取所有字段名
-	 * @param {String} key 键名
-	 * @return {Promise<Array>} 字段名数组
-	 */
-	async hkeys(key) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || typeof item.value !== 'object' || item.value === null) {
-				return [];
-			}
-			return Object.keys(item.value);
-		} catch (error) {
-			$.log.error('[MongoDB] 哈希表获取所有字段名失败:', error);
+/**
+ * @description Redis兼容API - 哈希表获取所有字段名
+ * @param {String} key 键名
+ * @return {Promise<Array>} 字段名数组
+ */
+MongoDB.prototype.hkeys = async function (key) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || typeof item.value !== 'object' || item.value === null) {
 			return [];
 		}
+		return Object.keys(item.value);
+	} catch (error) {
+		$.log.error('[MongoDB] 哈希表获取所有字段名失败:', error);
+		return [];
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 哈希表字段数量
-	 * @param {String} key 键名
-	 * @return {Promise<Number>} 字段数量
-	 */
-	async hlen(key) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || typeof item.value !== 'object' || item.value === null) {
-				return 0;
-			}
-			return Object.keys(item.value).length;
-		} catch (error) {
-			$.log.error('[MongoDB] 哈希表字段数量失败:', error);
+/**
+ * @description Redis兼容API - 哈希表字段数量
+ * @param {String} key 键名
+ * @return {Promise<Number>} 字段数量
+ */
+MongoDB.prototype.hlen = async function (key) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
 			return 0;
 		}
-	}
-
-	/**
-	 * @description Redis兼容API - 哈希表字段是否存在
-	 * @param {String} key 键名
-	 * @param {String} field 字段名
-	 * @return {Promise<Boolean>} 是否存在
-	 */
-	async hexists(key, field) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || typeof item.value !== 'object' || item.value === null) {
-				return false;
-			}
-			return field in item.value;
-		} catch (error) {
-			$.log.error('[MongoDB] 哈希表字段是否存在失败:', error);
-			return false;
-		}
-	}
 
-	/**
-	 * @description Redis兼容API - 列表尾部添加元素
-	 * @param {String} key 键名
-	 * @param {*} value 值
-	 * @return {Promise<Number>} 添加后列表长度
-	 */
-	async rpush(key, value) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			let list = item && Array.isArray(item.value) ? item.value : [];
+		await this._ensureConnected();
+		const item = await this.findOne({ key: key });
 
-			list.push(value);
-			await this._add(key, list);
-			return list.length;
-		} catch (error) {
-			$.log.error('[MongoDB] 列表尾部添加失败:', error);
+		// 如果键不存在或不是哈希表格式，返回0
+		if (!item || typeof item.value !== 'object' || item.value === null || Array.isArray(item.value)) {
 			return 0;
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 列表头部添加元素
-	 * @param {String} key 键名
-	 * @param {*} value 值
-	 * @return {Promise<Number>} 添加后列表长度
-	 */
-	async lpush(key, value) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			let list = item && Array.isArray(item.value) ? item.value : [];
+		// 使用Object.keys获取自有属性数量，这比for-in循环更高效
+		return Object.keys(item.value).length;
+	} catch (error) {
+		$.log.error('[MongoDB] hlen操作失败:', error);
+		return 0;
+	}
+};
 
-			list.unshift(value);
-			await this._add(key, list);
-			return list.length;
-		} catch (error) {
-			$.log.error('[MongoDB] 列表头部添加失败:', error);
-			return 0;
+/**
+ * @description Redis兼容API - 哈希表字段是否存在
+ * @param {String} key 键名
+ * @param {String} field 字段名
+ * @return {Promise<Boolean>} 是否存在
+ */
+MongoDB.prototype.hexists = async function (key, field) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || typeof item.value !== 'object' || item.value === null) {
+			return false;
 		}
+		return field in item.value;
+	} catch (error) {
+		$.log.error('[MongoDB] 哈希表字段是否存在失败:', error);
+		return false;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 列表范围查询
-	 * @param {String} key 键名
-	 * @param {Number} start 起始索引
-	 * @param {Number} stop 结束索引
-	 * @return {Promise<Array>} 元素数组
-	 */
-	async lrange(key, start, stop) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) {
-				return [];
-			}
-
-			// 处理负数索引
-			let startIndex = start < 0 ? item.value.length + start : start;
-			let endIndex = stop < 0 ? item.value.length + stop : stop;
+/**
+ * @description Redis兼容API - 列表尾部添加元素
+ * @param {String} key 键名
+ * @param {*} value 值
+ * @return {Promise<Number>} 添加后列表长度
+ */
+MongoDB.prototype.rpush = async function (key, value) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		let list = item && Array.isArray(item.value) ? item.value : [];
+
+		// 将值转换为字符串，与Redis行为一致
+		list.push(value.toString());
+		await this._add(key, list);
+		return list.length;
+	} catch (error) {
+		$.log.error('[MongoDB] 列表尾部添加失败:', error);
+		return 0;
+	}
+};
 
-			// 确保索引有效
-			startIndex = Math.max(0, Math.min(startIndex, item.value.length - 1));
-			endIndex = Math.max(startIndex, Math.min(endIndex, item.value.length - 1));
+/**
+ * @description Redis兼容API - 列表头部添加元素
+ * @param {String} key 键名
+ * @param {*} value 值
+ * @return {Promise<Number>} 添加后列表长度
+ */
+MongoDB.prototype.lpush = async function (key, value) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		let list = item && Array.isArray(item.value) ? item.value : [];
+
+		// 将值转换为字符串，与Redis行为一致
+		list.unshift(value.toString());
+		await this._add(key, list);
+		return list.length;
+	} catch (error) {
+		$.log.error('[MongoDB] 列表头部添加失败:', error);
+		return 0;
+	}
+};
 
-			return item.value.slice(startIndex, endIndex + 1);
-		} catch (error) {
-			$.log.error('[MongoDB] 列表范围查询失败:', error);
+/**
+ * @description Redis兼容API - 列表范围查询
+ * @param {String} key 键名
+ * @param {Number} start 起始索引
+ * @param {Number} stop 结束索引
+ * @return {Promise<Array>} 元素数组
+ */
+MongoDB.prototype.lrange = async function (key, start, stop) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value)) {
 			return [];
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 获取列表指定索引元素
-	 * @param {String} key 键名
-	 * @param {Number} index 索引
-	 * @return {Promise<any>} 元素值
-	 */
-	async lindex(key, index) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) {
-				return null;
-			}
+		// 处理负数索引
+		let startIndex = start < 0 ? item.value.length + start : start;
+		let endIndex = stop < 0 ? item.value.length + stop : stop;
 
-			// 处理负数索引
-			const realIndex = index < 0 ? item.value.length + index : index;
+		// 确保索引有效
+		startIndex = Math.max(0, Math.min(startIndex, item.value.length - 1));
+		endIndex = Math.max(startIndex, Math.min(endIndex, item.value.length - 1));
 
-			if (realIndex < 0 || realIndex >= item.value.length) {
-				return null;
-			}
+		return item.value.slice(startIndex, endIndex + 1);
+	} catch (error) {
+		$.log.error('[MongoDB] 列表范围查询失败:', error);
+		return [];
+	}
+};
 
-			return item.value[realIndex];
-		} catch (error) {
-			$.log.error('[MongoDB] 获取列表索引元素失败:', error);
+/**
+ * @description Redis兼容API - 获取列表指定索引元素
+ * @param {String} key 键名
+ * @param {Number} index 索引
+ * @return {Promise<any>} 元素值
+ */
+MongoDB.prototype.lindex = async function (key, index) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value)) {
 			return null;
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 设置列表指定索引元素
-	 * @param {String} key 键名
-	 * @param {Number} index 索引
-	 * @param {*} value 值
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async lset(key, index, value) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) {
-				return false;
-			}
+		// 处理负数索引
+		const realIndex = index < 0 ? item.value.length + index : index;
 
-			// 处理负数索引
-			const realIndex = index < 0 ? item.value.length + index : index;
+		if (realIndex < 0 || realIndex >= item.value.length) {
+			return null;
+		}
 
-			if (realIndex < 0 || realIndex >= item.value.length) {
-				return false;
-			}
+		return item.value[realIndex];
+	} catch (error) {
+		$.log.error('[MongoDB] 获取列表索引元素失败:', error);
+		return null;
+	}
+};
 
-			item.value[realIndex] = value;
-			await this._set({ key: key }, { value: item.value });
-			return true;
-		} catch (error) {
-			$.log.error('[MongoDB] 设置列表索引元素失败:', error);
+/**
+ * @description Redis兼容API - 设置列表指定索引元素
+ * @param {String} key 键名
+ * @param {Number} index 索引
+ * @param {*} value 值
+ * @return {Promise<Boolean>} 是否成功
+ */
+MongoDB.prototype.lset = async function (key, index, value) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value)) {
+			return false;
+		}
+
+		// 处理负数索引
+		const realIndex = index < 0 ? item.value.length + index : index;
+
+		if (realIndex < 0 || realIndex >= item.value.length) {
 			return false;
 		}
+
+		item.value[realIndex] = value;
+		await this._set({
+			key: key
+		}, {
+			value: item.value
+		});
+		return true;
+	} catch (error) {
+		$.log.error('[MongoDB] 设置列表索引元素失败:', error);
+		return false;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 删除列表元素
-	 * @param {String} key 键名
-	 * @param {Number} count 删除数量
-	 * @param {*} value 要删除的值
-	 * @return {Promise<Number>} 删除的元素数量
-	 */
-	async lrem(key, count, value) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) {
-				return 0;
-			}
+/**
+ * @description Redis兼容API - 删除列表元素
+ * @param {String} key 键名
+ * @param {Number} count 删除数量
+ * @param {*} value 要删除的值
+ * @return {Promise<Number>} 删除的元素数量
+ */
+MongoDB.prototype.lrem = async function (key, count, value) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value)) {
+			return 0;
+		}
 
-			let list = [...item.value];
-			let removedCount = 0;
+		let list = [...item.value];
+		let removedCount = 0;
 
-			if (count > 0) {
-				// 从头部删除count个等于value的元素
-				for (let i = 0; i < list.length && removedCount < count; i++) {
-					if (JSON.stringify(list[i]) === JSON.stringify(value)) {
-						list.splice(i, 1);
-						removedCount++;
-						i--; // 调整索引
-					}
+		if (count > 0) {
+			// 从头部删除count个等于value的元素
+			for (let i = 0; i < list.length && removedCount < count; i++) {
+				if (JSON.stringify(list[i]) === JSON.stringify(value)) {
+					list.splice(i, 1);
+					removedCount++;
+					i--; // 调整索引
 				}
-			} else if (count < 0) {
-				// 从尾部删除|count|个等于value的元素
-				count = Math.abs(count);
-				for (let i = list.length - 1; i >= 0 && removedCount < count; i--) {
-					if (JSON.stringify(list[i]) === JSON.stringify(value)) {
-						list.splice(i, 1);
-						removedCount++;
-					}
-				}
-			} else {
-				// 删除所有等于value的元素
-				list = list.filter(item => JSON.stringify(item) !== JSON.stringify(value));
-				removedCount = item.value.length - list.length;
 			}
-
-			if (removedCount > 0) {
-				await this._set({ key: key }, { value: list });
+		} else if (count < 0) {
+			// 从尾部删除|count|个等于value的元素
+			count = Math.abs(count);
+			for (let i = list.length - 1; i >= 0 && removedCount < count; i--) {
+				if (JSON.stringify(list[i]) === JSON.stringify(value)) {
+					list.splice(i, 1);
+					removedCount++;
+				}
 			}
+		} else {
+			// 删除所有等于value的元素
+			list = list.filter(item => JSON.stringify(item) !== JSON.stringify(value));
+			removedCount = item.value.length - list.length;
+		}
 
-			return removedCount;
-		} catch (error) {
-			$.log.error('[MongoDB] 删除列表元素失败:', error);
-			return 0;
+		if (removedCount > 0) {
+			await this._set({
+				key: key
+			}, {
+				value: list
+			});
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 裁剪列表
-	 * @param {String} key 键名
-	 * @param {Number} start 起始索引
-	 * @param {Number} stop 结束索引
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async ltrim(key, start, stop) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) {
-				return false;
-			}
+		return removedCount;
+	} catch (error) {
+		$.log.error('[MongoDB] 删除列表元素失败:', error);
+		return 0;
+	}
+};
 
-			// 使用lrange的逻辑获取裁剪后的列表
-			const trimmed = await this.lrange(key, start, stop);
-			await this._set({ key: key }, { value: trimmed });
-			return true;
-		} catch (error) {
-			$.log.error('[MongoDB] 裁剪列表失败:', error);
+/**
+ * @description Redis兼容API - 裁剪列表
+ * @param {String} key 键名
+ * @param {Number} start 起始索引
+ * @param {Number} stop 结束索引
+ * @return {Promise<Boolean>} 是否成功
+ */
+MongoDB.prototype.ltrim = async function (key, start, stop) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value)) {
 			return false;
 		}
+
+		// 使用lrange的逻辑获取裁剪后的列表
+		const trimmed = await this.lrange(key, start, stop);
+		await this._set({
+			key: key
+		}, {
+			value: trimmed
+		});
+		return true;
+	} catch (error) {
+		$.log.error('[MongoDB] 裁剪列表失败:', error);
+		return false;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 列表长度
-	 * @param {String} key 键名
-	 * @return {Promise<Number>} 列表长度
-	 */
-	async llen(key) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) {
-				return 0;
-			}
-			return item.value.length;
-		} catch (error) {
-			$.log.error('[MongoDB] 获取列表长度失败:', error);
+/**
+ * @description Redis兼容API - 列表长度
+ * @param {String} key 键名
+ * @return {Promise<Number>} 列表长度
+ */
+MongoDB.prototype.llen = async function (key) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value)) {
 			return 0;
 		}
+		return item.value.length;
+	} catch (error) {
+		$.log.error('[MongoDB] 获取列表长度失败:', error);
+		return 0;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 集合批量添加
-	 * @param {String} key 键名
-	 * @param {Array} members 成员数组
-	 * @return {Promise<Number>} 添加的成员数量
-	 */
-	async saddMulti(key, members) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			let set = item && Array.isArray(item.value) ? [...new Set(item.value)] : [];
-			let addedCount = 0;
-
-			members.forEach(member => {
-				if (!set.some(existing => JSON.stringify(existing) === JSON.stringify(member))) {
-					set.push(member);
-					addedCount++;
-				}
-			});
-
-			if (addedCount > 0) {
-				await this._add(key, set);
+/**
+ * @description Redis兼容API - 集合批量添加
+ * @param {String} key 键名
+ * @param {Array} members 成员数组
+ * @return {Promise<Number>} 添加的成员数量
+ */
+MongoDB.prototype.saddMulti = async function (key, members) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		let set = item && Array.isArray(item.value) ? [...new Set(item.value)] : [];
+		let addedCount = 0;
+
+		members.forEach(member => {
+			if (!set.some(existing => JSON.stringify(existing) === JSON.stringify(member))) {
+				set.push(member);
+				addedCount++;
 			}
+		});
 
-			return addedCount;
-		} catch (error) {
-			$.log.error('[MongoDB] 集合并发添加失败:', error);
-			return 0;
+		if (addedCount > 0) {
+			await this._add(key, set);
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 集合批量删除
-	 * @param {String} key 键名
-	 * @param {Array} members 成员数组
-	 * @return {Promise<Number>} 删除的成员数量
-	 */
-	async sremMulti(key, members) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) {
-				return 0;
-			}
+		return addedCount;
+	} catch (error) {
+		$.log.error('[MongoDB] 集合并发添加失败:', error);
+		return 0;
+	}
+};
 
-			let set = [...new Set(item.value)];
-			const originalLength = set.length;
+/**
+ * @description Redis兼容API - 集合批量删除
+ * @param {String} key 键名
+ * @param {Array} members 成员数组
+ * @return {Promise<Number>} 删除的成员数量
+ */
+MongoDB.prototype.sremMulti = async function (key, members) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value)) {
+			return 0;
+		}
 
-			// 创建要删除的值的字符串表示集合用于快速查找
-			const membersToRemove = new Set(members.map(m => JSON.stringify(m)));
-			set = set.filter(member => !membersToRemove.has(JSON.stringify(member)));
+		let set = [...new Set(item.value)];
+		const originalLength = set.length;
 
-			const removedCount = originalLength - set.length;
-			if (removedCount > 0) {
-				await this._add(key, set);
-			}
+		// 创建要删除的值的字符串表示集合用于快速查找
+		const membersToRemove = new Set(members.map(m => JSON.stringify(m)));
+		set = set.filter(member => !membersToRemove.has(JSON.stringify(member)));
 
-			return removedCount;
-		} catch (error) {
-			$.log.error('[MongoDB] 集合并发删除失败:', error);
-			return 0;
+		const removedCount = originalLength - set.length;
+		if (removedCount > 0) {
+			await this._add(key, set);
 		}
+
+		return removedCount;
+	} catch (error) {
+		$.log.error('[MongoDB] 集合并发删除失败:', error);
+		return 0;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 集合差集
-	 * @param {String} key1 第一个集合键
-	 * @param {String} key2 第二个集合键
-	 * @return {Promise<Array>} 差集数组
-	 */
-	async sdiff(key1, key2) {
-		try {
-			await this._ensureConnected();
-			const item1 = await this.findOne({ key: key1 });
-			const item2 = await this.findOne({ key: key2 });
+/**
+ * @description Redis兼容API - 集合差集
+ * @param {String} key1 第一个集合键
+ * @param {String} key2 第二个集合键
+ * @return {Promise<Array>} 差集数组
+ */
+MongoDB.prototype.sdiff = async function (key1, key2) {
+	try {
+		await this._ensureConnected();
+		const item1 = await this.findOne({
+			key: key1
+		});
+		const item2 = await this.findOne({
+			key: key2
+		});
+
+		const set1 = item1 && Array.isArray(item1.value) ? [...new Set(item1.value)] : [];
+		const set2 = item2 && Array.isArray(item2.value) ? [...new Set(item2.value)] : [];
 
-			const set1 = item1 && Array.isArray(item1.value) ? [...new Set(item1.value)] : [];
-			const set2 = item2 && Array.isArray(item2.value) ? [...new Set(item2.value)] : [];
+		// 创建第二个集合值的字符串表示用于快速查找
+		const set2Str = new Set(set2.map(m => JSON.stringify(m)));
 
-			// 创建第二个集合值的字符串表示用于快速查找
-			const set2Str = new Set(set2.map(m => JSON.stringify(m)));
+		// 找出在set1中但不在set2中的元素
+		return set1.filter(member => !set2Str.has(JSON.stringify(member)));
+	} catch (error) {
+		$.log.error('[MongoDB] 集合差集失败:', error);
+		return [];
+	}
+};
 
-			// 找出在set1中但不在set2中的元素
-			return set1.filter(member => !set2Str.has(JSON.stringify(member)));
-		} catch (error) {
-			$.log.error('[MongoDB] 集合差集失败:', error);
-			return [];
+/**
+ * @description Redis兼容API - 集合交集
+ * @param {String} key1 第一个集合键
+ * @param {String} key2 第二个集合键
+ * @return {Promise<Array>} 交集数组
+ */
+MongoDB.prototype.sinter = async function (key1, key2) {
+	try {
+		await this._ensureConnected();
+		const item1 = await this.findOne({
+			key: key1
+		});
+		const item2 = await this.findOne({
+			key: key2
+		});
+
+		const set1 = item1 && Array.isArray(item1.value) ? [...new Set(item1.value)] : [];
+		const set2 = item2 && Array.isArray(item2.value) ? [...new Set(item2.value)] : [];
+
+		// 创建较小集合的字符串表示用于快速查找，优化性能
+		let smallerSet, largerSet;
+		if (set1.length <= set2.length) {
+			smallerSet = set1;
+			largerSet = set2;
+		} else {
+			smallerSet = set2;
+			largerSet = set1;
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 集合交集
-	 * @param {String} key1 第一个集合键
-	 * @param {String} key2 第二个集合键
-	 * @return {Promise<Array>} 交集数组
-	 */
-	async sinter(key1, key2) {
-		try {
-			await this._ensureConnected();
-			const item1 = await this.findOne({ key: key1 });
-			const item2 = await this.findOne({ key: key2 });
+		const largerSetStr = new Set(largerSet.map(m => JSON.stringify(m)));
 
-			const set1 = item1 && Array.isArray(item1.value) ? [...new Set(item1.value)] : [];
-			const set2 = item2 && Array.isArray(item2.value) ? [...new Set(item2.value)] : [];
+		// 找出同时存在于两个集合中的元素
+		return smallerSet.filter(member => largerSetStr.has(JSON.stringify(member)));
+	} catch (error) {
+		$.log.error('[MongoDB] 集合并集失败:', error);
+		return [];
+	}
+};
 
-			// 创建较小集合的字符串表示用于快速查找，优化性能
-			let smallerSet, largerSet;
-			if (set1.length <= set2.length) {
-				smallerSet = set1;
-				largerSet = set2;
-			} else {
-				smallerSet = set2;
-				largerSet = set1;
+/**
+ * @description Redis兼容API - 集合并集
+ * @param {String} key1 第一个集合键
+ * @param {String} key2 第二个集合键
+ * @return {Promise<Array>} 并集数组
+ */
+MongoDB.prototype.sunion = async function (key1, key2) {
+	try {
+		await this._ensureConnected();
+		const item1 = await this.findOne({
+			key: key1
+		});
+		const item2 = await this.findOne({
+			key: key2
+		});
+
+		const set1 = item1 && Array.isArray(item1.value) ? item1.value : [];
+		const set2 = item2 && Array.isArray(item2.value) ? item2.value : [];
+
+		// 合并并去重
+		const combined = [...set1, ...set2];
+		// 使用Map进行对象去重，基于JSON字符串表示
+		const uniqueMap = new Map();
+
+		combined.forEach(item => {
+			const key = JSON.stringify(item);
+			if (!uniqueMap.has(key)) {
+				uniqueMap.set(key, item);
 			}
+		});
 
-			const largerSetStr = new Set(largerSet.map(m => JSON.stringify(m)));
-
-			// 找出同时存在于两个集合中的元素
-			return smallerSet.filter(member => largerSetStr.has(JSON.stringify(member)));
-		} catch (error) {
-			$.log.error('[MongoDB] 集合并集失败:', error);
-			return [];
-		}
+		return Array.from(uniqueMap.values());
+	} catch (error) {
+		$.log.error('[MongoDB] 集合并集失败:', error);
+		return [];
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 集合并集
-	 * @param {String} key1 第一个集合键
-	 * @param {String} key2 第二个集合键
-	 * @return {Promise<Array>} 并集数组
-	 */
-	async sunion(key1, key2) {
-		try {
-			await this._ensureConnected();
-			const item1 = await this.findOne({ key: key1 });
-			const item2 = await this.findOne({ key: key2 });
+/**
+ * @description Redis兼容API - 集合成员数量
+ * @param {String} key 键名
+ * @return {Promise<Number>} 成员数量
+ */
+MongoDB.prototype.scard = async function (key) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value)) {
+			return 0;
+		}
 
-			const set1 = item1 && Array.isArray(item1.value) ? item1.value : [];
-			const set2 = item2 && Array.isArray(item2.value) ? item2.value : [];
+		// 使用Set去重并计算大小
+		const uniqueItems = new Set(item.value.map(m => JSON.stringify(m)));
+		return uniqueItems.size;
+	} catch (error) {
+		$.log.error('[MongoDB] 获取集合成员数量失败:', error);
+		return 0;
+	}
+};
 
-			// 合并并去重
-			const combined = [...set1, ...set2];
-			// 使用Map进行对象去重，基于JSON字符串表示
-			const uniqueMap = new Map();
+/**
+ * @description Redis兼容API - 检查是否是集合成员
+ * @param {String} key 键名
+ * @param {*} member 成员
+ * @return {Promise<Boolean>} 是否是成员
+ */
+MongoDB.prototype.sismember = async function (key, member) {
+	try {
+		this.emit('sismember_before', {
+			key,
+			member
+		});
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
 
-			combined.forEach(item => {
-				const key = JSON.stringify(item);
-				if (!uniqueMap.has(key)) {
-					uniqueMap.set(key, item);
-				}
-			});
+		// 将成员转换为字符串，与Redis行为一致
+		const memberStr = String(member);
 
-			return Array.from(uniqueMap.values());
-		} catch (error) {
-			$.log.error('[MongoDB] 集合并集失败:', error);
-			return [];
+		let result = false;
+		if (item && Array.isArray(item.value)) {
+			// 检查是否存在相同的成员，使用字符串比较
+			result = item.value.includes(memberStr);
 		}
+
+		this.emit('sismember_after', {
+			key,
+			member,
+			result
+		});
+		return result;
+	} catch (error) {
+		this.emit('sismember_error', {
+			key,
+			member,
+			error
+		});
+		$.log.error('[MongoDB] 检查集合成员失败:', error);
+		return false;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 集合成员数量
-	 * @param {String} key 键名
-	 * @return {Promise<Number>} 成员数量
-	 */
-	async scard(key) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) {
-				return 0;
+/**
+ * @description Redis兼容API - 清空所有过期的数据
+ * @return {Promise<Boolean>} 是否成功
+ */
+MongoDB.prototype.clearExpire = async function () {
+	try {
+		this.emit('clearExpire_before', {});
+		await this._ensureConnected();
+		// 删除所有已过期的数据
+		const result = await this.delete({
+			expire_at: {
+				$exists: true,
+				$lt: new Date()
 			}
-
-			// 使用Set去重并计算大小
-			const uniqueItems = new Set(item.value.map(m => JSON.stringify(m)));
-			return uniqueItems.size;
-		} catch (error) {
-			$.log.error('[MongoDB] 获取集合成员数量失败:', error);
-			return 0;
-		}
+		});
+		this.emit('clearExpire_after', {
+			result: true
+		});
+		return true;
+	} catch (error) {
+		this.emit('clearExpire_error', {
+			error
+		});
+		$.log.error('[MongoDB] 清空过期数据失败:', error);
+		return false;
 	}
-
-	/**
-	 * @description Redis兼容API - 检查是否是集合成员
-	 * @param {String} key 键名
-	 * @param {*} member 成员
-	 * @return {Promise<Boolean>} 是否是成员
-	 */
-	async sismember(key, member) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) {
-				return false;
+};
+/**
+ * @param {...String} keys 键名列表
+ * @return {Promise<Array>} 与键顺序对应的值数组，不存在返回undefined
+ */
+MongoDB.prototype.mget = async function (...keys) {
+	try {
+		await this._ensureConnected();
+		// 确保keys是数组
+		const keyArray = Array.isArray(keys[0]) ? keys[0] : keys;
+		const results = await this.find({
+			key: {
+				$in: keyArray
 			}
+		});
+		const resultMap = {};
+		results.forEach(item => {
+			resultMap[item.key] = item.value;
+		});
+
+		// 返回与输入键顺序对应的数组，不存在的键对应位置返回undefined
+		return keyArray.map(key => resultMap.hasOwnProperty(key) ? resultMap[key] : undefined);
+	} catch (error) {
+		$.log.error('[MongoDB] 批量获取失败:', error);
+		throw error;
+	}
+};
 
-			// 检查是否存在相同的成员
-			const memberStr = JSON.stringify(member);
-			return item.value.some(m => JSON.stringify(m) === memberStr);
-		} catch (error) {
-			$.log.error('[MongoDB] 检查集合成员失败:', error);
+/**
+ * @description Redis兼容API - 批量设置
+ * @param {Object} keyValues 键值对象
+ * @return {Promise<string>} 返回'OK'
+ */
+MongoDB.prototype.mset = async function (keyValues, seconds = 0) {
+	try {
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			keyValues,
+			seconds,
+			cancel: false
+		};
+		this.emit('mset_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回false
+		if (beforeEventData.cancel) {
+			$.log.debug('[MongoDB] mset操作被事件处理器取消');
 			return false;
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 批量获取
-	 * @param {...String} keys 键名列表
-	 * @return {Promise<Array>} 与键顺序对应的值数组，不存在返回null
-	 */
-	async mget(...keys) {
-		try {
-			await this._ensureConnected();
-			// 确保keys是数组
-			const keyArray = Array.isArray(keys[0]) ? keys[0] : keys;
-			const results = await this.find({ key: { $in: keyArray } });
-			const resultMap = {};
-			results.forEach(item => {
-				resultMap[item.key] = item.value;
-			});
+		// 使用可能被修改的值
+		let {
+			keyValues: finalData,
+			seconds: finalSeconds
+		} = beforeEventData;
 
-			// 返回与输入键顺序对应的数组，不存在的键对应位置返回null
-			return keyArray.map(key => resultMap.hasOwnProperty(key) ? resultMap[key] : null);
-		} catch (error) {
-			$.log.error('[MongoDB] 批量获取失败:', error);
-			return [];
+		// 参数验证，确保keyValues是对象且不为null
+		if (typeof finalData !== 'object' || finalData === null || Array.isArray(finalData)) {
+			$.log.warn('[MongoDB] mset: 参数必须是非空对象');
+			return false;
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 批量设置
-	 * @param {Object} keyValues 键值对象
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async mset(keyValues) {
-		try {
-			await this._ensureConnected();
-			for (const [key, value] of Object.entries(keyValues)) {
-				await this._add(key, value);
-			}
-			return true;
-		} catch (error) {
-			$.log.error('[MongoDB] 批量设置失败:', error);
-			return false;
+		await this._ensureConnected();
+		for (const [key, value] of Object.entries(finalData)) {
+			await this._add(key, value, finalSeconds);
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 有序集合添加成员
-	 * @param {String} key 键名
-	 * @param {Number} score 分数
-	 * @param {*} member 成员
-	 * @return {Promise<Boolean>} 是否成功
-	 */
-	async zadd(key, score, member) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			let sortedSet = item && Array.isArray(item.value) ? item.value : [];
+		// 触发后置事件
+		this.emit('mset_after', {
+			keyValues: finalData,
+			seconds: finalSeconds,
+			result: true
+		});
+		return true;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('mset_error', {
+			keyValues,
+			seconds,
+			error
+		});
+		$.log.error('[MongoDB] 批量设置失败:', error);
+		return false;
+	}
+};
 
-			// 检查成员是否已存在，如果存在则更新分数
-			const memberStr = JSON.stringify(member);
-			const existingIndex = sortedSet.findIndex(item => JSON.stringify(item.member) === memberStr);
+/**
+ * @description Redis兼容API - 有序集合添加成员
+ * @param {String} key 键名
+ * @param {Number} score 分数
+ * @param {*} member 成员
+ * @return {Promise<Boolean>} 是否成功
+ */
+MongoDB.prototype.zadd = async function (key, score, member) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		let sortedSet = item && Array.isArray(item.value) ? item.value : [];
 
-			if (existingIndex >= 0) {
-				sortedSet[existingIndex].score = score;
-			} else {
-				sortedSet.push({ score, member });
-			}
+		// 检查成员是否已存在，如果存在则更新分数
+		const memberStr = JSON.stringify(member);
+		const existingIndex = sortedSet.findIndex(item => JSON.stringify(item.member) === memberStr);
 
-			// 按分数排序
-			sortedSet.sort((a, b) => a.score - b.score);
-			await this._add(key, sortedSet);
-			return true;
-		} catch (error) {
-			$.log.error('[MongoDB] 有序集合添加成员失败:', error);
-			return false;
+		if (existingIndex >= 0) {
+			sortedSet[existingIndex].score = score;
+		} else {
+			sortedSet.push({
+				score,
+				member
+			});
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 有序集合范围查询（按分数）
-	 * @param {String} key 键名
-	 * @param {Number} min 最小分数
-	 * @param {Number} max 最大分数
-	 * @return {Promise<Array>} 成员数组
-	 */
-	async zrangebyscore(key, min, max) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) {
-				return [];
-			}
+		// 按分数排序
+		sortedSet.sort((a, b) => a.score - b.score);
+		await this._add(key, sortedSet);
+		return true;
+	} catch (error) {
+		$.log.error('[MongoDB] 有序集合添加成员失败:', error);
+		return false;
+	}
+};
 
-			// 过滤分数范围内的成员
-			return item.value
-				.filter(item => item.score >= min && item.score <= max)
-				.map(item => item.member);
-		} catch (error) {
-			$.log.error('[MongoDB] 有序集合范围查询失败:', error);
+/**
+ * @description Redis兼容API - 有序集合范围查询（按分数）
+ * @param {String} key 键名
+ * @param {Number} min 最小分数
+ * @param {Number} max 最大分数
+ * @return {Promise<Array>} 成员数组
+ */
+MongoDB.prototype.zrangebyscore = async function (key, min, max) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value)) {
 			return [];
 		}
+
+		// 过滤分数范围内的成员
+		return item.value
+			.filter(item => item.score >= min && item.score <= max)
+			.map(item => item.member);
+	} catch (error) {
+		$.log.error('[MongoDB] 有序集合范围查询失败:', error);
+		return [];
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 有序集合成员数量
-	 * @param {String} key 键名
-	 * @return {Promise<Number>} 成员数量
-	 */
-	async zcard(key) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) {
-				return 0;
-			}
-			return item.value.length;
-		} catch (error) {
-			$.log.error('[MongoDB] 有序集合成员数量失败:', error);
+/**
+ * @description Redis兼容API - 有序集合成员数量
+ * @param {String} key 键名
+ * @return {Promise<Number>} 成员数量
+ */
+MongoDB.prototype.zcard = async function (key) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value)) {
 			return 0;
 		}
+		return item.value.length;
+	} catch (error) {
+		$.log.error('[MongoDB] 有序集合成员数量失败:', error);
+		return 0;
 	}
+};
 
-	/**
-	 * @description Redis兼容API - 有序集合删除成员
-	 * @param {String} key 键名
-	 * @param {*} member 成员
-	 * @return {Promise<Number>} 删除的成员数量
-	 */
-	async zrem(key, member) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) {
-				return 0;
-			}
-
-			const memberStr = JSON.stringify(member);
-			const filtered = item.value.filter(item => JSON.stringify(item.member) !== memberStr);
-			const removedCount = item.value.length - filtered.length;
+/**
+ * @description Redis兼容API - 有序集合删除成员
+ * @param {String} key 键名
+ * @param {*} member 成员
+ * @return {Promise<Number>} 删除的成员数量
+ */
+MongoDB.prototype.zrem = async function (key, member) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value)) {
+			return 0;
+		}
 
-			if (removedCount > 0) {
-				await this._add(key, filtered);
-			}
+		const memberStr = JSON.stringify(member);
+		const filtered = item.value.filter(item => JSON.stringify(item.member) !== memberStr);
+		const removedCount = item.value.length - filtered.length;
 
-			return removedCount;
-		} catch (error) {
-			$.log.error('[MongoDB] 有序集合删除成员失败:', error);
-			return 0;
+		if (removedCount > 0) {
+			await this._add(key, filtered);
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 获取成员分数
-	 * @param {String} key 键名
-	 * @param {*} member 成员
-	 * @return {Promise<Number|null>} 分数
-	 */
-	async zscore(key, member) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) {
-				return null;
-			}
+		return removedCount;
+	} catch (error) {
+		$.log.error('[MongoDB] 有序集合删除成员失败:', error);
+		return 0;
+	}
+};
 
-			const memberStr = JSON.stringify(member);
-			const found = item.value.find(item => JSON.stringify(item.member) === memberStr);
-			return found ? found.score : null;
-		} catch (error) {
-			$.log.error('[MongoDB] 获取成员分数失败:', error);
+/**
+ * @description Redis兼容API - 获取成员分数
+ * @param {String} key 键名
+ * @param {*} member 成员
+ * @return {Promise<Number|null>} 分数
+ */
+MongoDB.prototype.zscore = async function (key, member) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value)) {
 			return null;
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 列表弹出头部元素
-	 * @param {String} key 键名
-	 * @return {Promise<any|null>} 弹出的元素
-	 */
-	async lpop(key) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value) || item.value.length === 0) {
-				return null;
-			}
+		const memberStr = JSON.stringify(member);
+		const found = item.value.find(item => JSON.stringify(item.member) === memberStr);
+		return found ? found.score : null;
+	} catch (error) {
+		$.log.error('[MongoDB] 获取成员分数失败:', error);
+		return null;
+	}
+};
 
-			const popped = item.value.shift();
-			await this._set({ key: key }, { value: item.value });
-			return popped;
-		} catch (error) {
-			$.log.error('[MongoDB] 列表弹出头部元素失败:', error);
+/**
+ * @description Redis兼容API - 列表弹出头部元素
+ * @param {String} key 键名
+ * @return {Promise<any|null>} 弹出的元素
+ */
+MongoDB.prototype.lpop = async function (key) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value) || item.value.length === 0) {
 			return null;
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 列表弹出尾部元素
-	 * @param {String} key 键名
-	 * @return {Promise<any|null>} 弹出的元素
-	 */
-	async rpop(key) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value) || item.value.length === 0) {
-				return null;
-			}
+		const popped = item.value.shift();
+		await this._set({
+			key: key
+		}, {
+			value: item.value
+		});
+		return popped;
+	} catch (error) {
+		$.log.error('[MongoDB] 列表弹出头部元素失败:', error);
+		return null;
+	}
+};
 
-			const popped = item.value.pop();
-			await this._set({ key: key }, { value: item.value });
-			return popped;
-		} catch (error) {
-			$.log.error('[MongoDB] 列表弹出尾部元素失败:', error);
+/**
+ * @description Redis兼容API - 列表弹出尾部元素
+ * @param {String} key 键名
+ * @return {Promise<any|null>} 弹出的元素
+ */
+MongoDB.prototype.rpop = async function (key) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value) || item.value.length === 0) {
 			return null;
 		}
-	}
 
-	/**
-	 * @description Redis兼容API - 获取集合所有成员
-	 * @param {String} key 键名
-	 * @return {Promise<Array>} 成员数组
-	 */
-	async smembers(key) {
-		try {
-			await this._ensureConnected();
-			const item = await this.findOne({ key: key });
-			if (!item || !Array.isArray(item.value)) {
-				return [];
-			}
+		const popped = item.value.pop();
+		await this._set({
+			key: key
+		}, {
+			value: item.value
+		});
+		return popped;
+	} catch (error) {
+		$.log.error('[MongoDB] 列表弹出尾部元素失败:', error);
+		return null;
+	}
+};
 
-			// 去重并返回
-			const uniqueMap = new Map();
-			item.value.forEach(member => {
-				const keyStr = JSON.stringify(member);
-				if (!uniqueMap.has(keyStr)) {
-					uniqueMap.set(keyStr, member);
-				}
-			});
-			return Array.from(uniqueMap.values());
-		} catch (error) {
-			$.log.error('[MongoDB] 获取集合所有成员失败:', error);
+/**
+ * @description Redis兼容API - 获取集合所有成员
+ * @param {String} key 键名
+ * @return {Promise<Array>} 成员数组
+ */
+MongoDB.prototype.smembers = async function (key) {
+	try {
+		await this._ensureConnected();
+		const item = await this.findOne({
+			key: key
+		});
+		if (!item || !Array.isArray(item.value)) {
 			return [];
 		}
+
+		// 去重并返回
+		const uniqueMap = new Map();
+		item.value.forEach(member => {
+			const keyStr = JSON.stringify(member);
+			if (!uniqueMap.has(keyStr)) {
+				uniqueMap.set(keyStr, member);
+			}
+		});
+		return Array.from(uniqueMap.values());
+	} catch (error) {
+		$.log.error('[MongoDB] 获取集合所有成员失败:', error);
+		return [];
 	}
-}
+};
 
 /**
- * @description 设置配置
- * @param {Object|String} cg 配置对象或配置路径
+ * @description 查询单条数据
+ * @param {Object} query 查询条件对象
+ * @param {Object} options 查询选项
+ * @return {Promise<Object|null>} 查询结果
  */
-MongoDB.prototype.setConfig = function (cg) {
-	var obj;
-	if (typeof (cg) === "string") {
-		obj = cg.loadJson ? cg.loadJson(this.dir) : null;
-	} else if (cg) {
-		obj = cg;
-	}
-	if (obj) {
-		$.push(this.config, obj);
-		// 设置新配置后重新验证
-		this._validateConfig();
+MongoDB.prototype.findOne = async function (query, options = {}) {
+	await this._ensureConnected();
+	try {
+		// 确保query是对象
+		if (typeof query !== 'object' || query === null) {
+			return null;
+		}
+		// 不需要额外的sanitize，MongoDB驱动会处理
+		return await this.db.collection(this.table).findOne(query, options);
+	} catch (error) {
+		$.log.error('[MongoDB] 查询单条数据失败:', error);
+		return null;
 	}
 };
 
@@ -1519,7 +2694,9 @@ MongoDB.prototype.open = async function () {
 					this.connected = false;
 				});
 
-				$.log.info(`[MongoDB] 成功连接到 ${this.config.host}:${this.config.port}/${this.config.database}`);
+				$.log.info(
+					`[MongoDB] 成功连接到 ${this.config.host}:${this.config.port}/${this.config.database}`
+				);
 				return true;
 			} catch (error) {
 				$.log.error('[MongoDB] MongoDB连接失败:', error);
@@ -1544,10 +2721,10 @@ MongoDB.prototype.close = async function () {
 };
 
 /**
-	 * @description 创建数据表
-	 * @param {Object} table 表名
-	 * @return {Promise|Object} 执行结果
-	 */
+ * @description 创建数据表
+ * @param {Object} table 表名
+ * @return {Promise|Object} 执行结果
+ */
 MongoDB.prototype.addTable = async function (table) {
 	await this._ensureConnected();
 	if (table) {
@@ -1571,7 +2748,9 @@ MongoDB.prototype.createIndex = async function (keys, options = {}) {
 			throw new Error('数据库未连接或未指定表名');
 		}
 
-		$.log.info(`[MongoDB] 创建索引: ${this.table}, keys: ${JSON.stringify(keys)}, options: ${JSON.stringify(options)}`);
+		$.log.info(
+			`[MongoDB] 创建索引: ${this.table}, keys: ${JSON.stringify(keys)}, options: ${JSON.stringify(options)}`
+		);
 
 		return await this.db.collection(this.table).createIndex(keys, options);
 	} catch (error) {
@@ -1598,7 +2777,8 @@ MongoDB.prototype.createTTLIndex = async function (keys, expireAfterSeconds) {
 			expireAfterSeconds: expireAfterSeconds
 		};
 
-		$.log.info(`[MongoDB] 创建TTL索引: ${this.table}, keys: ${JSON.stringify(keys)}, 过期时间: ${expireAfterSeconds}秒`);
+		$.log.info(
+			`[MongoDB] 创建TTL索引: ${this.table}, keys: ${JSON.stringify(keys)}, 过期时间: ${expireAfterSeconds}秒`);
 
 		return await this.db.collection(this.table).createIndex(keys, options);
 	} catch (error) {
@@ -1608,9 +2788,9 @@ MongoDB.prototype.createTTLIndex = async function (keys, expireAfterSeconds) {
 };
 
 /**
-	 * @description 获取集合的所有索引
-	 * @returns {Promise<Array>} 索引信息数组
-	 */
+ * @description 获取集合的所有索引
+ * @returns {Promise<Array>} 索引信息数组
+ */
 MongoDB.prototype.getIndexes = async function () {
 	await this._ensureConnected();
 	try {
@@ -1621,7 +2801,7 @@ MongoDB.prototype.getIndexes = async function () {
 		$.log.info(`[MongoDB] 获取索引: ${this.table}`);
 		return await this.db.collection(this.table).indexes();
 	} catch (error) {
-		$.log.error(`[MongoDB] 获取索引失败: ${error.message}`);
+		$.log.error(`[MongoDB] [getIndexes] 获取索引失败: ${error.message}`);
 		return [];
 	}
 };
@@ -1640,11 +2820,11 @@ MongoDB.prototype.dropIndex = async function (indexName) {
 		throw new Error('索引名称不能为空');
 	}
 	try {
-		$.log.info(`[MongoDB] 删除索引: ${this.table}, 索引名: ${indexName}`);
+		$.log.info(`[MongoDB] [dropIndex] 删除索引: ${this.table}, 索引名: ${indexName}`);
 		await this.db.collection(this.table).dropIndex(indexName);
 		return true;
 	} catch (error) {
-		$.log.error(`[MongoDB] 删除索引失败: ${error.message}`);
+		$.log.error(`[MongoDB] [dropIndex] 删除索引失败: ${error.message}`);
 		throw error;
 	}
 };
@@ -1659,11 +2839,11 @@ MongoDB.prototype.dropTable = async function () {
 		throw new Error('未指定表名');
 	}
 	try {
-		$.log.info(`[MongoDB] 删除集合: ${this.table}`);
+		$.log.info(`[MongoDB] [dropTable] 删除集合: ${this.table}`);
 		await this.db.collection(this.table).drop();
 		return true;
 	} catch (error) {
-		$.log.error(`[MongoDB] 删除集合失败: ${error.message}`);
+		$.log.error(`[MongoDB] [dropTable] 删除集合失败: ${error.message}`);
 		throw error;
 	}
 };
@@ -1677,59 +2857,431 @@ MongoDB.prototype.addObj = async function (obj) {
 	await this._ensureConnected();
 	try {
 		// 触发前置事件
-		this.emit('addObj_before', { table: this.table, data: obj });
+		this.emit('addObj_before', {
+			table: this.table,
+			data: obj
+		});
 
 		// 执行插入操作
 		const result = await this.db.collection(this.table).insertOne(obj);
 
 		// 触发后置事件
-		this.emit('addObj_after', { table: this.table, data: obj, result });
+		this.emit('addObj_after', {
+			table: this.table,
+			data: obj,
+			result
+		});
 
 		return result;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('addObj_error', { table: this.table, data: obj, error });
+		this.emit('addObj_error', {
+			table: this.table,
+			data: obj,
+			error
+		});
 		throw error;
 	}
 };
 
 /**
-	 * @description Redis兼容API - 根据键获取值
-	 * @param {String} key 键名
-	 * @return {Promise<any|null>} 存储的值，如果不存在则返回null
-	 */
-	MongoDB.prototype.get = async function (key) {
-		await this._ensureConnected();
-		try {
-			const result = await this.db.collection(this.table).findOne({ key: key });
-			return result ? result.value : null;
-		} catch (error) {
-			$.log.error(`[MongoDB] 获取键值失败: ${error.message}`);
+ * @description Redis兼容API - 根据键获取值
+ * @param {String} key 键名
+ * @return {Promise<any|null>} 存储的值，如果不存在则返回null
+ */
+MongoDB.prototype.get = async function (key) {
+	await this._ensureConnected();
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
 			return null;
 		}
-	};
 
-	/**
- * @description Redis兼容API - 删除键
+		const result = await this.db.collection(this.table).findOne({
+			key: key
+		});
+		return result ? result.value : null;
+	} catch (error) {
+		$.log.error(`[MongoDB] 获取键值失败: ${error.message}`);
+		return null;
+	}
+};
+
+/**
+ * @description 设置列表
+ * @param {String} key 键名
+ * @param {Array} array 数组值
+ * @param {Number} seconds 过期时间（秒），0表示永不过期
+ * @return {Promise<Number>} 数组长度
+ */
+MongoDB.prototype.setForList = async function (key, array, seconds = 0) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return 0;
+		}
+
+		// 确保array是数组类型
+		if (!Array.isArray(array)) {
+			throw new Error('value必须是数组类型');
+		}
+
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			value: array,
+			ttl: seconds,
+			cancel: false
+		};
+		this.emit('setForList_before', beforeEventData);
+
+		if (beforeEventData.cancel) {
+			$.log.debug(`[MongoDB] [setForList] setForList操作被事件处理器取消 [${key}]`);
+			return 0;
+		}
+
+		const {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds
+		} = beforeEventData;
+
+		// 确保连接
+		await this._ensureConnected();
+
+		// 在MongoDB中存储数组
+		const success = await this._add(finalKey, finalValue, finalSeconds);
+		const length = finalValue.length;
+
+		// 触发后置事件
+		this.emit('setForList_after', {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds,
+			result: length,
+			success
+		});
+		return length;
+	} catch (error) {
+		this.emit('setForList_error', {
+			key,
+			value: array,
+			error
+		});
+		$.log.error(`[MongoDB] [setForList] setForList操作失败: ${error.message}`);
+		return 0;
+	}
+};
+
+/**
+ * @description 向列表中添加元素
+ * @param {String} key 键名
+ * @param {*} value 要添加的元素
+ * @param {Number} seconds 过期时间（秒），0表示永不过期
+ * @return {Promise<Number>} 添加后列表的长度
+ */
+MongoDB.prototype.addForList = async function (key, value, seconds = 0) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return 0;
+		}
+
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			value,
+			ttl: seconds,
+			cancel: false
+		};
+		this.emit('addForList_before', beforeEventData);
+
+		if (beforeEventData.cancel) {
+			$.log.debug(`[MongoDB] addForList操作被事件处理器取消 [${key}]`);
+			return 0;
+		}
+
+		const {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds
+		} = beforeEventData;
+
+		// 确保连接
+		await this._ensureConnected();
+
+		// 先获取当前数组
+		let currentArray = await this.get(finalKey);
+		if (!Array.isArray(currentArray)) {
+			currentArray = [];
+		}
+
+		// 添加新元素
+		currentArray.push(finalValue);
+
+		// 保存更新后的数组
+		const success = await this.set(finalKey, currentArray, finalSeconds);
+		const length = currentArray.length;
+
+		// 触发后置事件
+		this.emit('addForList_after', {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds,
+			result: length,
+			success
+		});
+		return length;
+	} catch (error) {
+		this.emit('addForList_error', {
+			key,
+			value,
+			error
+		});
+		$.log.error(`[MongoDB] addForList操作失败: ${error.message}`);
+		return 0;
+	}
+};
+
+/**
+ * @description Redis兼容API - 检查列表中是否存在指定元素
+ * @param {String} key 键名
+ * @param {any} value 要检查的元素值
+ * @return {Promise<Boolean>} 存在返回true，不存在返回false
+ */
+MongoDB.prototype.hasForList = async function (key, value) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return false;
+		}
+
+		// 确保连接
+		await this._ensureConnected();
+
+		// 获取当前数组
+		const array = await this.get(key);
+
+		// 检查是否为数组
+		if (!Array.isArray(array)) {
+			return false;
+		}
+
+		// 使用JSON.stringify比较，确保对象类型也能正确比较
+		const valueStr = JSON.stringify(value);
+		return array.some(item => JSON.stringify(item) === valueStr);
+	} catch (error) {
+		$.log.error(`[MongoDB] hasForList操作失败: ${error.message}`);
+		return false;
+	}
+};
+
+/**
+ * @description 获取列表指定范围的元素
+ * @param {String} key 键名
+ * @param {Number} start 起始索引，默认0
+ * @param {Number} stop 结束索引，默认-1（表示到末尾）
+ * @return {Promise<Array>} 元素数组
+ */
+MongoDB.prototype.getForList = async function (key, start = 0, stop = -1) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return [];
+		}
+
+		// 确保连接
+		await this._ensureConnected();
+
+		// 获取整个数组
+		const array = await this.get(key);
+		const list = Array.isArray(array) ? array : [];
+
+		// 处理Redis风格的索引范围
+		let result = [];
+		if (start >= 0 && stop >= -1) {
+			if (stop === -1) {
+				result = list.slice(start);
+			} else {
+				result = list.slice(start, stop + 1);
+			}
+		}
+
+		return result;
+	} catch (error) {
+		$.log.error(`[MongoDB] getForList操作失败: ${error.message}`);
+		return [];
+	}
+};
+
+/**
+ * @description 清空列表，保留键和过期时间
  * @param {String} key 键名
+ * @return {Promise<Boolean>} 是否成功
+ */
+MongoDB.prototype.clearForList = async function (key) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return false;
+		}
+
+		// 确保连接
+		await this._ensureConnected();
+
+		// 使用set方法直接设置为空数组，与其他模块行为一致
+		return await this.set(key, []);
+	} catch (error) {
+		$.log.error(`[MongoDB] clearForList操作失败: ${error.message}`);
+		return false;
+	}
+};
+
+MongoDB.prototype.has = async function (key) {
+	await this._ensureConnected();
+	try {
+		// 调用exists方法并转换结果为布尔值
+		const exists = await this.exists(key);
+		return exists > 0;
+	} catch (error) {
+		$.log.error(`[MongoDB] 检查键是否存在失败: ${error.message}`);
+		throw error;
+	}
+};
+
+MongoDB.prototype.exists = async function (key) {
+	await this._ensureConnected();
+	try {
+		// 检查单个键的情况
+		if (typeof key === 'string') {
+			const result = await this.db.collection(this.table).findOne({
+				key: key
+			}, {
+				projection: {
+					_id: 1
+				}
+			});
+			return result ? 1 : 0;
+		}
+		// 检查数组键的情况
+		else if (Array.isArray(key)) {
+			// 验证数组中的每个元素是否都是非空字符串
+			for (const k of key) {
+				if (!k || typeof k !== 'string') {
+					throw new Error('key must be a non-empty string or array of non-empty strings');
+				}
+			}
+
+			const filter = {
+				key: {
+					$in: key
+				}
+			};
+			const count = await this.db.collection(this.table).countDocuments(filter);
+			return count;
+		} else {
+			throw new Error('key must be a non-empty string or array of non-empty strings');
+		}
+	} catch (error) {
+		$.log.error(`[MongoDB] 检查键是否存在失败: ${error.message}`);
+		throw error;
+	}
+};
+
+/**
+ * @description Redis兼容API - 删除键
+ * @param {String|Array<String>} key 键名或键名数组
  * @return {Promise<Boolean>} 是否删除成功
  */
 MongoDB.prototype.del = async function (key) {
 	await this._ensureConnected();
 	try {
-		// 触发前置事件
-		this.emit('del_before', { table: this.table, key: key });
-		
-		const result = await this.db.collection(this.table).deleteOne({ key: key });
-		
+		// 键名必须是非空字符串或非空字符串数组
+		if (!key) {
+			$.log.error('[MongoDB] 参数错误: key必须是非空字符串或非空字符串数组');
+			return false;
+		}
+
+		// 如果是单个键，验证是否为非空字符串
+		if (typeof key === 'string') {
+			if (!key) {
+				$.log.error('[MongoDB] 参数错误: key必须是非空字符串');
+				return false;
+			}
+		}
+		// 如果是数组，验证每个元素是否为非空字符串
+		else if (Array.isArray(key)) {
+			for (const k of key) {
+				if (!k || typeof k !== 'string') {
+					$.log.error('[MongoDB] 参数错误: key必须是非空字符串或非空字符串数组');
+					return false;
+				}
+			}
+		} else {
+			$.log.error('[MongoDB] 参数错误: key必须是非空字符串或非空字符串数组');
+			return false;
+		}
+
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			cancel: false
+		};
+		this.emit('del_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回false
+		if (beforeEventData.cancel) {
+			$.log.debug(`[MongoDB] del操作被事件处理器取消 [${key}]`);
+			return false;
+		}
+
+		// 使用可能被修改的值
+		let {
+			key: finalKey
+		} = beforeEventData;
+
+		let success = false;
+		let deleted = [];
+
+		if (Array.isArray(finalKey)) {
+			// 批量删除
+			success = true;
+			for (const k of finalKey) {
+				const result = await this.db.collection(this.table).deleteOne({
+					key: k
+				});
+				if (result.deletedCount === 1) {
+					deleted.push(k);
+				} else {
+					success = false;
+				}
+			}
+		} else {
+			// 单个删除
+			const result = await this.db.collection(this.table).deleteOne({
+				key: finalKey
+			});
+			success = result.deletedCount === 1;
+			if (success) {
+				deleted.push(finalKey);
+			}
+		}
+
 		// 触发后置事件
-		this.emit('del_after', { table: this.table, key: key, result });
-		
-		return result.deletedCount > 0;
+		this.emit('del_after', {
+			key: finalKey,
+			success,
+			deleted
+		});
+
+		return success;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('del_error', { table: this.table, key: key, error });
-		$.log.error(`[MongoDB] 删除键失败: ${error.message}`);
+		this.emit('del_error', {
+			key,
+			error: error
+		});
+		$.log.error('[MongoDB] 删除缓存失败:', error);
 		return false;
 	}
 };
@@ -1738,32 +3290,81 @@ MongoDB.prototype.del = async function (key) {
  * @description Redis兼容API - 添加键值对
  * @param {String} key 键名
  * @param {any} value 值
+ * @param {Number} seconds 过期时间(秒)
  * @return {Promise<Boolean>} 是否添加成功（如果键已存在则返回false）
  */
-MongoDB.prototype.add = async function (key, value) {
+MongoDB.prototype.add = async function (key, value, seconds) {
 	await this._ensureConnected();
 	try {
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			value,
+			ttl: seconds,
+			cancel: false
+		};
+		this.emit('add_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回false
+		if (beforeEventData.cancel) {
+			$.log.debug(`[MongoDB] add操作被事件处理器取消 [${key}]`);
+			return false;
+		}
+
+		// 使用可能被修改的值
+		let {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds
+		} = beforeEventData;
+
 		// 检查键是否已存在
-		const exists = await this.db.collection(this.table).findOne({ key: key });
+		const exists = await this.db.collection(this.table).findOne({
+			key: finalKey
+		});
 		if (exists) {
+			// 键已存在时触发后置事件，但返回false
+			this.emit('add_after', {
+				key: finalKey,
+				value: finalValue,
+				ttl: finalSeconds,
+				success: false
+			});
 			return false;
 		}
-		
-		const data = { key: key, value: value };
-		
-		// 触发前置事件
-		this.emit('add_before', { table: this.table, key: key, value: value });
-		
+
+		const data = {
+			key: finalKey,
+			value: finalValue
+		};
+
+		// 如果设置了过期时间
+		if (finalSeconds) {
+			const now = new Date();
+			data.expire_at = new Date(now.getTime() + finalSeconds * 1000);
+		}
+
 		// 添加键值对
 		const result = await this.db.collection(this.table).insertOne(data);
-		
+		const success = result.acknowledged;
+
 		// 触发后置事件
-		this.emit('add_after', { table: this.table, key: key, value: value, result });
-		
-		return result.acknowledged;
+		this.emit('add_after', {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds,
+			success
+		});
+
+		return success;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('add_error', { table: this.table, key: key, value: value, error });
+		this.emit('add_error', {
+			key,
+			value,
+			ttl: seconds,
+			error
+		});
 		$.log.error(`[MongoDB] 添加键值失败: ${error.message}`);
 		return false;
 	}
@@ -1775,26 +3376,81 @@ MongoDB.prototype.add = async function (key, value) {
  * @param {any} value 值
  * @return {Promise<Boolean>} 是否设置成功
  */
-MongoDB.prototype.set = async function (key, value) {
+MongoDB.prototype.set = async function (key, value, seconds) {
 	await this._ensureConnected();
 	try {
-		// 触发前置事件
-		this.emit('set_before', { table: this.table, key: key, value: value });
-		
+		// 键名必须是非空字符串
+		if (!key || typeof key !== 'string') {
+			$.log.error('[MongoDB] 参数错误: key必须是非空字符串');
+			return false;
+		}
+
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			value,
+			ttl: seconds,
+			cancel: false
+		};
+		this.emit('set_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回false
+		if (beforeEventData.cancel) {
+			$.log.debug(`[MongoDB] set操作被事件处理器取消 [${key}]`);
+			return false;
+		}
+
+		// 使用可能被修改的值
+		let {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds
+		} = beforeEventData;
+
+		// 准备更新数据，包括值和可能的过期时间
+		const updateData = {
+			$set: {
+				value: finalValue
+			}
+		};
+
+		// 如果指定了过期时间，设置过期时间
+		if (finalSeconds && typeof finalSeconds === 'number' && finalSeconds > 0) {
+			const expireTime = new Date(Date.now() + finalSeconds * 1000);
+			updateData.$set.expire_at = expireTime;
+		} else {
+			// 如果没有指定过期时间，移除可能存在的过期字段
+			updateData.$unset = {
+				expire_at: ""
+			};
+		}
+
 		// 更新或插入键值对
-		const result = await this.db.collection(this.table).updateOne(
-			{ key: key },
-			{ $set: { value: value } },
-			{ upsert: true }
+		const result = await this.db.collection(this.table).updateOne({
+			key: finalKey
+		},
+			updateData, {
+			upsert: true
+		}
 		);
-		
+
 		// 触发后置事件
-		this.emit('set_after', { table: this.table, key: key, value: value, result });
-		
+		this.emit('set_after', {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds,
+			success: result.acknowledged
+		});
+
 		return result.acknowledged;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('set_error', { table: this.table, key: key, value: value, error });
+		this.emit('set_error', {
+			key,
+			value,
+			ttl: seconds,
+			error
+		});
 		$.log.error(`[MongoDB] 设置键值失败: ${error.message}`);
 		return false;
 	}
@@ -1809,18 +3465,29 @@ MongoDB.prototype.addList = async function (list) {
 	await this._ensureConnected();
 	try {
 		// 触发前置事件
-		this.emit('addList_before', { table: this.table, data: list });
+		this.emit('addList_before', {
+			table: this.table,
+			data: list
+		});
 
 		// 执行插入操作
 		const result = await this.db.collection(this.table).insertMany(list);
 
 		// 触发后置事件
-		this.emit('addList_after', { table: this.table, data: list, result });
+		this.emit('addList_after', {
+			table: this.table,
+			data: list,
+			result
+		});
 
 		return result;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('addList_error', { table: this.table, data: list, error });
+		this.emit('addList_error', {
+			table: this.table,
+			data: list,
+			error
+		});
 		throw error;
 	}
 };
@@ -1834,21 +3501,34 @@ MongoDB.prototype.delete = async function (query) {
 	await this._ensureConnected();
 	try {
 		// 如果query是字符串，则作为键名处理
-		const safeQuery = typeof query === 'string' ? { key: query } : query;
+		const safeQuery = typeof query === 'string' ? {
+			key: query
+		} : query;
 
 		// 触发前置事件
-		this.emit('delete_before', { table: this.table, query: safeQuery });
+		this.emit('delete_before', {
+			table: this.table,
+			query: safeQuery
+		});
 
 		// 执行删除操作
 		const result = await this.db.collection(this.table).deleteMany(safeQuery);
 
 		// 触发后置事件
-		this.emit('delete_after', { table: this.table, query: safeQuery, result });
+		this.emit('delete_after', {
+			table: this.table,
+			query: safeQuery,
+			result
+		});
 
 		return result;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('delete_error', { table: this.table, query, error });
+		this.emit('delete_error', {
+			table: this.table,
+			query,
+			error
+		});
 		throw error;
 	}
 };
@@ -1864,36 +3544,63 @@ MongoDB.prototype.setting = async function (query, body, options = {}) {
 	await this._ensureConnected();
 	try {
 		// 处理Redis兼容模式：如果query是字符串，则将query作为键名
-		const safeQuery = typeof query === 'string' ? { key: query } : query;
+		const safeQuery = typeof query === 'string' ? {
+			key: query
+		} : query;
 
 		// 默认使用$set操作符进行部分更新
 		let updateBody;
 		if (typeof query === 'string') {
 			// Redis兼容模式：如果是字符串键名，直接设置value
-			updateBody = { $set: { value: body } };
+			updateBody = {
+				$set: {
+					value: body
+				}
+			};
 		} else if (!body.$set && !body.$inc && !body.$push) {
-			updateBody = { $set: body };
+			updateBody = {
+				$set: body
+			};
 		} else {
 			updateBody = body;
 		}
 
 		// 默认更新多条
-		const updateOptions = Object.assign({ multi: true }, options);
+		const updateOptions = Object.assign({
+			multi: true
+		}, options);
 
 		// 触发前置事件
-		this.emit('setting_before', { table: this.table, query: safeQuery, update: updateBody, options: updateOptions });
+		this.emit('setting_before', {
+			table: this.table,
+			query: safeQuery,
+			update: updateBody,
+			options: updateOptions
+		});
 
 		// 执行更新操作
 		const result = await this.db.collection(this.table).updateMany(safeQuery, updateBody, updateOptions);
 
 		// 触发后置事件
-		this.emit('setting_after', { table: this.table, query: safeQuery, update: updateBody, options: updateOptions, result });
+		this.emit('setting_after', {
+			table: this.table,
+			query: safeQuery,
+			update: updateBody,
+			options: updateOptions,
+			result
+		});
 
 		// Redis兼容模式返回布尔值，否则返回完整结果
 		return typeof query === 'string' ? result.modifiedCount > 0 : result;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('setting_error', { table: this.table, query, update: body, options, error });
+		this.emit('setting_error', {
+			table: this.table,
+			query,
+			update: body,
+			options,
+			error
+		});
 
 		// Redis兼容模式返回布尔值
 		return typeof query === 'string' ? false : null;
@@ -1919,22 +3626,6 @@ MongoDB.prototype.find = async function (query, options = {}) {
 	}
 };
 
-/**
- * @description 查询单条数据
- * @param {Object} query 查询条件对象
- * @param {Object} options 查询选项
- * @return {Promise<Object|null>} 查询结果
- */
-MongoDB.prototype.findOne = async function (query, options = {}) {
-	await this._ensureConnected();
-	try {
-		const safeQuery = this._sanitizeQuery(query);
-		return await this.db.collection(this.table).findOne(safeQuery, options);
-	} catch (error) {
-		$.log.error('[MongoDB] 查询单条数据失败:', error);
-		return null;
-	}
-};
 
 /**
  * @description 计算文档数量
@@ -1964,7 +3655,8 @@ MongoDB.prototype._sanitizeQuery = function (query) {
 
 	for (const [key, value] of Object.entries(query)) {
 		// 防止NoSQL注入，如 {$ne: null} 等操作符注入
-		if (key.startsWith('$') && typeof key === 'string' && !Array.isArray(value) && typeof value === 'object' && value !== null) {
+		if (key.startsWith('$') && typeof key === 'string' && !Array.isArray(value) && typeof value === 'object' &&
+			value !== null) {
 			$.log.warn('[MongoDB] 检测到可能的操作符注入尝试:', key);
 			continue;
 		}
@@ -1985,7 +3677,7 @@ MongoDB.prototype.startTransaction = async function () {
 		session.startTransaction();
 		return session;
 	} catch (error) {
-		$.log.error('[MongoDB] 启动事务失败:', error);
+		$.log.error('[MongoDB] [startTransaction] 启动事务失败:', error);
 		throw error;
 	}
 };
@@ -2000,7 +3692,7 @@ MongoDB.prototype.commitTransaction = async function (session) {
 		await session.commitTransaction();
 		await session.endSession();
 	} catch (error) {
-		$.log.error('[MongoDB] 提交事务失败:', error);
+		$.log.error('[MongoDB] [commitTransaction] 提交事务失败:', error);
 		throw error;
 	}
 };
@@ -2015,7 +3707,7 @@ MongoDB.prototype.rollbackTransaction = async function (session) {
 		await session.abortTransaction();
 		await session.endSession();
 	} catch (error) {
-		$.log.error('[MongoDB] 回滚事务失败:', error);
+		$.log.error('[MongoDB] [rollbackTransaction] 回滚事务失败:', error);
 		throw error;
 	}
 };
@@ -2038,25 +3730,29 @@ if (!$.pool.mongoDB) {
 /**
  * @description MongoDB管理器，用于创建缓存
  * @param {String} scope 作用域
- * @param {String} dir 当前路径
+ * @param {Object} config 配置参数
  * @return {Object} 返回一个MongoDB类实例
  */
-function mongoDB_admin(scope, dir) {
+function mongodb_admin(scope, config) {
 	if (!scope) {
-		scope = ($.val && $.val.scope) || 'default';
+		scope = 'sys';
 	}
 	var obj = $.pool.mongoDB[scope];
 	if (!obj) {
-		$.pool.mongoDB[scope] = new MongoDB(scope, dir);
+		// 确保配置对象存在并有必要的字段
+		const dbConfig = {
+			host: 'localhost',
+			port: 27017,
+			database: scope,
+			...(typeof config === 'object' && config ? config : {})
+		};
+		$.pool.mongoDB[scope] = new MongoDB(dbConfig);
 		obj = $.pool.mongoDB[scope];
 	}
 	return obj;
 }
 
-
-
-
 /**
  * @module 导出MongoDB管理器
  */
-exports.mongoDB_admin = mongoDB_admin;
+exports.mongodb_admin = mongodb_admin;