mm_redis 2.0.8 → 2.1.0

package/index.js

@@ -34,12 +34,10 @@ class Redis extends Base {
 			// 重试间隔(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);
 		// 初始化连接池
@@ -87,20 +85,20 @@ Redis.prototype._delPrefix = function (key) {
  * @return {Promise<Boolean>} 订阅结果
  */
 Redis.prototype.subscribe = async function (channel, func) {
-	try {
-		// 参数验证
-		if (!channel || typeof channel !== 'string') {
-			throw new TypeError('channel必须是非空字符串');
-		}
-		if (typeof func !== 'function') {
-			throw new TypeError('func必须是函数');
-		}
+	// 参数验证
+	if (!channel || typeof channel !== 'string') {
+		throw new TypeError('channel必须是非空字符串');
+	}
+	if (typeof func !== 'function') {
+		throw new TypeError('func必须是函数');
+	}
 
+	try {
 		await this.conn.subscribe(this._addPrefix(channel));
 		this.func_list[channel] = func;
 		return true;
 	} catch (err) {
-		this.logger('error', `订阅频道 ${channel} 失败:`, err);
+		this.log('error', `订阅频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -111,17 +109,17 @@ Redis.prototype.subscribe = async function (channel, func) {
  * @return {Promise<Boolean>} 取消订阅结果
  */
 Redis.prototype.unsubscribe = async function (channel) {
-	try {
-		// 参数验证
-		if (!channel || typeof channel !== 'string') {
-			throw new TypeError('channel必须是非空字符串');
-		}
+	// 参数验证
+	if (!channel || typeof channel !== 'string') {
+		throw new TypeError('channel必须是非空字符串');
+	}
 
+	try {
 		await this.conn.unsubscribe(this._addPrefix(channel));
 		delete this.func_list[channel];
 		return true;
 	} catch (err) {
-		this.logger('error', `取消订阅频道 ${channel} 失败:`, err);
+		this.log('error', `取消订阅频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -133,18 +131,18 @@ Redis.prototype.unsubscribe = async function (channel) {
  * @return {Promise<Number>} 接收消息的客户端数量
  */
 Redis.prototype.publish = async function (channel, message) {
-	try {
-		// 参数验证
-		if (!channel || typeof channel !== 'string') {
-			throw new TypeError('channel必须是非空字符串');
-		}
-		if (message === undefined || message === null) {
-			throw new TypeError('message不能为undefined或null');
-		}
+	// 参数验证
+	if (!channel || typeof channel !== 'string') {
+		throw new TypeError('channel必须是非空字符串');
+	}
+	if (message === undefined || message === null) {
+		throw new TypeError('message不能为undefined或null');
+	}
 
+	try {
 		return await this.conn.publish(this._addPrefix(channel), message);
 	} catch (err) {
-		this.logger('error', `发布消息到频道 ${channel} 失败:`, err);
+		this.log('error', `发布消息到频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -156,7 +154,7 @@ Redis.prototype.publish = async function (channel, message) {
  */
 Redis.prototype.main = async function (channel, message) {
 	// 默认实现，可由子类重写
-	this.logger('debug', `收到未处理的消息 [${channel}]:`, message);
+	this.log('debug', `收到未处理的消息 [${channel}]:`, message);
 };
 
 /**
@@ -172,7 +170,7 @@ Redis.prototype.message = function (channel, message) {
 		try {
 			func(message);
 		} catch (err) {
-			this.logger('error', `处理频道 ${channel} 的消息时出错:`, err);
+			this.log('error', `处理频道 ${channel} 的消息时出错:`, err);
 		}
 	} else {
 		this.main(channel, message);
@@ -189,52 +187,14 @@ Redis.prototype.setConfig = function (config) {
 		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','配置已更新');
+	// this.log('debug','配置已更新');
 	this.identifier = this.config.host + "/" + this.config.database;
 	return this;
 };
@@ -242,24 +202,16 @@ Redis.prototype.setConfig = function (config) {
 // 添加连接池初始化方法
 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.log('debug','连接池已初始化，配置:', this.config);
 };
 
 /**
@@ -288,7 +240,7 @@ Redis.prototype.open = async function () {
 
 		// 监听错误事件
 		this.conn.on('error', (err) => {
-			this.logger('error', 'Redis连接错误:', err);
+			this.log('error', 'Redis连接错误:', err);
 			this.connected = false;
 			// 尝试重连
 			this._reconnect();
@@ -296,25 +248,25 @@ Redis.prototype.open = async function () {
 
 		// 监听连接成功事件
 		this.conn.on('connect', () => {
-			// this.logger('debug','Redis已连接');
+			// this.log('debug','Redis已连接');
 			this.connected = true;
 			this.retry_count = 0;
 		});
 
 		// 监听断开连接事件
 		this.conn.on('end', () => {
-			// this.logger('debug','Redis连接已断开');
+			// this.log('debug','Redis连接已断开');
 			this.connected = false;
 		});
 
 		// 监听订阅成功事件
 		this.conn.on('subscribe', (channel, count) => {
-			this.logger('debug', `频道${this._delPrefix(channel)}订阅成功, 当前总计订阅数：${count}`);
+			this.log('debug', `频道${this._delPrefix(channel)}订阅成功, 当前总计订阅数：${count}`);
 		});
 
 		// 监听取消订阅事件
 		this.conn.on('unsubscribe', (channel, count) => {
-			this.logger('debug', `频道${this._delPrefix(channel)}取消订阅, 当前总计订阅数：${count}`);
+			this.log('debug', `频道${this._delPrefix(channel)}取消订阅, 当前总计订阅数：${count}`);
 		});
 
 		// 收到消息后执行回调
@@ -327,7 +279,7 @@ Redis.prototype.open = async function () {
 		this.connected = true;
 		return true;
 	} catch (err) {
-		this.logger('error', 'Redis连接失败:', err);
+		this.log('error', 'Redis连接失败:', err);
 		// 尝试重连
 		this._reconnect();
 		return false;
@@ -340,18 +292,18 @@ Redis.prototype.open = async function () {
  */
 Redis.prototype._reconnect = function () {
 	if (this.retry_count >= this.config.retry_count) {
-		this.logger('error', `达到最大重连次数 ${this.config.retry_count}，停止重连`);
+		this.log('error', `达到最大重连次数 ${this.config.retry_count}，停止重连`);
 		return;
 	}
 
 	this.retry_count++;
-	this.logger('debug', `尝试第 ${this.retry_count} 次重连...`);
+	this.log('debug', `尝试第 ${this.retry_count} 次重连...`);
 
 	setTimeout(async () => {
 		try {
 			await this.open();
 		} catch (err) {
-			this.logger('error', `重连失败:`, err);
+			this.log('error', `重连失败:`, err);
 		}
 	}, this.config.retry_delay);
 };
@@ -363,7 +315,7 @@ Redis.prototype._reconnect = function () {
 // 修复close方法，正确处理连接池
 Redis.prototype.close = function () {
 	try {
-		// this.logger('debug','关闭所有连接...');
+		// this.log('debug','关闭所有连接...');
 
 		// 关闭所有使用中的连接
 		if (this.connection_pool && this.connection_pool.in_use) {
@@ -371,7 +323,7 @@ Redis.prototype.close = function () {
 				try {
 					connection.close();
 				} catch (e) {
-					this.logger('error', '关闭连接失败:', e);
+					this.log('error', '关闭连接失败:', e);
 				}
 			}
 			this.connection_pool.in_use.clear();
@@ -388,20 +340,20 @@ Redis.prototype.close = function () {
 						// 某些Redis客户端可能使用end方法
 						connection.end();
 					} else {
-						this.logger('debug', '连接对象没有可用的关闭方法');
+						this.log('debug', '连接对象没有可用的关闭方法');
 					}
 				} catch (e) {
-					this.logger('error', '关闭连接失败:', e);
+					this.log('error', '关闭连接失败:', e);
 				}
 			}
 			this.connection_pool.available = [];
 		}
 
 		this.connected = false;
-		this.logger('debug', 'Redis连接已断开');
+		this.log('debug', 'Redis连接已断开');
 		return Promise.resolve(true);
 	} catch (error) {
-		this.logger('error', '关闭连接时发生错误:', error);
+		this.log('error', '关闭连接时发生错误:', error);
 		return Promise.resolve(false);
 	}
 };
@@ -528,7 +480,7 @@ Redis.prototype.pipeline = function () {
 						// 直接返回结果值，符合测试期望的格式
 						results.push(result);
 					} catch (err) {
-						this.logger('error', `Pipeline命令执行失败 [${cmd[0]}]:`, err);
+						this.log('error', `Pipeline命令执行失败 [${cmd[0]}]:`, err);
 						results.push(null);
 					}
 				}
@@ -537,7 +489,7 @@ Redis.prototype.pipeline = function () {
 				redisInstance._recycleConnection(connection);
 				return results;
 			} catch (error) {
-				this.logger('error', 'Pipeline执行失败:', error);
+				this.log('error', 'Pipeline执行失败:', error);
 				return [];
 			}
 		}
@@ -552,12 +504,6 @@ 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 键名
@@ -565,11 +511,12 @@ Redis.prototype.isConnected = function () {
  * @return {Promise<Number|Boolean>} 不传seconds时返回剩余过期时间（-1表示无过期设置，-2表示已过期），传seconds时返回是否设置成功
  */
 Redis.prototype.ttl = async function (key, seconds) {
+	// 参数验证
+	if (!key || typeof key !== 'string') {
+		throw new TypeError('key必须是非空字符串');
+	}
+
 	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
 
 		const connection = await this._getConnection();
 		try {
@@ -589,7 +536,7 @@ Redis.prototype.ttl = async function (key, seconds) {
 					await connection.execute('EXPIRE', [key, seconds]);
 					return true;
 				} else {
-					this.logger('error', '连接对象不支持expire操作');
+					this.log('error', '连接对象不支持expire操作');
 					return false;
 				}
 			}
@@ -600,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.log('error', '连接对象不支持ttl操作');
 				return -2; // 默认返回键不存在
 			}
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `${seconds !== undefined ? '设置' : '获取'}过期时间失败 [${key}]:`, err);
+		this.log('error', `${seconds !== undefined ? '设置' : '获取'}过期时间失败 [${key}]:`, err);
 		return seconds !== undefined ? false : -2;
 	}
 };
@@ -620,16 +567,15 @@ Redis.prototype.ttl = async function (key, seconds) {
  * @return {Promise<Number>} 计算后的结果
  */
 Redis.prototype.addInt = async function (key, num, seconds = 0) {
+	// 参数验证
+	if (!key || typeof key !== 'string') {
+		throw new TypeError('key必须是非空字符串');
+	}
+	if (typeof num !== 'number' || isNaN(num) || !Number.isInteger(num)) {
+		throw new TypeError('num必须是有效整数');
+	}
+
 	try {
-		// 参数验证
-		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 = {
@@ -642,7 +588,7 @@ Redis.prototype.addInt = async function (key, num, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `addInt操作被事件处理器取消 [${key}]`);
+			this.log('debug', `addInt操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -665,7 +611,7 @@ Redis.prototype.addInt = async function (key, num, seconds = 0) {
 					result = await connection.execute('INCRBY', [prefixedKey, finalNum]);
 				} else {
 					// 如果出错，回退到先获取再设置的方式
-					this.logger('warn', `使用原子操作增加整数值失败，使用回退方案 [${key}]`);
+					this.log('warn', `使用原子操作增加整数值失败，使用回退方案 [${key}]`);
 					let value = await this.get(prefixedKey);
 					let n = 0;
 					if (value) {
@@ -683,7 +629,7 @@ Redis.prototype.addInt = async function (key, num, seconds = 0) {
 					result = await connection.execute('DECRBY', [prefixedKey, -finalNum]);
 				} else {
 					// 如果出错，回退到先获取再设置的方式
-					this.logger('warn', `使用原子操作减少整数值失败，使用回退方案`);
+					this.log('warn', `使用原子操作减少整数值失败，使用回退方案`);
 					let value = await this.get(prefixedKey);
 					let n = 0;
 					if (value) {
@@ -724,7 +670,7 @@ Redis.prototype.addInt = async function (key, num, seconds = 0) {
 			seconds,
 			error: err
 		});
-		this.logger('error', `增加整数值失败 [${key}]:`, err);
+		this.log('error', `增加整数值失败 [${key}]:`, err);
 		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
 		return 0;
 	}
@@ -738,17 +684,18 @@ Redis.prototype.addInt = async function (key, num, seconds = 0) {
  * @return {Promise<Number>} 计算后的结果
  */
 Redis.prototype.addFloat = async function (key, num, seconds = 0) {
-	try {
-		// 参数验证
-		if (!key || typeof key !== 'string') {
-			throw new TypeError('key必须是非空字符串');
-		}
+	// 参数验证
+	if (!key || typeof key !== 'string') {
+		throw new TypeError('key必须是非空字符串');
+	}
 
-		// 验证num参数
-		num = parseFloat(num);
-		if (isNaN(num)) {
-			throw new TypeError('num必须是有效的数值');
-		}
+	// 验证num参数
+	num = parseFloat(num);
+	if (isNaN(num)) {
+		throw new TypeError('num必须是有效的数值');
+	}
+
+	try {
 
 		// 触发前置事件，允许修改或阻止操作
 		const ctx = {
@@ -761,7 +708,7 @@ Redis.prototype.addFloat = async function (key, num, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回默认值
 		if (ctx.cancel) {
-			this.logger('debug', `addFloat操作被事件处理器取消 [${key}]`);
+			this.log('debug', `addFloat操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -787,7 +734,7 @@ Redis.prototype.addFloat = async function (key, num, seconds = 0) {
 			}
 			// 回退方案
 			else {
-				this.logger('warn', `连接对象不支持incrByFloat操作，使用回退方案`);
+				this.log('warn', `连接对象不支持incrByFloat操作，使用回退方案`);
 				let value = await this.get(prefixedKey);
 				let n = 0;
 				if (value) {
@@ -818,7 +765,7 @@ Redis.prototype.addFloat = async function (key, num, seconds = 0) {
 			return result;
 		} catch (err) {
 			// 如果出错，回退到先获取再设置的方式
-			this.logger('warn', `使用原子操作增加浮点数值失败，使用回退方案:`, err);
+			this.log('warn', `使用原子操作增加浮点数值失败，使用回退方案:`, err);
 			let value = await this.get(prefixedKey);
 			let n = 0;
 			if (value) {
@@ -847,7 +794,7 @@ Redis.prototype.addFloat = async function (key, num, seconds = 0) {
 			seconds,
 			error: err
 		});
-		this.logger('error', `增加浮点数值失败 [${key}]:`, err);
+		this.log('error', `增加浮点数值失败 [${key}]:`, err);
 		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
 		return 0;
 	}
@@ -884,7 +831,7 @@ Redis.prototype.addStr = async function (key, str, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug', `addStr操作被事件处理器取消 [${key}]`);
+			this.log('debug', `addStr操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -910,7 +857,7 @@ Redis.prototype.addStr = async function (key, str, seconds = 0) {
 			}
 			// 回退方案
 			else {
-				this.logger('warn', `连接对象不支持append操作，使用回退方案`);
+				this.log('warn', `连接对象不支持append操作，使用回退方案`);
 				let value = await this.get(prefixedKey) || '';
 				value += finalStr;
 				await this.set(prefixedKey, value, finalSeconds);
@@ -936,7 +883,7 @@ Redis.prototype.addStr = async function (key, str, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('warn', '追加字符串失败:', err);
+			this.log('warn', '追加字符串失败:', err);
 			// 回退方案：先获取再设置
 			let value = await this.get(prefixedKey) || '';
 			value += finalStr;
@@ -962,7 +909,7 @@ Redis.prototype.addStr = async function (key, str, seconds = 0) {
 			seconds,
 			error: err
 		});
-		this.logger('error', `追加字符串失败 [${key}]:`, err);
+		this.log('error', `追加字符串失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1005,7 +952,7 @@ Redis.prototype.del = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `del操作被事件处理器取消 [${key}]`);
+			this.log('debug', `del操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1058,7 +1005,7 @@ Redis.prototype.del = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `删除缓存失败 [${key}]:`, err);
+		this.log('error', `删除缓存失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1095,7 +1042,7 @@ Redis.prototype.set = async function (key, value, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `set操作被事件处理器取消 [${key}]`);
+			this.log('debug', `set操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1133,7 +1080,7 @@ Redis.prototype.set = async function (key, value, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `设置缓存失败 [${key}]:`, err);
+		this.log('error', `设置缓存失败 [${key}]:`, err);
 		// 触发错误事件
 		this.emit('set:error', {
 			key,
@@ -1173,7 +1120,7 @@ Redis.prototype.add = async function (key, value, seconds) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `add操作被事件处理器取消 [${key}]`);
+			this.log('debug', `add操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1213,7 +1160,7 @@ Redis.prototype.add = async function (key, value, seconds) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `添加缓存失败 [${key}]:`, err);
+		this.log('error', `添加缓存失败 [${key}]:`, err);
 		// 触发错误事件
 		this.emit('add:error', {
 			key,
@@ -1251,7 +1198,7 @@ Redis.prototype.get = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回null
 		if (ctx.cancel) {
-			this.logger('debug', `get操作被事件处理器取消 [${key}]`);
+			this.log('debug', `get操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -1292,7 +1239,7 @@ Redis.prototype.get = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `获取缓存失败 [${key}]:`, err);
+		this.log('error', `获取缓存失败 [${key}]:`, err);
 		return null;
 	}
 };
@@ -1318,7 +1265,7 @@ Redis.prototype.has = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `has操作被事件处理器取消 [${key}]`);
+			this.log('debug', `has操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1348,7 +1295,7 @@ Redis.prototype.has = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `检查键是否存在失败 [${key}]:`, err);
+		this.log('error', `检查键是否存在失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1391,7 +1338,7 @@ Redis.prototype.exists = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug', `exists操作被事件处理器取消 [${key}]`);
+			this.log('debug', `exists操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1426,7 +1373,7 @@ Redis.prototype.exists = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `检查键存在性失败 [${key}]:`, err);
+		this.log('error', `检查键存在性失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1445,7 +1392,7 @@ Redis.prototype.getrange = async function (key, start, end) {
 			key = this._addPrefix(key);
 			return await connection.getRange(key, start, end);
 		} catch (err) {
-			this.logger('error', '获取字符串范围失败:', err);
+			this.log('error', '获取字符串范围失败:', err);
 			// 回退方案
 			const value = await this.get(key);
 			if (value && typeof value === 'string') {
@@ -1456,7 +1403,7 @@ Redis.prototype.getrange = async function (key, start, end) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取字符串范围失败 [${key}]:`, err);
+		this.log('error', `获取字符串范围失败 [${key}]:`, err);
 		return '';
 	}
 };
@@ -1492,7 +1439,7 @@ Redis.prototype.setrange = async function (key, index, value) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug', `setrange操作被事件处理器取消 [${key}]`);
+			this.log('debug', `setrange操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1518,7 +1465,7 @@ Redis.prototype.setrange = async function (key, index, value) {
 			}
 			// 回退方案
 			else {
-				this.logger('warn', `连接对象不支持setRange操作，使用回退方案`);
+				this.log('warn', `连接对象不支持setRange操作，使用回退方案`);
 				let str = await this.get(finalKey) || '';
 				if (str.length < finalIndex) {
 					// 填充空格到指定索引
@@ -1539,7 +1486,7 @@ Redis.prototype.setrange = async function (key, index, value) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error', '设置字符串范围失败:', err);
+			this.log('error', '设置字符串范围失败:', err);
 			// 回退方案
 			let str = await this.get(finalKey) || '';
 			if (str.length < finalIndex) {
@@ -1569,7 +1516,7 @@ Redis.prototype.setrange = async function (key, index, value) {
 			value,
 			error: err
 		});
-		this.logger('error', `设置字符串范围失败 [${key}]:`, err);
+		this.log('error', `设置字符串范围失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1590,7 +1537,7 @@ Redis.prototype.clear = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `clear操作被事件处理器取消`);
+			this.log('debug', `clear操作被事件处理器取消`);
 			return false;
 		}
 
@@ -1614,7 +1561,7 @@ Redis.prototype.clear = async function (key) {
 					await connection.execute('FLUSHDB');
 					success = true;
 				} else {
-					this.logger('error', '连接对象不支持flushDb操作');
+					this.log('error', '连接对象不支持flushDb操作');
 					success = false;
 				}
 			}
@@ -1634,7 +1581,7 @@ Redis.prototype.clear = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', '清空缓存失败:', err);
+		this.log('error', '清空缓存失败:', err);
 		return false;
 	}
 };
@@ -1678,7 +1625,7 @@ Redis.prototype.sort = async function (key, options = {}) {
 
 			return await connection.sort(key, sortOptions);
 		} catch (err) {
-			this.logger('error', '排序失败:', err);
+			this.log('error', '排序失败:', err);
 			// 回退方案：获取数据后在内存中排序
 			const data = await this.getForList(key);
 			return data.sort((a, b) => {
@@ -1692,7 +1639,7 @@ Redis.prototype.sort = async function (key, options = {}) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `排序失败 [${key}]:`, err);
+		this.log('error', `排序失败 [${key}]:`, err);
 		return [];
 	}
 };
@@ -1715,7 +1662,7 @@ Redis.prototype.keys = async function (pattern = '*') {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', '获取键列表失败:', err);
+		this.log('error', '获取键列表失败:', err);
 		return [];
 	}
 };
@@ -1740,7 +1687,7 @@ Redis.prototype.setForList = async function (key, value, seconds) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug', `setForList操作被事件处理器取消 [${key}]`);
+			this.log('debug', `setForList操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1770,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.log('error', '连接对象不支持rPush操作');
 						len = 0;
 					}
 				}
@@ -1781,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.log('error', '连接对象不支持rPush操作');
 					len = 0;
 				}
 			}
@@ -1792,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.log('error', '连接对象不支持expire操作');
 				}
 			}
 
@@ -1815,7 +1762,7 @@ Redis.prototype.setForList = async function (key, value, seconds) {
 			value,
 			error: err
 		});
-		this.logger('error', `设置列表失败 [${key}]:`, err);
+		this.log('error', `设置列表失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1840,7 +1787,7 @@ Redis.prototype.addForList = async function (key, value, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug', `addForList操作被事件处理器取消 [${key}]`);
+			this.log('debug', `addForList操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1864,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.log('error', '连接对象不支持rPush操作');
 						len = 0;
 					}
 				}
@@ -1875,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.log('error', '连接对象不支持rPush操作');
 					len = 0;
 				}
 			}
@@ -1886,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.log('error', '连接对象不支持expire操作');
 				}
 			}
 
@@ -1909,7 +1856,7 @@ Redis.prototype.addForList = async function (key, value, seconds = 0) {
 			value,
 			error: err
 		});
-		this.logger('error', `添加列表项失败 [${key}]:`, err);
+		this.log('error', `添加列表项失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1937,7 +1884,7 @@ Redis.prototype.hasForList = async function (key, value) {
 			return itemStr === valueStr || item === value;
 		});
 	} catch (err) {
-		this.logger('error', `检查列表成员是否存在失败 [${key}]:`, err);
+		this.log('error', `检查列表成员是否存在失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1962,7 +1909,7 @@ Redis.prototype.getForList = async function (key, start = 0, end = -1) {
 
 		// 如果事件处理器标记为取消，则返回空数组
 		if (ctx.cancel) {
-			this.logger('debug', `getForList操作被事件处理器取消 [${key}]`);
+			this.log('debug', `getForList操作被事件处理器取消 [${key}]`);
 			return [];
 		}
 
@@ -1987,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.log('error', '连接对象不支持lRange或lrange操作');
 				return [];
 			}
 			// 确保结果是数组
 			if (!Array.isArray(result)) {
-				this.logger('error', '列表查询结果不是数组格式');
+				this.log('error', '列表查询结果不是数组格式');
 				return [];
 			}
 
@@ -2032,7 +1979,7 @@ Redis.prototype.getForList = async function (key, start = 0, end = -1) {
 			end,
 			error: err
 		});
-		this.logger('error', `获取列表失败 [${key}]:`, err);
+		this.log('error', `获取列表失败 [${key}]:`, err);
 		return [];
 	}
 };
@@ -2057,7 +2004,7 @@ Redis.prototype.clearForList = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `clearForList操作被事件处理器取消 [${key}]`);
+			this.log('debug', `clearForList操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2081,7 +2028,7 @@ Redis.prototype.clearForList = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `清空列表失败 [${key}]:`, err);
+		this.log('error', `清空列表失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -2119,7 +2066,7 @@ Redis.prototype.mget = async function (keys) {
 
 		// 如果事件处理器标记为取消，则返回空数组
 		if (ctx.cancel) {
-			this.logger('debug', `mget操作被事件处理器取消 [${keys}]`);
+			this.log('debug', `mget操作被事件处理器取消 [${keys}]`);
 			return [];
 		}
 
@@ -2165,7 +2112,7 @@ Redis.prototype.mget = async function (keys) {
 			keys,
 			error: err
 		});
-		this.logger('error', `批量获取缓存失败 [${keys}]:`, err);
+		this.log('error', `批量获取缓存失败 [${keys}]:`, err);
 		return [];
 	}
 }
@@ -2188,7 +2135,7 @@ Redis.prototype.mset = async function (obj, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `mset操作被事件处理器取消`);
+			this.log('debug', `mset操作被事件处理器取消`);
 			return false;
 		}
 
@@ -2234,7 +2181,7 @@ Redis.prototype.mset = async function (obj, seconds = 0) {
 		});
 
 		// 如果Pipeline失败，回退到原实现
-		this.logger('warn', '使用Pipeline批量设置失败，使用回退方案:', err);
+		this.log('warn', '使用Pipeline批量设置失败，使用回退方案:', err);
 		const connection = await this._getConnection();
 		try {
 			const pairs = [];
@@ -2272,7 +2219,7 @@ Redis.prototype.mset = async function (obj, seconds = 0) {
 				seconds,
 				error: fallbackErr
 			});
-			this.logger('error', '回退方案批量设置也失败:', fallbackErr);
+			this.log('error', '回退方案批量设置也失败:', fallbackErr);
 			return false;
 		} finally {
 			this._recycleConnection(connection);
@@ -2289,7 +2236,7 @@ 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) {
 	try {
@@ -2303,7 +2250,7 @@ Redis.prototype.hdel = async function (key, fields) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `hdel操作被事件处理器取消 [${key}]`);
+			this.log('debug', `hdel操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2321,23 +2268,24 @@ Redis.prototype.hdel = async function (key, fields) {
 				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.log('error', '连接对象不支持hDel操作');
+				deletedCount = 0;
 			}
 
 			// 触发后置事件
 			this.emit('hdel:after', {
 				key: finalKey,
 				value: finalFields,
-				success
+				deletedCount
 			});
-			return success;
+			return deletedCount;
 		} finally {
 			this._recycleConnection(connection);
 		}
@@ -2348,8 +2296,8 @@ Redis.prototype.hdel = async function (key, fields) {
 			value: fields,
 			error: err
 		});
-		this.logger('error', `删除哈希字段失败 [${key}]:`, err);
-		return false;
+		this.log('error', `删除哈希字段失败 [${key}]:`, err);
+		return 0; // 与Redis语义保持一致，返回删除的字段数量
 	}
 };
 
@@ -2368,7 +2316,7 @@ Redis.prototype.hlen = async function (key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取哈希字段数量失败 [${key}]:`, err);
+		this.log('error', `获取哈希字段数量失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -2482,7 +2430,7 @@ class RedisPipeline {
 			// 处理结果（解析JSON等）
 			return results.map(([err, value], index) => {
 				if (err) {
-					this.logger('error', `[Pipeline] Pipeline命令执行失败 [${this.commands[index].name}]:`, err);
+					this.log('error', `[Pipeline] Pipeline命令执行失败 [${this.commands[index].name}]:`, err);
 					return null;
 				}
 
@@ -2522,7 +2470,7 @@ Redis.prototype.clearExpire = async function () {
 		this.emit('clearExpire:error', {
 			error: err
 		});
-		this.logger('error', '清空过期数据失败:', err);
+		this.log('error', '清空过期数据失败:', err);
 		return false;
 	}
 };
@@ -2543,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);
@@ -2551,14 +2499,14 @@ Redis.prototype._getConnection = function () {
 			} else {
 				// 否则等待连接释放
 				// 这里简化处理，直接创建连接（生产环境应实现等待队列）
-				this.logger('warn', '连接池已满，创建额外连接');
+				this.log('warn', '连接池已满，创建额外连接');
 				this._createConnection().then(connection => {
 					this.connection_pool.in_use.add(connection);
 					resolve(connection);
 				}).catch(reject);
 			}
 		} catch (error) {
-			this.logger('error', '获取连接失败:', error);
+			this.log('error', '获取连接失败:', error);
 			reject(error);
 		}
 	});
@@ -2571,7 +2519,7 @@ Redis.prototype._releaseConnection = function (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 {
 				// 否则关闭多余的连接
@@ -2581,15 +2529,15 @@ Redis.prototype._releaseConnection = function (connection) {
 					} else if (typeof connection.end === 'function') {
 						connection.end();
 					} else {
-						this.logger('debug', '连接对象没有可用的关闭方法');
+						this.log('debug', '连接对象没有可用的关闭方法');
 					}
 				} catch (e) {
-					this.logger('error', '关闭多余连接失败:', e);
+					this.log('error', '关闭多余连接失败:', e);
 				}
 			}
 		}
 	} catch (error) {
-		this.logger('error', '释放连接失败:', error);
+		this.log('error', '释放连接失败:', error);
 	}
 };
 
@@ -2618,7 +2566,7 @@ Redis.prototype.hset = async function (key, field, value) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `hset操作被事件处理器取消 [${key}:${field}]`);
+			this.log('debug', `hset操作被事件处理器取消 [${key}:${field}]`);
 			return false;
 		}
 
@@ -2646,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.log('error', `设置哈希字段失败 [${key}:${field}]:`, err);
 		// 触发错误事件
 		this.emit('hset:error', {
 			key,
@@ -2693,7 +2641,7 @@ Redis.prototype.hget = async function (key, field) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取哈希字段失败 [${key}:${field}]:`, err);
+		this.log('error', `获取哈希字段失败 [${key}:${field}]:`, err);
 		return null;
 	}
 };
@@ -2716,7 +2664,7 @@ Redis.prototype.hmset = async function (key, obj) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `hmset操作被事件处理器取消 [${key}]`);
+			this.log('debug', `hmset操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2731,20 +2679,20 @@ Redis.prototype.hmset = async function (key, obj) {
 			finalKey = this._addPrefix(finalKey);
 
 			// 检查Redis版本，支持不同的方法
-			this.logger('debug',
+			this.log('debug',
 				`hmset方法检测到连接对象方法: hSet=${typeof connection.hSet === 'function'}, hmset=${typeof connection.hmset === 'function'}`
 			);
 			let success = true;
 
 			// 优化策略：对所有Redis版本都使用逐个字段设置的方式，确保兼容性和正确性
-			this.logger('debug', `对键 ${finalKey} 强制使用逐个字段设置策略`);
+			this.log('debug', `对键 ${finalKey} 强制使用逐个字段设置策略`);
 
 			// 获取适合的设置字段方法
 			const setFieldMethod = typeof connection.hSet === 'function' ? 'hSet' :
 				typeof connection.hset === 'function' ? 'hset' : null;
 
 			if (!setFieldMethod) {
-				this.logger('error', `连接对象不支持hSet或hset操作`);
+				this.log('error', `连接对象不支持hSet或hset操作`);
 				return false;
 			}
 
@@ -2756,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.log('debug', `单独设置字段: ${setFieldMethod}(${finalKey}, ${field}, ${value})`);
 						await connection[setFieldMethod](finalKey, field, value);
 					} catch (singleError) {
-						this.logger('error', `设置单个字段失败 ${field}: ${singleError.message}`);
+						this.log('error', `设置单个字段失败 ${field}: ${singleError.message}`);
 						success = false;
 						break;
 					}
@@ -2768,19 +2716,19 @@ Redis.prototype.hmset = async function (key, obj) {
 
 			// 验证所有字段是否都设置成功
 			if (success) {
-				this.logger('debug', `验证所有字段设置情况`);
+				this.log('debug', `验证所有字段设置情况`);
 				for (const field in finalObj) {
 					if (finalObj.hasOwnProperty(field)) {
 						try {
 							const hgetMethod = typeof connection.hGet === 'function' ? 'hGet' : 'hget';
 							const value = await connection[hgetMethod](finalKey, field);
-							this.logger('debug', `验证字段 ${field}: ${value !== null ? '存在' : '不存在'}`);
+							this.log('debug', `验证字段 ${field}: ${value !== null ? '存在' : '不存在'}`);
 							// 如果字段不存在，更新success状态
 							if (value === null) {
 								success = false;
 							}
 						} catch (getError) {
-							this.logger('error', `验证字段失败 ${field}: ${getError.message}`);
+							this.log('error', `验证字段失败 ${field}: ${getError.message}`);
 							success = false;
 						}
 					}
@@ -2798,7 +2746,7 @@ Redis.prototype.hmset = async function (key, obj) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `批量设置哈希字段失败 [${key}]:`, err);
+		this.log('error', `批量设置哈希字段失败 [${key}]:`, err);
 		// 触发错误事件
 		this.emit('hmset:error', {
 			key,
@@ -2823,14 +2771,14 @@ Redis.prototype.hgetall = async function (key) {
 				const result = await connection.hGetAll(key);
 				return result;
 			} else {
-				this.logger('error', '连接对象不支持hGetAll操作');
+				this.log('error', '连接对象不支持hGetAll操作');
 				return {};
 			}
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取哈希所有字段和值失败 [${key}]:`, err);
+		this.log('error', `获取哈希所有字段和值失败 [${key}]:`, err);
 		return {};
 	}
 };
@@ -2880,8 +2828,8 @@ Redis.prototype.hmget = async function (key, fields) {
 				});
 				return finalResult;
 			} else {
-				this.logger('error', '连接对象不支持hmGet操作');
-				this.logger('error', '错误: Redis客户端不支持hmget操作');
+				this.log('error', '连接对象不支持hmGet操作');
+				this.log('error', '错误: Redis客户端不支持hmget操作');
 				// 返回与fields长度相同的undefined数组，保持与注释一致
 				return fields.map(() => undefined);
 			}
@@ -2894,7 +2842,7 @@ Redis.prototype.hmget = async function (key, fields) {
 			fields,
 			error: err
 		});
-		this.logger('error', `哈希表批量获取失败 [${key}]:`, err);
+		this.log('error', `哈希表批量获取失败 [${key}]:`, err);
 		// 返回与fields长度相同的undefined数组，保持与注释类型一致
 		return fields.map(() => undefined);
 	}
