mm_redis 2.0.6 → 2.0.8

package/index.js

@@ -1,20 +1,13 @@
-/**
- * @fileOverview redis缓存帮助类函数
- * @author <a href="http://qww.elins.cn">邱文武</a>
- * @version 1.5.0
- */
-const {
-	BaseService
-} = require('mm_base_service');
 const {
 	createClient
 } = require('redis');
+const { Base } = require('mm_expand');
 
-// Redis缓存帮助类函数
-
-/* 创建Redis帮助类函数 */
-/// 构造函数
-class Redis extends BaseService {
+/**
+ * @class Redis
+ * @description Redis缓存帮助类函数
+ */
+class Redis extends Base {
 	/**
 	 * @description 创建Redis帮助类函数 (构造函数)
 	 * @param {Object} config 配置参数
@@ -68,8 +61,9 @@ class Redis extends BaseService {
  * 应用键前缀
  * @param {String} key 键
  * @return {String} 处理后的键
+ * @private
  */
-Redis.prototype.applyPrefix = function(key) {
+Redis.prototype._addPrefix = function (key) {
 	return this.config.prefix ? this.config.prefix + key : key;
 };
 
@@ -77,8 +71,9 @@ Redis.prototype.applyPrefix = function(key) {
  * 移除键前缀
  * @param {String} key 带前缀的键
  * @return {String} 处理后的键
+ * @private
  */
-Redis.prototype.removePrefix = function(key) {
+Redis.prototype._delPrefix = function (key) {
 	if (this.config.prefix && key.startsWith(this.config.prefix)) {
 		return key.slice(this.config.prefix.length);
 	}
@@ -91,13 +86,21 @@ Redis.prototype.removePrefix = function(key) {
  * @param {Function} func 操作回调函数，可判断成功与否
  * @return {Promise<Boolean>} 订阅结果
  */
-Redis.prototype.subscribe = async function(channel, func) {
+Redis.prototype.subscribe = async function (channel, func) {
 	try {
-		await this.conn.subscribe(this.applyPrefix(channel));
+		// 参数验证
+		if (!channel || typeof channel !== 'string') {
+			throw new TypeError('channel必须是非空字符串');
+		}
+		if (typeof func !== 'function') {
+			throw new TypeError('func必须是函数');
+		}
+
+		await this.conn.subscribe(this._addPrefix(channel));
 		this.func_list[channel] = func;
 		return true;
 	} catch (err) {
-		$.log.error(`[Redis] 订阅频道 ${channel} 失败:`, err);
+		this.logger('error', `订阅频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -107,13 +110,18 @@ Redis.prototype.subscribe = async function(channel, func) {
  * @param {String} channel 订阅的频道
  * @return {Promise<Boolean>} 取消订阅结果
  */
-Redis.prototype.unsubscribe = async function(channel) {
+Redis.prototype.unsubscribe = async function (channel) {
 	try {
-		await this.conn.unsubscribe(this.applyPrefix(channel));
+		// 参数验证
+		if (!channel || typeof channel !== 'string') {
+			throw new TypeError('channel必须是非空字符串');
+		}
+
+		await this.conn.unsubscribe(this._addPrefix(channel));
 		delete this.func_list[channel];
 		return true;
 	} catch (err) {
-		$.log.error(`[Redis] 取消订阅频道 ${channel} 失败:`, err);
+		this.logger('error', `取消订阅频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -124,12 +132,19 @@ Redis.prototype.unsubscribe = async function(channel) {
  * @param {String} message 订阅的消息
  * @return {Promise<Number>} 接收消息的客户端数量
  */
-Redis.prototype.publish = async function(channel, message) {
+Redis.prototype.publish = async function (channel, message) {
 	try {
-		return await this.conn.publish(this.applyPrefix(channel), message);
+		// 参数验证
+		if (!channel || typeof channel !== 'string') {
+			throw new TypeError('channel必须是非空字符串');
+		}
+		if (message === undefined || message === null) {
+			throw new TypeError('message不能为undefined或null');
+		}
+
+		return await this.conn.publish(this._addPrefix(channel), message);
 	} catch (err) {
-		$.log.error(`[Redis] 发布消息到频道 ${channel} 失败:`, err);
-		$.log.error('[Redis] 操作失败:', err);
+		this.logger('error', `发布消息到频道 ${channel} 失败:`, err);
 		return false;
 	}
 };
@@ -139,9 +154,9 @@ Redis.prototype.publish = async function(channel, message) {
  * @param {String} channel
  * @param {String} message
  */
-Redis.prototype.main = async function(channel, message) {
+Redis.prototype.main = async function (channel, message) {
 	// 默认实现，可由子类重写
-	$.log.debug(`[Redis] 收到未处理的消息 [${channel}]:`, message);
+	this.logger('debug', `收到未处理的消息 [${channel}]:`, message);
 };
 
 /**
@@ -149,15 +164,15 @@ Redis.prototype.main = async function(channel, message) {
  * @param {String} channel 频道
  * @param {String} message 消息
  */
-Redis.prototype.message = function(channel, message) {
+Redis.prototype.message = function (channel, message) {
 	// 移除前缀
-	channel = this.removePrefix(channel);
+	channel = this._delPrefix(channel);
 	var func = this.func_list[channel];
 	if (func) {
 		try {
 			func(message);
 		} catch (err) {
-			$.log.error(`[Redis] 处理频道 ${channel} 的消息时出错:`, err);
+			this.logger('error', `处理频道 ${channel} 的消息时出错:`, err);
 		}
 	} else {
 		this.main(channel, message);
@@ -168,7 +183,7 @@ Redis.prototype.message = function(channel, message) {
  * @description 设置配置
  * @param {Object} config 配置对象或配置路径
  */
-Redis.prototype.setConfig = function(config) {
+Redis.prototype.setConfig = function (config) {
 	let obj = {};
 	if (typeof config === 'string') {
 		obj = config.loadJson(__dirname);
@@ -219,13 +234,13 @@ Redis.prototype.setConfig = function(config) {
 
 	// 初始化连接池
 	this._initPool();
-	// $.log.debug('[Redis] 配置已更新');
+	// this.logger('debug','配置已更新');
 	this.identifier = this.config.host + "/" + this.config.database;
 	return this;
 };
 
 // 添加连接池初始化方法
-Redis.prototype._initPool = function() {
+Redis.prototype._initPool = function () {
 	// 确保连接池配置存在
 	if (!this.config.pool) {
 		this.config.pool = {
@@ -244,14 +259,14 @@ Redis.prototype._initPool = function() {
 	};
 
 	// 记录连接池初始化
-	// $.log.debug('[Redis] 连接池已初始化，配置:', this.config.pool);
+	// this.logger('debug','连接池已初始化，配置:', this.config.pool);
 };
 
 /**
  * @description 连接Redis数据库
  * @return {Promise<Boolean>} 连接结果
  */
-Redis.prototype.open = async function() {
+Redis.prototype.open = async function () {
 	if (this.conn && this.connected) {
 		return true;
 	}
@@ -273,7 +288,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 +296,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._delPrefix(channel)}订阅成功, 当前总计订阅数：${count}`);
 		});
 
 		// 监听取消订阅事件
 		this.conn.on('unsubscribe', (channel, count) => {
-			$.log.debug(`[Redis] 频道${this.removePrefix(channel)}取消订阅, 当前总计订阅数：${count}`);
+			this.logger('debug', `频道${this._delPrefix(channel)}取消订阅, 当前总计订阅数：${count}`);
 		});
 
 		// 收到消息后执行回调
@@ -312,7 +327,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;
@@ -323,20 +338,20 @@ Redis.prototype.open = async function() {
  * 内部重连方法
  * @private
  */
-Redis.prototype._reconnect = function() {
+Redis.prototype._reconnect = function () {
 	if (this.retry_count >= this.config.retry_count) {
-		$.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);
 };
@@ -346,9 +361,9 @@ Redis.prototype._reconnect = function() {
  * @return {Promise<Boolean>} 关闭结果
  */
 // 修复close方法，正确处理连接池
-Redis.prototype.close = function() {
+Redis.prototype.close = function () {
 	try {
-		// $.log.debug('[Redis] 关闭所有连接...');
+		// this.logger('debug','关闭所有连接...');
 
 		// 关闭所有使用中的连接
 		if (this.connection_pool && this.connection_pool.in_use) {
@@ -356,7 +371,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,68 +388,68 @@ 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);
 	}
 };
 
 // 添加Pipeline支持
-Redis.prototype.pipeline = function() {
+Redis.prototype.pipeline = function () {
 	const redisInstance = this;
 	const commands = [];
 
 	return {
 		// 设置值
-		set: function(key, value, seconds) {
+		set: function (key, value, seconds) {
 			commands.push(['set', key, value, seconds]);
 			return this;
 		},
 
 		// 获取值
-		get: function(key) {
+		get: function (key) {
 			commands.push(['get', key]);
 			return this;
 		},
 
 		// 删除
-		del: function(key) {
+		del: function (key) {
 			commands.push(['del', key]);
 			return this;
 		},
 
 		// 判断存在
-		has: function(key) {
+		has: function (key) {
 			commands.push(['has', key]);
 			return this;
 		},
 
 		// 设置哈希字段
-		hset: function(key, field, value) {
+		hset: function (key, field, value) {
 			commands.push(['hset', key, field, value]);
 			return this;
 		},
 
 		// 过期时间设置
-		expire: function(key, seconds) {
+		expire: function (key, seconds) {
 			commands.push(['expire', key, seconds]);
 			return this;
 		},
 
 		// 执行所有命令
-		exec: async function() {
+		exec: async function () {
 			try {
 				// 使用Redis实例的方法获取连接
 				const connection = await redisInstance._getConnection();
@@ -451,7 +466,7 @@ Redis.prototype.pipeline = function() {
 							case 'set': {
 								// 键前缀处理和值序列化
 								const [key, value, seconds] = args;
-								const prefixedKey = redisInstance.applyPrefix(key);
+								const prefixedKey = redisInstance._addPrefix(key);
 								let processedValue = value;
 								if (typeof value === 'object' && value !== null) {
 									processedValue = JSON.stringify(value);
@@ -465,7 +480,7 @@ Redis.prototype.pipeline = function() {
 							}
 							case 'get': {
 								const [key] = args;
-								const prefixedKey = redisInstance.applyPrefix(key);
+								const prefixedKey = redisInstance._addPrefix(key);
 								result = await connection.get(prefixedKey);
 								// 尝试解析JSON
 								if (typeof result === 'string') {
@@ -482,25 +497,25 @@ Redis.prototype.pipeline = function() {
 							}
 							case 'del': {
 								const [key] = args;
-								const prefixedKey = redisInstance.applyPrefix(key);
+								const prefixedKey = redisInstance._addPrefix(key);
 								result = await connection.del(prefixedKey);
 								break;
 							}
 							case 'has': {
 								const [key] = args;
-								const prefixedKey = redisInstance.applyPrefix(key);
+								const prefixedKey = redisInstance._addPrefix(key);
 								result = await connection.exists(prefixedKey) > 0;
 								break;
 							}
 							case 'hset': {
 								const [key, field, value] = args;
-								const prefixedKey = redisInstance.applyPrefix(key);
+								const prefixedKey = redisInstance._addPrefix(key);
 								result = await connection.hSet(prefixedKey, field, value);
 								break;
 							}
 							case 'expire': {
 								const [key, seconds] = args;
-								const prefixedKey = redisInstance.applyPrefix(key);
+								const prefixedKey = redisInstance._addPrefix(key);
 								result = await connection.expire(prefixedKey, seconds);
 								break;
 							}
@@ -513,7 +528,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 +537,7 @@ Redis.prototype.pipeline = function() {
 				redisInstance._recycleConnection(connection);
 				return results;
 			} catch (error) {
-				$.log.error('[Redis] Pipeline执行失败:', error);
+				this.logger('error', 'Pipeline执行失败:', error);
 				return [];
 			}
 		}
@@ -533,7 +548,7 @@ Redis.prototype.pipeline = function() {
  * @description 检查连接状态
  * @return {Boolean} 连接状态
  */
-Redis.prototype.isConnected = function() {
+Redis.prototype.isConnected = function () {
 	return this.connected && this.conn && this.conn.isReady;
 };
 
@@ -549,11 +564,16 @@ Redis.prototype.isConnected = function() {
  * @param {Number} [seconds] 过期时间（秒），不传此参数则获取剩余过期时间
  * @return {Promise<Number|Boolean>} 不传seconds时返回剩余过期时间（-1表示无过期设置，-2表示已过期），传seconds时返回是否设置成功
  */
-Redis.prototype.ttl = async function(key, seconds) {
+Redis.prototype.ttl = async function (key, seconds) {
 	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			throw new TypeError('key必须是非空字符串');
+		}
+
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 
 			// 如果传入了seconds参数，则设置过期时间
 			if (seconds !== undefined) {
@@ -569,7 +589,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 +600,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;
 	}
 };
@@ -599,30 +619,30 @@ Redis.prototype.ttl = async function(key, seconds) {
  * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 计算后的结果
  */
-Redis.prototype.addInt = async function(key, num, seconds = 0) {
+Redis.prototype.addInt = async function (key, num, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.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,11 +651,11 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
 			key: finalKey,
 			value: finalNum,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			let result;
 			if (finalNum > 0) {
 				// 增加整数值
@@ -645,7 +665,7 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
 					result = await connection.execute('INCRBY', [prefixedKey, finalNum]);
 				} else {
 					// 如果出错，回退到先获取再设置的方式
-					$.log.warn(`[Redis] 使用原子操作增加整数值失败，使用回退方案`);
+					this.logger('warn', `使用原子操作增加整数值失败，使用回退方案 [${key}]`);
 					let value = await this.get(prefixedKey);
 					let n = 0;
 					if (value) {
@@ -663,7 +683,7 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
 					result = await connection.execute('DECRBY', [prefixedKey, -finalNum]);
 				} else {
 					// 如果出错，回退到先获取再设置的方式
-					$.log.warn(`[Redis] 使用原子操作减少整数值失败，使用回退方案`);
+					this.logger('warn', `使用原子操作减少整数值失败，使用回退方案`);
 					let value = await this.get(prefixedKey);
 					let n = 0;
 					if (value) {
@@ -685,7 +705,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 +718,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;
 	}
@@ -717,33 +737,31 @@ Redis.prototype.addInt = async function(key, num, seconds = 0) {
  * @param {Number} seconds 过期时间，0表示永不过期
  * @return {Promise<Number>} 计算后的结果
  */
-Redis.prototype.addFloat = async function(key, num, seconds = 0) {
+Redis.prototype.addFloat = async function (key, num, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.warn(`[Redis] addFloat: key参数必须是非空字符串`);
-			return 0;
+			throw new TypeError('key必须是非空字符串');
 		}
 
 		// 验证num参数
 		num = parseFloat(num);
 		if (isNaN(num)) {
-			$.log.warn(`[Redis] addFloat: num参数必须是有效的数值`);
-			return 0;
+			throw new TypeError('num必须是有效的数值');
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		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,12 +770,12 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 			key: finalKey,
 			value: finalNum,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 		let result;
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 
 			// 优先使用原生方法
 			if (typeof connection.incrByFloat === 'function') {
@@ -769,7 +787,7 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 			}
 			// 回退方案
 			else {
-				$.log.warn(`[Redis] 连接对象不支持incrByFloat操作，使用回退方案`);
+				this.logger('warn', `连接对象不支持incrByFloat操作，使用回退方案`);
 				let value = await this.get(prefixedKey);
 				let n = 0;
 				if (value) {
@@ -790,7 +808,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 +818,7 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 			return result;
 		} catch (err) {
 			// 如果出错，回退到先获取再设置的方式
-			$.log.warn(`[Redis] 使用原子操作增加浮点数值失败，使用回退方案:`, err);
+			this.logger('warn', `使用原子操作增加浮点数值失败，使用回退方案:`, err);
 			let value = await this.get(prefixedKey);
 			let n = 0;
 			if (value) {
@@ -810,7 +828,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 +841,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;
 	}
@@ -842,33 +860,31 @@ Redis.prototype.addFloat = async function(key, num, seconds = 0) {
  * @param {Number} seconds 过期时间，0表示永不过期
  * @return {Promise<Number>} 添加后的字符串长度
  */
-Redis.prototype.addStr = async function(key, str, seconds = 0) {
+Redis.prototype.addStr = async function (key, str, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.warn(`[Redis] addStr: key参数必须是非空字符串`);
-			return 0;
+			throw new TypeError('key必须是非空字符串');
 		}
 
 		// 验证str参数
 		if (str === undefined || str === null) {
-			$.log.warn(`[Redis] addStr: str参数不能为undefined或null`);
-			return 0;
+			throw new TypeError('str不能为undefined或null');
 		}
 		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,12 +893,12 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
 			key: finalKey,
 			value: finalStr,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 		let result;
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 
 			// 优先使用原生方法
 			if (typeof connection.append === 'function') {
@@ -894,7 +910,7 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
 			}
 			// 回退方案
 			else {
-				$.log.warn(`[Redis] 连接对象不支持append操作，使用回退方案`);
+				this.logger('warn', `连接对象不支持append操作，使用回退方案`);
 				let value = await this.get(prefixedKey) || '';
 				value += finalStr;
 				await this.set(prefixedKey, value, finalSeconds);
@@ -911,7 +927,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 +936,14 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
 			});
 			return result;
 		} catch (err) {
-			$.log.error('[Redis] 追加字符串失败:', err);
+			this.logger('warn', '追加字符串失败:', 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 +956,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;
 	}
 };
@@ -956,51 +972,47 @@ Redis.prototype.addStr = async function(key, str, seconds = 0) {
  * @param {String|Array<String>} key 键或键数组
  * @return {Promise<Boolean>} 成功返回true,失败返回false
  */
-Redis.prototype.del = async function(key) {
+Redis.prototype.del = async function (key) {
 	try {
 		// 键名必须是非空字符串或非空字符串数组
 		if (!key) {
-			$.log.warn('[Redis] del: key必须是非空字符串或非空字符串数组');
-			return false;
+			throw new TypeError('key必须是非空字符串或非空字符串数组');
 		}
 
 		// 如果是单个键，验证是否为非空字符串
 		if (typeof key === 'string') {
 			if (!key) {
-				$.log.warn('[Redis] del: key必须是非空字符串');
-				return false;
+				throw new TypeError('key必须是非空字符串');
 			}
 		}
 		// 如果是数组，验证每个元素是否为非空字符串
 		else if (Array.isArray(key)) {
 			for (const k of key) {
 				if (!k || typeof k !== 'string') {
-					$.log.warn('[Redis] del: key必须是非空字符串或非空字符串数组');
-					return false;
+					throw new TypeError('key必须是非空字符串或非空字符串数组');
 				}
 			}
 		} else {
-			$.log.warn('[Redis] del: key必须是非空字符串或非空字符串数组');
-			return false;
+			throw new TypeError('key必须是非空字符串或非空字符串数组');
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		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 {
@@ -1010,7 +1022,7 @@ Redis.prototype.del = async function(key) {
 				success = true;
 				const deleted = [];
 				for (const k of finalKey) {
-					const prefixedKey = this.applyPrefix(k);
+					const prefixedKey = this._addPrefix(k);
 					const result = await connection.del(prefixedKey);
 					if (result !== 1) {
 						success = false;
@@ -1019,18 +1031,18 @@ Redis.prototype.del = async function(key) {
 					}
 				}
 				// 触发后置事件
-				this.emit('del_after', {
+				this.emit('del:after', {
 					key: finalKey,
 					success,
 					deleted
 				});
 			} else {
 				// 单个删除
-				const prefixedKey = this.applyPrefix(finalKey);
+				const prefixedKey = this._addPrefix(finalKey);
 				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 +1054,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;
 	}
 };
@@ -1065,26 +1077,25 @@ Redis.prototype.del = async function(key) {
  * @param {Number} seconds 过期时间，0表示永不过期
  * @return {Promise<Boolean>} 成功返回true,失败返回false
  */
-Redis.prototype.set = async function(key, value, seconds = 0) {
+Redis.prototype.set = async function (key, value, seconds = 0) {
 	try {
 		// 键名必须是非空字符串
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: key必须是非空字符串');
-			return false;
+			throw new TypeError('key必须是非空字符串');
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		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,12 +1104,12 @@ Redis.prototype.set = async function(key, value, seconds = 0) {
 			key: finalKey,
 			value: finalValue,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
-			if (typeof(finalValue) === "object") {
+			const prefixedKey = this._addPrefix(finalKey);
+			if (typeof (finalValue) === "object") {
 				finalValue = JSON.stringify(finalValue);
 			}
 
@@ -1111,7 +1122,7 @@ Redis.prototype.set = async function(key, value, seconds = 0) {
 			}
 
 			// 触发后置事件
-			this.emit('set_after', {
+			this.emit('set:after', {
 				key,
 				value,
 				seconds,
@@ -1122,9 +1133,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,
@@ -1141,20 +1152,28 @@ Redis.prototype.set = async function(key, value, seconds = 0) {
  * @param {Number} seconds 过期时间（秒）
  * @return {Promise<Boolean>} 操作结果，键不存在时设置成功返回true，键已存在返回false
  */
-Redis.prototype.add = async function(key, value, seconds) {
+Redis.prototype.add = async function (key, value, seconds) {
 	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			throw new TypeError('key必须是非空字符串');
+		}
+		if (value === undefined || value === null) {
+			throw new TypeError('value不能为undefined或null');
+		}
+
 		// 触发前置事件，允许修改或阻止操作
-		const 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,12 +1182,12 @@ Redis.prototype.add = async function(key, value, seconds) {
 			key: finalKey,
 			value: finalValue,
 			ttl: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
-			if (typeof(finalValue) === "object") {
+			finalKey = this._addPrefix(finalKey);
+			if (typeof (finalValue) === "object") {
 				finalValue = JSON.stringify(finalValue);
 			}
 
@@ -1183,7 +1202,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 +1213,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,
@@ -1216,36 +1235,35 @@ Redis.prototype.add = async function(key, value, seconds) {
  * @param {String} key 键
  * @return {Promise<*>} 获取到的值，不存在时返回null
  */
-Redis.prototype.get = async function(key) {
+Redis.prototype.get = async function (key) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.warn(`[Redis] get: key参数必须是非空字符串`);
-			return null;
+			throw new TypeError('key必须是非空字符串');
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		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 {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			const value = await connection.get(prefixedKey);
 			let result = value;
-			if (typeof(value) === "string") {
+			if (typeof (value) === "string") {
 				// 尝试解析JSON
 				try {
 					if (value.startsWith("{") && value.endsWith("}") ||
@@ -1258,7 +1276,7 @@ Redis.prototype.get = async function(key) {
 			}
 
 			// 触发后置事件
-			this.emit('get_after', {
+			this.emit('get:after', {
 				key: finalKey,
 				value: result,
 				success: true
@@ -1270,11 +1288,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;
 	}
 };
@@ -1284,38 +1302,37 @@ Redis.prototype.get = async function(key) {
  * @param {String} key 键
  * @return {Promise<Boolean>} 有返回true, 没有返回false
  */
-Redis.prototype.has = async function(key) {
+Redis.prototype.has = async function (key) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.warn(`[Redis] has: key参数必须是非空字符串`);
-			return false;
+			throw new TypeError('key必须是非空字符串');
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		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 {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			const result = await connection.exists(prefixedKey);
 			const exists = result > 0;
 
 			// 触发后置事件
-			this.emit('has_after', {
+			this.emit('has:after', {
 				key: finalKey,
 				result: exists,
 				success: true
@@ -1327,11 +1344,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;
 	}
 };
@@ -1341,63 +1358,59 @@ Redis.prototype.has = async function(key) {
  * @param {String|Array<String>} key 键或键数组
  * @return {Promise<Number>} 存在的键数量
  */
-Redis.prototype.exists = async function(key) {
+Redis.prototype.exists = async function (key) {
 	try {
 		// 参数验证
 		if (!key) {
-			$.log.warn('[Redis] exists: key必须是非空字符串或非空字符串数组');
-			return 0;
+			throw new TypeError('key必须是非空字符串或非空字符串数组');
 		}
 
 		// 如果是单个键，验证是否为非空字符串
 		if (typeof key === 'string') {
 			if (!key) {
-				$.log.warn('[Redis] exists: key必须是非空字符串');
-				return 0;
+				throw new TypeError('key必须是非空字符串');
 			}
 		}
 		// 如果是数组，验证每个元素是否为非空字符串
 		else if (Array.isArray(key)) {
 			for (const k of key) {
 				if (!k || typeof k !== 'string') {
-					$.log.warn('[Redis] exists: key必须是非空字符串或非空字符串数组');
-					return 0;
+					throw new TypeError('key必须是非空字符串或非空字符串数组');
 				}
 			}
 		} else {
-			$.log.warn('[Redis] exists: key必须是非空字符串或非空字符串数组');
-			return 0;
+			throw new TypeError('key必须是非空字符串或非空字符串数组');
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		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 {
 			let result;
 			if (typeof finalKey === 'string') {
-				const prefixedKey = this.applyPrefix(finalKey);
+				const prefixedKey = this._addPrefix(finalKey);
 				result = await connection.exists(prefixedKey);
 			} else if (Array.isArray(finalKey)) {
-				const prefixedKeys = finalKey.map(k => this.applyPrefix(k));
+				const prefixedKeys = finalKey.map(k => this._addPrefix(k));
 				result = await connection.exists(...prefixedKeys);
 			}
 
 			// 触发后置事件
-			this.emit('exists_after', {
+			this.emit('exists:after', {
 				key: finalKey,
 				result,
 				success: true
@@ -1409,11 +1422,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;
 	}
 };
@@ -1425,14 +1438,14 @@ Redis.prototype.exists = async function(key) {
  * @param {Number} end 结束位置
  * @return {Promise<String>} 查询值
  */
-Redis.prototype.getrange = async function(key, start, end) {
+Redis.prototype.getrange = async function (key, start, end) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 			return await connection.getRange(key, start, end);
 		} catch (err) {
-			$.log.error('[Redis] 获取字符串范围失败:', err);
+			this.logger('error', '获取字符串范围失败:', err);
 			// 回退方案
 			const value = await this.get(key);
 			if (value && typeof value === 'string') {
@@ -1443,7 +1456,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 '';
 	}
 };
@@ -1455,7 +1468,7 @@ Redis.prototype.getrange = async function(key, start, end) {
  * @param {String} str_sub 插入的字符串
  * @return {String} 插入后的字符串
  */
-Redis.prototype.insertString = function(str, index, str_sub) {
+Redis.prototype.insertString = function (str, index, str_sub) {
 	return str.substring(0, index) + str_sub + str.substring(index);
 };
 
@@ -1466,20 +1479,20 @@ Redis.prototype.insertString = function(str, index, str_sub) {
  * @param {String} value 变更的值
  * @return {Promise<Number>} 字符串长度
  */
-Redis.prototype.setrange = async function(key, index, value) {
+Redis.prototype.setrange = async function (key, index, value) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const 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,12 +1501,12 @@ Redis.prototype.setrange = async function(key, index, value) {
 			key: finalKey,
 			index: finalIndex,
 			value: finalValue
-		} = beforeEventData;
+		} = ctx;
 		let result;
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			finalKey = this._addPrefix(finalKey);
 
 			// 优先使用原生方法
 			if (typeof connection.setRange === 'function') {
@@ -1505,7 +1518,7 @@ Redis.prototype.setrange = async function(key, index, value) {
 			}
 			// 回退方案
 			else {
-				$.log.warn(`[Redis] 连接对象不支持setRange操作，使用回退方案`);
+				this.logger('warn', `连接对象不支持setRange操作，使用回退方案`);
 				let str = await this.get(finalKey) || '';
 				if (str.length < finalIndex) {
 					// 填充空格到指定索引
@@ -1517,7 +1530,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 +1539,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 +1550,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 +1563,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;
 	}
 };
@@ -1566,25 +1579,25 @@ Redis.prototype.setrange = async function(key, index, value) {
  * @param {String} key 键, 为空则清空所有
  * @return {Promise<Boolean>} 执行结果
  */
-Redis.prototype.clear = async function(key) {
+Redis.prototype.clear = async function (key) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const 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 +1614,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 +1630,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;
 	}
 };
@@ -1632,11 +1645,11 @@ Redis.prototype.clear = async function(key) {
  * @param {Object} options 排序选项
  * @return {Promise<Array>} 排序后的数组
  */
-Redis.prototype.sort = async function(key, options = {}) {
+Redis.prototype.sort = async function (key, options = {}) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 			// 默认升序
 			let sortOptions = [];
 			if (options.by) {
@@ -1665,7 +1678,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 +1692,7 @@ Redis.prototype.sort = async function(key, options = {}) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 排序失败 [${key}]:`, err);
+		this.logger('error', `排序失败 [${key}]:`, err);
 		return [];
 	}
 };
@@ -1689,7 +1702,7 @@ Redis.prototype.sort = async function(key, options = {}) {
  * @param {String} pattern 键模式 支持*号
  * @return {Promise<Array>} 键数组
  */
-Redis.prototype.keys = async function(pattern = '*') {
+Redis.prototype.keys = async function (pattern = '*') {
 	try {
 		const connection = await this._getConnection();
 		try {
@@ -1697,12 +1710,12 @@ Redis.prototype.keys = async function(pattern = '*') {
 			const fullPattern = this.config.prefix ? this.config.prefix + pattern : pattern;
 			const keys = await connection.keys(fullPattern);
 			// 返回移除前缀的键
-			return keys.map(key => this.removePrefix(key));
+			return keys.map(key => this._delPrefix(key));
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error('[Redis] 获取键列表失败:', err);
+		this.logger('error', '获取键列表失败:', err);
 		return [];
 	}
 };
@@ -1714,20 +1727,20 @@ Redis.prototype.keys = async function(pattern = '*') {
  * @param {Number} seconds 秒
  * @return {Promise<Number>} 数组长度
  */
-Redis.prototype.setForList = async function(key, value, seconds) {
+Redis.prototype.setForList = async function (key, value, seconds) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const 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,12 +1749,12 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 			key: finalKey,
 			value: finalValue,
 			ttl: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 		let len = 0;
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			finalKey = this._addPrefix(finalKey);
 			// 先清空再添加
 			if (typeof connection.del === 'function') {
 				await connection.del(finalKey);
@@ -1757,7 +1770,7 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 					} else if (typeof connection.execute === 'function') {
 						len = await connection.execute('RPUSH', [finalKey, ...finalValue]);
 					} else {
-						$.log.error('[Redis] 连接对象不支持rPush操作');
+						this.logger('error', '连接对象不支持rPush操作');
 						len = 0;
 					}
 				}
@@ -1768,7 +1781,7 @@ Redis.prototype.setForList = async function(key, value, seconds) {
 				} else if (typeof connection.execute === 'function') {
 					len = await connection.execute('RPUSH', [finalKey, finalValue]);
 				} else {
-					$.log.error('[Redis] 连接对象不支持rPush操作');
+					this.logger('error', '连接对象不支持rPush操作');
 					len = 0;
 				}
 			}
@@ -1779,12 +1792,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 +1810,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;
 	}
 };
@@ -1814,20 +1827,20 @@ Redis.prototype.setForList = async function(key, value, seconds) {
  * @param {Number} seconds 秒
  * @return {Promise<Number>} 追加后的数组长度
  */
-Redis.prototype.addForList = async function(key, value, seconds = 0) {
+Redis.prototype.addForList = async function (key, value, seconds = 0) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const 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,12 +1849,12 @@ 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();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			finalKey = this._addPrefix(finalKey);
 
 			if (Array.isArray(finalValue)) {
 				if (finalValue.length > 0) {
@@ -1851,7 +1864,7 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
 					} else if (typeof connection.execute === 'function') {
 						len = await connection.execute('RPUSH', [finalKey, ...finalValue]);
 					} else {
-						$.log.error('[Redis] 连接对象不支持rPush操作');
+						this.logger('error', '连接对象不支持rPush操作');
 						len = 0;
 					}
 				}
@@ -1862,7 +1875,7 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
 				} else if (typeof connection.execute === 'function') {
 					len = await connection.execute('RPUSH', [finalKey, finalValue]);
 				} else {
-					$.log.error('[Redis] 连接对象不支持rPush操作');
+					this.logger('error', '连接对象不支持rPush操作');
 					len = 0;
 				}
 			}
@@ -1873,12 +1886,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 +1904,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;
 	}
 };
@@ -1907,15 +1920,14 @@ Redis.prototype.addForList = async function(key, value, seconds = 0) {
  * @param {Object} value 值
  * @return {Promise<Boolean>} 存在返回true, 否则返回false
  */
-Redis.prototype.hasForList = async function(key, value) {
+Redis.prototype.hasForList = async function (key, value) {
 	if (!value) {
-		$.log.error('[Redis] 参数错误: 值不能为空');
-		return false;
+		throw new TypeError('值不能为空');
 	}
 
 	try {
 		// 尝试使用Redis的LREM命令来检查是否存在
-		const keyWithPrefix = this.applyPrefix(key);
+		const keyWithPrefix = this._addPrefix(key);
 		// 转换value为字符串以便比较
 		const valueStr = JSON.stringify(value);
 		// 使用scan来查找，避免在大列表上的性能问题
@@ -1925,7 +1937,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;
 	}
 };
@@ -1937,20 +1949,20 @@ Redis.prototype.hasForList = async function(key, value) {
  * @param {Number} end 结束位置
  * @return {Promise<Array>} 查询到的数组
  */
-Redis.prototype.getForList = async function(key, start = 0, end = -1) {
+Redis.prototype.getForList = async function (key, start = 0, end = -1) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const 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,11 +1971,11 @@ Redis.prototype.getForList = async function(key, start = 0, end = -1) {
 			key: finalKey,
 			start: finalStart,
 			end: finalEnd
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			finalKey = this._addPrefix(finalKey);
 			let result;
 			// 检查连接是否支持lRange方法，Redis v4 API
 			if (typeof connection.lRange === 'function') {
@@ -1975,12 +1987,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 +2014,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 +2026,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 [];
 	}
 };
@@ -2030,47 +2042,46 @@ Redis.prototype.getForList = async function(key, start = 0, end = -1) {
  * @param {String} key 键
  * @return {Promise<Boolean>} 成功返回true，失败返回false
  */
-Redis.prototype.clearForList = async function(key) {
+Redis.prototype.clearForList = async function (key) {
 	if (!key) {
-		$.log.error('[Redis] 参数错误: 键不能为空');
-		return false;
+		throw new TypeError('键不能为空');
 	}
 
 	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
-		finalKey = this.applyPrefix(finalKey);
+		finalKey = this._addPrefix(finalKey);
 		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;
 	}
 };
@@ -2085,48 +2096,46 @@ Redis.prototype.clearForList = async function(key) {
  * @param {Array<String>} keys 键数组
  * @return {Promise<Array>} 返回值数组，顺序与键数组一致
  */
-Redis.prototype.mget = async function(keys) {
+Redis.prototype.mget = async function (keys) {
 	try {
 		// 参数验证
 		if (!keys || !Array.isArray(keys)) {
-			$.log.warn('[Redis] mget: keys必须是非空数组');
-			return [];
+			throw new TypeError('keys必须是非空数组');
 		}
 
 		// 验证数组中的每个元素是否为非空字符串
 		for (const key of keys) {
 			if (!key || typeof key !== 'string') {
-				$.log.warn('[Redis] mget: keys数组中的每个元素必须是非空字符串');
-				return [];
+				throw new TypeError('keys数组中的每个元素必须是非空字符串');
 			}
 		}
 
 		// 触发前置事件，允许修改或阻止操作
-		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 {
 			// 直接使用Redis v4的mGet方法，应用键前缀
-			const keysWithPrefix = finalKeys.map(k => this.applyPrefix(k));
+			const keysWithPrefix = finalKeys.map(k => this._addPrefix(k));
 			const values = await connection.mGet(keysWithPrefix);
 
 			// 处理值的格式，保持数组返回格式
 			const result = [];
 			values.forEach((value, index) => {
-				if (typeof(value) === "string") {
+				if (typeof (value) === "string") {
 					try {
 						if (value.startsWith("{") && value.endsWith("}") ||
 							value.startsWith("[") && value.endsWith("]")) {
@@ -2140,7 +2149,7 @@ Redis.prototype.mget = async function(keys) {
 			});
 
 			// 触发后置事件
-			this.emit('mget_after', {
+			this.emit('mget:after', {
 				keys: finalKeys,
 				result,
 				success: true
@@ -2152,11 +2161,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 [];
 	}
 }
@@ -2167,19 +2176,19 @@ Redis.prototype.mget = async function(keys) {
  * @param {Number} seconds 过期时间(秒)
  * @return {Promise<boolean>} 返回true
  */
-Redis.prototype.mset = async function(obj, seconds = 0) {
+Redis.prototype.mset = async function (obj, seconds = 0) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const 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,12 +2196,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: 参数必须是非空对象');
-			return false;
+			throw new TypeError('参数必须是非空对象');
 		}
 
 		// 使用Pipeline优化批量操作
@@ -2211,7 +2219,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,27 +2227,26 @@ 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);
+		this.logger('warn', '使用Pipeline批量设置失败，使用回退方案:', err);
 		const connection = await this._getConnection();
 		try {
 			const pairs = [];
 			for (const [key, value] of Object.entries(obj)) {
-				const fullKey = this.applyPrefix(key);
-				const val = typeof(value) === "object" ? JSON.stringify(value) : value;
+				const fullKey = this._addPrefix(key);
+				const val = typeof (value) === "object" ? JSON.stringify(value) : value;
 				pairs.push(fullKey, val);
 			}
 
 			// 确保pairs数组格式正确，符合原生mSet方法要求
 			if (pairs.length % 2 !== 0) {
-				$.log.warn('[Redis] mset: 键值对数量必须相等');
-				return false;
+				throw new TypeError('键值对数量必须相等');
 			}
 
 			await connection.mSet(pairs);
@@ -2247,12 +2254,12 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 			// 如果设置了过期时间，为所有键设置过期
 			if (seconds > 0) {
 				for (const key of Object.keys(obj)) {
-					await connection.expire(this.applyPrefix(key), seconds);
+					await connection.expire(this._addPrefix(key), seconds);
 				}
 			}
 
 			// 触发后置事件（使用原始数据，因为前置数据修改处理已失败）
-			this.emit('mset_after', {
+			this.emit('mset:after', {
 				keyValues: obj,
 				seconds,
 				result: true
@@ -2260,12 +2267,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);
@@ -2274,7 +2281,7 @@ Redis.prototype.mset = async function(obj, seconds = 0) {
 };
 
 // 添加连接回收方法，作为_releaseConnection的别名
-Redis.prototype._recycleConnection = function(connection) {
+Redis.prototype._recycleConnection = function (connection) {
 	return this._releaseConnection(connection);
 };
 
@@ -2284,19 +2291,19 @@ Redis.prototype._recycleConnection = function(connection) {
  * @param {String|Array<String>} fields 字段名或字段名数组
  * @return {Promise<Boolean>} 操作结果
  */
-Redis.prototype.hdel = async function(key, fields) {
+Redis.prototype.hdel = async function (key, fields) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const 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,12 +2311,12 @@ Redis.prototype.hdel = async function(key, fields) {
 		let {
 			key: finalKey,
 			value: finalFields
-		} = beforeEventData;
+		} = ctx;
 		let success = true;
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			finalKey = this._addPrefix(finalKey);
 			if (!Array.isArray(finalFields)) {
 				finalFields = [finalFields];
 			}
@@ -2320,12 +2327,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 +2343,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;
 	}
 };
@@ -2351,17 +2358,17 @@ Redis.prototype.hdel = async function(key, fields) {
  * @param {String} key 键
  * @return {Promise<Number>} 字段数量
  */
-Redis.prototype.hlen = async function(key) {
+Redis.prototype.hlen = async function (key) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 			return await connection.hLen(key);
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取哈希字段数量失败 [${key}]:`, err);
+		this.logger('error', `获取哈希字段数量失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -2445,10 +2452,10 @@ class RedisPipeline {
 				if (name !== 'multi' && name !== 'exec' && args.length > 0) {
 					processedArgs = [...args];
 					// 大多数Redis命令第一个参数是key
-					processedArgs[0] = this.redis.applyPrefix(args[0]);
+					processedArgs[0] = this.redis._addPrefix(args[0]);
 
 					// 对于set命令，处理value的JSON序列化
-					if (name === 'set' && args.length >= 2 && typeof(args[1]) === 'object') {
+					if (name === 'set' && args.length >= 2 && typeof (args[1]) === 'object') {
 						processedArgs[1] = JSON.stringify(args[1]);
 					}
 				}
@@ -2465,7 +2472,7 @@ class RedisPipeline {
 				} else if (pipeline[name]) {
 					pipeline[name](...processedArgs);
 				} else {
-					$.log.warn(`[Redis] Pipeline不支持的命令: ${name}`);
+					throw new Error(`Pipeline不支持的命令: ${name}`);
 				}
 			}
 
@@ -2475,12 +2482,12 @@ 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;
 				}
 
 				// 尝试解析JSON结果
-				if (typeof(value) === 'string') {
+				if (typeof (value) === 'string') {
 					try {
 						if (value.startsWith('{') && value.endsWith('}') ||
 							value.startsWith('[') && value.endsWith(']')) {
@@ -2501,28 +2508,28 @@ class RedisPipeline {
  * 清空所有过期的数据
  * @return {Promise<Boolean>} 是否成功
  */
-Redis.prototype.clearExpire = async function() {
+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;
 	}
 };
 
 
 // 获取连接的方法
-Redis.prototype._getConnection = function() {
+Redis.prototype._getConnection = function () {
 	return new Promise((resolve, reject) => {
 		try {
 			// 如果有可用连接，直接返回
@@ -2544,21 +2551,21 @@ Redis.prototype._getConnection = function() {
 			} else {
 				// 否则等待连接释放
 				// 这里简化处理，直接创建连接（生产环境应实现等待队列）
-				$.log.warn('[Redis] 连接池已满，创建额外连接');
+				this.logger('warn', '连接池已满，创建额外连接');
 				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);
 		}
 	});
 };
 
 // 释放连接回池
-Redis.prototype._releaseConnection = function(connection) {
+Redis.prototype._releaseConnection = function (connection) {
 	try {
 		if (this.connection_pool.in_use.has(connection)) {
 			this.connection_pool.in_use.delete(connection);
@@ -2574,16 +2581,15 @@ 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);
 				} catch (e) {
-					$.log.error('[Redis] 关闭多余连接失败:', e);
+					this.logger('error', '关闭多余连接失败:', e);
 				}
 			}
 		}
 	} catch (error) {
-		$.log.error('[Redis] 释放连接失败:', error);
+		this.logger('error', '释放连接失败:', error);
 	}
 };
 
@@ -2599,20 +2605,20 @@ Redis.prototype._recycleConnection = Redis.prototype._releaseConnection;
  * @param {Object} value 值
  * @return {Promise<Boolean>} 操作结果
  */
-Redis.prototype.hset = async function(key, field, value) {
+Redis.prototype.hset = async function (key, field, value) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const 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,20 +2627,20 @@ Redis.prototype.hset = async function(key, field, value) {
 			key: finalKey,
 			field: finalField,
 			value: finalValue
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			finalKey = this._addPrefix(finalKey);
 			// 确保所有非字符串值都转换为字符串
-			if (typeof(finalValue) !== "string") {
+			if (typeof (finalValue) !== "string") {
 				finalValue = JSON.stringify(finalValue);
 			}
 			// 使用正确的Redis v4 API - hSet方法
 			const result = await connection.hSet(finalKey, finalField, finalValue);
 
 			// 触发后置事件
-			this.emit('hset_after', {
+			this.emit('hset:after', {
 				key: finalKey,
 				field: finalField,
 				value: finalValue,
@@ -2645,9 +2651,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,
@@ -2663,15 +2669,15 @@ Redis.prototype.hset = async function(key, field, value) {
  * @param {String} field 字段
  * @return {Promise<Object>} 字段值
  */
-Redis.prototype.hget = async function(key, field) {
+Redis.prototype.hget = async function (key, field) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 			// 使用正确的Redis v4 API - hGet方法
 			const value = await connection.hGet(key, field);
 			// 尝试解析JSON
-			if (value && typeof(value) === 'string') {
+			if (value && typeof (value) === 'string') {
 				try {
 					if (value.startsWith('{') && value.endsWith('}') ||
 						value.startsWith('[') && value.endsWith(']')) {
@@ -2687,7 +2693,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;
 	}
 };
@@ -2698,19 +2704,19 @@ Redis.prototype.hget = async function(key, field) {
  * @param {Object} obj 字段值对象
  * @return {Promise<Boolean>} 操作结果
  */
-Redis.prototype.hmset = async function(key, obj) {
+Redis.prototype.hmset = async function (key, obj) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const 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 +2724,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);
+			finalKey = this._addPrefix(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 +2756,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 +2768,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 +2788,7 @@ Redis.prototype.hmset = async function(key, obj) {
 			}
 
 			// 触发后置事件
-			this.emit('hmset_after', {
+			this.emit('hmset:after', {
 				key: finalKey,
 				value: finalObj,
 				success: success
@@ -2792,9 +2798,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
@@ -2808,23 +2814,23 @@ Redis.prototype.hmset = async function(key, obj) {
  * @param {String} key 键
  * @return {Promise<Object>} 所有字段和值
  */
-Redis.prototype.hgetall = async function(key) {
+Redis.prototype.hgetall = async function (key) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 			if (typeof connection.hGetAll === 'function') {
 				const result = await connection.hGetAll(key);
 				return result;
 			} else {
-				$.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 {};
 	}
 };
@@ -2835,28 +2841,26 @@ Redis.prototype.hgetall = async function(key) {
  * @param {Array} fields 字段名数组
  * @return {Promise<Array>} 与字段名顺序对应的数组值，不存在返回undefined
  */
-Redis.prototype.hmget = async function(key, fields) {
+Redis.prototype.hmget = async function (key, fields) {
 	try {
 		if (!Array.isArray(fields)) {
-			$.log.error('[Redis] 参数错误: fields必须是数组');
-			// 返回空数组而不是false，保持与注释类型一致
-			return [];
+			throw new TypeError('fields必须是数组');
 		}
 
-		this.emit('hmget_before', {
+		this.emit('hmget:before', {
 			key,
 			fields
 		});
 
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
+			key = this._addPrefix(key);
 
 			if (typeof connection.hmGet === 'function') {
 				const result = await connection.hmGet(key, fields);
 				// 将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 +2873,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 +2889,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);
 	}
@@ -2901,41 +2905,41 @@ Redis.prototype.hmget = async function(key, fields) {
  * @param {Number} seconds 过期时间（秒）
  * @return {Promise<Boolean>} 操作结果
  */
-Redis.prototype.expire = async function(key, seconds) {
+Redis.prototype.expire = async function (key, seconds) {
 	try {
 		// 触发前置事件
-		const 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 {
 			// 使用正确的Redis客户端Promise API
-			const result = await connection.expire(this.applyPrefix(finalKey), finalSeconds);
+			const result = await connection.expire(this._addPrefix(finalKey), finalSeconds);
 
 			// 触发后置事件
-			this.emit('expire_after', {
+			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 +2949,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
@@ -2961,59 +2965,57 @@ Redis.prototype.expire = async function(key, seconds) {
  * @param {Number} milliseconds 过期时间（毫秒）
  * @return {Promise<Boolean>} 操作结果
  */
-Redis.prototype.pexpire = async function(key, milliseconds) {
+Redis.prototype.pexpire = async function (key, milliseconds) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] pexpire参数错误: key must be a non-empty string');
-			return false;
+			throw new TypeError('key必须是非空字符串');
 		}
 		if (!Number.isInteger(milliseconds) || milliseconds <= 0) {
-			$.log.error('[Redis] pexpire参数错误: milliseconds must be a positive integer');
-			return false;
+			throw new TypeError('milliseconds必须是正整数');
 		}
 
 		// 触发前置事件
-		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 {
 			// 使用正确的Redis客户端Promise API
 			let result;
 			if (typeof connection.pexpire === 'function') {
-				result = await connection.pexpire(this.applyPrefix(finalKey), finalMilliseconds);
+				result = await connection.pexpire(this._addPrefix(finalKey), finalMilliseconds);
 			} else if (typeof connection.execute === 'function') {
-				result = await connection.execute('PEXPIRE', [this.applyPrefix(finalKey), finalMilliseconds]);
+				result = await connection.execute('PEXPIRE', [this._addPrefix(finalKey), finalMilliseconds]);
 			} else {
-				$.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 +3025,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
@@ -3034,38 +3036,38 @@ Redis.prototype.pexpire = async function(key, milliseconds) {
 };
 
 // 新增persist方法实现
-Redis.prototype.persist = async function(key) {
+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 {
 			// 使用正确的Redis客户端Promise API
-			const result = await connection.persist(this.applyPrefix(finalKey));
+			const result = await connection.persist(this._addPrefix(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 +3076,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
 		});
@@ -3089,35 +3091,34 @@ Redis.prototype.persist = async function(key) {
  * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 增加后的值
  */
-Redis.prototype.incr = async function(key, seconds = 0) {
+Redis.prototype.incr = async function (key, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
-			return null;
+			throw new TypeError('键必须是非空字符串');
 		}
 
 		// 触发前置事件
-		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 {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
 			const result = await connection.incr(prefixedKey);
 
@@ -3130,15 +3131,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 +3149,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
@@ -3164,35 +3165,34 @@ Redis.prototype.incr = async function(key, seconds = 0) {
  * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 减少后的值
  */
-Redis.prototype.decr = async function(key, seconds = 0) {
+Redis.prototype.decr = async function (key, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
-			return null;
+			throw new TypeError('键必须是非空字符串');
 		}
 
 		// 触发前置事件
-		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 {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
 			const result = await connection.decr(prefixedKey);
 
@@ -3205,15 +3205,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 +3223,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
@@ -3240,29 +3240,27 @@ Redis.prototype.decr = async function(key, seconds = 0) {
  * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 增加后的值
  */
-Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
+Redis.prototype.incrbyfloat = async function (key, increment, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
-			return null;
+			throw new TypeError('键必须是非空字符串');
 		}
 		if (typeof increment !== 'number' || isNaN(increment)) {
-			$.log.error('[Redis] 参数错误: 增量必须是有效数字');
-			return null;
+			throw new TypeError('增量必须是有效数字');
 		}
 
 		// 触发前置事件
-		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,11 +3268,11 @@ Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
 			key: finalKey,
 			increment: finalIncrement,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
 			const result = await connection.incrByFloat(prefixedKey, finalIncrement);
 			const parsedResult = parseFloat(result);
@@ -3288,7 +3286,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 +3294,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 +3306,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,
@@ -3326,29 +3324,27 @@ Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
  * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 增加后的值
  */
-Redis.prototype.incrby = async function(key, increment, seconds = 0) {
+Redis.prototype.incrby = async function (key, increment, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
-			return null;
+			throw new TypeError('键必须是非空字符串');
 		}
 		if (typeof increment !== 'number' || isNaN(increment) || !Number.isInteger(increment)) {
-			$.log.error('[Redis] 参数错误: 增量必须是有效整数');
-			return null;
+			throw new TypeError('增量必须是有效整数');
 		}
 
 		// 触发前置事件
-		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,11 +3352,11 @@ Redis.prototype.incrby = async function(key, increment, seconds = 0) {
 			key: finalKey,
 			increment: finalIncrement,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
 			const result = await connection.incrBy(prefixedKey, finalIncrement);
 
@@ -3373,7 +3369,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 +3377,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 +3389,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,
@@ -3411,29 +3407,27 @@ Redis.prototype.incrby = async function(key, increment, seconds = 0) {
  * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 减少后的值
  */
-Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
+Redis.prototype.decrby = async function (key, decrement, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
-			return null;
+			throw new TypeError('键必须是非空字符串');
 		}
 		if (typeof decrement !== 'number' || isNaN(decrement) || !Number.isInteger(decrement)) {
-			$.log.error('[Redis] 参数错误: 减量必须是有效整数');
-			return null;
+			throw new TypeError('减量必须是有效整数');
 		}
 
 		// 触发前置事件
-		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,11 +3435,11 @@ Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
 			key: finalKey,
 			decrement: finalDecrement,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
 			const result = await connection.decrBy(prefixedKey, finalDecrement);
 
@@ -3458,7 +3452,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 +3460,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 +3472,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,
@@ -3497,33 +3491,33 @@ Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
  * @param {String|Array} members 成员或成员数组
  * @return {Promise<Number>} 添加的成员数量
  */
-Redis.prototype.sadd = async function(key, members) {
+Redis.prototype.sadd = async function (key, members) {
 	try {
 		// 触发前置事件
-		const 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 {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			const result = await connection.sAdd(prefixedKey, finalMembers);
 
 			// 触发后置事件
-			this.emit('sadd_after', {
+			this.emit('sadd:after', {
 				key: finalKey,
 				members: finalMembers,
 				result
@@ -3533,8 +3527,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
@@ -3549,33 +3543,33 @@ Redis.prototype.sadd = async function(key, members) {
  * @param {String|Array} members 成员或成员数组
  * @return {Promise<Number>} 移除的成员数量
  */
-Redis.prototype.srem = async function(key, members) {
+Redis.prototype.srem = async function (key, members) {
 	try {
 		// 触发前置事件
-		const 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 {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			const result = await connection.sRem(prefixedKey, finalMembers);
 
 			// 触发后置事件
-			this.emit('srem_after', {
+			this.emit('srem:after', {
 				key: finalKey,
 				members: finalMembers,
 				result
@@ -3585,8 +3579,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
@@ -3601,29 +3595,27 @@ Redis.prototype.srem = async function(key, members) {
  * @param {String} member 成员
  * @return {Promise<Boolean>} 是否存在
  */
-Redis.prototype.sismember = async function(key, member) {
+Redis.prototype.sismember = async function (key, member) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] sismember参数错误: key must be a non-empty string');
-			return false;
+			throw new TypeError('key必须是非空字符串');
 		}
 		if (member === undefined || member === null) {
-			$.log.error('[Redis] sismember参数错误: member cannot be undefined or null');
-			return false;
+			throw new TypeError('member不能为undefined或null');
 		}
 
-		this.emit('sismember_before', {
+		this.emit('sismember:before', {
 			key,
 			member
 		});
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(key);
+			const prefixedKey = this._addPrefix(key);
 			// 将成员转换为字符串，与其他模块行为一致
 			const memberStr = String(member);
 			const result = await connection.sIsMember(prefixedKey, memberStr);
-			this.emit('sismember_after', {
+			this.emit('sismember:after', {
 				key,
 				member,
 				result
@@ -3633,12 +3625,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;
 	}
 };
@@ -3648,13 +3640,13 @@ Redis.prototype.sismember = async function(key, member) {
  * @param {String} key 键
  * @return {Promise<Array>} 成员数组
  */
-Redis.prototype.smembers = async function(key) {
+Redis.prototype.smembers = async function (key) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(key);
+			const prefixedKey = this._addPrefix(key);
 			const result = await connection.sMembers(prefixedKey);
-			this.emit('smembers_after', {
+			this.emit('smembers:after', {
 				key,
 				result
 			});
@@ -3663,8 +3655,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
 		});
@@ -3677,18 +3669,18 @@ Redis.prototype.smembers = async function(key) {
  * @param {String} key 键
  * @return {Promise<Number>} 成员数量
  */
-Redis.prototype.scard = async function(key) {
+Redis.prototype.scard = async function (key) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(key);
+			const prefixedKey = this._addPrefix(key);
 			const result = await connection.sCard(prefixedKey);
 			return result;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取集合大小失败 [${key}]:`, err);
+		this.logger('error', `获取集合大小失败 [${key}]:`, err);
 		return 0;
 	}
 };
@@ -3698,11 +3690,11 @@ Redis.prototype.scard = async function(key) {
  * @param {Array} keys 键数组
  * @return {Promise<Array>} 交集成员数组
  */
-Redis.prototype.sinter = async function(keys) {
+Redis.prototype.sinter = async function (keys) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKeys = keys.map(key => this.applyPrefix(key));
+			const prefixedKeys = keys.map(key => this._addPrefix(key));
 			// 使用Redis v4正确的方法
 			const result = await connection.sInter(...prefixedKeys);
 			return result || [];
@@ -3710,7 +3702,7 @@ Redis.prototype.sinter = async function(keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取集合交集失败:`, err);
+		this.logger('error', `获取集合交集失败:`, err);
 		return [];
 	}
 };
@@ -3720,11 +3712,11 @@ Redis.prototype.sinter = async function(keys) {
  * @param {Array} keys 键数组
  * @return {Promise<Array>} 并集成员数组
  */
-Redis.prototype.sunion = async function(keys) {
+Redis.prototype.sunion = async function (keys) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKeys = keys.map(key => this.applyPrefix(key));
+			const prefixedKeys = keys.map(key => this._addPrefix(key));
 			// 使用Redis v4正确的方法
 			const result = await connection.sUnion(...prefixedKeys);
 			return result || [];
@@ -3732,7 +3724,7 @@ Redis.prototype.sunion = async function(keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取集合并集失败:`, err);
+		this.logger('error', `获取集合并集失败:`, err);
 		return [];
 	}
 };
@@ -3742,11 +3734,11 @@ Redis.prototype.sunion = async function(keys) {
  * @param {Array} keys 键数组
  * @return {Promise<Array>} 差集成员数组
  */
-Redis.prototype.sdiff = async function(keys) {
+Redis.prototype.sdiff = async function (keys) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKeys = keys.map(key => this.applyPrefix(key));
+			const prefixedKeys = keys.map(key => this._addPrefix(key));
 			// 使用Redis v4正确的方法
 			const result = await connection.sDiff(...prefixedKeys);
 			return result || [];
@@ -3754,7 +3746,7 @@ Redis.prototype.sdiff = async function(keys) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取集合差集失败:`, err);
+		this.logger('error', `获取集合差集失败:`, err);
 		return [];
 	}
 };
@@ -3768,19 +3760,19 @@ Redis.prototype.sdiff = async function(keys) {
  * @param {String} member 成员
  * @return {Promise<Boolean>} 是否成功
  */
-Redis.prototype.zadd = async function(key, score, member) {
+Redis.prototype.zadd = async function (key, score, member) {
 	try {
 		// 触发前置事件
-		const 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,18 +3780,18 @@ Redis.prototype.zadd = async function(key, score, member) {
 			key: finalKey,
 			score: finalScore,
 			member: finalMember
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			const result = await connection.zAdd(prefixedKey, {
 				score: finalScore,
 				value: finalMember
 			});
 
 			// 触发后置事件
-			this.emit('zadd_after', {
+			this.emit('zadd:after', {
 				key: finalKey,
 				score: finalScore,
 				member: finalMember,
@@ -3810,8 +3802,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,
@@ -3827,41 +3819,41 @@ Redis.prototype.zadd = async function(key, score, member) {
  * @param {String|Array} members 成员或成员数组
  * @return {Promise<Number>} 移除的成员数量
  */
-Redis.prototype.zrem = async function(key, members) {
+Redis.prototype.zrem = async function (key, members) {
 	try {
 		// 触发前置事件
-		const 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 {
 			// 使用正确的Redis客户端Promise API
-			const result = await connection.zRem(this.applyPrefix(finalKey), ...finalMembers);
+			const result = await connection.zRem(this._addPrefix(finalKey), ...finalMembers);
 
 			// 触发后置事件
-			this.emit('zrem_after', {
+			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 +3863,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
@@ -3887,18 +3879,18 @@ Redis.prototype.zrem = async function(key, members) {
  * @param {String} member 成员
  * @return {Promise<Number|null>} 分数
  */
-Redis.prototype.zscore = async function(key, member) {
+Redis.prototype.zscore = async function (key, member) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(key);
+			const prefixedKey = this._addPrefix(key);
 			const result = await connection.zScore(prefixedKey, member);
 			return result ? parseFloat(result) : null;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取有序集合成员分数失败 [${key}:${member}]:`, err);
+		this.logger('error', `获取有序集合成员分数失败 [${key}:${member}]:`, err);
 		return null;
 	}
 };
@@ -3909,18 +3901,18 @@ Redis.prototype.zscore = async function(key, member) {
  * @param {String} member 成员
  * @return {Promise<Number|null>} 排名
  */
-Redis.prototype.zrank = async function(key, member) {
+Redis.prototype.zrank = async function (key, member) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(key);
+			const prefixedKey = this._addPrefix(key);
 			const result = await connection.zRank(prefixedKey, member);
 			return result;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取有序集合成员排名失败 [${key}:${member}]:`, err);
+		this.logger('error', `获取有序集合成员排名失败 [${key}:${member}]:`, err);
 		return null;
 	}
 };
@@ -3933,11 +3925,11 @@ Redis.prototype.zrank = async function(key, member) {
  * @param {Boolean} withScores 是否返回分数
  * @return {Promise<Array>} 成员数组
  */
-Redis.prototype.zrange = async function(key, start, stop, withScores = false) {
+Redis.prototype.zrange = async function (key, start, stop, withScores = false) {
 	try {
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(key);
+			const prefixedKey = this._addPrefix(key);
 
 			if (withScores) {
 				// 对于需要分数的情况，使用更可靠的方法
@@ -3961,13 +3953,13 @@ Redis.prototype.zrange = async function(key, start, stop, withScores = false) {
 								member,
 								score: 0
 							});
-							$.log.warn(`[Redis] 获取成员 ${member} 分数失败:`, scoreErr);
+							this.logger('error', `获取成员 ${member} 分数失败:`, scoreErr);
 						}
 					}
 
 					return results;
 				} catch (err) {
-					$.log.error(`[Redis] 使用备用方法获取有序集合范围失败 [${prefixedKey}]:`, err);
+					this.logger('error', `使用备用方法获取有序集合范围失败 [${prefixedKey}]:`, err);
 					// 回退到简单列表
 					return [];
 				}
@@ -3980,7 +3972,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 [];
 	}
 };
@@ -3990,21 +3982,21 @@ Redis.prototype.zrange = async function(key, start, stop, withScores = false) {
  * @param {String} key 键
  * @return {Promise<Number>} 成员数量
  */
-Redis.prototype.zcard = async function(key) {
+Redis.prototype.zcard = async function (key) {
 	try {
 		const connection = await this._getConnection();
 		try {
 			// 使用正确的Redis客户端Promise API
-			const result = await connection.zCard(this.applyPrefix(key));
+			const result = await connection.zCard(this._addPrefix(key));
 			return result || 0;
 		} catch (err) {
-			$.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;
 	}
 };
@@ -4017,34 +4009,31 @@ Redis.prototype.zcard = async function(key) {
  * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 增加后的分数
  */
-Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
+Redis.prototype.zincrby = async function (key, increment, member, seconds = 0) {
 	try {
 		// 参数验证
 		if (!key || typeof key !== 'string') {
-			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
-			return null;
+			throw new TypeError('键必须是非空字符串');
 		}
 		if (typeof increment !== 'number' || isNaN(increment)) {
-			$.log.error('[Redis] 参数错误: 增量必须是有效数字');
-			return null;
+			throw new TypeError('增量必须是有效数字');
 		}
 		if (!member || typeof member !== 'string') {
-			$.log.error('[Redis] 参数错误: 成员必须是非空字符串');
-			return null;
+			throw new TypeError('成员必须是非空字符串');
 		}
 
 		// 触发前置事件
-		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,11 +4042,11 @@ Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
 			increment: finalIncrement,
 			member: finalMember,
 			seconds: finalSeconds
-		} = beforeEventData;
+		} = ctx;
 
 		const connection = await this._getConnection();
 		try {
-			const prefixedKey = this.applyPrefix(finalKey);
+			const prefixedKey = this._addPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
 			const result = await connection.zIncrBy(prefixedKey, finalIncrement, finalMember);
 
@@ -4071,7 +4060,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 +4069,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 +4082,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,
@@ -4106,7 +4095,7 @@ Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
 };
 
 // 创建真实Redis连接的方法
-Redis.prototype._createConnection = function() {
+Redis.prototype._createConnection = function () {
 	return new Promise((resolve, reject) => {
 		try {
 			const cg = this.config;
@@ -4127,19 +4116,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);
 		}
 	});