mm_mongodb 1.4.4 → 1.4.6

package/index.js

@@ -1,15 +1,23 @@
 /**
- * @fileOverview mongoDB帮助类函数
+ * @fileOverview MongoDB帮助类函数
  * @author <a href="http://qww.elins.cn">邱文武</a>
  * @version 1.2.1
  */
-require('mm_expand');
+const eventEmitter = require('events');
+require('mm_logs');
 const MongoClient = require('mongodb').MongoClient;
 
+/**
+ * 确保全局$对象存在
+ */
+if (!global.$) {
+	global.$ = {};
+}
+
 /**
  * @description MongoDB帮助类
  */
-class MongoDB {
+class MongoDB extends eventEmitter {
 	/**
 	 * @description 创建MongoDB帮助类函数 (构造函数)
 	 * @param {String} scope 作用域
@@ -17,18 +25,15 @@ class MongoDB {
 	 * @constructor
 	 */
 	constructor(scope, dir, config) {
+		super();
 		// 作用域
-		this.scope;
-		if (scope) {
-			this.scope = scope;
-		} else {
-			this.scope = $.val.scope + '';
-		}
+		this.scope = scope || ($.val && $.val.scope ? String($.val.scope) : 'default');
 		// 当前目录
-		this.dir = __dirname;
-		if (dir) {
-			this.dir = dir;
-		}
+		this.dir = dir || __dirname;
+
+		// 从环境变量加载配置
+		const envConfig = this._loadEnvConfig();
+
 		this.config = Object.assign({
 			// 服务器地址
 			host: "localhost",
@@ -40,25 +45,36 @@ class MongoDB {
 			user: "admin",
 			// 密码
 			password: "",
-			// 附加选项
+			// 连接选项
 			options: {
-				// 使用新的url分析器
-				useNewUrlParser: true,
-				// 自动重连接
-				// auto_reconnect: true,
-				// 使用统一拓扑
-				useUnifiedTopology: true,
-				// useCreateIndex: true,
-				// 连接池数
-				// poolSize: 10
-			}
-		}, config);
+				// 移除已废弃的选项
+				// 使用MongoDB驱动推荐的配置
+				// 连接池配置
+				minPoolSize: 5,
+				maxPoolSize: 20,
+				// 连接超时时间
+				connectTimeoutMS: 10000,
+				// 服务器选择超时
+				serverSelectionTimeoutMS: 5000,
+				// 重试策略
+				retryWrites: true
+			},
+			// 重试配置
+			retry: {
+				maxAttempts: 3,
+				delayMS: 1000
+			}
+		}, envConfig, config);
+
+		// 验证配置
+		this._validateConfig();
+
 		// 连接地址
-		this.url;
+		this.url = null;
 		// 数据库连接器
-		this.conn;
+		this.conn = null;
 		// 操作的数据库
-		this.db;
+		this.db = null;
 		// 表名
 		this.table = "cache";
 		/**
@@ -69,6 +85,1207 @@ class MongoDB {
 		 * 每页显示条数
 		 */
 		this.size = 0;
+		// 连接状态
+		this.connected = false;
+	}
+
+	/**
+	 * @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;
+	}
+
+	/**
+	 * @private
+	 * @description 验证配置有效性
+	 * @throws {Error} 配置无效时抛出错误
+	 */
+	_validateConfig() {
+		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 (!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;
+
+		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));
+				}
+			}
+		}
+
+		// 所有重试都失败，抛出最后一个错误
+		throw lastError;
+	}
+	
+	/**
+	 * @description Redis兼容API - 获取缓存值
+	 * @param {String} key 键名
+	 * @return {Promise<any>} 缓存值
+	 */
+	async get(key) {
+		try {
+			const result = await this.findOne({ key: key });
+			return result ? result.value : null;
+		} catch (error) {
+			$.log.error('[MongoDB] 获取缓存失败:', error);
+			return null;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 清空所有缓存
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async clear() {
+		try {
+			await this.del({});
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 清空缓存失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 获取所有键
+	 * @param {String} pattern 匹配模式
+	 * @return {Promise<Array>} 键名数组
+	 */
+	async keys(pattern = '*') {
+		try {
+			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 {Number} seconds 过期时间（秒）
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async ttl(key, seconds) {
+		try {
+			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} key 键名
+	 * @param {*} value 值
+	 * @param {Number} expire 过期时间（秒）
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async add(key, value, expire) {
+		try {
+			const data = {
+				key: key,
+				value: value
+			};
+			
+			if (expire) {
+				data.expireAt = new Date(Date.now() + expire * 1000);
+			}
+			
+			// 检查是否已存在
+			const existing = await this.findOne({ key: key });
+			if (existing) {
+				await this.set({ key: key }, data);
+			} else {
+				await this.addObj(data);
+			}
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 添加缓存失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 增加整数值
+	 * @param {String} key 键名
+	 * @param {Number} value 增加值
+	 * @return {Promise<Number>} 增加后的值
+	 */
+	async addInt(key, value = 1) {
+		try {
+			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 - 增加浮点数值
+	 * @param {String} key 键名
+	 * @param {Number} value 增加值
+	 * @return {Promise<Number>} 增加后的值
+	 */
+	async addFloat(key, value = 1.0) {
+		return this.addInt(key, value); // 复用addInt方法
+	}
+	
+	/**
+	 * @description Redis兼容API - 添加字符串
+	 * @param {String} key 键名
+	 * @param {String} value 字符串值
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async addStr(key, value) {
+		return this.add(key, String(value));
+	}
+	
+	/**
+	 * @description Redis兼容API - 排序
+	 * @param {String} key 键名
+	 * @param {Object} options 排序选项
+	 * @return {Promise<Array>} 排序结果
+	 */
+	async sort(key, options = {}) {
+		try {
+			// 假设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<Boolean>} 是否成功
+	 */
+	async hset(key, field, value) {
+		try {
+			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);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表获取字段
+	 * @param {String} key 键名
+	 * @param {String} field 字段名
+	 * @return {Promise<any>} 字段值
+	 */
+	async hget(key, field) {
+		try {
+			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;
+		}
+	}
+	
+	/**
+	 * @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 {};
+		}
+	}
+	
+	/**
+	 * @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;
+			}
+			
+			if (item.value[field] === undefined) {
+				return false;
+			}
+			
+			delete item.value[field];
+			await this.set({ key: key }, { value: item.value });
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表删除失败:', error);
+			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);
+			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 - 递增（通过addInt模拟）
+	 * @param {String} key 键名
+	 * @return {Promise<Number>} 递增后的值
+	 */
+	async incr(key) {
+		return this.addInt(key, 1);
+	}
+	
+	/**
+	 * @description Redis兼容API - 递减（通过addInt模拟）
+	 * @param {String} key 键名
+	 * @return {Promise<Number>} 递减后的值
+	 */
+	async decr(key) {
+		return this.addInt(key, -1);
+	}
+	
+	/**
+	 * @description Redis兼容API - 检查键是否存在（别名）
+	 * @param {String} key 键名
+	 * @return {Promise<Boolean>} 是否存在
+	 */
+	async exists(key) {
+		return this.has(key);
+	}
+	
+	/**
+	 * @description Redis兼容API - 设置键值
+	 * @param {String} key 键名
+	 * @param {*} value 值
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async set(key, value) {
+		try {
+			// 直接使用已有的add方法，它已正确处理查询条件格式
+			return await this.add(key, value);
+		} catch (error) {
+			$.log.error('[MongoDB] 设置键值失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表批量设置
+	 * @param {String} key 键名
+	 * @param {Object} fieldValues 字段值对象
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async hmset(key, fieldValues) {
+		try {
+			const item = await this.findOne({ key: key });
+			let hash = item && typeof item.value === 'object' && item.value !== null ? item.value : {};
+			
+			// 合并字段值
+			Object.assign(hash, fieldValues);
+			await this.add(key, hash);
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表批量设置失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表批量获取
+	 * @param {String} key 键名
+	 * @param {Array} fields 字段名数组
+	 * @return {Promise<Object>} 字段值对象
+	 */
+	async hmget(key, fields) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return {};
+			}
+			
+			const result = {};
+			fields.forEach(field => {
+				result[field] = item.value[field] !== undefined ? item.value[field] : null;
+			});
+			return result;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表批量获取失败:', error);
+			return {};
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表批量删除字段
+	 * @param {String} key 键名
+	 * @param {Array} fields 字段名数组
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async hdelMulti(key, fields) {
+		try {
+			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;
+				}
+			});
+			
+			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>} 值数组
+	 */
+	async hvals(key) {
+		try {
+			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 {
+			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 {
+			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);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 哈希表字段是否存在
+	 * @param {String} key 键名
+	 * @param {String} field 字段名
+	 * @return {Promise<Boolean>} 是否存在
+	 */
+	async hexists(key, field) {
+		try {
+			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 {
+			const item = await this.findOne({ key: key });
+			let list = item && Array.isArray(item.value) ? item.value : [];
+			
+			list.push(value);
+			await this.add(key, list);
+			return list.length;
+		} catch (error) {
+			$.log.error('[MongoDB] 列表尾部添加失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 列表头部添加元素
+	 * @param {String} key 键名
+	 * @param {*} value 值
+	 * @return {Promise<Number>} 添加后列表长度
+	 */
+	async lpush(key, value) {
+		try {
+			const item = await this.findOne({ key: key });
+			let list = item && Array.isArray(item.value) ? item.value : [];
+			
+			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 {Number} start 起始索引
+	 * @param {Number} stop 结束索引
+	 * @return {Promise<Array>} 元素数组
+	 */
+	async lrange(key, start, stop) {
+		try {
+			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;
+			
+			// 确保索引有效
+			startIndex = Math.max(0, Math.min(startIndex, item.value.length - 1));
+			endIndex = Math.max(startIndex, Math.min(endIndex, item.value.length - 1));
+			
+			return item.value.slice(startIndex, endIndex + 1);
+		} catch (error) {
+			$.log.error('[MongoDB] 列表范围查询失败:', error);
+			return [];
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 获取列表指定索引元素
+	 * @param {String} key 键名
+	 * @param {Number} index 索引
+	 * @return {Promise<any>} 元素值
+	 */
+	async lindex(key, index) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return null;
+			}
+			
+			// 处理负数索引
+			const realIndex = index < 0 ? item.value.length + index : index;
+			
+			if (realIndex < 0 || realIndex >= item.value.length) {
+				return null;
+			}
+			
+			return item.value[realIndex];
+		} catch (error) {
+			$.log.error('[MongoDB] 获取列表索引元素失败:', error);
+			return null;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 设置列表指定索引元素
+	 * @param {String} key 键名
+	 * @param {Number} index 索引
+	 * @param {*} value 值
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async lset(key, index, value) {
+		try {
+			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 {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return 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--; // 调整索引
+					}
+				}
+			} 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 });
+			}
+			
+			return removedCount;
+		} catch (error) {
+			$.log.error('[MongoDB] 删除列表元素失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 裁剪列表
+	 * @param {String} key 键名
+	 * @param {Number} start 起始索引
+	 * @param {Number} stop 结束索引
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async ltrim(key, start, stop) {
+		try {
+			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 {
+			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 {
+			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);
+			}
+			
+			return addedCount;
+		} catch (error) {
+			$.log.error('[MongoDB] 集合并发添加失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 集合批量删除
+	 * @param {String} key 键名
+	 * @param {Array} members 成员数组
+	 * @return {Promise<Number>} 删除的成员数量
+	 */
+	async sremMulti(key, members) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return 0;
+			}
+			
+			let set = [...new Set(item.value)];
+			const originalLength = set.length;
+			
+			// 创建要删除的值的字符串表示集合用于快速查找
+			const membersToRemove = new Set(members.map(m => JSON.stringify(m)));
+			set = set.filter(member => !membersToRemove.has(JSON.stringify(member)));
+			
+			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 {
+			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 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 [];
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 集合交集
+	 * @param {String} key1 第一个集合键
+	 * @param {String} key2 第二个集合键
+	 * @return {Promise<Array>} 交集数组
+	 */
+	async sinter(key1, key2) {
+		try {
+			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;
+			}
+			
+			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 [];
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 集合并集
+	 * @param {String} key1 第一个集合键
+	 * @param {String} key2 第二个集合键
+	 * @return {Promise<Array>} 并集数组
+	 */
+	async sunion(key1, key2) {
+		try {
+			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);
+				}
+			});
+			
+			return Array.from(uniqueMap.values());
+		} catch (error) {
+			$.log.error('[MongoDB] 集合并集失败:', error);
+			return [];
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 集合成员数量
+	 * @param {String} key 键名
+	 * @return {Promise<Number>} 成员数量
+	 */
+	async scard(key) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return 0;
+			}
+			
+			// 使用Set去重并计算大小
+			const uniqueItems = new Set(item.value.map(m => JSON.stringify(m)));
+			return uniqueItems.size;
+		} catch (error) {
+			$.log.error('[MongoDB] 获取集合成员数量失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 检查是否是集合成员
+	 * @param {String} key 键名
+	 * @param {*} member 成员
+	 * @return {Promise<Boolean>} 是否是成员
+	 */
+	async sismember(key, member) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return false;
+			}
+			
+			// 检查是否存在相同的成员
+			const memberStr = JSON.stringify(member);
+			return item.value.some(m => JSON.stringify(m) === memberStr);
+		} catch (error) {
+			$.log.error('[MongoDB] 检查集合成员失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 批量获取
+	 * @param {Array} keys 键名数组
+	 * @return {Promise<Object>} 键值对象
+	 */
+	async mget(keys) {
+		try {
+			const results = await this.find({ key: { $in: keys } });
+			const resultMap = {};
+			results.forEach(item => {
+				resultMap[item.key] = item.value;
+			});
+			return resultMap;
+		} catch (error) {
+			$.log.error('[MongoDB] 批量获取失败:', error);
+			return {};
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 批量设置
+	 * @param {Object} keyValues 键值对象
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async mset(keyValues) {
+		try {
+			for (const [key, value] of Object.entries(keyValues)) {
+				await this.add(key, value);
+			}
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 批量设置失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 有序集合添加成员
+	 * @param {String} key 键名
+	 * @param {Number} score 分数
+	 * @param {*} member 成员
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async zadd(key, score, member) {
+		try {
+			const item = await this.findOne({ key: key });
+			let sortedSet = item && Array.isArray(item.value) ? item.value : [];
+			
+			// 检查成员是否已存在，如果存在则更新分数
+			const memberStr = JSON.stringify(member);
+			const existingIndex = sortedSet.findIndex(item => JSON.stringify(item.member) === memberStr);
+			
+			if (existingIndex >= 0) {
+				sortedSet[existingIndex].score = score;
+			} else {
+				sortedSet.push({ score, member });
+			}
+			
+			// 按分数排序
+			sortedSet.sort((a, b) => a.score - b.score);
+			await this.add(key, sortedSet);
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 有序集合添加成员失败:', error);
+			return false;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 有序集合范围查询（按分数）
+	 * @param {String} key 键名
+	 * @param {Number} min 最小分数
+	 * @param {Number} max 最大分数
+	 * @return {Promise<Array>} 成员数组
+	 */
+	async zrangebyscore(key, min, max) {
+		try {
+			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 {
+			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 {
+			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;
+			
+			if (removedCount > 0) {
+				await this.add(key, filtered);
+			}
+			
+			return removedCount;
+		} catch (error) {
+			$.log.error('[MongoDB] 有序集合删除成员失败:', error);
+			return 0;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 获取成员分数
+	 * @param {String} key 键名
+	 * @param {*} member 成员
+	 * @return {Promise<Number|null>} 分数
+	 */
+	async zscore(key, member) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				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;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 列表弹出头部元素
+	 * @param {String} key 键名
+	 * @return {Promise<any|null>} 弹出的元素
+	 */
+	async lpop(key) {
+		try {
+			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;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 列表弹出尾部元素
+	 * @param {String} key 键名
+	 * @return {Promise<any|null>} 弹出的元素
+	 */
+	async rpop(key) {
+		try {
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value) || item.value.length === 0) {
+				return null;
+			}
+			
+			const popped = item.value.pop();
+			await this.set({ key: key }, { value: item.value });
+			return popped;
+		} catch (error) {
+			$.log.error('[MongoDB] 列表弹出尾部元素失败:', error);
+			return null;
+		}
+	}
+	
+	/**
+	 * @description Redis兼容API - 获取集合所有成员
+	 * @param {String} key 键名
+	 * @return {Promise<Array>} 成员数组
+	 */
+	async smembers(key) {
+		try {
+			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 [];
+		}
 	}
 }
 
@@ -76,49 +1293,79 @@ class MongoDB {
  * @description 设置配置
  * @param {Object|String} cg 配置对象或配置路径
  */
-MongoDB.prototype.setConfig = function(cg) {
+MongoDB.prototype.setConfig = function (cg) {
 	var obj;
-	if (typeof(cg) === "string") {
-		obj = cg.loadJson(this.dir);
-	} else {
+	if (typeof (cg) === "string") {
+		obj = cg.loadJson ? cg.loadJson(this.dir) : null;
+	} else if (cg) {
 		obj = cg;
 	}
-	$.push(this.config, obj);
+	if (obj) {
+		$.push(this.config, obj);
+		// 设置新配置后重新验证
+		this._validateConfig();
+	}
 };
 
 /**
  * @description 设置Url
  */
-MongoDB.prototype.setUrl = function() {
+MongoDB.prototype.setUrl = function () {
 	var url = "mongodb://";
 	if (this.config.password) {
-		url += this.config.user + ':' + this.config.password + '@';
+		url += encodeURIComponent(this.config.user) + ':' + encodeURIComponent(this.config.password) + '@';
 	}
 	url += this.config.host + ":" + this.config.port + "/";
 	this.url = url;
 };
 
 /**
- * @description 连接mongoDB数据库
- * @return {Boolean} 连接成功返回true, 失败返回false
+ * @description 连接MongoDB数据库
+ * @return {Promise<Boolean>} 连接成功返回true, 失败抛出错误
  */
-MongoDB.prototype.open = async function() {
+MongoDB.prototype.open = async function () {
 	if (!this.url) {
 		this.setUrl();
 	}
 	if (!this.conn) {
-		this.conn = await MongoClient.connect(this.url, this.config.options);
-		this.db = this.conn.db(this.config.database);
+		return await this._withRetry(async () => {
+			try {
+				this.conn = await MongoClient.connect(this.url, this.config.options);
+				this.db = this.conn.db(this.config.database);
+				this.connected = true;
+
+				// 设置连接事件监听
+				this.conn.on('error', (err) => {
+					$.log.error('[MongoDB] 连接错误:', err);
+					this.connected = false;
+				});
+
+				this.conn.on('close', () => {
+					$.log.warn('[MongoDB] 连接已关闭');
+					this.connected = false;
+				});
+
+				$.log.info(`[MongoDB] 成功连接到 ${this.config.host}:${this.config.port}/${this.config.database}`);
+				return true;
+			} catch (error) {
+				$.log.error('[MongoDB] MongoDB连接失败:', error);
+				throw error;
+			}
+		}, '数据库连接');
 	}
-	return this.conn == true;
+	return true;
 };
 
 /**
  * 关闭数据库连接
  */
-MongoDB.prototype.close = function() {
+MongoDB.prototype.close = async function () {
 	if (this.conn) {
-		this.conn.close();
+		$.log.info(`[MongoDB] 关闭连接`);
+		await this.conn.close().catch(err => $.log.error('[MongoDB] 关闭MongoDB连接时出错:', err));
+		this.conn = null;
+		this.db = null;
+		this.connected = false;
 	}
 };
 
@@ -127,7 +1374,7 @@ MongoDB.prototype.close = function() {
  * @param {Object} table 表名
  * @return {Promise|Object} 执行结果
  */
-MongoDB.prototype.addTable = function(table) {
+MongoDB.prototype.addTable = function (table) {
 	if (table) {
 		this.table = table;
 	} else {
@@ -136,13 +1383,139 @@ MongoDB.prototype.addTable = function(table) {
 	return this.db.createCollection(table);
 };
 
+/**
+ * @description 创建索引
+ * @param {Object} keys 索引键配置 {field: 1或-1}
+ * @param {Object} options 索引选项
+ * @returns {Promise<Object>} 创建索引的结果
+ */
+MongoDB.prototype.createIndex = async function (keys, options = {}) {
+	try {
+		if (!this.db || !this.table) {
+			throw new Error('数据库未连接或未指定表名');
+		}
+
+		$.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) {
+		$.log.error(`[MongoDB] 创建索引失败: ${error.message}`);
+		throw error;
+	}
+};
+
+/**
+ * @description 创建TTL索引（数据自动过期）
+ * @param {Object} keys 索引键配置 {field: 1}
+ * @param {Number} expireAfterSeconds 过期时间（秒）
+ * @returns {Promise<Object>} 创建索引的结果
+ */
+MongoDB.prototype.createTTLIndex = async function (keys, expireAfterSeconds) {
+	try {
+		if (!this.db || !this.table) {
+			throw new Error('数据库未连接或未指定表名');
+		}
+
+		const options = {
+			background: true,
+			expireAfterSeconds: expireAfterSeconds
+		};
+
+		$.log.info(`[MongoDB] 创建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}`);
+		throw error;
+	}
+};
+
+/**
+ * @description 获取集合的所有索引
+ * @returns {Promise<Array>} 索引信息数组
+ */
+MongoDB.prototype.getIndexes = async function () {
+	try {
+		if (!this.db || !this.table) {
+			throw new Error('数据库未连接或未指定表名');
+		}
+
+		$.log.info(`[MongoDB] 获取索引: ${this.table}`);
+		return await this.db.collection(this.table).indexes();
+	} catch (error) {
+		$.log.error(`[MongoDB] 获取索引失败: ${error.message}`);
+		return [];
+	}
+};
+
+/**
+ * @description 删除指定索引
+ * @param {String} indexName 索引名称
+ * @returns {Promise<Boolean>} 是否删除成功
+ */
+MongoDB.prototype.dropIndex = async function (indexName) {
+	if (!this.conn || !this.db) {
+		throw new Error('数据库未连接');
+	}
+	if (!this.table) {
+		throw new Error('未指定表名');
+	}
+	if (!indexName) {
+		throw new Error('索引名称不能为空');
+	}
+	try {
+		$.log.info(`[MongoDB] 删除索引: ${this.table}, 索引名: ${indexName}`);
+		await this.db.collection(this.table).dropIndex(indexName);
+		return true;
+	} catch (error) {
+		$.log.error(`[MongoDB] 删除索引失败: ${error.message}`);
+		throw error;
+	}
+};
+
+/**
+ * @description 删除集合（表）
+ * @returns {Promise<Boolean>} 是否删除成功
+ */
+MongoDB.prototype.dropTable = async function () {
+	if (!this.conn || !this.db) {
+		throw new Error('数据库未连接');
+	}
+	if (!this.table) {
+		throw new Error('未指定表名');
+	}
+	try {
+		$.log.info(`[MongoDB] 删除集合: ${this.table}`);
+		await this.db.collection(this.table).drop();
+		return true;
+	} catch (error) {
+		$.log.error(`[MongoDB] 删除集合失败: ${error.message}`);
+		throw error;
+	}
+};
+
 /**
  * @description 增加一条缓存
  * @param {Object} obj 对象
  * @return {Promise|Object} 执行结果
  */
-MongoDB.prototype.addObj = function(obj) {
-	return this.db.collection(this.table).insertOne(obj);
+MongoDB.prototype.addObj = async function(obj) {
+	try {
+		// 触发前置事件
+		this.emit('beforeInsert', { table: this.table, data: obj });
+		
+		// 执行插入操作
+		const result = await this.db.collection(this.table).insertOne(obj);
+		
+		// 触发后置事件
+		this.emit('afterInsert', { table: this.table, data: obj, result });
+		
+		return result;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('insertError', { table: this.table, data: obj, error });
+		throw error;
+	}
 };
 
 /**
@@ -150,52 +1523,225 @@ MongoDB.prototype.addObj = function(obj) {
  * @param {Array} list 对象数组
  * @return {Promise|Object} 执行结果
  */
-MongoDB.prototype.addList = function(list) {
-	return this.db.collection(this.table).insertMany(list);
+MongoDB.prototype.addList = async function(list) {
+	try {
+		// 触发前置事件
+		this.emit('beforeInsertMany', { table: this.table, data: list });
+		
+		// 执行插入操作
+		const result = await this.db.collection(this.table).insertMany(list);
+		
+		// 触发后置事件
+		this.emit('afterInsertMany', { table: this.table, data: list, result });
+		
+		return result;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('insertManyError', { table: this.table, data: list, error });
+		throw error;
+	}
 };
 
 /**
  * @description 删除缓存
- * @param {Object} query 查询条件对象
+ * @param {Object|String} query 查询条件对象或键名
  * @return {Promise|Object} 执行结果
  */
-MongoDB.prototype.del = function(query) {
-	return this.db.collection(this.table).remove(query);
+MongoDB.prototype.del = async function(query) {
+	try {
+		// 如果query是字符串，则作为键名处理
+		const safeQuery = typeof query === 'string' ? { key: query } : query;
+		
+		// 触发前置事件
+		this.emit('beforeDelete', { table: this.table, query: safeQuery });
+		
+		// 执行删除操作
+		const result = await this.db.collection(this.table).deleteMany(safeQuery);
+		
+		// 触发后置事件
+		this.emit('afterDelete', { table: this.table, query: safeQuery, result });
+		
+		return result;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('deleteError', { table: this.table, query, error });
+		throw error;
+	}
 };
 
 /**
  * @description 修改缓存
- * @param {Object} query 查询条件对象
+ * @param {Object|String} query 查询条件对象或键名
  * @param {Object} body 修改对象
+ * @param {Object} options 附加选项
  * @return {Promise|Object} 执行结果
  */
-MongoDB.prototype.set = function(query, body) {
-	return this.db.collection(this.table).update(query, body);
+MongoDB.prototype.set = async function(query, body, options = {}) {
+	try {
+		// 处理Redis兼容模式：如果query是字符串，则将query作为键名
+		const safeQuery = typeof query === 'string' ? { key: query } : query;
+		
+		// 默认使用$set操作符进行部分更新
+		let updateBody;
+		if (typeof query === 'string') {
+			// Redis兼容模式：如果是字符串键名，直接设置value
+			updateBody = { $set: { value: body } };
+		} else if (!body.$set && !body.$inc && !body.$push) {
+			updateBody = { $set: body };
+		} else {
+			updateBody = body;
+		}
+		
+		// 默认更新多条
+		const updateOptions = Object.assign({ multi: true }, options);
+		
+		// 触发前置事件
+		this.emit('beforeUpdate', { table: this.table, query: safeQuery, update: updateBody, options: updateOptions });
+		
+		// 执行更新操作
+		const result = await this.db.collection(this.table).updateMany(safeQuery, updateBody, updateOptions);
+		
+		// 触发后置事件
+		this.emit('afterUpdate', { table: this.table, query: safeQuery, update: updateBody, options: updateOptions, result });
+		
+		// Redis兼容模式返回布尔值，否则返回完整结果
+		return typeof query === 'string' ? result.modifiedCount > 0 : result;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('updateError', { table: this.table, query, update: body, options, error });
+		
+		// Redis兼容模式返回布尔值
+		return typeof query === 'string' ? false : null;
+	}
 };
 
 /**
  * @description 查询缓存
  * @param {Object} query 查询条件对象
- * @return {Promise|Array} 执行结果
+ * @param {Object} options 查询选项
+ * @return {Promise|Array} 查询结果数组
  */
-MongoDB.prototype.get = function(query) {
-	if (this.page !== 0 && this.size !== 0) {
-		return this.db.collection(this.table).find(query).limit(this.size).skip((this.page - 1) * this
-			.size).toArray();
-	} else {
-		return this.db.collection(this.table).find(query).toArray();
+MongoDB.prototype.find = async function (query, options = {}) {
+	try {
+		// 安全处理查询条件，避免注入
+		const safeQuery = this._sanitizeQuery(query);
+		const cursor = this.db.collection(this.table).find(safeQuery, options);
+		return await cursor.toArray();
+	} catch (error) {
+		$.log.error('[MongoDB] 查询失败:', error);
+		return [];
 	}
 };
 
 /**
- * @module 导出MongoDB帮助类
+ * @description 查询单条数据
+ * @param {Object} query 查询条件对象
+ * @param {Object} options 查询选项
+ * @return {Promise<Object|null>} 查询结果
  */
-exports.MongoDB = MongoDB;
+MongoDB.prototype.findOne = async function (query, options = {}) {
+	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 计算文档数量
+ * @param {Object} query 查询条件对象
+ * @return {Promise<Number>} 文档数量
+ */
+MongoDB.prototype.count = async function (query = {}) {
+	try {
+		const safeQuery = this._sanitizeQuery(query);
+		return await this.db.collection(this.table).countDocuments(safeQuery);
+	} catch (error) {
+		$.log.error('[MongoDB] 计算文档数量失败:', error);
+		return 0;
+	}
+};
+
+/**
+ * @private
+ * @description 清理查询条件，防止注入攻击
+ * @param {Object} query 查询条件
+ * @return {Object} 安全的查询条件
+ */
+MongoDB.prototype._sanitizeQuery = function (query) {
+	// 简单实现，可根据需要扩展更复杂的安全检查
+	const sanitized = {};
+
+	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) {
+			$.log.warn('[MongoDB] 检测到可能的操作符注入尝试:', key);
+			continue;
+		}
+		sanitized[key] = value;
+	}
+
+	return sanitized;
+};
 
+/**
+ * @description 启动事务
+ * @return {Promise<Object>} 会话对象
+ */
+MongoDB.prototype.startTransaction = async function () {
+	try {
+		const session = this.conn.startSession();
+		session.startTransaction();
+		return session;
+	} catch (error) {
+		$.log.error('[MongoDB] 启动事务失败:', error);
+		throw error;
+	}
+};
 
 /**
- * @description mongoDB连接池
+ * @description 提交事务
+ * @param {Object} session 会话对象
+ * @return {Promise<void>}
  */
+MongoDB.prototype.commitTransaction = async function (session) {
+	try {
+		await session.commitTransaction();
+		await session.endSession();
+	} catch (error) {
+		$.log.error('[MongoDB] 提交事务失败:', error);
+		throw error;
+	}
+};
+
+/**
+ * @description 回滚事务
+ * @param {Object} session 会话对象
+ * @return {Promise<void>}
+ */
+MongoDB.prototype.rollbackTransaction = async function (session) {
+	try {
+		await session.abortTransaction();
+		await session.endSession();
+	} catch (error) {
+		$.log.error('[MongoDB] 回滚事务失败:', error);
+		throw error;
+	}
+};
+
+/**
+ * 导出MongoDB类
+ */
+exports.MongoDB = MongoDB;
+
+/**
+ * 确保连接池对象存在
+ */
+if (!$.pool) {
+	$.pool = {};
+}
 if (!$.pool.mongoDB) {
 	$.pool.mongoDB = {};
 }
@@ -204,11 +1750,11 @@ if (!$.pool.mongoDB) {
  * @description MongoDB管理器，用于创建缓存
  * @param {String} scope 作用域
  * @param {String} dir 当前路径
- * @return {Object} 返回一个缓存类
+ * @return {Object} 返回一个MongoDB类实例
  */
 function mongoDB_admin(scope, dir) {
 	if (!scope) {
-		scope = $.val.scope
+		scope = ($.val && $.val.scope) || 'default';
 	}
 	var obj = $.pool.mongoDB[scope];
 	if (!obj) {
@@ -221,4 +1767,4 @@ function mongoDB_admin(scope, dir) {
 /**
  * @module 导出MongoDB管理器
  */
-exports.mongoDB_admin = mongoDB_admin;
+exports.mongoDB_admin = mongoDB_admin;