mm_mongodb 1.5.0 → 1.5.2

package/index.js

@@ -4,14 +4,14 @@
  * @version 1.2.1
  */
 const {
-	BaseService
-} = require('mm_base_service');
+	Base
+} = require('mm_expand');
 const MongoClient = require('mongodb').MongoClient;
 
 /**
  * @description MongoDB帮助类
  */
-class MongoDB extends BaseService {
+class MongoDB extends Base {
 	/**
 	 * @description 创建MongoDB帮助类函数 (构造函数)
 	 * @param {Object} config 配置参数
@@ -19,8 +19,6 @@ class MongoDB extends BaseService {
 	 */
 	constructor(config) {
 		super();
-
-		// 合并配置，确保使用对象扩展运算符正确合并
 		this.config = {
 			// 服务器地址
 			host: "localhost",
@@ -29,26 +27,17 @@ class MongoDB extends BaseService {
 			// 数据库名
 			database: "mm",
 			// 用户名
-			user: "admin",
+			user: "",
 			// 密码
 			password: "",
-			// 连接选项
-			options: {
-				minPoolSize: 10,
-				maxPoolSize: 100,
-				connectTimeoutMS: 10000,
-				serverSelectionTimeoutMS: 5000,
-				retryWrites: true
-			},
-			// 重试配置
-			retry: {
-				maxAttempts: 3,
-				delayMS: 1000
-			}
+			// 连接选项 (MongoDB驱动7.x版本支持的参数)
+			min_pool_size: 10,
+			max_pool_size: 100,
+			connect_timeout_ms: 10000,
+			server_selection_timeout_ms: 5000,
+			retry_writes: true
 		};
 
-		// 连接地址
-		this.url = null;
 		// 数据库连接器
 		this.conn = null;
 		// 操作的数据库
@@ -84,15 +73,15 @@ class MongoDB extends BaseService {
  */
 MongoDB.prototype._validateConfig = function () {
 	if (!this.config.host || typeof this.config.host !== 'string') {
-		throw new Error('MongoDB配置无效：host必须是有效的字符串');
+		throw new TypeError('host必须是有效的字符串');
 	}
 
 	if (!Number.isInteger(this.config.port) || this.config.port < 1 || this.config.port > 65535) {
-		throw new Error('MongoDB配置无效：port必须是1-65535之间的整数');
+		throw new TypeError('port必须是1-65535之间的整数');
 	}
 
 	if (!this.config.database || typeof this.config.database !== 'string') {
-		throw new Error('MongoDB配置无效：database必须是有效的字符串');
+		throw new TypeError('database必须是有效的字符串');
 	}
 };
 
@@ -104,8 +93,8 @@ MongoDB.prototype._validateConfig = function () {
  * @return {Promise} 操作结果
  */
 MongoDB.prototype._withRetry = async function (operation, operationName) {
-	const maxAttempts = this.config.retry?.maxAttempts || 3;
-	const delayMS = this.config.retry?.delayMS || 1000;
+	const maxAttempts = 3; // 固定重试次数，不再从配置读取
+	const delayMS = 1000; // 固定延迟时间，不再从配置读取
 	let lastError;
 
 	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
@@ -113,7 +102,7 @@ MongoDB.prototype._withRetry = async function (operation, operationName) {
 			return await operation();
 		} catch (error) {
 			lastError = error;
-			$.log.error(`[MongoDB] ${operationName} 第${attempt}次尝试失败:`, error.message);
+			this.logger('error', `${operationName} 第${attempt}次尝试失败:`, error);
 
 			// 如果不是最后一次尝试，则等待后重试
 			if (attempt < maxAttempts) {
@@ -122,8 +111,8 @@ MongoDB.prototype._withRetry = async function (operation, operationName) {
 		}
 	}
 
-	// 所有重试都失败，抛出最后一个错误
-	throw lastError;
+	// 所有重试都失败，触发错误事件
+	this.emit('error', lastError);
 };
 /**
  * @description 确保数据库连接已建立
@@ -149,16 +138,16 @@ MongoDB.prototype._ensureConnected = async function () {
 
 				// 检查连接是否成功
 				if (this.db && this.db.collection) {
-					$.log.debug(`[MongoDB] [_ensureConnected] 连接成功，db对象存在，开始初始化collection，table=${this.table}`);
+					this.logger('debug', `[_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}`);
+						this.logger('debug', `[_ensureConnected] 成功初始化collection: ${this.table}`);
 					} catch (err) {
-						$.log.error(`[MongoDB] [_ensureConnected] 初始化collection失败:`, err.message);
+						this.logger('error', `[_ensureConnected] 初始化collection失败:`, err);
 						this.collection = null;
 					}
 
@@ -167,15 +156,14 @@ MongoDB.prototype._ensureConnected = async function () {
 						await this._ensureIndexes();
 					}
 
-					$.log.info(`[MongoDB] 成功连接到数据库，表名: ${this.table}`);
+					this.logger('info', `成功连接到数据库，表名: ${this.table}`);
 				} else {
-					$.log.error(`[MongoDB] [_ensureConnected] 连接失败，db对象为空或不具有collection方法`);
+					this.logger('error', `[_ensureConnected] 连接失败，db对象为空或不具有collection方法`);
 					throw new Error('数据库连接失败，db对象为空');
 				}
 			}
 		} catch (error) {
-			$.log.error(`[MongoDB] 连接失败 (尝试 ${this.connectAttempts}/${this.maxConnectAttempts}):`,
-				error.message);
+			this.logger('error', `连接失败 (尝试 ${this.connectAttempts}/${this.maxConnectAttempts}):`, error);
 
 			// 重置连接Promise，允许下次重试
 			this.connectPromise = null;
@@ -185,8 +173,8 @@ MongoDB.prototype._ensureConnected = async function () {
 				throw error;
 			} else {
 				// 超过重试次数，记录严重错误
-				$.log.error('[MongoDB] 达到最大连接重试次数，连接失败');
-				throw new Error('数据库连接失败，已达到最大重试次数');
+				this.logger('error', '达到最大连接重试次数，连接失败');
+				this.emit('error', new Error('数据库连接失败，已达到最大重试次数'));
 			}
 		}
 	})();
@@ -219,7 +207,7 @@ MongoDB.prototype._ensureIndexes = async function () {
 	} catch (error) {
 		// 忽略索引已存在的错误
 		if (error.code !== 85) {
-			$.log.error('[MongoDB] 创建索引失败:', error);
+			this.logger('error', '创建索引失败:', error);
 		}
 	}
 };
@@ -227,18 +215,23 @@ MongoDB.prototype._ensureIndexes = async function () {
 /**
  * @description Redis兼容API - 获取缓存值
  * @param {String} key 键名
- * @return {Promise<any>} 返回键值，不存在返回undefined
+ * @return {Promise<any>} 返回键值，不存在返回null
  */
 MongoDB.prototype.get = async function (key) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const result = await this.findOne({
 			key: key
 		});
-		return result ? result.value : undefined;
+		return result ? result.value : null;
 	} catch (error) {
-		$.log.error('[MongoDB] 获取缓存失败:', error);
-		throw error;
+		this.logger('error', '获取缓存失败:', error);
+		this.emit('error', error);
 	}
 };
 
@@ -248,9 +241,14 @@ MongoDB.prototype.get = async function (key) {
  * @return {Promise<Boolean>} 是否成功
  */
 MongoDB.prototype.clear = async function (pattern) {
+	// 参数校验
+	if (pattern !== undefined && pattern !== null && typeof pattern !== 'string') {
+		throw new TypeError('pattern必须是有效的字符串');
+	}
+
 	try {
 		// 触发前置事件
-		this.emit('clear_before', {
+		this.emit('clear:before', {
 			pattern
 		});
 
@@ -264,7 +262,7 @@ MongoDB.prototype.clear = async function (pattern) {
 					$regex: regex
 				}
 			});
-			this.emit('clear_after', {
+			this.emit('clear:after', {
 				pattern,
 				result
 			});
@@ -272,17 +270,17 @@ MongoDB.prototype.clear = async function (pattern) {
 		} else {
 			// 清空所有数据，直接使用deleteMany操作
 			const result = await this.db.collection(this.table).deleteMany({});
-			this.emit('clear_after', {
+			this.emit('clear:after', {
 				result
 			});
 			return result.acknowledged;
 		}
 	} catch (error) {
-		this.emit('clear_error', {
+		this.emit('clear:error', {
 			error,
 			pattern
 		});
-		$.log.error('[MongoDB] 清空缓存失败:', error);
+		this.logger('error', '清空缓存失败:', error);
 		return false;
 	}
 };
@@ -293,6 +291,11 @@ MongoDB.prototype.clear = async function (pattern) {
  * @return {Promise<Array>} 键名数组
  */
 MongoDB.prototype.keys = async function (pattern = '*') {
+	// 参数校验
+	if (typeof pattern !== 'string') {
+		throw new TypeError('pattern必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		let query = {};
@@ -310,7 +313,7 @@ MongoDB.prototype.keys = async function (pattern = '*') {
 		});
 		return results.map(item => item.key);
 	} catch (error) {
-		$.log.error('[MongoDB] 获取键列表失败:', error);
+		this.logger('error', '获取键列表失败:', error);
 		return [];
 	}
 };
@@ -322,11 +325,12 @@ MongoDB.prototype.keys = async function (pattern = '*') {
  * @return {Promise<Number|Boolean>} 不传seconds时返回剩余过期时间（-1表示无过期设置，-2表示已过期或不存在），传seconds时返回是否设置成功
  */
 MongoDB.prototype.ttl = async function (key, seconds) {
+	// 参数验证
+	if (!key || typeof key !== 'string') {
+		throw new TypeError('key必须是非空字符串');
+	}
+
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			return arguments.length === 1 ? -2 : false;
-		}
 
 		// 设置模式才需要触发事件
 		if (seconds !== undefined && seconds !== null) {
@@ -336,7 +340,7 @@ MongoDB.prototype.ttl = async function (key, seconds) {
 				seconds,
 				cancel: false
 			};
-			this.emit('ttl_before', beforeEventData);
+			this.emit('ttl:before', beforeEventData);
 
 			if (beforeEventData.cancel) {
 				return false;
@@ -353,19 +357,19 @@ MongoDB.prototype.ttl = async function (key, seconds) {
 
 			// 直接尝试获取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`);
+				this.logger('debug', `[ttl] 设置模式：直接获取collection, table=${this.table}`);
+		try {
+			this.collection = this.db.collection(this.table);
+			this.logger('debug', `[ttl] 设置模式：成功获取collection`);
 				} catch (err) {
-					$.log.error(`[MongoDB] [ttl] 设置模式：获取collection失败:`, err.message);
+					this.logger('error', `[ttl] 设置模式：获取collection失败:`, err);
 					this.collection = null;
 				}
 			}
 
 			// 检查collection是否存在
 			if (!this.collection) {
-				this.emit('ttl_after', {
+				this.emit('ttl:after', {
 					key: finalKey,
 					seconds: finalSeconds,
 					result: false
@@ -376,7 +380,7 @@ MongoDB.prototype.ttl = async function (key, seconds) {
 			// 检查键是否存在
 			const count = await this.collection.countDocuments({ key: finalKey });
 			if (count === 0) {
-				this.emit('ttl_after', {
+				this.emit('ttl:after', {
 					key: finalKey,
 					seconds: finalSeconds,
 					result: false
@@ -403,7 +407,7 @@ MongoDB.prototype.ttl = async function (key, seconds) {
 				{ upsert: false }
 			);
 
-			this.emit('ttl_after', {
+			this.emit('ttl:after', {
 				key: finalKey,
 				seconds: finalSeconds,
 				result: true
@@ -421,12 +425,12 @@ MongoDB.prototype.ttl = async function (key, seconds) {
 
 			// 直接尝试获取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`);
+				this.logger('debug', `[ttl] 直接获取collection, table=${this.table}`);
+		try {
+			this.collection = this.db.collection(this.table);
+			this.logger('debug', `[ttl] 成功获取collection`);
 				} catch (err) {
-					$.log.error(`[MongoDB] [ttl] 获取collection失败:`, err.message);
+					this.logger('error', `[ttl] 获取collection失败:`, err);
 					this.collection = null;
 				}
 			}
@@ -437,19 +441,19 @@ MongoDB.prototype.ttl = async function (key, seconds) {
 			}
 
 			// 查询键是否存在及过期时间
-			const item = await this.collection.findOne({ key });
-			$.log.debug(`[MongoDB] [ttl] 查询键结果: item=${JSON.stringify(item)}`);
+		const item = await this.collection.findOne({ key });
+		this.logger('debug', `[ttl] 查询键结果: item=${JSON.stringify(item)}`);
 
-			if (!item) {
-				// 键不存在返回-2
-				$.log.debug(`[MongoDB] [ttl] 键 ${key} 不存在，返回-2`);
-				return -2;
-			}
+		if (!item) {
+			// 键不存在返回-2
+			this.logger('debug', `[ttl] 键 ${key} 不存在，返回-2`);
+			return -2;
+		}
 
-			if (!item.expire_at) {
-				// 没有过期时间返回-1
-				$.log.debug(`[MongoDB] [ttl] 键 ${key} 没有过期时间，返回-1`);
-				return -1;
+		if (!item.expire_at) {
+			// 没有过期时间返回-1
+			this.logger('debug', `[ttl] 键 ${key} 没有过期时间，返回-1`);
+			return -1;
 			}
 
 			// 计算剩余过期时间
@@ -466,8 +470,8 @@ MongoDB.prototype.ttl = async function (key, seconds) {
 			return remainingSeconds;
 		}
 	} catch (error) {
-		this.emit('ttl_error', { key, seconds, error });
-		$.log.error(`[MongoDB] [ttl] 操作失败:`, error.message);
+		this.emit('ttl:error', { key, seconds, error });
+		this.logger('error', `[ttl] 操作失败:`, error);
 		return arguments.length === 1 ? -2 : false;
 	}
 };
@@ -478,18 +482,19 @@ MongoDB.prototype.ttl = async function (key, seconds) {
  * @return {Promise<boolean>} 移除成功返回true，键不存在或没有过期时间返回false
  */
 MongoDB.prototype.persist = async function (key) {
+	// 参数验证
+	if (!key || typeof key !== 'string') {
+		throw new TypeError('key必须是非空字符串');
+	}
+
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			return false;
-		}
 
 		// 触发前置事件
 		const beforeEventData = {
 			key,
 			cancel: false
 		};
-		this.emit('persist_before', beforeEventData);
+		this.emit('persist:before', beforeEventData);
 
 		if (beforeEventData.cancel) {
 			return false;
@@ -504,20 +509,20 @@ MongoDB.prototype.persist = async function (key) {
 
 		// 直接尝试获取collection，不依赖_ensureConnected的复杂逻辑
 		if (!this.collection && this.db && this.db.collection) {
-			$.log.debug(`[MongoDB] [persist] 直接获取collection, table=${this.table}`);
+			this.logger('debug', `[persist] 直接获取collection, table=${this.table}`);
 			try {
 				this.collection = this.db.collection(this.table);
-				$.log.debug(`[MongoDB] [persist] 成功获取collection`);
+				this.logger('debug', `[persist] 成功获取collection`);
 			} catch (err) {
-				$.log.error(`[MongoDB] [persist] 获取collection失败:`, err.message);
+				this.logger('error', `[persist] 获取collection失败:`, err);
 				this.collection = null;
 			}
 		}
 
 		// 再次检查collection
 		if (!this.collection) {
-			$.log.error('[MongoDB] persist: collection is undefined');
-			this.emit('persist_error', {
+			this.logger('error', 'persist: collection is undefined');
+			this.emit('persist:error', {
 				key: finalKey,
 				error: new Error('collection is undefined')
 			});
@@ -528,7 +533,7 @@ MongoDB.prototype.persist = async function (key) {
 		const item = await this.collection.findOne({ key: finalKey });
 		if (!item) {
 			// 键不存在返回false
-			this.emit('persist_after', {
+			this.emit('persist:after', {
 				key: finalKey,
 				success: false
 			});
@@ -537,7 +542,7 @@ MongoDB.prototype.persist = async function (key) {
 
 		// 如果没有过期时间，直接返回true
 		if (!item.expire_at) {
-			this.emit('persist_after', {
+			this.emit('persist:after', {
 				key: finalKey,
 				success: true
 			});
@@ -555,14 +560,14 @@ MongoDB.prototype.persist = async function (key) {
 		const success = result.modifiedCount > 0;
 
 		// 触发后置事件
-		this.emit('persist_after', {
+		this.emit('persist:after', {
 			key: finalKey,
 			success: success
 		});
 		return success;
 	} catch (error) {
-		$.log.error('[MongoDB] persist error:', error.message);
-		this.emit('persist_error', {
+		this.logger('error', 'persist error:', error);
+		this.emit('persist:error', {
 			key,
 			error
 		});
@@ -600,7 +605,7 @@ MongoDB.prototype._add = async function (key, value, expire) {
 		}
 		return true;
 	} catch (error) {
-		$.log.error('[MongoDB] 添加缓存失败:', error);
+		this.logger('error', '添加缓存失败:', error);
 		return false;
 	}
 };
@@ -621,11 +626,11 @@ MongoDB.prototype.add = async function (key, value, seconds) {
 			ttl: seconds,
 			cancel: false
 		};
-		this.emit('add_before', beforeEventData);
+		this.emit('add:before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回false
 		if (beforeEventData.cancel) {
-			$.log.debug(`[MongoDB] add操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `add操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -644,7 +649,7 @@ MongoDB.prototype.add = async function (key, value, seconds) {
 		});
 		if (existing) {
 			// 键已存在，返回false
-			this.emit('add_after', {
+			this.emit('add:after', {
 				key: finalKey,
 				value: finalValue,
 				ttl: finalSeconds,
@@ -666,7 +671,7 @@ MongoDB.prototype.add = async function (key, value, seconds) {
 		await this.addObj(data);
 
 		// 触发后置事件
-		this.emit('add_after', {
+		this.emit('add:after', {
 			key: finalKey,
 			value: finalValue,
 			ttl: finalSeconds,
@@ -674,9 +679,9 @@ MongoDB.prototype.add = async function (key, value, seconds) {
 		});
 		return true;
 	} catch (error) {
-		$.log.error(`[MongoDB] 添加缓存失败 [${key}]:`, error);
+		this.logger('error', `添加缓存失败 [${key}]:`, error);
 		// 触发错误事件
-		this.emit('add_error', {
+		this.emit('add:error', {
 			key,
 			value,
 			ttl: seconds,
@@ -709,8 +714,8 @@ MongoDB.prototype._addNum = async function (key, value = 1) {
 		await this._add(key, newValue);
 		return newValue;
 	} catch (error) {
-		$.log.error('[MongoDB] 增加整数值失败:', error);
-		return undefined;
+		this.logger('error', '增加整数值失败:', error);
+		return false;
 	}
 };
 
@@ -727,6 +732,11 @@ MongoDB.prototype._addNum = async function (key, value = 1) {
  * @return {Promise<Number>} 增加后的值
  */
 MongoDB.prototype.addInt = async function (key, value = 1, seconds = 0) {
+	// 参数验证
+	if (!key || typeof key !== 'string') {
+		throw new TypeError('key必须是非空字符串');
+	}
+
 	try {
 		// 触发前置事件，允许修改或阻止操作
 		const beforeEventData = {
@@ -735,11 +745,11 @@ MongoDB.prototype.addInt = async function (key, value = 1, seconds = 0) {
 			seconds,
 			cancel: false
 		};
-		this.emit('addInt_before', beforeEventData);
+		this.emit('addInt:before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			$.log.debug('[MongoDB] addInt操作被事件处理器取消');
+			this.logger('debug', 'addInt操作被事件处理器取消');
 			return 0;
 		}
 
@@ -750,12 +760,6 @@ MongoDB.prototype.addInt = async function (key, value = 1, seconds = 0) {
 			seconds: finalSeconds
 		} = beforeEventData;
 
-		// 参数验证
-		if (!finalKey || typeof finalKey !== 'string') {
-			$.log.warn('[MongoDB] addInt: key必须是非空字符串');
-			return 0;
-		}
-
 		finalValue = Number(finalValue) || 0;
 
 		await this._ensureConnected();
@@ -774,7 +778,7 @@ MongoDB.prototype.addInt = async function (key, value = 1, seconds = 0) {
 		await this._add(finalKey, newValue, finalSeconds);
 
 		// 触发后置事件
-		this.emit('addInt_after', {
+		this.emit('addInt:after', {
 			key: finalKey,
 			value: finalValue,
 			seconds: finalSeconds,
@@ -784,13 +788,13 @@ MongoDB.prototype.addInt = async function (key, value = 1, seconds = 0) {
 		return newValue;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('addInt_error', {
+		this.emit('addInt:error', {
 			key,
 			value,
 			seconds,
 			error
 		});
-		$.log.error('[MongoDB] 增加整数值失败:', error);
+		this.logger('error', '增加整数值失败:', error);
 		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
 		return 0;
 	}
@@ -803,6 +807,11 @@ MongoDB.prototype.addInt = async function (key, value = 1, seconds = 0) {
  * @return {Promise<Number>} 增加后的值
  */
 MongoDB.prototype.addFloat = async function (key, value = 1.0, seconds = 0) {
+	// 参数验证
+	if (!key || typeof key !== 'string') {
+		throw new TypeError('key必须是非空字符串');
+	}
+
 	try {
 		// 触发前置事件，允许修改或阻止操作
 		const beforeEventData = {
@@ -811,11 +820,11 @@ MongoDB.prototype.addFloat = async function (key, value = 1.0, seconds = 0) {
 			seconds,
 			cancel: false
 		};
-		this.emit('addFloat_before', beforeEventData);
+		this.emit('addFloat:before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			$.log.debug('[MongoDB] addFloat操作被事件处理器取消');
+			this.logger('debug', 'addFloat操作被事件处理器取消');
 			return 0.0;
 		}
 
@@ -826,12 +835,6 @@ MongoDB.prototype.addFloat = async function (key, value = 1.0, seconds = 0) {
 			seconds: finalSeconds
 		} = beforeEventData;
 
-		// 参数验证
-		if (!finalKey || typeof finalKey !== 'string') {
-			$.log.warn('[MongoDB] addFloat: key必须是非空字符串');
-			return 0.0;
-		}
-
 		finalValue = Number(finalValue) || 0.0;
 
 		await this._ensureConnected();
@@ -850,7 +853,7 @@ MongoDB.prototype.addFloat = async function (key, value = 1.0, seconds = 0) {
 		await this._add(finalKey, newValue, finalSeconds);
 
 		// 触发后置事件
-		this.emit('addFloat_after', {
+		this.emit('addFloat:after', {
 			key: finalKey,
 			value: finalValue,
 			seconds: finalSeconds,
@@ -860,13 +863,13 @@ MongoDB.prototype.addFloat = async function (key, value = 1.0, seconds = 0) {
 		return newValue;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('addFloat_error', {
+		this.emit('addFloat:error', {
 			key,
 			value,
 			seconds,
 			error
 		});
-		$.log.error('[MongoDB] 增加浮点数值失败:', error);
+		this.logger('error', '增加浮点数值失败:', error);
 		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
 		return 0.0;
 	}
@@ -879,22 +882,22 @@ MongoDB.prototype.addFloat = async function (key, value = 1.0, seconds = 0) {
  * @return {Promise<Number>} 添加后的字符串长度
  */
 MongoDB.prototype.addStr = async function (key, value) {
+	// 参数验证
+	if (!key || typeof key !== 'string') {
+		throw new TypeError('key必须是非空字符串');
+	}
+
+	if (value === undefined || value === null) {
+		value = '';
+	}
+
 	try {
 		// 触发前置事件
-		this.emit('addStr_before', {
+		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({
@@ -906,7 +909,7 @@ MongoDB.prototype.addStr = async function (key, value) {
 		await this._add(key, newValue);
 
 		// 触发后置事件
-		this.emit('addStr_after', {
+		this.emit('addStr:after', {
 			key,
 			value,
 			result: newValue.length
@@ -915,12 +918,12 @@ MongoDB.prototype.addStr = async function (key, value) {
 		return newValue.length;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('addStr_error', {
+		this.emit('addStr:error', {
 			key,
 			value,
 			error
 		});
-		$.log.error('[MongoDB] 添加字符串失败:', error);
+		this.logger('error', '添加字符串失败:', error);
 		return 0;
 	}
 };
@@ -957,7 +960,7 @@ MongoDB.prototype.sort = async function (key, options = {}) {
 
 		return sorted;
 	} catch (error) {
-		$.log.error('[MongoDB] 排序失败:', error);
+		this.logger('error', '排序失败:', error);
 		return [];
 	}
 };
@@ -970,6 +973,14 @@ MongoDB.prototype.sort = async function (key, options = {}) {
  * @return {Promise<number>} 返回1表示新建字段，0表示更新字段
  */
 MongoDB.prototype.hset = async function (key, field, value) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+	if (typeof field !== 'string' || !field) {
+		throw new TypeError('field必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -981,9 +992,9 @@ MongoDB.prototype.hset = async function (key, field, value) {
 		const isNewField = !hash.hasOwnProperty(field);
 		hash[field] = value;
 		await this._add(key, hash);
-		return isNewField ? 1 : 0;
+		return true; // hset操作成功返回true
 	} catch (error) {
-		$.log.error('[MongoDB] 哈希表设置失败:', error);
+		this.logger('error', '哈希表设置失败:', error);
 		throw error;
 	}
 };
@@ -995,6 +1006,14 @@ MongoDB.prototype.hset = async function (key, field, value) {
  * @return {Promise<any>} 返回字段值，不存在返回undefined
  */
 MongoDB.prototype.hget = async function (key, field) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+	if (typeof field !== 'string' || !field) {
+		throw new TypeError('field必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -1005,8 +1024,8 @@ MongoDB.prototype.hget = async function (key, field) {
 		}
 		return item.value[field] !== undefined ? item.value[field] : undefined;
 	} catch (error) {
-		$.log.error('[MongoDB] 哈希表获取失败:', error);
-		throw error;
+		this.logger('error', '哈希表获取失败:', error);
+		return null; // 与Redis保持一致，错误时返回null
 	}
 };
 
@@ -1016,6 +1035,11 @@ MongoDB.prototype.hget = async function (key, field) {
  * @return {Promise<Object>} 哈希表对象
  */
 MongoDB.prototype.hgetall = async function (key) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		const item = await this.findOne({
 			key: key
@@ -1025,7 +1049,7 @@ MongoDB.prototype.hgetall = async function (key) {
 		}
 		return item.value;
 	} catch (error) {
-		$.log.error('[MongoDB] 哈希表获取全部失败:', error);
+		this.logger('error', '哈希表获取全部失败:', error);
 		return {};
 	}
 };
@@ -1037,12 +1061,15 @@ MongoDB.prototype.hgetall = async function (key) {
  * @return {Promise<boolean>} 返回true表示成功删除，false表示未删除
  */
 MongoDB.prototype.hdel = async function (key, fields) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			return 0;
-		}
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+	if (!fields || (typeof fields !== 'string' && !Array.isArray(fields))) {
+		throw new TypeError('fields必须是字符串或字符串数组');
+	}
 
+	try {
 		// 统一将fields转换为数组格式
 		const fieldArray = Array.isArray(fields) ? fields : [fields];
 		if (fieldArray.length === 0) {
@@ -1082,7 +1109,7 @@ MongoDB.prototype.hdel = async function (key, fields) {
 
 		return deletedCount;
 	} catch (error) {
-		$.log.error('[MongoDB] hdel操作失败:', error);
+		this.logger('error', 'hdel操作失败:', error);
 		return 0;
 	}
 };
@@ -1093,13 +1120,18 @@ MongoDB.prototype.hdel = async function (key, fields) {
  * @return {Promise<Boolean>} 是否存在
  */
 MongoDB.prototype.has = async function (key) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		const result = await this.findOne({
 			key: key
 		});
 		return result !== null;
 	} catch (error) {
-		$.log.error('[MongoDB] [has] 检查键是否存在失败:', error);
+		this.logger('error', '[has] 检查键是否存在失败:', error);
 		throw error;
 	}
 };
@@ -1121,11 +1153,11 @@ MongoDB.prototype.expire = async function (key, seconds) {
 			seconds,
 			cancel: false
 		};
-		this.emit('expire_before', beforeEventData);
+		this.emit('expire:before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			$.log.debug('[MongoDB] expire操作被事件处理器取消');
+			this.logger('debug', 'expire操作被事件处理器取消');
 			return false;
 		}
 
@@ -1139,7 +1171,7 @@ MongoDB.prototype.expire = async function (key, seconds) {
 		const result = await this.ttl(finalKey, finalSeconds);
 
 		// 触发后置事件
-		this.emit('expire_after', {
+		this.emit('expire:after', {
 			key: finalKey,
 			seconds: finalSeconds,
 			result
@@ -1149,10 +1181,10 @@ MongoDB.prototype.expire = async function (key, seconds) {
 		return result === true || (typeof result === 'number' && result >= -2);
 	} catch (error) {
 		// 记录错误日志
-		$.log.error('[MongoDB] expire方法执行错误', { error: error.message, key, seconds });
+		this.logger('error', 'expire方法执行错误', { error: error.message, key, seconds });
 
 		// 触发错误事件
-		this.emit('expire_error', {
+		this.emit('expire:error', {
 			key,
 			seconds,
 			error
@@ -1175,11 +1207,11 @@ MongoDB.prototype.incr = async function (key, seconds = 0) {
 			seconds,
 			cancel: false
 		};
-		this.emit('incr_before', beforeEventData);
+		this.emit('incr:before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			$.log.debug('[MongoDB] incr操作被事件处理器取消');
+			this.logger('debug', 'incr操作被事件处理器取消');
 			return 0;
 		}
 
@@ -1190,9 +1222,8 @@ MongoDB.prototype.incr = async function (key, seconds = 0) {
 		} = beforeEventData;
 
 		// 参数验证
-		if (!finalKey || typeof finalKey !== 'string') {
-			$.log.warn('[MongoDB] incr: key必须是非空字符串');
-			return 0;
+		if (typeof finalKey !== 'string' || !finalKey) {
+			throw new TypeError('key必须是有效的字符串');
 		}
 
 		await this._ensureConnected();
@@ -1200,7 +1231,7 @@ MongoDB.prototype.incr = async function (key, seconds = 0) {
 		const returnResult = result !== undefined ? result : 0;
 
 		// 触发后置事件
-		this.emit('incr_after', {
+		this.emit('incr:after', {
 			key: finalKey,
 			seconds: finalSeconds,
 			result: returnResult,
@@ -1210,12 +1241,12 @@ MongoDB.prototype.incr = async function (key, seconds = 0) {
 		return returnResult;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('incr_error', {
+		this.emit('incr:error', {
 			key,
 			seconds,
 			error
 		});
-		$.log.error('[MongoDB] 递增操作失败:', error);
+		this.logger('error', '递增操作失败:', error);
 		return 0;
 	}
 };
@@ -1233,11 +1264,11 @@ MongoDB.prototype.decr = async function (key, seconds = 0) {
 			seconds,
 			cancel: false
 		};
-		this.emit('decr_before', beforeEventData);
+		this.emit('decr:before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			$.log.debug('[MongoDB] decr操作被事件处理器取消');
+			this.logger('debug', 'decr操作被事件处理器取消');
 			return 0;
 		}
 
@@ -1248,9 +1279,8 @@ MongoDB.prototype.decr = async function (key, seconds = 0) {
 		} = beforeEventData;
 
 		// 参数验证
-		if (!finalKey || typeof finalKey !== 'string') {
-			$.log.warn('[MongoDB] decr: key必须是非空字符串');
-			return 0;
+		if (typeof finalKey !== 'string' || !finalKey) {
+			throw new TypeError('key必须是有效的字符串');
 		}
 
 		await this._ensureConnected();
@@ -1258,7 +1288,7 @@ MongoDB.prototype.decr = async function (key, seconds = 0) {
 		const returnResult = result !== undefined ? result : 0;
 
 		// 触发后置事件
-		this.emit('decr_after', {
+		this.emit('decr:after', {
 			key: finalKey,
 			seconds: finalSeconds,
 			result: returnResult,
@@ -1268,12 +1298,12 @@ MongoDB.prototype.decr = async function (key, seconds = 0) {
 		return returnResult;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('decr_error', {
+		this.emit('decr:error', {
 			key,
 			seconds,
 			error
 		});
-		$.log.error('[MongoDB] 递减操作失败:', error);
+		this.logger('error', '递减操作失败:', error);
 		return 0;
 	}
 };
@@ -1293,11 +1323,11 @@ MongoDB.prototype.incrby = async function (key, value = 1, seconds = 0) {
 			seconds,
 			cancel: false
 		};
-		this.emit('incrby_before', beforeEventData);
+		this.emit('incrby:before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			$.log.debug('[MongoDB] incrby操作被事件处理器取消');
+			this.logger('debug', 'incrby操作被事件处理器取消');
 			return 0;
 		}
 
@@ -1309,9 +1339,8 @@ MongoDB.prototype.incrby = async function (key, value = 1, seconds = 0) {
 		} = beforeEventData;
 
 		// 参数验证
-		if (!finalKey || typeof finalKey !== 'string') {
-			$.log.warn('[MongoDB] incrby: key必须是非空字符串');
-			return 0;
+		if (typeof finalKey !== 'string' || !finalKey) {
+			throw new TypeError('key必须是有效的字符串');
 		}
 
 		// 确保value是数字
@@ -1322,7 +1351,7 @@ MongoDB.prototype.incrby = async function (key, value = 1, seconds = 0) {
 		const returnResult = result !== undefined ? result : 0;
 
 		// 触发后置事件
-		this.emit('incrby_after', {
+		this.emit('incrby:after', {
 			key: finalKey,
 			value: finalValue,
 			seconds: finalSeconds,
@@ -1333,13 +1362,13 @@ MongoDB.prototype.incrby = async function (key, value = 1, seconds = 0) {
 		return returnResult;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('incrby_error', {
+		this.emit('incrby:error', {
 			key,
 			value,
 			seconds,
 			error
 		});
-		$.log.error('[MongoDB] 递增操作失败:', error);
+		this.logger('error', '递增操作失败:', error);
 		return 0;
 	}
 };
@@ -1359,11 +1388,11 @@ MongoDB.prototype.decrby = async function (key, value = 1, seconds = 0) {
 			seconds,
 			cancel: false
 		};
-		this.emit('decrby_before', beforeEventData);
+		this.emit('decrby:before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			$.log.debug('[MongoDB] decrby操作被事件处理器取消');
+			this.logger('debug', 'decrby操作被事件处理器取消');
 			return 0;
 		}
 
@@ -1375,9 +1404,8 @@ MongoDB.prototype.decrby = async function (key, value = 1, seconds = 0) {
 		} = beforeEventData;
 
 		// 参数验证
-		if (!finalKey || typeof finalKey !== 'string') {
-			$.log.warn('[MongoDB] decrby: key必须是非空字符串');
-			return 0;
+		if (typeof finalKey !== 'string' || !finalKey) {
+			throw new TypeError('key必须是有效的字符串');
 		}
 
 		// 确保value是数字
@@ -1388,7 +1416,7 @@ MongoDB.prototype.decrby = async function (key, value = 1, seconds = 0) {
 		const returnResult = result !== undefined ? result : 0;
 
 		// 触发后置事件
-		this.emit('decrby_after', {
+		this.emit('decrby:after', {
 			key: finalKey,
 			value: finalValue,
 			seconds: finalSeconds,
@@ -1399,13 +1427,13 @@ MongoDB.prototype.decrby = async function (key, value = 1, seconds = 0) {
 		return returnResult;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('decrby_error', {
+		this.emit('decrby:error', {
 			key,
 			value,
 			seconds,
 			error
 		});
-		$.log.error('[MongoDB] 递减操作失败:', error);
+		this.logger('error', '递减操作失败:', error);
 		return 0;
 	}
 };
@@ -1425,11 +1453,11 @@ MongoDB.prototype.incrbyfloat = async function (key, value = 1.0, seconds = 0) {
 			seconds,
 			cancel: false
 		};
-		this.emit('incrbyfloat_before', beforeEventData);
+		this.emit('incrbyfloat:before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (beforeEventData.cancel) {
-			$.log.debug('[MongoDB] incrbyfloat操作被事件处理器取消');
+			this.logger('debug', 'incrbyfloat操作被事件处理器取消');
 			return 0.0;
 		}
 
@@ -1441,9 +1469,8 @@ MongoDB.prototype.incrbyfloat = async function (key, value = 1.0, seconds = 0) {
 		} = beforeEventData;
 
 		// 参数验证
-		if (!finalKey || typeof finalKey !== 'string') {
-			$.log.warn('[MongoDB] incrbyfloat: key必须是非空字符串');
-			return 0.0;
+		if (typeof finalKey !== 'string' || !finalKey) {
+			throw new TypeError('key必须是有效的字符串');
 		}
 
 		// 确保value是数字
@@ -1454,7 +1481,7 @@ MongoDB.prototype.incrbyfloat = async function (key, value = 1.0, seconds = 0) {
 		const returnResult = result !== undefined ? result : 0.0;
 
 		// 触发后置事件
-		this.emit('incrbyfloat_after', {
+		this.emit('incrbyfloat:after', {
 			key: finalKey,
 			value: finalValue,
 			seconds: finalSeconds,
@@ -1465,13 +1492,13 @@ MongoDB.prototype.incrbyfloat = async function (key, value = 1.0, seconds = 0) {
 		return returnResult;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('incrbyfloat_error', {
+		this.emit('incrbyfloat:error', {
 			key,
 			value,
 			seconds,
 			error
 		});
-		$.log.error('[MongoDB] 浮点递增操作失败:', error);
+		this.logger('error', '浮点递增操作失败:', error);
 		return 0.0;
 	}
 };
@@ -1479,43 +1506,46 @@ MongoDB.prototype.incrbyfloat = async function (key, value = 1.0, seconds = 0) {
 /**
  * @description Redis兼容API - 检查键是否存在
  * @param {String|Array<String>} key 键名或键名数组
- * @return {Promise<number>} 返回存在的键数量
+ * @return {Promise<boolean>} 是否存在
  */
 MongoDB.prototype.exists = async function (key) {
 	try {
 		await this._ensureConnected();
 
+		// 参数验证
+		if (!key) {
+			throw new TypeError('key必须是非空字符串或非空字符串数组');
+		}
+
 		// 验证数组中的每个元素都是非空字符串
 		if (Array.isArray(key)) {
 			for (const k of key) {
 				if (typeof k !== 'string' || !k) {
-					throw new Error('all keys must be non-empty strings');
+					throw new TypeError('key数组中的每个元素必须是非空字符串');
 				}
 			}
+		} else if (typeof key !== 'string') {
+			throw new TypeError('key必须是非空字符串或非空字符串数组');
 		}
 
-		let existsCount = 0;
-
 		// 检查输入类型并处理
 		if (Array.isArray(key)) {
-			// 处理多键检查
+			// 处理多键检查：只要有一个键存在就返回true
 			const results = await this.find({
 				key: {
 					$in: key
 				}
 			});
-			existsCount = results.length;
+			return results.length > 0;
 		} else {
 			// 处理单键检查
 			const result = await this.findOne({
 				key: key
 			});
-			existsCount = result !== null ? 1 : 0;
+			return result !== null;
 		}
-
-		return existsCount;
 	} catch (error) {
-		$.log.error('[MongoDB] 检查键是否存在失败:', error);
+		this.logger('error', '检查键是否存在失败:', error);
 		throw error;
 	}
 };
@@ -1545,9 +1575,9 @@ MongoDB.prototype._set = async function (key, value, expire) {
 		);
 		return true;
 	} catch (error) {
-		$.log.error('[MongoDB] 设置键值失败:', error);
-		return false; // 与CacheBase保持一致，返回false而不是抛出异常
-	}
+		this.logger('error', '设置缓存失败:', error);
+		return false;
+	} // 与CacheBase保持一致，返回false而不是抛出异常
 };
 
 /**
@@ -1565,13 +1595,13 @@ MongoDB.prototype.set = async function (key, value, seconds = 0) {
  * @description Redis兼容API - 哈希表批量设置
  * @param {String} key 键名
  * @param {Array} fieldValues 字段值对数组，格式: [field1, value1, field2, value2, ...] 或对象格式 {field1: value1, field2: value2}
- * @return {Promise<Number>} 设置的字段数量
+ * @return {Promise<Boolean>} 操作结果
  */
 MongoDB.prototype.hmset = async function (key, ...fieldValues) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.warn('[MongoDB] hmset: 键名无效');
+			this.logger('warn', 'hmset: 键名无效');
 			return 0;
 		}
 
@@ -1590,8 +1620,6 @@ MongoDB.prototype.hmset = async function (key, ...fieldValues) {
 			}
 		}
 
-		const fieldsCount = Object.keys(hashData).length;
-
 		// 确保连接
 		await this._ensureConnected();
 
@@ -1620,10 +1648,10 @@ MongoDB.prototype.hmset = async function (key, ...fieldValues) {
 			await this.addObj(data);
 		}
 
-		return fieldsCount;
+		return true; // 操作成功返回true
 	} catch (error) {
-		$.log.error('[MongoDB] [hmset] 哈希表批量设置失败:', error);
-		return 0;
+		this.logger('error', '[hmset] 哈希表批量设置失败:', error);
+		return false; // 操作失败返回false
 	}
 };
 
@@ -1659,7 +1687,7 @@ MongoDB.prototype.hmget = async function (key, fields) {
 
 		return values;
 	} catch (error) {
-		$.log.error('[MongoDB] hmget操作失败:', error);
+		this.logger('error', 'hmget操作失败:', error);
 		// 错误时返回与fields长度相同的null数组
 		const fieldArray = Array.isArray(fields) ? fields : [fields];
 		return fieldArray.map(() => null);
@@ -1673,6 +1701,14 @@ MongoDB.prototype.hmget = async function (key, fields) {
  * @return {Promise<Boolean>} 是否成功
  */
 MongoDB.prototype.hdelMulti = async function (key, fields) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+	if (!Array.isArray(fields) || fields.length === 0) {
+		throw new TypeError('fields必须是非空数组');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -1699,7 +1735,7 @@ MongoDB.prototype.hdelMulti = async function (key, fields) {
 		}
 		return deleted;
 	} catch (error) {
-		$.log.error('[MongoDB] 哈希表批量删除失败:', error);
+		this.logger('error', '增加整数值失败:', error);
 		return false;
 	}
 };
@@ -1710,6 +1746,11 @@ MongoDB.prototype.hdelMulti = async function (key, fields) {
  * @return {Promise<Array>} 值数组
  */
 MongoDB.prototype.hvals = async function (key) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -1720,7 +1761,7 @@ MongoDB.prototype.hvals = async function (key) {
 		}
 		return Object.values(item.value);
 	} catch (error) {
-		$.log.error('[MongoDB] 哈希表获取所有值失败:', error);
+		this.logger('error', '哈希表获取所有值失败:', error);
 		return [];
 	}
 };
@@ -1731,6 +1772,11 @@ MongoDB.prototype.hvals = async function (key) {
  * @return {Promise<Array>} 字段名数组
  */
 MongoDB.prototype.hkeys = async function (key) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -1741,7 +1787,7 @@ MongoDB.prototype.hkeys = async function (key) {
 		}
 		return Object.keys(item.value);
 	} catch (error) {
-		$.log.error('[MongoDB] 哈希表获取所有字段名失败:', error);
+		this.logger('error', '哈希表获取所有字段名失败:', error);
 		return [];
 	}
 };
@@ -1752,12 +1798,12 @@ MongoDB.prototype.hkeys = async function (key) {
  * @return {Promise<Number>} 字段数量
  */
 MongoDB.prototype.hlen = async function (key) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			return 0;
-		}
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
 
+	try {
 		await this._ensureConnected();
 		const item = await this.findOne({ key: key });
 
@@ -1769,7 +1815,7 @@ MongoDB.prototype.hlen = async function (key) {
 		// 使用Object.keys获取自有属性数量，这比for-in循环更高效
 		return Object.keys(item.value).length;
 	} catch (error) {
-		$.log.error('[MongoDB] hlen操作失败:', error);
+		this.logger('error', 'hlen操作失败:', error);
 		return 0;
 	}
 };
@@ -1781,6 +1827,14 @@ MongoDB.prototype.hlen = async function (key) {
  * @return {Promise<Boolean>} 是否存在
  */
 MongoDB.prototype.hexists = async function (key, field) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+	if (typeof field !== 'string' || !field) {
+		throw new TypeError('field必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -1791,7 +1845,7 @@ MongoDB.prototype.hexists = async function (key, field) {
 		}
 		return field in item.value;
 	} catch (error) {
-		$.log.error('[MongoDB] 哈希表字段是否存在失败:', error);
+		this.logger('error', '哈希表字段是否存在失败:', error);
 		return false;
 	}
 };
@@ -1803,6 +1857,11 @@ MongoDB.prototype.hexists = async function (key, field) {
  * @return {Promise<Number>} 添加后列表长度
  */
 MongoDB.prototype.rpush = async function (key, value) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -1815,7 +1874,7 @@ MongoDB.prototype.rpush = async function (key, value) {
 		await this._add(key, list);
 		return list.length;
 	} catch (error) {
-		$.log.error('[MongoDB] 列表尾部添加失败:', error);
+		this.logger('error', '列表尾部添加失败:', error);
 		return 0;
 	}
 };
@@ -1827,6 +1886,11 @@ MongoDB.prototype.rpush = async function (key, value) {
  * @return {Promise<Number>} 添加后列表长度
  */
 MongoDB.prototype.lpush = async function (key, value) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -1839,7 +1903,7 @@ MongoDB.prototype.lpush = async function (key, value) {
 		await this._add(key, list);
 		return list.length;
 	} catch (error) {
-		$.log.error('[MongoDB] 列表头部添加失败:', error);
+		this.logger('error', '列表头部添加失败:', error);
 		return 0;
 	}
 };
@@ -1852,6 +1916,17 @@ MongoDB.prototype.lpush = async function (key, value) {
  * @return {Promise<Array>} 元素数组
  */
 MongoDB.prototype.lrange = async function (key, start, stop) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+	if (typeof start !== 'number' || isNaN(start)) {
+		throw new TypeError('start必须是有效的数字');
+	}
+	if (typeof stop !== 'number' || isNaN(stop)) {
+		throw new TypeError('stop必须是有效的数字');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -1871,7 +1946,7 @@ MongoDB.prototype.lrange = async function (key, start, stop) {
 
 		return item.value.slice(startIndex, endIndex + 1);
 	} catch (error) {
-		$.log.error('[MongoDB] 列表范围查询失败:', error);
+		this.logger('error', '列表范围查询失败:', error);
 		return [];
 	}
 };
@@ -1901,7 +1976,7 @@ MongoDB.prototype.lindex = async function (key, index) {
 
 		return item.value[realIndex];
 	} catch (error) {
-		$.log.error('[MongoDB] 获取列表索引元素失败:', error);
+		this.logger('error', '获取列表索引元素失败:', error);
 		return null;
 	}
 };
@@ -1938,7 +2013,7 @@ MongoDB.prototype.lset = async function (key, index, value) {
 		});
 		return true;
 	} catch (error) {
-		$.log.error('[MongoDB] 设置列表索引元素失败:', error);
+		this.logger('error', '设置列表索引元素失败:', error);
 		return false;
 	}
 };
@@ -1997,7 +2072,7 @@ MongoDB.prototype.lrem = async function (key, count, value) {
 
 		return removedCount;
 	} catch (error) {
-		$.log.error('[MongoDB] 删除列表元素失败:', error);
+		this.logger('error', '删除列表元素失败:', error);
 		return 0;
 	}
 };
@@ -2028,7 +2103,7 @@ MongoDB.prototype.ltrim = async function (key, start, stop) {
 		});
 		return true;
 	} catch (error) {
-		$.log.error('[MongoDB] 裁剪列表失败:', error);
+		this.logger('error', '增加整数值失败:', error);
 		return false;
 	}
 };
@@ -2039,6 +2114,11 @@ MongoDB.prototype.ltrim = async function (key, start, stop) {
  * @return {Promise<Number>} 列表长度
  */
 MongoDB.prototype.llen = async function (key) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -2049,7 +2129,7 @@ MongoDB.prototype.llen = async function (key) {
 		}
 		return item.value.length;
 	} catch (error) {
-		$.log.error('[MongoDB] 获取列表长度失败:', error);
+		this.logger('error', '获取列表长度失败:', error);
 		return 0;
 	}
 };
@@ -2061,6 +2141,14 @@ MongoDB.prototype.llen = async function (key) {
  * @return {Promise<Number>} 添加的成员数量
  */
 MongoDB.prototype.saddMulti = async function (key, members) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+	if (!Array.isArray(members)) {
+		throw new TypeError('members必须是有效的数组');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -2082,7 +2170,7 @@ MongoDB.prototype.saddMulti = async function (key, members) {
 
 		return addedCount;
 	} catch (error) {
-		$.log.error('[MongoDB] 集合并发添加失败:', error);
+		this.logger('error', '集合并发添加失败:', error);
 		return 0;
 	}
 };
@@ -2094,6 +2182,14 @@ MongoDB.prototype.saddMulti = async function (key, members) {
  * @return {Promise<Number>} 删除的成员数量
  */
 MongoDB.prototype.sremMulti = async function (key, members) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+	if (!Array.isArray(members)) {
+		throw new TypeError('members必须是有效的数组');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -2117,101 +2213,145 @@ MongoDB.prototype.sremMulti = async function (key, members) {
 
 		return removedCount;
 	} catch (error) {
-		$.log.error('[MongoDB] 集合并发删除失败:', error);
+		this.logger('error', '集合并发删除失败:', error);
 		return 0;
 	}
 };
 
 /**
  * @description Redis兼容API - 集合差集
- * @param {String} key1 第一个集合键
- * @param {String} key2 第二个集合键
+ * @param {...String} keys 集合键（至少两个）
  * @return {Promise<Array>} 差集数组
  */
-MongoDB.prototype.sdiff = async function (key1, key2) {
+MongoDB.prototype.sdiff = async function (...keys) {
+	// 参数校验
+	if (!Array.isArray(keys) || keys.length < 2) {
+		throw new TypeError('必须提供至少两个集合键');
+	}
+	for (const key of keys) {
+		if (typeof key !== 'string' || !key) {
+			throw new TypeError('所有集合键必须是有效的字符串');
+		}
+	}
+
 	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 items = await Promise.all(keys.map(key => this.findOne({ key })));
+
+		// 转换为集合数组
+		const sets = items.map(item =>
+			item && Array.isArray(item.value) ? [...new Set(item.value)] : []
+		);
+
+		// 第一个集合作为基准
+		const baseSet = sets[0];
 
-		// 创建第二个集合值的字符串表示用于快速查找
-		const set2Str = new Set(set2.map(m => JSON.stringify(m)));
+		// 创建其他所有集合的字符串表示的并集用于快速查找
+		const otherSetsStr = new Set();
+		for (let i = 1; i < sets.length; i++) {
+			sets[i].forEach(member => {
+				otherSetsStr.add(JSON.stringify(member));
+			});
+		}
 
-		// 找出在set1中但不在set2中的元素
-		return set1.filter(member => !set2Str.has(JSON.stringify(member)));
+		// 找出在baseSet中但不在其他所有集合中的元素
+		return baseSet.filter(member => !otherSetsStr.has(JSON.stringify(member)));
 	} catch (error) {
-		$.log.error('[MongoDB] 集合差集失败:', error);
+		this.logger('error', '集合差集失败:', error);
 		return [];
 	}
 };
 
 /**
  * @description Redis兼容API - 集合交集
- * @param {String} key1 第一个集合键
- * @param {String} key2 第二个集合键
+ * @param {...String} keys 集合键（至少两个）
  * @return {Promise<Array>} 交集数组
  */
-MongoDB.prototype.sinter = async function (key1, key2) {
+MongoDB.prototype.sinter = async function (...keys) {
+	// 参数校验
+	if (!Array.isArray(keys) || keys.length < 2) {
+		throw new TypeError('必须提供至少两个集合键');
+	}
+	for (const key of keys) {
+		if (typeof key !== 'string' || !key) {
+			throw new TypeError('所有集合键必须是有效的字符串');
+		}
+	}
+
 	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 items = await Promise.all(keys.map(key => this.findOne({ key })));
 
-		// 创建较小集合的字符串表示用于快速查找，优化性能
-		let smallerSet, largerSet;
-		if (set1.length <= set2.length) {
-			smallerSet = set1;
-			largerSet = set2;
-		} else {
-			smallerSet = set2;
-			largerSet = set1;
+		// 转换为集合数组
+		const sets = items.map(item =>
+			item && Array.isArray(item.value) ? [...new Set(item.value)] : []
+		);
+
+		// 如果有一个集合为空，交集就是空
+		if (sets.some(set => set.length === 0)) {
+			return [];
+		}
+
+		// 找到最小的集合作为基准
+		let smallestSet = sets[0];
+		let smallestIndex = 0;
+		for (let i = 1; i < sets.length; i++) {
+			if (sets[i].length < smallestSet.length) {
+				smallestSet = sets[i];
+				smallestIndex = i;
+			}
 		}
 
-		const largerSetStr = new Set(largerSet.map(m => JSON.stringify(m)));
+		// 创建其他集合的字符串表示用于快速查找
+		const otherSetsStr = sets.map((set, index) =>
+			index !== smallestIndex ? new Set(set.map(m => JSON.stringify(m))) : null
+		).filter(Boolean);
 
-		// 找出同时存在于两个集合中的元素
-		return smallerSet.filter(member => largerSetStr.has(JSON.stringify(member)));
+		// 找出同时存在于所有集合中的元素
+		return smallestSet.filter(member => {
+			const memberStr = JSON.stringify(member);
+			return otherSetsStr.every(set => set.has(memberStr));
+		});
 	} catch (error) {
-		$.log.error('[MongoDB] 集合并集失败:', error);
+		this.logger('error', '集合交集失败:', error);
 		return [];
 	}
 };
 
 /**
  * @description Redis兼容API - 集合并集
- * @param {String} key1 第一个集合键
- * @param {String} key2 第二个集合键
+ * @param {...String} keys 集合键（至少两个）
  * @return {Promise<Array>} 并集数组
  */
-MongoDB.prototype.sunion = async function (key1, key2) {
+MongoDB.prototype.sunion = async function (...keys) {
+	// 参数校验
+	if (!Array.isArray(keys) || keys.length < 2) {
+		throw new TypeError('必须提供至少两个集合键');
+	}
+	for (const key of keys) {
+		if (typeof key !== 'string' || !key) {
+			throw new TypeError('所有集合键必须是有效的字符串');
+		}
+	}
+
 	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 items = await Promise.all(keys.map(key => this.findOne({ key })));
+
+		// 转换为集合数组
+		const sets = items.map(item =>
+			item && Array.isArray(item.value) ? item.value : []
+		);
+
+		// 合并所有集合
+		const combined = sets.reduce((acc, set) => [...acc, ...set], []);
 
-		// 合并并去重
-		const combined = [...set1, ...set2];
 		// 使用Map进行对象去重，基于JSON字符串表示
 		const uniqueMap = new Map();
 
@@ -2224,7 +2364,7 @@ MongoDB.prototype.sunion = async function (key1, key2) {
 
 		return Array.from(uniqueMap.values());
 	} catch (error) {
-		$.log.error('[MongoDB] 集合并集失败:', error);
+		this.logger('error', '集合并集失败:', error);
 		return [];
 	}
 };
@@ -2235,6 +2375,11 @@ MongoDB.prototype.sunion = async function (key1, key2) {
  * @return {Promise<Number>} 成员数量
  */
 MongoDB.prototype.scard = async function (key) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -2248,7 +2393,7 @@ MongoDB.prototype.scard = async function (key) {
 		const uniqueItems = new Set(item.value.map(m => JSON.stringify(m)));
 		return uniqueItems.size;
 	} catch (error) {
-		$.log.error('[MongoDB] 获取集合成员数量失败:', error);
+		this.logger('error', '获取集合成员数量失败:', error);
 		return 0;
 	}
 };
@@ -2260,8 +2405,16 @@ MongoDB.prototype.scard = async function (key) {
  * @return {Promise<Boolean>} 是否是成员
  */
 MongoDB.prototype.sismember = async function (key, member) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+	if (member === undefined || member === null) {
+		throw new TypeError('member不能为undefined或null');
+	}
+
 	try {
-		this.emit('sismember_before', {
+		this.emit('sismember:before', {
 			key,
 			member
 		});
@@ -2279,19 +2432,19 @@ MongoDB.prototype.sismember = async function (key, member) {
 			result = item.value.includes(memberStr);
 		}
 
-		this.emit('sismember_after', {
+		this.emit('sismember:after', {
 			key,
 			member,
 			result
 		});
 		return result;
 	} catch (error) {
-		this.emit('sismember_error', {
+		this.emit('sismember:error', {
 			key,
 			member,
 			error
 		});
-		$.log.error('[MongoDB] 检查集合成员失败:', error);
+		this.logger('error', '检查集合成员失败:', error);
 		return false;
 	}
 };
@@ -2302,7 +2455,7 @@ MongoDB.prototype.sismember = async function (key, member) {
  */
 MongoDB.prototype.clearExpire = async function () {
 	try {
-		this.emit('clearExpire_before', {});
+		this.emit('clearExpire:before', {});
 		await this._ensureConnected();
 		// 删除所有已过期的数据
 		const result = await this.delete({
@@ -2311,15 +2464,15 @@ MongoDB.prototype.clearExpire = async function () {
 				$lt: new Date()
 			}
 		});
-		this.emit('clearExpire_after', {
+		this.emit('clearExpire:after', {
 			result: true
 		});
 		return true;
 	} catch (error) {
-		this.emit('clearExpire_error', {
+		this.emit('clearExpire:error', {
 			error
 		});
-		$.log.error('[MongoDB] 清空过期数据失败:', error);
+		this.logger('error', '清空过期数据失败:', error);
 		return false;
 	}
 };
@@ -2345,7 +2498,7 @@ MongoDB.prototype.mget = async function (...keys) {
 		// 返回与输入键顺序对应的数组，不存在的键对应位置返回undefined
 		return keyArray.map(key => resultMap.hasOwnProperty(key) ? resultMap[key] : undefined);
 	} catch (error) {
-		$.log.error('[MongoDB] 批量获取失败:', error);
+		this.logger('error', '批量获取失败:', error);
 		throw error;
 	}
 };
@@ -2363,11 +2516,11 @@ MongoDB.prototype.mset = async function (keyValues, seconds = 0) {
 			seconds,
 			cancel: false
 		};
-		this.emit('mset_before', beforeEventData);
+		this.emit('mset:before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回false
 		if (beforeEventData.cancel) {
-			$.log.debug('[MongoDB] mset操作被事件处理器取消');
+			this.logger('debug', 'mset操作被事件处理器取消');
 			return false;
 		}
 
@@ -2379,7 +2532,7 @@ MongoDB.prototype.mset = async function (keyValues, seconds = 0) {
 
 		// 参数验证，确保keyValues是对象且不为null
 		if (typeof finalData !== 'object' || finalData === null || Array.isArray(finalData)) {
-			$.log.warn('[MongoDB] mset: 参数必须是非空对象');
+			this.logger('warn', 'mset: 参数必须是非空对象');
 			return false;
 		}
 
@@ -2389,7 +2542,7 @@ MongoDB.prototype.mset = async function (keyValues, seconds = 0) {
 		}
 
 		// 触发后置事件
-		this.emit('mset_after', {
+		this.emit('mset:after', {
 			keyValues: finalData,
 			seconds: finalSeconds,
 			result: true
@@ -2397,12 +2550,12 @@ MongoDB.prototype.mset = async function (keyValues, seconds = 0) {
 		return true;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('mset_error', {
+		this.emit('mset:error', {
 			keyValues,
 			seconds,
 			error
 		});
-		$.log.error('[MongoDB] 批量设置失败:', error);
+		this.logger('error', '批量设置失败:', error);
 		return false;
 	}
 };
@@ -2415,6 +2568,14 @@ MongoDB.prototype.mset = async function (keyValues, seconds = 0) {
  * @return {Promise<Boolean>} 是否成功
  */
 MongoDB.prototype.zadd = async function (key, score, member) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+	if (typeof score !== 'number' || isNaN(score)) {
+		throw new TypeError('score必须是有效的数字');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -2440,7 +2601,7 @@ MongoDB.prototype.zadd = async function (key, score, member) {
 		await this._add(key, sortedSet);
 		return true;
 	} catch (error) {
-		$.log.error('[MongoDB] 有序集合添加成员失败:', error);
+		this.logger('error', '增加浮点数值失败:', error);
 		return false;
 	}
 };
@@ -2453,6 +2614,17 @@ MongoDB.prototype.zadd = async function (key, score, member) {
  * @return {Promise<Array>} 成员数组
  */
 MongoDB.prototype.zrangebyscore = async function (key, min, max) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+	if (typeof min !== 'number' || isNaN(min)) {
+		throw new TypeError('min必须是有效的数字');
+	}
+	if (typeof max !== 'number' || isNaN(max)) {
+		throw new TypeError('max必须是有效的数字');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -2467,7 +2639,7 @@ MongoDB.prototype.zrangebyscore = async function (key, min, max) {
 			.filter(item => item.score >= min && item.score <= max)
 			.map(item => item.member);
 	} catch (error) {
-		$.log.error('[MongoDB] 有序集合范围查询失败:', error);
+		this.logger('error', '有序集合范围查询失败:', error);
 		return [];
 	}
 };
@@ -2478,6 +2650,11 @@ MongoDB.prototype.zrangebyscore = async function (key, min, max) {
  * @return {Promise<Number>} 成员数量
  */
 MongoDB.prototype.zcard = async function (key) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -2488,7 +2665,7 @@ MongoDB.prototype.zcard = async function (key) {
 		}
 		return item.value.length;
 	} catch (error) {
-		$.log.error('[MongoDB] 有序集合成员数量失败:', error);
+		this.logger('error', '有序集合成员数量失败:', error);
 		return 0;
 	}
 };
@@ -2500,6 +2677,11 @@ MongoDB.prototype.zcard = async function (key) {
  * @return {Promise<Number>} 删除的成员数量
  */
 MongoDB.prototype.zrem = async function (key, member) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -2519,7 +2701,7 @@ MongoDB.prototype.zrem = async function (key, member) {
 
 		return removedCount;
 	} catch (error) {
-		$.log.error('[MongoDB] 有序集合删除成员失败:', error);
+		this.logger('error', '有序集合删除成员失败:', error);
 		return 0;
 	}
 };
@@ -2531,6 +2713,11 @@ MongoDB.prototype.zrem = async function (key, member) {
  * @return {Promise<Number|null>} 分数
  */
 MongoDB.prototype.zscore = async function (key, member) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -2544,7 +2731,7 @@ MongoDB.prototype.zscore = async function (key, member) {
 		const found = item.value.find(item => JSON.stringify(item.member) === memberStr);
 		return found ? found.score : null;
 	} catch (error) {
-		$.log.error('[MongoDB] 获取成员分数失败:', error);
+		this.logger('error', '获取成员分数失败:', error);
 		return null;
 	}
 };
@@ -2555,6 +2742,11 @@ MongoDB.prototype.zscore = async function (key, member) {
  * @return {Promise<any|null>} 弹出的元素
  */
 MongoDB.prototype.lpop = async function (key) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -2572,7 +2764,7 @@ MongoDB.prototype.lpop = async function (key) {
 		});
 		return popped;
 	} catch (error) {
-		$.log.error('[MongoDB] 列表弹出头部元素失败:', error);
+		this.logger('error', '列表弹出头部元素失败:', error);
 		return null;
 	}
 };
@@ -2583,6 +2775,11 @@ MongoDB.prototype.lpop = async function (key) {
  * @return {Promise<any|null>} 弹出的元素
  */
 MongoDB.prototype.rpop = async function (key) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -2600,7 +2797,7 @@ MongoDB.prototype.rpop = async function (key) {
 		});
 		return popped;
 	} catch (error) {
-		$.log.error('[MongoDB] 列表弹出尾部元素失败:', error);
+		this.logger('error', '列表弹出尾部元素失败:', error);
 		return null;
 	}
 };
@@ -2611,6 +2808,11 @@ MongoDB.prototype.rpop = async function (key) {
  * @return {Promise<Array>} 成员数组
  */
 MongoDB.prototype.smembers = async function (key) {
+	// 参数校验
+	if (typeof key !== 'string' || !key) {
+		throw new TypeError('key必须是有效的字符串');
+	}
+
 	try {
 		await this._ensureConnected();
 		const item = await this.findOne({
@@ -2630,7 +2832,7 @@ MongoDB.prototype.smembers = async function (key) {
 		});
 		return Array.from(uniqueMap.values());
 	} catch (error) {
-		$.log.error('[MongoDB] 获取集合所有成员失败:', error);
+		this.logger('error', '获取集合所有成员失败:', error);
 		return [];
 	}
 };
@@ -2651,7 +2853,7 @@ MongoDB.prototype.findOne = async function (query, options = {}) {
 		// 不需要额外的sanitize，MongoDB驱动会处理
 		return await this.db.collection(this.table).findOne(query, options);
 	} catch (error) {
-		$.log.error('[MongoDB] 查询单条数据失败:', error);
+		this.logger('error', '查询单条数据失败:', error);
 		return null;
 	}
 };
@@ -2661,11 +2863,31 @@ MongoDB.prototype.findOne = async function (query, options = {}) {
  */
 MongoDB.prototype.setUrl = function () {
 	var url = "mongodb://";
+	if (this.config.user) {
+		url += encodeURIComponent(this.config.user);
+	}
 	if (this.config.password) {
-		url += encodeURIComponent(this.config.user) + ':' + encodeURIComponent(this.config.password) + '@';
+		url += ':' + encodeURIComponent(this.config.password)
+	}
+	if (this.config.user || this.config.password) {
+		url += '@'
 	}
 	url += this.config.host + ":" + this.config.port + "/";
-	this.url = url;
+	url += this.config.database;
+	
+	// 添加连接参数到连接字符串
+	var params = [];
+	if (this.config.min_pool_size) params.push('minPoolSize=' + this.config.min_pool_size);
+	if (this.config.max_pool_size) params.push('maxPoolSize=' + this.config.max_pool_size);
+	if (this.config.connect_timeout_ms) params.push('connectTimeoutMS=' + this.config.connect_timeout_ms);
+	if (this.config.server_selection_timeout_ms) params.push('serverSelectionTimeoutMS=' + this.config.server_selection_timeout_ms);
+	if (this.config.retry_writes !== undefined) params.push('retryWrites=' + (this.config.retry_writes ? 'true' : 'false'));
+	
+	if (params.length > 0) {
+		url += '?' + params.join('&');
+	}
+	
+	return url;
 };
 
 /**
@@ -2673,34 +2895,32 @@ MongoDB.prototype.setUrl = function () {
  * @return {Promise<Boolean>} 连接成功返回true, 失败抛出错误
  */
 MongoDB.prototype.open = async function () {
-	if (!this.url) {
-		this.setUrl();
-	}
+
 	if (!this.conn) {
 		return await this._withRetry(async () => {
 			try {
-				this.conn = await MongoClient.connect(this.url, this.config.options);
+				// 新版本MongoDB驱动只接受连接字符串，不再支持配置对象
+				this.conn = await MongoClient.connect(this.setUrl());
 				this.db = this.conn.db(this.config.database);
 				this.connected = true;
 
 				// 设置连接事件监听
 				this.conn.on('error', (err) => {
-					$.log.error('[MongoDB] 连接错误:', err);
+					this.logger('error', '连接错误:', err);
 					this.connected = false;
 				});
 
 				this.conn.on('close', () => {
-					$.log.warn('[MongoDB] 连接已关闭');
+					this.logger('warn', '连接已关闭');
 					this.connected = false;
 				});
 
-				$.log.info(
-					`[MongoDB] 成功连接到 ${this.config.host}:${this.config.port}/${this.config.database}`
+				this.logger('info',
+					`成功连接到 ${this.config.host}:${this.config.port}/${this.config.database}`
 				);
 				return true;
 			} catch (error) {
-				$.log.error('[MongoDB] MongoDB连接失败:', error);
-				throw error;
+				this.logger('error', 'MongoDB连接失败:', error);
 			}
 		}, '数据库连接');
 	}
@@ -2712,8 +2932,8 @@ MongoDB.prototype.open = async function () {
  */
 MongoDB.prototype.close = async function () {
 	if (this.conn) {
-		$.log.info(`[MongoDB] 关闭连接`);
-		await this.conn.close().catch(err => $.log.error('[MongoDB] 关闭MongoDB连接时出错:', err));
+		this.logger('info', `关闭连接`);
+		await this.conn.close().catch(err => this.logger('error', '关闭MongoDB连接时出错:', err));
 		this.conn = null;
 		this.db = null;
 		this.connected = false;
@@ -2726,6 +2946,11 @@ MongoDB.prototype.close = async function () {
  * @return {Promise|Object} 执行结果
  */
 MongoDB.prototype.addTable = async function (table) {
+	// 参数校验
+	if (typeof table !== 'string' || !table) {
+		throw new TypeError('table必须是有效的字符串');
+	}
+
 	await this._ensureConnected();
 	if (table) {
 		this.table = table;
@@ -2742,19 +2967,24 @@ MongoDB.prototype.addTable = async function (table) {
  * @returns {Promise<Object>} 创建索引的结果
  */
 MongoDB.prototype.createIndex = async function (keys, options = {}) {
+	// 参数校验
+	if (typeof keys !== 'object' || keys === null || Array.isArray(keys)) {
+		throw new TypeError('keys必须是非空对象');
+	}
+
 	await this._ensureConnected();
 	try {
 		if (!this.db || !this.table) {
 			throw new Error('数据库未连接或未指定表名');
 		}
 
-		$.log.info(
-			`[MongoDB] 创建索引: ${this.table}, keys: ${JSON.stringify(keys)}, options: ${JSON.stringify(options)}`
+		this.logger('info',
+			`创建索引: ${this.table}, keys: ${JSON.stringify(keys)}, options: ${JSON.stringify(options)}`
 		);
 
 		return await this.db.collection(this.table).createIndex(keys, options);
 	} catch (error) {
-		$.log.error(`[MongoDB] 创建索引失败: ${error.message}`);
+		this.logger('error', `创建索引失败: ${error.message}`);
 		throw error;
 	}
 };
@@ -2766,6 +2996,14 @@ MongoDB.prototype.createIndex = async function (keys, options = {}) {
  * @returns {Promise<Object>} 创建索引的结果
  */
 MongoDB.prototype.createTTLIndex = async function (keys, expireAfterSeconds) {
+	// 参数校验
+	if (typeof keys !== 'object' || keys === null || Array.isArray(keys)) {
+		throw new TypeError('keys必须是非空对象');
+	}
+	if (typeof expireAfterSeconds !== 'number' || expireAfterSeconds < 0) {
+		throw new TypeError('expireAfterSeconds必须是非负数');
+	}
+
 	await this._ensureConnected();
 	try {
 		if (!this.db || !this.table) {
@@ -2777,12 +3015,12 @@ MongoDB.prototype.createTTLIndex = async function (keys, expireAfterSeconds) {
 			expireAfterSeconds: expireAfterSeconds
 		};
 
-		$.log.info(
-			`[MongoDB] 创建TTL索引: ${this.table}, keys: ${JSON.stringify(keys)}, 过期时间: ${expireAfterSeconds}秒`);
+		this.logger('info',
+			`创建TTL索引: ${this.table}, keys: ${JSON.stringify(keys)}, 过期时间: ${expireAfterSeconds}秒`);
 
 		return await this.db.collection(this.table).createIndex(keys, options);
 	} catch (error) {
-		$.log.error(`[MongoDB] 创建TTL索引失败: ${error.message}`);
+		this.logger('error', `创建TTL索引失败: ${error.message}`);
 		throw error;
 	}
 };
@@ -2794,16 +3032,16 @@ MongoDB.prototype.createTTLIndex = async function (keys, expireAfterSeconds) {
 MongoDB.prototype.getIndexes = async function () {
 	await this._ensureConnected();
 	try {
-		if (!this.table) {
-			throw new Error('未指定表名');
-		}
+			if (!this.table) {
+				throw new Error('未指定表名');
+			}
 
-		$.log.info(`[MongoDB] 获取索引: ${this.table}`);
-		return await this.db.collection(this.table).indexes();
-	} catch (error) {
-		$.log.error(`[MongoDB] [getIndexes] 获取索引失败: ${error.message}`);
-		return [];
-	}
+			this.logger('info', `获取索引: ${this.table}`);
+			return await this.db.collection(this.table).indexes();
+		} catch (error) {
+			this.logger('error', `[getIndexes] 获取索引失败: ${error.message}`);
+			return [];
+		}
 };
 
 /**
@@ -2814,17 +3052,17 @@ MongoDB.prototype.getIndexes = async function () {
 MongoDB.prototype.dropIndex = async function (indexName) {
 	await this._ensureConnected();
 	if (!this.table) {
-		throw new Error('未指定表名');
+		throw new TypeError('未指定表名');
 	}
 	if (!indexName) {
-		throw new Error('索引名称不能为空');
+		throw new TypeError('索引名称不能为空');
 	}
 	try {
-		$.log.info(`[MongoDB] [dropIndex] 删除索引: ${this.table}, 索引名: ${indexName}`);
+		this.logger('info', `[dropIndex] 删除索引: ${this.table}, 索引名: ${indexName}`);
 		await this.db.collection(this.table).dropIndex(indexName);
 		return true;
 	} catch (error) {
-		$.log.error(`[MongoDB] [dropIndex] 删除索引失败: ${error.message}`);
+		this.logger('error', `[dropIndex] 删除索引失败: ${error.message}`);
 		throw error;
 	}
 };
@@ -2839,11 +3077,11 @@ MongoDB.prototype.dropTable = async function () {
 		throw new Error('未指定表名');
 	}
 	try {
-		$.log.info(`[MongoDB] [dropTable] 删除集合: ${this.table}`);
+		this.logger('info', `[dropTable] 删除集合: ${this.table}`);
 		await this.db.collection(this.table).drop();
 		return true;
 	} catch (error) {
-		$.log.error(`[MongoDB] [dropTable] 删除集合失败: ${error.message}`);
+		this.logger('error', `[dropTable] 删除集合失败: ${error.message}`);
 		throw error;
 	}
 };
@@ -2857,7 +3095,7 @@ MongoDB.prototype.addObj = async function (obj) {
 	await this._ensureConnected();
 	try {
 		// 触发前置事件
-		this.emit('addObj_before', {
+		this.emit('addObj:before', {
 			table: this.table,
 			data: obj
 		});
@@ -2866,7 +3104,7 @@ MongoDB.prototype.addObj = async function (obj) {
 		const result = await this.db.collection(this.table).insertOne(obj);
 
 		// 触发后置事件
-		this.emit('addObj_after', {
+		this.emit('addObj:after', {
 			table: this.table,
 			data: obj,
 			result
@@ -2875,7 +3113,7 @@ MongoDB.prototype.addObj = async function (obj) {
 		return result;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('addObj_error', {
+		this.emit('addObj:error', {
 			table: this.table,
 			data: obj,
 			error
@@ -2902,7 +3140,7 @@ MongoDB.prototype.get = async function (key) {
 		});
 		return result ? result.value : null;
 	} catch (error) {
-		$.log.error(`[MongoDB] 获取键值失败: ${error.message}`);
+		this.logger('error', `获取键值失败: ${error.message}`);
 		return null;
 	}
 };
@@ -2923,7 +3161,7 @@ MongoDB.prototype.setForList = async function (key, array, seconds = 0) {
 
 		// 确保array是数组类型
 		if (!Array.isArray(array)) {
-			throw new Error('value必须是数组类型');
+			throw new TypeError('value必须是数组类型');
 		}
 
 		// 触发前置事件，允许修改或阻止操作
@@ -2933,10 +3171,10 @@ MongoDB.prototype.setForList = async function (key, array, seconds = 0) {
 			ttl: seconds,
 			cancel: false
 		};
-		this.emit('setForList_before', beforeEventData);
+		this.emit('setForList:before', beforeEventData);
 
 		if (beforeEventData.cancel) {
-			$.log.debug(`[MongoDB] [setForList] setForList操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `[setForList] setForList操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -2954,7 +3192,7 @@ MongoDB.prototype.setForList = async function (key, array, seconds = 0) {
 		const length = finalValue.length;
 
 		// 触发后置事件
-		this.emit('setForList_after', {
+		this.emit('setForList:after', {
 			key: finalKey,
 			value: finalValue,
 			ttl: finalSeconds,
@@ -2963,12 +3201,12 @@ MongoDB.prototype.setForList = async function (key, array, seconds = 0) {
 		});
 		return length;
 	} catch (error) {
-		this.emit('setForList_error', {
+		this.emit('setForList:error', {
 			key,
 			value: array,
 			error
 		});
-		$.log.error(`[MongoDB] [setForList] setForList操作失败: ${error.message}`);
+		this.logger('error', `[setForList] setForList操作失败: ${error.message}`);
 		return 0;
 	}
 };
@@ -2994,10 +3232,10 @@ MongoDB.prototype.addForList = async function (key, value, seconds = 0) {
 			ttl: seconds,
 			cancel: false
 		};
-		this.emit('addForList_before', beforeEventData);
+		this.emit('addForList:before', beforeEventData);
 
 		if (beforeEventData.cancel) {
-			$.log.debug(`[MongoDB] addForList操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `addForList操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -3024,7 +3262,7 @@ MongoDB.prototype.addForList = async function (key, value, seconds = 0) {
 		const length = currentArray.length;
 
 		// 触发后置事件
-		this.emit('addForList_after', {
+		this.emit('addForList:after', {
 			key: finalKey,
 			value: finalValue,
 			ttl: finalSeconds,
@@ -3033,12 +3271,12 @@ MongoDB.prototype.addForList = async function (key, value, seconds = 0) {
 		});
 		return length;
 	} catch (error) {
-		this.emit('addForList_error', {
+		this.emit('addForList:error', {
 			key,
 			value,
 			error
 		});
-		$.log.error(`[MongoDB] addForList操作失败: ${error.message}`);
+		this.logger('error', `addForList操作失败: ${error.message}`);
 		return 0;
 	}
 };
@@ -3071,7 +3309,7 @@ MongoDB.prototype.hasForList = async function (key, value) {
 		const valueStr = JSON.stringify(value);
 		return array.some(item => JSON.stringify(item) === valueStr);
 	} catch (error) {
-		$.log.error(`[MongoDB] hasForList操作失败: ${error.message}`);
+		this.logger('error', `hasForList操作失败: ${error.message}`);
 		return false;
 	}
 };
@@ -3109,7 +3347,7 @@ MongoDB.prototype.getForList = async function (key, start = 0, stop = -1) {
 
 		return result;
 	} catch (error) {
-		$.log.error(`[MongoDB] getForList操作失败: ${error.message}`);
+		this.logger('error', `getForList操作失败: ${error.message}`);
 		return [];
 	}
 };
@@ -3132,7 +3370,7 @@ MongoDB.prototype.clearForList = async function (key) {
 		// 使用set方法直接设置为空数组，与其他模块行为一致
 		return await this.set(key, []);
 	} catch (error) {
-		$.log.error(`[MongoDB] clearForList操作失败: ${error.message}`);
+		this.logger('error', `clearForList操作失败: ${error.message}`);
 		return false;
 	}
 };
@@ -3144,7 +3382,7 @@ MongoDB.prototype.has = async function (key) {
 		const exists = await this.exists(key);
 		return exists > 0;
 	} catch (error) {
-		$.log.error(`[MongoDB] 检查键是否存在失败: ${error.message}`);
+		this.logger('error', `检查键是否存在失败: ${error.message}`);
 		throw error;
 	}
 };
@@ -3152,6 +3390,11 @@ MongoDB.prototype.has = async function (key) {
 MongoDB.prototype.exists = async function (key) {
 	await this._ensureConnected();
 	try {
+		// 参数验证
+		if (!key) {
+			throw new TypeError('key必须是非空字符串或非空字符串数组');
+		}
+
 		// 检查单个键的情况
 		if (typeof key === 'string') {
 			const result = await this.db.collection(this.table).findOne({
@@ -3168,7 +3411,7 @@ MongoDB.prototype.exists = async function (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');
+					throw new TypeError('key数组中的每个元素必须是非空字符串');
 				}
 			}
 
@@ -3180,10 +3423,10 @@ MongoDB.prototype.exists = async function (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');
+			throw new TypeError('key必须是非空字符串或非空字符串数组');
 		}
 	} catch (error) {
-		$.log.error(`[MongoDB] 检查键是否存在失败: ${error.message}`);
+		this.logger('error', `检查键是否存在失败: ${error.message}`);
 		throw error;
 	}
 };
@@ -3194,44 +3437,41 @@ MongoDB.prototype.exists = async function (key) {
  * @return {Promise<Boolean>} 是否删除成功
  */
 MongoDB.prototype.del = async function (key) {
-	await this._ensureConnected();
-	try {
-		// 键名必须是非空字符串或非空字符串数组
-		if (!key) {
-			$.log.error('[MongoDB] 参数错误: key必须是非空字符串或非空字符串数组');
-			return false;
-		}
+	// 参数验证
+	if (!key) {
+		throw new TypeError('key必须是非空字符串或非空字符串数组');
+	}
 
-		// 如果是单个键，验证是否为非空字符串
-		if (typeof key === 'string') {
-			if (!key) {
-				$.log.error('[MongoDB] 参数错误: key必须是非空字符串');
-				return false;
-			}
+	// 如果是单个键，验证是否为非空字符串
+	if (typeof key === 'string') {
+		if (!key) {
+			throw new TypeError('key必须是非空字符串');
 		}
-		// 如果是数组，验证每个元素是否为非空字符串
-		else if (Array.isArray(key)) {
-			for (const k of key) {
-				if (!k || typeof k !== 'string') {
-					$.log.error('[MongoDB] 参数错误: key必须是非空字符串或非空字符串数组');
-					return false;
-				}
+	}
+	// 如果是数组，验证每个元素是否为非空字符串
+	else if (Array.isArray(key)) {
+		for (const k of key) {
+			if (!k || typeof k !== 'string') {
+				throw new TypeError('key必须是非空字符串或非空字符串数组');
 			}
-		} else {
-			$.log.error('[MongoDB] 参数错误: key必须是非空字符串或非空字符串数组');
-			return false;
 		}
+	} else {
+		throw new TypeError('key必须是非空字符串或非空字符串数组');
+	}
+
+	await this._ensureConnected();
+	try {
 
 		// 触发前置事件，允许修改或阻止操作
 		const beforeEventData = {
 			key,
 			cancel: false
 		};
-		this.emit('del_before', beforeEventData);
+		this.emit('del:before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回false
 		if (beforeEventData.cancel) {
-			$.log.debug(`[MongoDB] del操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `del操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -3268,7 +3508,7 @@ MongoDB.prototype.del = async function (key) {
 		}
 
 		// 触发后置事件
-		this.emit('del_after', {
+		this.emit('del:after', {
 			key: finalKey,
 			success,
 			deleted
@@ -3277,11 +3517,11 @@ MongoDB.prototype.del = async function (key) {
 		return success;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('del_error', {
+		this.emit('del:error', {
 			key,
 			error: error
 		});
-		$.log.error('[MongoDB] 删除缓存失败:', error);
+		this.logger('error', '删除缓存失败:', error);
 		return false;
 	}
 };
@@ -3303,11 +3543,11 @@ MongoDB.prototype.add = async function (key, value, seconds) {
 			ttl: seconds,
 			cancel: false
 		};
-		this.emit('add_before', beforeEventData);
+		this.emit('add:before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回false
 		if (beforeEventData.cancel) {
-			$.log.debug(`[MongoDB] add操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `add操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -3324,7 +3564,7 @@ MongoDB.prototype.add = async function (key, value, seconds) {
 		});
 		if (exists) {
 			// 键已存在时触发后置事件，但返回false
-			this.emit('add_after', {
+			this.emit('add:after', {
 				key: finalKey,
 				value: finalValue,
 				ttl: finalSeconds,
@@ -3349,7 +3589,7 @@ MongoDB.prototype.add = async function (key, value, seconds) {
 		const success = result.acknowledged;
 
 		// 触发后置事件
-		this.emit('add_after', {
+		this.emit('add:after', {
 			key: finalKey,
 			value: finalValue,
 			ttl: finalSeconds,
@@ -3359,13 +3599,13 @@ MongoDB.prototype.add = async function (key, value, seconds) {
 		return success;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('add_error', {
+		this.emit('add:error', {
 			key,
 			value,
 			ttl: seconds,
 			error
 		});
-		$.log.error(`[MongoDB] 添加键值失败: ${error.message}`);
+		this.logger('error', `添加键值失败: ${error.message}`);
 		return false;
 	}
 };
@@ -3381,7 +3621,7 @@ MongoDB.prototype.set = async function (key, value, seconds) {
 	try {
 		// 键名必须是非空字符串
 		if (!key || typeof key !== 'string') {
-			$.log.error('[MongoDB] 参数错误: key必须是非空字符串');
+			this.logger('error', '参数错误: key必须是非空字符串');
 			return false;
 		}
 
@@ -3392,11 +3632,11 @@ MongoDB.prototype.set = async function (key, value, seconds) {
 			ttl: seconds,
 			cancel: false
 		};
-		this.emit('set_before', beforeEventData);
+		this.emit('set:before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回false
 		if (beforeEventData.cancel) {
-			$.log.debug(`[MongoDB] set操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `set操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -3435,7 +3675,7 @@ MongoDB.prototype.set = async function (key, value, seconds) {
 		);
 
 		// 触发后置事件
-		this.emit('set_after', {
+		this.emit('set:after', {
 			key: finalKey,
 			value: finalValue,
 			ttl: finalSeconds,
@@ -3445,13 +3685,13 @@ MongoDB.prototype.set = async function (key, value, seconds) {
 		return result.acknowledged;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('set_error', {
+		this.emit('set:error', {
 			key,
 			value,
 			ttl: seconds,
 			error
 		});
-		$.log.error(`[MongoDB] 设置键值失败: ${error.message}`);
+		this.logger('error', `设置键值失败: ${error.message}`);
 		return false;
 	}
 };
@@ -3465,7 +3705,7 @@ MongoDB.prototype.addList = async function (list) {
 	await this._ensureConnected();
 	try {
 		// 触发前置事件
-		this.emit('addList_before', {
+		this.emit('addList:before', {
 			table: this.table,
 			data: list
 		});
@@ -3474,7 +3714,7 @@ MongoDB.prototype.addList = async function (list) {
 		const result = await this.db.collection(this.table).insertMany(list);
 
 		// 触发后置事件
-		this.emit('addList_after', {
+		this.emit('addList:after', {
 			table: this.table,
 			data: list,
 			result
@@ -3483,7 +3723,7 @@ MongoDB.prototype.addList = async function (list) {
 		return result;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('addList_error', {
+		this.emit('addList:error', {
 			table: this.table,
 			data: list,
 			error
@@ -3506,7 +3746,7 @@ MongoDB.prototype.delete = async function (query) {
 		} : query;
 
 		// 触发前置事件
-		this.emit('delete_before', {
+		this.emit('delete:before', {
 			table: this.table,
 			query: safeQuery
 		});
@@ -3515,7 +3755,7 @@ MongoDB.prototype.delete = async function (query) {
 		const result = await this.db.collection(this.table).deleteMany(safeQuery);
 
 		// 触发后置事件
-		this.emit('delete_after', {
+		this.emit('delete:after', {
 			table: this.table,
 			query: safeQuery,
 			result
@@ -3524,7 +3764,7 @@ MongoDB.prototype.delete = async function (query) {
 		return result;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('delete_error', {
+		this.emit('delete:error', {
 			table: this.table,
 			query,
 			error
@@ -3571,7 +3811,7 @@ MongoDB.prototype.setting = async function (query, body, options = {}) {
 		}, options);
 
 		// 触发前置事件
-		this.emit('setting_before', {
+		this.emit('setting:before', {
 			table: this.table,
 			query: safeQuery,
 			update: updateBody,
@@ -3582,7 +3822,7 @@ MongoDB.prototype.setting = async function (query, body, options = {}) {
 		const result = await this.db.collection(this.table).updateMany(safeQuery, updateBody, updateOptions);
 
 		// 触发后置事件
-		this.emit('setting_after', {
+		this.emit('setting:after', {
 			table: this.table,
 			query: safeQuery,
 			update: updateBody,
@@ -3594,7 +3834,7 @@ MongoDB.prototype.setting = async function (query, body, options = {}) {
 		return typeof query === 'string' ? result.modifiedCount > 0 : result;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('setting_error', {
+		this.emit('setting:error', {
 			table: this.table,
 			query,
 			update: body,
@@ -3621,7 +3861,7 @@ MongoDB.prototype.find = async function (query, options = {}) {
 		const cursor = this.db.collection(this.table).find(safeQuery, options);
 		return await cursor.toArray();
 	} catch (error) {
-		$.log.error('[MongoDB] 查询失败:', error);
+		this.logger('error', '查询失败:', error);
 		return [];
 	}
 };
@@ -3638,7 +3878,7 @@ MongoDB.prototype.count = async function (query = {}) {
 		const safeQuery = this._sanitizeQuery(query);
 		return await this.db.collection(this.table).countDocuments(safeQuery);
 	} catch (error) {
-		$.log.error('[MongoDB] 计算文档数量失败:', error);
+		this.logger('error', '计算文档数量失败:', error);
 		return 0;
 	}
 };
@@ -3657,7 +3897,7 @@ MongoDB.prototype._sanitizeQuery = function (query) {
 		// 防止NoSQL注入，如 {$ne: null} 等操作符注入
 		if (key.startsWith('$') && typeof key === 'string' && !Array.isArray(value) && typeof value === 'object' &&
 			value !== null) {
-			$.log.warn('[MongoDB] 检测到可能的操作符注入尝试:', key);
+			this.logger('warn', '检测到可能的操作符注入尝试:', key);
 			continue;
 		}
 		sanitized[key] = value;
@@ -3677,7 +3917,7 @@ MongoDB.prototype.startTransaction = async function () {
 		session.startTransaction();
 		return session;
 	} catch (error) {
-		$.log.error('[MongoDB] [startTransaction] 启动事务失败:', error);
+		this.logger('error', '[startTransaction] 启动事务失败:', error);
 		throw error;
 	}
 };
@@ -3692,7 +3932,7 @@ MongoDB.prototype.commitTransaction = async function (session) {
 		await session.commitTransaction();
 		await session.endSession();
 	} catch (error) {
-		$.log.error('[MongoDB] [commitTransaction] 提交事务失败:', error);
+		this.logger('error', '[commitTransaction] 提交事务失败:', error);
 		throw error;
 	}
 };
@@ -3707,7 +3947,7 @@ MongoDB.prototype.rollbackTransaction = async function (session) {
 		await session.abortTransaction();
 		await session.endSession();
 	} catch (error) {
-		$.log.error('[MongoDB] [rollbackTransaction] 回滚事务失败:', error);
+		this.logger('error', '[rollbackTransaction] 回滚事务失败:', error);
 		throw error;
 	}
 };