mm_redis 2.0.6 → 2.0.7

package/index.js

@@ -3,18 +3,16 @@
  * @author <a href="http://qww.elins.cn">邱文武</a>
  * @version 1.5.0
  */
-const {
-	BaseService
-} = require('mm_base_service');
 const {
 	createClient
 } = require('redis');
+const {Event} = require('mm_expand');
 
 // Redis缓存帮助类函数
 
 /* 创建Redis帮助类函数 */
 /// 构造函数
-class Redis extends BaseService {
+class Redis extends Event {
 	/**
 	 * @description 创建Redis帮助类函数 (构造函数)
 	 * @param {Object} config 配置参数
@@ -97,7 +95,7 @@ Redis.prototype.subscribe = async function(channel, func) {
 		this.func_list[channel] = func;
 		return true;
 	} catch (err) {
-		$.log.error(`[Redis] 订阅频道 ${channel} 失败:`, err);
+		this.logger('error',`订阅频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -113,7 +111,7 @@ Redis.prototype.unsubscribe = async function(channel) {
 		delete this.func_list[channel];
 		return true;
 	} catch (err) {
-		$.log.error(`[Redis] 取消订阅频道 ${channel} 失败:`, err);
+		this.logger('error',`取消订阅频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -128,8 +126,7 @@ Redis.prototype.publish = async function(channel, message) {
 	try {
 		return await this.conn.publish(this.applyPrefix(channel), message);
 	} catch (err) {
-		$.log.error(`[Redis] 发布消息到频道 ${channel} 失败:`, err);
-		$.log.error('[Redis] 操作失败:', err);
+		this.logger('error',`发布消息到频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -141,7 +138,7 @@ Redis.prototype.publish = async function(channel, message) {
  */
 Redis.prototype.main = async function(channel, message) {
 	// 默认实现，可由子类重写
-	$.log.debug(`[Redis] 收到未处理的消息 [${channel}]:`, message);
+	this.logger('debug',`收到未处理的消息 [${channel}]:`, message);
 };
 
 /**
@@ -157,7 +154,7 @@ Redis.prototype.message = function(channel, message) {
 		try {
 			func(message);
 		} catch (err) {
-			$.log.error(`[Redis] 处理频道 ${channel} 的消息时出错:`, err);
+			this.logger('error',`处理频道 ${channel} 的消息时出错:`, err);
 		}
 	} else {
 		this.main(channel, message);
@@ -219,7 +216,7 @@ Redis.prototype.setConfig = function(config) {
 
 	// 初始化连接池
 	this._initPool();
-	// $.log.debug('[Redis] 配置已更新');
+	// this.logger('debug','配置已更新');
 	this.identifier = this.config.host + "/" + this.config.database;
 	return this;
 };
@@ -244,7 +241,7 @@ Redis.prototype._initPool = function() {
 	};
 
 	// 记录连接池初始化
-	// $.log.debug('[Redis] 连接池已初始化，配置:', this.config.pool);
+	// this.logger('debug','连接池已初始化，配置:', this.config.pool);
 };
 
 /**
@@ -273,7 +270,7 @@ Redis.prototype.open = async function() {
 
 		// 监听错误事件
 		this.conn.on('error', (err) => {
-			$.log.error('[Redis] Redis连接错误:', err);
+			this.logger('error','Redis连接错误:', err);
 			this.connected = false;
 			// 尝试重连
 			this._reconnect();
@@ -281,25 +278,25 @@ Redis.prototype.open = async function() {
 
 		// 监听连接成功事件
 		this.conn.on('connect', () => {
-			// $.log.debug('[Redis] Redis已连接');
+			// this.logger('debug','Redis已连接');
 			this.connected = true;
 			this.retry_count = 0;
 		});
 
 		// 监听断开连接事件
 		this.conn.on('end', () => {
-			// $.log.debug('[Redis] Redis连接已断开');
+			// this.logger('debug','Redis连接已断开');
 			this.connected = false;
 		});
 
 		// 监听订阅成功事件
 		this.conn.on('subscribe', (channel, count) => {
-			$.log.debug(`[Redis] 频道${this.removePrefix(channel)}订阅成功, 当前总计订阅数：${count}`);
+			this.logger('debug',`频道${this.removePrefix(channel)}订阅成功, 当前总计订阅数：${count}`);
 		});
 
 		// 监听取消订阅事件
 		this.conn.on('unsubscribe', (channel, count) => {
-			$.log.debug(`[Redis] 频道${this.removePrefix(channel)}取消订阅, 当前总计订阅数：${count}`);
+			this.logger('debug',`频道${this.removePrefix(channel)}取消订阅, 当前总计订阅数：${count}`);
 		});
 
 		// 收到消息后执行回调
@@ -312,7 +309,7 @@ Redis.prototype.open = async function() {
 		this.connected = true;
 		return true;
 	} catch (err) {
-		$.log.error('[Redis] Redis连接失败:', err);
+		this.logger('error','Redis连接失败:', err);
 		// 尝试重连
 		this._reconnect();
 		return false;
@@ -325,18 +322,18 @@ Redis.prototype.open = async function() {
  */
 Redis.prototype._reconnect = function() {
 	if (this.retry_count >= this.config.retry_count) {
-		$.log.error(`[Redis] 达到最大重连次数 ${this.config.retry_count}，停止重连`);
+		this.logger('error',`达到最大重连次数 ${this.config.retry_count}，停止重连`);
 		return;
 	}
 
 	this.retry_count++;
-	$.log.debug(`[Redis] 尝试第 ${this.retry_count} 次重连...`);
+	this.logger('debug',`尝试第 ${this.retry_count} 次重连...`);
 
 	setTimeout(async () => {
 		try {
 			await this.open();
 		} catch (err) {
-			$.log.error(`[Redis] 重连失败:`, err);
+			this.logger('error',`重连失败:`, err);
 		}
 	}, this.config.retry_delay);
 };
@@ -348,7 +345,7 @@ Redis.prototype._reconnect = function() {
 // 修复close方法，正确处理连接池
 Redis.prototype.close = function() {
 	try {
-		// $.log.debug('[Redis] 关闭所有连接...');
+		// this.logger('debug','关闭所有连接...');
 
 		// 关闭所有使用中的连接
 		if (this.connection_pool && this.connection_pool.in_use) {
@@ -356,7 +353,7 @@ Redis.prototype.close = function() {
 				try {
 					connection.close();
 				} catch (e) {
-					$.log.error('[Redis] 关闭连接失败:', e);
+					this.logger('error','关闭连接失败:', e);
 				}
 			}
 			this.connection_pool.in_use.clear();
@@ -373,20 +370,20 @@ Redis.prototype.close = function() {
 						// 某些Redis客户端可能使用end方法
 						connection.end();
 					} else {
-						$.log.debug('[Redis] 连接对象没有可用的关闭方法');
+						this.logger('debug','连接对象没有可用的关闭方法');
 					}
 				} catch (e) {
-					$.log.error('[Redis] 关闭连接失败:', e);
+					this.logger('error','关闭连接失败:', e);
 				}
 			}
 			this.connection_pool.available = [];
 		}
 
 		this.connected = false;
-		$.log.debug('[Redis] Redis连接已断开');
+		this.logger('debug','Redis连接已断开');
 		return Promise.resolve(true);
 	} catch (error) {
-		$.log.error('[Redis] 关闭连接时发生错误:', error);
+		this.logger('error','关闭连接时发生错误:', error);
 		return Promise.resolve(false);
 	}
 };
@@ -513,7 +510,7 @@ Redis.prototype.pipeline = function() {
 						// 直接返回结果值，符合测试期望的格式
 						results.push(result);
 					} catch (err) {
-						$.log.error(`[Redis] Pipeline命令执行失败 [${cmd[0]}]:`, err);
+						this.logger('error',`Pipeline命令执行失败 [${cmd[0]}]:`, err);
 						results.push(null);
 					}
 				}
@@ -522,7 +519,7 @@ Redis.prototype.pipeline = function() {
 				redisInstance._recycleConnection(connection);
 				return results;
 			} catch (error) {
-				$.log.error('[Redis] Pipeline执行失败:', error);
+				this.logger('error','Pipeline执行失败:', error);
 				return [];
 			}
 		}
@@ -569,7 +566,7 @@ Redis.prototype.ttl = async function(key, seconds) {
 					await connection.execute('EXPIRE', [key, seconds]);
 					return true;
 				} else {
-					$.log.error('[Redis] 连接对象不支持expire操作');
+					this.logger('error','连接对象不支持expire操作');
 					return false;
 				}
 			}
