npm - mm_redis - Versions diffs - 2.0.7 → 2.0.9 - Mend

mm_redis 2.0.7 → 2.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/index.js CHANGED Viewed

@@ -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 配置参数
@@ -39,12 +34,10 @@ class Redis extends Event {
 			// 重试间隔(ms)
 			"retry_delay": 1000,
 			// 连接池配置
-			"pool": {
-				"max_clients": 100, // 最大连接数
-				"min_idle": 5, // 最小空闲连接数
-				"max_idle": 20, // 最大空闲连接数
-				"idle_timeout": 30000 // 空闲超时时间(ms)
-			}
+			"max_clients": 100, // 最大连接数
+			"min_idle": 5, // 最小空闲连接数
+			"max_idle": 20, // 最大空闲连接数
+			"idle_timeout": 30000 // 空闲超时时间(ms)
 		};
 		this.setConfig(config);
 		// 初始化连接池
@@ -66,8 +59,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 +69,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 +84,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) {
+	// 参数验证
+	if (!channel || typeof channel !== 'string') {
+		throw new TypeError('channel必须是非空字符串');
+	}
+	if (typeof func !== 'function') {
+		throw new TypeError('func必须是函数');
+	}
 	try {
-		await this.conn.subscribe(this.applyPrefix(channel));
+		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 +108,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) {
+	// 参数验证
+	if (!channel || typeof channel !== 'string') {
+		throw new TypeError('channel必须是非空字符串');
+	}
 	try {
-		await this.conn.unsubscribe(this.applyPrefix(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 +130,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) {
+	// 参数验证
+	if (!channel || typeof channel !== 'string') {
+		throw new TypeError('channel必须是非空字符串');
+	}
+	if (message === undefined || message === null) {
+		throw new TypeError('message不能为undefined或null');
+	}
 	try {
-		return await this.conn.publish(this.applyPrefix(channel), message);
+		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 +152,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 +162,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,55 +181,17 @@ 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);
 	} else if (config) {
 		// 合并配置参数
-		if (config.pool) {
-			// 确保连接池配置的合并不会覆盖所有默认值
-			if (!this.config.pool) {
-				this.config.pool = {};
-			}
-			Object.assign(this.config.pool, config.pool);
-			// 删除config中的pool属性，避免后续Object.assign重复处理
-			const configCopy = {
-				...config
-			};
-			delete configCopy.pool;
-			Object.assign(this.config, configCopy);
-		} else {
-			Object.assign(this.config, config);
-		}
+		Object.assign(this.config, config);
 	} else {
 		return;
 	}
-	// 确保连接池配置存在且包含所有必要字段
-	if (!this.config.pool) {
-		this.config.pool = {};
-	}
-	// 设置默认连接池配置，只覆盖未定义的字段
-	const defaultPoolConfig = {
-		max_clients: 100,
-		min_idle: 5,
-		max_idle: 20,
-		idle_timeout: 30000
-	};
-	for (const key in defaultPoolConfig) {
-		if (this.config.pool[key] === undefined) {
-			this.config.pool[key] = defaultPoolConfig[key];
-		}
-	}
-	// 如果连接池已经初始化，更新其配置
-	if (this.connection_pool) {
-		this.connection_pool.config = this.config.pool;
-	}
 	// 初始化连接池
 	this._initPool();
 	// this.logger('debug','配置已更新');
@@ -222,33 +200,25 @@ Redis.prototype.setConfig = function(config) {
 };
 // 添加连接池初始化方法
-Redis.prototype._initPool = function() {
+Redis.prototype._initPool = function () {
 	// 确保连接池配置存在
-	if (!this.config.pool) {
-		this.config.pool = {
-			max_clients: 100,
-			min_idle: 5,
-			max_idle: 20,
-			idle_timeout: 30000
-		};
-	}
 	// 初始化连接池相关属性
 	this.connection_pool = {
 		available: [],
 		in_use: new Set(),
-		config: this.config.pool // 直接引用配置对象，确保同步更新
+		config: this.config // 直接引用配置对象，确保同步更新
 	};
 	// 记录连接池初始化
-	// this.logger('debug','连接池已初始化，配置:', this.config.pool);
+	// this.logger('debug','连接池已初始化，配置:', this.config);
 };
 /**
  * @description 连接Redis数据库
  * @return {Promise<Boolean>} 连接结果
  */
-Redis.prototype.open = async function() {
+Redis.prototype.open = async function () {
 	if (this.conn && this.connected) {
 		return true;
 	}
@@ -270,7 +240,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 +261,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 +279,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 +290,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 +313,7 @@ Redis.prototype._reconnect = function() {
  * @return {Promise<Boolean>} 关闭结果
  */
 // 修复close方法，正确处理连接池
-Redis.prototype.close = function() {
+Redis.prototype.close = function () {
 	try {
 		// this.logger('debug','关闭所有连接...');
@@ -353,7 +323,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 +340,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 +418,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 +432,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 +449,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 +480,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 +489,7 @@ Redis.prototype.pipeline = function() {
 				redisInstance._recycleConnection(connection);
 				return results;
 			} catch (error) {
-				this.logger('error','Pipeline执行失败:', error);
+				this.logger('error', 'Pipeline执行失败:', error);
 				return [];
 			}
 		}
@@ -530,27 +500,27 @@ Redis.prototype.pipeline = function() {
  * @description 检查连接状态
  * @return {Boolean} 连接状态
  */
-Redis.prototype.isConnected = function() {
+Redis.prototype.isConnected = function () {
 	return this.connected && this.conn && this.conn.isReady;
 };
-/**
- * @description 查询或是设置缓存过期时间
- * @param {String} key 键
- * @param {Number} seconds 秒, 为空则查询有效时长
- * @return {Promise<Number|Boolean>} 查询时长或设置结果, 时长为-1表示永不过期
- */
 /**
  * 获取或设置键的过期时间
  * @param {String} key 键名
  * @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) {
+	// 参数验证
+	if (!key || typeof key !== 'string') {
+		throw new TypeError('key必须是非空字符串');
+	}
 	try {
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 			// 如果传入了seconds参数，则设置过期时间
 			if (seconds !== undefined) {
@@ -566,7 +536,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 +547,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,17 +566,16 @@ 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) {
+	// 参数验证
+	if (!key || typeof key !== 'string') {
+		throw new TypeError('key必须是非空字符串');
+	}
+	if (typeof num !== 'number' || isNaN(num) || !Number.isInteger(num)) {
+		throw new TypeError('num必须是有效整数');
+	}
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			this.logger('error','参数错误: 键必须是非空字符串');
-			return false;
-		}
-		if (typeof num !== 'number' || isNaN(num) || !Number.isInteger(num)) {
-			this.logger('error','参数错误: 数值必须是有效整数');
-			return false;
-		}
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -619,7 +588,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 +601,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 +611,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 +629,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 +670,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,20 +683,19 @@ 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) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new Error(`addFloat: key参数必须是非空字符串`);
-			return 0;
-		}
+Redis.prototype.addFloat = async function (key, num, seconds = 0) {
+	// 参数验证
+	if (!key || typeof key !== 'string') {
+		throw new TypeError('key必须是非空字符串');
+	}
-		// 验证num参数
-		num = parseFloat(num);
-		if (isNaN(num)) {
-			throw new Error(`addFloat: num参数必须是有效的数值`);
-			return 0;
-		}
+	// 验证num参数
+	num = parseFloat(num);
+	if (isNaN(num)) {
+		throw new TypeError('num必须是有效的数值');
+	}
+	try {
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -740,7 +708,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 +722,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 +734,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 +765,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 +794,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 +807,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 +831,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 +845,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 +857,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 +883,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 +909,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 +919,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 +952,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 +969,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 +985,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 +1005,7 @@ Redis.prototype.del = async function(key) {
 			key,
 			error: err
 		});
-		this.logger('error',`删除缓存失败 [${key}]:`, err);
+		this.logger('error', `删除缓存失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1062,12 +1024,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 +1042,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 +1055,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 +1080,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 +1099,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 +1120,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 +1133,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 +1160,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 +1182,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 +1198,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 +1207,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 +1239,7 @@ Redis.prototype.get = async function(key) {
 			key,
 			error: err
 		});
-		this.logger('error',`获取缓存失败 [${key}]:`, err);
+		this.logger('error', `获取缓存失败 [${key}]:`, err);
 		return null;
 	}
 };
@@ -1281,12 +1249,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 +1265,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 +1274,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 +1295,7 @@ Redis.prototype.has = async function(key) {
 			key,
 			error: err
 		});
-		this.logger('error',`检查键是否存在失败 [${key}]:`, err);
+		this.logger('error', `检查键是否存在失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1338,32 +1305,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 +1338,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 +1349,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 +1373,7 @@ Redis.prototype.exists = async function(key) {
 			key,
 			error: err
 		});
-		this.logger('error',`检查键存在性失败 [${key}]:`, err);
+		this.logger('error', `检查键存在性失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1422,14 +1385,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 +1403,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 +1415,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 +1426,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 +1439,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 +1453,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 +1465,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 +1486,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 +1516,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 +1526,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 +1537,7 @@ Redis.prototype.clear = async function(key) {
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug',`clear操作被事件处理器取消`);
+			this.logger('debug', `clear操作被事件处理器取消`);
 			return false;
 		}
@@ -1598,7 +1561,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 +1581,7 @@ Redis.prototype.clear = async function(key) {
 			key,
 			error: err
 		});
-		this.logger('error','清空缓存失败:', err);
+		this.logger('error', '清空缓存失败:', err);
 		return false;
 	}
 };
@@ -1629,11 +1592,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 +1625,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 +1639,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 +1649,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 +1657,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 +1674,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 +1687,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 +1701,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 +1717,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 +1728,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 +1739,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 +1762,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 +1774,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 +1787,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 +1801,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 +1811,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 +1822,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 +1833,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 +1856,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 +1867,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 +1884,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 +1896,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 +1909,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 +1922,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 +1934,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 +1979,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 +1989,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 +2004,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 +2013,7 @@ Redis.prototype.clearForList = async function(key) {
 		// 直接使用set方法设置为空数组，这样更可靠且与其他模块行为一致
 		// 这样可以确保返回值是一个空数组，而不是null或undefined
-		finalKey = this.applyPrefix(finalKey);
+		finalKey = this._addPrefix(finalKey);
 		await this.set(finalKey, []);
 		// 触发后置事件
@@ -2067,7 +2028,7 @@ Redis.prototype.clearForList = async function(key) {
 			key,
 			error: err
 		});
-		this.logger('error',`清空列表失败 [${key}]:`, err);
+		this.logger('error', `清空列表失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -2082,19 +2043,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 +2066,7 @@ Redis.prototype.mget = async function(keys) {
 		// 如果事件处理器标记为取消，则返回空数组
 		if (ctx.cancel) {
-			this.logger('debug',`mget操作被事件处理器取消 [${keys}]`);
+			this.logger('debug', `mget操作被事件处理器取消 [${keys}]`);
 			return [];
 		}
@@ -2117,13 +2076,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 +2112,7 @@ Redis.prototype.mget = async function(keys) {
 			keys,
 			error: err
 		});
-		this.logger('error',`批量获取缓存失败 [${keys}]:`, err);
+		this.logger('error', `批量获取缓存失败 [${keys}]:`, err);
 		return [];
 	}
 }
@@ -2164,7 +2123,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 +2135,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 +2147,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 +2181,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 +2201,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 +2219,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 +2228,7 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 };
 // 添加连接回收方法，作为_releaseConnection的别名
-Redis.prototype._recycleConnection = function(connection) {
+Redis.prototype._recycleConnection = function (connection) {
 	return this._releaseConnection(connection);
 };
@@ -2279,9 +2236,9 @@ Redis.prototype._recycleConnection = function(connection) {
  * @description 删除哈希字段
  * @param {String} key 键
  * @param {String|Array<String>} fields 字段名或字段名数组
- * @return {Promise<Boolean>} 操作结果
+ * @return {Promise<Number>} 删除的字段数量
  */
-Redis.prototype.hdel = async function(key, fields) {
+Redis.prototype.hdel = async function (key, fields) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -2293,7 +2250,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,28 +2263,29 @@ 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];
 			}
+			let deletedCount = 0;
 			// 执行删除操作
 			if (typeof connection.hDel === 'function') {
-				await connection.hDel(finalKey, finalFields);
+				deletedCount = await connection.hDel(finalKey, finalFields);
 			} else if (typeof connection.execute === 'function') {
-				await connection.execute('HDEL', [finalKey, ...finalFields]);
+				deletedCount = await connection.execute('HDEL', [finalKey, ...finalFields]);
 			} else {
-				this.logger('error','连接对象不支持hDel操作');
-				success = false;
+				this.logger('error', '连接对象不支持hDel操作');
+				deletedCount = 0;
 			}
 			// 触发后置事件
 			this.emit('hdel:after', {
 				key: finalKey,
 				value: finalFields,
-				success
+				deletedCount
 			});
-			return success;
+			return deletedCount;
 		} finally {
 			this._recycleConnection(connection);
 		}
@@ -2338,8 +2296,8 @@ Redis.prototype.hdel = async function(key, fields) {
 			value: fields,
 			error: err
 		});
-		this.logger('error',`删除哈希字段失败 [${key}]:`, err);
-		return false;
+		this.logger('error', `删除哈希字段失败 [${key}]:`, err);
+		return 0; // 与Redis语义保持一致，返回删除的字段数量
 	}
 };
@@ -2348,17 +2306,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 +2400,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 +2430,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 +2456,7 @@ class RedisPipeline {
  * 清空所有过期的数据
  * @return {Promise<Boolean>} 是否成功
  */
-Redis.prototype.clearExpire = async function() {
+Redis.prototype.clearExpire = async function () {
 	try {
 		this.emit('clearExpire:before', {});
 		// Redis没有直接的方法来清空所有过期数据
@@ -2512,14 +2470,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 {
 			// 如果有可用连接，直接返回
@@ -2533,7 +2491,7 @@ Redis.prototype._getConnection = function() {
 			// 如果连接数未达到上限，创建新连接
 			const totalConnections = this.connection_pool.available.length + this.connection_pool.in_use
 				.size;
-			if (totalConnections < this.connection_pool.config.max_clients) {
+			if (totalConnections < this.config.max_clients) {
 				this._createConnection().then(connection => {
 					this.connection_pool.in_use.add(connection);
 					resolve(connection);
@@ -2541,27 +2499,27 @@ 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);
 			// 检查是否超过最大空闲连接数
-			if (this.connection_pool.available.length < this.connection_pool.config.max_idle) {
+			if (this.connection_pool.available.length < this.config.max_idle) {
 				this.connection_pool.available.push(connection);
 			} else {
 				// 否则关闭多余的连接
@@ -2571,16 +2529,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 +2553,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 +2566,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 +2579,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方法
@@ -2637,12 +2594,12 @@ Redis.prototype.hset = async function(key, field, value) {
 				value: finalValue,
 				success: true
 			});
-			return result > 0; // 如果field是新的，hSet返回1，否则返回0
+			return true; // hSet操作成功返回true
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`设置哈希字段失败 [${key}:${field}]:`, err);
+		this.logger('error', `设置哈希字段失败 [${key}:${field}]:`, err);
 		// 触发错误事件
 		this.emit('hset:error', {
 			key,
@@ -2660,15 +2617,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 +2641,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 +2652,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 +2664,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 +2676,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 +2685,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 +2704,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 +2716,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 +2746,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 +2762,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 +2789,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 +2802,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 +2828,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 +2842,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 +2853,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 +2864,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 +2876,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 +2886,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 +2897,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 +2913,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 +2932,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 +2946,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 +2962,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 +2973,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 +2984,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 +2994,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 +3005,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 +3014,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 +3024,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 +3039,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 +3055,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 +3066,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 +3086,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 +3097,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 +3113,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 +3129,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 +3140,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 +3160,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 +3171,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 +3188,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 +3208,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 +3220,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 +3242,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 +3254,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 +3272,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 +3292,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 +3304,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 +3325,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 +3337,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 +3355,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 +3375,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 +3387,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 +3408,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 +3420,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 +3439,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 +3450,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 +3461,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 +3475,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 +3491,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 +3502,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 +3513,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 +3527,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 +3543,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 +3559,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 +3578,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 +3588,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 +3603,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 +3617,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 +3638,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 +3650,7 @@ Redis.prototype.sinter = async function(keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取集合交集失败:`, err);
+		this.logger('error', `获取集合交集失败:`, err);
 		return [];
 	}
 };
@@ -3717,11 +3660,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 +3672,7 @@ Redis.prototype.sunion = async function(keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取集合并集失败:`, err);
+		this.logger('error', `获取集合并集失败:`, err);
 		return [];
 	}
 };
@@ -3739,11 +3682,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 +3694,7 @@ Redis.prototype.sdiff = async function(keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error',`获取集合差集失败:`, err);
+		this.logger('error', `获取集合差集失败:`, err);
 		return [];
 	}
 };
@@ -3765,7 +3708,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 +3720,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 +3732,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 +3750,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 +3767,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 +3778,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 +3790,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 +3800,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 +3811,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 +3827,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 +3849,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 +3873,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 +3901,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 +3920,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 +3930,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 +3957,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 +3981,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 +3994,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 +4017,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 +4030,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 +4043,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 +4064,7 @@ Redis.prototype._createConnection = function() {
 			// 监听错误事件
 			connection.on('error', (err) => {
-				this.logger('error',`连接 ${connection.id} 错误:`, err);
+				this.logger('error', `连接 ${connection.id} 错误:`, err);
 			});
 			// 连接Redis
@@ -4132,11 +4072,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);
 		}
 	});