mm_redis 2.0.9 → 2.1.1

package/index.js

@@ -8,38 +8,36 @@ const { Base } = require('mm_expand');
  * @description Redis缓存帮助类函数
  */
 class Redis extends Base {
+	static config = {
+		// 服务器地址
+		"host": "localhost",
+		// 端口号
+		"port": 6379,
+		// 密码
+		"password": "asd159357",
+		// 数据库
+		"database": 0,
+		// 前缀
+		"prefix": "",
+		// 连接超时时间(ms)
+		"connect_timeout": 10000,
+		// 重试次数
+		"retry_count": 3,
+		// 重试间隔(ms)
+		"retry_delay": 1000,
+		// 连接池配置
+		"max_clients": 100, // 最大连接数
+		"min_idle": 5, // 最小空闲连接数
+		"max_idle": 20, // 最大空闲连接数
+		"idle_timeout": 30000 // 空闲超时时间(ms)
+	};
 	/**
 	 * @description 创建Redis帮助类函数 (构造函数)
 	 * @param {Object} config 配置参数
 	 * @constructor
 	 */
 	constructor(config) {
-		super();
-		// 配置参数
-		this.config = {
-			// 服务器地址
-			"host": "localhost",
-			// 端口号
-			"port": 6379,
-			// 密码
-			"password": "asd159357",
-			// 数据库
-			"database": 0,
-			// 前缀
-			"prefix": "",
-			// 连接超时时间(ms)
-			"connect_timeout": 10000,
-			// 重试次数
-			"retry_count": 3,
-			// 重试间隔(ms)
-			"retry_delay": 1000,
-			// 连接池配置
-			"max_clients": 100, // 最大连接数
-			"min_idle": 5, // 最小空闲连接数
-			"max_idle": 20, // 最大空闲连接数
-			"idle_timeout": 30000 // 空闲超时时间(ms)
-		};
-		this.setConfig(config);
+		super(Redis.config);
 		// 初始化连接池
 		this._initPool();
 		// 唯一标识符
@@ -52,6 +50,7 @@ class Redis extends Base {
 		this.retry_count = 0;
 		// 订阅回调函数
 		this.func_list = {};
+		this.setConfig(config);
 	}
 }
 
@@ -98,7 +97,7 @@ Redis.prototype.subscribe = async function (channel, func) {
 		this.func_list[channel] = func;
 		return true;
 	} catch (err) {
-		this.logger('error', `订阅频道 ${channel} 失败:`, err);
+		this.log('error', `订阅频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -119,7 +118,7 @@ Redis.prototype.unsubscribe = async function (channel) {
 		delete this.func_list[channel];
 		return true;
 	} catch (err) {
-		this.logger('error', `取消订阅频道 ${channel} 失败:`, err);
+		this.log('error', `取消订阅频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -142,7 +141,7 @@ Redis.prototype.publish = async function (channel, message) {
 	try {
 		return await this.conn.publish(this._addPrefix(channel), message);
 	} catch (err) {
-		this.logger('error', `发布消息到频道 ${channel} 失败:`, err);
+		this.log('error', `发布消息到频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -154,7 +153,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);
 };
 
 /**
@@ -170,7 +169,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);
@@ -194,7 +193,7 @@ Redis.prototype.setConfig = function (config) {
 
 	// 初始化连接池
 	this._initPool();
-	// this.logger('debug','配置已更新');
+	// this.log('debug','配置已更新');
 	this.identifier = this.config.host + "/" + this.config.database;
 	return this;
 };
@@ -211,7 +210,7 @@ Redis.prototype._initPool = function () {
 	};
 
 	// 记录连接池初始化
-	// this.logger('debug','连接池已初始化，配置:', this.config);
+	// this.log('debug','连接池已初始化，配置:', this.config);
 };
 
 /**
@@ -240,7 +239,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();
@@ -248,25 +247,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}`);
 		});
 
 		// 收到消息后执行回调
@@ -279,7 +278,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;
@@ -292,18 +291,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);
 };
@@ -315,7 +314,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) {
@@ -323,7 +322,7 @@ Redis.prototype.close = function () {
 				try {
 					connection.close();
 				} catch (e) {
-					this.logger('error', '关闭连接失败:', e);
+					this.log('error', '关闭连接失败:', e);
 				}
 			}
 			this.connection_pool.in_use.clear();
@@ -340,20 +339,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);
 	}
 };
