mm_mongodb 1.4.5 → 1.4.7

package/index.js

@@ -87,6 +87,11 @@ class MongoDB extends eventEmitter {
 		this.size = 0;
 		// 连接状态
 		this.connected = false;
+		// 连接Promise缓存
+		this.connectPromise = null;
+		// 连接重试次数
+		this.connectAttempts = 0;
+		this.maxConnectAttempts = 3;
 	}
 
 	/**
@@ -154,6 +159,1308 @@ class MongoDB extends eventEmitter {
 		// 所有重试都失败，抛出最后一个错误
 		throw lastError;
 	}
+
+	/**
+	 * @description 确保数据库连接已建立
+	 * @private
+	 * @return {Promise<void>}
+	 */
+	async _ensureConnected() {
+		// 如果已有连接Promise，等待其完成
+		if (this.connectPromise) {
+			return this.connectPromise;
+		}
+
+		// 创建新的连接Promise
+		this.connectPromise = (async () => {
+			try {
+				// 检查连接状态
+				if (!this.db || !this.connected) {
+					// 记录连接尝试
+					this.connectAttempts++;
+
+					// 尝试连接
+					await this.open();
+
+					// 检查连接是否成功
+					if (this.db && this.db.collection) {
+						this.connected = true;
+						this.connectAttempts = 0;
+
+						// 确保索引已创建
+						await this._ensureIndexes();
+
+						$.log.info(`[MongoDB] 成功连接到数据库，表名: ${this.table}`);
+					} else {
+						throw new Error('数据库连接失败，db对象为空');
+					}
+				}
+			} catch (error) {
+				$.log.error(`[MongoDB] 连接失败 (尝试 ${this.connectAttempts}/${this.maxConnectAttempts}):`, error.message);
+
+				// 重置连接Promise，允许下次重试
+				this.connectPromise = null;
+
+				// 如果尝试次数未超过限制，抛出错误让上层处理
+				if (this.connectAttempts < this.maxConnectAttempts) {
+					throw error;
+				} else {
+					// 超过重试次数，记录严重错误
+					$.log.error('[MongoDB] 达到最大连接重试次数，连接失败');
+					throw new Error('数据库连接失败，已达到最大重试次数');
+				}
+			}
+		})();
+
+		return this.connectPromise;
+	}
+
+	/**
+	 * @description 确保索引已创建
+	 * @private
+	 * @return {Promise<void>}
+	 */
+	async _ensureIndexes() {
+		try {
+			// 确保db对象有效
+			if (!this.db || !this.db.collection) {
+				throw new Error('数据库连接无效，无法创建索引');
+			}
+
+			// 创建TTL索引用于自动过期
+			await this.db.collection(this.table).createIndex(
+				{ expireAt: 1 },
+				{ expireAfterSeconds: 0 }
+			);
+			// 创建_id索引(通常自动创建，但显式指定更清晰)
+			await this.db.collection(this.table).createIndex({ _id: 1 });
+		} catch (error) {
+			// 忽略索引已存在的错误
+			if (error.code !== 85) {
+				$.log.error('[MongoDB] 创建索引失败:', error);
+			}
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 获取缓存值
+	 * @param {String} key 键名
+	 * @return {Promise<any>} 缓存值
+	 */
+	async get(key) {
+		try {
+			await this._ensureConnected();
+			const result = await this.findOne({ key: key });
+			return result ? result.value : null;
+		} catch (error) {
+			$.log.error('[MongoDB] 获取缓存失败:', error);
+			return null;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 清空所有缓存
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async clear() {
+		try {
+			await this._ensureConnected();
+			await this.del({});
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 清空缓存失败:', error);
+			return false;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 获取所有键
+	 * @param {String} pattern 匹配模式
+	 * @return {Promise<Array>} 键名数组
+	 */
+	async keys(pattern = '*') {
+		try {
+			await this._ensureConnected();
+			let query = {};
+			if (pattern !== '*') {
+				// 简单的通配符支持
+				const regexPattern = pattern.replace(/\*/g, '.*').replace(/\?/g, '.');
+				query.key = { $regex: new RegExp(`^${regexPattern}$`) };
+			}
+			const results = await this.find(query, { projection: { key: 1 } });
+			return results.map(item => item.key);
+		} catch (error) {
+			$.log.error('[MongoDB] 获取键列表失败:', error);
+			return [];
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 设置过期时间
+	 * @param {String} key 键名
+	 * @param {Number} seconds 过期时间（秒）
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async ttl(key, seconds) {
+		try {
+			await this._ensureConnected();
+			if (!seconds && seconds !== 0) {
+				// 获取剩余过期时间
+				const item = await this.findOne({ key: key });
+				if (!item || !item.expireAt) return -1;
+				const ttl = Math.floor((item.expireAt.getTime() - Date.now()) / 1000);
+				return ttl > 0 ? ttl : -2; // -2 表示已过期
+			} else {
+				// 设置过期时间
+				const expireAt = seconds === 0 ? null : new Date(Date.now() + seconds * 1000);
+				const result = await this._set({ key: key }, { expireAt: expireAt });
+				return result.modifiedCount > 0;
+			}
+		} catch (error) {
+			$.log.error('[MongoDB] 设置TTL失败:', error);
+			return false;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 添加缓存
+	 * @param {String} key 键名
+	 * @param {*} value 值
+	 * @param {Number} expire 过期时间（秒）
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async _add(key, value, expire) {
+		try {
+			await this._ensureConnected();
+			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 {*} value 值
+	 * @param {Number} expire 过期时间（秒）
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async add(key, value, expire) {
+		return this._add(key, value, expire);
+	}
+
+	/**
+	 * @description Redis兼容API - 增加整数值
+	 * @param {String} key 键名
+	 * @param {Number} value 增加值
+	 * @return {Promise<Number>} 增加后的值
+	 */
+	async addInt(key, value = 1) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			let currentValue = 0;
+
+			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 {
+			await this._ensureConnected();
+			// 假设value是数组
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) return [];
+
+			const sorted = [...item.value];
+
+			// 处理排序选项
+			if (options.desc) {
+				sorted.sort((a, b) => b - a);
+			} else {
+				sorted.sort((a, b) => a - b);
+			}
+
+			// 处理限制
+			if (options.limit) {
+				const offset = options.offset || 0;
+				return sorted.slice(offset, offset + options.limit);
+			}
+
+			return sorted;
+		} catch (error) {
+			$.log.error('[MongoDB] 排序失败:', error);
+			return [];
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 哈希表设置字段
+	 * @param {String} key 键名
+	 * @param {String} field 字段名
+	 * @param {*} value 值
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async hset(key, field, value) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			let hash = item && typeof item.value === 'object' && item.value !== null ? item.value : {};
+
+			hash[field] = value;
+			await this._add(key, hash);
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表设置失败:', error);
+			return false;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 哈希表获取字段
+	 * @param {String} key 键名
+	 * @param {String} field 字段名
+	 * @return {Promise<any>} 字段值
+	 */
+	async hget(key, field) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return null;
+			}
+			return item.value[field] !== undefined ? item.value[field] : null;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表获取失败:', error);
+			return null;
+		}
+	}
+
+	/**
+	 * @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) {
+		try {
+			await this._ensureConnected();
+			const result = await this.addInt(key, 1);
+			return result !== undefined ? result : 0;
+		} catch (error) {
+			$.log.error('[MongoDB] 递增操作失败:', error);
+			return 0;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 递减（通过addInt模拟）
+	 * @param {String} key 键名
+	 * @return {Promise<Number>} 递减后的值
+	 */
+	async decr(key) {
+		try {
+			await this._ensureConnected();
+			const result = await this.addInt(key, -1);
+			return result !== undefined ? result : 0;
+		} catch (error) {
+			$.log.error('[MongoDB] 递减操作失败:', error);
+			return 0;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 检查键是否存在（别名）
+	 * @param {String} key 键名
+	 * @return {Promise<Boolean>} 是否存在
+	 */
+	async exists(key) {
+		try {
+			await this._ensureConnected();
+			return this.has(key);
+		} catch (error) {
+			$.log.error('[MongoDB] 检查键是否存在失败:', error);
+			return false;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 设置键值
+	 * @param {String} key 键名
+	 * @param {*} value 值
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async _set(key, value) {
+		try {
+			await this._ensureConnected();
+			// 直接使用已有的add方法，它已正确处理查询条件格式
+			return await this._add(key, value);
+		} catch (error) {
+			$.log.error('[MongoDB] 设置键值失败:', error);
+			return false;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 设置键值
+	 * @param {String} key 键名
+	 * @param {*} value 值
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async set(key, value) {
+		return this._set(key, value);
+	}
+
+	/**
+	 * @description Redis兼容API - 哈希表批量设置
+	 * @param {String} key 键名
+	 * @param {Object} fieldValues 字段值对象
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async hmset(key, fieldValues) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			let hash = item && typeof item.value === 'object' && item.value !== null ? item.value : {};
+
+			// 合并字段值
+			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 {
+			await this._ensureConnected();
+			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 {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return false;
+			}
+
+			let deleted = false;
+			fields.forEach(field => {
+				if (item.value[field] !== undefined) {
+					delete item.value[field];
+					deleted = true;
+				}
+			});
+
+			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 {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return [];
+			}
+			return Object.values(item.value);
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表获取所有值失败:', error);
+			return [];
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 哈希表获取所有字段名
+	 * @param {String} key 键名
+	 * @return {Promise<Array>} 字段名数组
+	 */
+	async hkeys(key) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return [];
+			}
+			return Object.keys(item.value);
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表获取所有字段名失败:', error);
+			return [];
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 哈希表字段数量
+	 * @param {String} key 键名
+	 * @return {Promise<Number>} 字段数量
+	 */
+	async hlen(key) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return 0;
+			}
+			return Object.keys(item.value).length;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表字段数量失败:', error);
+			return 0;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 哈希表字段是否存在
+	 * @param {String} key 键名
+	 * @param {String} field 字段名
+	 * @return {Promise<Boolean>} 是否存在
+	 */
+	async hexists(key, field) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || typeof item.value !== 'object' || item.value === null) {
+				return false;
+			}
+			return field in item.value;
+		} catch (error) {
+			$.log.error('[MongoDB] 哈希表字段是否存在失败:', error);
+			return false;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 列表尾部添加元素
+	 * @param {String} key 键名
+	 * @param {*} value 值
+	 * @return {Promise<Number>} 添加后列表长度
+	 */
+	async rpush(key, value) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			let list = item && Array.isArray(item.value) ? item.value : [];
+
+			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 {
+			await this._ensureConnected();
+			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 {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return [];
+			}
+
+			// 处理负数索引
+			let startIndex = start < 0 ? item.value.length + start : start;
+			let endIndex = stop < 0 ? item.value.length + stop : stop;
+
+			// 确保索引有效
+			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 {
+			await this._ensureConnected();
+			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 {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return false;
+			}
+
+			// 处理负数索引
+			const realIndex = index < 0 ? item.value.length + index : index;
+
+			if (realIndex < 0 || realIndex >= item.value.length) {
+				return false;
+			}
+
+			item.value[realIndex] = value;
+			await this._set({ key: key }, { value: item.value });
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 设置列表索引元素失败:', error);
+			return false;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 删除列表元素
+	 * @param {String} key 键名
+	 * @param {Number} count 删除数量
+	 * @param {*} value 要删除的值
+	 * @return {Promise<Number>} 删除的元素数量
+	 */
+	async lrem(key, count, value) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return 0;
+			}
+
+			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 {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return false;
+			}
+
+			// 使用lrange的逻辑获取裁剪后的列表
+			const trimmed = await this.lrange(key, start, stop);
+			await this._set({ key: key }, { value: trimmed });
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 裁剪列表失败:', error);
+			return false;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 列表长度
+	 * @param {String} key 键名
+	 * @return {Promise<Number>} 列表长度
+	 */
+	async llen(key) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return 0;
+			}
+			return item.value.length;
+		} catch (error) {
+			$.log.error('[MongoDB] 获取列表长度失败:', error);
+			return 0;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 集合批量添加
+	 * @param {String} key 键名
+	 * @param {Array} members 成员数组
+	 * @return {Promise<Number>} 添加的成员数量
+	 */
+	async saddMulti(key, members) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			let set = item && Array.isArray(item.value) ? [...new Set(item.value)] : [];
+			let addedCount = 0;
+
+			members.forEach(member => {
+				if (!set.some(existing => JSON.stringify(existing) === JSON.stringify(member))) {
+					set.push(member);
+					addedCount++;
+				}
+			});
+
+			if (addedCount > 0) {
+				await this._add(key, set);
+			}
+
+			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 {
+			await this._ensureConnected();
+			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 {
+			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 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 {
+			await this._ensureConnected();
+			const item1 = await this.findOne({ key: key1 });
+			const item2 = await this.findOne({ key: key2 });
+
+			const set1 = item1 && Array.isArray(item1.value) ? [...new Set(item1.value)] : [];
+			const set2 = item2 && Array.isArray(item2.value) ? [...new Set(item2.value)] : [];
+
+			// 创建较小集合的字符串表示用于快速查找，优化性能
+			let smallerSet, largerSet;
+			if (set1.length <= set2.length) {
+				smallerSet = set1;
+				largerSet = set2;
+			} else {
+				smallerSet = set2;
+				largerSet = set1;
+			}
+
+			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 {
+			await this._ensureConnected();
+			const item1 = await this.findOne({ key: key1 });
+			const item2 = await this.findOne({ key: key2 });
+
+			const set1 = item1 && Array.isArray(item1.value) ? item1.value : [];
+			const set2 = item2 && Array.isArray(item2.value) ? item2.value : [];
+
+			// 合并并去重
+			const combined = [...set1, ...set2];
+			// 使用Map进行对象去重，基于JSON字符串表示
+			const uniqueMap = new Map();
+
+			combined.forEach(item => {
+				const key = JSON.stringify(item);
+				if (!uniqueMap.has(key)) {
+					uniqueMap.set(key, item);
+				}
+			});
+
+			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 {
+			await this._ensureConnected();
+			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 {
+			await this._ensureConnected();
+			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 {...String} keys 键名列表
+	 * @return {Promise<Array>} 与键顺序对应的值数组，不存在返回null
+	 */
+	async mget(...keys) {
+		try {
+			await this._ensureConnected();
+			// 确保keys是数组
+			const keyArray = Array.isArray(keys[0]) ? keys[0] : keys;
+			const results = await this.find({ key: { $in: keyArray } });
+			const resultMap = {};
+			results.forEach(item => {
+				resultMap[item.key] = item.value;
+			});
+
+			// 返回与输入键顺序对应的数组，不存在的键对应位置返回null
+			return keyArray.map(key => resultMap.hasOwnProperty(key) ? resultMap[key] : null);
+		} catch (error) {
+			$.log.error('[MongoDB] 批量获取失败:', error);
+			return [];
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 批量设置
+	 * @param {Object} keyValues 键值对象
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async mset(keyValues) {
+		try {
+			await this._ensureConnected();
+			for (const [key, value] of Object.entries(keyValues)) {
+				await this._add(key, value);
+			}
+			return true;
+		} catch (error) {
+			$.log.error('[MongoDB] 批量设置失败:', error);
+			return false;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 有序集合添加成员
+	 * @param {String} key 键名
+	 * @param {Number} score 分数
+	 * @param {*} member 成员
+	 * @return {Promise<Boolean>} 是否成功
+	 */
+	async zadd(key, score, member) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			let sortedSet = item && Array.isArray(item.value) ? item.value : [];
+
+			// 检查成员是否已存在，如果存在则更新分数
+			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 {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return [];
+			}
+
+			// 过滤分数范围内的成员
+			return item.value
+				.filter(item => item.score >= min && item.score <= max)
+				.map(item => item.member);
+		} catch (error) {
+			$.log.error('[MongoDB] 有序集合范围查询失败:', error);
+			return [];
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 有序集合成员数量
+	 * @param {String} key 键名
+	 * @return {Promise<Number>} 成员数量
+	 */
+	async zcard(key) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return 0;
+			}
+			return item.value.length;
+		} catch (error) {
+			$.log.error('[MongoDB] 有序集合成员数量失败:', error);
+			return 0;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 有序集合删除成员
+	 * @param {String} key 键名
+	 * @param {*} member 成员
+	 * @return {Promise<Number>} 删除的成员数量
+	 */
+	async zrem(key, member) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return 0;
+			}
+
+			const memberStr = JSON.stringify(member);
+			const filtered = item.value.filter(item => JSON.stringify(item.member) !== memberStr);
+			const removedCount = item.value.length - filtered.length;
+
+			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 {
+			await this._ensureConnected();
+			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 {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value) || item.value.length === 0) {
+				return null;
+			}
+
+			const popped = item.value.shift();
+			await this._set({ key: key }, { value: item.value });
+			return popped;
+		} catch (error) {
+			$.log.error('[MongoDB] 列表弹出头部元素失败:', error);
+			return null;
+		}
+	}
+
+	/**
+	 * @description Redis兼容API - 列表弹出尾部元素
+	 * @param {String} key 键名
+	 * @return {Promise<any|null>} 弹出的元素
+	 */
+	async rpop(key) {
+		try {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value) || item.value.length === 0) {
+				return null;
+			}
+
+			const popped = item.value.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 {
+			await this._ensureConnected();
+			const item = await this.findOne({ key: key });
+			if (!item || !Array.isArray(item.value)) {
+				return [];
+			}
+
+			// 去重并返回
+			const uniqueMap = new Map();
+			item.value.forEach(member => {
+				const keyStr = JSON.stringify(member);
+				if (!uniqueMap.has(keyStr)) {
+					uniqueMap.set(keyStr, member);
+				}
+			});
+			return Array.from(uniqueMap.values());
+		} catch (error) {
+			$.log.error('[MongoDB] 获取集合所有成员失败:', error);
+			return [];
+		}
+	}
 }
 
 /**
@@ -237,11 +1544,12 @@ MongoDB.prototype.close = async function () {
 };
 
 /**
- * @description 创建数据表
- * @param {Object} table 表名
- * @return {Promise|Object} 执行结果
- */
-MongoDB.prototype.addTable = function (table) {
+	 * @description 创建数据表
+	 * @param {Object} table 表名
+	 * @return {Promise|Object} 执行结果
+	 */
+MongoDB.prototype.addTable = async function (table) {
+	await this._ensureConnected();
 	if (table) {
 		this.table = table;
 	} else {
@@ -250,28 +1558,6 @@ MongoDB.prototype.addTable = function (table) {
 	return this.db.createCollection(table);
 };
 
-/**
- * @description 创建TTL索引
- * @param {String} table 表名
- * @param {String} field 过期字段名
- * @param {Number} expireAfterSeconds 过期时间(秒)
- * @return {Promise<Object>} 执行结果
- */
-MongoDB.prototype.createTTLIndex = async function (table, field, expireAfterSeconds) {
-	if (!table) table = this.table;
-	return await this.db.collection(table).createIndex(
-		{ [field]: 1 },
-		{ expireAfterSeconds: expireAfterSeconds || 0 }
-	);
-};
-
-/**
- * @description 创建普通索引
- * @param {String} table 表名
- * @param {Object} keys 索引字段对象
- * @param {Object} options 索引选项
- * @return {Promise<Object>} 执行结果
- */
 /**
  * @description 创建索引
  * @param {Object} keys 索引键配置 {field: 1或-1}
@@ -279,6 +1565,7 @@ MongoDB.prototype.createTTLIndex = async function (table, field, expireAfterSeco
  * @returns {Promise<Object>} 创建索引的结果
  */
 MongoDB.prototype.createIndex = async function (keys, options = {}) {
+	await this._ensureConnected();
 	try {
 		if (!this.db || !this.table) {
 			throw new Error('数据库未连接或未指定表名');
@@ -300,6 +1587,7 @@ MongoDB.prototype.createIndex = async function (keys, options = {}) {
  * @returns {Promise<Object>} 创建索引的结果
  */
 MongoDB.prototype.createTTLIndex = async function (keys, expireAfterSeconds) {
+	await this._ensureConnected();
 	try {
 		if (!this.db || !this.table) {
 			throw new Error('数据库未连接或未指定表名');
@@ -320,13 +1608,14 @@ MongoDB.prototype.createTTLIndex = async function (keys, expireAfterSeconds) {
 };
 
 /**
- * @description 获取集合的所有索引
- * @returns {Promise<Array>} 索引信息数组
- */
+	 * @description 获取集合的所有索引
+	 * @returns {Promise<Array>} 索引信息数组
+	 */
 MongoDB.prototype.getIndexes = async function () {
+	await this._ensureConnected();
 	try {
-		if (!this.db || !this.table) {
-			throw new Error('数据库未连接或未指定表名');
+		if (!this.table) {
+			throw new Error('未指定表名');
 		}
 
 		$.log.info(`[MongoDB] 获取索引: ${this.table}`);
@@ -343,9 +1632,7 @@ MongoDB.prototype.getIndexes = async function () {
  * @returns {Promise<Boolean>} 是否删除成功
  */
 MongoDB.prototype.dropIndex = async function (indexName) {
-	if (!this.conn || !this.db) {
-		throw new Error('数据库未连接');
-	}
+	await this._ensureConnected();
 	if (!this.table) {
 		throw new Error('未指定表名');
 	}
@@ -367,9 +1654,7 @@ MongoDB.prototype.dropIndex = async function (indexName) {
  * @returns {Promise<Boolean>} 是否删除成功
  */
 MongoDB.prototype.dropTable = async function () {
-	if (!this.conn || !this.db) {
-		throw new Error('数据库未连接');
-	}
+	await this._ensureConnected();
 	if (!this.table) {
 		throw new Error('未指定表名');
 	}
@@ -388,103 +1673,230 @@ MongoDB.prototype.dropTable = async function () {
  * @param {Object} obj 对象
  * @return {Promise|Object} 执行结果
  */
-MongoDB.prototype.addObj = async function(obj) {
+MongoDB.prototype.addObj = async function (obj) {
+	await this._ensureConnected();
 	try {
 		// 触发前置事件
-		this.emit('beforeInsert', { table: this.table, data: obj });
-		
+		this.emit('addObj_before', { table: this.table, data: obj });
+
 		// 执行插入操作
 		const result = await this.db.collection(this.table).insertOne(obj);
-		
+
 		// 触发后置事件
-		this.emit('afterInsert', { table: this.table, data: obj, result });
-		
+		this.emit('addObj_after', { table: this.table, data: obj, result });
+
 		return result;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('insertError', { table: this.table, data: obj, error });
+		this.emit('addObj_error', { table: this.table, data: obj, error });
 		throw error;
 	}
 };
 
+/**
+	 * @description Redis兼容API - 根据键获取值
+	 * @param {String} key 键名
+	 * @return {Promise<any|null>} 存储的值，如果不存在则返回null
+	 */
+	MongoDB.prototype.get = async function (key) {
+		await this._ensureConnected();
+		try {
+			const result = await this.db.collection(this.table).findOne({ key: key });
+			return result ? result.value : null;
+		} catch (error) {
+			$.log.error(`[MongoDB] 获取键值失败: ${error.message}`);
+			return null;
+		}
+	};
+
+	/**
+ * @description Redis兼容API - 删除键
+ * @param {String} key 键名
+ * @return {Promise<Boolean>} 是否删除成功
+ */
+MongoDB.prototype.del = async function (key) {
+	await this._ensureConnected();
+	try {
+		// 触发前置事件
+		this.emit('del_before', { table: this.table, key: key });
+		
+		const result = await this.db.collection(this.table).deleteOne({ key: key });
+		
+		// 触发后置事件
+		this.emit('del_after', { table: this.table, key: key, result });
+		
+		return result.deletedCount > 0;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('del_error', { table: this.table, key: key, error });
+		$.log.error(`[MongoDB] 删除键失败: ${error.message}`);
+		return false;
+	}
+};
+
+/**
+ * @description Redis兼容API - 添加键值对
+ * @param {String} key 键名
+ * @param {any} value 值
+ * @return {Promise<Boolean>} 是否添加成功（如果键已存在则返回false）
+ */
+MongoDB.prototype.add = async function (key, value) {
+	await this._ensureConnected();
+	try {
+		// 检查键是否已存在
+		const exists = await this.db.collection(this.table).findOne({ key: key });
+		if (exists) {
+			return false;
+		}
+		
+		const data = { key: key, value: value };
+		
+		// 触发前置事件
+		this.emit('add_before', { table: this.table, key: key, value: value });
+		
+		// 添加键值对
+		const result = await this.db.collection(this.table).insertOne(data);
+		
+		// 触发后置事件
+		this.emit('add_after', { table: this.table, key: key, value: value, result });
+		
+		return result.acknowledged;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('add_error', { table: this.table, key: key, value: value, error });
+		$.log.error(`[MongoDB] 添加键值失败: ${error.message}`);
+		return false;
+	}
+};
+
+/**
+ * @description Redis兼容API - 设置键值对
+ * @param {String} key 键名
+ * @param {any} value 值
+ * @return {Promise<Boolean>} 是否设置成功
+ */
+MongoDB.prototype.set = async function (key, value) {
+	await this._ensureConnected();
+	try {
+		// 触发前置事件
+		this.emit('set_before', { table: this.table, key: key, value: value });
+		
+		// 更新或插入键值对
+		const result = await this.db.collection(this.table).updateOne(
+			{ key: key },
+			{ $set: { value: value } },
+			{ upsert: true }
+		);
+		
+		// 触发后置事件
+		this.emit('set_after', { table: this.table, key: key, value: value, result });
+		
+		return result.acknowledged;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('set_error', { table: this.table, key: key, value: value, error });
+		$.log.error(`[MongoDB] 设置键值失败: ${error.message}`);
+		return false;
+	}
+};
+
 /**
  * @description 增加多条缓存
  * @param {Array} list 对象数组
  * @return {Promise|Object} 执行结果
  */
-MongoDB.prototype.addList = async function(list) {
+MongoDB.prototype.addList = async function (list) {
+	await this._ensureConnected();
 	try {
 		// 触发前置事件
-		this.emit('beforeInsertMany', { table: this.table, data: list });
-		
+		this.emit('addList_before', { table: this.table, data: list });
+
 		// 执行插入操作
 		const result = await this.db.collection(this.table).insertMany(list);
-		
+
 		// 触发后置事件
-		this.emit('afterInsertMany', { table: this.table, data: list, result });
-		
+		this.emit('addList_after', { table: this.table, data: list, result });
+
 		return result;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('insertManyError', { table: this.table, data: list, error });
+		this.emit('addList_error', { table: this.table, data: list, error });
 		throw error;
 	}
 };
 
 /**
  * @description 删除缓存
- * @param {Object} query 查询条件对象
+ * @param {Object|String} query 查询条件对象或键名
  * @return {Promise|Object} 执行结果
  */
-MongoDB.prototype.del = async function(query) {
+MongoDB.prototype.delete = async function (query) {
+	await this._ensureConnected();
 	try {
+		// 如果query是字符串，则作为键名处理
+		const safeQuery = typeof query === 'string' ? { key: query } : query;
+
 		// 触发前置事件
-		this.emit('beforeDelete', { table: this.table, query });
-		
+		this.emit('delete_before', { table: this.table, query: safeQuery });
+
 		// 执行删除操作
-		const result = await this.db.collection(this.table).deleteMany(query);
-		
+		const result = await this.db.collection(this.table).deleteMany(safeQuery);
+
 		// 触发后置事件
-		this.emit('afterDelete', { table: this.table, query, result });
-		
+		this.emit('delete_after', { table: this.table, query: safeQuery, result });
+
 		return result;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('deleteError', { table: this.table, query, error });
+		this.emit('delete_error', { 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 = async function(query, body, options = {}) {
+MongoDB.prototype.setting = async function (query, body, options = {}) {
+	await this._ensureConnected();
 	try {
+		// 处理Redis兼容模式：如果query是字符串，则将query作为键名
+		const safeQuery = typeof query === 'string' ? { key: query } : query;
+
 		// 默认使用$set操作符进行部分更新
-		if (!body.$set && !body.$inc && !body.$push) {
-			body = { $set: body };
+		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, update: body, options: updateOptions });
-		
+		this.emit('setting_before', { table: this.table, query: safeQuery, update: updateBody, options: updateOptions });
+
 		// 执行更新操作
-		const result = await this.db.collection(this.table).updateMany(query, body, updateOptions);
-		
+		const result = await this.db.collection(this.table).updateMany(safeQuery, updateBody, updateOptions);
+
 		// 触发后置事件
-		this.emit('afterUpdate', { table: this.table, query, update: body, options: updateOptions, result });
-		
-		return result;
+		this.emit('setting_after', { table: this.table, query: safeQuery, update: updateBody, options: updateOptions, result });
+
+		// Redis兼容模式返回布尔值，否则返回完整结果
+		return typeof query === 'string' ? result.modifiedCount > 0 : result;
 	} catch (error) {
 		// 触发错误事件
-		this.emit('updateError', { table: this.table, query, update: body, options, error });
-		throw error;
+		this.emit('setting_error', { table: this.table, query, update: body, options, error });
+
+		// Redis兼容模式返回布尔值
+		return typeof query === 'string' ? false : null;
 	}
 };
 
@@ -495,6 +1907,7 @@ MongoDB.prototype.set = async function(query, body, options = {}) {
  * @return {Promise|Array} 查询结果数组
  */
 MongoDB.prototype.find = async function (query, options = {}) {
+	await this._ensureConnected();
 	try {
 		// 安全处理查询条件，避免注入
 		const safeQuery = this._sanitizeQuery(query);
@@ -513,6 +1926,7 @@ MongoDB.prototype.find = async function (query, options = {}) {
  * @return {Promise<Object|null>} 查询结果
  */
 MongoDB.prototype.findOne = async function (query, options = {}) {
+	await this._ensureConnected();
 	try {
 		const safeQuery = this._sanitizeQuery(query);
 		return await this.db.collection(this.table).findOne(safeQuery, options);
@@ -528,6 +1942,7 @@ MongoDB.prototype.findOne = async function (query, options = {}) {
  * @return {Promise<Number>} 文档数量
  */
 MongoDB.prototype.count = async function (query = {}) {
+	await this._ensureConnected();
 	try {
 		const safeQuery = this._sanitizeQuery(query);
 		return await this.db.collection(this.table).countDocuments(safeQuery);
@@ -564,6 +1979,7 @@ MongoDB.prototype._sanitizeQuery = function (query) {
  * @return {Promise<Object>} 会话对象
  */
 MongoDB.prototype.startTransaction = async function () {
+	await this._ensureConnected();
 	try {
 		const session = this.conn.startSession();
 		session.startTransaction();
@@ -637,6 +2053,9 @@ function mongoDB_admin(scope, dir) {
 	return obj;
 }
 
+
+
+
 /**
  * @module 导出MongoDB管理器
  */