mm_cachebase 2.0.4 → 2.0.5

package/lib/cachebase.js

@@ -0,0 +1,3125 @@
+/**
+ * CacheBase 是一个通用缓存基类，支持内存缓存和持久化缓存
+ * 接口与 mm_redis 完全对齐：全异步、冒号风格事件、统一签名与返回值
+ * @class CacheBase
+ * @extends Base
+ */
+const Base = require('mm_corejs').Base;
+const { fullname, hasFile, loadJson, saveJson, addDir } = require('mm_helper');
+
+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 = fullname('./config/cachebase.config.json', __dirname);
+		if (hasFile(config_path)) {
+			const config = loadJson(config_path);
+			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 = fullname(`./${scope}.json`, 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 (hasFile(this.file_path)) {
+				// 使用mm_helper的函数读取JSON文件
+				const parsed_data = loadJson(this.file_path);
+				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) {
+			// 确保目录存在
+			addDir(this.file_path);
+
+			const data_to_save = {
+				data: this._data,
+				expires: this._expires,
+				types: this._types,
+				timestamp: Date.now()
+			};
+
+			// 使用mm_helper的函数写入JSON文件
+			saveJson(this.file_path, 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;
+
+		// 触发销毁事件
+		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;
+	}
+};
+
+/**
+ * 获取有序集合中成员的排名（分数从小到大）
+ * @param {String} key 键
+ * @param {String} member 成员
+ * @returns {Promise<Number|null>} 排名，不存在返回null
+ */
+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);
+	}
+};
+
+module.exports = CacheBase;