@@ -480,7 +479,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);
 					}
 				}
@@ -489,7 +488,7 @@ Redis.prototype.pipeline = function () {
 				redisInstance._recycleConnection(connection);
 				return results;
 			} catch (error) {
-				this.logger('error', 'Pipeline执行失败:', error);
+				this.log('error', 'Pipeline执行失败:', error);
 				return [];
 			}
 		}
@@ -536,7 +535,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;
 				}
 			}
@@ -547,14 +546,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;
 	}
 };
@@ -588,7 +587,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;
 		}
 
@@ -611,7 +610,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) {
@@ -629,7 +628,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) {
@@ -670,7 +669,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;
 	}
@@ -708,7 +707,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;
 		}
 
@@ -734,7 +733,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) {
@@ -765,7 +764,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) {
@@ -794,7 +793,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;
 	}
@@ -831,7 +830,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;
 		}
 
@@ -857,7 +856,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);
@@ -883,7 +882,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;
@@ -909,7 +908,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;
 	}
 };
@@ -952,7 +951,7 @@ Redis.prototype.del = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `del操作被事件处理器取消 [${key}]`);
+			this.log('debug', `del操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1005,7 +1004,7 @@ Redis.prototype.del = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `删除缓存失败 [${key}]:`, err);
+		this.log('error', `删除缓存失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1042,7 +1041,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;
 		}
 
@@ -1080,7 +1079,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,
@@ -1120,7 +1119,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;
 		}
 
@@ -1160,7 +1159,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,
@@ -1198,7 +1197,7 @@ Redis.prototype.get = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回null
 		if (ctx.cancel) {
-			this.logger('debug', `get操作被事件处理器取消 [${key}]`);
+			this.log('debug', `get操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -1239,7 +1238,7 @@ Redis.prototype.get = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `获取缓存失败 [${key}]:`, err);
+		this.log('error', `获取缓存失败 [${key}]:`, err);
 		return null;
 	}
 };
@@ -1265,7 +1264,7 @@ Redis.prototype.has = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `has操作被事件处理器取消 [${key}]`);
+			this.log('debug', `has操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1295,7 +1294,7 @@ Redis.prototype.has = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `检查键是否存在失败 [${key}]:`, err);
+		this.log('error', `检查键是否存在失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1338,7 +1337,7 @@ Redis.prototype.exists = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回0
 		if (ctx.cancel) {
-			this.logger('debug', `exists操作被事件处理器取消 [${key}]`);
+			this.log('debug', `exists操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1373,7 +1372,7 @@ Redis.prototype.exists = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `检查键存在性失败 [${key}]:`, err);
+		this.log('error', `检查键存在性失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1392,7 +1391,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') {
@@ -1403,7 +1402,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 '';
 	}
 };
@@ -1439,7 +1438,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;
 		}
 
@@ -1465,7 +1464,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) {
 					// 填充空格到指定索引
@@ -1486,7 +1485,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) {
@@ -1516,7 +1515,7 @@ Redis.prototype.setrange = async function (key, index, value) {
 			value,
 			error: err
 		});
-		this.logger('error', `设置字符串范围失败 [${key}]:`, err);
+		this.log('error', `设置字符串范围失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1537,7 +1536,7 @@ Redis.prototype.clear = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `clear操作被事件处理器取消`);
+			this.log('debug', `clear操作被事件处理器取消`);
 			return false;
 		}
 
@@ -1561,7 +1560,7 @@ Redis.prototype.clear = async function (key) {
 					await connection.execute('FLUSHDB');
 					success = true;
 				} else {
-					this.logger('error', '连接对象不支持flushDb操作');
+					this.log('error', '连接对象不支持flushDb操作');
 					success = false;
 				}
 			}
@@ -1581,7 +1580,7 @@ Redis.prototype.clear = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', '清空缓存失败:', err);
+		this.log('error', '清空缓存失败:', err);
 		return false;
 	}
 };
@@ -1625,7 +1624,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) => {
@@ -1639,7 +1638,7 @@ Redis.prototype.sort = async function (key, options = {}) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `排序失败 [${key}]:`, err);
+		this.log('error', `排序失败 [${key}]:`, err);
 		return [];
 	}
 };
@@ -1662,7 +1661,7 @@ Redis.prototype.keys = async function (pattern = '*') {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', '获取键列表失败:', err);
+		this.log('error', '获取键列表失败:', err);
 		return [];
 	}
 };
