mm_cachebase 2.0.4 → 2.0.6

package/index.js

@@ -1,3141 +1,11 @@
-/**
- * CacheBase 是一个通用缓存基类，支持内存缓存和持久化缓存
- * 接口与 mm_redis 完全对齐：全异步、冒号风格事件、统一签名与返回值
- * @class CacheBase
- * @extends Base
- */
-const {
-	Base
-} = require('mm_expand');
-
-class CacheBase extends Base {
-	/**
-	 * 默认配置静态变量
-	 */
-	static config = {
-		enabled: true,
-		persist: true,
-		scope: 'sys',
-		dir: './cache',
-		debug: false,
-		auto_save: true,
-		save_interval: 30000,
-		expire_check_interval: 1000,
-		max_size: null,
-		storage_type: 'memory'
-	};
-
-	/**
-	 * 构造函数
-	 * @param {Object} config - 配置对象
-	 */
-	constructor(config = {}) {
-		// 先调用父类构造函数
-		super(CacheBase.config);
-
-		// 存储实际数据
-		this._data = {};
-
-		// 存储过期时间
-		this._expires = {};
-
-		// 存储数据类型
-		this._types = {};
-
-		// 存储持久化数据的定时器
-		this._save_timer = null;
-
-		// 存储过期检查的定时器
-		this._check_timer = null;
-
-		// 初始化服务状态
-		this.is_inited = false;
-		this.is_destroyed = false;
-
-		// 连接状态（与 mm_redis 保持一致）
-		this.connected = false;
-
-		// 发布订阅频道回调
-		this._channels = {};
-
-		this.setConfig(config);
-		// 初始化服务（内存缓存特性：构造即初始化）
-		this.init();
-	}
-}
-
-/**
- * 设置配置
- * @param {Object} config - 配置对象
- */
-CacheBase.prototype.setConfig = function (config) {
-	// 加载外部配置文件
-	const external_config = this._loadExternalConfig();
-	// 更新配置
-	Object.assign(this.config, external_config, config);
-};
-
-/**
- * 初始化服务
- * @returns {Promise<void>}
- */
-CacheBase.prototype.init = async function () {
-	if (this.is_inited || this.is_destroyed) {
-		return;
-	}
-
-	try {
-		await this._initService();
-		this.is_inited = true;
-		this.connected = true;
-	} catch (error) {
-		this.log('error', 'Failed to initialize CacheBase service:', error);
-	}
-};
-
-/**
- * 加载外部配置文件
- * @private
- * @returns {Object} 外部配置对象
- */
-CacheBase.prototype._loadExternalConfig = function () {
-	try {
-		const config_path = './config/cachebase.config.json'.fullname(__dirname);
-		if (config_path.hasFile()) {
-			const config = config_path.loadJson();
-			return config;
-		}
-	} catch (error) {
-		this.log('warn', '外部配置文件加载失败，使用默认配置:', error.message);
-	}
-	return {};
-};
-
-/**
- * 设置文件路径
- * @private
- */
-CacheBase.prototype._setFilePath = function () {
-	const scope = this.config.scope || 'sys';
-	const dir = this.config.dir || './cache';
-	this.file_path = `./${scope}.json`.fullname(dir);
-};
-
-/**
- * 初始化服务
- * @private
- * @returns {Promise<void>}
- */
-CacheBase.prototype._initService = async function () {
-	try {
-		// 设置文件路径
-		this._setFilePath();
-		// 初始化过期检查定时器
-		this._check_timer = setInterval(() => {
-			this.clearExpire();
-		}, this.config.expire_check_interval || 1000);
-
-		// 设置最大大小限制
-		if (this.config.max_size) {
-			this._max_size = this.config.max_size;
-		}
-
-		// 加载数据
-		this._loadData();
-
-		// 设置定时保存
-		this._connect();
-
-		// 设置初始化完成状态
-		this.is_inited = true;
-	} catch (error) {
-		this.log('error', 'Failed to initialize service:', error);
-	}
-};
-
-/**
- * 设置定时保存（内部方法）
- * @private
- */
-CacheBase.prototype._connect = function () {
-	// 如果启用了自动保存
-	if (this.config.auto_save) {
-		this._save_timer = setInterval(() => {
-			this.save();
-		}, this.config.save_interval || 30000);
-	}
-};
-
-/**
- * 从文件加载数据
- * @private
- */
-CacheBase.prototype._loadData = function () {
-	try {
-		if (this.config.persist && this.file_path) {
-			if (this.file_path.hasFile()) {
-				// 使用mm_expand的原型函数读取JSON文件
-				const parsed_data = this.file_path.loadJson();
-				if (parsed_data && parsed_data.data) {
-					this._data = parsed_data.data || {};
-				} else {
-					this.log('warn', `[_loadData] 解析后的数据中没有data字段`);
-				}
-
-				if (parsed_data && parsed_data.expires) {
-					this._expires = parsed_data.expires || {};
-				}
-
-				if (parsed_data && parsed_data.types) {
-					this._types = parsed_data.types || {};
-				}
-			}
-		}
-	} catch (error) {
-		this.log('error', '加载数据失败:', error);
-	}
-};
-
-/**
- * 保存数据到文件
- */
-CacheBase.prototype.save = function () {
-	// 检查服务状态
-	if (!this.is_inited || this.is_destroyed) {
-		this.log('error', 'Service is not initialized or has been destroyed');
-		return;
-	}
-
-	try {
-		this.emit('save:before');
-		this._saveData();
-		this.emit('save:after');
-	} catch (error) {
-		this.log('error', 'Failed to save data:', error);
-	}
-};
-
-/**
- * 保存数据到文件
- * @private
- */
-CacheBase.prototype._saveData = function () {
-	try {
-		if (this.config.persist && this.file_path) {
-			// 确保目录存在 - 使用目录路径的原型函数
-			this.file_path.addDir();
-
-			const data_to_save = {
-				data: this._data,
-				expires: this._expires,
-				types: this._types,
-				timestamp: Date.now()
-			};
-
-			// 使用mm_expand的原型函数写入JSON文件
-			this.file_path.saveJson(data_to_save, null, 2);
-		}
-	} catch (error) {
-		this.log('error', 'Failed to save data:', error);
-	}
-};
-
-/**
- * 销毁服务
- * @returns {Promise<void>}
- */
-CacheBase.prototype.destroy = async function () {
-	if (this.is_destroyed) {
-		return;
-	}
-
-	try {
-		// 保存数据
-		this.save();
-
-		// 清除定时器
-		if (this._save_timer) {
-			clearInterval(this._save_timer);
-			this._save_timer = null;
-		}
-
-		if (this._check_timer) {
-			clearInterval(this._check_timer);
-			this._check_timer = null;
-		}
-
-		// 清空数据
-		this._data = {};
-		this._expires = {};
-		this._types = {};
-		this._channels = {};
-
-		// 设置销毁状态
-		this.is_inited = false;
-		this.is_destroyed = true;
-		this.connected = false;
-
-		// 触发销毁事件（注意：不可使用 'destroy:after' 冒号格式，
-		// mm_expand 的 Base.emit 会将冒号格式解释为 do 流程的阶段，触发 _destroyCore）
-		this.emit('destroy', { success: true });
-	} catch (error) {
-		this.log('error', 'Failed to destroy service:', error);
-	}
-};
-
-/**
- * 打开缓存服务（与 mm_redis 接口对齐）
- * @returns {Promise<Boolean>} 连接结果
- */
-CacheBase.prototype.open = async function () {
-	try {
-		if (!this.is_inited) {
-			await this.init();
-		}
-		return this.connected;
-	} catch (error) {
-		this.log('error', 'Failed to open CacheBase:', error);
-		return false;
-	}
-};
-
-/**
- * 关闭缓存服务（与 mm_redis 接口对齐）
- * @returns {Promise<Boolean>} 关闭结果
- */
-CacheBase.prototype.close = async function () {
-	try {
-		await this.destroy();
-		return true;
-	} catch (error) {
-		this.log('error', 'Failed to close CacheBase:', error);
-		return false;
-	}
-};
-
-/**
- * 检查连接状态（与 mm_redis 接口对齐）
- * @returns {Boolean} 是否已连接
- */
-CacheBase.prototype.isConnected = function () {
-	return this.connected;
-};
-
-/**
- * 清理资源并销毁实例
- * @returns {Boolean} 操作结果
- */
-CacheBase.prototype.dispose = function () {
-	try {
-		// 防止重复销毁
-		if (this.is_destroyed) {
-			return true;
-		}
-
-		// 清除定时任务
-		if (this._save_timer) {
-			clearInterval(this._save_timer);
-			this._save_timer = null;
-		}
-
-		if (this._check_timer) {
-			clearInterval(this._check_timer);
-			this._check_timer = null;
-		}
-
-		// 清除所有数据
-		this._data = {};
-		this._expires = {};
-		this._types = {};
-		this._channels = {};
-
-		// 设置销毁状态
-		this.is_inited = false;
-		this.is_destroyed = true;
-		this.connected = false;
-
-		// 触发销毁事件
-		this.emit('destroy', {
-			success: true
-		});
-
-		return true;
-	} catch (error) {
-		this.log('error', 'Failed to dispose:', error);
-		return false;
-	}
-};
-
-// ==================== 键值操作 ====================
-
-/**
- * 设置键值对
- * @param {String} key 键
- * @param {*} value 值
- * @param {Number} [seconds=0] 过期时间（秒），0表示永不过期
- * @returns {Promise<Boolean>} 成功返回true，失败返回false
- */
-CacheBase.prototype.set = async function (key, value, seconds = 0) {
-	// 检查服务状态
-	if (!this.is_inited || this.is_destroyed) {
-		this.log('error', 'Service is not initialized or has been destroyed');
-		return false;
-	}
-
-	// 参数验证
-	if (!key || typeof key !== 'string') {
-		throw new TypeError('key必须是非空字符串');
-	}
-
-	try {
-		// 触发前置事件
-		const ctx = {
-			key,
-			value,
-			seconds,
-			cancel: false
-		};
-		this.emit('set:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `set操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		// 使用可能被修改的值
-		const {
-			key: finalKey,
-			value: finalValue,
-			seconds: finalSeconds
-		} = ctx;
-
-		// 保存数据
-		this._data[finalKey] = finalValue;
-
-		// 设置类型
-		this._types[finalKey] = this._getDataTypes(finalValue);
-
-		// 设置过期时间
-		if (finalSeconds && typeof finalSeconds === 'number' && finalSeconds > 0) {
-			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
-		} else {
-			delete this._expires[finalKey];
-		}
-
-		// 触发后置事件
-		this.emit('set:after', {
-			key,
-			value,
-			seconds,
-			success: true
-		});
-
-		return true;
-	} catch (error) {
-		this.log('error', `Failed to set key ${key}:`, error);
-		this.emit('set:error', { key, value, seconds, error });
-		return false;
-	}
-};
-
-/**
- * 获取键值
- * @param {String} key 键
- * @returns {Promise<Object|null>} 值，不存在或错误返回null
- */
-CacheBase.prototype.get = async function (key) {
-	// 检查服务状态
-	if (!this.is_inited || this.is_destroyed) {
-		this.log('error', 'Service is not initialized or has been destroyed');
-		return null;
-	}
-
-	try {
-		this.emit('get:before', { key });
-
-		// 检查是否过期
-		if (this._isExpired(key)) {
-			await this.del(key);
-			this.emit('get:after', { key, value: null });
-			return null;
-		}
-
-		const value = this._data[key];
-		this.emit('get:after', { key, value });
-		return value !== undefined ? value : null;
-	} catch (error) {
-		this.log('error', `Failed to get key ${key}:`, error);
-		this.emit('get:error', { key, error });
-		return null;
-	}
-};
-
-/**
- * 删除键
- * @param {String|Array<String>} key 键名或键名数组
- * @returns {Promise<Number>} 删除的键数量
- */
-CacheBase.prototype.del = async function (key) {
-	// 参数验证
-	if (!key) {
-		throw new TypeError('key必须是非空字符串或非空字符串数组');
-	}
-
-	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') {
-				throw new TypeError('key必须是非空字符串或非空字符串数组');
-			}
-		}
-	} else {
-		throw new TypeError('key必须是非空字符串或非空字符串数组');
-	}
-
-	// 检查服务状态
-	if (!this.is_inited || this.is_destroyed) {
-		this.log('error', 'Service is not initialized or has been destroyed');
-		return 0;
-	}
-
-	try {
-		// 触发前置事件
-		const ctx = {
-			key,
-			cancel: false
-		};
-		this.emit('del:before', ctx);
-
-		if (ctx.cancel) {
-			return 0;
-		}
-
-		const finalKey = ctx.key;
-		let deletedCount = 0;
-
-		if (Array.isArray(finalKey)) {
-			// 批量删除
-			for (const k of finalKey) {
-				if (k in this._data) {
-					delete this._data[k];
-					delete this._types[k];
-					delete this._expires[k];
-					deletedCount++;
-				}
-			}
-		} else {
-			// 单个删除
-			if (finalKey in this._data) {
-				delete this._data[finalKey];
-				delete this._types[finalKey];
-				delete this._expires[finalKey];
-				deletedCount++;
-			}
-		}
-
-		// 触发后置事件
-		this.emit('del:after', {
-			key: finalKey,
-			success: deletedCount > 0,
-			deleted: deletedCount
-		});
-
-		return deletedCount;
-	} catch (error) {
-		this.log('error', 'Failed to del:', error);
-		this.emit('del:error', { key, error });
-		return 0;
-	}
-};
-
-/**
- * 批量删除键
- * @param {Array} keys 键名数组
- * @returns {Promise<Number>} 删除的键数量
- */
-CacheBase.prototype.delBatch = async function (keys) {
-	try {
-		if (!Array.isArray(keys)) {
-			return 0;
-		}
-		return await this.del(keys);
-	} catch (error) {
-		this.log('error', 'Failed to delBatch:', error);
-		return 0;
-	}
-};
-
-/**
- * 检查键是否存在
- * @param {String} key 键
- * @returns {Promise<Number>} 存在返回1，不存在返回0
- */
-CacheBase.prototype.exists = async function (key) {
-	try {
-		this.emit('exists:before', { key });
-
-		if (this._isExpired(key)) {
-			await this.del(key);
-			this.emit('exists:after', { key, result: 0 });
-			return 0;
-		}
-
-		const result = key in this._data ? 1 : 0;
-		this.emit('exists:after', { key, result });
-		return result;
-	} catch (error) {
-		this.log('error', `Failed to check key ${key}:`, error);
-		return 0;
-	}
-};
-
-/**
- * 检查键是否存在
- * @param {String} key 键名
- * @returns {Promise<Boolean>} 是否存在
- */
-CacheBase.prototype.has = async function (key) {
-	const result = await this.exists(key);
-	return result > 0;
-};
-
-/**
- * 清空过期数据
- * @returns {Promise<void>}
- */
-CacheBase.prototype.clearExpire = async function () {
-	try {
-		const now = Date.now();
-		const expiredKeys = [];
-		for (const key in this._expires) {
-			if (this._expires[key] < now) {
-				expiredKeys.push(key);
-			}
-		}
-		if (expiredKeys.length > 0) {
-			await this.del(expiredKeys);
-		}
-	} catch (error) {
-		this.log('error', 'Failed to clear expired data:', error);
-	}
-};
-
-/**
- * 检查键是否过期
- * @private
- * @param {String} key 键名
- * @returns {Boolean} 是否过期
- */
-CacheBase.prototype._isExpired = function (key) {
-	// 先检查键是否存在
-	if (!(key in this._data)) {
-		return true;
-	}
-
-	// 如果没有设置过期时间，则未过期
-	if (!(key in this._expires)) {
-		return false;
-	}
-
-	const now = Date.now();
-	const is_expired = now > this._expires[key];
-
-	// 仅返回过期状态，不在此处做惰性删除。
-	// 删除统一由 del 方法完成，避免事件不成对。
-	return is_expired;
-};
-
-/**
- * 获取数据类型
- * @private
- * @param {*} value 值
- * @returns {String} 数据类型
- */
-CacheBase.prototype._getDataTypes = function (value) {
-	if (value === null) return 'null';
-	if (value instanceof Set) return 'set';
-	if (value instanceof Map) return 'zset';
-	if (Array.isArray(value)) return 'array';
-	return typeof value;
-};
-
-// ==================== 过期时间管理 ====================
-
-/**
- * 设置键的过期时间
- * @param {String} key 键名
- * @param {Number} seconds 过期时间（秒）
- * @returns {Promise<Boolean>} 是否成功
- */
-CacheBase.prototype.expire = async function (key, seconds) {
-	try {
-		if (!key || typeof key !== 'string') {
-			return false;
-		}
-
-		if (typeof seconds !== 'number' || seconds <= 0) {
-			return false;
-		}
-
-		// 触发前置事件
-		const ctx = {
-			key,
-			ttl: seconds,
-			cancel: false
-		};
-		this.emit('expire:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const {
-			key: finalKey,
-			ttl: finalSeconds
-		} = ctx;
-
-		// 检查键是否存在
-		if (!(finalKey in this._data)) {
-			return false;
-		}
-
-		// 设置过期时间
-		this._expires[finalKey] = Date.now() + finalSeconds * 1000;
-
-		// 触发后置事件
-		this.emit('expire:after', {
-			key: finalKey,
-			ttl: finalSeconds,
-			success: true
-		});
-
-		return true;
-	} catch (error) {
-		this.log('error', `Failed to set expire for key ${key}:`, error);
-		this.emit('expire:error', { key, ttl: seconds, error });
-		return false;
-	}
-};
-
-/**
- * 设置键的过期时间（毫秒）
- * @param {String} key 键名
- * @param {Number} milliseconds 过期时间（毫秒）
- * @returns {Promise<Boolean>} 是否成功
- */
-CacheBase.prototype.pexpire = async function (key, milliseconds) {
-	try {
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-		if (typeof milliseconds !== 'number' || milliseconds <= 0) {
-			throw new TypeError('milliseconds必须是正数');
-		}
-
-		// 触发前置事件
-		const ctx = {
-			key,
-			ttl: milliseconds,
-			cancel: false
-		};
-		this.emit('pexpire:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const {
-			key: finalKey,
-			ttl: finalMilliseconds
-		} = ctx;
-
-		// 检查键是否存在
-		if (!(finalKey in this._data)) {
-			return false;
-		}
-
-		// 设置过期时间（毫秒）
-		this._expires[finalKey] = Date.now() + finalMilliseconds;
-
-		// 触发后置事件
-		this.emit('pexpire:after', {
-			key: finalKey,
-			ttl: finalMilliseconds,
-			success: true
-		});
-
-		return true;
-	} catch (error) {
-		this.log('error', `Failed to set pexpire for key ${key}:`, error);
-		this.emit('pexpire:error', { key, ttl: milliseconds, error });
-		return false;
-	}
-};
-
-/**
- * 移除键的过期时间
- * @param {String} key 键名
- * @returns {Promise<Boolean>} 是否成功移除
- */
-CacheBase.prototype.persist = async function (key) {
-	try {
-		if (!key || typeof key !== 'string') {
-			return false;
-		}
-
-		// 触发前置事件
-		const ctx = {
-			key,
-			cancel: false
-		};
-		this.emit('persist:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const {
-			key: finalKey
-		} = ctx;
-
-		// 检查键是否存在
-		if (!(finalKey in this._data)) {
-			return false;
-		}
-
-		// 检查是否过期
-		if (this._isExpired(finalKey)) {
-			await this.del(finalKey);
-			return false;
-		}
-
-		// 移除过期时间
-		if (finalKey in this._expires) {
-			delete this._expires[finalKey];
-
-			this.emit('persist:after', {
-				key: finalKey,
-				success: true
-			});
-			return true;
-		}
-
-		return false;
-	} catch (error) {
-		this.log('error', `Failed to persist key ${key}:`, error);
-		this.emit('persist:error', { key, error });
-		return false;
-	}
-};
-
-/**
- * 获取或设置键的过期时间
- * @param {String} key 键名
- * @param {Number} [seconds] 过期时间（秒），不传则获取剩余过期时间
- * @returns {Promise<Number|Boolean>} 不传seconds返回剩余秒数（-1无过期，-2已过期），传seconds返回是否设置成功
- */
-CacheBase.prototype.ttl = async function (key, seconds) {
-	const isSetMode = arguments.length > 1 && seconds !== undefined;
-	try {
-		this.emit('ttl:before', { key, seconds });
-
-		if (!key || typeof key !== 'string') {
-			return isSetMode ? false : -2;
-		}
-
-		if (isSetMode) {
-			// 设置过期时间模式
-			if (typeof seconds !== 'number' || seconds < 0) {
-				return false;
-			}
-
-			if (!(key in this._data)) {
-				return false;
-			}
-
-			if (this._isExpired(key)) {
-				await this.del(key);
-				return false;
-			}
-
-			if (seconds > 0) {
-				this._expires[key] = Date.now() + seconds * 1000;
-			} else if (seconds === 0) {
-				delete this._expires[key];
-			}
-
-			this.emit('ttl:after', { key, seconds, success: true });
-			return true;
-		} else {
-			// 获取剩余过期时间模式
-			if (!(key in this._data)) {
-				return -2;
-			}
-
-			if (this._isExpired(key)) {
-				await this.del(key);
-				return -2;
-			}
-
-			if (!(key in this._expires)) {
-				return -1;
-			}
-
-			const now = Date.now();
-			const remaining = this._expires[key] - now;
-			return Math.max(0, Math.ceil(remaining / 1000));
-		}
-	} catch (error) {
-		this.log('error', `Failed to ttl for key ${key}:`, error);
-		return isSetMode ? false : -2;
-	}
-};
-
-// ==================== 哈希表操作 ====================
-
-/**
- * 设置哈希表字段
- * @param {String} key 哈希表键名
- * @param {String} field 字段名
- * @param {*} value 值
- * @returns {Promise<Boolean>} 操作结果
- */
-CacheBase.prototype.hset = async function (key, field, value) {
-	try {
-		if (!key || typeof key !== 'string' || !field || typeof field !== 'string') {
-			return false;
-		}
-
-		// 触发前置事件
-		const ctx = {
-			key,
-			field,
-			value,
-			cancel: false
-		};
-		this.emit('hset:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const {
-			key: finalKey,
-			field: finalField,
-			value: finalValue
-		} = ctx;
-
-		// 检查是否过期
-		if (this._isExpired(finalKey)) {
-			await this.del(finalKey);
-		}
-
-		// 初始化哈希表
-		if (!(finalKey in this._data) || this._types[finalKey] !== 'hash') {
-			this._data[finalKey] = {};
-			this._types[finalKey] = 'hash';
-		}
-
-		// 设置字段值
-		this._data[finalKey][finalField] = finalValue;
-
-		this.emit('hset:after', {
-			key: finalKey,
-			field: finalField,
-			value: finalValue,
-			success: true
-		});
-
-		return true;
-	} catch (error) {
-		this.log('error', `Failed to hset for key ${key}:`, error);
-		this.emit('hset:error', { key, field, value, error });
-		return false;
-	}
-};
-
-/**
- * 获取哈希表字段值
- * @param {String} key 哈希表键名
- * @param {String} field 字段名
- * @returns {Promise<Object|null>} 字段值，不存在或错误返回null
- */
-CacheBase.prototype.hget = async function (key, field) {
-	try {
-		this.emit('hget:before', { key, field });
-
-		if (!key || typeof key !== 'string' || !field || typeof field !== 'string') {
-			return null;
-		}
-
-		// 检查是否过期
-		if (this._isExpired(key)) {
-			await this.del(key);
-			return null;
-		}
-
-		// 检查键是否存在且类型正确
-		if (!(key in this._data) || this._types[key] !== 'hash') {
-			return null;
-		}
-
-		const value = this._data[key][field];
-		this.emit('hget:after', { key, field, value });
-		return value !== undefined ? value : null;
-	} catch (error) {
-		this.log('error', `Failed to hget for key ${key}:`, error);
-		return null;
-	}
-};
-
-/**
- * 获取哈希表所有字段和值
- * @param {String} key 哈希表键名
- * @returns {Promise<Object>} 哈希表内容
- */
-CacheBase.prototype.hgetall = async function (key) {
-	try {
-		this.emit('hgetall:before', { key });
-
-		if (!key || typeof key !== 'string') {
-			return {};
-		}
-
-		// 检查是否过期
-		if (this._isExpired(key)) {
-			await this.del(key);
-			return {};
-		}
-
-		// 检查键是否存在且类型正确
-		if (!(key in this._data) || this._types[key] !== 'hash') {
-			return {};
-		}
-
-		const result = { ...this._data[key] };
-		this.emit('hgetall:after', { key, result });
-		return result;
-	} catch (error) {
-		this.log('error', `Failed to hgetall for key ${key}:`, error);
-		return {};
-	}
-};
-
-/**
- * 删除哈希表字段
- * @param {String} key 哈希表键名
- * @param {String|Array<String>} field 字段名或字段名数组
- * @returns {Promise<Number>} 删除的字段数量
- */
-CacheBase.prototype.hdel = async function (key, field) {
-	try {
-		if (!key || typeof key !== 'string') {
-			return 0;
-		}
-
-		// 触发前置事件
-		const ctx = {
-			key,
-			field,
-			cancel: false
-		};
-		this.emit('hdel:before', ctx);
-
-		if (ctx.cancel) {
-			return 0;
-		}
-
-		// 检查是否过期
-		if (this._isExpired(key)) {
-			await this.del(key);
-			this.emit('hdel:after', { key, field, success: false, deleted: 0 });
-			return 0;
-		}
-
-		// 检查键是否存在且类型正确
-		if (!(key in this._data) || this._types[key] !== 'hash') {
-			this.emit('hdel:after', { key, field, success: false, deleted: 0 });
-			return 0;
-		}
-
-		// 处理字段参数
-		const fields = Array.isArray(field) ? field : [field];
-		let deletedCount = 0;
-
-		for (const f of fields) {
-			if (typeof f === 'string' && f && f in this._data[key]) {
-				delete this._data[key][f];
-				deletedCount++;
-			}
-		}
-
-		// 如果哈希表为空，删除整个键
-		if (deletedCount > 0 && Object.keys(this._data[key]).length === 0) {
-			delete this._data[key];
-			delete this._types[key];
-			delete this._expires[key];
-		}
-
-		this.emit('hdel:after', {
-			key,
-			field,
-			success: deletedCount > 0,
-			deleted: deletedCount
-		});
-
-		return deletedCount;
-	} catch (error) {
-		this.emit('hdel:error', { key, field, error });
-		this.log('error', 'Failed to hdel:', error);
-		return 0;
-	}
-};
-
-/**
- * 批量设置哈希表字段
- * @param {String} key 哈希表键名
- * @param {Object} obj 包含多个字段的对象
- * @returns {Promise<Boolean>} 操作结果
- */
-CacheBase.prototype.hmset = async function (key, obj) {
-	try {
-		if (!key || typeof key !== 'string' || !obj || typeof obj !== 'object' || Array.isArray(obj)) {
-			return false;
-		}
-
-		// 触发前置事件
-		const ctx = {
-			key,
-			value: obj,
-			cancel: false
-		};
-		this.emit('hmset:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const {
-			key: finalKey,
-			value: finalObj
-		} = ctx;
-
-		// 检查是否过期
-		if (this._isExpired(finalKey)) {
-			await this.del(finalKey);
-		}
-
-		// 初始化哈希表
-		if (!(finalKey in this._data) || this._types[finalKey] !== 'hash') {
-			this._data[finalKey] = {};
-			this._types[finalKey] = 'hash';
-		}
-
-		// 批量设置字段
-		for (const field in finalObj) {
-			if (Object.prototype.hasOwnProperty.call(finalObj, field)) {
-				this._data[finalKey][field] = finalObj[field];
-			}
-		}
-
-		this.emit('hmset:after', {
-			key: finalKey,
-			value: finalObj,
-			success: true
-		});
-
-		return true;
-	} catch (error) {
-		this.emit('hmset:error', { key, value: obj, error });
-		this.log('error', 'Failed to hmset:', error);
-		return false;
-	}
-};
-
-/**
- * 批量获取哈希表字段
- * @param {String} key 哈希表键名
- * @param {Array} fields 字段名数组
- * @returns {Promise<Array>} 字段值数组，不存在的字段返回null
- */
-CacheBase.prototype.hmget = async function (key, fields) {
-	try {
-		this.emit('hmget:before', { key, fields });
-
-		if (!key || typeof key !== 'string' || !Array.isArray(fields)) {
-			return [];
-		}
-
-		// 检查是否过期
-		if (this._isExpired(key)) {
-			await this.del(key);
-			return fields.map(() => null);
-		}
-
-		// 检查键是否存在且类型正确
-		if (!(key in this._data) || this._types[key] !== 'hash') {
-			return fields.map(() => null);
-		}
-
-		// 批量获取字段值
-		const results = [];
-		for (const field of fields) {
-			const val = this._data[key][field];
-			results.push(val !== undefined ? val : null);
-		}
-
-		this.emit('hmget:after', { key, fields, results });
-		return results;
-	} catch (error) {
-		this.emit('hmget:error', { key, fields, error });
-		this.log('error', 'Failed to hmget:', error);
-		return [];
-	}
-};
-
-/**
- * 获取哈希表字段数量
- * @param {String} key 哈希表键名
- * @returns {Promise<Number>} 字段数量
- */
-CacheBase.prototype.hlen = async function (key) {
-	try {
-		this.emit('hlen:before', { key });
-
-		if (!key || typeof key !== 'string') {
-			return 0;
-		}
-
-		// 检查是否过期
-		if (this._isExpired(key)) {
-			await this.del(key);
-			return 0;
-		}
-
-		// 检查键是否存在且类型正确
-		if (!(key in this._data) || this._types[key] !== 'hash') {
-			return 0;
-		}
-
-		const result = Object.keys(this._data[key]).length;
-		this.emit('hlen:after', { key, result });
-		return result;
-	} catch (error) {
-		this.emit('hlen:error', { key, error });
-		this.log('error', 'Failed to hlen:', error);
-		return 0;
-	}
-};
-
-// ==================== 数值操作 ====================
-
-/**
- * 将键的值增加1
- * @param {String} key 键
- * @param {Number} [seconds=0] 过期时间（秒）
- * @returns {Promise<Number>} 增加后的值，失败返回null
- */
-CacheBase.prototype.incr = async function (key, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('键必须是非空字符串');
-		}
-
-		const ctx = {
-			key,
-			ttl: seconds,
-			cancel: false
-		};
-		this.emit('incr:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const {
-			key: finalKey,
-			ttl: finalSeconds
-		} = ctx;
-
-		// 确保_data对象存在
-		if (!this._data) {
-			this._data = {};
-		}
-
-		let current = 0;
-		if (finalKey in this._data && !this._isExpired(finalKey)) {
-			current = Number(this._data[finalKey]) || 0;
-		}
-
-		const newValue = current + 1;
-		this._data[finalKey] = newValue;
-		this._types[finalKey] = 'number';
-
-		if (finalSeconds > 0) {
-			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
-		} else {
-			delete this._expires[finalKey];
-		}
-
-		this.emit('incr:after', {
-			key: finalKey,
-			ttl: finalSeconds,
-			success: true,
-			result: newValue
-		});
-		return newValue;
-	} catch (error) {
-		this.emit('incr:error', { key, ttl: seconds, error });
-		this.log('error', 'incr操作失败:', error);
-		return null;
-	}
-};
-
-/**
- * 将键的值减少1
- * @param {String} key 键
- * @param {Number} [seconds=0] 过期时间（秒）
- * @returns {Promise<Number>} 减少后的值，失败返回null
- */
-CacheBase.prototype.decr = async function (key, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('键必须是非空字符串');
-		}
-
-		const ctx = {
-			key,
-			ttl: seconds,
-			cancel: false
-		};
-		this.emit('decr:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const {
-			key: finalKey,
-			ttl: finalSeconds
-		} = ctx;
-
-		if (!this._data) {
-			this._data = {};
-		}
-
-		let current = 0;
-		if (finalKey in this._data && !this._isExpired(finalKey)) {
-			current = Number(this._data[finalKey]) || 0;
-		}
-
-		const newValue = current - 1;
-		this._data[finalKey] = newValue;
-		this._types[finalKey] = 'number';
-
-		if (finalSeconds > 0) {
-			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
-		} else {
-			delete this._expires[finalKey];
-		}
-
-		this.emit('decr:after', {
-			key: finalKey,
-			ttl: finalSeconds,
-			success: true,
-			result: newValue
-		});
-		return newValue;
-	} catch (error) {
-		this.emit('decr:error', { key, ttl: seconds, error });
-		this.log('error', 'decr操作失败:', error);
-		return null;
-	}
-};
-
-/**
- * 将键的值增加指定整数
- * @param {String} key 键
- * @param {Number} increment 增量
- * @param {Number} [seconds=0] 过期时间（秒）
- * @returns {Promise<Number>} 增加后的值，失败返回null
- */
-CacheBase.prototype.incrby = async function (key, increment, seconds = 0) {
-	// 检查服务状态
-	if (!this.is_inited || this.is_destroyed) {
-		this.log('error', 'Service is not initialized or has been destroyed');
-		return null;
-	}
-
-	if (!key || typeof key !== 'string' || typeof increment !== 'number') {
-		this.log('error', 'incrby参数错误: key必须是非空字符串，increment必须是数字');
-		return null;
-	}
-
-	try {
-		const ctx = {
-			key,
-			increment,
-			seconds,
-			cancel: false
-		};
-		this.emit('incrby:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const {
-			key: finalKey,
-			increment: finalIncrement,
-			seconds: finalSeconds
-		} = ctx;
-
-		if (!this._data) {
-			this._data = {};
-		}
-
-		let current = 0;
-		if (finalKey in this._data && !this._isExpired(finalKey)) {
-			current = Number(this._data[finalKey]) || 0;
-		} else if (finalKey in this._data && this._isExpired(finalKey)) {
-			await this.del(finalKey);
-		}
-
-		const newValue = current + finalIncrement;
-		this._data[finalKey] = newValue;
-		this._types[finalKey] = 'number';
-
-		// 设置过期时间（保留 TTL 语义与 Redis 一致）
-		if (finalSeconds > 0) {
-			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
-		}
-
-		this.emit('incrby:after', {
-			key: finalKey,
-			increment: finalIncrement,
-			seconds: finalSeconds,
-			success: true,
-			result: newValue
-		});
-
-		return newValue;
-	} catch (error) {
-		this.emit('incrby:error', { key, increment, seconds, error });
-		this.log('error', 'incrby操作失败:', error);
-		return null;
-	}
-};
-
-/**
- * 将键的值减少指定整数
- * @param {String} key 键
- * @param {Number} decrement 减量
- * @param {Number} [seconds=0] 过期时间（秒）
- * @returns {Promise<Number>} 减少后的值，失败返回null
- */
-CacheBase.prototype.decrby = async function (key, decrement, seconds = 0) {
-	// 检查服务状态
-	if (!this.is_inited || this.is_destroyed) {
-		this.log('error', 'Service is not initialized or has been destroyed');
-		return null;
-	}
-
-	if (!key || typeof key !== 'string' || typeof decrement !== 'number') {
-		this.log('error', 'decrby参数错误: key必须是非空字符串，decrement必须是数字');
-		return null;
-	}
-
-	try {
-		const ctx = {
-			key,
-			decrement,
-			seconds,
-			cancel: false
-		};
-		this.emit('decrby:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const {
-			key: finalKey,
-			decrement: finalDecrement,
-			seconds: finalSeconds
-		} = ctx;
-
-		if (!this._data) {
-			this._data = {};
-		}
-
-		let current = 0;
-		if (finalKey in this._data && !this._isExpired(finalKey)) {
-			current = Number(this._data[finalKey]) || 0;
-		} else if (finalKey in this._data && this._isExpired(finalKey)) {
-			await this.del(finalKey);
-		}
-
-		const newValue = current - finalDecrement;
-		this._data[finalKey] = newValue;
-		this._types[finalKey] = 'number';
-
-		if (finalSeconds > 0) {
-			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
-		}
-
-		this.emit('decrby:after', {
-			key: finalKey,
-			decrement: finalDecrement,
-			seconds: finalSeconds,
-			success: true,
-			result: newValue
-		});
-
-		return newValue;
-	} catch (error) {
-		this.emit('decrby:error', { key, decrement, seconds, error });
-		this.log('error', 'decrby操作失败:', error);
-		return null;
-	}
-};
-
-/**
- * 将键的值增加指定浮点数
- * @param {String} key 键
- * @param {Number} [increment=1.0] 增量
- * @param {Number} [seconds=0] 过期时间（秒）
- * @returns {Promise<Number>} 增加后的值，失败返回null
- */
-CacheBase.prototype.incrbyfloat = async function (key, increment = 1.0, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string' || typeof increment !== 'number') {
-			this.log('error', 'incrbyfloat参数错误: key必须是非空字符串，increment必须是数字');
-			return null;
-		}
-
-		const ctx = {
-			key,
-			increment,
-			ttl: seconds,
-			cancel: false
-		};
-		this.emit('incrbyfloat:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const {
-			key: finalKey,
-			increment: finalIncrement,
-			ttl: finalSeconds
-		} = ctx;
-
-		if (!this._data) {
-			this._data = {};
-		}
-
-		let current = 0;
-		if (finalKey in this._data && !this._isExpired(finalKey)) {
-			current = Number(this._data[finalKey]) || 0;
-		}
-
-		const newValue = current + finalIncrement;
-		this._data[finalKey] = newValue;
-		this._types[finalKey] = 'number';
-
-		if (finalSeconds > 0) {
-			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
-		} else {
-			delete this._expires[finalKey];
-		}
-
-		this.emit('incrbyfloat:after', {
-			key: finalKey,
-			increment: finalIncrement,
-			ttl: finalSeconds,
-			success: true,
-			result: newValue
-		});
-		return newValue;
-	} catch (error) {
-		this.emit('incrbyfloat:error', { key, increment, ttl: seconds, error });
-		this.log('error', 'incrbyfloat操作失败:', error);
-		return null;
-	}
-};
-
-/**
- * 增加整数值（兼容方法）
- * @param {String} key 键名
- * @param {Number} value 要增加的整数值
- * @param {Number} [seconds=0] 过期时间（秒）
- * @returns {Promise<Number>} 增加后的值，失败返回null
- */
-CacheBase.prototype.addInt = async function (key, value, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-		if (typeof value !== 'number') {
-			throw new TypeError('value必须是数字');
-		}
-
-		const ctx = {
-			key,
-			value,
-			ttl: seconds,
-			cancel: false
-		};
-		this.emit('addInt:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const {
-			key: finalKey,
-			value: finalValue,
-			ttl: finalSeconds
-		} = ctx;
-
-		let currentValue = 0;
-		if (finalKey in this._data && !this._isExpired(finalKey)) {
-			currentValue = parseInt(this._data[finalKey], 10) || 0;
-		}
-		const result = Math.floor(currentValue + parseInt(finalValue, 10));
-
-		this._data[finalKey] = result;
-		this._types[finalKey] = 'number';
-
-		if (finalSeconds > 0) {
-			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
-		} else {
-			delete this._expires[finalKey];
-		}
-
-		this.emit('addInt:after', {
-			key: finalKey,
-			value: finalValue,
-			ttl: finalSeconds,
-			success: true,
-			result
-		});
-		return result;
-	} catch (error) {
-		this.emit('addInt:error', { key, value, ttl: seconds, error });
-		this.log('error', 'addInt操作失败:', error);
-		return null;
-	}
-};
-
-/**
- * 增加浮点数（兼容方法）
- * @param {String} key 键名
- * @param {Number} num 要增加的浮点数值
- * @param {Number} [seconds=0] 过期时间（秒）
- * @returns {Promise<Number>} 增加后的值，失败返回null
- */
-CacheBase.prototype.addFloat = async function (key, num, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string' || typeof num !== 'number') {
-			throw new TypeError('addFloat参数错误: key必须是非空字符串，num必须是数字');
-		}
-
-		const ctx = {
-			key,
-			num,
-			ttl: seconds,
-			cancel: false
-		};
-		this.emit('addFloat:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const {
-			key: finalKey,
-			num: finalNum,
-			ttl: finalSeconds
-		} = ctx;
-
-		let currentValue = 0;
-		if (finalKey in this._data && !this._isExpired(finalKey)) {
-			currentValue = Number(this._data[finalKey]) || 0;
-		}
-		const result = currentValue + Number(finalNum);
-
-		this._data[finalKey] = result;
-		this._types[finalKey] = 'number';
-
-		if (finalSeconds > 0) {
-			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
-		} else {
-			delete this._expires[finalKey];
-		}
-
-		this.emit('addFloat:after', {
-			key: finalKey,
-			num: finalNum,
-			ttl: finalSeconds,
-			success: true,
-			result
-		});
-		return result;
-	} catch (error) {
-		this.emit('addFloat:error', { key, num, ttl: seconds, error });
-		this.log('error', 'addFloat操作失败:', error);
-		return null;
-	}
-};
-
-// ==================== 字符串操作 ====================
-
-/**
- * 追加字符串（兼容方法，对齐 mm_redis 的 setrange）
- * @param {String} key 键名
- * @param {String} value 要追加的字符串
- * @param {Number} [seconds=0] 过期时间（秒）
- * @returns {Promise<Number>} 追加后字符串的长度，失败返回null
- */
-CacheBase.prototype.setrange = async function (key, value, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string' || typeof value !== 'string') {
-			throw new TypeError('setrange参数错误: key和value必须是非空字符串');
-		}
-
-		const ctx = {
-			key,
-			value,
-			ttl: seconds,
-			cancel: false
-		};
-		this.emit('setrange:before', ctx);
-
-		if (ctx.cancel) {
-			return null;
-		}
-
-		const {
-			key: finalKey,
-			value: finalValue,
-			ttl: finalSeconds
-		} = ctx;
-
-		let currentValue = '';
-		if (finalKey in this._data && !this._isExpired(finalKey)) {
-			currentValue = String(this._data[finalKey]) || '';
-		}
-		const result = currentValue + finalValue;
-		const length = result.length;
-
-		this._data[finalKey] = result;
-		this._types[finalKey] = 'string';
-
-		if (finalSeconds > 0) {
-			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
-		} else {
-			delete this._expires[finalKey];
-		}
-
-		this.emit('setrange:after', {
-			key: finalKey,
-			value: finalValue,
-			ttl: finalSeconds,
-			result,
-			length,
-			success: true
-		});
-		return length;
-	} catch (error) {
-		this.emit('setrange:error', { key, value, ttl: seconds, error });
-		this.log('error', 'setrange操作失败:', error);
-		return null;
-	}
-};
-
-/**
- * 向字符串末尾追加内容
- * @param {String} key 键名
- * @param {String} append 要追加的内容
- * @returns {Promise<Number>} 追加后的字符串长度，失败返回null
- */
-CacheBase.prototype.append = async function (key, append) {
-	try {
-		if (!key || typeof key !== 'string' || typeof append !== 'string') {
-			return null;
-		}
-
-		// 检查是否过期
-		if (this._isExpired(key)) {
-			await this.del(key);
-			return null;
-		}
-
-		let current = '';
-		if (key in this._data && typeof this._data[key] === 'string') {
-			current = this._data[key];
-		}
-
-		current += append;
-		this._data[key] = current;
-		this._types[key] = 'string';
-
-		return current.length;
-	} catch (error) {
-		this.log('error', `Failed to append for key ${key}:`, error);
-		return null;
-	}
-};
-
-/**
- * 获取字符串长度
- * @param {String} key 键名
- * @returns {Promise<Number>} 字符串长度，不存在返回0
- */
-CacheBase.prototype.strlen = async function (key) {
-	try {
-		if (!key || typeof key !== 'string') {
-			return 0;
-		}
-
-		if (this._isExpired(key)) {
-			await this.del(key);
-			return 0;
-		}
-
-		if (!(key in this._data)) {
-			return 0;
-		}
-
-		if (typeof this._data[key] !== 'string') {
-			return 0;
-		}
-
-		return this._data[key].length;
-	} catch (error) {
-		this.log('error', `Failed to strlen for key ${key}:`, error);
-		return 0;
-	}
-};
-
-/**
- * 获取并设置值
- * @param {String} key 键名
- * @param {*} value 新值
- * @param {Number} [seconds=0] 过期时间（秒）
- * @returns {Promise<Object|null>} 旧值
- */
-CacheBase.prototype.getset = async function (key, value, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string') {
-			return null;
-		}
-
-		// 获取旧值
-		const oldValue = await this.get(key);
-
-		// 设置新值
-		await this.set(key, value, seconds);
-
-		return oldValue;
-	} catch (error) {
-		this.log('error', 'Failed to getset:', error);
-		return null;
-	}
-};
-
-/**
- * 仅当键不存在时设置值（兼容方法，类似 Redis SETNX 语义）
- * @param {String} key 键名
- * @param {*} value 要设置的值
- * @param {Number} [seconds=0] 过期时间（秒）
- * @returns {Promise<Boolean>} 键不存在并设置成功返回true，键已存在返回false
- */
-CacheBase.prototype.add = async function (key, value, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('add参数错误: key必须是非空字符串');
-		}
-
-		const ctx = {
-			key,
-			value,
-			ttl: seconds,
-			cancel: false
-		};
-		this.emit('add:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `add操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		const {
-			key: finalKey,
-			value: finalValue,
-			ttl: finalSeconds
-		} = ctx;
-
-		// 检查键是否存在且未过期
-		if (finalKey in this._data && !this._isExpired(finalKey)) {
-			this.emit('add:after', {
-				key: finalKey,
-				value: finalValue,
-				ttl: finalSeconds,
-				success: false
-			});
-			return false;
-		}
-
-		// 键不存在或已过期，设置新值
-		this._data[finalKey] = finalValue;
-		this._types[finalKey] = this._getDataTypes(finalValue);
-
-		if (finalSeconds > 0) {
-			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
-		} else {
-			delete this._expires[finalKey];
-		}
-
-		this.emit('add:after', {
-			key: finalKey,
-			value: finalValue,
-			ttl: finalSeconds,
-			success: true
-		});
-		return true;
-	} catch (error) {
-		this.log('error', `add操作失败 [${key}]:`, error);
-		this.emit('add:error', { key, value, ttl: seconds, error });
-		return false;
-	}
-};
-
-// ==================== 批量操作 ====================
-
-/**
- * 一次性设置多个键值对
- * @param {Object} obj 键值对对象
- * @param {Number} [seconds=0] 过期时间（秒）
- * @returns {Promise<Boolean>} 成功返回true，失败返回false
- */
-CacheBase.prototype.mset = async function (obj, seconds = 0) {
-	// 检查服务状态
-	if (!this.is_inited || this.is_destroyed) {
-		this.log('error', 'Service is not initialized or has been destroyed');
-		return false;
-	}
-
-	try {
-		// 参数验证：必须是对象
-		if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
-			throw new TypeError('参数必须是键值对对象');
-		}
-
-		// 触发前置事件
-		const ctx = {
-			keyValuePairs: obj,
-			seconds,
-			cancel: false
-		};
-		this.emit('mset:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', '[mset] 操作被事件处理器取消');
-			return false;
-		}
-
-		const {
-			keyValuePairs: finalKeyValuePairs,
-			seconds: finalSeconds
-		} = ctx;
-
-		// 先校验所有键的合法性，避免批量写入中途失败导致部分写入（保证原子性）
-		const entries = Object.entries(finalKeyValuePairs);
-		for (const [key] of entries) {
-			if (typeof key !== 'string' || !key) {
-				throw new TypeError('键必须是非空字符串');
-			}
-		}
-
-		// 批量设置键值对
-		for (const [key, value] of entries) {
-			// 检查键是否过期
-			if (this._isExpired(key)) {
-				await this.del(key);
-			}
-
-			this._data[key] = value;
-			this._types[key] = this._getDataTypes(value);
-
-			if (finalSeconds > 0) {
-				this._expires[key] = Date.now() + finalSeconds * 1000;
-			} else {
-				delete this._expires[key];
-			}
-		}
-
-		this.emit('mset:after', {
-			keyValuePairs: finalKeyValuePairs,
-			seconds: finalSeconds,
-			result: true,
-			success: true
-		});
-		return true;
-	} catch (error) {
-		this.emit('mset:error', { keyValuePairs: obj, error });
-		// 参数校验类错误属预期内，用 debug 级别避免误导；运行时错误保留 error 级别
-		if (error instanceof TypeError) {
-			this.log('debug', `[mset] 参数错误: ${error.message}`);
-		} else {
-			this.log('error', 'Failed to mset:', error);
-		}
-		return false;
-	}
-};
-
-/**
- * 批量获取多个键的值
- * @param {Array} keys 键名数组
- * @returns {Promise<Array>} 值数组，按键的顺序返回
- */
-CacheBase.prototype.mget = async function (keys) {
-	try {
-		this.emit('mget:before', { keys });
-
-		if (!Array.isArray(keys)) {
-			return [];
-		}
-
-		const results = [];
-		for (const key of keys) {
-			if (typeof key === 'string') {
-				results.push(await this.get(key));
-			} else {
-				results.push(null);
-			}
-		}
-
-		this.emit('mget:after', { keys, results });
-		return results;
-	} catch (error) {
-		this.log('error', 'Failed to mget:', error);
-		return [];
-	}
-};
-
-// ==================== 键管理 ====================
-
-/**
- * 获取所有键名
- * @param {String} [pattern] 键名匹配模式，支持*通配符
- * @returns {Promise<Array>} 所有键名数组
- */
-CacheBase.prototype.keys = async function (pattern) {
-	try {
-		this.emit('keys:before', { pattern });
-
-		const result = [];
-		for (const key in this._data) {
-			if (!this._isExpired(key)) {
-				if (!pattern || this._matchPattern(key, pattern)) {
-					result.push(key);
-				}
-			}
-		}
-
-		this.emit('keys:after', { pattern, result });
-		return result;
-	} catch (error) {
-		this.log('error', 'Failed to get keys:', error);
-		return [];
-	}
-};
-
-/**
- * 检查键是否匹配指定模式
- * @private
- * @param {String} key 要检查的键名
- * @param {String} pattern 匹配模式，支持*通配符
- * @returns {Boolean} 是否匹配
- */
-CacheBase.prototype._matchPattern = function (key, pattern) {
-	try {
-		// 转义正则元字符（包含 ]）
-		var regexPattern = pattern
-			.replace(/[.+?^${}()|[\]\\]/g, '\\$&')
-			.replace(/\*/g, '.*');
-		var regex = new RegExp('^' + regexPattern + '$');
-		return regex.test(key);
-	} catch (error) {
-		return false;
-	}
-};
-
-/**
- * 获取键的数量
- * @returns {Promise<Number>} 键的数量
- */
-CacheBase.prototype.dbsize = async function () {
-	try {
-		let count = 0;
-		for (const key in this._data) {
-			if (!this._isExpired(key)) {
-				count++;
-			}
-		}
-		return count;
-	} catch (error) {
-		this.log('error', 'Failed to get dbsize:', error);
-		return 0;
-	}
-};
-
-/**
- * 清空所有数据库键
- * @returns {Promise<Boolean>} 操作结果
- */
-CacheBase.prototype.flushdb = async function () {
-	try {
-		const ctx = {
-			cancel: false
-		};
-		this.emit('clear:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		this._data = {};
-		this._expires = {};
-		this._types = {};
-
-		this.emit('clear:after', { success: true });
-		return true;
-	} catch (error) {
-		this.log('error', 'Failed to flushdb:', error);
-		return false;
-	}
-};
-
-/**
- * 清空所有数据（flushdb 别名）
- * @returns {Promise<Boolean>} 操作结果
- */
-CacheBase.prototype.clear = async function () {
-	return this.flushdb();
-};
-
-// ==================== 列表操作 ====================
-
-/**
- * 设置列表
- * @param {String} key 键名
- * @param {Array} value 列表值
- * @param {Number} [seconds=0] 过期时间（秒）
- * @returns {Promise<Number>} 列表长度
- */
-CacheBase.prototype.setForList = async function (key, value, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string') {
-			return 0;
-		}
-
-		// 确保value是数组
-		let stringValues = [];
-		if (Array.isArray(value)) {
-			stringValues = value.map(item => String(item));
-		} else {
-			stringValues = [String(value)];
-		}
-
-		const ctx = {
-			key,
-			value,
-			seconds,
-			cancel: false
-		};
-		this.emit('setForList:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `setForList操作被事件处理器取消 [${key}]`);
-			return 0;
-		}
-
-		const {
-			key: finalKey,
-			value: finalValue,
-			seconds: finalSeconds
-		} = ctx;
-
-		// 重新处理 finalValue
-		let finalStringValues = [];
-		if (Array.isArray(finalValue)) {
-			finalStringValues = finalValue.map(item => String(item));
-		} else {
-			finalStringValues = [String(finalValue)];
-		}
-
-		// 检查键是否存在且未过期
-		if (finalKey in this._data && !this._isExpired(finalKey)) {
-			if (!Array.isArray(this._data[finalKey])) {
-				delete this._data[finalKey];
-				delete this._types[finalKey];
-				delete this._expires[finalKey];
-			}
-		}
-
-		this._data[finalKey] = finalStringValues;
-		this._types[finalKey] = 'array';
-
-		if (finalSeconds > 0) {
-			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
-		} else {
-			delete this._expires[finalKey];
-		}
-
-		const length = finalStringValues.length;
-		this.emit('setForList:after', {
-			key: finalKey,
-			value: finalStringValues,
-			seconds: finalSeconds,
-			result: length
-		});
-		return length;
-	} catch (error) {
-		this.emit('setForList:error', { key, value, seconds, error });
-		this.log('error', 'setForList操作失败:', error);
-		return 0;
-	}
-};
-
-/**
- * 向列表添加元素
- * @param {String} key 键名
- * @param {*} value 要添加的元素
- * @param {Number} [seconds=0] 过期时间（秒）
- * @returns {Promise<Number>} 添加后列表长度
- */
-CacheBase.prototype.addForList = async function (key, value, seconds = 0) {
-	try {
-		if (!key || typeof key !== 'string') {
-			return 0;
-		}
-
-		const ctx = {
-			key,
-			value,
-			seconds,
-			cancel: false
-		};
-		this.emit('addForList:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `addForList操作被事件处理器取消 [${key}]`);
-			return 0;
-		}
-
-		const {
-			key: finalKey,
-			value: finalValue,
-			seconds: finalSeconds
-		} = ctx;
-
-		const stringValue = String(finalValue);
-
-		// 检查键是否存在且未过期
-		if (finalKey in this._data && !this._isExpired(finalKey)) {
-			if (!Array.isArray(this._data[finalKey])) {
-				this._data[finalKey] = [stringValue];
-				this._types[finalKey] = 'array';
-			} else {
-				this._data[finalKey].push(stringValue);
-			}
-		} else {
-			this._data[finalKey] = [stringValue];
-			this._types[finalKey] = 'array';
-		}
-
-		if (finalSeconds > 0) {
-			this._expires[finalKey] = Date.now() + finalSeconds * 1000;
-		} else if (finalKey in this._expires) {
-			delete this._expires[finalKey];
-		}
-
-		const length = this._data[finalKey].length;
-		this.emit('addForList:after', {
-			key: finalKey,
-			value: stringValue,
-			seconds: finalSeconds,
-			result: length
-		});
-		return length;
-	} catch (error) {
-		this.emit('addForList:error', { key, value, seconds, error });
-		this.log('error', 'addForList操作失败:', error);
-		return 0;
-	}
-};
-
-/**
- * 检查列表中是否包含指定元素
- * @param {String} key 键名
- * @param {*} value 要检查的元素
- * @returns {Promise<Boolean>} 是否包含
- */
-CacheBase.prototype.hasForList = async function (key, value) {
-	try {
-		if (!key || typeof key !== 'string') {
-			return false;
-		}
-
-		const ctx = {
-			key,
-			value,
-			cancel: false
-		};
-		this.emit('hasForList:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `hasForList操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		const {
-			key: finalKey,
-			value: finalValue
-		} = ctx;
-
-		const stringValue = String(finalValue);
-
-		if (finalKey in this._data && !this._isExpired(finalKey)) {
-			if (Array.isArray(this._data[finalKey])) {
-				const result = this._data[finalKey].includes(stringValue);
-				this.emit('hasForList:after', { key: finalKey, value: finalValue, result });
-				return result;
-			}
-		}
-
-		this.emit('hasForList:after', { key: finalKey, value: finalValue, result: false });
-		return false;
-	} catch (error) {
-		this.emit('hasForList:error', { key, value, error });
-		this.log('error', 'hasForList操作失败:', error);
-		return false;
-	}
-};
-
-/**
- * 获取列表缓存
- * @param {String} key 键名
- * @param {Number} [start=0] 起始索引
- * @param {Number} [end=-1] 结束索引
- * @returns {Promise<Array>} 列表数组
- */
-CacheBase.prototype.getForList = async function (key, start = 0, end = -1) {
-	try {
-		this.emit('getForList:before', { key, start, end });
-
-		if (!key || typeof key !== 'string') {
-			return [];
-		}
-
-		// 检查是否过期
-		if (this._isExpired(key)) {
-			await this.del(key);
-			return [];
-		}
-
-		// 检查键是否存在
-		if (!(key in this._data)) {
-			return [];
-		}
-
-		// 检查是否为数组
-		if (Array.isArray(this._data[key])) {
-			const array = this._data[key];
-
-			// 处理负索引，符合 Redis LRANGE 语义
-			const startIndex = start < 0
-				? Math.max(0, array.length + start)
-				: start;
-			const endIndex = end < 0
-				? Math.max(0, array.length + end + 1)
-				: end + 1;
-
-			const result = array.slice(startIndex, endIndex);
-			this.emit('getForList:after', { key, start, end, result });
-			return result;
-		}
-
-		return [];
-	} catch (error) {
-		this.log('error', 'getForList操作失败:', error);
-		return [];
-	}
-};
-
-/**
- * 清空列表
- * @param {String} key 键名
- * @returns {Promise<Boolean>} 操作结果
- */
-CacheBase.prototype.clearForList = async function (key) {
-	try {
-		const ctx = {
-			key,
-			cancel: false
-		};
-		this.emit('clearForList:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const {
-			key: finalKey
-		} = ctx;
-
-		if (!finalKey || typeof finalKey !== 'string') {
-			return false;
-		}
-
-		if (finalKey in this._data && !this._isExpired(finalKey)) {
-			if (Array.isArray(this._data[finalKey])) {
-				this._data[finalKey] = [];
-				this.emit('clearForList:after', { key: finalKey, result: true });
-				return true;
-			} else {
-				delete this._data[finalKey];
-				delete this._types[finalKey];
-				delete this._expires[finalKey];
-				this.emit('clearForList:after', { key: finalKey, result: false });
-				return false;
-			}
-		}
-
-		this._data[finalKey] = [];
-		this._types[finalKey] = 'array';
-		this.emit('clearForList:after', { key: finalKey, result: true });
-		return true;
-	} catch (error) {
-		this.emit('clearForList:error', { key, error });
-		this.log('error', 'clearForList操作失败:', error);
-		return false;
-	}
-};
-
-// ==================== 集合操作 ====================
-
-/**
- * 将成员添加到集合
- * @param {String} key 键
- * @param {String|Array} members 成员或成员数组
- * @returns {Promise<Number>} 添加的成员数量
- */
-CacheBase.prototype.sadd = async function (key, members) {
-	try {
-		const ctx = {
-			key,
-			members: Array.isArray(members) ? members : [members],
-			cancel: false
-		};
-		this.emit('sadd:before', ctx);
-
-		if (ctx.cancel) {
-			return 0;
-		}
-
-		const {
-			key: finalKey,
-			members: finalMembers
-		} = ctx;
-
-		// 检查是否过期
-		if (this._isExpired(finalKey)) {
-			await this.del(finalKey);
-		}
-
-		// 初始化集合
-		if (!(finalKey in this._data) || this._types[finalKey] !== 'set') {
-			this._data[finalKey] = new Set();
-			this._types[finalKey] = 'set';
-		}
-
-		const set = this._data[finalKey];
-		let addedCount = 0;
-		for (const member of finalMembers) {
-			const memberStr = String(member);
-			if (!set.has(memberStr)) {
-				set.add(memberStr);
-				addedCount++;
-			}
-		}
-
-		this.emit('sadd:after', {
-			key: finalKey,
-			members: finalMembers,
-			result: addedCount
-		});
-		return addedCount;
-	} catch (error) {
-		this.log('error', `添加集合成员失败 [${key}]:`, error);
-		this.emit('sadd:error', { key, members, error });
-		return 0;
-	}
-};
-
-/**
- * 从集合中移除成员
- * @param {String} key 键
- * @param {String|Array} members 成员或成员数组
- * @returns {Promise<Number>} 移除的成员数量
- */
-CacheBase.prototype.srem = async function (key, members) {
-	try {
-		const ctx = {
-			key,
-			members: Array.isArray(members) ? members : [members],
-			cancel: false
-		};
-		this.emit('srem:before', ctx);
-
-		if (ctx.cancel) {
-			return 0;
-		}
-
-		const {
-			key: finalKey,
-			members: finalMembers
-		} = ctx;
-
-		if (!(finalKey in this._data) || this._types[finalKey] !== 'set') {
-			return 0;
-		}
-
-		const set = this._data[finalKey];
-		let removedCount = 0;
-		for (const member of finalMembers) {
-			const memberStr = String(member);
-			if (set.has(memberStr)) {
-				set.delete(memberStr);
-				removedCount++;
-			}
-		}
-
-		// 如果集合为空，删除整个键
-		if (set.size === 0) {
-			delete this._data[finalKey];
-			delete this._types[finalKey];
-			delete this._expires[finalKey];
-		}
-
-		this.emit('srem:after', {
-			key: finalKey,
-			members: finalMembers,
-			result: removedCount
-		});
-		return removedCount;
-	} catch (error) {
-		this.log('error', `移除集合成员失败 [${key}]:`, error);
-		this.emit('srem:error', { key, members, error });
-		return 0;
-	}
-};
-
-/**
- * 检查成员是否在集合中
- * @param {String} key 键
- * @param {String} member 成员
- * @returns {Promise<Boolean>} 是否存在
- */
-CacheBase.prototype.sismember = async function (key, member) {
-	try {
-		this.emit('sismember:before', { key, member });
-
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-		if (member === undefined || member === null) {
-			throw new TypeError('member不能为undefined或null');
-		}
-
-		if (this._isExpired(key)) {
-			await this.del(key);
-			return false;
-		}
-
-		if (!(key in this._data) || this._types[key] !== 'set') {
-			return false;
-		}
-
-		const memberStr = String(member);
-		const result = this._data[key].has(memberStr);
-		this.emit('sismember:after', { key, member, result });
-		return result;
-	} catch (error) {
-		this.emit('sismember:error', { key, member, error });
-		this.log('error', `检查集合成员失败 [${key}:${member}]:`, error);
-		return false;
-	}
-};
-
-/**
- * 获取集合中的所有成员
- * @param {String} key 键
- * @returns {Promise<Array>} 成员数组
- */
-CacheBase.prototype.smembers = async function (key) {
-	try {
-		this.emit('smembers:before', { key });
-
-		if (this._isExpired(key)) {
-			await this.del(key);
-			return [];
-		}
-
-		if (!(key in this._data) || this._types[key] !== 'set') {
-			return [];
-		}
-
-		const result = Array.from(this._data[key]);
-		this.emit('smembers:after', { key, result });
-		return result;
-	} catch (error) {
-		this.log('error', `获取集合所有成员失败 [${key}]:`, error);
-		this.emit('smembers:error', { key, error });
-		return [];
-	}
-};
-
-/**
- * 获取集合中的成员数量
- * @param {String} key 键
- * @returns {Promise<Number>} 成员数量
- */
-CacheBase.prototype.scard = async function (key) {
-	try {
-		if (this._isExpired(key)) {
-			await this.del(key);
-			return 0;
-		}
-
-		if (!(key in this._data) || this._types[key] !== 'set') {
-			return 0;
-		}
-
-		return this._data[key].size;
-	} catch (error) {
-		this.log('error', `获取集合成员数量失败 [${key}]:`, error);
-		return 0;
-	}
-};
-
-/**
- * 获取多个集合的交集
- * @param {...String} keys 键名列表
- * @returns {Promise<Array>} 交集成员数组
- */
-CacheBase.prototype.sinter = async function (...keys) {
-	try {
-		if (keys.length === 0) {
-			return [];
-		}
-
-		const sets = [];
-		for (const key of keys) {
-			if (this._isExpired(key)) {
-				await this.del(key);
-				return [];
-			}
-			if (!(key in this._data) || this._types[key] !== 'set') {
-				return [];
-			}
-			sets.push(this._data[key]);
-		}
-
-		const result = Array.from(sets[0]).filter(member =>
-			sets.every(set => set.has(member))
-		);
-		return result;
-	} catch (error) {
-		this.log('error', '获取集合交集失败:', error);
-		return [];
-	}
-};
-
-/**
- * 获取多个集合的并集
- * @param {...String} keys 键名列表
- * @returns {Promise<Array>} 并集成员数组
- */
-CacheBase.prototype.sunion = async function (...keys) {
-	try {
-		if (keys.length === 0) {
-			return [];
-		}
-
-		const resultSet = new Set();
-		for (const key of keys) {
-			if (this._isExpired(key)) {
-				await this.del(key);
-				continue;
-			}
-			if (key in this._data && this._types[key] === 'set') {
-				for (const member of this._data[key]) {
-					resultSet.add(member);
-				}
-			}
-		}
-
-		return Array.from(resultSet);
-	} catch (error) {
-		this.log('error', '获取集合并集失败:', error);
-		return [];
-	}
-};
-
-/**
- * 获取多个集合的差集（第一个集合减去其余集合）
- * @param {...String} keys 键名列表
- * @returns {Promise<Array>} 差集成员数组
- */
-CacheBase.prototype.sdiff = async function (...keys) {
-	try {
-		if (keys.length === 0) {
-			return [];
-		}
-
-		const firstKey = keys[0];
-		if (this._isExpired(firstKey)) {
-			await this.del(firstKey);
-			return [];
-		}
-		if (!(firstKey in this._data) || this._types[firstKey] !== 'set') {
-			return [];
-		}
-
-		const firstSet = this._data[firstKey];
-		const otherSets = [];
-		for (let i = 1; i < keys.length; i++) {
-			const key = keys[i];
-			if (this._isExpired(key)) {
-				await this.del(key);
-				continue;
-			}
-			if (key in this._data && this._types[key] === 'set') {
-				otherSets.push(this._data[key]);
-			}
-		}
-
-		const result = Array.from(firstSet).filter(member =>
-			!otherSets.some(set => set.has(member))
-		);
-		return result;
-	} catch (error) {
-		this.log('error', '获取集合差集失败:', error);
-		return [];
-	}
-};
-
-// ==================== 有序集合操作 ====================
-
-/**
- * 添加成员到有序集合
- * @param {String} key 键
- * @param {Number} score 分数
- * @param {String} member 成员
- * @returns {Promise<Boolean>} 是否成功（新成员返回true，更新返回false）
- */
-CacheBase.prototype.zadd = async function (key, score, member) {
-	try {
-		const ctx = {
-			key,
-			score,
-			member,
-			cancel: false
-		};
-		this.emit('zadd:before', ctx);
-
-		if (ctx.cancel) {
-			return false;
-		}
-
-		const {
-			key: finalKey,
-			score: finalScore,
-			member: finalMember
-		} = ctx;
-
-		// 检查是否过期
-		if (this._isExpired(finalKey)) {
-			await this.del(finalKey);
-		}
-
-		// 初始化有序集合
-		if (!(finalKey in this._data) || this._types[finalKey] !== 'zset') {
-			this._data[finalKey] = new Map();
-			this._types[finalKey] = 'zset';
-		}
-
-		const map = this._data[finalKey];
-		const memberStr = String(finalMember);
-		const isNew = !map.has(memberStr);
-		map.set(memberStr, Number(finalScore));
-
-		this.emit('zadd:after', {
-			key: finalKey,
-			score: finalScore,
-			member: finalMember,
-			success: isNew
-		});
-		return isNew;
-	} catch (error) {
-		this.log('error', `添加有序集合成员失败 [${key}]:`, error);
-		this.emit('zadd:error', { key, score, member, error });
-		return false;
-	}
-};
-
-/**
- * 从有序集合中移除成员
- * @param {String} key 键
- * @param {String|Array} members 成员或成员数组
- * @returns {Promise<Number>} 移除的成员数量
- */
-CacheBase.prototype.zrem = async function (key, members) {
-	try {
-		const ctx = {
-			key,
-			members: Array.isArray(members) ? members : [members],
-			cancel: false
-		};
-		this.emit('zrem:before', ctx);
-
-		if (ctx.cancel) {
-			return 0;
-		}
-
-		const {
-			key: finalKey,
-			members: finalMembers
-		} = ctx;
-
-		if (!(finalKey in this._data) || this._types[finalKey] !== 'zset') {
-			return 0;
-		}
-
-		const map = this._data[finalKey];
-		let removedCount = 0;
-		for (const member of finalMembers) {
-			const memberStr = String(member);
-			if (map.has(memberStr)) {
-				map.delete(memberStr);
-				removedCount++;
-			}
-		}
-
-		// 如果有序集合为空，删除整个键
-		if (map.size === 0) {
-			delete this._data[finalKey];
-			delete this._types[finalKey];
-			delete this._expires[finalKey];
-		}
-
-		this.emit('zrem:after', {
-			key: finalKey,
-			members: finalMembers,
-			result: removedCount
-		});
-		return removedCount;
-	} catch (error) {
-		this.log('error', `移除有序集合成员失败 [${key}]:`, error);
-		this.emit('zrem:error', { key, members, error });
-		return 0;
-	}
-};
-
-/**
- * 获取有序集合中成员的分数
- * @param {String} key 键
- * @param {String} member 成员
- * @returns {Promise<Number|null>} 分数，不存在返回null
- */
-CacheBase.prototype.zscore = async function (key, member) {
-	try {
-		if (this._isExpired(key)) {
-			await this.del(key);
-			return null;
-		}
-
-		if (!(key in this._data) || this._types[key] !== 'zset') {
-			return null;
-		}
-
-		const memberStr = String(member);
-		const map = this._data[key];
-		if (!map.has(memberStr)) {
-			return null;
-		}
-		return map.get(memberStr);
-	} catch (error) {
-		this.log('error', `获取有序集合成员分数失败 [${key}:${member}]:`, error);
-		return null;
-	}
-};
+const CacheBase = require('./lib/cachebase');
+const Admin = require('mm_corejs').Admin;
 
 /**
- * 获取有序集合中成员的排名（分数从小到大）
- * @param {String} key 键
- * @param {String} member 成员
- * @returns {Promise<Number|null>} 排名，不存在返回null
+ * 缓存管理器实例（Admin 工厂）
  */