@@ -2916,7 +2864,7 @@ Redis.prototype.expire = async function (key, seconds) {
 		this.emit('expire:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `expire操作被事件处理器取消 [${key}]`);
+			this.log('debug', `expire操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2938,7 +2886,7 @@ Redis.prototype.expire = async function (key, seconds) {
 			});
 			return result === 1;
 		} catch (err) {
-			this.logger('error', `设置过期时间失败 [${finalKey}]:`, err);
+			this.log('error', `设置过期时间失败 [${finalKey}]:`, err);
 			this.emit('expire:error', {
 				key: finalKey,
 				ttl: finalSeconds,
@@ -2949,7 +2897,7 @@ Redis.prototype.expire = async function (key, seconds) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `设置过期时间失败 [${key}]:`, err);
+		this.log('error', `设置过期时间失败 [${key}]:`, err);
 		this.emit('expire:error', {
 			key,
 			ttl: seconds,
@@ -2984,7 +2932,7 @@ Redis.prototype.pexpire = async function (key, milliseconds) {
 		this.emit('pexpire:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `pexpire操作被事件处理器取消 [${key}]`);
+			this.log('debug', `pexpire操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -3002,7 +2950,7 @@ Redis.prototype.pexpire = async function (key, milliseconds) {
 			} else if (typeof connection.execute === 'function') {
 				result = await connection.execute('PEXPIRE', [this._addPrefix(finalKey), finalMilliseconds]);
 			} else {
-				this.logger('error', '连接对象不支持pexpire操作');
+				this.log('error', '连接对象不支持pexpire操作');
 				return false;
 			}
 
@@ -3014,7 +2962,7 @@ Redis.prototype.pexpire = async function (key, milliseconds) {
 			});
 			return result === 1;
 		} catch (err) {
-			this.logger('error', `设置过期时间（毫秒）失败 [${finalKey}]:`, err);
+			this.log('error', `设置过期时间（毫秒）失败 [${finalKey}]:`, err);
 			this.emit('pexpire:error', {
 				key: finalKey,
 				ttl: finalMilliseconds,
@@ -3025,7 +2973,7 @@ Redis.prototype.pexpire = async function (key, milliseconds) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `设置过期时间（毫秒）失败 [${key}]:`, err);
+		this.log('error', `设置过期时间（毫秒）失败 [${key}]:`, err);
 		this.emit('pexpire:error', {
 			key,
 			ttl: milliseconds,
@@ -3046,7 +2994,7 @@ Redis.prototype.persist = async function (key) {
 		this.emit('persist:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `persist操作被事件处理器取消 [${key}]`);
+			this.log('debug', `persist操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -3066,7 +3014,7 @@ Redis.prototype.persist = async function (key) {
 			});
 			return result === 1;
 		} catch (err) {
-			this.logger('error', `移除过期时间失败 [${finalKey}]:`, err);
+			this.log('error', `移除过期时间失败 [${finalKey}]:`, err);
 			this.emit('persist:error', {
 				key: finalKey,
 				error: err
@@ -3076,7 +3024,7 @@ Redis.prototype.persist = async function (key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `移除过期时间失败 [${key}]:`, err);
+		this.log('error', `移除过期时间失败 [${key}]:`, err);
 		this.emit('persist:error', {
 			key,
 			error: err
@@ -3107,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.log('debug', `incr操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3138,7 +3086,7 @@ Redis.prototype.incr = async function (key, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error', `增加整数值失败 [${finalKey}]:`, err);
+			this.log('error', `增加整数值失败 [${finalKey}]:`, err);
 			this.emit('incr:error', {
 				key: finalKey,
 				seconds: finalSeconds,
@@ -3149,7 +3097,7 @@ Redis.prototype.incr = async function (key, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `增加整数值失败 [${key}]:`, err);
+		this.log('error', `增加整数值失败 [${key}]:`, err);
 		this.emit('incr:error', {
 			key,
 			seconds,
@@ -3181,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.log('debug', `decr操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3212,7 +3160,7 @@ Redis.prototype.decr = async function (key, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error', `减少整数值失败 [${finalKey}]:`, err);
+			this.log('error', `减少整数值失败 [${finalKey}]:`, err);
 			this.emit('decr:error', {
 				key: finalKey,
 				seconds: finalSeconds,
@@ -3223,7 +3171,7 @@ Redis.prototype.decr = async function (key, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `减少整数值失败 [${key}]:`, err);
+		this.log('error', `减少整数值失败 [${key}]:`, err);
 		this.emit('decr:error', {
 			key,
 			seconds,
@@ -3260,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.log('debug', `incrbyfloat操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3294,7 +3242,7 @@ Redis.prototype.incrbyfloat = async function (key, increment, seconds = 0) {
 			});
 			return parsedResult;
 		} catch (err) {
-			this.logger('error', `增加浮点数值失败 [${finalKey}]:`, err);
+			this.log('error', `增加浮点数值失败 [${finalKey}]:`, err);
 			this.emit('incrbyfloat:error', {
 				key: finalKey,
 				increment: finalIncrement,
@@ -3306,7 +3254,7 @@ Redis.prototype.incrbyfloat = async function (key, increment, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `增加浮点数值失败 [${key}]:`, err);
+		this.log('error', `增加浮点数值失败 [${key}]:`, err);
 		this.emit('incrbyfloat:error', {
 			key,
 			increment,
@@ -3344,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.log('debug', `incrby操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3377,7 +3325,7 @@ Redis.prototype.incrby = async function (key, increment, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error', `增加指定值失败 [${finalKey}]:`, err);
+			this.log('error', `增加指定值失败 [${finalKey}]:`, err);
 			this.emit('incrby:error', {
 				key: finalKey,
 				increment: finalIncrement,
@@ -3389,7 +3337,7 @@ Redis.prototype.incrby = async function (key, increment, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `增加指定值失败 [${key}]:`, err);
+		this.log('error', `增加指定值失败 [${key}]:`, err);
 		this.emit('incrby:error', {
 			key,
 			increment,
@@ -3427,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.log('debug', `decrby操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3460,7 +3408,7 @@ Redis.prototype.decrby = async function (key, decrement, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error', `减少指定值失败 [${finalKey}]:`, err);
+			this.log('error', `减少指定值失败 [${finalKey}]:`, err);
 			this.emit('decrby:error', {
 				key: finalKey,
 				decrement: finalDecrement,
@@ -3472,7 +3420,7 @@ Redis.prototype.decrby = async function (key, decrement, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `减少指定值失败 [${key}]:`, err);
+		this.log('error', `减少指定值失败 [${key}]:`, err);
 		this.emit('decrby:error', {
 			key,
 			decrement,
@@ -3502,7 +3450,7 @@ Redis.prototype.sadd = async function (key, members) {
 		this.emit('sadd:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `sadd操作被事件处理器取消 [${key}]`);
+			this.log('debug', `sadd操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -3527,7 +3475,7 @@ Redis.prototype.sadd = async function (key, members) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `添加集合成员失败 [${key}]:`, err);
+		this.log('error', `添加集合成员失败 [${key}]:`, err);
 		this.emit('sadd:error', {
 			key,
 			members,
@@ -3554,7 +3502,7 @@ Redis.prototype.srem = async function (key, members) {
 		this.emit('srem:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `srem操作被事件处理器取消 [${key}]`);
+			this.log('debug', `srem操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -3579,7 +3527,7 @@ Redis.prototype.srem = async function (key, members) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `移除集合成员失败 [${key}]:`, err);
+		this.log('error', `移除集合成员失败 [${key}]:`, err);
 		this.emit('srem:error', {
 			key,
 			members,
@@ -3630,7 +3578,7 @@ Redis.prototype.sismember = async function (key, member) {
 			member,
 			error: err
 		});
-		this.logger('error', `检查集合成员失败 [${key}:${member}]:`, err);
+		this.log('error', `检查集合成员失败 [${key}:${member}]:`, err);
 		return false;
 	}
 };
@@ -3655,7 +3603,7 @@ Redis.prototype.smembers = async function (key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取集合所有成员失败 [${key}]:`, err);
+		this.log('error', `获取集合所有成员失败 [${key}]:`, err);
 		this.emit('smembers:error', {
 			key,
 			error: err
@@ -3680,7 +3628,7 @@ Redis.prototype.scard = async function (key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取集合大小失败 [${key}]:`, err);
+		this.log('error', `获取集合大小失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -3702,7 +3650,7 @@ Redis.prototype.sinter = async function (keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取集合交集失败:`, err);
+		this.log('error', `获取集合交集失败:`, err);
 		return [];
 	}
 };
@@ -3724,7 +3672,7 @@ Redis.prototype.sunion = async function (keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取集合并集失败:`, err);
+		this.log('error', `获取集合并集失败:`, err);
 		return [];
 	}
 };
@@ -3746,7 +3694,7 @@ Redis.prototype.sdiff = async function (keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取集合差集失败:`, err);
+		this.log('error', `获取集合差集失败:`, err);
 		return [];
 	}
 };
@@ -3772,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.log('debug', `zadd操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -3802,7 +3750,7 @@ Redis.prototype.zadd = async function (key, score, member) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `添加有序集合成员失败 [${key}]:`, err);
+		this.log('error', `添加有序集合成员失败 [${key}]:`, err);
 		this.emit('zadd:error', {
 			key,
 			score,
@@ -3830,7 +3778,7 @@ Redis.prototype.zrem = async function (key, members) {
 		this.emit('zrem:before', ctx);
 
 		if (ctx.cancel) {
-			this.logger('debug', `zrem操作被事件处理器取消 [${key}]`);
+			this.log('debug', `zrem操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -3852,7 +3800,7 @@ Redis.prototype.zrem = async function (key, members) {
 			});
 			return result;
 		} catch (err) {
-			this.logger('error', `移除有序集合成员失败 [${finalKey}]:`, err);
+			this.log('error', `移除有序集合成员失败 [${finalKey}]:`, err);
 			this.emit('zrem:error', {
 				key: finalKey,
 				members: finalMembers,
@@ -3863,7 +3811,7 @@ Redis.prototype.zrem = async function (key, members) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `移除有序集合成员失败 [${key}]:`, err);
+		this.log('error', `移除有序集合成员失败 [${key}]:`, err);
 		this.emit('zrem:error', {
 			key,
 			members,
@@ -3890,7 +3838,7 @@ Redis.prototype.zscore = async function (key, member) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取有序集合成员分数失败 [${key}:${member}]:`, err);
+		this.log('error', `获取有序集合成员分数失败 [${key}:${member}]:`, err);
 		return null;
 	}
 };
@@ -3912,7 +3860,7 @@ Redis.prototype.zrank = async function (key, member) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取有序集合成员排名失败 [${key}:${member}]:`, err);
+		this.log('error', `获取有序集合成员排名失败 [${key}:${member}]:`, err);
 		return null;
 	}
 };
@@ -3953,13 +3901,13 @@ Redis.prototype.zrange = async function (key, start, stop, withScores = false) {
 								member,
 								score: 0
 							});
-							this.logger('error', `获取成员 ${member} 分数失败:`, scoreErr);
+							this.log('error', `获取成员 ${member} 分数失败:`, scoreErr);
 						}
 					}
 
 					return results;
 				} catch (err) {
-					this.logger('error', `使用备用方法获取有序集合范围失败 [${prefixedKey}]:`, err);
+					this.log('error', `使用备用方法获取有序集合范围失败 [${prefixedKey}]:`, err);
 					// 回退到简单列表
 					return [];
 				}
@@ -3972,7 +3920,7 @@ Redis.prototype.zrange = async function (key, start, stop, withScores = false) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取有序集合范围成员失败 [${key}]:`, err);
+		this.log('error', `获取有序集合范围成员失败 [${key}]:`, err);
 		return [];
 	}
 };
@@ -3990,13 +3938,13 @@ Redis.prototype.zcard = async function (key) {
 			const result = await connection.zCard(this._addPrefix(key));
 			return result || 0;
 		} catch (err) {
-			this.logger('error', `获取有序集合成员数量失败 [${key}]:`, err);
+			this.log('error', `获取有序集合成员数量失败 [${key}]:`, err);
 			return 0;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取有序集合成员数量失败 [${key}]:`, err);
+		this.log('error', `获取有序集合成员数量失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -4033,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.log('debug', `zincrby操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -4069,7 +4017,7 @@ Redis.prototype.zincrby = async function (key, increment, member, seconds = 0) {
 			});
 			return parseFloat(result);
 		} catch (err) {
-			this.logger('error', `增加有序集合成员分数失败 [${finalKey}]:`, err);
+			this.log('error', `增加有序集合成员分数失败 [${finalKey}]:`, err);
 			this.emit('zincrby:error', {
 				key: finalKey,
 				increment: finalIncrement,
@@ -4082,7 +4030,7 @@ Redis.prototype.zincrby = async function (key, increment, member, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `增加有序集合成员分数失败 [${key}]:`, err);
+		this.log('error', `增加有序集合成员分数失败 [${key}]:`, err);
 		this.emit('zincrby:error', {
 			key,
 			increment,
@@ -4116,19 +4064,19 @@ Redis.prototype._createConnection = function () {
 
 			// 监听错误事件
 			connection.on('error', (err) => {
-				this.logger('error', `连接 ${connection.id} 错误:`, err);
+				this.log('error', `连接 ${connection.id} 错误:`, err);
 			});
 
 			// 连接Redis
 			connection.connect().then(() => {
-				// this.logger('debug','新连接已创建并连接:', connection.id);
+				// this.log('debug','新连接已创建并连接:', connection.id);
 				resolve(connection);
 			}).catch(err => {
-				this.logger('error', '创建连接失败:', err);
+				this.log('error', '创建连接失败:', err);
 				reject(err);
 			});
 		} catch (error) {
-			this.logger('error', '创建连接时发生异常:', error);
+			this.log('error', '创建连接时发生异常:', error);
 			reject(error);
 		}
 	});