mm_redis 2.1.6 → 2.1.8

package/index.js

@@ -1,4116 +1,16 @@
-const {
-	createClient
-} = require('redis');
-const { Base } = require('mm_expand');
+const Redis = require('./lib/redis');
+const Admin = require('mm_corejs').Admin;
 
-/**
- * @class Redis
- * @description Redis缓存帮助类函数
- */
-class Redis extends Base {
-	static config = {
-		// 服务器地址
-		"host": "localhost",
-		// 端口号
-		"port": 6379,
-		// 密码
-		"password": "asd159357",
-		// 数据库
-		"database": 0,
-		// 前缀
-		"prefix": "",
-		// 连接超时时间(ms)
-		"connect_timeout": 10000,
-		// 重试次数
-		"retry_count": 3,
-		// 重试间隔(ms)
-		"retry_delay": 1000,
-		// 连接池配置
-		"max_clients": 100, // 最大连接数
-		"min_idle": 5, // 最小空闲连接数
-		"max_idle": 20, // 最大空闲连接数
-		"idle_timeout": 30000 // 空闲超时时间(ms)
-	};
-	/**
-	 * @description 创建Redis帮助类函数 (构造函数)
-	 * @param {Object} config 配置参数
-	 * @constructor
-	 */
-	constructor(config) {
-		super(Redis.config);
-		// 初始化连接池
-		this._initPool();
-		// 唯一标识符
-		this.identifier = this.config.host + "/" + this.config.database;
-		// 数据库连接器
-		this.conn = null;
-		// 连接状态
-		this.connected = false;
-		// 重试次数计数器
-		this.retry_count = 0;
-		// 订阅回调函数
-		this.func_list = {};
-		this.setConfig(config);
-	}
-}
-
-/**
- * 应用键前缀
- * @param {String} key 键
- * @return {String} 处理后的键
- * @private
- */
-Redis.prototype._addPrefix = function (key) {
-	return this.config.prefix ? this.config.prefix + key : key;
-};
-
-/**
- * 移除键前缀
- * @param {String} key 带前缀的键
- * @return {String} 处理后的键
- * @private
- */
-Redis.prototype._delPrefix = function (key) {
-	if (this.config.prefix && key.startsWith(this.config.prefix)) {
-		return key.slice(this.config.prefix.length);
-	}
-	return key;
-};
-
-/**
- * 消息订阅
- * @param {String} channel 订阅的频道
- * @param {Function} func 操作回调函数，可判断成功与否
- * @return {Promise<Boolean>} 订阅结果
- */
-Redis.prototype.subscribe = async function (channel, func) {
-	// 参数验证
-	if (!channel || typeof channel !== 'string') {
-		throw new TypeError('channel必须是非空字符串');
-	}
-	if (typeof func !== 'function') {
-		throw new TypeError('func必须是函数');
-	}
-
-	try {
-		await this.conn.subscribe(this._addPrefix(channel));
-		this.func_list[channel] = func;
-		return true;
-	} catch (err) {
-		this.log('error', `订阅频道 ${channel} 失败:`, err);
-		return false;
-	}
-};
-
-/**
- * 取消订阅
- * @param {String} channel 订阅的频道
- * @return {Promise<Boolean>} 取消订阅结果
- */
-Redis.prototype.unsubscribe = async function (channel) {
-	// 参数验证
-	if (!channel || typeof channel !== 'string') {
-		throw new TypeError('channel必须是非空字符串');
-	}
-
-	try {
-		await this.conn.unsubscribe(this._addPrefix(channel));
-		delete this.func_list[channel];
-		return true;
-	} catch (err) {
-		this.log('error', `取消订阅频道 ${channel} 失败:`, err);
-		return false;
-	}
-};
-
-/**
- * 发布消息
- * @param {String} channel 频道
- * @param {String} message 订阅的消息
- * @return {Promise<Number>} 接收消息的客户端数量
- */
-Redis.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 {
-		return await this.conn.publish(this._addPrefix(channel), message);
-	} catch (err) {
-		this.log('error', `发布消息到频道 ${channel} 失败:`, err);
-		return false;
-	}
-};
-
-/**
- * 订阅消息处理, 如果没有订阅函数，则其他的订阅消息会进入该函数
- * @param {String} channel
- * @param {String} message
- */
-Redis.prototype.main = async function (channel, message) {
-	// 默认实现，可由子类重写
-	this.log('debug', `收到未处理的消息 [${channel}]:`, message);
-};
-
-/**
- * 消息通知
- * @param {String} channel 频道
- * @param {String} message 消息
- */
-Redis.prototype.message = function (channel, message) {
-	// 移除前缀
-	channel = this._delPrefix(channel);
-	var func = this.func_list[channel];
-	if (func) {
-		try {
-			func(message);
-		} catch (err) {
-			this.log('error', `处理频道 ${channel} 的消息时出错:`, err);
-		}
-	} else {
-		this.main(channel, message);
-	}
-};
-
-/**
- * @description 设置配置
- * @param {Object} config 配置对象或配置路径
- */
-Redis.prototype.setConfig = function (config) {
-	let obj = {};
-	if (typeof config === 'string') {
-		obj = config.loadJson(__dirname);
-	} else if (config) {
-		// 合并配置参数
-		Object.assign(this.config, config);
-	} else {
-		return;
-	}
-
-	// 初始化连接池
-	this._initPool();
-	// this.log('debug','配置已更新');
-	this.identifier = this.config.host + "/" + this.config.database;
-	return this;
-};
-
-// 添加连接池初始化方法
-Redis.prototype._initPool = function () {
-	// 确保连接池配置存在
-
-	// 初始化连接池相关属性
-	this.connection_pool = {
-		available: [],
-		in_use: new Set(),
-		config: this.config // 直接引用配置对象，确保同步更新
-	};
-
-	// 记录连接池初始化
-	// this.log('debug','连接池已初始化，配置:', this.config);
-};
-
-/**
- * @description 连接Redis数据库
- * @return {Promise<Boolean>} 连接结果
- */
-Redis.prototype.open = async function () {
-	if (this.conn && this.connected) {
-		return true;
-	}
-
-	try {
-		const cg = this.config;
-		this.retry_count = 0;
-
-		// 创建客户端
-		this.conn = createClient({
-			socket: {
-				host: cg.host,
-				port: cg.port,
-				timeout: cg.connect_timeout
-			},
-			password: cg.password,
-			database: cg.database
-		});
-
-		// 监听错误事件
-		this.conn.on('error', (err) => {
-			this.log('error', 'Redis连接错误:', err);
-			this.connected = false;
-			// 尝试重连
-			this._reconnect();
-		});
-
-		// 监听连接成功事件
-		this.conn.on('connect', () => {
-			// this.log('debug','Redis已连接');
-			this.connected = true;
-			this.retry_count = 0;
-		});
-
-		// 监听断开连接事件
-		this.conn.on('end', () => {
-			// this.log('debug','Redis连接已断开');
-			this.connected = false;
-		});
-
-		// 监听订阅成功事件
-		this.conn.on('subscribe', (channel, count) => {
-			this.log('debug', `频道${this._delPrefix(channel)}订阅成功, 当前总计订阅数：${count}`);
-		});
-
-		// 监听取消订阅事件
-		this.conn.on('unsubscribe', (channel, count) => {
-			this.log('debug', `频道${this._delPrefix(channel)}取消订阅, 当前总计订阅数：${count}`);
-		});
-
-		// 收到消息后执行回调
-		this.conn.on('message', (channel, message) => {
-			this.message(channel, message);
-		});
-
-		// 连接Redis
-		await this.conn.connect();
-		this.connected = true;
-		return true;
-	} catch (err) {
-		this.log('error', 'Redis连接失败:', err);
-		// 尝试重连
-		this._reconnect();
-		return false;
-	}
-};
-
-/**
- * 内部重连方法
- * @private
- */
-Redis.prototype._reconnect = function () {
-	if (this.retry_count >= this.config.retry_count) {
-		this.log('error', `达到最大重连次数 ${this.config.retry_count}，停止重连`);
-		return;
-	}
-
-	this.retry_count++;
-	this.log('debug', `尝试第 ${this.retry_count} 次重连...`);
-
-	setTimeout(async () => {
-		try {
-			await this.open();
-		} catch (err) {
-			this.log('error', `重连失败:`, err);
-		}
-	}, this.config.retry_delay);
-};
-
-/**
- * @description 关闭连接
- * @return {Promise<Boolean>} 关闭结果
- */
-// 修复close方法，正确处理连接池
-Redis.prototype.close = function () {
-	try {
-		// this.log('debug','关闭所有连接...');
-
-		// 关闭所有使用中的连接
-		if (this.connection_pool && this.connection_pool.in_use) {
-			for (const connection of this.connection_pool.in_use) {
-				try {
-					connection.close();
-				} catch (e) {
-					this.log('error', '关闭连接失败:', e);
-				}
-			}
-			this.connection_pool.in_use.clear();
-		}
-
-		// 关闭所有可用连接
-		if (this.connection_pool && this.connection_pool.available) {
-			for (const connection of this.connection_pool.available) {
-				try {
-					// 检查连接对象是否有close方法
-					if (typeof connection.close === 'function') {
-						connection.close();
-					} else if (typeof connection.end === 'function') {
-						// 某些Redis客户端可能使用end方法
-						connection.end();
-					} else {
-						this.log('debug', '连接对象没有可用的关闭方法');
-					}
-				} catch (e) {
-					this.log('error', '关闭连接失败:', e);
-				}
-			}
-			this.connection_pool.available = [];
-		}
-
-		this.connected = false;
-		this.log('debug', 'Redis连接已断开');
-		return Promise.resolve(true);
-	} catch (error) {
-		this.log('error', '关闭连接时发生错误:', error);
-		return Promise.resolve(false);
-	}
-};
-
-// 添加Pipeline支持
-Redis.prototype.pipeline = function () {
-	const redisInstance = this;
-	const commands = [];
-
-	return {
-		// 设置值
-		set: function (key, value, seconds) {
-			commands.push(['set', key, value, seconds]);
-			return this;
-		},
-
-		// 获取值
-		get: function (key) {
-			commands.push(['get', key]);
-			return this;
-		},
-
-		// 删除
-		del: function (key) {
-			commands.push(['del', key]);
-			return this;
-		},
-
-		// 判断存在
-		has: function (key) {
-			commands.push(['has', key]);
-			return this;
-		},
-
-		// 设置哈希字段
-		hset: function (key, field, value) {
-			commands.push(['hset', key, field, value]);
-			return this;
-		},
-
-		// 过期时间设置
-		expire: function (key, seconds) {
-			commands.push(['expire', key, seconds]);
-			return this;
-		},
-
-		// 执行所有命令
-		exec: async function () {
-			try {
-				// 使用Redis实例的方法获取连接
-				const connection = await redisInstance._getConnection();
-				const results = [];
-
-				// 依次执行所有命令
-				for (const cmd of commands) {
-					try {
-						let result;
-						const [command, ...args] = cmd;
-
-						// 根据命令类型直接调用对应的方法
-						switch (command) {
-							case 'set': {
-								// 键前缀处理和值序列化
-								const [key, value, seconds] = args;
-								const prefixedKey = redisInstance._addPrefix(key);
-								let processedValue = value;
-								if (typeof value === 'object' && value !== null) {
-									processedValue = JSON.stringify(value);
-								}
-								result = await connection.set(prefixedKey, processedValue);
-								// 设置过期时间
-								if (seconds && seconds > 0) {
-									await connection.expire(prefixedKey, seconds);
-								}
-								break;
-							}
-							case 'get': {
-								const [key] = args;
-								const prefixedKey = redisInstance._addPrefix(key);
-								result = await connection.get(prefixedKey);
-								// 尝试解析JSON
-								if (typeof result === 'string') {
-									try {
-										if (result.startsWith('{') && result.endsWith('}') ||
-											result.startsWith('[') && result.endsWith(']')) {
-											result = JSON.parse(result);
-										}
-									} catch (e) {
-										// 解析失败，保持原样
-									}
-								}
-								break;
-							}
-							case 'del': {
-								const [key] = args;
-								const prefixedKey = redisInstance._addPrefix(key);
-								result = await connection.del(prefixedKey);
-								break;
-							}
-							case 'has': {
-								const [key] = args;
-								const prefixedKey = redisInstance._addPrefix(key);
-								result = await connection.exists(prefixedKey) > 0;
-								break;
-							}
-							case 'hset': {
-								const [key, field, value] = args;
-								const prefixedKey = redisInstance._addPrefix(key);
-								result = await connection.hSet(prefixedKey, field, value);
-								break;
-							}
-							case 'expire': {
-								const [key, seconds] = args;
-								const prefixedKey = redisInstance._addPrefix(key);
-								result = await connection.expire(prefixedKey, seconds);
-								break;
-							}
-							default:
-								// 对于其他命令，直接返回null
-								result = null;
-								break;
-						}
-
-						// 直接返回结果值，符合测试期望的格式
-						results.push(result);
-					} catch (err) {
-						this.log('error', `Pipeline命令执行失败 [${cmd[0]}]:`, err);
-						results.push(null);
-					}
-				}
-
-				// 释放连接回连接池
-				redisInstance._recycleConnection(connection);
-				return results;
-			} catch (error) {
-				this.log('error', 'Pipeline执行失败:', error);
-				return [];
-			}
-		}
-	};
-};
-
-/**
- * @description 检查连接状态
- * @return {Boolean} 连接状态
- */
-Redis.prototype.isConnected = function () {
-	return this.connected && this.conn && this.conn.isReady;
-};
-
-/**
- * 获取或设置键的过期时间
- * @param {String} key 键名
- * @param {Number} [seconds] 过期时间（秒），不传此参数则获取剩余过期时间
- * @return {Promise<Number|Boolean>} 不传seconds时返回剩余过期时间（-1表示无过期设置，-2表示已过期），传seconds时返回是否设置成功
- */
-Redis.prototype.ttl = async function (key, seconds) {
-	// 参数验证
-	if (!key || typeof key !== 'string') {
-		throw new TypeError('key必须是非空字符串');
-	}
-
-	try {
-
-		const connection = await this._getConnection();
-		try {
-			key = this._addPrefix(key);
-
-			// 如果传入了seconds参数，则设置过期时间
-			if (seconds !== undefined) {
-				if (typeof seconds !== 'number' || isNaN(seconds) || seconds < 0) {
-					return false;
-				}
-
-				// 设置过期时间
-				if (typeof connection.expire === 'function') {
-					await connection.expire(key, seconds);
-					return true;
-				} else if (typeof connection.execute === 'function') {
-					await connection.execute('EXPIRE', [key, seconds]);
-					return true;
-				} else {
-					this.log('error', '连接对象不支持expire操作');
-					return false;
-				}
-			}
-
-			// 否则获取剩余过期时间
-			if (typeof connection.ttl === 'function') {
-				return await connection.ttl(key);
-			} else if (typeof connection.execute === 'function') {
-				return await connection.execute('TTL', [key]);
-			} else {
-				this.log('error', '连接对象不支持ttl操作');
-				return -2; // 默认返回键不存在
-			}
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `${seconds !== undefined ? '设置' : '获取'}过期时间失败 [${key}]:`, err);
-		return seconds !== undefined ? false : -2;
-	}
-};
-
-/**
- * @description 增加整数值(负数为减)（兼容方法）
- * @param {String} key 键
- * @param {Number} num 数值
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 计算后的结果
- */
-Redis.prototype.addInt = async function (key, num, seconds = 0) {
-	// 参数验证
-	if (!key || typeof key !== 'string') {
-		throw new TypeError('key必须是非空字符串');
-	}
-	if (typeof num !== 'number' || isNaN(num) || !Number.isInteger(num)) {
-		throw new TypeError('num必须是有效整数');
-	}
-
-	try {
-
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			value: num,
-			seconds,
-			cancel: false
-		};
-		this.emit('addInt:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回false
-		if (ctx.cancel) {
-			this.log('debug', `addInt操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		// 使用可能被修改的值
-		let {
-			key: finalKey,
-			value: finalNum,
-			seconds: finalSeconds
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-			let result;
-			if (finalNum > 0) {
-				// 增加整数值
-				if (typeof connection.incrBy === 'function') {
-					result = await connection.incrBy(prefixedKey, finalNum);
-				} else if (typeof connection.execute === 'function') {
-					result = await connection.execute('INCRBY', [prefixedKey, finalNum]);
-				} else {
-					// 如果出错，回退到先获取再设置的方式
-					this.log('warn', `使用原子操作增加整数值失败，使用回退方案 [${key}]`);
-					let value = await this.get(prefixedKey);
-					let n = 0;
-					if (value) {
-						n = Number(value);
-					}
-					n += finalNum;
-					await this.set(prefixedKey, n, finalSeconds);
-					result = n;
-				}
-			} else {
-				// 减少整数值
-				if (typeof connection.decrBy === 'function') {
-					result = await connection.decrBy(prefixedKey, -finalNum);
-				} else if (typeof connection.execute === 'function') {
-					result = await connection.execute('DECRBY', [prefixedKey, -finalNum]);
-				} else {
-					// 如果出错，回退到先获取再设置的方式
-					this.log('warn', `使用原子操作减少整数值失败，使用回退方案`);
-					let value = await this.get(prefixedKey);
-					let n = 0;
-					if (value) {
-						n = Number(value);
-					}
-					n += finalNum;
-					await this.set(prefixedKey, n, finalSeconds);
-					result = n;
-				}
-			}
-
-			// 如果设置了过期时间
-			if (finalSeconds > 0) {
-				if (typeof connection.expire === 'function') {
-					await connection.expire(prefixedKey, finalSeconds);
-				} else if (typeof connection.execute === 'function') {
-					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
-				}
-			}
-
-			// 触发后置事件
-			this.emit('addInt:after', {
-				key: finalKey,
-				value: finalNum,
-				seconds: finalSeconds,
-				result,
-				success: true
-			});
-			return result;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		// 触发错误事件
-		this.emit('addInt:error', {
-			key,
-			value: num,
-			seconds,
-			error: err
-		});
-		this.log('error', `增加整数值失败 [${key}]:`, err);
-		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
-		return 0;
-	}
-};
-
-/**
- * @description 增加浮点数值(负数为减)（兼容方法）
- * @param {String} key 键
- * @param {Number} num 数值
- * @param {Number} seconds 过期时间，0表示永不过期
- * @return {Promise<Number>} 计算后的结果
- */
-Redis.prototype.addFloat = async function (key, num, seconds = 0) {
-	// 参数验证
-	if (!key || typeof key !== 'string') {
-		throw new TypeError('key必须是非空字符串');
-	}
-
-	// 验证num参数
-	num = parseFloat(num);
-	if (isNaN(num)) {
-		throw new TypeError('num必须是有效的数值');
-	}
-
-	try {
-
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			value: num,
-			seconds,
-			cancel: false
-		};
-		this.emit('addFloat:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回默认值
-		if (ctx.cancel) {
-			this.log('debug', `addFloat操作被事件处理器取消 [${key}]`);
-			return 0;
-		}
-
-		// 使用可能被修改的值
-		let {
-			key: finalKey,
-			value: finalNum,
-			seconds: finalSeconds
-		} = ctx;
-		let result;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-
-			// 优先使用原生方法
-			if (typeof connection.incrByFloat === 'function') {
-				result = parseFloat(await connection.incrByFloat(prefixedKey, finalNum));
-			}
-			// 尝试使用execute通用方法
-			else if (typeof connection.execute === 'function') {
-				result = parseFloat(await connection.execute('INCRBYFLOAT', [prefixedKey, finalNum]));
-			}
-			// 回退方案
-			else {
-				this.log('warn', `连接对象不支持incrByFloat操作，使用回退方案`);
-				let value = await this.get(prefixedKey);
-				let n = 0;
-				if (value) {
-					n = Number(value);
-				}
-				n += finalNum;
-				await this.set(prefixedKey, n, finalSeconds);
-				result = n;
-			}
-
-			// 设置过期时间
-			if (finalSeconds > 0) {
-				if (typeof connection.expire === 'function') {
-					await connection.expire(prefixedKey, finalSeconds);
-				} else if (typeof connection.execute === 'function') {
-					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
-				}
-			}
-
-			// 触发后置事件
-			this.emit('addFloat:after', {
-				key: finalKey,
-				value: finalNum,
-				seconds: finalSeconds,
-				result,
-				success: true
-			});
-			return result;
-		} catch (err) {
-			// 如果出错，回退到先获取再设置的方式
-			this.log('warn', `使用原子操作增加浮点数值失败，使用回退方案:`, err);
-			let value = await this.get(prefixedKey);
-			let n = 0;
-			if (value) {
-				n = Number(value);
-			}
-			n += finalNum;
-			await this.set(prefixedKey, n, finalSeconds);
-
-			// 触发后置事件
-			this.emit('addFloat:after', {
-				key: finalKey,
-				value: finalNum,
-				seconds: finalSeconds,
-				result: n,
-				success: true
-			});
-			return n;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		// 触发错误事件
-		this.emit('addFloat:error', {
-			key,
-			value: num,
-			seconds,
-			error: err
-		});
-		this.log('error', `增加浮点数值失败 [${key}]:`, err);
-		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
-		return 0;
-	}
-};
-
-/**
- * @description 增加字符串值到指定缓存（兼容方法）
- * @param {String} key 键
- * @param {String} str 添加的字符串
- * @param {Number} seconds 过期时间，0表示永不过期
- * @return {Promise<Number>} 添加后的字符串长度
- */
-Redis.prototype.addStr = async function (key, str, seconds = 0) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-
-		// 验证str参数
-		if (str === undefined || str === null) {
-			throw new TypeError('str不能为undefined或null');
-		}
-		str = String(str);
-
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			value: str,
-			seconds,
-			cancel: false
-		};
-		this.emit('addStr:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回0
-		if (ctx.cancel) {
-			this.log('debug', `addStr操作被事件处理器取消 [${key}]`);
-			return 0;
-		}
-
-		// 使用可能被修改的值
-		let {
-			key: finalKey,
-			value: finalStr,
-			seconds: finalSeconds
-		} = ctx;
-		let result;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-
-			// 优先使用原生方法
-			if (typeof connection.append === 'function') {
-				result = await connection.append(prefixedKey, finalStr);
-			}
-			// 尝试使用execute通用方法
-			else if (typeof connection.execute === 'function') {
-				result = await connection.execute('APPEND', [prefixedKey, finalStr]);
-			}
-			// 回退方案
-			else {
-				this.log('warn', `连接对象不支持append操作，使用回退方案`);
-				let value = await this.get(prefixedKey) || '';
-				value += finalStr;
-				await this.set(prefixedKey, value, finalSeconds);
-				result = value.length;
-			}
-
-			// 设置过期时间
-			if (finalSeconds > 0) {
-				if (typeof connection.expire === 'function') {
-					await connection.expire(prefixedKey, finalSeconds);
-				} else if (typeof connection.execute === 'function') {
-					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
-				}
-			}
-
-			// 触发后置事件
-			this.emit('addStr:after', {
-				key: finalKey,
-				value: finalStr,
-				seconds: finalSeconds,
-				result,
-				success: true
-			});
-			return result;
-		} catch (err) {
-			this.log('warn', '追加字符串失败:', err);
-			// 回退方案：先获取再设置
-			let value = await this.get(prefixedKey) || '';
-			value += finalStr;
-			await this.set(prefixedKey, value, finalSeconds);
-
-			// 触发后置事件
-			this.emit('addStr:after', {
-				key: finalKey,
-				value: finalStr,
-				seconds: finalSeconds,
-				result: value.length,
-				success: true
-			});
-			return value.length;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		// 触发错误事件
-		this.emit('addStr:error', {
-			key,
-			value: str,
-			seconds,
-			error: err
-		});
-		this.log('error', `追加字符串失败 [${key}]:`, err);
-		return 0;
-	}
-};
-
-/**
- * @description 删除缓存（兼容方法）
- * @param {String|Array<String>} key 键或键数组
- * @return {Promise<Boolean>} 成功返回true,失败返回false
- */
-Redis.prototype.del = async function (key) {
-	try {
-		// 键名必须是非空字符串或非空字符串数组
-		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必须是非空字符串或非空字符串数组');
-		}
-
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			cancel: false
-		};
-		this.emit('del:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回false
-		if (ctx.cancel) {
-			this.log('debug', `del操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		// 使用可能被修改的值
-		let {
-			key: finalKey
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			let success;
-			if (Array.isArray(finalKey)) {
-				// 批量删除 - 分别删除每个键以确保正确处理
-				success = true;
-				const deleted = [];
-				for (const k of finalKey) {
-					const prefixedKey = this._addPrefix(k);
-					const result = await connection.del(prefixedKey);
-					if (result !== 1) {
-						success = false;
-					} else {
-						deleted.push(k);
-					}
-				}
-				// 触发后置事件
-				this.emit('del:after', {
-					key: finalKey,
-					success,
-					deleted
-				});
-			} else {
-				// 单个删除
-				const prefixedKey = this._addPrefix(finalKey);
-				const n = await connection.del(prefixedKey);
-				success = n === 1;
-				// 触发后置事件
-				this.emit('del:after', {
-					key: finalKey,
-					success,
-					deleted: success ? [finalKey] : []
-				});
-			}
-			return success;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		// 触发错误事件
-		this.emit('del:error', {
-			key,
-			error: err
-		});
-		this.log('error', `删除缓存失败 [${key}]:`, err);
-		return false;
-	}
-};
-
-/**
- * @description 修改缓存
- * @param {String} key 键
- * @param {Object} value 值
- * @param {Number} seconds 秒
- * @return {Promise<Boolean>} 操作结果
- */
-/**
- * @description 设置缓存（兼容方法）
- * @param {String} key 键
- * @param {*} value 值
- * @param {Number} seconds 过期时间，0表示永不过期
- * @return {Promise<Boolean>} 成功返回true,失败返回false
- */
-Redis.prototype.set = async function (key, value, seconds = 0) {
-	try {
-		// 键名必须是非空字符串
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			value,
-			seconds,
-			cancel: false
-		};
-		this.emit('set:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回false
-		if (ctx.cancel) {
-			this.log('debug', `set操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		// 使用可能被修改的值
-		let {
-			key: finalKey,
-			value: finalValue,
-			seconds: finalSeconds
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-			if (typeof (finalValue) === "object") {
-				finalValue = JSON.stringify(finalValue);
-			}
-
-			if (finalSeconds > 0) {
-				await connection.set(prefixedKey, finalValue, {
-					EX: finalSeconds
-				});
-			} else {
-				await connection.set(prefixedKey, finalValue);
-			}
-
-			// 触发后置事件
-			this.emit('set:after', {
-				key,
-				value,
-				seconds,
-				success: true
-			});
-			return true;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `设置缓存失败 [${key}]:`, err);
-		// 触发错误事件
-		this.emit('set:error', {
-			key,
-			value,
-			seconds,
-			error: err
-		});
-		return false;
-	}
-};
-
-/**
- * @description 仅当键不存在时设置缓存
- * @param {String} key 键
- * @param {Object} value 值
- * @param {Number} seconds 过期时间（秒）
- * @return {Promise<Boolean>} 操作结果，键不存在时设置成功返回true，键已存在返回false
- */
-Redis.prototype.add = async function (key, value, seconds) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-		if (value === undefined || value === null) {
-			throw new TypeError('value不能为undefined或null');
-		}
-
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			value,
-			ttl: seconds,
-			cancel: false
-		};
-		this.emit('add:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回false
-		if (ctx.cancel) {
-			this.log('debug', `add操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		// 使用可能被修改的值
-		let {
-			key: finalKey,
-			value: finalValue,
-			ttl: finalSeconds
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			finalKey = this._addPrefix(finalKey);
-			if (typeof (finalValue) === "object") {
-				finalValue = JSON.stringify(finalValue);
-			}
-
-			// 使用NX选项实现SETNX操作 - 仅在键不存在时设置
-			const options = finalSeconds ? {
-				NX: true,
-				EX: finalSeconds
-			} : {
-				NX: true
-			};
-			const result = await connection.set(finalKey, finalValue, options);
-			const success = result === "OK";
-
-			// 触发后置事件
-			this.emit('add:after', {
-				key: finalKey,
-				value: finalValue,
-				ttl: finalSeconds,
-				success
-			});
-			return success;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `添加缓存失败 [${key}]:`, err);
-		// 触发错误事件
-		this.emit('add:error', {
-			key,
-			value,
-			ttl: seconds,
-			error: err
-		});
-		return false;
-	}
-};
-
-/**
- * @description 查询缓存
- * @param {String} key 键
- * @return {Promise<Object>} 查询值
- */
-/**
- * @description 获取缓存（兼容方法）
- * @param {String} key 键
- * @return {Promise<*>} 获取到的值，不存在时返回null
- */
-Redis.prototype.get = async function (key) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			cancel: false
-		};
-		this.emit('get:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回null
-		if (ctx.cancel) {
-			this.log('debug', `get操作被事件处理器取消 [${key}]`);
-			return null;
-		}
-
-		// 使用可能被修改的值
-		const finalKey = ctx.key;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-			const value = await connection.get(prefixedKey);
-			let result = value;
-			if (typeof (value) === "string") {
-				// 尝试解析JSON
-				try {
-					if (value.startsWith("{") && value.endsWith("}") ||
-						value.startsWith("[") && value.endsWith("]")) {
-						result = JSON.parse(value);
-					}
-				} catch (e) {
-					// 解析失败，返回原始字符串
-				}
-			}
-
-			// 触发后置事件
-			this.emit('get:after', {
-				key: finalKey,
-				value: result,
-				success: true
-			});
-
-			return result;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		// 触发错误事件
-		this.emit('get:error', {
-			key,
-			error: err
-		});
-		this.log('error', `获取缓存失败 [${key}]:`, err);
-		return null;
-	}
-};
-
-/**
- * @description 判断键是否存在（兼容方法）
- * @param {String} key 键
- * @return {Promise<Boolean>} 有返回true, 没有返回false
- */
-Redis.prototype.has = async function (key) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			cancel: false
-		};
-		this.emit('has:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回false
-		if (ctx.cancel) {
-			this.log('debug', `has操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		// 使用可能被修改的值
-		const finalKey = ctx.key;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-			const result = await connection.exists(prefixedKey);
-			const exists = result > 0;
-
-			// 触发后置事件
-			this.emit('has:after', {
-				key: finalKey,
-				result: exists,
-				success: true
-			});
-
-			return exists;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		// 触发错误事件
-		this.emit('has:error', {
-			key,
-			error: err
-		});
-		this.log('error', `检查键是否存在失败 [${key}]:`, err);
-		return false;
-	}
-};
-
-/**
- * @description 检查键是否存在，返回存在的键数量（兼容方法）
- * @param {String|Array<String>} key 键或键数组
- * @return {Promise<Number>} 存在的键数量
- */
-Redis.prototype.exists = async function (key) {
-	try {
-		// 参数验证
-		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必须是非空字符串或非空字符串数组');
-		}
-
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			cancel: false
-		};
-		this.emit('exists:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回0
-		if (ctx.cancel) {
-			this.log('debug', `exists操作被事件处理器取消 [${key}]`);
-			return 0;
-		}
-
-		// 使用可能被修改的值
-		const finalKey = ctx.key;
-
-		const connection = await this._getConnection();
-		try {
-			let result;
-			if (typeof finalKey === 'string') {
-				const prefixedKey = this._addPrefix(finalKey);
-				result = await connection.exists(prefixedKey);
-			} else if (Array.isArray(finalKey)) {
-				const prefixedKeys = finalKey.map(k => this._addPrefix(k));
-				result = await connection.exists(...prefixedKeys);
-			}
-
-			// 触发后置事件
-			this.emit('exists:after', {
-				key: finalKey,
-				result,
-				success: true
-			});
-
-			return result;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		// 触发错误事件
-		this.emit('exists:error', {
-			key,
-			error: err
-		});
-		this.log('error', `检查键存在性失败 [${key}]:`, err);
-		return 0;
-	}
-};
-
-/**
- * @description 查询缓存的字符串中的一段字符串
- * @param {String} key 键
- * @param {Number} start 开始位置
- * @param {Number} end 结束位置
- * @return {Promise<String>} 查询值
- */
-Redis.prototype.getrange = async function (key, start, end) {
-	try {
-		const connection = await this._getConnection();
-		try {
-			key = this._addPrefix(key);
-			return await connection.getRange(key, start, end);
-		} catch (err) {
-			this.log('error', '获取字符串范围失败:', err);
-			// 回退方案
-			const value = await this.get(key);
-			if (value && typeof value === 'string') {
-				return value.substring(start, end + 1);
-			}
-			return '';
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `获取字符串范围失败 [${key}]:`, err);
-		return '';
-	}
-};
-
-/**
- * 在指定位置插入文本
- * @param {String} str 原字符串
- * @param {Number} index 索引
- * @param {String} str_sub 插入的字符串
- * @return {String} 插入后的字符串
- */
-Redis.prototype.insertString = function (str, index, str_sub) {
-	return str.substring(0, index) + str_sub + str.substring(index);
-};
-
-/**
- * @description 在值的指定位置开始增加一段字符串
- * @param {String} key 键
- * @param {Number} index 开始位置
- * @param {String} value 变更的值
- * @return {Promise<Number>} 字符串长度
- */
-Redis.prototype.setrange = async function (key, index, value) {
-	try {
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			index,
-			value,
-			cancel: false
-		};
-		this.emit('setrange:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回0
-		if (ctx.cancel) {
-			this.log('debug', `setrange操作被事件处理器取消 [${key}]`);
-			return 0;
-		}
-
-		// 使用可能被修改的值
-		let {
-			key: finalKey,
-			index: finalIndex,
-			value: finalValue
-		} = ctx;
-		let result;
-
-		const connection = await this._getConnection();
-		try {
-			finalKey = this._addPrefix(finalKey);
-
-			// 优先使用原生方法
-			if (typeof connection.setRange === 'function') {
-				result = await connection.setRange(finalKey, finalIndex, finalValue);
-			}
-			// 尝试使用execute通用方法
-			else if (typeof connection.execute === 'function') {
-				result = await connection.execute('SETRANGE', [finalKey, finalIndex, finalValue]);
-			}
-			// 回退方案
-			else {
-				this.log('warn', `连接对象不支持setRange操作，使用回退方案`);
-				let str = await this.get(finalKey) || '';
-				if (str.length < finalIndex) {
-					// 填充空格到指定索引
-					str = str.padEnd(finalIndex, ' ');
-				}
-				str = this.insertString(str, finalIndex, finalValue);
-				await this.set(finalKey, str);
-				result = str.length;
-			}
-
-			// 触发后置事件
-			this.emit('setrange:after', {
-				key: finalKey,
-				index: finalIndex,
-				value: finalValue,
-				result,
-				success: true
-			});
-			return result;
-		} catch (err) {
-			this.log('error', '设置字符串范围失败:', err);
-			// 回退方案
-			let str = await this.get(finalKey) || '';
-			if (str.length < finalIndex) {
-				// 填充空格到指定索引
-				str = str.padEnd(finalIndex, ' ');
-			}
-			str = this.insertString(str, finalIndex, finalValue);
-			await this.set(finalKey, str);
-
-			// 触发后置事件
-			this.emit('setrange:after', {
-				key: finalKey,
-				index: finalIndex,
-				value: finalValue,
-				result: str.length,
-				success: true
-			});
-			return str.length;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		// 触发错误事件
-		this.emit('setrange:error', {
-			key,
-			index,
-			value,
-			error: err
-		});
-		this.log('error', `设置字符串范围失败 [${key}]:`, err);
-		return 0;
-	}
-};
-
-/**
- * @description 清空缓存
- * @param {String} key 键, 为空则清空所有
- * @return {Promise<Boolean>} 执行结果
- */
-Redis.prototype.clear = async function (key) {
-	try {
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			cancel: false
-		};
-		this.emit('clear:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回false
-		if (ctx.cancel) {
-			this.log('debug', `clear操作被事件处理器取消`);
-			return false;
-		}
-
-		// 使用可能被修改的值
-		let {
-			key: finalKey
-		} = ctx;
-		let success = false;
-
-		const connection = await this._getConnection();
-		try {
-			if (finalKey) {
-				// 清空指定键
-				success = await this.del(finalKey);
-			} else {
-				// 清空当前数据库
-				if (typeof connection.flushDb === 'function') {
-					await connection.flushDb();
-					success = true;
-				} else if (typeof connection.execute === 'function') {
-					await connection.execute('FLUSHDB');
-					success = true;
-				} else {
-					this.log('error', '连接对象不支持flushDb操作');
-					success = false;
-				}
-			}
-
-			// 触发后置事件
-			this.emit('clear:after', {
-				key: finalKey,
-				success
-			});
-			return success;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		// 触发错误事件
-		this.emit('clear:error', {
-			key,
-			error: err
-		});
-		this.log('error', '清空缓存失败:', err);
-		return false;
-	}
-};
-
-/**
- * @description 排序
- * @param {String} key 键
- * @param {Object} options 排序选项
- * @return {Promise<Array>} 排序后的数组
- */
-Redis.prototype.sort = async function (key, options = {}) {
-	try {
-		const connection = await this._getConnection();
-		try {
-			key = this._addPrefix(key);
-			// 默认升序
-			let sortOptions = [];
-			if (options.by) {
-				sortOptions.push('BY', options.by);
-			}
-			if (options.limit) {
-				sortOptions.push('LIMIT', options.limit.offset || 0, options.limit.count || -1);
-			}
-			if (options.order === 'desc') {
-				sortOptions.push('DESC');
-			} else {
-				sortOptions.push('ASC');
-			}
-			if (options.alpha) {
-				sortOptions.push('ALPHA');
-			}
-			if (options.get) {
-				if (Array.isArray(options.get)) {
-					options.get.forEach(getKey => {
-						sortOptions.push('GET', getKey);
-					});
-				} else {
-					sortOptions.push('GET', options.get);
-				}
-			}
-
-			return await connection.sort(key, sortOptions);
-		} catch (err) {
-			this.log('error', '排序失败:', err);
-			// 回退方案：获取数据后在内存中排序
-			const data = await this.getForList(key);
-			return data.sort((a, b) => {
-				if (options.alpha) {
-					return options.order === 'desc' ? b.localeCompare(a) : a.localeCompare(b);
-				} else {
-					return options.order === 'desc' ? Number(b) - Number(a) : Number(a) - Number(b);
-				}
-			});
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `排序失败 [${key}]:`, err);
-		return [];
-	}
-};
-
-/**
- * @description 获取所有键名
- * @param {String} pattern 键模式 支持*号
- * @return {Promise<Array>} 键数组
- */
-Redis.prototype.keys = async function (pattern = '*') {
-	try {
-		const connection = await this._getConnection();
-		try {
-			// 应用前缀到模式
-			const fullPattern = this.config.prefix ? this.config.prefix + pattern : pattern;
-			const keys = await connection.keys(fullPattern);
-			// 返回移除前缀的键
-			return keys.map(key => this._delPrefix(key));
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', '获取键列表失败:', err);
-		return [];
-	}
-};
-
-/**
- * @description 修改数组缓存
- * @param {String} key 键
- * @param {Object|Array} value 值
- * @param {Number} seconds 秒
- * @return {Promise<Number>} 数组长度
- */
-Redis.prototype.setForList = async function (key, value, seconds) {
-	try {
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			value,
-			ttl: seconds,
-			cancel: false
-		};
-		this.emit('setForList:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回0
-		if (ctx.cancel) {
-			this.log('debug', `setForList操作被事件处理器取消 [${key}]`);
-			return 0;
-		}
-
-		// 使用可能被修改的值
-		let {
-			key: finalKey,
-			value: finalValue,
-			ttl: finalSeconds
-		} = ctx;
-		let len = 0;
-
-		const connection = await this._getConnection();
-		try {
-			finalKey = this._addPrefix(finalKey);
-			// 先清空再添加
-			if (typeof connection.del === 'function') {
-				await connection.del(finalKey);
-			} else if (typeof connection.execute === 'function') {
-				await connection.execute('DEL', [finalKey]);
-			}
-
-			if (Array.isArray(finalValue)) {
-				if (finalValue.length > 0) {
-					// 添加数组元素
-					if (typeof connection.rPush === 'function') {
-						len = await connection.rPush(finalKey, finalValue);
-					} else if (typeof connection.execute === 'function') {
-						len = await connection.execute('RPUSH', [finalKey, ...finalValue]);
-					} else {
-						this.log('error', '连接对象不支持rPush操作');
-						len = 0;
-					}
-				}
-			} else {
-				// 添加单个元素
-				if (typeof connection.rPush === 'function') {
-					len = await connection.rPush(finalKey, finalValue);
-				} else if (typeof connection.execute === 'function') {
-					len = await connection.execute('RPUSH', [finalKey, finalValue]);
-				} else {
-					this.log('error', '连接对象不支持rPush操作');
-					len = 0;
-				}
-			}
-			if (finalSeconds) {
-				// 设置过期时间
-				if (typeof connection.expire === 'function') {
-					await connection.expire(finalKey, finalSeconds);
-				} else if (typeof connection.execute === 'function') {
-					await connection.execute('EXPIRE', [finalKey, finalSeconds]);
-				} else {
-					this.log('error', '连接对象不支持expire操作');
-				}
-			}
-
-			// 触发后置事件
-			this.emit('setForList:after', {
-				key: finalKey,
-				value: finalValue,
-				ttl: finalSeconds,
-				result: len,
-				success: len > 0
-			});
-			return len;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		// 触发错误事件
-		this.emit('setForList:error', {
-			key,
-			value,
-			error: err
-		});
-		this.log('error', `设置列表失败 [${key}]:`, err);
-		return 0;
-	}
-};
-
-/**
- * @description 数组缓存追加对象
- * @param {String} key 键
- * @param {Object|Array} value 值
- * @param {Number} seconds 秒
- * @return {Promise<Number>} 追加后的数组长度
- */
-Redis.prototype.addForList = async function (key, value, seconds = 0) {
-	try {
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			value,
-			ttl: seconds,
-			cancel: false
-		};
-		this.emit('addForList:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回0
-		if (ctx.cancel) {
-			this.log('debug', `addForList操作被事件处理器取消 [${key}]`);
-			return 0;
-		}
-
-		// 使用可能被修改的值
-		let {
-			key: finalKey,
-			value: finalValue,
-			ttl: finalSeconds
-		} = ctx;
-		let len = 0;
-
-		const connection = await this._getConnection();
-		try {
-			finalKey = this._addPrefix(finalKey);
-
-			if (Array.isArray(finalValue)) {
-				if (finalValue.length > 0) {
-					// 添加数组元素
-					if (typeof connection.rPush === 'function') {
-						len = await connection.rPush(finalKey, finalValue);
-					} else if (typeof connection.execute === 'function') {
-						len = await connection.execute('RPUSH', [finalKey, ...finalValue]);
-					} else {
-						this.log('error', '连接对象不支持rPush操作');
-						len = 0;
-					}
-				}
-			} else {
-				// 添加单个元素
-				if (typeof connection.rPush === 'function') {
-					len = await connection.rPush(finalKey, finalValue);
-				} else if (typeof connection.execute === 'function') {
-					len = await connection.execute('RPUSH', [finalKey, finalValue]);
-				} else {
-					this.log('error', '连接对象不支持rPush操作');
-					len = 0;
-				}
-			}
-			if (finalSeconds) {
-				// 设置过期时间
-				if (typeof connection.expire === 'function') {
-					await connection.expire(finalKey, finalSeconds);
-				} else if (typeof connection.execute === 'function') {
-					await connection.execute('EXPIRE', [finalKey, finalSeconds]);
-				} else {
-					this.log('error', '连接对象不支持expire操作');
-				}
-			}
-
-			// 触发后置事件
-			this.emit('addForList:after', {
-				key: finalKey,
-				value: finalValue,
-				ttl: finalSeconds,
-				result: len,
-				success: len > 0
-			});
-			return len;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		// 触发错误事件
-		this.emit('addForList:error', {
-			key,
-			value,
-			error: err
-		});
-		this.log('error', `添加列表项失败 [${key}]:`, err);
-		return 0;
-	}
-};
-
-/**
- * @description 判断成员是否存在
- * @param {String} key 键
- * @param {Object} value 值
- * @return {Promise<Boolean>} 存在返回true, 否则返回false
- */
-Redis.prototype.hasForList = async function (key, value) {
-	if (!value) {
-		throw new TypeError('值不能为空');
-	}
-
-	try {
-		// 尝试使用Redis的LREM命令来检查是否存在
-		const keyWithPrefix = this._addPrefix(key);
-		// 转换value为字符串以便比较
-		const valueStr = JSON.stringify(value);
-		// 使用scan来查找，避免在大列表上的性能问题
-		const arr = await this.getForList(key);
-		return arr.some(item => {
-			const itemStr = JSON.stringify(item);
-			return itemStr === valueStr || item === value;
-		});
-	} catch (err) {
-		this.log('error', `检查列表成员是否存在失败 [${key}]:`, err);
-		return false;
-	}
-};
-
-/**
- * @description 查询数组缓存
- * @param {String} key 键
- * @param {Number} start 起始位置
- * @param {Number} end 结束位置
- * @return {Promise<Array>} 查询到的数组
- */
-Redis.prototype.getForList = async function (key, start = 0, end = -1) {
-	try {
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			start,
-			end,
-			cancel: false
-		};
-		this.emit('getForList:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回空数组
-		if (ctx.cancel) {
-			this.log('debug', `getForList操作被事件处理器取消 [${key}]`);
-			return [];
-		}
-
-		// 使用可能被修改的值
-		let {
-			key: finalKey,
-			start: finalStart,
-			end: finalEnd
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			finalKey = this._addPrefix(finalKey);
-			let result;
-			// 检查连接是否支持lRange方法，Redis v4 API
-			if (typeof connection.lRange === 'function') {
-				result = await connection.lRange(finalKey, finalStart, finalEnd);
-			} else if (typeof connection.lrange === 'function') {
-				// 兼容旧版API
-				result = await connection.lrange(finalKey, finalStart, finalEnd);
-			} else if (typeof connection.execute === 'function') {
-				// 回退到通用execute方法
-				result = await connection.execute('LRANGE', [finalKey, finalStart, finalEnd]);
-			} else {
-				this.log('error', '连接对象不支持lRange或lrange操作');
-				return [];
-			}
-			// 确保结果是数组
-			if (!Array.isArray(result)) {
-				this.log('error', '列表查询结果不是数组格式');
-				return [];
-			}
-
-			// 尝试解析每个元素为JSON
-			const parsedResult = result.map(item => {
-				if (typeof item === "string") {
-					try {
-						// 尝试识别并解析JSON字符串
-						const trimmedItem = item.trim();
-						if ((trimmedItem.startsWith("{") && trimmedItem.endsWith("}")) ||
-							(trimmedItem.startsWith("[") && trimmedItem.endsWith("]"))) {
-							return JSON.parse(trimmedItem);
-						}
-					} catch (e) {
-						// 解析失败，返回原始字符串
-					}
-				}
-				return item;
-			});
-
-			// 触发后置事件
-			this.emit('getForList:after', {
-				key: finalKey,
-				start: finalStart,
-				end: finalEnd,
-				result: parsedResult
-			});
-			return parsedResult;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		// 触发错误事件
-		this.emit('getForList:error', {
-			key,
-			start,
-			end,
-			error: err
-		});
-		this.log('error', `获取列表失败 [${key}]:`, err);
-		return [];
-	}
-};
-
-/**
- * @description 清空列表，保留键和过期时间
- * @param {String} key 键
- * @return {Promise<Boolean>} 成功返回true，失败返回false
- */
-Redis.prototype.clearForList = async function (key) {
-	if (!key) {
-		throw new TypeError('键不能为空');
-	}
-
-	try {
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			cancel: false
-		};
-		this.emit('clearForList:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回false
-		if (ctx.cancel) {
-			this.log('debug', `clearForList操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		// 使用可能被修改的值
-		let finalKey = ctx.key;
-
-		// 直接使用set方法设置为空数组，这样更可靠且与其他模块行为一致
-		// 这样可以确保返回值是一个空数组，而不是null或undefined
-		finalKey = this._addPrefix(finalKey);
-		await this.set(finalKey, []);
-
-		// 触发后置事件
-		this.emit('clearForList:after', {
-			key: finalKey,
-			success: true
-		});
-		return true;
-	} catch (err) {
-		// 触发错误事件
-		this.emit('clearForList:error', {
-			key,
-			error: err
-		});
-		this.log('error', `清空列表失败 [${key}]:`, err);
-		return false;
-	}
-};
-
-/**
- * @description 批量获取缓存
- * @param {Array<String>} keys 键数组
- * @return {Promise<Object>} 键值对对象
- */
-/**
- * @description 批量获取缓存（兼容方法）
- * @param {Array<String>} keys 键数组
- * @return {Promise<Array>} 返回值数组，顺序与键数组一致
- */
-Redis.prototype.mget = async function (keys) {
-	try {
-		// 参数验证
-		if (!keys || !Array.isArray(keys)) {
-			throw new TypeError('keys必须是非空数组');
-		}
-
-		// 验证数组中的每个元素是否为非空字符串
-		for (const key of keys) {
-			if (!key || typeof key !== 'string') {
-				throw new TypeError('keys数组中的每个元素必须是非空字符串');
-			}
-		}
-
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			keys,
-			cancel: false
-		};
-		this.emit('mget:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回空数组
-		if (ctx.cancel) {
-			this.log('debug', `mget操作被事件处理器取消 [${keys}]`);
-			return [];
-		}
-
-		// 使用可能被修改的值
-		const finalKeys = ctx.keys;
-
-		const connection = await this._getConnection();
-		try {
-			// 直接使用Redis v4的mGet方法，应用键前缀
-			const keysWithPrefix = finalKeys.map(k => this._addPrefix(k));
-			const values = await connection.mGet(keysWithPrefix);
-
-			// 处理值的格式，保持数组返回格式
-			const result = [];
-			values.forEach((value, index) => {
-				if (typeof (value) === "string") {
-					try {
-						if (value.startsWith("{") && value.endsWith("}") ||
-							value.startsWith("[") && value.endsWith("]")) {
-							value = JSON.parse(value);
-						}
-					} catch (e) {
-						// 解析失败，返回原始字符串
-					}
-				}
-				result[index] = value;
-			});
-
-			// 触发后置事件
-			this.emit('mget:after', {
-				keys: finalKeys,
-				result,
-				success: true
-			});
-
-			return result;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		// 触发错误事件
-		this.emit('mget:error', {
-			keys,
-			error: err
-		});
-		this.log('error', `批量获取缓存失败 [${keys}]:`, err);
-		return [];
-	}
-}
-
-/**
- * @description 批量设置缓存（兼容方法）
- * @param {Object} obj 键值对对象
- * @param {Number} seconds 过期时间(秒)
- * @return {Promise<boolean>} 返回true
- */
-Redis.prototype.mset = async function (obj, seconds = 0) {
-	try {
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			value: obj,
-			seconds,
-			cancel: false
-		};
-		this.emit('mset:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回false
-		if (ctx.cancel) {
-			this.log('debug', `mset操作被事件处理器取消`);
-			return false;
-		}
-
-		// 使用可能被修改的值
-		let {
-			value: finalData,
-			seconds: finalSeconds
-		} = ctx;
-
-		// 检查最终数据是否有效
-		if (!finalData || typeof finalData !== 'object' || finalData === null || Array.isArray(finalData)) {
-			throw new TypeError('参数必须是非空对象');
-		}
-
-		// 使用Pipeline优化批量操作
-		const pipeline = this.pipeline();
-		for (const [key, value] of Object.entries(finalData)) {
-			pipeline.set(key, value);
-		}
-
-		// 如果设置了过期时间，添加过期时间设置
-		if (finalSeconds > 0) {
-			for (const key of Object.keys(finalData)) {
-				pipeline.expire(key, finalSeconds);
-			}
-		}
-
-		await pipeline.exec();
-
-		// 触发后置事件
-		this.emit('mset:after', {
-			keyValues: finalData,
-			seconds: finalSeconds,
-			result: true
-		});
-		return true;
-	} catch (err) {
-		// 触发错误事件
-		this.emit('mset:error', {
-			keyValues: obj,
-			seconds,
-			error: err
-		});
-
-		// 如果Pipeline失败，回退到原实现
-		this.log('warn', '使用Pipeline批量设置失败，使用回退方案:', err);
-		const connection = await this._getConnection();
-		try {
-			const pairs = [];
-			for (const [key, value] of Object.entries(obj)) {
-				const fullKey = this._addPrefix(key);
-				const val = typeof (value) === "object" ? JSON.stringify(value) : value;
-				pairs.push(fullKey, val);
-			}
-
-			// 确保pairs数组格式正确，符合原生mSet方法要求
-			if (pairs.length % 2 !== 0) {
-				throw new TypeError('键值对数量必须相等');
-			}
-
-			await connection.mSet(pairs);
-
-			// 如果设置了过期时间，为所有键设置过期
-			if (seconds > 0) {
-				for (const key of Object.keys(obj)) {
-					await connection.expire(this._addPrefix(key), seconds);
-				}
-			}
-
-			// 触发后置事件（使用原始数据，因为前置数据修改处理已失败）
-			this.emit('mset:after', {
-				keyValues: obj,
-				seconds,
-				result: true
-			});
-			return true;
-		} catch (fallbackErr) {
-			// 触发错误事件
-			this.emit('mset:error', {
-				keyValues: obj,
-				seconds,
-				error: fallbackErr
-			});
-			this.log('error', '回退方案批量设置也失败:', fallbackErr);
-			return false;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	}
-};
-
-// 添加连接回收方法，作为_releaseConnection的别名
-Redis.prototype._recycleConnection = function (connection) {
-	return this._releaseConnection(connection);
-};
-
-/**
- * @description 删除哈希字段
- * @param {String} key 键
- * @param {String|Array<String>} fields 字段名或字段名数组
- * @return {Promise<Number>} 删除的字段数量
- */
-Redis.prototype.hdel = async function (key, fields) {
-	try {
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			value: fields,
-			cancel: false
-		};
-		this.emit('hdel:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回false
-		if (ctx.cancel) {
-			this.log('debug', `hdel操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		// 使用可能被修改的值
-		let {
-			key: finalKey,
-			value: finalFields
-		} = ctx;
-		let success = true;
-
-		const connection = await this._getConnection();
-		try {
-			finalKey = this._addPrefix(finalKey);
-			if (!Array.isArray(finalFields)) {
-				finalFields = [finalFields];
-			}
-
-			let deletedCount = 0;
-			// 执行删除操作
-			if (typeof connection.hDel === 'function') {
-				deletedCount = await connection.hDel(finalKey, finalFields);
-			} else if (typeof connection.execute === 'function') {
-				deletedCount = await connection.execute('HDEL', [finalKey, ...finalFields]);
-			} else {
-				this.log('error', '连接对象不支持hDel操作');
-				deletedCount = 0;
-			}
-
-			// 触发后置事件
-			this.emit('hdel:after', {
-				key: finalKey,
-				value: finalFields,
-				deletedCount
-			});
-			return deletedCount;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		// 触发错误事件
-		this.emit('hdel:error', {
-			key,
-			value: fields,
-			error: err
-		});
-		this.log('error', `删除哈希字段失败 [${key}]:`, err);
-		return 0; // 与Redis语义保持一致，返回删除的字段数量
-	}
-};
-
-/**
- * @description 获取哈希字段数量
- * @param {String} key 键
- * @return {Promise<Number>} 字段数量
- */
-Redis.prototype.hlen = async function (key) {
-	try {
-		const connection = await this._getConnection();
-		try {
-			key = this._addPrefix(key);
-			return await connection.hLen(key);
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `获取哈希字段数量失败 [${key}]:`, err);
-		return 0;
-	}
-};
-
-// Pipeline类，用于批量操作优化
-class RedisPipeline {
-	constructor(redis) {
-		this.redis = redis;
-		this.commands = [];
-	}
-
-	// 添加get命令到pipeline
-	get(key) {
-		this.commands.push({
-			name: 'get',
-			args: [key]
-		});
-		return this;
-	}
-
-	// 添加set命令到pipeline
-	set(key, value, seconds) {
-		this.commands.push({
-			name: 'set',
-			args: [key, value, seconds]
-		});
-		return this;
-	}
-
-	// 添加del命令到pipeline
-	del(key) {
-		this.commands.push({
-			name: 'del',
-			args: [key]
-		});
-		return this;
-	}
-
-	// 添加ttl命令到pipeline
-	ttl(key, seconds) {
-		this.commands.push({
-			name: 'ttl',
-			args: [key, seconds]
-		});
-		return this;
-	}
-
-	// 添加hset命令到pipeline
-	hset(key, field, value) {
-		this.commands.push({
-			name: 'hset',
-			args: [key, field, value]
-		});
-		return this;
-	}
-
-	// 添加hget命令到pipeline
-	hget(key, field) {
-		this.commands.push({
-			name: 'hget',
-			args: [key, field]
-		});
-		return this;
-	}
-
-	// 执行pipeline中的所有命令
-	async exec() {
-		const connection = await this.redis._getConnection();
-		try {
-			const pipeline = connection.multi();
-
-			// 执行所有命令
-			for (const cmd of this.commands) {
-				const {
-					name,
-					args
-				} = cmd;
-				let processedArgs = args;
-
-				// 处理键前缀
-				if (name !== 'multi' && name !== 'exec' && args.length > 0) {
-					processedArgs = [...args];
-					// 大多数Redis命令第一个参数是key
-					processedArgs[0] = this.redis._addPrefix(args[0]);
-
-					// 对于set命令，处理value的JSON序列化
-					if (name === 'set' && args.length >= 2 && typeof (args[1]) === 'object') {
-						processedArgs[1] = JSON.stringify(args[1]);
-					}
-				}
-
-				// 执行命令
-				if (name === 'set' && processedArgs.length >= 3) {
-					// 处理set命令的过期时间
-					pipeline.set(processedArgs[0], processedArgs[1], {
-						EX: processedArgs[2]
-					});
-				} else if (name === 'ttl' && processedArgs.length >= 2) {
-					// 处理ttl命令
-					pipeline.expire(processedArgs[0], processedArgs[1]);
-				} else if (pipeline[name]) {
-					pipeline[name](...processedArgs);
-				} else {
-					throw new Error(`Pipeline不支持的命令: ${name}`);
-				}
-			}
-
-			// 执行所有命令并获取结果
-			const results = await pipeline.exec();
-
-			// 处理结果（解析JSON等）
-			return results.map(([err, value], index) => {
-				if (err) {
-					this.log('error', `[Pipeline] Pipeline命令执行失败 [${this.commands[index].name}]:`, err);
-					return null;
-				}
-
-				// 尝试解析JSON结果
-				if (typeof (value) === 'string') {
-					try {
-						if (value.startsWith('{') && value.endsWith('}') ||
-							value.startsWith('[') && value.endsWith(']')) {
-							return JSON.parse(value);
-						}
-					} catch (e) {
-						// 解析失败，返回原始值
-					}
-				}
-				return value;
-			});
-		} finally {
-			this.redis._recycleConnection(connection);
-		}
-	}
-}
-/**
- * 清空所有过期的数据
- * @return {Promise<Boolean>} 是否成功
- */
-Redis.prototype.clearExpire = async function () {
-	try {
-		this.emit('clearExpire:before', {});
-		// Redis没有直接的方法来清空所有过期数据
-		// 我们可以通过扫描所有键并检查过期时间来模拟这个行为
-		// 但为了简单起见，我们直接返回true表示操作成功
-		this.emit('clearExpire:after', {
-			result: true
-		});
-		return true;
-	} catch (err) {
-		this.emit('clearExpire:error', {
-			error: err
-		});
-		this.log('error', '清空过期数据失败:', err);
-		return false;
-	}
-};
-
-
-// 获取连接的方法
-Redis.prototype._getConnection = function () {
-	return new Promise((resolve, reject) => {
-		try {
-			// 如果有可用连接，直接返回
-			if (this.connection_pool.available.length > 0) {
-				const connection = this.connection_pool.available.pop();
-				this.connection_pool.in_use.add(connection);
-				resolve(connection);
-				return;
-			}
-
-			// 如果连接数未达到上限，创建新连接
-			const totalConnections = this.connection_pool.available.length + this.connection_pool.in_use
-				.size;
-			if (totalConnections < this.config.max_clients) {
-				this._createConnection().then(connection => {
-					this.connection_pool.in_use.add(connection);
-					resolve(connection);
-				}).catch(reject);
-			} else {
-				// 否则等待连接释放
-				// 这里简化处理，直接创建连接（生产环境应实现等待队列）
-				this.log('warn', '连接池已满，创建额外连接');
-				this._createConnection().then(connection => {
-					this.connection_pool.in_use.add(connection);
-					resolve(connection);
-				}).catch(reject);
-			}
-		} catch (error) {
-			this.log('error', '获取连接失败:', error);
-			reject(error);
-		}
-	});
-};
-
-// 释放连接回池
-Redis.prototype._releaseConnection = function (connection) {
-	try {
-		if (this.connection_pool.in_use.has(connection)) {
-			this.connection_pool.in_use.delete(connection);
-
-			// 检查是否超过最大空闲连接数
-			if (this.connection_pool.available.length < this.config.max_idle) {
-				this.connection_pool.available.push(connection);
-			} else {
-				// 否则关闭多余的连接
-				try {
-					if (typeof connection.close === 'function') {
-						connection.close();
-					} else if (typeof connection.end === 'function') {
-						connection.end();
-					} else {
-						this.log('debug', '连接对象没有可用的关闭方法');
-					}
-				} catch (e) {
-					this.log('error', '关闭多余连接失败:', e);
-				}
-			}
-		}
-	} catch (error) {
-		this.log('error', '释放连接失败:', error);
-	}
-};
-
-// 确保_recycleConnection方法是_releaseConnection的别名
-Redis.prototype._recycleConnection = Redis.prototype._releaseConnection;
-
-// 添加Hash操作相关方法
-
-/**
- * @description 设置哈希字段
- * @param {String} key 键
- * @param {String} field 字段
- * @param {Object} value 值
- * @return {Promise<Boolean>} 操作结果
- */
-Redis.prototype.hset = async function (key, field, value) {
-	try {
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			field,
-			value,
-			cancel: false
-		};
-		this.emit('hset:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回false
-		if (ctx.cancel) {
-			this.log('debug', `hset操作被事件处理器取消 [${key}:${field}]`);
-			return false;
-		}
-
-		// 使用可能被修改的值
-		let {
-			key: finalKey,
-			field: finalField,
-			value: finalValue
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			finalKey = this._addPrefix(finalKey);
-			// 确保所有非字符串值都转换为字符串
-			if (typeof (finalValue) !== "string") {
-				finalValue = JSON.stringify(finalValue);
-			}
-			// 使用正确的Redis v4 API - hSet方法
-			const result = await connection.hSet(finalKey, finalField, finalValue);
-
-			// 触发后置事件
-			this.emit('hset:after', {
-				key: finalKey,
-				field: finalField,
-				value: finalValue,
-				success: true
-			});
-			return true; // hSet操作成功返回true
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `设置哈希字段失败 [${key}:${field}]:`, err);
-		// 触发错误事件
-		this.emit('hset:error', {
-			key,
-			field,
-			value,
-			error: err
-		});
-		return false;
-	}
-};
-
-/**
- * @description 获取哈希字段
- * @param {String} key 键
- * @param {String} field 字段
- * @return {Promise<Object>} 字段值
- */
-Redis.prototype.hget = async function (key, field) {
-	try {
-		const connection = await this._getConnection();
-		try {
-			key = this._addPrefix(key);
-			// 使用正确的Redis v4 API - hGet方法
-			const value = await connection.hGet(key, field);
-			// 尝试解析JSON
-			if (value && typeof (value) === 'string') {
-				try {
-					if (value.startsWith('{') && value.endsWith('}') ||
-						value.startsWith('[') && value.endsWith(']')) {
-						return JSON.parse(value);
-					}
-				} catch (e) {
-					// 如果不是JSON，直接返回原值
-					return value;
-				}
-			}
-			return value;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `获取哈希字段失败 [${key}:${field}]:`, err);
-		return null;
-	}
-};
-
-/**
- * @description 批量设置哈希字段
- * @param {String} key 键
- * @param {Object} obj 字段值对象
- * @return {Promise<Boolean>} 操作结果
- */
-Redis.prototype.hmset = async function (key, obj) {
-	try {
-		// 触发前置事件，允许修改或阻止操作
-		const ctx = {
-			key,
-			value: obj,
-			cancel: false
-		};
-		this.emit('hmset:before', ctx);
-
-		// 如果事件处理器标记为取消，则返回false
-		if (ctx.cancel) {
-			this.log('debug', `hmset操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		// 使用可能被修改的值
-		let {
-			key: finalKey,
-			value: finalObj
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			finalKey = this._addPrefix(finalKey);
-
-			// 检查Redis版本，支持不同的方法
-			this.log('debug',
-				`hmset方法检测到连接对象方法: hSet=${typeof connection.hSet === 'function'}, hmset=${typeof connection.hmset === 'function'}`
-			);
-			let success = true;
-
-			// 优化策略：对所有Redis版本都使用逐个字段设置的方式，确保兼容性和正确性
-			this.log('debug', `对键 ${finalKey} 强制使用逐个字段设置策略`);
-
-			// 获取适合的设置字段方法
-			const setFieldMethod = typeof connection.hSet === 'function' ? 'hSet' :
-				typeof connection.hset === 'function' ? 'hset' : null;
-
-			if (!setFieldMethod) {
-				this.log('error', `连接对象不支持hSet或hset操作`);
-				return false;
-			}
-
-			// 逐个设置每个字段
-			for (const field in finalObj) {
-				if (finalObj.hasOwnProperty(field)) {
-					try {
-						let value = finalObj[field];
-						if (typeof value !== 'string') {
-							value = JSON.stringify(value);
-						}
-						this.log('debug', `单独设置字段: ${setFieldMethod}(${finalKey}, ${field}, ${value})`);
-						await connection[setFieldMethod](finalKey, field, value);
-					} catch (singleError) {
-						this.log('error', `设置单个字段失败 ${field}: ${singleError.message}`);
-						success = false;
-						break;
-					}
-				}
-			}
-
-			// 验证所有字段是否都设置成功
-			if (success) {
-				this.log('debug', `验证所有字段设置情况`);
-				for (const field in finalObj) {
-					if (finalObj.hasOwnProperty(field)) {
-						try {
-							const hgetMethod = typeof connection.hGet === 'function' ? 'hGet' : 'hget';
-							const value = await connection[hgetMethod](finalKey, field);
-							this.log('debug', `验证字段 ${field}: ${value !== null ? '存在' : '不存在'}`);
-							// 如果字段不存在，更新success状态
-							if (value === null) {
-								success = false;
-							}
-						} catch (getError) {
-							this.log('error', `验证字段失败 ${field}: ${getError.message}`);
-							success = false;
-						}
-					}
-				}
-			}
-
-			// 触发后置事件
-			this.emit('hmset:after', {
-				key: finalKey,
-				value: finalObj,
-				success: success
-			});
-			return success;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `批量设置哈希字段失败 [${key}]:`, err);
-		// 触发错误事件
-		this.emit('hmset:error', {
-			key,
-			value: obj,
-			error: err
-		});
-		return false;
-	}
-};
-
-/**
- * @description 获取哈希所有字段和值
- * @param {String} key 键
- * @return {Promise<Object>} 所有字段和值
- */
-Redis.prototype.hgetall = async function (key) {
-	try {
-		const connection = await this._getConnection();
-		try {
-			key = this._addPrefix(key);
-			if (typeof connection.hGetAll === 'function') {
-				const result = await connection.hGetAll(key);
-				return result;
-			} else {
-				this.log('error', '连接对象不支持hGetAll操作');
-				return {};
-			}
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `获取哈希所有字段和值失败 [${key}]:`, err);
-		return {};
-	}
-};
-
-/**
- * @description Redis兼容API - 哈希表批量获取
- * @param {String} key 键名
- * @param {Array} fields 字段名数组
- * @return {Promise<Array>} 与字段名顺序对应的数组值，不存在返回undefined
- */
-Redis.prototype.hmget = async function (key, fields) {
-	try {
-		if (!Array.isArray(fields)) {
-			throw new TypeError('fields必须是数组');
-		}
-
-		this.emit('hmget:before', {
-			key,
-			fields
-		});
-
-		const connection = await this._getConnection();
-		try {
-			key = this._addPrefix(key);
-
-			if (typeof connection.hmGet === 'function') {
-				const result = await connection.hmGet(key, fields);
-				// 将null转换为undefined以保持与CacheBase行为一致
-				const finalResult = result.map(value => value === null ? undefined : value);
-				this.emit('hmget:after', {
-					key,
-					fields,
-					result: finalResult
-				});
-				return finalResult;
-			} else if (typeof connection.hGetAll === 'function') {
-				// 回退方案：获取所有字段然后筛选
-				const allFields = await connection.hGetAll(key);
-				const finalResult = fields.map(field => {
-					const value = allFields[field];
-					return value === null || value === undefined ? undefined : value;
-				});
-				this.emit('hmget:after', {
-					key,
-					fields,
-					result: finalResult
-				});
-				return finalResult;
-			} else {
-				this.log('error', '连接对象不支持hmGet操作');
-				this.log('error', '错误: Redis客户端不支持hmget操作');
-				// 返回与fields长度相同的undefined数组，保持与注释一致
-				return fields.map(() => undefined);
-			}
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.emit('hmget:error', {
-			key,
-			fields,
-			error: err
-		});
-		this.log('error', `哈希表批量获取失败 [${key}]:`, err);
-		// 返回与fields长度相同的undefined数组，保持与注释类型一致
-		return fields.map(() => undefined);
-	}
-};
-/**
- * @description 设置键的过期时间
- * @param {String} key 键
- * @param {Number} seconds 过期时间（秒）
- * @return {Promise<Boolean>} 操作结果
- */
-Redis.prototype.expire = async function (key, seconds) {
-	try {
-		// 触发前置事件
-		const ctx = {
-			key,
-			ttl: seconds,
-			cancel: false
-		};
-		this.emit('expire:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `expire操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		const {
-			key: finalKey,
-			ttl: finalSeconds
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			// 使用正确的Redis客户端Promise API
-			const result = await connection.expire(this._addPrefix(finalKey), finalSeconds);
-
-			// 触发后置事件
-			this.emit('expire:after', {
-				key: finalKey,
-				ttl: finalSeconds,
-				success: result === 1
-			});
-			return result === 1;
-		} catch (err) {
-			this.log('error', `设置过期时间失败 [${finalKey}]:`, err);
-			this.emit('expire:error', {
-				key: finalKey,
-				ttl: finalSeconds,
-				error: err
-			});
-			return false;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `设置过期时间失败 [${key}]:`, err);
-		this.emit('expire:error', {
-			key,
-			ttl: seconds,
-			error: err
-		});
-		return false;
-	}
-};
-
-/**
- * @description 设置键的过期时间（毫秒）
- * @param {String} key 键
- * @param {Number} milliseconds 过期时间（毫秒）
- * @return {Promise<Boolean>} 操作结果
- */
-Redis.prototype.pexpire = async function (key, milliseconds) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-		if (!Number.isInteger(milliseconds) || milliseconds <= 0) {
-			throw new TypeError('milliseconds必须是正整数');
-		}
-
-		// 触发前置事件
-		const ctx = {
-			key,
-			ttl: milliseconds,
-			cancel: false
-		};
-		this.emit('pexpire:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `pexpire操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		const {
-			key: finalKey,
-			ttl: finalMilliseconds
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			// 使用正确的Redis客户端Promise API
-			let result;
-			if (typeof connection.pexpire === 'function') {
-				result = await connection.pexpire(this._addPrefix(finalKey), finalMilliseconds);
-			} else if (typeof connection.execute === 'function') {
-				result = await connection.execute('PEXPIRE', [this._addPrefix(finalKey), finalMilliseconds]);
-			} else {
-				this.log('error', '连接对象不支持pexpire操作');
-				return false;
-			}
-
-			// 触发后置事件
-			this.emit('pexpire:after', {
-				key: finalKey,
-				ttl: finalMilliseconds,
-				success: result === 1
-			});
-			return result === 1;
-		} catch (err) {
-			this.log('error', `设置过期时间（毫秒）失败 [${finalKey}]:`, err);
-			this.emit('pexpire:error', {
-				key: finalKey,
-				ttl: finalMilliseconds,
-				error: err
-			});
-			return false;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `设置过期时间（毫秒）失败 [${key}]:`, err);
-		this.emit('pexpire:error', {
-			key,
-			ttl: milliseconds,
-			error: err
-		});
-		return false;
-	}
-};
-
-// 新增persist方法实现
-Redis.prototype.persist = async function (key) {
-	try {
-		// 触发前置事件
-		const ctx = {
-			key,
-			cancel: false
-		};
-		this.emit('persist:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `persist操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		const {
-			key: finalKey
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			// 使用正确的Redis客户端Promise API
-			const result = await connection.persist(this._addPrefix(finalKey));
-
-			// 触发后置事件
-			this.emit('persist:after', {
-				key: finalKey,
-				success: result === 1
-			});
-			return result === 1;
-		} catch (err) {
-			this.log('error', `移除过期时间失败 [${finalKey}]:`, err);
-			this.emit('persist:error', {
-				key: finalKey,
-				error: err
-			});
-			return false;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `移除过期时间失败 [${key}]:`, err);
-		this.emit('persist:error', {
-			key,
-			error: err
-		});
-		return false;
-	}
-};
-
-/**
- * @description 将键的值增加1（兼容方法，与addInt功能相同）
- * @param {String} key 键
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 增加后的值
- */
-Redis.prototype.incr = async function (key, seconds = 0) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('键必须是非空字符串');
-		}
-
-		// 触发前置事件
-		const ctx = {
-			key,
-			seconds,
-			cancel: false
-		};
-		this.emit('incr:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `incr操作被事件处理器取消 [${key}]`);
-			return null;
-		}
-
-		const {
-			key: finalKey,
-			seconds: finalSeconds
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-			// 使用正确的Redis客户端Promise API
-			const result = await connection.incr(prefixedKey);
-
-			// 如果设置了过期时间
-			if (finalSeconds > 0) {
-				if (typeof connection.expire === 'function') {
-					await connection.expire(prefixedKey, finalSeconds);
-				} else if (typeof connection.execute === 'function') {
-					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
-				}
-			}
-
-			this.emit('incr:after', {
-				key: finalKey,
-				seconds: finalSeconds,
-				result
-			});
-			return result;
-		} catch (err) {
-			this.log('error', `增加整数值失败 [${finalKey}]:`, err);
-			this.emit('incr:error', {
-				key: finalKey,
-				seconds: finalSeconds,
-				error: err
-			});
-			return null;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `增加整数值失败 [${key}]:`, err);
-		this.emit('incr:error', {
-			key,
-			seconds,
-			error: err
-		});
-		return null;
-	}
-};
-
-/**
- * @description 将键的值减少1（兼容方法）
- * @param {String} key 键
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 减少后的值
- */
-Redis.prototype.decr = async function (key, seconds = 0) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('键必须是非空字符串');
-		}
-
-		// 触发前置事件
-		const ctx = {
-			key,
-			seconds,
-			cancel: false
-		};
-		this.emit('decr:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `decr操作被事件处理器取消 [${key}]`);
-			return null;
-		}
-
-		const {
-			key: finalKey,
-			seconds: finalSeconds
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-			// 使用正确的Redis客户端Promise API
-			const result = await connection.decr(prefixedKey);
-
-			// 如果设置了过期时间
-			if (finalSeconds > 0) {
-				if (typeof connection.expire === 'function') {
-					await connection.expire(prefixedKey, finalSeconds);
-				} else if (typeof connection.execute === 'function') {
-					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
-				}
-			}
-
-			this.emit('decr:after', {
-				key: finalKey,
-				seconds: finalSeconds,
-				result
-			});
-			return result;
-		} catch (err) {
-			this.log('error', `减少整数值失败 [${finalKey}]:`, err);
-			this.emit('decr:error', {
-				key: finalKey,
-				seconds: finalSeconds,
-				error: err
-			});
-			return null;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `减少整数值失败 [${key}]:`, err);
-		this.emit('decr:error', {
-			key,
-			seconds,
-			error: err
-		});
-		return null;
-	}
-};
-
-/**
- * @description 将键的值增加指定的浮点数（兼容方法，与addFloat功能相同）
- * @param {String} key 键
- * @param {Number} increment 浮点数增量
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 增加后的值
- */
-Redis.prototype.incrbyfloat = async function (key, increment, seconds = 0) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('键必须是非空字符串');
-		}
-		if (typeof increment !== 'number' || isNaN(increment)) {
-			throw new TypeError('增量必须是有效数字');
-		}
-
-		// 触发前置事件
-		const ctx = {
-			key,
-			increment,
-			seconds,
-			cancel: false
-		};
-		this.emit('incrbyfloat:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `incrbyfloat操作被事件处理器取消 [${key}]`);
-			return null;
-		}
-
-		const {
-			key: finalKey,
-			increment: finalIncrement,
-			seconds: finalSeconds
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-			// 使用正确的Redis客户端Promise API
-			const result = await connection.incrByFloat(prefixedKey, finalIncrement);
-			const parsedResult = parseFloat(result);
-
-			// 如果设置了过期时间
-			if (finalSeconds > 0) {
-				if (typeof connection.expire === 'function') {
-					await connection.expire(prefixedKey, finalSeconds);
-				} else if (typeof connection.execute === 'function') {
-					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
-				}
-			}
-
-			this.emit('incrbyfloat:after', {
-				key: finalKey,
-				increment: finalIncrement,
-				seconds: finalSeconds,
-				result: parsedResult
-			});
-			return parsedResult;
-		} catch (err) {
-			this.log('error', `增加浮点数值失败 [${finalKey}]:`, err);
-			this.emit('incrbyfloat:error', {
-				key: finalKey,
-				increment: finalIncrement,
-				seconds: finalSeconds,
-				error: err
-			});
-			return null;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `增加浮点数值失败 [${key}]:`, err);
-		this.emit('incrbyfloat:error', {
-			key,
-			increment,
-			seconds,
-			error: err
-		});
-		return null;
-	}
-};
-
-/**
- * @description 将键的值增加指定的整数（兼容方法）
- * @param {String} key 键
- * @param {Number} increment 增量
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 增加后的值
- */
-Redis.prototype.incrby = async function (key, increment, seconds = 0) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('键必须是非空字符串');
-		}
-		if (typeof increment !== 'number' || isNaN(increment) || !Number.isInteger(increment)) {
-			throw new TypeError('增量必须是有效整数');
-		}
-
-		// 触发前置事件
-		const ctx = {
-			key,
-			increment,
-			seconds,
-			cancel: false
-		};
-		this.emit('incrby:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `incrby操作被事件处理器取消 [${key}]`);
-			return null;
-		}
-
-		const {
-			key: finalKey,
-			increment: finalIncrement,
-			seconds: finalSeconds
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-			// 使用正确的Redis客户端Promise API
-			const result = await connection.incrBy(prefixedKey, finalIncrement);
-
-			// 如果设置了过期时间
-			if (finalSeconds > 0) {
-				if (typeof connection.expire === 'function') {
-					await connection.expire(prefixedKey, finalSeconds);
-				} else if (typeof connection.execute === 'function') {
-					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
-				}
-			}
-
-			this.emit('incrby:after', {
-				key: finalKey,
-				increment: finalIncrement,
-				seconds: finalSeconds,
-				result
-			});
-			return result;
-		} catch (err) {
-			this.log('error', `增加指定值失败 [${finalKey}]:`, err);
-			this.emit('incrby:error', {
-				key: finalKey,
-				increment: finalIncrement,
-				seconds: finalSeconds,
-				error: err
-			});
-			return null;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `增加指定值失败 [${key}]:`, err);
-		this.emit('incrby:error', {
-			key,
-			increment,
-			seconds,
-			error: err
-		});
-		return null;
-	}
-};
-
-/**
- * @description 将键的值减少指定的整数（兼容方法）
- * @param {String} key 键
- * @param {Number} decrement 减量
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 减少后的值
- */
-Redis.prototype.decrby = async function (key, decrement, seconds = 0) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('键必须是非空字符串');
-		}
-		if (typeof decrement !== 'number' || isNaN(decrement) || !Number.isInteger(decrement)) {
-			throw new TypeError('减量必须是有效整数');
-		}
-
-		// 触发前置事件
-		const ctx = {
-			key,
-			decrement,
-			seconds,
-			cancel: false
-		};
-		this.emit('decrby:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `decrby操作被事件处理器取消 [${key}]`);
-			return null;
-		}
-
-		const {
-			key: finalKey,
-			decrement: finalDecrement,
-			seconds: finalSeconds
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-			// 使用正确的Redis客户端Promise API
-			const result = await connection.decrBy(prefixedKey, finalDecrement);
-
-			// 如果设置了过期时间
-			if (finalSeconds > 0) {
-				if (typeof connection.expire === 'function') {
-					await connection.expire(prefixedKey, finalSeconds);
-				} else if (typeof connection.execute === 'function') {
-					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
-				}
-			}
-
-			this.emit('decrby:after', {
-				key: finalKey,
-				decrement: finalDecrement,
-				seconds: finalSeconds,
-				result
-			});
-			return result;
-		} catch (err) {
-			this.log('error', `减少指定值失败 [${finalKey}]:`, err);
-			this.emit('decrby:error', {
-				key: finalKey,
-				decrement: finalDecrement,
-				seconds: finalSeconds,
-				error: err
-			});
-			return null;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `减少指定值失败 [${key}]:`, err);
-		this.emit('decrby:error', {
-			key,
-			decrement,
-			seconds,
-			error: err
-		});
-		return null;
-	}
-};
-
-// 集合操作方法
-
-/**
- * @description 将成员添加到集合
- * @param {String} key 键
- * @param {String|Array} members 成员或成员数组
- * @return {Promise<Number>} 添加的成员数量
- */
-Redis.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) {
-			this.log('debug', `sadd操作被事件处理器取消 [${key}]`);
-			return 0;
-		}
-
-		const {
-			key: finalKey,
-			members: finalMembers
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-			const result = await connection.sAdd(prefixedKey, finalMembers);
-
-			// 触发后置事件
-			this.emit('sadd:after', {
-				key: finalKey,
-				members: finalMembers,
-				result
-			});
-			return result;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `添加集合成员失败 [${key}]:`, err);
-		this.emit('sadd:error', {
-			key,
-			members,
-			error: err
-		});
-		return 0;
-	}
-};
-
-/**
- * @description 从集合中移除成员
- * @param {String} key 键
- * @param {String|Array} members 成员或成员数组
- * @return {Promise<Number>} 移除的成员数量
- */
-Redis.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) {
-			this.log('debug', `srem操作被事件处理器取消 [${key}]`);
-			return 0;
-		}
-
-		const {
-			key: finalKey,
-			members: finalMembers
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-			const result = await connection.sRem(prefixedKey, finalMembers);
-
-			// 触发后置事件
-			this.emit('srem:after', {
-				key: finalKey,
-				members: finalMembers,
-				result
-			});
-			return result;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `移除集合成员失败 [${key}]:`, err);
-		this.emit('srem:error', {
-			key,
-			members,
-			error: err
-		});
-		return 0;
-	}
-};
-
-/**
- * @description 检查成员是否在集合中
- * @param {String} key 键
- * @param {String} member 成员
- * @return {Promise<Boolean>} 是否存在
- */
-Redis.prototype.sismember = async function (key, member) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
-		if (member === undefined || member === null) {
-			throw new TypeError('member不能为undefined或null');
-		}
-
-		this.emit('sismember:before', {
-			key,
-			member
-		});
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(key);
-			// 将成员转换为字符串，与其他模块行为一致
-			const memberStr = String(member);
-			const result = await connection.sIsMember(prefixedKey, memberStr);
-			this.emit('sismember:after', {
-				key,
-				member,
-				result
-			});
-			return result;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.emit('sismember:error', {
-			key,
-			member,
-			error: err
-		});
-		this.log('error', `检查集合成员失败 [${key}:${member}]:`, err);
-		return false;
-	}
-};
-
-/**
- * @description 获取集合中的所有成员
- * @param {String} key 键
- * @return {Promise<Array>} 成员数组
- */
-Redis.prototype.smembers = async function (key) {
-	try {
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(key);
-			const result = await connection.sMembers(prefixedKey);
-			this.emit('smembers:after', {
-				key,
-				result
-			});
-			return result || [];
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `获取集合所有成员失败 [${key}]:`, err);
-		this.emit('smembers:error', {
-			key,
-			error: err
-		});
-		return [];
-	}
-};
-
-/**
- * @description 获取集合中的成员数量
- * @param {String} key 键
- * @return {Promise<Number>} 成员数量
- */
-Redis.prototype.scard = async function (key) {
-	try {
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(key);
-			const result = await connection.sCard(prefixedKey);
-			return result;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `获取集合大小失败 [${key}]:`, err);
-		return 0;
-	}
-};
-
-/**
- * @description 获取多个集合的交集
- * @param {Array} keys 键数组
- * @return {Promise<Array>} 交集成员数组
- */
-Redis.prototype.sinter = async function (keys) {
-	try {
-		const connection = await this._getConnection();
-		try {
-			const prefixedKeys = keys.map(key => this._addPrefix(key));
-			// 使用Redis v4正确的方法
-			const result = await connection.sInter(...prefixedKeys);
-			return result || [];
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `获取集合交集失败:`, err);
-		return [];
-	}
-};
-
-/**
- * @description 获取多个集合的并集
- * @param {Array} keys 键数组
- * @return {Promise<Array>} 并集成员数组
- */
-Redis.prototype.sunion = async function (keys) {
-	try {
-		const connection = await this._getConnection();
-		try {
-			const prefixedKeys = keys.map(key => this._addPrefix(key));
-			// 使用Redis v4正确的方法
-			const result = await connection.sUnion(...prefixedKeys);
-			return result || [];
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `获取集合并集失败:`, err);
-		return [];
-	}
-};
-
-/**
- * @description 获取多个集合的差集
- * @param {Array} keys 键数组
- * @return {Promise<Array>} 差集成员数组
- */
-Redis.prototype.sdiff = async function (keys) {
-	try {
-		const connection = await this._getConnection();
-		try {
-			const prefixedKeys = keys.map(key => this._addPrefix(key));
-			// 使用Redis v4正确的方法
-			const result = await connection.sDiff(...prefixedKeys);
-			return result || [];
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `获取集合差集失败:`, err);
-		return [];
-	}
-};
-
-// 有序集合操作方法
-
-/**
- * @description 添加成员到有序集合
- * @param {String} key 键
- * @param {Number} score 分数
- * @param {String} member 成员
- * @return {Promise<Boolean>} 是否成功
- */
-Redis.prototype.zadd = async function (key, score, member) {
-	try {
-		// 触发前置事件
-		const ctx = {
-			key,
-			score,
-			member,
-			cancel: false
-		};
-		this.emit('zadd:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `zadd操作被事件处理器取消 [${key}]`);
-			return false;
-		}
-
-		const {
-			key: finalKey,
-			score: finalScore,
-			member: finalMember
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-			const result = await connection.zAdd(prefixedKey, {
-				score: finalScore,
-				value: finalMember
-			});
-
-			// 触发后置事件
-			this.emit('zadd:after', {
-				key: finalKey,
-				score: finalScore,
-				member: finalMember,
-				success: result === 1
-			});
-			return result === 1;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `添加有序集合成员失败 [${key}]:`, err);
-		this.emit('zadd:error', {
-			key,
-			score,
-			member,
-			error: err
-		});
-		return false;
-	}
-};
-
-/**
- * @description 从有序集合中移除成员
- * @param {String} key 键
- * @param {String|Array} members 成员或成员数组
- * @return {Promise<Number>} 移除的成员数量
- */
-Redis.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) {
-			this.log('debug', `zrem操作被事件处理器取消 [${key}]`);
-			return 0;
-		}
-
-		const {
-			key: finalKey,
-			members: finalMembers
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			// 使用正确的Redis客户端Promise API
-			const result = await connection.zRem(this._addPrefix(finalKey), ...finalMembers);
-
-			// 触发后置事件
-			this.emit('zrem:after', {
-				key: finalKey,
-				members: finalMembers,
-				result
-			});
-			return result;
-		} catch (err) {
-			this.log('error', `移除有序集合成员失败 [${finalKey}]:`, err);
-			this.emit('zrem:error', {
-				key: finalKey,
-				members: finalMembers,
-				error: err
-			});
-			return 0;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `移除有序集合成员失败 [${key}]:`, err);
-		this.emit('zrem:error', {
-			key,
-			members,
-			error: err
-		});
-		return 0;
-	}
-};
-
-/**
- * @description 获取有序集合中成员的分数
- * @param {String} key 键
- * @param {String} member 成员
- * @return {Promise<Number|null>} 分数
- */
-Redis.prototype.zscore = async function (key, member) {
-	try {
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(key);
-			const result = await connection.zScore(prefixedKey, member);
-			return result ? parseFloat(result) : null;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `获取有序集合成员分数失败 [${key}:${member}]:`, err);
-		return null;
-	}
-};
-
-/**
- * @description 获取有序集合中成员的排名（分数从小到大）
- * @param {String} key 键
- * @param {String} member 成员
- * @return {Promise<Number|null>} 排名
- */
-Redis.prototype.zrank = async function (key, member) {
-	try {
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(key);
-			const result = await connection.zRank(prefixedKey, member);
-			return result;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `获取有序集合成员排名失败 [${key}:${member}]:`, err);
-		return null;
-	}
-};
-
-/**
- * @description 获取有序集合中指定范围的成员
- * @param {String} key 键
- * @param {Number} start 起始索引
- * @param {Number} stop 结束索引
- * @param {Boolean} withScores 是否返回分数
- * @return {Promise<Array>} 成员数组
- */
-Redis.prototype.zrange = async function (key, start, stop, withScores = false) {
-	try {
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(key);
-
-			if (withScores) {
-				// 对于需要分数的情况，使用更可靠的方法
-				try {
-					// 直接获取所有成员的分数
-					const members = await connection.zRange(prefixedKey, start, stop);
-					const results = [];
-
-					// 为每个成员单独获取分数，确保准确性
-					for (const member of members) {
-						try {
-							let score = await connection.zScore(prefixedKey, member);
-							score = score ? parseFloat(score) : 0;
-							results.push({
-								member,
-								score
-							});
-						} catch (scoreErr) {
-							// 如果获取分数失败，设置默认值0
-							results.push({
-								member,
-								score: 0
-							});
-							this.log('error', `获取成员 ${member} 分数失败:`, scoreErr);
-						}
-					}
-
-					return results;
-				} catch (err) {
-					this.log('error', `使用备用方法获取有序集合范围失败 [${prefixedKey}]:`, err);
-					// 回退到简单列表
-					return [];
-				}
-			} else {
-				// 不需要分数的情况
-				const result = await connection.zRange(prefixedKey, start, stop);
-				return result || [];
-			}
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `获取有序集合范围成员失败 [${key}]:`, err);
-		return [];
-	}
-};
-
-/**
- * @description 获取有序集合中的成员数量
- * @param {String} key 键
- * @return {Promise<Number>} 成员数量
- */
-Redis.prototype.zcard = async function (key) {
-	try {
-		const connection = await this._getConnection();
-		try {
-			// 使用正确的Redis客户端Promise API
-			const result = await connection.zCard(this._addPrefix(key));
-			return result || 0;
-		} catch (err) {
-			this.log('error', `获取有序集合成员数量失败 [${key}]:`, err);
-			return 0;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `获取有序集合成员数量失败 [${key}]:`, err);
-		return 0;
-	}
-};
-
-/**
- * @description 增加有序集合中成员的分数（兼容方法）
- * @param {String} key 键
- * @param {Number} increment 增量
- * @param {String} member 成员
- * @param {Number} [seconds=0] 过期时间（秒）
- * @return {Promise<Number>} 增加后的分数
- */
-Redis.prototype.zincrby = async function (key, increment, member, seconds = 0) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('键必须是非空字符串');
-		}
-		if (typeof increment !== 'number' || isNaN(increment)) {
-			throw new TypeError('增量必须是有效数字');
-		}
-		if (!member || typeof member !== 'string') {
-			throw new TypeError('成员必须是非空字符串');
-		}
-
-		// 触发前置事件
-		const ctx = {
-			key,
-			increment,
-			member,
-			seconds,
-			cancel: false
-		};
-		this.emit('zincrby:before', ctx);
-
-		if (ctx.cancel) {
-			this.log('debug', `zincrby操作被事件处理器取消 [${key}]`);
-			return null;
-		}
-
-		const {
-			key: finalKey,
-			increment: finalIncrement,
-			member: finalMember,
-			seconds: finalSeconds
-		} = ctx;
-
-		const connection = await this._getConnection();
-		try {
-			const prefixedKey = this._addPrefix(finalKey);
-			// 使用正确的Redis客户端Promise API
-			const result = await connection.zIncrBy(prefixedKey, finalIncrement, finalMember);
-
-			// 如果设置了过期时间
-			if (finalSeconds > 0) {
-				if (typeof connection.expire === 'function') {
-					await connection.expire(prefixedKey, finalSeconds);
-				} else if (typeof connection.execute === 'function') {
-					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
-				}
-			}
-
-			// 触发后置事件
-			this.emit('zincrby:after', {
-				key: finalKey,
-				increment: finalIncrement,
-				member: finalMember,
-				seconds: finalSeconds,
-				result: parseFloat(result)
-			});
-			return parseFloat(result);
-		} catch (err) {
-			this.log('error', `增加有序集合成员分数失败 [${finalKey}]:`, err);
-			this.emit('zincrby:error', {
-				key: finalKey,
-				increment: finalIncrement,
-				member: finalMember,
-				seconds: finalSeconds,
-				error: err
-			});
-			return null;
-		} finally {
-			this._recycleConnection(connection);
-		}
-	} catch (err) {
-		this.log('error', `增加有序集合成员分数失败 [${key}]:`, err);
-		this.emit('zincrby:error', {
-			key,
-			increment,
-			member,
-			seconds,
-			error: err
-		});
-		return null;
-	}
-};
-
-// 创建真实Redis连接的方法
-Redis.prototype._createConnection = function () {
-	return new Promise((resolve, reject) => {
-		try {
-			const cg = this.config;
-
-			// 创建真实的Redis客户端连接
-			const connection = createClient({
-				socket: {
-					host: cg.host,
-					port: cg.port,
-					timeout: cg.connect_timeout
-				},
-				password: cg.password,
-				database: cg.database
-			});
-
-			// 添加标识符
-			connection.id = Date.now() + Math.random();
-
-			// 监听错误事件
-			connection.on('error', (err) => {
-				this.log('error', `连接 ${connection.id} 错误:`, err);
-			});
-
-			// 连接Redis
-			connection.connect().then(() => {
-				// this.log('debug','新连接已创建并连接:', connection.id);
-				resolve(connection);
-			}).catch(err => {
-				this.log('error', '创建连接失败:', err);
-				reject(err);
-			});
-		} catch (error) {
-			this.log('error', '创建连接时发生异常:', error);
-			reject(error);
-		}
-	});
-};
-
-
-/**
- * 确保连接池对象存在
- */
-if (!$.pool) {
-	$.pool = {};
-}
-if (!$.pool.redis) {
-	$.pool.redis = {};
-}
-
-/**
- * @description Redis管理器，用于创建缓存
- * @param {String} scope 作用域
- * @param {Object} config 配置参数
- * @return {Object} 返回一个Redis类实例
- */
-function redisAdmin(scope, config) {
-	if (!scope) {
-		scope = 'sys';
-	}
-	var obj = $.pool.redis[scope];
-	if (!obj) {
-		$.pool.redis[scope] = new Redis(config);
-		obj = $.pool.redis[scope];
-	}
-	return obj;
-}
+let admin = new Admin();
+admin.setClass(Redis);
 
 module.exports = {
 	Redis,
-	redisAdmin
+	admin,
+	redisAdmin(scope, config) {
+		if (!scope) {
+			scope = 'os';
+		}
+		return admin.get(scope, config);
+	}
 };