@@ -1687,7 +1686,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;
 		}
 
@@ -1717,7 +1716,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;
 					}
 				}
@@ -1728,7 +1727,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;
 				}
 			}
@@ -1739,7 +1738,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操作');
 				}
 			}
 
@@ -1762,7 +1761,7 @@ Redis.prototype.setForList = async function (key, value, seconds) {
 			value,
 			error: err
 		});
-		this.logger('error', `设置列表失败 [${key}]:`, err);
+		this.log('error', `设置列表失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1787,7 +1786,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;
 		}
 
@@ -1811,7 +1810,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;
 					}
 				}
@@ -1822,7 +1821,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;
 				}
 			}
@@ -1833,7 +1832,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操作');
 				}
 			}
 
@@ -1856,7 +1855,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;
 	}
 };
@@ -1884,7 +1883,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;
 	}
 };
@@ -1909,7 +1908,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 [];
 		}
 
@@ -1934,12 +1933,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 [];
 			}
 
@@ -1979,7 +1978,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 [];
 	}
 };
@@ -2004,7 +2003,7 @@ Redis.prototype.clearForList = async function (key) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `clearForList操作被事件处理器取消 [${key}]`);
+			this.log('debug', `clearForList操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2028,7 +2027,7 @@ Redis.prototype.clearForList = async function (key) {
 			key,
 			error: err
 		});
-		this.logger('error', `清空列表失败 [${key}]:`, err);
+		this.log('error', `清空列表失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -2066,7 +2065,7 @@ Redis.prototype.mget = async function (keys) {
 
 		// 如果事件处理器标记为取消，则返回空数组
 		if (ctx.cancel) {
-			this.logger('debug', `mget操作被事件处理器取消 [${keys}]`);
+			this.log('debug', `mget操作被事件处理器取消 [${keys}]`);
 			return [];
 		}
 
@@ -2112,7 +2111,7 @@ Redis.prototype.mget = async function (keys) {
 			keys,
 			error: err
 		});
-		this.logger('error', `批量获取缓存失败 [${keys}]:`, err);
+		this.log('error', `批量获取缓存失败 [${keys}]:`, err);
 		return [];
 	}
 }
@@ -2135,7 +2134,7 @@ Redis.prototype.mset = async function (obj, seconds = 0) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `mset操作被事件处理器取消`);
+			this.log('debug', `mset操作被事件处理器取消`);
 			return false;
 		}
 
@@ -2181,7 +2180,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 = [];
@@ -2219,7 +2218,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);
@@ -2250,7 +2249,7 @@ Redis.prototype.hdel = async function (key, fields) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `hdel操作被事件处理器取消 [${key}]`);
+			this.log('debug', `hdel操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2275,7 +2274,7 @@ Redis.prototype.hdel = async function (key, fields) {
 			} else if (typeof connection.execute === 'function') {
 				deletedCount = await connection.execute('HDEL', [finalKey, ...finalFields]);
 			} else {
-				this.logger('error', '连接对象不支持hDel操作');
+				this.log('error', '连接对象不支持hDel操作');
 				deletedCount = 0;
 			}
 
@@ -2296,7 +2295,7 @@ Redis.prototype.hdel = async function (key, fields) {
 			value: fields,
 			error: err
 		});
-		this.logger('error', `删除哈希字段失败 [${key}]:`, err);
+		this.log('error', `删除哈希字段失败 [${key}]:`, err);
 		return 0; // 与Redis语义保持一致，返回删除的字段数量
 	}
 };
@@ -2316,7 +2315,7 @@ Redis.prototype.hlen = async function (key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取哈希字段数量失败 [${key}]:`, err);
+		this.log('error', `获取哈希字段数量失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -2430,7 +2429,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;
 				}
 
@@ -2470,7 +2469,7 @@ Redis.prototype.clearExpire = async function () {
 		this.emit('clearExpire:error', {
 			error: err
 		});
-		this.logger('error', '清空过期数据失败:', err);
+		this.log('error', '清空过期数据失败:', err);
 		return false;
 	}
 };
@@ -2499,14 +2498,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);
 		}
 	});
@@ -2529,15 +2528,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);
 	}
 };
 
@@ -2566,7 +2565,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;
 		}
 
