mm_redis 2.0.7 → 2.0.8

package/index.js

@@ -1,18 +1,13 @@
-/**
- * @fileOverview redis缓存帮助类函数
- * @author <a href="http://qww.elins.cn">邱文武</a>
- * @version 1.5.0
- */
 const {
 	createClient
 } = require('redis');
-const {Event} = require('mm_expand');
+const { Base } = require('mm_expand');
 
-// Redis缓存帮助类函数
-
-/* 创建Redis帮助类函数 */
-/// 构造函数
-class Redis extends Event {
+/**
+ * @class Redis
+ * @description Redis缓存帮助类函数
+ */
+class Redis extends Base {
 	/**
 	 * @description 创建Redis帮助类函数 (构造函数)
 	 * @param {Object} config 配置参数
@@ -66,8 +61,9 @@ class Redis extends Event {
  * 应用键前缀
  * @param {String} key 键
  * @return {String} 处理后的键
+ * @private
  */
-Redis.prototype.applyPrefix = function(key) {
+Redis.prototype._addPrefix = function (key) {
 	return this.config.prefix ? this.config.prefix + key : key;
 };
 
@@ -75,8 +71,9 @@ Redis.prototype.applyPrefix = function(key) {
  * 移除键前缀
  * @param {String} key 带前缀的键
  * @return {String} 处理后的键
+ * @private
  */
-Redis.prototype.removePrefix = function(key) {
+Redis.prototype._delPrefix = function (key) {
 	if (this.config.prefix && key.startsWith(this.config.prefix)) {
 		return key.slice(this.config.prefix.length);
 	}
@@ -89,13 +86,21 @@ Redis.prototype.removePrefix = function(key) {
  * @param {Function} func 操作回调函数，可判断成功与否
  * @return {Promise<Boolean>} 订阅结果
  */
-Redis.prototype.subscribe = async function(channel, func) {
+Redis.prototype.subscribe = async function (channel, func) {
 	try {
-		await this.conn.subscribe(this.applyPrefix(channel));
+		// 参数验证
+		if (!channel || typeof channel !== 'string') {
+			throw new TypeError('channel必须是非空字符串');
+		}
+		if (typeof func !== 'function') {
+			throw new TypeError('func必须是函数');
+		}
+
+		await this.conn.subscribe(this._addPrefix(channel));
 		this.func_list[channel] = func;
 		return true;
 	} catch (err) {
-		this.logger('error',`订阅频道 ${channel} 失败:`, err);
+		this.logger('error', `订阅频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -105,13 +110,18 @@ Redis.prototype.subscribe = async function(channel, func) {
  * @param {String} channel 订阅的频道
  * @return {Promise<Boolean>} 取消订阅结果
  */
-Redis.prototype.unsubscribe = async function(channel) {
+Redis.prototype.unsubscribe = async function (channel) {
 	try {
-		await this.conn.unsubscribe(this.applyPrefix(channel));
+		// 参数验证
+		if (!channel || typeof channel !== 'string') {
+			throw new TypeError('channel必须是非空字符串');
+		}
+
+		await this.conn.unsubscribe(this._addPrefix(channel));
 		delete this.func_list[channel];
 		return true;
 	} catch (err) {
-		this.logger('error',`取消订阅频道 ${channel} 失败:`, err);
+		this.logger('error', `取消订阅频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -122,11 +132,19 @@ Redis.prototype.unsubscribe = async function(channel) {
  * @param {String} message 订阅的消息
  * @return {Promise<Number>} 接收消息的客户端数量
  */
-Redis.prototype.publish = async function(channel, message) {
+Redis.prototype.publish = async function (channel, message) {
 	try {
-		return await this.conn.publish(this.applyPrefix(channel), message);
+		// 参数验证
+		if (!channel || typeof channel !== 'string') {
+			throw new TypeError('channel必须是非空字符串');
+		}
+		if (message === undefined || message === null) {
+			throw new TypeError('message不能为undefined或null');
+		}
+
+		return await this.conn.publish(this._addPrefix(channel), message);
 	} catch (err) {
-		this.logger('error',`发布消息到频道 ${channel} 失败:`, err);
+		this.logger('error', `发布消息到频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -136,9 +154,9 @@ Redis.prototype.publish = async function(channel, message) {
  * @param {String} channel
  * @param {String} message
  */
-Redis.prototype.main = async function(channel, message) {
+Redis.prototype.main = async function (channel, message) {
 	// 默认实现，可由子类重写
-	this.logger('debug',`收到未处理的消息 [${channel}]:`, message);
+	this.logger('debug', `收到未处理的消息 [${channel}]:`, message);
 };
 
 /**
@@ -146,15 +164,15 @@ Redis.prototype.main = async function(channel, message) {
  * @param {String} channel 频道
  * @param {String} message 消息
  */
-Redis.prototype.message = function(channel, message) {
+Redis.prototype.message = function (channel, message) {
 	// 移除前缀
-	channel = this.removePrefix(channel);
+	channel = this._delPrefix(channel);
 	var func = this.func_list[channel];
 	if (func) {
 		try {
 			func(message);
 		} catch (err) {
-			this.logger('error',`处理频道 ${channel} 的消息时出错:`, err);
+			this.logger('error', `处理频道 ${channel} 的消息时出错:`, err);
 		}
 	} else {
 		this.main(channel, message);
@@ -165,7 +183,7 @@ Redis.prototype.message = function(channel, message) {
  * @description 设置配置
  * @param {Object} config 配置对象或配置路径
  */
-Redis.prototype.setConfig = function(config) {
+Redis.prototype.setConfig = function (config) {
 	let obj = {};
 	if (typeof config === 'string') {
 		obj = config.loadJson(__dirname);
@@ -222,7 +240,7 @@ Redis.prototype.setConfig = function(config) {
 };
 
 // 添加连接池初始化方法
-Redis.prototype._initPool = function() {
+Redis.prototype._initPool = function () {
 	// 确保连接池配置存在
 	if (!this.config.pool) {
 		this.config.pool = {
@@ -248,7 +266,7 @@ Redis.prototype._initPool = function() {
  * @description 连接Redis数据库
  * @return {Promise<Boolean>} 连接结果
  */
-Redis.prototype.open = async function() {
+Redis.prototype.open = async function () {
 	if (this.conn && this.connected) {
 		return true;
 	}
@@ -270,7 +288,7 @@ Redis.prototype.open = async function() {
 
 		// 监听错误事件
 		this.conn.on('error', (err) => {
-			this.logger('error','Redis连接错误:', err);
+			this.logger('error', 'Redis连接错误:', err);
 			this.connected = false;
 			// 尝试重连
 			this._reconnect();
@@ -291,12 +309,12 @@ Redis.prototype.open = async function() {
 
 		// 监听订阅成功事件
 		this.conn.on('subscribe', (channel, count) => {
-			this.logger('debug',`频道${this.removePrefix(channel)}订阅成功, 当前总计订阅数：${count}`);
+			this.logger('debug', `频道${this._delPrefix(channel)}订阅成功, 当前总计订阅数：${count}`);
 		});
 
 		// 监听取消订阅事件
 		this.conn.on('unsubscribe', (channel, count) => {
-			this.logger('debug',`频道${this.removePrefix(channel)}取消订阅, 当前总计订阅数：${count}`);
+			this.logger('debug', `频道${this._delPrefix(channel)}取消订阅, 当前总计订阅数：${count}`);
 		});
 
 		// 收到消息后执行回调
@@ -309,7 +327,7 @@ Redis.prototype.open = async function() {
 		this.connected = true;
 		return true;
 	} catch (err) {
-		this.logger('error','Redis连接失败:', err);
+		this.logger('error', 'Redis连接失败:', err);
 		// 尝试重连
 		this._reconnect();
 		return false;
@@ -320,20 +338,20 @@ Redis.prototype.open = async function() {
  * 内部重连方法
  * @private
  */
-Redis.prototype._reconnect = function() {
+Redis.prototype._reconnect = function () {
 	if (this.retry_count >= this.config.retry_count) {
-		this.logger('error',`达到最大重连次数 ${this.config.retry_count}，停止重连`);
+		this.logger('error', `达到最大重连次数 ${this.config.retry_count}，停止重连`);
 		return;
 	}
 
 	this.retry_count++;
-	this.logger('debug',`尝试第 ${this.retry_count} 次重连...`);
+	this.logger('debug', `尝试第 ${this.retry_count} 次重连...`);
 
 	setTimeout(async () => {
 		try {
 			await this.open();
 		} catch (err) {
-			this.logger('error',`重连失败:`, err);
+			this.logger('error', `重连失败:`, err);
 		}
 	}, this.config.retry_delay);
 };
@@ -343,7 +361,7 @@ Redis.prototype._reconnect = function() {
  * @return {Promise<Boolean>} 关闭结果
  */
 // 修复close方法，正确处理连接池
-Redis.prototype.close = function() {
+Redis.prototype.close = function () {
 	try {
 		// this.logger('debug','关闭所有连接...');
 
@@ -353,7 +371,7 @@ Redis.prototype.close = function() {
 				try {
 					connection.close();
 				} catch (e) {
-					this.logger('error','关闭连接失败:', e);
+					this.logger('error', '关闭连接失败:', e);
 				}
 			}
 			this.connection_pool.in_use.clear();
@@ -370,68 +388,68 @@ Redis.prototype.close = function() {
 						// 某些Redis客户端可能使用end方法
 						connection.end();
 					} else {
-						this.logger('debug','连接对象没有可用的关闭方法');
+						this.logger('debug', '连接对象没有可用的关闭方法');
 					}
 				} catch (e) {
-					this.logger('error','关闭连接失败:', e);
+					this.logger('error', '关闭连接失败:', e);
 				}
 			}
 			this.connection_pool.available = [];
 		}
 
 		this.connected = false;
-		this.logger('debug','Redis连接已断开');
+		this.logger('debug', 'Redis连接已断开');
 		return Promise.resolve(true);
 	} catch (error) {
-		this.logger('error','关闭连接时发生错误:', error);
+		this.logger('error', '关闭连接时发生错误:', error);
 		return Promise.resolve(false);
 	}
 };
 
 // 添加Pipeline支持
-Redis.prototype.pipeline = function() {
+Redis.prototype.pipeline = function () {
 	const redisInstance = this;
 	const commands = [];
 
 	return {
 		// 设置值
-		set: function(key, value, seconds) {
+		set: function (key, value, seconds) {
 			commands.push(['set', key, value, seconds]);
 			return this;
 		},
 
 		// 获取值
-		get: function(key) {
+		get: function (key) {
 			commands.push(['get', key]);
 			return this;
 		},
 
 		// 删除
-		del: function(key) {
+		del: function (key) {
 			commands.push(['del', key]);
 			return this;
 		},
 
 		// 判断存在
-		has: function(key) {
+		has: function (key) {
 			commands.push(['has', key]);
 			return this;
 		},
 
 		// 设置哈希字段
-		hset: function(key, field, value) {
+		hset: function (key, field, value) {
 			commands.push(['hset', key, field, value]);
 			return this;
 		},
 
 		// 过期时间设置
-		expire: function(key, seconds) {
+		expire: function (key, seconds) {
 			commands.push(['expire', key, seconds]);
 			return this;
 		},
 
 		// 执行所有命令
-		exec: async function() {
+		exec: async function () {
 			try {
 				// 使用Redis实例的方法获取连接
 				const connection = await redisInstance._getConnection();
@@ -448,7 +466,7 @@ Redis.prototype.pipeline = function() {
 							case 'set': {
 								// 键前缀处理和值序列化
 								const [key, value, seconds] = args;
-								const prefixedKey = redisInstance.applyPrefix(key);
+								const prefixedKey = redisInstance._addPrefix(key);
 								let processedValue = value;
 								if (typeof value === 'object' && value !== null) {
 									processedValue = JSON.stringify(value);
@@ -462,7 +480,7 @@ Redis.prototype.pipeline = function() {
 							}
 							case 'get': {
 								const [key] = args;
-								const prefixedKey = redisInstance.applyPrefix(key);
+								const prefixedKey = redisInstance._addPrefix(key);
 								result = await connection.get(prefixedKey);
 								// 尝试解析JSON
 								if (typeof result === 'string') {
@@ -479,25 +497,25 @@ Redis.prototype.pipeline = function() {
 							}
 							case 'del': {
 								const [key] = args;
-								const prefixedKey = redisInstance.applyPrefix(key);
+								const prefixedKey = redisInstance._addPrefix(key);
 								result = await connection.del(prefixedKey);
 								break;
 							}
 							case 'has': {
 								const [key] = args;
-								const prefixedKey = redisInstance.applyPrefix(key);
+								const prefixedKey = redisInstance._addPrefix(key);
 								result = await connection.exists(prefixedKey) > 0;
 								break;
 							}
 							case 'hset': {
 								const [key, field, value] = args;
-								const prefixedKey = redisInstance.applyPrefix(key);
+								const prefixedKey = redisInstance._addPrefix(key);
 								result = await connection.hSet(prefixedKey, field, value);
 								break;
 							}
 							case 'expire': {
 								const [key, seconds] = args;
-								const prefixedKey = redisInstance.applyPrefix(key);
+								const prefixedKey = redisInstance._addPrefix(key);
 								result = await connection.expire(prefixedKey, seconds);
 								break;
 							}
@@ -510,7 +528,7 @@ Redis.prototype.pipeline = function() {
 						// 直接返回结果值，符合测试期望的格式
 						results.push(result);
 					} catch (err) {
-						this.logger('error',`Pipeline命令执行失败 [${cmd[0]}]:`, err);
+						this.logger('error', `Pipeline命令执行失败 [${cmd[0]}]:`, err);
 						results.push(null);
 					}
 				}
@@ -519,7 +537,7 @@ Redis.prototype.pipeline = function() {
 				redisInstance._recycleConnection(connection);
 				return results;
 			} catch (error) {
-				this.logger('error','Pipeline执行失败:', error);
+				this.logger('error', 'Pipeline执行失败:', error);
 				return [];
 			}
 		}
@@ -530,7 +548,7 @@ Redis.prototype.pipeline = function() {
  * @description 检查连接状态
  * @return {Boolean} 连接状态
  */
-Redis.prototype.isConnected = function() {
+Redis.prototype.isConnected = function () {
 	return this.connected && this.conn && this.conn.isReady;
 };
 
@@ -546,11 +564,16 @@ Redis.prototype.isConnected = function() {
  * @param {Number} [seconds] 过期时间（秒），不传此参数则获取剩余过期时间
  * @return {Promise<Number|Boolean>} 不传seconds时返回剩余过期时间（-1表示无过期设置，-2表示已过期），传seconds时返回是否设置成功
  */
-Redis.prototype.ttl = async function(key, seconds) {
+Redis.prototype.ttl = async function (key, seconds) {
 	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			throw new TypeError('key必须是非空字符串');
+		}
+
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 
 			// 如果传入了seconds参数，则设置过期时间
 			if (seconds !== undefined) {
@@ -566,7 +589,7 @@ Redis.prototype.ttl = async function(key, seconds) {
 					await connection.execute('EXPIRE', [key, seconds]);
 					return true;
 				} else {
-					this.logger('error','连接对象不支持expire操作');
+					this.logger('error', '连接对象不支持expire操作');
 					return false;
 				}
 			}
@@ -577,14 +600,14 @@ Redis.prototype.ttl = async function(key, seconds) {
 			} else if (typeof connection.execute === 'function') {
 				return await connection.execute('TTL', [key]);
 			} else {
-				this.logger('error','连接对象不支持ttl操作');
+				this.logger('error', '连接对象不支持ttl操作');
 				return -2; // 默认返回键不存在
 			}
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`${seconds !== undefined ? '设置' : '获取'}过期时间失败 [${key}]:`, err);
+		this.logger('error', `${seconds !== undefined ? '设置' : '获取'}过期时间失败 [${key}]:`, err);
 		return seconds !== undefined ? false : -2;
 	}
 };
@@ -596,15 +619,15 @@ Redis.prototype.ttl = async function(key, seconds) {
  * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 计算后的结果
  */
-Redis.prototype.addInt = async function(key, num, seconds = 0) {
+Redis.prototype.addInt = async function (key, num, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			this.logger('error','参数错误: 键必须是非空字符串');
+			this.logger('error', '参数错误: 键必须是非空字符串');
 			return false;
 		}
 		if (typeof num !== 'number' || isNaN(num) || !Number.isInteger(num)) {
-			this.logger('error','参数错误: 数值必须是有效整数');
+			this.logger('error', '参数错误: 数值必须是有效整数');
 			return false;
 		}
 
@@ -619,7 +642,7 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug',`addInt操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `addInt操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -632,7 +655,7 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			let result;
 			if (finalNum > 0) {
 				// 增加整数值
@@ -642,7 +665,7 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
 					result = await connection.execute('INCRBY', [prefixedKey, finalNum]);
 				} else {
 					// 如果出错，回退到先获取再设置的方式
-					throw new Error(`使用原子操作增加整数值失败，使用回退方案`);
+					this.logger('warn', `使用原子操作增加整数值失败，使用回退方案 [${key}]`);
 					let value = await this.get(prefixedKey);
 					let n = 0;
 					if (value) {
@@ -660,7 +683,7 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
 					result = await connection.execute('DECRBY', [prefixedKey, -finalNum]);
 				} else {
 					// 如果出错，回退到先获取再设置的方式
-					throw new Error(`使用原子操作减少整数值失败，使用回退方案`);
+					this.logger('warn', `使用原子操作减少整数值失败，使用回退方案`);
 					let value = await this.get(prefixedKey);
 					let n = 0;
 					if (value) {
@@ -701,7 +724,7 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
 			seconds,
 			error: err
 		});
-		this.logger('error',`增加整数值失败 [${key}]:`, err);
+		this.logger('error', `增加整数值失败 [${key}]:`, err);
 		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
 		return 0;
 	}
@@ -714,19 +737,17 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
  * @param {Number} seconds 过期时间，0表示永不过期
  * @return {Promise<Number>} 计算后的结果
  */
-Redis.prototype.addFloat = async function(key, num, seconds = 0) {
+Redis.prototype.addFloat = async function (key, num, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			throw new Error(`addFloat: key参数必须是非空字符串`);
-			return 0;
+			throw new TypeError('key必须是非空字符串');
 		}
 
 		// 验证num参数
 		num = parseFloat(num);
 		if (isNaN(num)) {
-			throw new Error(`addFloat: num参数必须是有效的数值`);
-			return 0;
+			throw new TypeError('num必须是有效的数值');
 		}
 
 		// 触发前置事件，允许修改或阻止操作
@@ -740,7 +761,7 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (ctx.cancel) {
-			this.logger('debug',`addFloat操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `addFloat操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -754,7 +775,7 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 
 			// 优先使用原生方法
 			if (typeof connection.incrByFloat === 'function') {
@@ -766,7 +787,7 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 			}
 			// 回退方案
 			else {
-				throw new Error(`连接对象不支持incrByFloat操作，使用回退方案`);
+				this.logger('warn', `连接对象不支持incrByFloat操作，使用回退方案`);
 				let value = await this.get(prefixedKey);
 				let n = 0;
 				if (value) {
@@ -797,7 +818,7 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 			return result;
 		} catch (err) {
 			// 如果出错，回退到先获取再设置的方式
-			throw new Error(`使用原子操作增加浮点数值失败，使用回退方案:`, err);
+			this.logger('warn', `使用原子操作增加浮点数值失败，使用回退方案:`, err);
 			let value = await this.get(prefixedKey);
 			let n = 0;
 			if (value) {
@@ -826,7 +847,7 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 			seconds,
 			error: err
 		});
-		this.logger('error',`增加浮点数值失败 [${key}]:`, err);
+		this.logger('error', `增加浮点数值失败 [${key}]:`, err);
 		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
 		return 0;
 	}
@@ -839,18 +860,16 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
  * @param {Number} seconds 过期时间，0表示永不过期
  * @return {Promise<Number>} 添加后的字符串长度
  */
-Redis.prototype.addStr = async function(key, str, seconds = 0) {
+Redis.prototype.addStr = async function (key, str, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			throw new Error(`addStr: key参数必须是非空字符串`);
-			return 0;
+			throw new TypeError('key必须是非空字符串');
 		}
 
 		// 验证str参数
 		if (str === undefined || str === null) {
-			throw new Error(`addStr: str参数不能为undefined或null`);
-			return 0;
+			throw new TypeError('str不能为undefined或null');
 		}
 		str = String(str);
 
@@ -865,7 +884,7 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug',`addStr操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `addStr操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -879,7 +898,7 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 
 			// 优先使用原生方法
 			if (typeof connection.append === 'function') {
@@ -891,7 +910,7 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
 			}
 			// 回退方案
 			else {
-				throw new Error(`连接对象不支持append操作，使用回退方案`);
+				this.logger('warn', `连接对象不支持append操作，使用回退方案`);
 				let value = await this.get(prefixedKey) || '';
 				value += finalStr;
 				await this.set(prefixedKey, value, finalSeconds);
@@ -917,7 +936,7 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error','追加字符串失败:', err);
+			this.logger('warn', '追加字符串失败:', err);
 			// 回退方案：先获取再设置
 			let value = await this.get(prefixedKey) || '';
 			value += finalStr;
@@ -943,7 +962,7 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
 			seconds,
 			error: err
 		});
-		this.logger('error',`追加字符串失败 [${key}]:`, err);
+		this.logger('error', `追加字符串失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -953,32 +972,28 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
  * @param {String|Array<String>} key 键或键数组
  * @return {Promise<Boolean>} 成功返回true,失败返回false
  */
-Redis.prototype.del = async function(key) {
+Redis.prototype.del = async function (key) {
 	try {
 		// 键名必须是非空字符串或非空字符串数组
 		if (!key) {
-			throw new Error('del: key必须是非空字符串或非空字符串数组');
-			return false;
+			throw new TypeError('key必须是非空字符串或非空字符串数组');
 		}
 
 		// 如果是单个键，验证是否为非空字符串
 		if (typeof key === 'string') {
 			if (!key) {
-				throw new Error('del: key必须是非空字符串');
-				return false;
+				throw new TypeError('key必须是非空字符串');
 			}
 		}
 		// 如果是数组，验证每个元素是否为非空字符串
 		else if (Array.isArray(key)) {
 			for (const k of key) {
 				if (!k || typeof k !== 'string') {
-					throw new Error('del: key必须是非空字符串或非空字符串数组');
-					return false;
+					throw new TypeError('key必须是非空字符串或非空字符串数组');
 				}
 			}
 		} else {
-			throw new Error('del: key必须是非空字符串或非空字符串数组');
-			return false;
+			throw new TypeError('key必须是非空字符串或非空字符串数组');
 		}
 
 		// 触发前置事件，允许修改或阻止操作
@@ -990,7 +1005,7 @@ Redis.prototype.del = async function(key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug',`del操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `del操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1007,7 +1022,7 @@ Redis.prototype.del = async function(key) {
 				success = true;
 				const deleted = [];
 				for (const k of finalKey) {
-					const prefixedKey = this.applyPrefix(k);
+					const prefixedKey = this._addPrefix(k);
 					const result = await connection.del(prefixedKey);
 					if (result !== 1) {
 						success = false;
@@ -1023,7 +1038,7 @@ Redis.prototype.del = async function(key) {
 				});
 			} else {
 				// 单个删除
-				const prefixedKey = this.applyPrefix(finalKey);
+				const prefixedKey = this._addPrefix(finalKey);
 				const n = await connection.del(prefixedKey);
 				success = n === 1;
 				// 触发后置事件
@@ -1043,7 +1058,7 @@ Redis.prototype.del = async function(key) {
 			key,
 			error: err
 		});
-		this.logger('error',`删除缓存失败 [${key}]:`, err);
+		this.logger('error', `删除缓存失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1062,12 +1077,11 @@ Redis.prototype.del = async function(key) {
  * @param {Number} seconds 过期时间，0表示永不过期
  * @return {Promise<Boolean>} 成功返回true,失败返回false
  */
-Redis.prototype.set = async function(key, value, seconds = 0) {
+Redis.prototype.set = async function (key, value, seconds = 0) {
 	try {
 		// 键名必须是非空字符串
 		if (!key || typeof key !== 'string') {
-			this.logger('error','参数错误: key必须是非空字符串');
-			return false;
+			throw new TypeError('key必须是非空字符串');
 		}
 
 		// 触发前置事件，允许修改或阻止操作
@@ -1081,7 +1095,7 @@ Redis.prototype.set = async function(key, value, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug',`set操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `set操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1094,8 +1108,8 @@ Redis.prototype.set = async function(key, value, seconds = 0) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
-			if (typeof(finalValue) === "object") {
+			const prefixedKey = this._addPrefix(finalKey);
+			if (typeof (finalValue) === "object") {
 				finalValue = JSON.stringify(finalValue);
 			}
 
@@ -1119,7 +1133,7 @@ Redis.prototype.set = async function(key, value, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`设置缓存失败 [${key}]:`, err);
+		this.logger('error', `设置缓存失败 [${key}]:`, err);
 		// 触发错误事件
 		this.emit('set:error', {
 			key,
@@ -1138,8 +1152,16 @@ Redis.prototype.set = async function(key, value, seconds = 0) {
  * @param {Number} seconds 过期时间（秒）
  * @return {Promise<Boolean>} 操作结果，键不存在时设置成功返回true，键已存在返回false
  */
-Redis.prototype.add = async function(key, value, seconds) {
+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,
@@ -1151,7 +1173,7 @@ Redis.prototype.add = async function(key, value, seconds) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug',`add操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `add操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1164,8 +1186,8 @@ Redis.prototype.add = async function(key, value, seconds) {
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
-			if (typeof(finalValue) === "object") {
+			finalKey = this._addPrefix(finalKey);
+			if (typeof (finalValue) === "object") {
 				finalValue = JSON.stringify(finalValue);
 			}
 
@@ -1191,7 +1213,7 @@ Redis.prototype.add = async function(key, value, seconds) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`添加缓存失败 [${key}]:`, err);
+		this.logger('error', `添加缓存失败 [${key}]:`, err);
 		// 触发错误事件
 		this.emit('add:error', {
 			key,
@@ -1213,12 +1235,11 @@ Redis.prototype.add = async function(key, value, seconds) {
  * @param {String} key 键
  * @return {Promise<*>} 获取到的值，不存在时返回null
  */
-Redis.prototype.get = async function(key) {
+Redis.prototype.get = async function (key) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			throw new Error(`get: key参数必须是非空字符串`);
-			return null;
+			throw new TypeError('key必须是非空字符串');
 		}
 
 		// 触发前置事件，允许修改或阻止操作
@@ -1230,7 +1251,7 @@ Redis.prototype.get = async function(key) {
 
 		// 如果事件处理器标记为取消，则返回null
 		if (ctx.cancel) {
-			this.logger('debug',`get操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `get操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -1239,10 +1260,10 @@ Redis.prototype.get = async function(key) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			const value = await connection.get(prefixedKey);
 			let result = value;
-			if (typeof(value) === "string") {
+			if (typeof (value) === "string") {
 				// 尝试解析JSON
 				try {
 					if (value.startsWith("{") && value.endsWith("}") ||
@@ -1271,7 +1292,7 @@ Redis.prototype.get = async function(key) {
 			key,
 			error: err
 		});
-		this.logger('error',`获取缓存失败 [${key}]:`, err);
+		this.logger('error', `获取缓存失败 [${key}]:`, err);
 		return null;
 	}
 };
@@ -1281,12 +1302,11 @@ Redis.prototype.get = async function(key) {
  * @param {String} key 键
  * @return {Promise<Boolean>} 有返回true, 没有返回false
  */
-Redis.prototype.has = async function(key) {
+Redis.prototype.has = async function (key) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			throw new Error(`has: key参数必须是非空字符串`);
-			return false;
+			throw new TypeError('key必须是非空字符串');
 		}
 
 		// 触发前置事件，允许修改或阻止操作
@@ -1298,7 +1318,7 @@ Redis.prototype.has = async function(key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug',`has操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `has操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1307,7 +1327,7 @@ Redis.prototype.has = async function(key) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			const result = await connection.exists(prefixedKey);
 			const exists = result > 0;
 
@@ -1328,7 +1348,7 @@ Redis.prototype.has = async function(key) {
 			key,
 			error: err
 		});
-		this.logger('error',`检查键是否存在失败 [${key}]:`, err);
+		this.logger('error', `检查键是否存在失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1338,32 +1358,28 @@ Redis.prototype.has = async function(key) {
  * @param {String|Array<String>} key 键或键数组
  * @return {Promise<Number>} 存在的键数量
  */
-Redis.prototype.exists = async function(key) {
+Redis.prototype.exists = async function (key) {
 	try {
 		// 参数验证
 		if (!key) {
-			throw new Error('exists: key必须是非空字符串或非空字符串数组');
-			return 0;
+			throw new TypeError('key必须是非空字符串或非空字符串数组');
 		}
 
 		// 如果是单个键，验证是否为非空字符串
 		if (typeof key === 'string') {
 			if (!key) {
-				throw new Error('exists: key必须是非空字符串');
-				return 0;
+				throw new TypeError('key必须是非空字符串');
 			}
 		}
 		// 如果是数组，验证每个元素是否为非空字符串
 		else if (Array.isArray(key)) {
 			for (const k of key) {
 				if (!k || typeof k !== 'string') {
-					throw new Error('exists: key必须是非空字符串或非空字符串数组');
-					return 0;
+					throw new TypeError('key必须是非空字符串或非空字符串数组');
 				}
 			}
 		} else {
-			throw new Error('exists: key必须是非空字符串或非空字符串数组');
-			return 0;
+			throw new TypeError('key必须是非空字符串或非空字符串数组');
 		}
 
 		// 触发前置事件，允许修改或阻止操作
@@ -1375,7 +1391,7 @@ Redis.prototype.exists = async function(key) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug',`exists操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `exists操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1386,10 +1402,10 @@ Redis.prototype.exists = async function(key) {
 		try {
 			let result;
 			if (typeof finalKey === 'string') {
-				const prefixedKey = this.applyPrefix(finalKey);
+				const prefixedKey = this._addPrefix(finalKey);
 				result = await connection.exists(prefixedKey);
 			} else if (Array.isArray(finalKey)) {
-				const prefixedKeys = finalKey.map(k => this.applyPrefix(k));
+				const prefixedKeys = finalKey.map(k => this._addPrefix(k));
 				result = await connection.exists(...prefixedKeys);
 			}
 
@@ -1410,7 +1426,7 @@ Redis.prototype.exists = async function(key) {
 			key,
 			error: err
 		});
-		this.logger('error',`检查键存在性失败 [${key}]:`, err);
+		this.logger('error', `检查键存在性失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1422,14 +1438,14 @@ Redis.prototype.exists = async function(key) {
  * @param {Number} end 结束位置
  * @return {Promise<String>} 查询值
  */
-Redis.prototype.getrange = async function(key, start, end) {
+Redis.prototype.getrange = async function (key, start, end) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 			return await connection.getRange(key, start, end);
 		} catch (err) {
-			this.logger('error','获取字符串范围失败:', err);
+			this.logger('error', '获取字符串范围失败:', err);
 			// 回退方案
 			const value = await this.get(key);
 			if (value && typeof value === 'string') {
@@ -1440,7 +1456,7 @@ Redis.prototype.getrange = async function(key, start, end) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取字符串范围失败 [${key}]:`, err);
+		this.logger('error', `获取字符串范围失败 [${key}]:`, err);
 		return '';
 	}
 };
@@ -1452,7 +1468,7 @@ Redis.prototype.getrange = async function(key, start, end) {
  * @param {String} str_sub 插入的字符串
  * @return {String} 插入后的字符串
  */
-Redis.prototype.insertString = function(str, index, str_sub) {
+Redis.prototype.insertString = function (str, index, str_sub) {
 	return str.substring(0, index) + str_sub + str.substring(index);
 };
 
@@ -1463,7 +1479,7 @@ Redis.prototype.insertString = function(str, index, str_sub) {
  * @param {String} value 变更的值
  * @return {Promise<Number>} 字符串长度
  */
-Redis.prototype.setrange = async function(key, index, value) {
+Redis.prototype.setrange = async function (key, index, value) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -1476,7 +1492,7 @@ Redis.prototype.setrange = async function(key, index, value) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug',`setrange操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `setrange操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1490,7 +1506,7 @@ Redis.prototype.setrange = async function(key, index, value) {
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			finalKey = this._addPrefix(finalKey);
 
 			// 优先使用原生方法
 			if (typeof connection.setRange === 'function') {
@@ -1502,7 +1518,7 @@ Redis.prototype.setrange = async function(key, index, value) {
 			}
 			// 回退方案
 			else {
-				throw new Error(`连接对象不支持setRange操作，使用回退方案`);
+				this.logger('warn', `连接对象不支持setRange操作，使用回退方案`);
 				let str = await this.get(finalKey) || '';
 				if (str.length < finalIndex) {
 					// 填充空格到指定索引
@@ -1523,7 +1539,7 @@ Redis.prototype.setrange = async function(key, index, value) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error','设置字符串范围失败:', err);
+			this.logger('error', '设置字符串范围失败:', err);
 			// 回退方案
 			let str = await this.get(finalKey) || '';
 			if (str.length < finalIndex) {
@@ -1553,7 +1569,7 @@ Redis.prototype.setrange = async function(key, index, value) {
 			value,
 			error: err
 		});
-		this.logger('error',`设置字符串范围失败 [${key}]:`, err);
+		this.logger('error', `设置字符串范围失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1563,7 +1579,7 @@ Redis.prototype.setrange = async function(key, index, value) {
  * @param {String} key 键, 为空则清空所有
  * @return {Promise<Boolean>} 执行结果
  */
-Redis.prototype.clear = async function(key) {
+Redis.prototype.clear = async function (key) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -1574,7 +1590,7 @@ Redis.prototype.clear = async function(key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug',`clear操作被事件处理器取消`);
+			this.logger('debug', `clear操作被事件处理器取消`);
 			return false;
 		}
 
@@ -1598,7 +1614,7 @@ Redis.prototype.clear = async function(key) {
 					await connection.execute('FLUSHDB');
 					success = true;
 				} else {
-					this.logger('error','连接对象不支持flushDb操作');
+					this.logger('error', '连接对象不支持flushDb操作');
 					success = false;
 				}
 			}
@@ -1618,7 +1634,7 @@ Redis.prototype.clear = async function(key) {
 			key,
 			error: err
 		});
-		this.logger('error','清空缓存失败:', err);
+		this.logger('error', '清空缓存失败:', err);
 		return false;
 	}
 };
@@ -1629,11 +1645,11 @@ Redis.prototype.clear = async function(key) {
  * @param {Object} options 排序选项
  * @return {Promise<Array>} 排序后的数组
  */
-Redis.prototype.sort = async function(key, options = {}) {
+Redis.prototype.sort = async function (key, options = {}) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 			// 默认升序
 			let sortOptions = [];
 			if (options.by) {
@@ -1662,7 +1678,7 @@ Redis.prototype.sort = async function(key, options = {}) {
 
 			return await connection.sort(key, sortOptions);
 		} catch (err) {
-			this.logger('error','排序失败:', err);
+			this.logger('error', '排序失败:', err);
 			// 回退方案：获取数据后在内存中排序
 			const data = await this.getForList(key);
 			return data.sort((a, b) => {
@@ -1676,7 +1692,7 @@ Redis.prototype.sort = async function(key, options = {}) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`排序失败 [${key}]:`, err);
+		this.logger('error', `排序失败 [${key}]:`, err);
 		return [];
 	}
 };
@@ -1686,7 +1702,7 @@ Redis.prototype.sort = async function(key, options = {}) {
  * @param {String} pattern 键模式 支持*号
  * @return {Promise<Array>} 键数组
  */
-Redis.prototype.keys = async function(pattern = '*') {
+Redis.prototype.keys = async function (pattern = '*') {
 	try {
 		const connection = await this._getConnection();
 		try {
@@ -1694,12 +1710,12 @@ Redis.prototype.keys = async function(pattern = '*') {
 			const fullPattern = this.config.prefix ? this.config.prefix + pattern : pattern;
 			const keys = await connection.keys(fullPattern);
 			// 返回移除前缀的键
-			return keys.map(key => this.removePrefix(key));
+			return keys.map(key => this._delPrefix(key));
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error','获取键列表失败:', err);
+		this.logger('error', '获取键列表失败:', err);
 		return [];
 	}
 };
@@ -1711,7 +1727,7 @@ Redis.prototype.keys = async function(pattern = '*') {
  * @param {Number} seconds 秒
  * @return {Promise<Number>} 数组长度
  */
-Redis.prototype.setForList = async function(key, value, seconds) {
+Redis.prototype.setForList = async function (key, value, seconds) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -1724,7 +1740,7 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug',`setForList操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `setForList操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1738,7 +1754,7 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			finalKey = this._addPrefix(finalKey);
 			// 先清空再添加
 			if (typeof connection.del === 'function') {
 				await connection.del(finalKey);
@@ -1754,7 +1770,7 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 					} else if (typeof connection.execute === 'function') {
 						len = await connection.execute('RPUSH', [finalKey, ...finalValue]);
 					} else {
-						this.logger('error','连接对象不支持rPush操作');
+						this.logger('error', '连接对象不支持rPush操作');
 						len = 0;
 					}
 				}
@@ -1765,7 +1781,7 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 				} else if (typeof connection.execute === 'function') {
 					len = await connection.execute('RPUSH', [finalKey, finalValue]);
 				} else {
-					this.logger('error','连接对象不支持rPush操作');
+					this.logger('error', '连接对象不支持rPush操作');
 					len = 0;
 				}
 			}
@@ -1776,7 +1792,7 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 				} else if (typeof connection.execute === 'function') {
 					await connection.execute('EXPIRE', [finalKey, finalSeconds]);
 				} else {
-					this.logger('error','连接对象不支持expire操作');
+					this.logger('error', '连接对象不支持expire操作');
 				}
 			}
 
@@ -1799,7 +1815,7 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 			value,
 			error: err
 		});
-		this.logger('error',`设置列表失败 [${key}]:`, err);
+		this.logger('error', `设置列表失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1811,7 +1827,7 @@ Redis.prototype.setForList = async function(key, value, seconds) {
  * @param {Number} seconds 秒
  * @return {Promise<Number>} 追加后的数组长度
  */
-Redis.prototype.addForList = async function(key, value, seconds = 0) {
+Redis.prototype.addForList = async function (key, value, seconds = 0) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -1824,7 +1840,7 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug',`addForList操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `addForList操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1838,7 +1854,7 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			finalKey = this._addPrefix(finalKey);
 
 			if (Array.isArray(finalValue)) {
 				if (finalValue.length > 0) {
@@ -1848,7 +1864,7 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
 					} else if (typeof connection.execute === 'function') {
 						len = await connection.execute('RPUSH', [finalKey, ...finalValue]);
 					} else {
-						this.logger('error','连接对象不支持rPush操作');
+						this.logger('error', '连接对象不支持rPush操作');
 						len = 0;
 					}
 				}
@@ -1859,7 +1875,7 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
 				} else if (typeof connection.execute === 'function') {
 					len = await connection.execute('RPUSH', [finalKey, finalValue]);
 				} else {
-					this.logger('error','连接对象不支持rPush操作');
+					this.logger('error', '连接对象不支持rPush操作');
 					len = 0;
 				}
 			}
@@ -1870,7 +1886,7 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
 				} else if (typeof connection.execute === 'function') {
 					await connection.execute('EXPIRE', [finalKey, finalSeconds]);
 				} else {
-					this.logger('error','连接对象不支持expire操作');
+					this.logger('error', '连接对象不支持expire操作');
 				}
 			}
 
@@ -1893,7 +1909,7 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
 			value,
 			error: err
 		});
-		this.logger('error',`添加列表项失败 [${key}]:`, err);
+		this.logger('error', `添加列表项失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1904,15 +1920,14 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
  * @param {Object} value 值
  * @return {Promise<Boolean>} 存在返回true, 否则返回false
  */
-Redis.prototype.hasForList = async function(key, value) {
+Redis.prototype.hasForList = async function (key, value) {
 	if (!value) {
-		this.logger('error','参数错误: 值不能为空');
-		return false;
+		throw new TypeError('值不能为空');
 	}
 
 	try {
 		// 尝试使用Redis的LREM命令来检查是否存在
-		const keyWithPrefix = this.applyPrefix(key);
+		const keyWithPrefix = this._addPrefix(key);
 		// 转换value为字符串以便比较
 		const valueStr = JSON.stringify(value);
 		// 使用scan来查找，避免在大列表上的性能问题
@@ -1922,7 +1937,7 @@ Redis.prototype.hasForList = async function(key, value) {
 			return itemStr === valueStr || item === value;
 		});
 	} catch (err) {
-		this.logger('error',`检查列表成员是否存在失败 [${key}]:`, err);
+		this.logger('error', `检查列表成员是否存在失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1934,7 +1949,7 @@ Redis.prototype.hasForList = async function(key, value) {
  * @param {Number} end 结束位置
  * @return {Promise<Array>} 查询到的数组
  */
-Redis.prototype.getForList = async function(key, start = 0, end = -1) {
+Redis.prototype.getForList = async function (key, start = 0, end = -1) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -1947,7 +1962,7 @@ Redis.prototype.getForList = async function(key, start = 0, end = -1) {
 
 		// 如果事件处理器标记为取消，则返回空数组
 		if (ctx.cancel) {
-			this.logger('debug',`getForList操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `getForList操作被事件处理器取消 [${key}]`);
 			return [];
 		}
 
@@ -1960,7 +1975,7 @@ Redis.prototype.getForList = async function(key, start = 0, end = -1) {
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			finalKey = this._addPrefix(finalKey);
 			let result;
 			// 检查连接是否支持lRange方法，Redis v4 API
 			if (typeof connection.lRange === 'function') {
@@ -1972,12 +1987,12 @@ Redis.prototype.getForList = async function(key, start = 0, end = -1) {
 				// 回退到通用execute方法
 				result = await connection.execute('LRANGE', [finalKey, finalStart, finalEnd]);
 			} else {
-				this.logger('error','连接对象不支持lRange或lrange操作');
+				this.logger('error', '连接对象不支持lRange或lrange操作');
 				return [];
 			}
 			// 确保结果是数组
 			if (!Array.isArray(result)) {
-				this.logger('error','列表查询结果不是数组格式');
+				this.logger('error', '列表查询结果不是数组格式');
 				return [];
 			}
 
@@ -2017,7 +2032,7 @@ Redis.prototype.getForList = async function(key, start = 0, end = -1) {
 			end,
 			error: err
 		});
-		this.logger('error',`获取列表失败 [${key}]:`, err);
+		this.logger('error', `获取列表失败 [${key}]:`, err);
 		return [];
 	}
 };
@@ -2027,10 +2042,9 @@ Redis.prototype.getForList = async function(key, start = 0, end = -1) {
  * @param {String} key 键
  * @return {Promise<Boolean>} 成功返回true，失败返回false
  */
-Redis.prototype.clearForList = async function(key) {
+Redis.prototype.clearForList = async function (key) {
 	if (!key) {
-		this.logger('error','参数错误: 键不能为空');
-		return false;
+		throw new TypeError('键不能为空');
 	}
 
 	try {
@@ -2043,7 +2057,7 @@ Redis.prototype.clearForList = async function(key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug',`clearForList操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `clearForList操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2052,7 +2066,7 @@ Redis.prototype.clearForList = async function(key) {
 
 		// 直接使用set方法设置为空数组，这样更可靠且与其他模块行为一致
 		// 这样可以确保返回值是一个空数组，而不是null或undefined
-		finalKey = this.applyPrefix(finalKey);
+		finalKey = this._addPrefix(finalKey);
 		await this.set(finalKey, []);
 
 		// 触发后置事件
@@ -2067,7 +2081,7 @@ Redis.prototype.clearForList = async function(key) {
 			key,
 			error: err
 		});
-		this.logger('error',`清空列表失败 [${key}]:`, err);
+		this.logger('error', `清空列表失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -2082,19 +2096,17 @@ Redis.prototype.clearForList = async function(key) {
  * @param {Array<String>} keys 键数组
  * @return {Promise<Array>} 返回值数组，顺序与键数组一致
  */
-Redis.prototype.mget = async function(keys) {
+Redis.prototype.mget = async function (keys) {
 	try {
 		// 参数验证
 		if (!keys || !Array.isArray(keys)) {
-			throw new Error('mget: keys必须是非空数组');
-			return [];
+			throw new TypeError('keys必须是非空数组');
 		}
 
 		// 验证数组中的每个元素是否为非空字符串
 		for (const key of keys) {
 			if (!key || typeof key !== 'string') {
-				throw new Error('mget: keys数组中的每个元素必须是非空字符串');
-				return [];
+				throw new TypeError('keys数组中的每个元素必须是非空字符串');
 			}
 		}
 
@@ -2107,7 +2119,7 @@ Redis.prototype.mget = async function(keys) {
 
 		// 如果事件处理器标记为取消，则返回空数组
 		if (ctx.cancel) {
-			this.logger('debug',`mget操作被事件处理器取消 [${keys}]`);
+			this.logger('debug', `mget操作被事件处理器取消 [${keys}]`);
 			return [];
 		}
 
@@ -2117,13 +2129,13 @@ Redis.prototype.mget = async function(keys) {
 		const connection = await this._getConnection();
 		try {
 			// 直接使用Redis v4的mGet方法，应用键前缀
-			const keysWithPrefix = finalKeys.map(k => this.applyPrefix(k));
+			const keysWithPrefix = finalKeys.map(k => this._addPrefix(k));
 			const values = await connection.mGet(keysWithPrefix);
 
 			// 处理值的格式，保持数组返回格式
 			const result = [];
 			values.forEach((value, index) => {
-				if (typeof(value) === "string") {
+				if (typeof (value) === "string") {
 					try {
 						if (value.startsWith("{") && value.endsWith("}") ||
 							value.startsWith("[") && value.endsWith("]")) {
@@ -2153,7 +2165,7 @@ Redis.prototype.mget = async function(keys) {
 			keys,
 			error: err
 		});
-		this.logger('error',`批量获取缓存失败 [${keys}]:`, err);
+		this.logger('error', `批量获取缓存失败 [${keys}]:`, err);
 		return [];
 	}
 }
@@ -2164,7 +2176,7 @@ Redis.prototype.mget = async function(keys) {
  * @param {Number} seconds 过期时间(秒)
  * @return {Promise<boolean>} 返回true
  */
-Redis.prototype.mset = async function(obj, seconds = 0) {
+Redis.prototype.mset = async function (obj, seconds = 0) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -2176,7 +2188,7 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug',`mset操作被事件处理器取消`);
+			this.logger('debug', `mset操作被事件处理器取消`);
 			return false;
 		}
 
@@ -2188,8 +2200,7 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 
 		// 检查最终数据是否有效
 		if (!finalData || typeof finalData !== 'object' || finalData === null || Array.isArray(finalData)) {
-			throw new Error('mset: 参数必须是非空对象');
-			return false;
+			throw new TypeError('参数必须是非空对象');
 		}
 
 		// 使用Pipeline优化批量操作
@@ -2223,20 +2234,19 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 		});
 
 		// 如果Pipeline失败，回退到原实现
-		throw new Error('使用Pipeline批量设置失败，使用回退方案:', err);
+		this.logger('warn', '使用Pipeline批量设置失败，使用回退方案:', err);
 		const connection = await this._getConnection();
 		try {
 			const pairs = [];
 			for (const [key, value] of Object.entries(obj)) {
-				const fullKey = this.applyPrefix(key);
-				const val = typeof(value) === "object" ? JSON.stringify(value) : value;
+				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 Error('mset: 键值对数量必须相等');
-				return false;
+				throw new TypeError('键值对数量必须相等');
 			}
 
 			await connection.mSet(pairs);
@@ -2244,7 +2254,7 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 			// 如果设置了过期时间，为所有键设置过期
 			if (seconds > 0) {
 				for (const key of Object.keys(obj)) {
-					await connection.expire(this.applyPrefix(key), seconds);
+					await connection.expire(this._addPrefix(key), seconds);
 				}
 			}
 
@@ -2262,7 +2272,7 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 				seconds,
 				error: fallbackErr
 			});
-			this.logger('error','回退方案批量设置也失败:', fallbackErr);
+			this.logger('error', '回退方案批量设置也失败:', fallbackErr);
 			return false;
 		} finally {
 			this._recycleConnection(connection);
@@ -2271,7 +2281,7 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 };
 
 // 添加连接回收方法，作为_releaseConnection的别名
-Redis.prototype._recycleConnection = function(connection) {
+Redis.prototype._recycleConnection = function (connection) {
 	return this._releaseConnection(connection);
 };
 
@@ -2281,7 +2291,7 @@ Redis.prototype._recycleConnection = function(connection) {
  * @param {String|Array<String>} fields 字段名或字段名数组
  * @return {Promise<Boolean>} 操作结果
  */
-Redis.prototype.hdel = async function(key, fields) {
+Redis.prototype.hdel = async function (key, fields) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -2293,7 +2303,7 @@ Redis.prototype.hdel = async function(key, fields) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug',`hdel操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `hdel操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2306,7 +2316,7 @@ Redis.prototype.hdel = async function(key, fields) {
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			finalKey = this._addPrefix(finalKey);
 			if (!Array.isArray(finalFields)) {
 				finalFields = [finalFields];
 			}
@@ -2317,7 +2327,7 @@ Redis.prototype.hdel = async function(key, fields) {
 			} else if (typeof connection.execute === 'function') {
 				await connection.execute('HDEL', [finalKey, ...finalFields]);
 			} else {
-				this.logger('error','连接对象不支持hDel操作');
+				this.logger('error', '连接对象不支持hDel操作');
 				success = false;
 			}
 
@@ -2338,7 +2348,7 @@ Redis.prototype.hdel = async function(key, fields) {
 			value: fields,
 			error: err
 		});
-		this.logger('error',`删除哈希字段失败 [${key}]:`, err);
+		this.logger('error', `删除哈希字段失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -2348,17 +2358,17 @@ Redis.prototype.hdel = async function(key, fields) {
  * @param {String} key 键
  * @return {Promise<Number>} 字段数量
  */
-Redis.prototype.hlen = async function(key) {
+Redis.prototype.hlen = async function (key) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 			return await connection.hLen(key);
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取哈希字段数量失败 [${key}]:`, err);
+		this.logger('error', `获取哈希字段数量失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -2442,10 +2452,10 @@ class RedisPipeline {
 				if (name !== 'multi' && name !== 'exec' && args.length > 0) {
 					processedArgs = [...args];
 					// 大多数Redis命令第一个参数是key
-					processedArgs[0] = this.redis.applyPrefix(args[0]);
+					processedArgs[0] = this.redis._addPrefix(args[0]);
 
 					// 对于set命令，处理value的JSON序列化
-					if (name === 'set' && args.length >= 2 && typeof(args[1]) === 'object') {
+					if (name === 'set' && args.length >= 2 && typeof (args[1]) === 'object') {
 						processedArgs[1] = JSON.stringify(args[1]);
 					}
 				}
@@ -2472,12 +2482,12 @@ class RedisPipeline {
 			// 处理结果（解析JSON等）
 			return results.map(([err, value], index) => {
 				if (err) {
-					this.logger('error',`[Pipeline] Pipeline命令执行失败 [${this.commands[index].name}]:`, err);
+					this.logger('error', `[Pipeline] Pipeline命令执行失败 [${this.commands[index].name}]:`, err);
 					return null;
 				}
 
 				// 尝试解析JSON结果
-				if (typeof(value) === 'string') {
+				if (typeof (value) === 'string') {
 					try {
 						if (value.startsWith('{') && value.endsWith('}') ||
 							value.startsWith('[') && value.endsWith(']')) {
@@ -2498,7 +2508,7 @@ class RedisPipeline {
  * 清空所有过期的数据
  * @return {Promise<Boolean>} 是否成功
  */
-Redis.prototype.clearExpire = async function() {
+Redis.prototype.clearExpire = async function () {
 	try {
 		this.emit('clearExpire:before', {});
 		// Redis没有直接的方法来清空所有过期数据
@@ -2512,14 +2522,14 @@ Redis.prototype.clearExpire = async function() {
 		this.emit('clearExpire:error', {
 			error: err
 		});
-		this.logger('error','清空过期数据失败:', err);
+		this.logger('error', '清空过期数据失败:', err);
 		return false;
 	}
 };
 
 
 // 获取连接的方法
-Redis.prototype._getConnection = function() {
+Redis.prototype._getConnection = function () {
 	return new Promise((resolve, reject) => {
 		try {
 			// 如果有可用连接，直接返回
@@ -2541,21 +2551,21 @@ Redis.prototype._getConnection = function() {
 			} else {
 				// 否则等待连接释放
 				// 这里简化处理，直接创建连接（生产环境应实现等待队列）
-				throw new Error('连接池已满，创建额外连接');
+				this.logger('warn', '连接池已满，创建额外连接');
 				this._createConnection().then(connection => {
 					this.connection_pool.in_use.add(connection);
 					resolve(connection);
 				}).catch(reject);
 			}
 		} catch (error) {
-			this.logger('error','获取连接失败:', error);
+			this.logger('error', '获取连接失败:', error);
 			reject(error);
 		}
 	});
 };
 
 // 释放连接回池
-Redis.prototype._releaseConnection = function(connection) {
+Redis.prototype._releaseConnection = function (connection) {
 	try {
 		if (this.connection_pool.in_use.has(connection)) {
 			this.connection_pool.in_use.delete(connection);
@@ -2571,16 +2581,15 @@ Redis.prototype._releaseConnection = function(connection) {
 					} else if (typeof connection.end === 'function') {
 						connection.end();
 					} else {
-						this.logger('debug','连接对象没有可用的关闭方法');
+						this.logger('debug', '连接对象没有可用的关闭方法');
 					}
-					// this.logger('debug','关闭多余连接:', connection.id);
 				} catch (e) {
-					this.logger('error','关闭多余连接失败:', e);
+					this.logger('error', '关闭多余连接失败:', e);
 				}
 			}
 		}
 	} catch (error) {
-		this.logger('error','释放连接失败:', error);
+		this.logger('error', '释放连接失败:', error);
 	}
 };
 
@@ -2596,7 +2605,7 @@ Redis.prototype._recycleConnection = Redis.prototype._releaseConnection;
  * @param {Object} value 值
  * @return {Promise<Boolean>} 操作结果
  */
-Redis.prototype.hset = async function(key, field, value) {
+Redis.prototype.hset = async function (key, field, value) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -2609,7 +2618,7 @@ Redis.prototype.hset = async function(key, field, value) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug',`hset操作被事件处理器取消 [${key}:${field}]`);
+			this.logger('debug', `hset操作被事件处理器取消 [${key}:${field}]`);
 			return false;
 		}
 
@@ -2622,9 +2631,9 @@ Redis.prototype.hset = async function(key, field, value) {
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			finalKey = this._addPrefix(finalKey);
 			// 确保所有非字符串值都转换为字符串
-			if (typeof(finalValue) !== "string") {
+			if (typeof (finalValue) !== "string") {
 				finalValue = JSON.stringify(finalValue);
 			}
 			// 使用正确的Redis v4 API - hSet方法
@@ -2642,7 +2651,7 @@ Redis.prototype.hset = async function(key, field, value) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`设置哈希字段失败 [${key}:${field}]:`, err);
+		this.logger('error', `设置哈希字段失败 [${key}:${field}]:`, err);
 		// 触发错误事件
 		this.emit('hset:error', {
 			key,
@@ -2660,15 +2669,15 @@ Redis.prototype.hset = async function(key, field, value) {
  * @param {String} field 字段
  * @return {Promise<Object>} 字段值
  */
-Redis.prototype.hget = async function(key, field) {
+Redis.prototype.hget = async function (key, field) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 			// 使用正确的Redis v4 API - hGet方法
 			const value = await connection.hGet(key, field);
 			// 尝试解析JSON
-			if (value && typeof(value) === 'string') {
+			if (value && typeof (value) === 'string') {
 				try {
 					if (value.startsWith('{') && value.endsWith('}') ||
 						value.startsWith('[') && value.endsWith(']')) {
@@ -2684,7 +2693,7 @@ Redis.prototype.hget = async function(key, field) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取哈希字段失败 [${key}:${field}]:`, err);
+		this.logger('error', `获取哈希字段失败 [${key}:${field}]:`, err);
 		return null;
 	}
 };
@@ -2695,7 +2704,7 @@ Redis.prototype.hget = async function(key, field) {
  * @param {Object} obj 字段值对象
  * @return {Promise<Boolean>} 操作结果
  */
-Redis.prototype.hmset = async function(key, obj) {
+Redis.prototype.hmset = async function (key, obj) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -2707,7 +2716,7 @@ Redis.prototype.hmset = async function(key, obj) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug',`hmset操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `hmset操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2719,7 +2728,7 @@ Redis.prototype.hmset = async function(key, obj) {
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			finalKey = this._addPrefix(finalKey);
 
 			// 检查Redis版本，支持不同的方法
 			this.logger('debug',
@@ -2728,14 +2737,14 @@ Redis.prototype.hmset = async function(key, obj) {
 			let success = true;
 
 			// 优化策略：对所有Redis版本都使用逐个字段设置的方式，确保兼容性和正确性
-			this.logger('debug',`对键 ${finalKey} 强制使用逐个字段设置策略`);
+			this.logger('debug', `对键 ${finalKey} 强制使用逐个字段设置策略`);
 
 			// 获取适合的设置字段方法
 			const setFieldMethod = typeof connection.hSet === 'function' ? 'hSet' :
 				typeof connection.hset === 'function' ? 'hset' : null;
 
 			if (!setFieldMethod) {
-				this.logger('error',`连接对象不支持hSet或hset操作`);
+				this.logger('error', `连接对象不支持hSet或hset操作`);
 				return false;
 			}
 
@@ -2747,10 +2756,10 @@ Redis.prototype.hmset = async function(key, obj) {
 						if (typeof value !== 'string') {
 							value = JSON.stringify(value);
 						}
-						this.logger('debug',`单独设置字段: ${setFieldMethod}(${finalKey}, ${field}, ${value})`);
+						this.logger('debug', `单独设置字段: ${setFieldMethod}(${finalKey}, ${field}, ${value})`);
 						await connection[setFieldMethod](finalKey, field, value);
 					} catch (singleError) {
-						this.logger('error',`设置单个字段失败 ${field}: ${singleError.message}`);
+						this.logger('error', `设置单个字段失败 ${field}: ${singleError.message}`);
 						success = false;
 						break;
 					}
@@ -2759,19 +2768,19 @@ Redis.prototype.hmset = async function(key, obj) {
 
 			// 验证所有字段是否都设置成功
 			if (success) {
-				this.logger('debug',`验证所有字段设置情况`);
+				this.logger('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.logger('debug',`验证字段 ${field}: ${value !== null ? '存在' : '不存在'}`);
+							this.logger('debug', `验证字段 ${field}: ${value !== null ? '存在' : '不存在'}`);
 							// 如果字段不存在，更新success状态
 							if (value === null) {
 								success = false;
 							}
 						} catch (getError) {
-							this.logger('error',`验证字段失败 ${field}: ${getError.message}`);
+							this.logger('error', `验证字段失败 ${field}: ${getError.message}`);
 							success = false;
 						}
 					}
@@ -2789,7 +2798,7 @@ Redis.prototype.hmset = async function(key, obj) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`批量设置哈希字段失败 [${key}]:`, err);
+		this.logger('error', `批量设置哈希字段失败 [${key}]:`, err);
 		// 触发错误事件
 		this.emit('hmset:error', {
 			key,
@@ -2805,23 +2814,23 @@ Redis.prototype.hmset = async function(key, obj) {
  * @param {String} key 键
  * @return {Promise<Object>} 所有字段和值
  */
-Redis.prototype.hgetall = async function(key) {
+Redis.prototype.hgetall = async function (key) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 			if (typeof connection.hGetAll === 'function') {
 				const result = await connection.hGetAll(key);
 				return result;
 			} else {
-				this.logger('error','连接对象不支持hGetAll操作');
+				this.logger('error', '连接对象不支持hGetAll操作');
 				return {};
 			}
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取哈希所有字段和值失败 [${key}]:`, err);
+		this.logger('error', `获取哈希所有字段和值失败 [${key}]:`, err);
 		return {};
 	}
 };
@@ -2832,12 +2841,10 @@ Redis.prototype.hgetall = async function(key) {
  * @param {Array} fields 字段名数组
  * @return {Promise<Array>} 与字段名顺序对应的数组值，不存在返回undefined
  */
-Redis.prototype.hmget = async function(key, fields) {
+Redis.prototype.hmget = async function (key, fields) {
 	try {
 		if (!Array.isArray(fields)) {
-			this.logger('error','参数错误: fields必须是数组');
-			// 返回空数组而不是false，保持与注释类型一致
-			return [];
+			throw new TypeError('fields必须是数组');
 		}
 
 		this.emit('hmget:before', {
@@ -2847,7 +2854,7 @@ Redis.prototype.hmget = async function(key, fields) {
 
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 
 			if (typeof connection.hmGet === 'function') {
 				const result = await connection.hmGet(key, fields);
@@ -2873,8 +2880,8 @@ Redis.prototype.hmget = async function(key, fields) {
 				});
 				return finalResult;
 			} else {
-				this.logger('error','连接对象不支持hmGet操作');
-				this.logger('error','错误: Redis客户端不支持hmget操作');
+				this.logger('error', '连接对象不支持hmGet操作');
+				this.logger('error', '错误: Redis客户端不支持hmget操作');
 				// 返回与fields长度相同的undefined数组，保持与注释一致
 				return fields.map(() => undefined);
 			}
@@ -2887,7 +2894,7 @@ Redis.prototype.hmget = async function(key, fields) {
 			fields,
 			error: err
 		});
-		this.logger('error',`哈希表批量获取失败 [${key}]:`, err);
+		this.logger('error', `哈希表批量获取失败 [${key}]:`, err);
 		// 返回与fields长度相同的undefined数组，保持与注释类型一致
 		return fields.map(() => undefined);
 	}
@@ -2898,7 +2905,7 @@ Redis.prototype.hmget = async function(key, fields) {
  * @param {Number} seconds 过期时间（秒）
  * @return {Promise<Boolean>} 操作结果
  */
-Redis.prototype.expire = async function(key, seconds) {
+Redis.prototype.expire = async function (key, seconds) {
 	try {
 		// 触发前置事件
 		const ctx = {
@@ -2909,7 +2916,7 @@ Redis.prototype.expire = async function(key, seconds) {
 		this.emit('expire:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug',`expire操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `expire操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2921,7 +2928,7 @@ Redis.prototype.expire = async function(key, seconds) {
 		const connection = await this._getConnection();
 		try {
 			// 使用正确的Redis客户端Promise API
-			const result = await connection.expire(this.applyPrefix(finalKey), finalSeconds);
+			const result = await connection.expire(this._addPrefix(finalKey), finalSeconds);
 
 			// 触发后置事件
 			this.emit('expire:after', {
@@ -2931,7 +2938,7 @@ Redis.prototype.expire = async function(key, seconds) {
 			});
 			return result === 1;
 		} catch (err) {
-			this.logger('error',`设置过期时间失败 [${finalKey}]:`, err);
+			this.logger('error', `设置过期时间失败 [${finalKey}]:`, err);
 			this.emit('expire:error', {
 				key: finalKey,
 				ttl: finalSeconds,
@@ -2942,7 +2949,7 @@ Redis.prototype.expire = async function(key, seconds) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`设置过期时间失败 [${key}]:`, err);
+		this.logger('error', `设置过期时间失败 [${key}]:`, err);
 		this.emit('expire:error', {
 			key,
 			ttl: seconds,
@@ -2958,16 +2965,14 @@ Redis.prototype.expire = async function(key, seconds) {
  * @param {Number} milliseconds 过期时间（毫秒）
  * @return {Promise<Boolean>} 操作结果
  */
-Redis.prototype.pexpire = async function(key, milliseconds) {
+Redis.prototype.pexpire = async function (key, milliseconds) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			this.logger('error','pexpire参数错误: key must be a non-empty string');
-			return false;
+			throw new TypeError('key必须是非空字符串');
 		}
 		if (!Number.isInteger(milliseconds) || milliseconds <= 0) {
-			this.logger('error','pexpire参数错误: milliseconds must be a positive integer');
-			return false;
+			throw new TypeError('milliseconds必须是正整数');
 		}
 
 		// 触发前置事件
@@ -2979,7 +2984,7 @@ Redis.prototype.pexpire = async function(key, milliseconds) {
 		this.emit('pexpire:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug',`pexpire操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `pexpire操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2993,11 +2998,11 @@ Redis.prototype.pexpire = async function(key, milliseconds) {
 			// 使用正确的Redis客户端Promise API
 			let result;
 			if (typeof connection.pexpire === 'function') {
-				result = await connection.pexpire(this.applyPrefix(finalKey), finalMilliseconds);
+				result = await connection.pexpire(this._addPrefix(finalKey), finalMilliseconds);
 			} else if (typeof connection.execute === 'function') {
-				result = await connection.execute('PEXPIRE', [this.applyPrefix(finalKey), finalMilliseconds]);
+				result = await connection.execute('PEXPIRE', [this._addPrefix(finalKey), finalMilliseconds]);
 			} else {
-				this.logger('error','连接对象不支持pexpire操作');
+				this.logger('error', '连接对象不支持pexpire操作');
 				return false;
 			}
 
@@ -3009,7 +3014,7 @@ Redis.prototype.pexpire = async function(key, milliseconds) {
 			});
 			return result === 1;
 		} catch (err) {
-			this.logger('error',`设置过期时间（毫秒）失败 [${finalKey}]:`, err);
+			this.logger('error', `设置过期时间（毫秒）失败 [${finalKey}]:`, err);
 			this.emit('pexpire:error', {
 				key: finalKey,
 				ttl: finalMilliseconds,
@@ -3020,7 +3025,7 @@ Redis.prototype.pexpire = async function(key, milliseconds) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`设置过期时间（毫秒）失败 [${key}]:`, err);
+		this.logger('error', `设置过期时间（毫秒）失败 [${key}]:`, err);
 		this.emit('pexpire:error', {
 			key,
 			ttl: milliseconds,
@@ -3031,7 +3036,7 @@ Redis.prototype.pexpire = async function(key, milliseconds) {
 };
 
 // 新增persist方法实现
-Redis.prototype.persist = async function(key) {
+Redis.prototype.persist = async function (key) {
 	try {
 		// 触发前置事件
 		const ctx = {
@@ -3041,7 +3046,7 @@ Redis.prototype.persist = async function(key) {
 		this.emit('persist:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug',`persist操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `persist操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -3052,7 +3057,7 @@ Redis.prototype.persist = async function(key) {
 		const connection = await this._getConnection();
 		try {
 			// 使用正确的Redis客户端Promise API
-			const result = await connection.persist(this.applyPrefix(finalKey));
+			const result = await connection.persist(this._addPrefix(finalKey));
 
 			// 触发后置事件
 			this.emit('persist:after', {
@@ -3061,7 +3066,7 @@ Redis.prototype.persist = async function(key) {
 			});
 			return result === 1;
 		} catch (err) {
-			this.logger('error',`移除过期时间失败 [${finalKey}]:`, err);
+			this.logger('error', `移除过期时间失败 [${finalKey}]:`, err);
 			this.emit('persist:error', {
 				key: finalKey,
 				error: err
@@ -3071,7 +3076,7 @@ Redis.prototype.persist = async function(key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`移除过期时间失败 [${key}]:`, err);
+		this.logger('error', `移除过期时间失败 [${key}]:`, err);
 		this.emit('persist:error', {
 			key,
 			error: err
@@ -3086,12 +3091,11 @@ Redis.prototype.persist = async function(key) {
  * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 增加后的值
  */
-Redis.prototype.incr = async function(key, seconds = 0) {
+Redis.prototype.incr = async function (key, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			this.logger('error','参数错误: 键必须是非空字符串');
-			return null;
+			throw new TypeError('键必须是非空字符串');
 		}
 
 		// 触发前置事件
@@ -3103,7 +3107,7 @@ Redis.prototype.incr = async function(key, seconds = 0) {
 		this.emit('incr:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug',`incr操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `incr操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3114,7 +3118,7 @@ Redis.prototype.incr = async function(key, seconds = 0) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
 			const result = await connection.incr(prefixedKey);
 
@@ -3134,7 +3138,7 @@ Redis.prototype.incr = async function(key, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error',`增加整数值失败 [${finalKey}]:`, err);
+			this.logger('error', `增加整数值失败 [${finalKey}]:`, err);
 			this.emit('incr:error', {
 				key: finalKey,
 				seconds: finalSeconds,
@@ -3145,7 +3149,7 @@ Redis.prototype.incr = async function(key, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`增加整数值失败 [${key}]:`, err);
+		this.logger('error', `增加整数值失败 [${key}]:`, err);
 		this.emit('incr:error', {
 			key,
 			seconds,
@@ -3161,12 +3165,11 @@ Redis.prototype.incr = async function(key, seconds = 0) {
  * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 减少后的值
  */
-Redis.prototype.decr = async function(key, seconds = 0) {
+Redis.prototype.decr = async function (key, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			this.logger('error','参数错误: 键必须是非空字符串');
-			return null;
+			throw new TypeError('键必须是非空字符串');
 		}
 
 		// 触发前置事件
@@ -3178,7 +3181,7 @@ Redis.prototype.decr = async function(key, seconds = 0) {
 		this.emit('decr:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug',`decr操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `decr操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3189,7 +3192,7 @@ Redis.prototype.decr = async function(key, seconds = 0) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
 			const result = await connection.decr(prefixedKey);
 
@@ -3209,7 +3212,7 @@ Redis.prototype.decr = async function(key, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error',`减少整数值失败 [${finalKey}]:`, err);
+			this.logger('error', `减少整数值失败 [${finalKey}]:`, err);
 			this.emit('decr:error', {
 				key: finalKey,
 				seconds: finalSeconds,
@@ -3220,7 +3223,7 @@ Redis.prototype.decr = async function(key, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`减少整数值失败 [${key}]:`, err);
+		this.logger('error', `减少整数值失败 [${key}]:`, err);
 		this.emit('decr:error', {
 			key,
 			seconds,
@@ -3237,16 +3240,14 @@ Redis.prototype.decr = async function(key, seconds = 0) {
  * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 增加后的值
  */
-Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
+Redis.prototype.incrbyfloat = async function (key, increment, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			this.logger('error','参数错误: 键必须是非空字符串');
-			return null;
+			throw new TypeError('键必须是非空字符串');
 		}
 		if (typeof increment !== 'number' || isNaN(increment)) {
-			this.logger('error','参数错误: 增量必须是有效数字');
-			return null;
+			throw new TypeError('增量必须是有效数字');
 		}
 
 		// 触发前置事件
@@ -3259,7 +3260,7 @@ Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
 		this.emit('incrbyfloat:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug',`incrbyfloat操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `incrbyfloat操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3271,7 +3272,7 @@ Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
 			const result = await connection.incrByFloat(prefixedKey, finalIncrement);
 			const parsedResult = parseFloat(result);
@@ -3293,7 +3294,7 @@ Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
 			});
 			return parsedResult;
 		} catch (err) {
-			this.logger('error',`增加浮点数值失败 [${finalKey}]:`, err);
+			this.logger('error', `增加浮点数值失败 [${finalKey}]:`, err);
 			this.emit('incrbyfloat:error', {
 				key: finalKey,
 				increment: finalIncrement,
@@ -3305,7 +3306,7 @@ Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`增加浮点数值失败 [${key}]:`, err);
+		this.logger('error', `增加浮点数值失败 [${key}]:`, err);
 		this.emit('incrbyfloat:error', {
 			key,
 			increment,
@@ -3323,16 +3324,14 @@ Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
  * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 增加后的值
  */
-Redis.prototype.incrby = async function(key, increment, seconds = 0) {
+Redis.prototype.incrby = async function (key, increment, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			this.logger('error','参数错误: 键必须是非空字符串');
-			return null;
+			throw new TypeError('键必须是非空字符串');
 		}
 		if (typeof increment !== 'number' || isNaN(increment) || !Number.isInteger(increment)) {
-			this.logger('error','参数错误: 增量必须是有效整数');
-			return null;
+			throw new TypeError('增量必须是有效整数');
 		}
 
 		// 触发前置事件
@@ -3345,7 +3344,7 @@ Redis.prototype.incrby = async function(key, increment, seconds = 0) {
 		this.emit('incrby:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug',`incrby操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `incrby操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3357,7 +3356,7 @@ Redis.prototype.incrby = async function(key, increment, seconds = 0) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
 			const result = await connection.incrBy(prefixedKey, finalIncrement);
 
@@ -3378,7 +3377,7 @@ Redis.prototype.incrby = async function(key, increment, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error',`增加指定值失败 [${finalKey}]:`, err);
+			this.logger('error', `增加指定值失败 [${finalKey}]:`, err);
 			this.emit('incrby:error', {
 				key: finalKey,
 				increment: finalIncrement,
@@ -3390,7 +3389,7 @@ Redis.prototype.incrby = async function(key, increment, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`增加指定值失败 [${key}]:`, err);
+		this.logger('error', `增加指定值失败 [${key}]:`, err);
 		this.emit('incrby:error', {
 			key,
 			increment,
@@ -3408,16 +3407,14 @@ Redis.prototype.incrby = async function(key, increment, seconds = 0) {
  * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 减少后的值
  */
-Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
+Redis.prototype.decrby = async function (key, decrement, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			this.logger('error','参数错误: 键必须是非空字符串');
-			return null;
+			throw new TypeError('键必须是非空字符串');
 		}
 		if (typeof decrement !== 'number' || isNaN(decrement) || !Number.isInteger(decrement)) {
-			this.logger('error','参数错误: 减量必须是有效整数');
-			return null;
+			throw new TypeError('减量必须是有效整数');
 		}
 
 		// 触发前置事件
@@ -3430,7 +3427,7 @@ Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
 		this.emit('decrby:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug',`decrby操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `decrby操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3442,7 +3439,7 @@ Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
 			const result = await connection.decrBy(prefixedKey, finalDecrement);
 
@@ -3463,7 +3460,7 @@ Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error',`减少指定值失败 [${finalKey}]:`, err);
+			this.logger('error', `减少指定值失败 [${finalKey}]:`, err);
 			this.emit('decrby:error', {
 				key: finalKey,
 				decrement: finalDecrement,
@@ -3475,7 +3472,7 @@ Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`减少指定值失败 [${key}]:`, err);
+		this.logger('error', `减少指定值失败 [${key}]:`, err);
 		this.emit('decrby:error', {
 			key,
 			decrement,
@@ -3494,7 +3491,7 @@ Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
  * @param {String|Array} members 成员或成员数组
  * @return {Promise<Number>} 添加的成员数量
  */
-Redis.prototype.sadd = async function(key, members) {
+Redis.prototype.sadd = async function (key, members) {
 	try {
 		// 触发前置事件
 		const ctx = {
@@ -3505,7 +3502,7 @@ Redis.prototype.sadd = async function(key, members) {
 		this.emit('sadd:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug',`sadd操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `sadd操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -3516,7 +3513,7 @@ Redis.prototype.sadd = async function(key, members) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			const result = await connection.sAdd(prefixedKey, finalMembers);
 
 			// 触发后置事件
@@ -3530,7 +3527,7 @@ Redis.prototype.sadd = async function(key, members) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`添加集合成员失败 [${key}]:`, err);
+		this.logger('error', `添加集合成员失败 [${key}]:`, err);
 		this.emit('sadd:error', {
 			key,
 			members,
@@ -3546,7 +3543,7 @@ Redis.prototype.sadd = async function(key, members) {
  * @param {String|Array} members 成员或成员数组
  * @return {Promise<Number>} 移除的成员数量
  */
-Redis.prototype.srem = async function(key, members) {
+Redis.prototype.srem = async function (key, members) {
 	try {
 		// 触发前置事件
 		const ctx = {
@@ -3557,7 +3554,7 @@ Redis.prototype.srem = async function(key, members) {
 		this.emit('srem:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug',`srem操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `srem操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -3568,7 +3565,7 @@ Redis.prototype.srem = async function(key, members) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			const result = await connection.sRem(prefixedKey, finalMembers);
 
 			// 触发后置事件
@@ -3582,7 +3579,7 @@ Redis.prototype.srem = async function(key, members) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`移除集合成员失败 [${key}]:`, err);
+		this.logger('error', `移除集合成员失败 [${key}]:`, err);
 		this.emit('srem:error', {
 			key,
 			members,
@@ -3598,16 +3595,14 @@ Redis.prototype.srem = async function(key, members) {
  * @param {String} member 成员
  * @return {Promise<Boolean>} 是否存在
  */
-Redis.prototype.sismember = async function(key, member) {
+Redis.prototype.sismember = async function (key, member) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			this.logger('error','sismember参数错误: key must be a non-empty string');
-			return false;
+			throw new TypeError('key必须是非空字符串');
 		}
 		if (member === undefined || member === null) {
-			this.logger('error','sismember参数错误: member cannot be undefined or null');
-			return false;
+			throw new TypeError('member不能为undefined或null');
 		}
 
 		this.emit('sismember:before', {
@@ -3616,7 +3611,7 @@ Redis.prototype.sismember = async function(key, member) {
 		});
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(key);
+			const prefixedKey = this._addPrefix(key);
 			// 将成员转换为字符串，与其他模块行为一致
 			const memberStr = String(member);
 			const result = await connection.sIsMember(prefixedKey, memberStr);
@@ -3635,7 +3630,7 @@ Redis.prototype.sismember = async function(key, member) {
 			member,
 			error: err
 		});
-		this.logger('error',`检查集合成员失败 [${key}:${member}]:`, err);
+		this.logger('error', `检查集合成员失败 [${key}:${member}]:`, err);
 		return false;
 	}
 };
@@ -3645,11 +3640,11 @@ Redis.prototype.sismember = async function(key, member) {
  * @param {String} key 键
  * @return {Promise<Array>} 成员数组
  */
-Redis.prototype.smembers = async function(key) {
+Redis.prototype.smembers = async function (key) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(key);
+			const prefixedKey = this._addPrefix(key);
 			const result = await connection.sMembers(prefixedKey);
 			this.emit('smembers:after', {
 				key,
@@ -3660,7 +3655,7 @@ Redis.prototype.smembers = async function(key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取集合所有成员失败 [${key}]:`, err);
+		this.logger('error', `获取集合所有成员失败 [${key}]:`, err);
 		this.emit('smembers:error', {
 			key,
 			error: err
@@ -3674,18 +3669,18 @@ Redis.prototype.smembers = async function(key) {
  * @param {String} key 键
  * @return {Promise<Number>} 成员数量
  */
-Redis.prototype.scard = async function(key) {
+Redis.prototype.scard = async function (key) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(key);
+			const prefixedKey = this._addPrefix(key);
 			const result = await connection.sCard(prefixedKey);
 			return result;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取集合大小失败 [${key}]:`, err);
+		this.logger('error', `获取集合大小失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -3695,11 +3690,11 @@ Redis.prototype.scard = async function(key) {
  * @param {Array} keys 键数组
  * @return {Promise<Array>} 交集成员数组
  */
-Redis.prototype.sinter = async function(keys) {
+Redis.prototype.sinter = async function (keys) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKeys = keys.map(key => this.applyPrefix(key));
+			const prefixedKeys = keys.map(key => this._addPrefix(key));
 			// 使用Redis v4正确的方法
 			const result = await connection.sInter(...prefixedKeys);
 			return result || [];
@@ -3707,7 +3702,7 @@ Redis.prototype.sinter = async function(keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取集合交集失败:`, err);
+		this.logger('error', `获取集合交集失败:`, err);
 		return [];
 	}
 };
@@ -3717,11 +3712,11 @@ Redis.prototype.sinter = async function(keys) {
  * @param {Array} keys 键数组
  * @return {Promise<Array>} 并集成员数组
  */
-Redis.prototype.sunion = async function(keys) {
+Redis.prototype.sunion = async function (keys) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKeys = keys.map(key => this.applyPrefix(key));
+			const prefixedKeys = keys.map(key => this._addPrefix(key));
 			// 使用Redis v4正确的方法
 			const result = await connection.sUnion(...prefixedKeys);
 			return result || [];
@@ -3729,7 +3724,7 @@ Redis.prototype.sunion = async function(keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取集合并集失败:`, err);
+		this.logger('error', `获取集合并集失败:`, err);
 		return [];
 	}
 };
@@ -3739,11 +3734,11 @@ Redis.prototype.sunion = async function(keys) {
  * @param {Array} keys 键数组
  * @return {Promise<Array>} 差集成员数组
  */
-Redis.prototype.sdiff = async function(keys) {
+Redis.prototype.sdiff = async function (keys) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKeys = keys.map(key => this.applyPrefix(key));
+			const prefixedKeys = keys.map(key => this._addPrefix(key));
 			// 使用Redis v4正确的方法
 			const result = await connection.sDiff(...prefixedKeys);
 			return result || [];
@@ -3751,7 +3746,7 @@ Redis.prototype.sdiff = async function(keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取集合差集失败:`, err);
+		this.logger('error', `获取集合差集失败:`, err);
 		return [];
 	}
 };
@@ -3765,7 +3760,7 @@ Redis.prototype.sdiff = async function(keys) {
  * @param {String} member 成员
  * @return {Promise<Boolean>} 是否成功
  */
-Redis.prototype.zadd = async function(key, score, member) {
+Redis.prototype.zadd = async function (key, score, member) {
 	try {
 		// 触发前置事件
 		const ctx = {
@@ -3777,7 +3772,7 @@ Redis.prototype.zadd = async function(key, score, member) {
 		this.emit('zadd:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug',`zadd操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `zadd操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -3789,7 +3784,7 @@ Redis.prototype.zadd = async function(key, score, member) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			const result = await connection.zAdd(prefixedKey, {
 				score: finalScore,
 				value: finalMember
@@ -3807,7 +3802,7 @@ Redis.prototype.zadd = async function(key, score, member) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`添加有序集合成员失败 [${key}]:`, err);
+		this.logger('error', `添加有序集合成员失败 [${key}]:`, err);
 		this.emit('zadd:error', {
 			key,
 			score,
@@ -3824,7 +3819,7 @@ Redis.prototype.zadd = async function(key, score, member) {
  * @param {String|Array} members 成员或成员数组
  * @return {Promise<Number>} 移除的成员数量
  */
-Redis.prototype.zrem = async function(key, members) {
+Redis.prototype.zrem = async function (key, members) {
 	try {
 		// 触发前置事件
 		const ctx = {
@@ -3835,7 +3830,7 @@ Redis.prototype.zrem = async function(key, members) {
 		this.emit('zrem:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug',`zrem操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `zrem操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -3847,7 +3842,7 @@ Redis.prototype.zrem = async function(key, members) {
 		const connection = await this._getConnection();
 		try {
 			// 使用正确的Redis客户端Promise API
-			const result = await connection.zRem(this.applyPrefix(finalKey), ...finalMembers);
+			const result = await connection.zRem(this._addPrefix(finalKey), ...finalMembers);
 
 			// 触发后置事件
 			this.emit('zrem:after', {
@@ -3857,7 +3852,7 @@ Redis.prototype.zrem = async function(key, members) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error',`移除有序集合成员失败 [${finalKey}]:`, err);
+			this.logger('error', `移除有序集合成员失败 [${finalKey}]:`, err);
 			this.emit('zrem:error', {
 				key: finalKey,
 				members: finalMembers,
@@ -3868,7 +3863,7 @@ Redis.prototype.zrem = async function(key, members) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`移除有序集合成员失败 [${key}]:`, err);
+		this.logger('error', `移除有序集合成员失败 [${key}]:`, err);
 		this.emit('zrem:error', {
 			key,
 			members,
@@ -3884,18 +3879,18 @@ Redis.prototype.zrem = async function(key, members) {
  * @param {String} member 成员
  * @return {Promise<Number|null>} 分数
  */
-Redis.prototype.zscore = async function(key, member) {
+Redis.prototype.zscore = async function (key, member) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(key);
+			const prefixedKey = this._addPrefix(key);
 			const result = await connection.zScore(prefixedKey, member);
 			return result ? parseFloat(result) : null;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取有序集合成员分数失败 [${key}:${member}]:`, err);
+		this.logger('error', `获取有序集合成员分数失败 [${key}:${member}]:`, err);
 		return null;
 	}
 };
@@ -3906,18 +3901,18 @@ Redis.prototype.zscore = async function(key, member) {
  * @param {String} member 成员
  * @return {Promise<Number|null>} 排名
  */
-Redis.prototype.zrank = async function(key, member) {
+Redis.prototype.zrank = async function (key, member) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(key);
+			const prefixedKey = this._addPrefix(key);
 			const result = await connection.zRank(prefixedKey, member);
 			return result;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取有序集合成员排名失败 [${key}:${member}]:`, err);
+		this.logger('error', `获取有序集合成员排名失败 [${key}:${member}]:`, err);
 		return null;
 	}
 };
@@ -3930,11 +3925,11 @@ Redis.prototype.zrank = async function(key, member) {
  * @param {Boolean} withScores 是否返回分数
  * @return {Promise<Array>} 成员数组
  */
-Redis.prototype.zrange = async function(key, start, stop, withScores = false) {
+Redis.prototype.zrange = async function (key, start, stop, withScores = false) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(key);
+			const prefixedKey = this._addPrefix(key);
 
 			if (withScores) {
 				// 对于需要分数的情况，使用更可靠的方法
@@ -3958,13 +3953,13 @@ Redis.prototype.zrange = async function(key, start, stop, withScores = false) {
 								member,
 								score: 0
 							});
-							throw new Error(`获取成员 ${member} 分数失败:`, scoreErr);
+							this.logger('error', `获取成员 ${member} 分数失败:`, scoreErr);
 						}
 					}
 
 					return results;
 				} catch (err) {
-					this.logger('error',`使用备用方法获取有序集合范围失败 [${prefixedKey}]:`, err);
+					this.logger('error', `使用备用方法获取有序集合范围失败 [${prefixedKey}]:`, err);
 					// 回退到简单列表
 					return [];
 				}
@@ -3977,7 +3972,7 @@ Redis.prototype.zrange = async function(key, start, stop, withScores = false) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取有序集合范围成员失败 [${key}]:`, err);
+		this.logger('error', `获取有序集合范围成员失败 [${key}]:`, err);
 		return [];
 	}
 };
@@ -3987,21 +3982,21 @@ Redis.prototype.zrange = async function(key, start, stop, withScores = false) {
  * @param {String} key 键
  * @return {Promise<Number>} 成员数量
  */
-Redis.prototype.zcard = async function(key) {
+Redis.prototype.zcard = async function (key) {
 	try {
 		const connection = await this._getConnection();
 		try {
 			// 使用正确的Redis客户端Promise API
-			const result = await connection.zCard(this.applyPrefix(key));
+			const result = await connection.zCard(this._addPrefix(key));
 			return result || 0;
 		} catch (err) {
-			this.logger('error',`获取有序集合成员数量失败 [${key}]:`, err);
+			this.logger('error', `获取有序集合成员数量失败 [${key}]:`, err);
 			return 0;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取有序集合成员数量失败 [${key}]:`, err);
+		this.logger('error', `获取有序集合成员数量失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -4014,20 +4009,17 @@ Redis.prototype.zcard = async function(key) {
  * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 增加后的分数
  */
-Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
+Redis.prototype.zincrby = async function (key, increment, member, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			this.logger('error','参数错误: 键必须是非空字符串');
-			return null;
+			throw new TypeError('键必须是非空字符串');
 		}
 		if (typeof increment !== 'number' || isNaN(increment)) {
-			this.logger('error','参数错误: 增量必须是有效数字');
-			return null;
+			throw new TypeError('增量必须是有效数字');
 		}
 		if (!member || typeof member !== 'string') {
-			this.logger('error','参数错误: 成员必须是非空字符串');
-			return null;
+			throw new TypeError('成员必须是非空字符串');
 		}
 
 		// 触发前置事件
@@ -4041,7 +4033,7 @@ Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
 		this.emit('zincrby:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug',`zincrby操作被事件处理器取消 [${key}]`);
+			this.logger('debug', `zincrby操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -4054,7 +4046,7 @@ Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
 			const result = await connection.zIncrBy(prefixedKey, finalIncrement, finalMember);
 
@@ -4077,7 +4069,7 @@ Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
 			});
 			return parseFloat(result);
 		} catch (err) {
-			this.logger('error',`增加有序集合成员分数失败 [${finalKey}]:`, err);
+			this.logger('error', `增加有序集合成员分数失败 [${finalKey}]:`, err);
 			this.emit('zincrby:error', {
 				key: finalKey,
 				increment: finalIncrement,
@@ -4090,7 +4082,7 @@ Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`增加有序集合成员分数失败 [${key}]:`, err);
+		this.logger('error', `增加有序集合成员分数失败 [${key}]:`, err);
 		this.emit('zincrby:error', {
 			key,
 			increment,
@@ -4103,7 +4095,7 @@ Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
 };
 
 // 创建真实Redis连接的方法
-Redis.prototype._createConnection = function() {
+Redis.prototype._createConnection = function () {
 	return new Promise((resolve, reject) => {
 		try {
 			const cg = this.config;
@@ -4124,7 +4116,7 @@ Redis.prototype._createConnection = function() {
 
 			// 监听错误事件
 			connection.on('error', (err) => {
-				this.logger('error',`连接 ${connection.id} 错误:`, err);
+				this.logger('error', `连接 ${connection.id} 错误:`, err);
 			});
 
 			// 连接Redis
@@ -4132,11 +4124,11 @@ Redis.prototype._createConnection = function() {
 				// this.logger('debug','新连接已创建并连接:', connection.id);
 				resolve(connection);
 			}).catch(err => {
-				this.logger('error','创建连接失败:', err);
+				this.logger('error', '创建连接失败:', err);
 				reject(err);
 			});
 		} catch (error) {
-			this.logger('error','创建连接时发生异常:', error);
+			this.logger('error', '创建连接时发生异常:', error);
 			reject(error);
 		}
 	});