@@ -580,14 +577,14 @@ Redis.prototype.ttl = async function(key, seconds) {
 			} else if (typeof connection.execute === 'function') {
 				return await connection.execute('TTL', [key]);
 			} else {
-				$.log.error('[Redis] 连接对象不支持ttl操作');
+				this.logger('error','连接对象不支持ttl操作');
 				return -2; // 默认返回键不存在
 			}
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] ${seconds !== undefined ? '设置' : '获取'}过期时间失败 [${key}]:`, err);
+		this.logger('error',`${seconds !== undefined ? '设置' : '获取'}过期时间失败 [${key}]:`, err);
 		return seconds !== undefined ? false : -2;
 	}
 };
@@ -603,26 +600,26 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
+			this.logger('error','参数错误: 键必须是非空字符串');
 			return false;
 		}
 		if (typeof num !== 'number' || isNaN(num) || !Number.isInteger(num)) {
-			$.log.error('[Redis] 参数错误: 数值必须是有效整数');
+			this.logger('error','参数错误: 数值必须是有效整数');
 			return false;
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			value: num,
 			seconds,
 			cancel: false
 		};
-		this.emit('addInt_before', beforeEventData);
+		this.emit('addInt:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回false
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] addInt操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`addInt操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -631,7 +628,7 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
 			key: finalKey,
 			value: finalNum,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -645,7 +642,7 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
 					result = await connection.execute('INCRBY', [prefixedKey, finalNum]);
 				} else {
 					// 如果出错，回退到先获取再设置的方式
-					$.log.warn(`[Redis] 使用原子操作增加整数值失败，使用回退方案`);
+					throw new Error(`使用原子操作增加整数值失败，使用回退方案`);
 					let value = await this.get(prefixedKey);
 					let n = 0;
 					if (value) {
@@ -663,7 +660,7 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
 					result = await connection.execute('DECRBY', [prefixedKey, -finalNum]);
 				} else {
 					// 如果出错，回退到先获取再设置的方式
-					$.log.warn(`[Redis] 使用原子操作减少整数值失败，使用回退方案`);
+					throw new Error(`使用原子操作减少整数值失败，使用回退方案`);
 					let value = await this.get(prefixedKey);
 					let n = 0;
 					if (value) {
@@ -685,7 +682,7 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
 			}
 
 			// 触发后置事件
-			this.emit('addInt_after', {
+			this.emit('addInt:after', {
 				key: finalKey,
 				value: finalNum,
 				seconds: finalSeconds,
@@ -698,13 +695,13 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('addInt_error', {
+		this.emit('addInt:error', {
 			key,
 			value: num,
 			seconds,
 			error: err
 		});
-		$.log.error(`[Redis] 增加整数值失败 [${key}]:`, err);
+		this.logger('error',`增加整数值失败 [${key}]:`, err);
 		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
 		return 0;
 	}
@@ -721,29 +718,29 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.warn(`[Redis] addFloat: key参数必须是非空字符串`);
+			throw new Error(`addFloat: key参数必须是非空字符串`);
 			return 0;
 		}
 
 		// 验证num参数
 		num = parseFloat(num);
 		if (isNaN(num)) {
-			$.log.warn(`[Redis] addFloat: num参数必须是有效的数值`);
+			throw new Error(`addFloat: num参数必须是有效的数值`);
 			return 0;
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			value: num,
 			seconds,
 			cancel: false
 		};
-		this.emit('addFloat_before', beforeEventData);
+		this.emit('addFloat:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回默认值
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] addFloat操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`addFloat操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -752,7 +749,7 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 			key: finalKey,
 			value: finalNum,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 		let result;
 
 		const connection = await this._getConnection();
@@ -769,7 +766,7 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 			}
 			// 回退方案
 			else {
-				$.log.warn(`[Redis] 连接对象不支持incrByFloat操作，使用回退方案`);
+				throw new Error(`连接对象不支持incrByFloat操作，使用回退方案`);
 				let value = await this.get(prefixedKey);
 				let n = 0;
 				if (value) {
@@ -790,7 +787,7 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 			}
 
 			// 触发后置事件
-			this.emit('addFloat_after', {
+			this.emit('addFloat:after', {
 				key: finalKey,
 				value: finalNum,
 				seconds: finalSeconds,
@@ -800,7 +797,7 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 			return result;
 		} catch (err) {
 			// 如果出错，回退到先获取再设置的方式
-			$.log.warn(`[Redis] 使用原子操作增加浮点数值失败，使用回退方案:`, err);
+			throw new Error(`使用原子操作增加浮点数值失败，使用回退方案:`, err);
 			let value = await this.get(prefixedKey);
 			let n = 0;
 			if (value) {
@@ -810,7 +807,7 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 			await this.set(prefixedKey, n, finalSeconds);
 
 			// 触发后置事件
-			this.emit('addFloat_after', {
+			this.emit('addFloat:after', {
 				key: finalKey,
 				value: finalNum,
 				seconds: finalSeconds,
@@ -823,13 +820,13 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('addFloat_error', {
+		this.emit('addFloat:error', {
 			key,
 			value: num,
 			seconds,
 			error: err
 		});
-		$.log.error(`[Redis] 增加浮点数值失败 [${key}]:`, err);
+		this.logger('error',`增加浮点数值失败 [${key}]:`, err);
 		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
 		return 0;
 	}
@@ -846,29 +843,29 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.warn(`[Redis] addStr: key参数必须是非空字符串`);
+			throw new Error(`addStr: key参数必须是非空字符串`);
 			return 0;
 		}
 
 		// 验证str参数
 		if (str === undefined || str === null) {
-			$.log.warn(`[Redis] addStr: str参数不能为undefined或null`);
+			throw new Error(`addStr: str参数不能为undefined或null`);
 			return 0;
 		}
 		str = String(str);
 
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			value: str,
 			seconds,
 			cancel: false
 		};
-		this.emit('addStr_before', beforeEventData);
+		this.emit('addStr:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回0
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] addStr操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`addStr操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -877,7 +874,7 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
 			key: finalKey,
 			value: finalStr,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 		let result;
 
 		const connection = await this._getConnection();
@@ -894,7 +891,7 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
 			}
 			// 回退方案
 			else {
-				$.log.warn(`[Redis] 连接对象不支持append操作，使用回退方案`);
+				throw new Error(`连接对象不支持append操作，使用回退方案`);
 				let value = await this.get(prefixedKey) || '';
 				value += finalStr;
 				await this.set(prefixedKey, value, finalSeconds);
@@ -911,7 +908,7 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
 			}
 
 			// 触发后置事件
-			this.emit('addStr_after', {
+			this.emit('addStr:after', {
 				key: finalKey,
 				value: finalStr,
 				seconds: finalSeconds,
@@ -920,14 +917,14 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			$.log.error('[Redis] 追加字符串失败:', err);
+			this.logger('error','追加字符串失败:', err);
 			// 回退方案：先获取再设置
 			let value = await this.get(prefixedKey) || '';
 			value += finalStr;
 			await this.set(prefixedKey, value, finalSeconds);
 
 			// 触发后置事件
-			this.emit('addStr_after', {
+			this.emit('addStr:after', {
 				key: finalKey,
 				value: finalStr,
 				seconds: finalSeconds,
@@ -940,13 +937,13 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('addStr_error', {
+		this.emit('addStr:error', {
 			key,
 			value: str,
 			seconds,
 			error: err
 		});
-		$.log.error(`[Redis] 追加字符串失败 [${key}]:`, err);
+		this.logger('error',`追加字符串失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -960,14 +957,14 @@ Redis.prototype.del = async function(key) {
 	try {
 		// 键名必须是非空字符串或非空字符串数组
 		if (!key) {
-			$.log.warn('[Redis] del: key必须是非空字符串或非空字符串数组');
+			throw new Error('del: key必须是非空字符串或非空字符串数组');
 			return false;
 		}
 
 		// 如果是单个键，验证是否为非空字符串
 		if (typeof key === 'string') {
 			if (!key) {
-				$.log.warn('[Redis] del: key必须是非空字符串');
+				throw new Error('del: key必须是非空字符串');
 				return false;
 			}
 		}
@@ -975,32 +972,32 @@ Redis.prototype.del = async function(key) {
 		else if (Array.isArray(key)) {
 			for (const k of key) {
 				if (!k || typeof k !== 'string') {
-					$.log.warn('[Redis] del: key必须是非空字符串或非空字符串数组');
+					throw new Error('del: key必须是非空字符串或非空字符串数组');
 					return false;
 				}
 			}
 		} else {
-			$.log.warn('[Redis] del: key必须是非空字符串或非空字符串数组');
+			throw new Error('del: key必须是非空字符串或非空字符串数组');
 			return false;
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			cancel: false
 		};
-		this.emit('del_before', beforeEventData);
+		this.emit('del:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回false
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] del操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`del操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
 		// 使用可能被修改的值
 		let {
 			key: finalKey
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -1019,7 +1016,7 @@ Redis.prototype.del = async function(key) {
 					}
 				}
 				// 触发后置事件
-				this.emit('del_after', {
+				this.emit('del:after', {
 					key: finalKey,
 					success,
 					deleted
@@ -1030,7 +1027,7 @@ Redis.prototype.del = async function(key) {
 				const n = await connection.del(prefixedKey);
 				success = n === 1;
 				// 触发后置事件
-				this.emit('del_after', {
+				this.emit('del:after', {
 					key: finalKey,
 					success,
 					deleted: success ? [finalKey] : []
@@ -1042,11 +1039,11 @@ Redis.prototype.del = async function(key) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('del_error', {
+		this.emit('del:error', {
 			key,
 			error: err
 		});
-		$.log.error(`[Redis] 删除缓存失败 [${key}]:`, err);
+		this.logger('error',`删除缓存失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1069,22 +1066,22 @@ Redis.prototype.set = async function(key, value, seconds = 0) {
 	try {
 		// 键名必须是非空字符串
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: key必须是非空字符串');
+			this.logger('error','参数错误: key必须是非空字符串');
 			return false;
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			value,
 			seconds,
 			cancel: false
 		};
-		this.emit('set_before', beforeEventData);
+		this.emit('set:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回false
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] set操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`set操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1093,7 +1090,7 @@ Redis.prototype.set = async function(key, value, seconds = 0) {
 			key: finalKey,
 			value: finalValue,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -1111,7 +1108,7 @@ Redis.prototype.set = async function(key, value, seconds = 0) {
 			}
 
 			// 触发后置事件
-			this.emit('set_after', {
+			this.emit('set:after', {
 				key,
 				value,
 				seconds,
@@ -1122,9 +1119,9 @@ Redis.prototype.set = async function(key, value, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 设置缓存失败 [${key}]:`, err);
+		this.logger('error',`设置缓存失败 [${key}]:`, err);
 		// 触发错误事件
-		this.emit('set_error', {
+		this.emit('set:error', {
 			key,
 			value,
 			seconds,
@@ -1144,17 +1141,17 @@ Redis.prototype.set = async function(key, value, seconds = 0) {
 Redis.prototype.add = async function(key, value, seconds) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			value,
 			ttl: seconds,
 			cancel: false
 		};
-		this.emit('add_before', beforeEventData);
+		this.emit('add:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回false
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] add操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`add操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -1163,7 +1160,7 @@ Redis.prototype.add = async function(key, value, seconds) {
 			key: finalKey,
 			value: finalValue,
 			ttl: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -1183,7 +1180,7 @@ Redis.prototype.add = async function(key, value, seconds) {
 			const success = result === "OK";
 
 			// 触发后置事件
-			this.emit('add_after', {
+			this.emit('add:after', {
 				key: finalKey,
 				value: finalValue,
 				ttl: finalSeconds,
@@ -1194,9 +1191,9 @@ Redis.prototype.add = async function(key, value, seconds) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 添加缓存失败 [${key}]:`, err);
+		this.logger('error',`添加缓存失败 [${key}]:`, err);
 		// 触发错误事件
-		this.emit('add_error', {
+		this.emit('add:error', {
 			key,
 			value,
 			ttl: seconds,
@@ -1220,25 +1217,25 @@ Redis.prototype.get = async function(key) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.warn(`[Redis] get: key参数必须是非空字符串`);
+			throw new Error(`get: key参数必须是非空字符串`);
 			return null;
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			cancel: false
 		};
-		this.emit('get_before', beforeEventData);
+		this.emit('get:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回null
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] get操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`get操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
 		// 使用可能被修改的值
-		const finalKey = beforeEventData.key;
+		const finalKey = ctx.key;
 
 		const connection = await this._getConnection();
 		try {
@@ -1258,7 +1255,7 @@ Redis.prototype.get = async function(key) {
 			}
 
 			// 触发后置事件
-			this.emit('get_after', {
+			this.emit('get:after', {
 				key: finalKey,
 				value: result,
 				success: true
@@ -1270,11 +1267,11 @@ Redis.prototype.get = async function(key) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('get_error', {
+		this.emit('get:error', {
 			key,
 			error: err
 		});
-		$.log.error(`[Redis] 获取缓存失败 [${key}]:`, err);
+		this.logger('error',`获取缓存失败 [${key}]:`, err);
 		return null;
 	}
 };
@@ -1288,25 +1285,25 @@ Redis.prototype.has = async function(key) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.warn(`[Redis] has: key参数必须是非空字符串`);
+			throw new Error(`has: key参数必须是非空字符串`);
 			return false;
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			cancel: false
 		};
-		this.emit('has_before', beforeEventData);
+		this.emit('has:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回false
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] has操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`has操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
 		// 使用可能被修改的值
-		const finalKey = beforeEventData.key;
+		const finalKey = ctx.key;
 
 		const connection = await this._getConnection();
 		try {
@@ -1315,7 +1312,7 @@ Redis.prototype.has = async function(key) {
 			const exists = result > 0;
 
 			// 触发后置事件
-			this.emit('has_after', {
+			this.emit('has:after', {
 				key: finalKey,
 				result: exists,
 				success: true
@@ -1327,11 +1324,11 @@ Redis.prototype.has = async function(key) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('has_error', {
+		this.emit('has:error', {
 			key,
 			error: err
 		});
-		$.log.error(`[Redis] 检查键是否存在失败 [${key}]:`, err);
+		this.logger('error',`检查键是否存在失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1345,14 +1342,14 @@ Redis.prototype.exists = async function(key) {
 	try {
 		// 参数验证
 		if (!key) {
-			$.log.warn('[Redis] exists: key必须是非空字符串或非空字符串数组');
+			throw new Error('exists: key必须是非空字符串或非空字符串数组');
 			return 0;
 		}
 
 		// 如果是单个键，验证是否为非空字符串
 		if (typeof key === 'string') {
 			if (!key) {
-				$.log.warn('[Redis] exists: key必须是非空字符串');
+				throw new Error('exists: key必须是非空字符串');
 				return 0;
 			}
 		}
@@ -1360,30 +1357,30 @@ Redis.prototype.exists = async function(key) {
 		else if (Array.isArray(key)) {
 			for (const k of key) {
 				if (!k || typeof k !== 'string') {
-					$.log.warn('[Redis] exists: key必须是非空字符串或非空字符串数组');
+					throw new Error('exists: key必须是非空字符串或非空字符串数组');
 					return 0;
 				}
 			}
 		} else {
-			$.log.warn('[Redis] exists: key必须是非空字符串或非空字符串数组');
+			throw new Error('exists: key必须是非空字符串或非空字符串数组');
 			return 0;
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			cancel: false
 		};
-		this.emit('exists_before', beforeEventData);
+		this.emit('exists:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回0
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] exists操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`exists操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
 		// 使用可能被修改的值
-		const finalKey = beforeEventData.key;
+		const finalKey = ctx.key;
 
 		const connection = await this._getConnection();
 		try {
@@ -1397,7 +1394,7 @@ Redis.prototype.exists = async function(key) {
 			}
 
 			// 触发后置事件
-			this.emit('exists_after', {
+			this.emit('exists:after', {
 				key: finalKey,
 				result,
 				success: true
@@ -1409,11 +1406,11 @@ Redis.prototype.exists = async function(key) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('exists_error', {
+		this.emit('exists:error', {
 			key,
 			error: err
 		});
-		$.log.error(`[Redis] 检查键存在性失败 [${key}]:`, err);
+		this.logger('error',`检查键存在性失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1432,7 +1429,7 @@ Redis.prototype.getrange = async function(key, start, end) {
 			key = this.applyPrefix(key);
 			return await connection.getRange(key, start, end);
 		} catch (err) {
-			$.log.error('[Redis] 获取字符串范围失败:', err);
+			this.logger('error','获取字符串范围失败:', err);
 			// 回退方案
 			const value = await this.get(key);
 			if (value && typeof value === 'string') {
@@ -1443,7 +1440,7 @@ Redis.prototype.getrange = async function(key, start, end) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取字符串范围失败 [${key}]:`, err);
+		this.logger('error',`获取字符串范围失败 [${key}]:`, err);
 		return '';
 	}
 };
@@ -1469,17 +1466,17 @@ Redis.prototype.insertString = function(str, index, str_sub) {
 Redis.prototype.setrange = async function(key, index, value) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			index,
 			value,
 			cancel: false
 		};
-		this.emit('setrange_before', beforeEventData);
+		this.emit('setrange:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回0
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] setrange操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`setrange操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1488,7 +1485,7 @@ Redis.prototype.setrange = async function(key, index, value) {
 			key: finalKey,
 			index: finalIndex,
 			value: finalValue
-		} = beforeEventData;
+		} = ctx;
 		let result;
 
 		const connection = await this._getConnection();
@@ -1505,7 +1502,7 @@ Redis.prototype.setrange = async function(key, index, value) {
 			}
 			// 回退方案
 			else {
-				$.log.warn(`[Redis] 连接对象不支持setRange操作，使用回退方案`);
+				throw new Error(`连接对象不支持setRange操作，使用回退方案`);
 				let str = await this.get(finalKey) || '';
 				if (str.length < finalIndex) {
 					// 填充空格到指定索引
@@ -1517,7 +1514,7 @@ Redis.prototype.setrange = async function(key, index, value) {
 			}
 
 			// 触发后置事件
-			this.emit('setrange_after', {
+			this.emit('setrange:after', {
 				key: finalKey,
 				index: finalIndex,
 				value: finalValue,
@@ -1526,7 +1523,7 @@ Redis.prototype.setrange = async function(key, index, value) {
 			});
 			return result;
 		} catch (err) {
-			$.log.error('[Redis] 设置字符串范围失败:', err);
+			this.logger('error','设置字符串范围失败:', err);
 			// 回退方案
 			let str = await this.get(finalKey) || '';
 			if (str.length < finalIndex) {
@@ -1537,7 +1534,7 @@ Redis.prototype.setrange = async function(key, index, value) {
 			await this.set(finalKey, str);
 
 			// 触发后置事件
-			this.emit('setrange_after', {
+			this.emit('setrange:after', {
 				key: finalKey,
 				index: finalIndex,
 				value: finalValue,
@@ -1550,13 +1547,13 @@ Redis.prototype.setrange = async function(key, index, value) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('setrange_error', {
+		this.emit('setrange:error', {
 			key,
 			index,
 			value,
 			error: err
 		});
-		$.log.error(`[Redis] 设置字符串范围失败 [${key}]:`, err);
+		this.logger('error',`设置字符串范围失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1569,22 +1566,22 @@ Redis.prototype.setrange = async function(key, index, value) {
 Redis.prototype.clear = async function(key) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			cancel: false
 		};
-		this.emit('clear_before', beforeEventData);
+		this.emit('clear:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回false
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] clear操作被事件处理器取消`);
+		if (ctx.cancel) {
+			this.logger('debug',`clear操作被事件处理器取消`);
 			return false;
 		}
 
 		// 使用可能被修改的值
 		let {
 			key: finalKey
-		} = beforeEventData;
+		} = ctx;
 		let success = false;
 
 		const connection = await this._getConnection();
@@ -1601,13 +1598,13 @@ Redis.prototype.clear = async function(key) {
 					await connection.execute('FLUSHDB');
 					success = true;
 				} else {
-					$.log.error('[Redis] 连接对象不支持flushDb操作');
+					this.logger('error','连接对象不支持flushDb操作');
 					success = false;
 				}
 			}
 
 			// 触发后置事件
-			this.emit('clear_after', {
+			this.emit('clear:after', {
 				key: finalKey,
 				success
 			});
@@ -1617,11 +1614,11 @@ Redis.prototype.clear = async function(key) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('clear_error', {
+		this.emit('clear:error', {
 			key,
 			error: err
 		});
-		$.log.error('[Redis] 清空缓存失败:', err);
+		this.logger('error','清空缓存失败:', err);
 		return false;
 	}
 };
@@ -1665,7 +1662,7 @@ Redis.prototype.sort = async function(key, options = {}) {
 
 			return await connection.sort(key, sortOptions);
 		} catch (err) {
-			$.log.error('[Redis] 排序失败:', err);
+			this.logger('error','排序失败:', err);
 			// 回退方案：获取数据后在内存中排序
 			const data = await this.getForList(key);
 			return data.sort((a, b) => {
@@ -1679,7 +1676,7 @@ Redis.prototype.sort = async function(key, options = {}) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 排序失败 [${key}]:`, err);
+		this.logger('error',`排序失败 [${key}]:`, err);
 		return [];
 	}
 };
@@ -1702,7 +1699,7 @@ Redis.prototype.keys = async function(pattern = '*') {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error('[Redis] 获取键列表失败:', err);
+		this.logger('error','获取键列表失败:', err);
 		return [];
 	}
 };
@@ -1717,17 +1714,17 @@ Redis.prototype.keys = async function(pattern = '*') {
 Redis.prototype.setForList = async function(key, value, seconds) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			value,
 			ttl: seconds,
 			cancel: false
 		};
-		this.emit('setForList_before', beforeEventData);
+		this.emit('setForList:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回0
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] setForList操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`setForList操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1736,7 +1733,7 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 			key: finalKey,
 			value: finalValue,
 			ttl: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 		let len = 0;
 
 		const connection = await this._getConnection();
@@ -1757,7 +1754,7 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 					} else if (typeof connection.execute === 'function') {
 						len = await connection.execute('RPUSH', [finalKey, ...finalValue]);
 					} else {
-						$.log.error('[Redis] 连接对象不支持rPush操作');
+						this.logger('error','连接对象不支持rPush操作');
 						len = 0;
 					}
 				}
@@ -1768,7 +1765,7 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 				} else if (typeof connection.execute === 'function') {
 					len = await connection.execute('RPUSH', [finalKey, finalValue]);
 				} else {
-					$.log.error('[Redis] 连接对象不支持rPush操作');
+					this.logger('error','连接对象不支持rPush操作');
 					len = 0;
 				}
 			}
@@ -1779,12 +1776,12 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 				} else if (typeof connection.execute === 'function') {
 					await connection.execute('EXPIRE', [finalKey, finalSeconds]);
 				} else {
-					$.log.error('[Redis] 连接对象不支持expire操作');
+					this.logger('error','连接对象不支持expire操作');
 				}
 			}
 
 			// 触发后置事件
-			this.emit('setForList_after', {
+			this.emit('setForList:after', {
 				key: finalKey,
 				value: finalValue,
 				ttl: finalSeconds,
@@ -1797,12 +1794,12 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('setForList_error', {
+		this.emit('setForList:error', {
 			key,
 			value,
 			error: err
 		});
-		$.log.error(`[Redis] 设置列表失败 [${key}]:`, err);
+		this.logger('error',`设置列表失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1817,17 +1814,17 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 Redis.prototype.addForList = async function(key, value, seconds = 0) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			value,
 			ttl: seconds,
 			cancel: false
 		};
-		this.emit('addForList_before', beforeEventData);
+		this.emit('addForList:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回0
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] addForList操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`addForList操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
@@ -1836,7 +1833,7 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
 			key: finalKey,
 			value: finalValue,
 			ttl: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 		let len = 0;
 
 		const connection = await this._getConnection();
@@ -1851,7 +1848,7 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
 					} else if (typeof connection.execute === 'function') {
 						len = await connection.execute('RPUSH', [finalKey, ...finalValue]);
 					} else {
-						$.log.error('[Redis] 连接对象不支持rPush操作');
+						this.logger('error','连接对象不支持rPush操作');
 						len = 0;
 					}
 				}
@@ -1862,7 +1859,7 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
 				} else if (typeof connection.execute === 'function') {
 					len = await connection.execute('RPUSH', [finalKey, finalValue]);
 				} else {
-					$.log.error('[Redis] 连接对象不支持rPush操作');
+					this.logger('error','连接对象不支持rPush操作');
 					len = 0;
 				}
 			}
@@ -1873,12 +1870,12 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
 				} else if (typeof connection.execute === 'function') {
 					await connection.execute('EXPIRE', [finalKey, finalSeconds]);
 				} else {
-					$.log.error('[Redis] 连接对象不支持expire操作');
+					this.logger('error','连接对象不支持expire操作');
 				}
 			}
 
 			// 触发后置事件
-			this.emit('addForList_after', {
+			this.emit('addForList:after', {
 				key: finalKey,
 				value: finalValue,
 				ttl: finalSeconds,
@@ -1891,12 +1888,12 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('addForList_error', {
+		this.emit('addForList:error', {
 			key,
 			value,
 			error: err
 		});
-		$.log.error(`[Redis] 添加列表项失败 [${key}]:`, err);
+		this.logger('error',`添加列表项失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -1909,7 +1906,7 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
  */
 Redis.prototype.hasForList = async function(key, value) {
 	if (!value) {
-		$.log.error('[Redis] 参数错误: 值不能为空');
+		this.logger('error','参数错误: 值不能为空');
 		return false;
 	}
 
@@ -1925,7 +1922,7 @@ Redis.prototype.hasForList = async function(key, value) {
 			return itemStr === valueStr || item === value;
 		});
 	} catch (err) {
-		$.log.error(`[Redis] 检查列表成员是否存在失败 [${key}]:`, err);
+		this.logger('error',`检查列表成员是否存在失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -1940,17 +1937,17 @@ Redis.prototype.hasForList = async function(key, value) {
 Redis.prototype.getForList = async function(key, start = 0, end = -1) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			start,
 			end,
 			cancel: false
 		};
-		this.emit('getForList_before', beforeEventData);
+		this.emit('getForList:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回空数组
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] getForList操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`getForList操作被事件处理器取消 [${key}]`);
 			return [];
 		}
 
@@ -1959,7 +1956,7 @@ Redis.prototype.getForList = async function(key, start = 0, end = -1) {
 			key: finalKey,
 			start: finalStart,
 			end: finalEnd
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -1975,12 +1972,12 @@ Redis.prototype.getForList = async function(key, start = 0, end = -1) {
 				// 回退到通用execute方法
 				result = await connection.execute('LRANGE', [finalKey, finalStart, finalEnd]);
 			} else {
-				$.log.error('[Redis] 连接对象不支持lRange或lrange操作');
+				this.logger('error','连接对象不支持lRange或lrange操作');
 				return [];
 			}
 			// 确保结果是数组
 			if (!Array.isArray(result)) {
-				$.log.error('[Redis] 列表查询结果不是数组格式');
+				this.logger('error','列表查询结果不是数组格式');
 				return [];
 			}
 
@@ -2002,7 +1999,7 @@ Redis.prototype.getForList = async function(key, start = 0, end = -1) {
 			});
 
 			// 触发后置事件
-			this.emit('getForList_after', {
+			this.emit('getForList:after', {
 				key: finalKey,
 				start: finalStart,
 				end: finalEnd,
@@ -2014,13 +2011,13 @@ Redis.prototype.getForList = async function(key, start = 0, end = -1) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('getForList_error', {
+		this.emit('getForList:error', {
 			key,
 			start,
 			end,
 			error: err
 		});
-		$.log.error(`[Redis] 获取列表失败 [${key}]:`, err);
+		this.logger('error',`获取列表失败 [${key}]:`, err);
 		return [];
 	}
 };
@@ -2032,26 +2029,26 @@ Redis.prototype.getForList = async function(key, start = 0, end = -1) {
  */
 Redis.prototype.clearForList = async function(key) {
 	if (!key) {
-		$.log.error('[Redis] 参数错误: 键不能为空');
+		this.logger('error','参数错误: 键不能为空');
 		return false;
 	}
 
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			cancel: false
 		};
-		this.emit('clearForList_before', beforeEventData);
+		this.emit('clearForList:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回false
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] clearForList操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`clearForList操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
 		// 使用可能被修改的值
-		let finalKey = beforeEventData.key;
+		let finalKey = ctx.key;
 
 		// 直接使用set方法设置为空数组，这样更可靠且与其他模块行为一致
 		// 这样可以确保返回值是一个空数组，而不是null或undefined
@@ -2059,18 +2056,18 @@ Redis.prototype.clearForList = async function(key) {
 		await this.set(finalKey, []);
 
 		// 触发后置事件
-		this.emit('clearForList_after', {
+		this.emit('clearForList:after', {
 			key: finalKey,
 			success: true
 		});
 		return true;
 	} catch (err) {
 		// 触发错误事件
-		this.emit('clearForList_error', {
+		this.emit('clearForList:error', {
 			key,
 			error: err
 		});
-		$.log.error(`[Redis] 清空列表失败 [${key}]:`, err);
+		this.logger('error',`清空列表失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -2089,33 +2086,33 @@ Redis.prototype.mget = async function(keys) {
 	try {
 		// 参数验证
 		if (!keys || !Array.isArray(keys)) {
-			$.log.warn('[Redis] mget: keys必须是非空数组');
+			throw new Error('mget: keys必须是非空数组');
 			return [];
 		}
 
 		// 验证数组中的每个元素是否为非空字符串
 		for (const key of keys) {
 			if (!key || typeof key !== 'string') {
-				$.log.warn('[Redis] mget: keys数组中的每个元素必须是非空字符串');
+				throw new Error('mget: keys数组中的每个元素必须是非空字符串');
 				return [];
 			}
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			keys,
 			cancel: false
 		};
-		this.emit('mget_before', beforeEventData);
+		this.emit('mget:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回空数组
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] mget操作被事件处理器取消 [${keys}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`mget操作被事件处理器取消 [${keys}]`);
 			return [];
 		}
 
 		// 使用可能被修改的值
-		const finalKeys = beforeEventData.keys;
+		const finalKeys = ctx.keys;
 
 		const connection = await this._getConnection();
 		try {
@@ -2140,7 +2137,7 @@ Redis.prototype.mget = async function(keys) {
 			});
 
 			// 触发后置事件
-			this.emit('mget_after', {
+			this.emit('mget:after', {
 				keys: finalKeys,
 				result,
 				success: true
@@ -2152,11 +2149,11 @@ Redis.prototype.mget = async function(keys) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('mget_error', {
+		this.emit('mget:error', {
 			keys,
 			error: err
 		});
-		$.log.error(`[Redis] 批量获取缓存失败 [${keys}]:`, err);
+		this.logger('error',`批量获取缓存失败 [${keys}]:`, err);
 		return [];
 	}
 }
@@ -2170,16 +2167,16 @@ Redis.prototype.mget = async function(keys) {
 Redis.prototype.mset = async function(obj, seconds = 0) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			value: obj,
 			seconds,
 			cancel: false
 		};
-		this.emit('mset_before', beforeEventData);
+		this.emit('mset:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回false
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] mset操作被事件处理器取消`);
+		if (ctx.cancel) {
+			this.logger('debug',`mset操作被事件处理器取消`);
 			return false;
 		}
 
@@ -2187,11 +2184,11 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 		let {
 			value: finalData,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		// 检查最终数据是否有效
 		if (!finalData || typeof finalData !== 'object' || finalData === null || Array.isArray(finalData)) {
-			$.log.warn('[Redis] mset: 参数必须是非空对象');
+			throw new Error('mset: 参数必须是非空对象');
 			return false;
 		}
 
@@ -2211,7 +2208,7 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 		await pipeline.exec();
 
 		// 触发后置事件
-		this.emit('mset_after', {
+		this.emit('mset:after', {
 			keyValues: finalData,
 			seconds: finalSeconds,
 			result: true
@@ -2219,14 +2216,14 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 		return true;
 	} catch (err) {
 		// 触发错误事件
-		this.emit('mset_error', {
+		this.emit('mset:error', {
 			keyValues: obj,
 			seconds,
 			error: err
 		});
 
 		// 如果Pipeline失败，回退到原实现
-		$.log.warn('[Redis] 使用Pipeline批量设置失败，使用回退方案:', err);
+		throw new Error('使用Pipeline批量设置失败，使用回退方案:', err);
 		const connection = await this._getConnection();
 		try {
 			const pairs = [];
@@ -2238,7 +2235,7 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 
 			// 确保pairs数组格式正确，符合原生mSet方法要求
 			if (pairs.length % 2 !== 0) {
-				$.log.warn('[Redis] mset: 键值对数量必须相等');
+				throw new Error('mset: 键值对数量必须相等');
 				return false;
 			}
 
@@ -2252,7 +2249,7 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 			}
 
 			// 触发后置事件（使用原始数据，因为前置数据修改处理已失败）
-			this.emit('mset_after', {
+			this.emit('mset:after', {
 				keyValues: obj,
 				seconds,
 				result: true
@@ -2260,12 +2257,12 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 			return true;
 		} catch (fallbackErr) {
 			// 触发错误事件
-			this.emit('mset_error', {
+			this.emit('mset:error', {
 				keyValues: obj,
 				seconds,
 				error: fallbackErr
 			});
-			$.log.error('[Redis] 回退方案批量设置也失败:', fallbackErr);
+			this.logger('error','回退方案批量设置也失败:', fallbackErr);
 			return false;
 		} finally {
 			this._recycleConnection(connection);
@@ -2287,16 +2284,16 @@ Redis.prototype._recycleConnection = function(connection) {
 Redis.prototype.hdel = async function(key, fields) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			value: fields,
 			cancel: false
 		};
-		this.emit('hdel_before', beforeEventData);
+		this.emit('hdel:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回false
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] hdel操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`hdel操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2304,7 +2301,7 @@ Redis.prototype.hdel = async function(key, fields) {
 		let {
 			key: finalKey,
 			value: finalFields
-		} = beforeEventData;
+		} = ctx;
 		let success = true;
 
 		const connection = await this._getConnection();
@@ -2320,12 +2317,12 @@ Redis.prototype.hdel = async function(key, fields) {
 			} else if (typeof connection.execute === 'function') {
 				await connection.execute('HDEL', [finalKey, ...finalFields]);
 			} else {
-				$.log.error('[Redis] 连接对象不支持hDel操作');
+				this.logger('error','连接对象不支持hDel操作');
 				success = false;
 			}
 
 			// 触发后置事件
-			this.emit('hdel_after', {
+			this.emit('hdel:after', {
 				key: finalKey,
 				value: finalFields,
 				success
@@ -2336,12 +2333,12 @@ Redis.prototype.hdel = async function(key, fields) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('hdel_error', {
+		this.emit('hdel:error', {
 			key,
 			value: fields,
 			error: err
 		});
-		$.log.error(`[Redis] 删除哈希字段失败 [${key}]:`, err);
+		this.logger('error',`删除哈希字段失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -2361,7 +2358,7 @@ Redis.prototype.hlen = async function(key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取哈希字段数量失败 [${key}]:`, err);
+		this.logger('error',`获取哈希字段数量失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -2465,7 +2462,7 @@ class RedisPipeline {
 				} else if (pipeline[name]) {
 					pipeline[name](...processedArgs);
 				} else {
-					$.log.warn(`[Redis] Pipeline不支持的命令: ${name}`);
+					throw new Error(`Pipeline不支持的命令: ${name}`);
 				}
 			}
 
@@ -2475,7 +2472,7 @@ class RedisPipeline {
 			// 处理结果（解析JSON等）
 			return results.map(([err, value], index) => {
 				if (err) {
-					$.log.error(`[Redis] [Pipeline] Pipeline命令执行失败 [${this.commands[index].name}]:`, err);
+					this.logger('error',`[Pipeline] Pipeline命令执行失败 [${this.commands[index].name}]:`, err);
 					return null;
 				}
 
@@ -2503,19 +2500,19 @@ class RedisPipeline {
  */
 Redis.prototype.clearExpire = async function() {
 	try {
-		this.emit('clearExpire_before', {});
+		this.emit('clearExpire:before', {});
 		// Redis没有直接的方法来清空所有过期数据
 		// 我们可以通过扫描所有键并检查过期时间来模拟这个行为
 		// 但为了简单起见，我们直接返回true表示操作成功
-		this.emit('clearExpire_after', {
+		this.emit('clearExpire:after', {
 			result: true
 		});
 		return true;
 	} catch (err) {
-		this.emit('clearExpire_error', {
+		this.emit('clearExpire:error', {
 			error: err
 		});
-		$.log.error('[Redis] 清空过期数据失败:', err);
+		this.logger('error','清空过期数据失败:', err);
 		return false;
 	}
 };
@@ -2544,14 +2541,14 @@ Redis.prototype._getConnection = function() {
 			} else {
 				// 否则等待连接释放
 				// 这里简化处理，直接创建连接（生产环境应实现等待队列）
-				$.log.warn('[Redis] 连接池已满，创建额外连接');
+				throw new Error('连接池已满，创建额外连接');
 				this._createConnection().then(connection => {
 					this.connection_pool.in_use.add(connection);
 					resolve(connection);
 				}).catch(reject);
 			}
 		} catch (error) {
-			$.log.error('[Redis] 获取连接失败:', error);
+			this.logger('error','获取连接失败:', error);
 			reject(error);
 		}
 	});
@@ -2574,16 +2571,16 @@ Redis.prototype._releaseConnection = function(connection) {
 					} else if (typeof connection.end === 'function') {
 						connection.end();
 					} else {
-						$.log.debug('[Redis] 连接对象没有可用的关闭方法');
+						this.logger('debug','连接对象没有可用的关闭方法');
 					}
-					// $.log.debug('[Redis] 关闭多余连接:', connection.id);
+					// this.logger('debug','关闭多余连接:', connection.id);
 				} catch (e) {
-					$.log.error('[Redis] 关闭多余连接失败:', e);
+					this.logger('error','关闭多余连接失败:', e);
 				}
 			}
 		}
 	} catch (error) {
-		$.log.error('[Redis] 释放连接失败:', error);
+		this.logger('error','释放连接失败:', error);
 	}
 };
 
@@ -2602,17 +2599,17 @@ Redis.prototype._recycleConnection = Redis.prototype._releaseConnection;
 Redis.prototype.hset = async function(key, field, value) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			field,
 			value,
 			cancel: false
 		};
-		this.emit('hset_before', beforeEventData);
+		this.emit('hset:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回false
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] hset操作被事件处理器取消 [${key}:${field}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`hset操作被事件处理器取消 [${key}:${field}]`);
 			return false;
 		}
 
@@ -2621,7 +2618,7 @@ Redis.prototype.hset = async function(key, field, value) {
 			key: finalKey,
 			field: finalField,
 			value: finalValue
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -2634,7 +2631,7 @@ Redis.prototype.hset = async function(key, field, value) {
 			const result = await connection.hSet(finalKey, finalField, finalValue);
 
 			// 触发后置事件
-			this.emit('hset_after', {
+			this.emit('hset:after', {
 				key: finalKey,
 				field: finalField,
 				value: finalValue,
@@ -2645,9 +2642,9 @@ Redis.prototype.hset = async function(key, field, value) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 设置哈希字段失败 [${key}:${field}]:`, err);
+		this.logger('error',`设置哈希字段失败 [${key}:${field}]:`, err);
 		// 触发错误事件
-		this.emit('hset_error', {
+		this.emit('hset:error', {
 			key,
 			field,
 			value,
@@ -2687,7 +2684,7 @@ Redis.prototype.hget = async function(key, field) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取哈希字段失败 [${key}:${field}]:`, err);
+		this.logger('error',`获取哈希字段失败 [${key}:${field}]:`, err);
 		return null;
 	}
 };
@@ -2701,16 +2698,16 @@ Redis.prototype.hget = async function(key, field) {
 Redis.prototype.hmset = async function(key, obj) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = {
+		const ctx = {
 			key,
 			value: obj,
 			cancel: false
 		};
-		this.emit('hmset_before', beforeEventData);
+		this.emit('hmset:before', ctx);
 
 		// 如果事件处理器标记为取消，则返回false
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] hmset操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`hmset操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -2718,27 +2715,27 @@ Redis.prototype.hmset = async function(key, obj) {
 		let {
 			key: finalKey,
 			value: finalObj
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
 			finalKey = this.applyPrefix(finalKey);
 
 			// 检查Redis版本，支持不同的方法
-			$.log.debug(
-				`[Redis] hmset方法检测到连接对象方法: hSet=${typeof connection.hSet === 'function'}, hmset=${typeof connection.hmset === 'function'}`
+			this.logger('debug',
+				`hmset方法检测到连接对象方法: hSet=${typeof connection.hSet === 'function'}, hmset=${typeof connection.hmset === 'function'}`
 			);
 			let success = true;
 
 			// 优化策略：对所有Redis版本都使用逐个字段设置的方式，确保兼容性和正确性
-			$.log.debug(`[Redis] 对键 ${finalKey} 强制使用逐个字段设置策略`);
+			this.logger('debug',`对键 ${finalKey} 强制使用逐个字段设置策略`);
 
 			// 获取适合的设置字段方法
 			const setFieldMethod = typeof connection.hSet === 'function' ? 'hSet' :
 				typeof connection.hset === 'function' ? 'hset' : null;
 
 			if (!setFieldMethod) {
-				$.log.error(`[Redis] 连接对象不支持hSet或hset操作`);
+				this.logger('error',`连接对象不支持hSet或hset操作`);
 				return false;
 			}
 
@@ -2750,10 +2747,10 @@ Redis.prototype.hmset = async function(key, obj) {
 						if (typeof value !== 'string') {
 							value = JSON.stringify(value);
 						}
-						$.log.debug(`[Redis] 单独设置字段: ${setFieldMethod}(${finalKey}, ${field}, ${value})`);
+						this.logger('debug',`单独设置字段: ${setFieldMethod}(${finalKey}, ${field}, ${value})`);
 						await connection[setFieldMethod](finalKey, field, value);
 					} catch (singleError) {
-						$.log.error(`[Redis] 设置单个字段失败 ${field}: ${singleError.message}`);
+						this.logger('error',`设置单个字段失败 ${field}: ${singleError.message}`);
 						success = false;
 						break;
 					}
@@ -2762,19 +2759,19 @@ Redis.prototype.hmset = async function(key, obj) {
 
 			// 验证所有字段是否都设置成功
 			if (success) {
-				$.log.debug(`[Redis] 验证所有字段设置情况`);
+				this.logger('debug',`验证所有字段设置情况`);
 				for (const field in finalObj) {
 					if (finalObj.hasOwnProperty(field)) {
 						try {
 							const hgetMethod = typeof connection.hGet === 'function' ? 'hGet' : 'hget';
 							const value = await connection[hgetMethod](finalKey, field);
-							$.log.debug(`[Redis] 验证字段 ${field}: ${value !== null ? '存在' : '不存在'}`);
+							this.logger('debug',`验证字段 ${field}: ${value !== null ? '存在' : '不存在'}`);
 							// 如果字段不存在，更新success状态
 							if (value === null) {
 								success = false;
 							}
 						} catch (getError) {
-							$.log.error(`[Redis] 验证字段失败 ${field}: ${getError.message}`);
+							this.logger('error',`验证字段失败 ${field}: ${getError.message}`);
 							success = false;
 						}
 					}
@@ -2782,7 +2779,7 @@ Redis.prototype.hmset = async function(key, obj) {
 			}
 
 			// 触发后置事件
-			this.emit('hmset_after', {
+			this.emit('hmset:after', {
 				key: finalKey,
 				value: finalObj,
 				success: success
@@ -2792,9 +2789,9 @@ Redis.prototype.hmset = async function(key, obj) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 批量设置哈希字段失败 [${key}]:`, err);
+		this.logger('error',`批量设置哈希字段失败 [${key}]:`, err);
 		// 触发错误事件
-		this.emit('hmset_error', {
+		this.emit('hmset:error', {
 			key,
 			value: obj,
 			error: err
@@ -2817,14 +2814,14 @@ Redis.prototype.hgetall = async function(key) {
 				const result = await connection.hGetAll(key);
 				return result;
 			} else {
-				$.log.error('[Redis] 连接对象不支持hGetAll操作');
+				this.logger('error','连接对象不支持hGetAll操作');
 				return {};
 			}
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取哈希所有字段和值失败 [${key}]:`, err);
+		this.logger('error',`获取哈希所有字段和值失败 [${key}]:`, err);
 		return {};
 	}
 };
@@ -2838,12 +2835,12 @@ Redis.prototype.hgetall = async function(key) {
 Redis.prototype.hmget = async function(key, fields) {
 	try {
 		if (!Array.isArray(fields)) {
-			$.log.error('[Redis] 参数错误: fields必须是数组');
+			this.logger('error','参数错误: fields必须是数组');
 			// 返回空数组而不是false，保持与注释类型一致
 			return [];
 		}
 
-		this.emit('hmget_before', {
+		this.emit('hmget:before', {
 			key,
 			fields
 		});
@@ -2856,7 +2853,7 @@ Redis.prototype.hmget = async function(key, fields) {
 				const result = await connection.hmGet(key, fields);
 				// 将null转换为undefined以保持与CacheBase行为一致
 				const finalResult = result.map(value => value === null ? undefined : value);
-				this.emit('hmget_after', {
+				this.emit('hmget:after', {
 					key,
 					fields,
 					result: finalResult
@@ -2869,15 +2866,15 @@ Redis.prototype.hmget = async function(key, fields) {
 					const value = allFields[field];
 					return value === null || value === undefined ? undefined : value;
 				});
-				this.emit('hmget_after', {
+				this.emit('hmget:after', {
 					key,
 					fields,
 					result: finalResult
 				});
 				return finalResult;
 			} else {
-				$.log.error('[Redis] 连接对象不支持hmGet操作');
-				$.log.error('[Redis] 错误: Redis客户端不支持hmget操作');
+				this.logger('error','连接对象不支持hmGet操作');
+				this.logger('error','错误: Redis客户端不支持hmget操作');
 				// 返回与fields长度相同的undefined数组，保持与注释一致
 				return fields.map(() => undefined);
 			}
@@ -2885,12 +2882,12 @@ Redis.prototype.hmget = async function(key, fields) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.emit('hmget_error', {
+		this.emit('hmget:error', {
 			key,
 			fields,
 			error: err
 		});
-		$.log.error(`[Redis] 哈希表批量获取失败 [${key}]:`, err);
+		this.logger('error',`哈希表批量获取失败 [${key}]:`, err);
 		// 返回与fields长度相同的undefined数组，保持与注释类型一致
 		return fields.map(() => undefined);
 	}
@@ -2904,22 +2901,22 @@ Redis.prototype.hmget = async function(key, fields) {
 Redis.prototype.expire = async function(key, seconds) {
 	try {
 		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
 			ttl: seconds,
 			cancel: false
 		};
-		this.emit('expire_before', beforeEventData);
+		this.emit('expire:before', ctx);
 
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] expire操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`expire操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
 		const {
 			key: finalKey,
 			ttl: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -2927,15 +2924,15 @@ Redis.prototype.expire = async function(key, seconds) {
 			const result = await connection.expire(this.applyPrefix(finalKey), finalSeconds);
 
 			// 触发后置事件
-			this.emit('expire_after', {
+			this.emit('expire:after', {
 				key: finalKey,
 				ttl: finalSeconds,
 				success: result === 1
 			});
 			return result === 1;
 		} catch (err) {
-			$.log.error(`[Redis] 设置过期时间失败 [${finalKey}]:`, err);
-			this.emit('expire_error', {
+			this.logger('error',`设置过期时间失败 [${finalKey}]:`, err);
+			this.emit('expire:error', {
 				key: finalKey,
 				ttl: finalSeconds,
 				error: err
@@ -2945,8 +2942,8 @@ Redis.prototype.expire = async function(key, seconds) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 设置过期时间失败 [${key}]:`, err);
-		this.emit('expire_error', {
+		this.logger('error',`设置过期时间失败 [${key}]:`, err);
+		this.emit('expire:error', {
 			key,
 			ttl: seconds,
 			error: err
@@ -2965,31 +2962,31 @@ Redis.prototype.pexpire = async function(key, milliseconds) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] pexpire参数错误: key must be a non-empty string');
+			this.logger('error','pexpire参数错误: key must be a non-empty string');
 			return false;
 		}
 		if (!Number.isInteger(milliseconds) || milliseconds <= 0) {
-			$.log.error('[Redis] pexpire参数错误: milliseconds must be a positive integer');
+			this.logger('error','pexpire参数错误: milliseconds must be a positive integer');
 			return false;
 		}
 
 		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
 			ttl: milliseconds,
 			cancel: false
 		};
-		this.emit('pexpire_before', beforeEventData);
+		this.emit('pexpire:before', ctx);
 
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] pexpire操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`pexpire操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
 		const {
 			key: finalKey,
 			ttl: finalMilliseconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -3000,20 +2997,20 @@ Redis.prototype.pexpire = async function(key, milliseconds) {
 			} else if (typeof connection.execute === 'function') {
 				result = await connection.execute('PEXPIRE', [this.applyPrefix(finalKey), finalMilliseconds]);
 			} else {
-				$.log.error('[Redis] 连接对象不支持pexpire操作');
+				this.logger('error','连接对象不支持pexpire操作');
 				return false;
 			}
 
 			// 触发后置事件
-			this.emit('pexpire_after', {
+			this.emit('pexpire:after', {
 				key: finalKey,
 				ttl: finalMilliseconds,
 				success: result === 1
 			});
 			return result === 1;
 		} catch (err) {
-			$.log.error(`[Redis] 设置过期时间（毫秒）失败 [${finalKey}]:`, err);
-			this.emit('pexpire_error', {
+			this.logger('error',`设置过期时间（毫秒）失败 [${finalKey}]:`, err);
+			this.emit('pexpire:error', {
 				key: finalKey,
 				ttl: finalMilliseconds,
 				error: err
@@ -3023,8 +3020,8 @@ Redis.prototype.pexpire = async function(key, milliseconds) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 设置过期时间（毫秒）失败 [${key}]:`, err);
-		this.emit('pexpire_error', {
+		this.logger('error',`设置过期时间（毫秒）失败 [${key}]:`, err);
+		this.emit('pexpire:error', {
 			key,
 			ttl: milliseconds,
 			error: err
@@ -3037,20 +3034,20 @@ Redis.prototype.pexpire = async function(key, milliseconds) {
 Redis.prototype.persist = async function(key) {
 	try {
 		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
 			cancel: false
 		};
-		this.emit('persist_before', beforeEventData);
+		this.emit('persist:before', ctx);
 
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] persist操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`persist操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
 		const {
 			key: finalKey
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -3058,14 +3055,14 @@ Redis.prototype.persist = async function(key) {
 			const result = await connection.persist(this.applyPrefix(finalKey));
 
 			// 触发后置事件
-			this.emit('persist_after', {
+			this.emit('persist:after', {
 				key: finalKey,
 				success: result === 1
 			});
 			return result === 1;
 		} catch (err) {
-			$.log.error(`[Redis] 移除过期时间失败 [${finalKey}]:`, err);
-			this.emit('persist_error', {
+			this.logger('error',`移除过期时间失败 [${finalKey}]:`, err);
+			this.emit('persist:error', {
 				key: finalKey,
 				error: err
 			});
@@ -3074,8 +3071,8 @@ Redis.prototype.persist = async function(key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 移除过期时间失败 [${key}]:`, err);
-		this.emit('persist_error', {
+		this.logger('error',`移除过期时间失败 [${key}]:`, err);
+		this.emit('persist:error', {
 			key,
 			error: err
 		});
@@ -3093,27 +3090,27 @@ Redis.prototype.incr = async function(key, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
+			this.logger('error','参数错误: 键必须是非空字符串');
 			return null;
 		}
 
 		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
 			seconds,
 			cancel: false
 		};
-		this.emit('incr_before', beforeEventData);
+		this.emit('incr:before', ctx);
 
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] incr操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`incr操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
 		const {
 			key: finalKey,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -3130,15 +3127,15 @@ Redis.prototype.incr = async function(key, seconds = 0) {
 				}
 			}
 
-			this.emit('incr_after', {
+			this.emit('incr:after', {
 				key: finalKey,
 				seconds: finalSeconds,
 				result
 			});
 			return result;
 		} catch (err) {
-			$.log.error(`[Redis] 增加整数值失败 [${finalKey}]:`, err);
-			this.emit('incr_error', {
+			this.logger('error',`增加整数值失败 [${finalKey}]:`, err);
+			this.emit('incr:error', {
 				key: finalKey,
 				seconds: finalSeconds,
 				error: err
@@ -3148,8 +3145,8 @@ Redis.prototype.incr = async function(key, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 增加整数值失败 [${key}]:`, err);
-		this.emit('incr_error', {
+		this.logger('error',`增加整数值失败 [${key}]:`, err);
+		this.emit('incr:error', {
 			key,
 			seconds,
 			error: err
@@ -3168,27 +3165,27 @@ Redis.prototype.decr = async function(key, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
+			this.logger('error','参数错误: 键必须是非空字符串');
 			return null;
 		}
 
 		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
 			seconds,
 			cancel: false
 		};
-		this.emit('decr_before', beforeEventData);
+		this.emit('decr:before', ctx);
 
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] decr操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`decr操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
 		const {
 			key: finalKey,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -3205,15 +3202,15 @@ Redis.prototype.decr = async function(key, seconds = 0) {
 				}
 			}
 
-			this.emit('decr_after', {
+			this.emit('decr:after', {
 				key: finalKey,
 				seconds: finalSeconds,
 				result
 			});
 			return result;
 		} catch (err) {
-			$.log.error(`[Redis] 减少整数值失败 [${finalKey}]:`, err);
-			this.emit('decr_error', {
+			this.logger('error',`减少整数值失败 [${finalKey}]:`, err);
+			this.emit('decr:error', {
 				key: finalKey,
 				seconds: finalSeconds,
 				error: err
@@ -3223,8 +3220,8 @@ Redis.prototype.decr = async function(key, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 减少整数值失败 [${key}]:`, err);
-		this.emit('decr_error', {
+		this.logger('error',`减少整数值失败 [${key}]:`, err);
+		this.emit('decr:error', {
 			key,
 			seconds,
 			error: err
@@ -3244,25 +3241,25 @@ Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
+			this.logger('error','参数错误: 键必须是非空字符串');
 			return null;
 		}
 		if (typeof increment !== 'number' || isNaN(increment)) {
-			$.log.error('[Redis] 参数错误: 增量必须是有效数字');
+			this.logger('error','参数错误: 增量必须是有效数字');
 			return null;
 		}
 
 		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
 			increment,
 			seconds,
 			cancel: false
 		};
-		this.emit('incrbyfloat_before', beforeEventData);
+		this.emit('incrbyfloat:before', ctx);
 
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] incrbyfloat操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`incrbyfloat操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3270,7 +3267,7 @@ Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
 			key: finalKey,
 			increment: finalIncrement,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -3288,7 +3285,7 @@ Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
 				}
 			}
 
-			this.emit('incrbyfloat_after', {
+			this.emit('incrbyfloat:after', {
 				key: finalKey,
 				increment: finalIncrement,
 				seconds: finalSeconds,
@@ -3296,8 +3293,8 @@ Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
 			});
 			return parsedResult;
 		} catch (err) {
-			$.log.error(`[Redis] 增加浮点数值失败 [${finalKey}]:`, err);
-			this.emit('incrbyfloat_error', {
+			this.logger('error',`增加浮点数值失败 [${finalKey}]:`, err);
+			this.emit('incrbyfloat:error', {
 				key: finalKey,
 				increment: finalIncrement,
 				seconds: finalSeconds,
@@ -3308,8 +3305,8 @@ Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 增加浮点数值失败 [${key}]:`, err);
-		this.emit('incrbyfloat_error', {
+		this.logger('error',`增加浮点数值失败 [${key}]:`, err);
+		this.emit('incrbyfloat:error', {
 			key,
 			increment,
 			seconds,
@@ -3330,25 +3327,25 @@ Redis.prototype.incrby = async function(key, increment, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
+			this.logger('error','参数错误: 键必须是非空字符串');
 			return null;
 		}
 		if (typeof increment !== 'number' || isNaN(increment) || !Number.isInteger(increment)) {
-			$.log.error('[Redis] 参数错误: 增量必须是有效整数');
+			this.logger('error','参数错误: 增量必须是有效整数');
 			return null;
 		}
 
 		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
 			increment,
 			seconds,
 			cancel: false
 		};
-		this.emit('incrby_before', beforeEventData);
+		this.emit('incrby:before', ctx);
 
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] incrby操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`incrby操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3356,7 +3353,7 @@ Redis.prototype.incrby = async function(key, increment, seconds = 0) {
 			key: finalKey,
 			increment: finalIncrement,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -3373,7 +3370,7 @@ Redis.prototype.incrby = async function(key, increment, seconds = 0) {
 				}
 			}
 
-			this.emit('incrby_after', {
+			this.emit('incrby:after', {
 				key: finalKey,
 				increment: finalIncrement,
 				seconds: finalSeconds,
@@ -3381,8 +3378,8 @@ Redis.prototype.incrby = async function(key, increment, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			$.log.error(`[Redis] 增加指定值失败 [${finalKey}]:`, err);
-			this.emit('incrby_error', {
+			this.logger('error',`增加指定值失败 [${finalKey}]:`, err);
+			this.emit('incrby:error', {
 				key: finalKey,
 				increment: finalIncrement,
 				seconds: finalSeconds,
@@ -3393,8 +3390,8 @@ Redis.prototype.incrby = async function(key, increment, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 增加指定值失败 [${key}]:`, err);
-		this.emit('incrby_error', {
+		this.logger('error',`增加指定值失败 [${key}]:`, err);
+		this.emit('incrby:error', {
 			key,
 			increment,
 			seconds,
@@ -3415,25 +3412,25 @@ Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
+			this.logger('error','参数错误: 键必须是非空字符串');
 			return null;
 		}
 		if (typeof decrement !== 'number' || isNaN(decrement) || !Number.isInteger(decrement)) {
-			$.log.error('[Redis] 参数错误: 减量必须是有效整数');
+			this.logger('error','参数错误: 减量必须是有效整数');
 			return null;
 		}
 
 		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
 			decrement,
 			seconds,
 			cancel: false
 		};
-		this.emit('decrby_before', beforeEventData);
+		this.emit('decrby:before', ctx);
 
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] decrby操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`decrby操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -3441,7 +3438,7 @@ Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
 			key: finalKey,
 			decrement: finalDecrement,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -3458,7 +3455,7 @@ Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
 				}
 			}
 
-			this.emit('decrby_after', {
+			this.emit('decrby:after', {
 				key: finalKey,
 				decrement: finalDecrement,
 				seconds: finalSeconds,
@@ -3466,8 +3463,8 @@ Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			$.log.error(`[Redis] 减少指定值失败 [${finalKey}]:`, err);
-			this.emit('decrby_error', {
+			this.logger('error',`减少指定值失败 [${finalKey}]:`, err);
+			this.emit('decrby:error', {
 				key: finalKey,
 				decrement: finalDecrement,
 				seconds: finalSeconds,
@@ -3478,8 +3475,8 @@ Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 减少指定值失败 [${key}]:`, err);
-		this.emit('decrby_error', {
+		this.logger('error',`减少指定值失败 [${key}]:`, err);
+		this.emit('decrby:error', {
 			key,
 			decrement,
 			seconds,
@@ -3500,22 +3497,22 @@ Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
 Redis.prototype.sadd = async function(key, members) {
 	try {
 		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
 			members: Array.isArray(members) ? members : [members],
 			cancel: false
 		};
-		this.emit('sadd_before', beforeEventData);
+		this.emit('sadd:before', ctx);
 
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] sadd操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`sadd操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
 		const {
 			key: finalKey,
 			members: finalMembers
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -3523,7 +3520,7 @@ Redis.prototype.sadd = async function(key, members) {
 			const result = await connection.sAdd(prefixedKey, finalMembers);
 
 			// 触发后置事件
-			this.emit('sadd_after', {
+			this.emit('sadd:after', {
 				key: finalKey,
 				members: finalMembers,
 				result
@@ -3533,8 +3530,8 @@ Redis.prototype.sadd = async function(key, members) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 添加集合成员失败 [${key}]:`, err);
-		this.emit('sadd_error', {
+		this.logger('error',`添加集合成员失败 [${key}]:`, err);
+		this.emit('sadd:error', {
 			key,
 			members,
 			error: err
@@ -3552,22 +3549,22 @@ Redis.prototype.sadd = async function(key, members) {
 Redis.prototype.srem = async function(key, members) {
 	try {
 		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
 			members: Array.isArray(members) ? members : [members],
 			cancel: false
 		};
-		this.emit('srem_before', beforeEventData);
+		this.emit('srem:before', ctx);
 
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] srem操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`srem操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
 		const {
 			key: finalKey,
 			members: finalMembers
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -3575,7 +3572,7 @@ Redis.prototype.srem = async function(key, members) {
 			const result = await connection.sRem(prefixedKey, finalMembers);
 
 			// 触发后置事件
-			this.emit('srem_after', {
+			this.emit('srem:after', {
 				key: finalKey,
 				members: finalMembers,
 				result
@@ -3585,8 +3582,8 @@ Redis.prototype.srem = async function(key, members) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 移除集合成员失败 [${key}]:`, err);
-		this.emit('srem_error', {
+		this.logger('error',`移除集合成员失败 [${key}]:`, err);
+		this.emit('srem:error', {
 			key,
 			members,
 			error: err
@@ -3605,15 +3602,15 @@ Redis.prototype.sismember = async function(key, member) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] sismember参数错误: key must be a non-empty string');
+			this.logger('error','sismember参数错误: key must be a non-empty string');
 			return false;
 		}
 		if (member === undefined || member === null) {
-			$.log.error('[Redis] sismember参数错误: member cannot be undefined or null');
+			this.logger('error','sismember参数错误: member cannot be undefined or null');
 			return false;
 		}
 
-		this.emit('sismember_before', {
+		this.emit('sismember:before', {
 			key,
 			member
 		});
@@ -3623,7 +3620,7 @@ Redis.prototype.sismember = async function(key, member) {
 			// 将成员转换为字符串，与其他模块行为一致
 			const memberStr = String(member);
 			const result = await connection.sIsMember(prefixedKey, memberStr);
-			this.emit('sismember_after', {
+			this.emit('sismember:after', {
 				key,
 				member,
 				result
@@ -3633,12 +3630,12 @@ Redis.prototype.sismember = async function(key, member) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		this.emit('sismember_error', {
+		this.emit('sismember:error', {
 			key,
 			member,
 			error: err
 		});
-		$.log.error(`[Redis] 检查集合成员失败 [${key}:${member}]:`, err);
+		this.logger('error',`检查集合成员失败 [${key}:${member}]:`, err);
 		return false;
 	}
 };
@@ -3654,7 +3651,7 @@ Redis.prototype.smembers = async function(key) {
 		try {
 			const prefixedKey = this.applyPrefix(key);
 			const result = await connection.sMembers(prefixedKey);
-			this.emit('smembers_after', {
+			this.emit('smembers:after', {
 				key,
 				result
 			});
@@ -3663,8 +3660,8 @@ Redis.prototype.smembers = async function(key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取集合所有成员失败 [${key}]:`, err);
-		this.emit('smembers_error', {
+		this.logger('error',`获取集合所有成员失败 [${key}]:`, err);
+		this.emit('smembers:error', {
 			key,
 			error: err
 		});
@@ -3688,7 +3685,7 @@ Redis.prototype.scard = async function(key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取集合大小失败 [${key}]:`, err);
+		this.logger('error',`获取集合大小失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -3710,7 +3707,7 @@ Redis.prototype.sinter = async function(keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取集合交集失败:`, err);
+		this.logger('error',`获取集合交集失败:`, err);
 		return [];
 	}
 };
@@ -3732,7 +3729,7 @@ Redis.prototype.sunion = async function(keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取集合并集失败:`, err);
+		this.logger('error',`获取集合并集失败:`, err);
 		return [];
 	}
 };
@@ -3754,7 +3751,7 @@ Redis.prototype.sdiff = async function(keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取集合差集失败:`, err);
+		this.logger('error',`获取集合差集失败:`, err);
 		return [];
 	}
 };
@@ -3771,16 +3768,16 @@ Redis.prototype.sdiff = async function(keys) {
 Redis.prototype.zadd = async function(key, score, member) {
 	try {
 		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
 			score,
 			member,
 			cancel: false
 		};
-		this.emit('zadd_before', beforeEventData);
+		this.emit('zadd:before', ctx);
 
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] zadd操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`zadd操作被事件处理器取消 [${key}]`);
 			return false;
 		}
 
@@ -3788,7 +3785,7 @@ Redis.prototype.zadd = async function(key, score, member) {
 			key: finalKey,
 			score: finalScore,
 			member: finalMember
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -3799,7 +3796,7 @@ Redis.prototype.zadd = async function(key, score, member) {
 			});
 
 			// 触发后置事件
-			this.emit('zadd_after', {
+			this.emit('zadd:after', {
 				key: finalKey,
 				score: finalScore,
 				member: finalMember,
@@ -3810,8 +3807,8 @@ Redis.prototype.zadd = async function(key, score, member) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 添加有序集合成员失败 [${key}]:`, err);
-		this.emit('zadd_error', {
+		this.logger('error',`添加有序集合成员失败 [${key}]:`, err);
+		this.emit('zadd:error', {
 			key,
 			score,
 			member,
@@ -3830,22 +3827,22 @@ Redis.prototype.zadd = async function(key, score, member) {
 Redis.prototype.zrem = async function(key, members) {
 	try {
 		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
 			members: Array.isArray(members) ? members : [members],
 			cancel: false
 		};
-		this.emit('zrem_before', beforeEventData);
+		this.emit('zrem:before', ctx);
 
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] zrem操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`zrem操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
 		const {
 			key: finalKey,
 			members: finalMembers
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -3853,15 +3850,15 @@ Redis.prototype.zrem = async function(key, members) {
 			const result = await connection.zRem(this.applyPrefix(finalKey), ...finalMembers);
 
 			// 触发后置事件
-			this.emit('zrem_after', {
+			this.emit('zrem:after', {
 				key: finalKey,
 				members: finalMembers,
 				result
 			});
 			return result;
 		} catch (err) {
-			$.log.error(`[Redis] 移除有序集合成员失败 [${finalKey}]:`, err);
-			this.emit('zrem_error', {
+			this.logger('error',`移除有序集合成员失败 [${finalKey}]:`, err);
+			this.emit('zrem:error', {
 				key: finalKey,
 				members: finalMembers,
 				error: err
@@ -3871,8 +3868,8 @@ Redis.prototype.zrem = async function(key, members) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 移除有序集合成员失败 [${key}]:`, err);
-		this.emit('zrem_error', {
+		this.logger('error',`移除有序集合成员失败 [${key}]:`, err);
+		this.emit('zrem:error', {
 			key,
 			members,
 			error: err
@@ -3898,7 +3895,7 @@ Redis.prototype.zscore = async function(key, member) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取有序集合成员分数失败 [${key}:${member}]:`, err);
+		this.logger('error',`获取有序集合成员分数失败 [${key}:${member}]:`, err);
 		return null;
 	}
 };
@@ -3920,7 +3917,7 @@ Redis.prototype.zrank = async function(key, member) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取有序集合成员排名失败 [${key}:${member}]:`, err);
+		this.logger('error',`获取有序集合成员排名失败 [${key}:${member}]:`, err);
 		return null;
 	}
 };
@@ -3961,13 +3958,13 @@ Redis.prototype.zrange = async function(key, start, stop, withScores = false) {
 								member,
 								score: 0
 							});
-							$.log.warn(`[Redis] 获取成员 ${member} 分数失败:`, scoreErr);
+							throw new Error(`获取成员 ${member} 分数失败:`, scoreErr);
 						}
 					}
 
 					return results;
 				} catch (err) {
-					$.log.error(`[Redis] 使用备用方法获取有序集合范围失败 [${prefixedKey}]:`, err);
+					this.logger('error',`使用备用方法获取有序集合范围失败 [${prefixedKey}]:`, err);
 					// 回退到简单列表
 					return [];
 				}
@@ -3980,7 +3977,7 @@ Redis.prototype.zrange = async function(key, start, stop, withScores = false) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取有序集合范围成员失败 [${key}]:`, err);
+		this.logger('error',`获取有序集合范围成员失败 [${key}]:`, err);
 		return [];
 	}
 };
@@ -3998,13 +3995,13 @@ Redis.prototype.zcard = async function(key) {
 			const result = await connection.zCard(this.applyPrefix(key));
 			return result || 0;
 		} catch (err) {
-			$.log.error(`[Redis] 获取有序集合成员数量失败 [${key}]:`, err);
+			this.logger('error',`获取有序集合成员数量失败 [${key}]:`, err);
 			return 0;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取有序集合成员数量失败 [${key}]:`, err);
+		this.logger('error',`获取有序集合成员数量失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -4021,30 +4018,30 @@ Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
+			this.logger('error','参数错误: 键必须是非空字符串');
 			return null;
 		}
 		if (typeof increment !== 'number' || isNaN(increment)) {
-			$.log.error('[Redis] 参数错误: 增量必须是有效数字');
+			this.logger('error','参数错误: 增量必须是有效数字');
 			return null;
 		}
 		if (!member || typeof member !== 'string') {
-			$.log.error('[Redis] 参数错误: 成员必须是非空字符串');
+			this.logger('error','参数错误: 成员必须是非空字符串');
 			return null;
 		}
 
 		// 触发前置事件
-		const beforeEventData = {
+		const ctx = {
 			key,
 			increment,
 			member,
 			seconds,
 			cancel: false
 		};
-		this.emit('zincrby_before', beforeEventData);
+		this.emit('zincrby:before', ctx);
 
-		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] zincrby操作被事件处理器取消 [${key}]`);
+		if (ctx.cancel) {
+			this.logger('debug',`zincrby操作被事件处理器取消 [${key}]`);
 			return null;
 		}
 
@@ -4053,7 +4050,7 @@ Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
 			increment: finalIncrement,
 			member: finalMember,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
@@ -4071,7 +4068,7 @@ Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
 			}
 
 			// 触发后置事件
-			this.emit('zincrby_after', {
+			this.emit('zincrby:after', {
 				key: finalKey,
 				increment: finalIncrement,
 				member: finalMember,
@@ -4080,8 +4077,8 @@ Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
 			});
 			return parseFloat(result);
 		} catch (err) {
-			$.log.error(`[Redis] 增加有序集合成员分数失败 [${finalKey}]:`, err);
-			this.emit('zincrby_error', {
+			this.logger('error',`增加有序集合成员分数失败 [${finalKey}]:`, err);
+			this.emit('zincrby:error', {
 				key: finalKey,
 				increment: finalIncrement,
 				member: finalMember,
@@ -4093,8 +4090,8 @@ Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 增加有序集合成员分数失败 [${key}]:`, err);
-		this.emit('zincrby_error', {
+		this.logger('error',`增加有序集合成员分数失败 [${key}]:`, err);
+		this.emit('zincrby:error', {
 			key,
 			increment,
 			member,
@@ -4127,19 +4124,19 @@ Redis.prototype._createConnection = function() {
 
 			// 监听错误事件
 			connection.on('error', (err) => {
-				$.log.error(`[Redis] 连接 ${connection.id} 错误:`, err);
+				this.logger('error',`连接 ${connection.id} 错误:`, err);
 			});
 
 			// 连接Redis
 			connection.connect().then(() => {
-				// $.log.debug('[Redis] 新连接已创建并连接:', connection.id);
+				// this.logger('debug','新连接已创建并连接:', connection.id);
 				resolve(connection);
 			}).catch(err => {
-				$.log.error('[Redis] 创建连接失败:', err);
+				this.logger('error','创建连接失败:', err);
 				reject(err);
 			});
 		} catch (error) {
-			$.log.error('[Redis] 创建连接时发生异常:', error);
+			this.logger('error','创建连接时发生异常:', error);
 			reject(error);
 		}
 	});