@@ -2599,7 +2598,7 @@ Redis.prototype.hset = async function (key, field, value) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `设置哈希字段失败 [${key}:${field}]:`, err);
+		this.log('error', `设置哈希字段失败 [${key}:${field}]:`, err);
 		// 触发错误事件
 		this.emit('hset:error', {
 			key,
@@ -2641,7 +2640,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;
 	}
 };
@@ -2664,7 +2663,7 @@ Redis.prototype.hmset = async function (key, obj) {
 
 		// 如果事件处理器标记为取消，则返回false
 		if (ctx.cancel) {
-			this.logger('debug', `hmset操作被事件处理器取消 [${key}]`);
+			this.log('debug', `hmset操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2679,20 +2678,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;
 			}
 
@@ -2704,10 +2703,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;
 					}
@@ -2716,19 +2715,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;
 						}
 					}
@@ -2746,7 +2745,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,
@@ -2771,14 +2770,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 {};
 	}
 };
@@ -2828,8 +2827,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);
 			}
@@ -2842,7 +2841,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);
 	}
@@ -2864,7 +2863,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;
 		}
 
@@ -2886,7 +2885,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,
@@ -2897,7 +2896,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,
@@ -2932,7 +2931,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;
 		}
 
@@ -2950,7 +2949,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;
 			}
 
@@ -2962,7 +2961,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,
@@ -2973,7 +2972,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,
@@ -2994,7 +2993,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;
 		}
 
@@ -3014,7 +3013,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
@@ -3024,7 +3023,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
@@ -3055,7 +3054,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;
 		}
 
@@ -3086,7 +3085,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,
@@ -3097,7 +3096,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,
@@ -3129,7 +3128,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;
 		}
 
@@ -3160,7 +3159,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,
@@ -3171,7 +3170,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,
@@ -3208,7 +3207,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;
 		}
 
@@ -3242,7 +3241,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,
@@ -3254,7 +3253,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,
@@ -3292,7 +3291,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;
 		}
 
@@ -3325,7 +3324,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,
@@ -3337,7 +3336,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,
@@ -3375,7 +3374,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;
 		}
 
@@ -3408,7 +3407,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,
@@ -3420,7 +3419,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,
@@ -3450,7 +3449,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;
 		}
 
@@ -3475,7 +3474,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,
@@ -3502,7 +3501,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;
 		}
 
@@ -3527,7 +3526,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,
@@ -3578,7 +3577,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;
 	}
 };
@@ -3603,7 +3602,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
@@ -3628,7 +3627,7 @@ Redis.prototype.scard = async function (key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取集合大小失败 [${key}]:`, err);
+		this.log('error', `获取集合大小失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -3650,7 +3649,7 @@ Redis.prototype.sinter = async function (keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取集合交集失败:`, err);
+		this.log('error', `获取集合交集失败:`, err);
 		return [];
 	}
 };
@@ -3672,7 +3671,7 @@ Redis.prototype.sunion = async function (keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取集合并集失败:`, err);
+		this.log('error', `获取集合并集失败:`, err);
 		return [];
 	}
 };
@@ -3694,7 +3693,7 @@ Redis.prototype.sdiff = async function (keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.logger('error', `获取集合差集失败:`, err);
+		this.log('error', `获取集合差集失败:`, err);
 		return [];
 	}
 };
@@ -3720,7 +3719,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;
 		}
 
@@ -3750,7 +3749,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,
@@ -3778,7 +3777,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;
 		}
 
@@ -3800,7 +3799,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,
@@ -3811,7 +3810,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,
@@ -3838,7 +3837,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;
 	}
 };
@@ -3860,7 +3859,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;
 	}
 };
@@ -3901,13 +3900,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 [];
 				}
@@ -3920,7 +3919,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 [];
 	}
 };
@@ -3938,13 +3937,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;
 	}
 };
@@ -3981,7 +3980,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;
 		}
 
@@ -4017,7 +4016,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,
@@ -4030,7 +4029,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,
@@ -4064,26 +4063,24 @@ 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);
 		}
 	});
 };
 
-// 修改导出方式以支持多种导入格式
-exports.Redis = Redis;
 
 /**
  * 确保连接池对象存在
@@ -4113,7 +4110,7 @@ function redisAdmin(scope, config) {
 	return obj;
 }
 
-/**
- * @module 导出Redis管理器
- */
-exports.redisAdmin = redisAdmin;
+module.exports = {
+	Redis,
+	redisAdmin
+};