-CacheBase.prototype.zrank = async function (key, member) {
-	try {
-		if (this._isExpired(key)) {
-			await this.del(key);
-			return null;
-		}
-
-		if (!(key in this._data) || this._types[key] !== 'zset') {
-			return null;
-		}
-
-		const memberStr = String(member);
-		const map = this._data[key];
-		if (!map.has(memberStr)) {
-			return null;
-		}
-
-		// 按分数从小到大排序
-		const sorted = Array.from(map.entries()).sort((a, b) => a[1] - b[1]);
-		const rank = sorted.findIndex(([m]) => m === memberStr);
-		return rank >= 0 ? rank : null;
-	} catch (error) {
-		this.log('error', `获取有序集合成员排名失败 [${key}:${member}]:`, error);
-		return null;
-	}
-};
-
-/**
- * 获取有序集合中指定范围的成员
- * @param {String} key 键
- * @param {Number} start 起始索引
- * @param {Number} stop 结束索引
- * @param {Boolean} [withScores=false] 是否返回分数
- * @returns {Promise<Array>} 成员数组
- */
-CacheBase.prototype.zrange = async function (key, start, stop, withScores = false) {
-	try {
-		if (this._isExpired(key)) {
-			await this.del(key);
-			return [];
-		}
-
-		if (!(key in this._data) || this._types[key] !== 'zset') {
-			return [];
-		}
-
-		const map = this._data[key];
-		// 按分数从小到大排序
-		const sorted = Array.from(map.entries()).sort((a, b) => a[1] - b[1]);
-		const len = sorted.length;
-
-		// 处理负索引
-		let startIndex = start < 0 ? Math.max(0, len + start) : start;
-		let endIndex = stop < 0 ? Math.max(0, len + stop + 1) : stop + 1;
-
-		if (startIndex >= len) {
-			return [];
-		}
-
-		const slice = sorted.slice(startIndex, endIndex);
-		if (withScores) {
-			return slice.map(([member, score]) => ({ member, score }));
-		}
-		return slice.map(([member]) => member);
-	} catch (error) {
-		this.log('error', `获取有序集合范围成员失败 [${key}]:`, error);
-		return [];
-	}
-};
-
-/**
- * 获取有序集合中的成员数量
- * @param {String} key 键
- * @returns {Promise<Number>} 成员数量
- */
-CacheBase.prototype.zcard = async function (key) {
-	try {
-		if (this._isExpired(key)) {
-			await this.del(key);
-			return 0;
-		}
-
-		if (!(key in this._data) || this._types[key] !== 'zset') {
-			return 0;
-		}
-
-		return this._data[key].size;
-	} catch (error) {
-		this.log('error', `获取有序集合成员数量失败 [${key}]:`, error);
-		return 0;
-	}
-};
-
-/**
- * 增加有序集合成员的分数
- * @param {String} key 键
- * @param {Number} increment 增量
- * @param {String} member 成员
- * @returns {Promise<Number>} 增加后的分数
- */
-CacheBase.prototype.zincrby = async function (key, increment, member) {
-	try {
-		// 检查是否过期
-		if (this._isExpired(key)) {
-			await this.del(key);
-		}
-
-		// 初始化有序集合
-		if (!(key in this._data) || this._types[key] !== 'zset') {
-			this._data[key] = new Map();
-			this._types[key] = 'zset';
-		}
-
-		const map = this._data[key];
-		const memberStr = String(member);
-		const currentScore = map.has(memberStr) ? map.get(memberStr) : 0;
-		const newScore = currentScore + Number(increment);
-		map.set(memberStr, newScore);
-
-		return newScore;
-	} catch (error) {
-		this.log('error', `增加有序集合成员分数失败 [${key}:${member}]:`, error);
-		return null;
-	}
-};
-
-// ==================== 发布订阅 ====================
-
-/**
- * 消息订阅
- * @param {String} channel 订阅的频道
- * @param {Function} func 操作回调函数
- * @returns {Promise<Boolean>} 订阅结果
- */
-CacheBase.prototype.subscribe = async function (channel, func) {
-	if (!channel || typeof channel !== 'string') {
-		throw new TypeError('channel必须是非空字符串');
-	}
-	if (typeof func !== 'function') {
-		throw new TypeError('func必须是函数');
-	}
-
-	try {
-		this._channels[channel] = func;
-		return true;
-	} catch (err) {
-		this.log('error', `订阅频道 ${channel} 失败:`, err);
-		return false;
-	}
-};
-
-/**
- * 取消订阅
- * @param {String} channel 订阅的频道
- * @returns {Promise<Boolean>} 取消订阅结果
- */
-CacheBase.prototype.unsubscribe = async function (channel) {
-	if (!channel || typeof channel !== 'string') {
-		throw new TypeError('channel必须是非空字符串');
-	}
-
-	try {
-		delete this._channels[channel];
-		return true;
-	} catch (err) {
-		this.log('error', `取消订阅频道 ${channel} 失败:`, err);
-		return false;
-	}
-};
-
-/**
- * 发布消息
- * @param {String} channel 频道
- * @param {String} message 消息
- * @returns {Promise<Number>} 接收消息的订阅者数量
- */
-CacheBase.prototype.publish = async function (channel, message) {
-	if (!channel || typeof channel !== 'string') {
-		throw new TypeError('channel必须是非空字符串');
-	}
-	if (message === undefined || message === null) {
-		throw new TypeError('message不能为undefined或null');
-	}
-
-	try {
-		const func = this._channels[channel];
-		if (func) {
-			try {
-				func(message);
-			} catch (err) {
-				this.log('error', `处理频道 ${channel} 的消息时出错:`, err);
-			}
-			return 1;
-		}
-		return 0;
-	} catch (err) {
-		this.log('error', `发布消息到频道 ${channel} 失败:`, err);
-		return 0;
-	}
-};
-
-/**
- * 订阅消息处理, 如果没有订阅函数，则其他的订阅消息会进入该函数
- * @param {String} channel 频道
- * @param {String} message 消息
- */
-CacheBase.prototype.main = async function (channel, message) {
-	// 默认实现，可由子类重写
-	this.log('debug', `收到未处理的消息 [${channel}]:`, message);
-};
-
-/**
- * 消息通知
- * @param {String} channel 频道
- * @param {String} message 消息
- */
-CacheBase.prototype.message = function (channel, message) {
-	var func = this._channels[channel];
-	if (func) {
-		try {
-			func(message);
-		} catch (err) {
-			this.log('error', `处理频道 ${channel} 的消息时出错:`, err);
-		}
-	} else {
-		this.main(channel, message);
-	}
-};
-
-// ==================== 连接池管理 ====================
-
-/**
- * 确保连接池对象存在
- */
-global.$ = global.$ || {};
-if (!$.pool) {
-	$.pool = {};
-}
-if (!$.pool.cachebase) {
-	$.pool.cachebase = {};
-}
+const admin = new Admin();
+admin.setClass(CacheBase);
 
 /**
  * @description CacheBase管理器，用于创建缓存
@@ -3144,32 +14,15 @@ if (!$.pool.cachebase) {
  * @return {Object} 返回一个CacheBase类实例
  */
 function cachebaseAdmin(scope, config) {
-	if (!global.$) {
-		global.$ = {};
-	}
-	if (!$.pool) {
-		$.pool = {};
-	}
-	if (!$.pool.cachebase) {
-		$.pool.cachebase = {};
-	}
 	if (!scope) {
-		scope = 'sys';
-	}
-	var obj = $.pool.cachebase[scope];
-	if (!obj) {
-		const dbConfig = {
-			scope: scope,
-			...(typeof config === 'object' && config ? config : {})
-		};
-		$.pool.cachebase[scope] = new CacheBase(dbConfig);
-		obj = $.pool.cachebase[scope];
+		scope = 'os';
 	}
-	return obj;
+	return admin.get(scope, config);
 }
 
 // 导出类
 module.exports = {
 	CacheBase,
+	admin,
 	cachebaseAdmin
-};
+};