mm_redis 1.9.8 → 1.9.9

package/index.js

@@ -3,8 +3,9 @@
  * @author <a href="http://qww.elins.cn">邱文武</a>
  * @version 1.5.0
  */
-const eventEmitter = require('events');
-require('mm_logs');
+const {
+	BaseService
+} = require('mm_base_service');
 const {
 	createClient
 } = require('redis');
@@ -13,17 +14,14 @@ const {
 
 /* 创建Redis帮助类函数 */
 /// 构造函数
-class Redis extends eventEmitter {
+class Redis extends BaseService {
 	/**
 	 * @description 创建Redis帮助类函数 (构造函数)
-	 * @param {String} scope 作用域
 	 * @param {Object} config 配置参数
 	 * @constructor
 	 */
-	constructor(scope, config) {
+	constructor(config) {
 		super();
-		// 作用域
-		this.scope = scope;
 		// 配置参数
 		this.config = {
 			// 服务器地址
@@ -31,7 +29,7 @@ class Redis extends eventEmitter {
 			// 端口号
 			"port": 6379,
 			// 密码
-			"password": "",
+			"password": "asd159357",
 			// 数据库
 			"database": 0,
 			// 前缀
@@ -45,9 +43,9 @@ class Redis extends eventEmitter {
 		};
 		this.setConfig(config);
 		// 连接池配置
-		this.connectionPool = {
+		this.connection_pool = {
 			available: [], // 可用连接数组
-			inUse: new Set(), // 使用中的连接集合
+			in_use: new Set(), // 使用中的连接集合
 			config: {
 				max_clients: 10 // 最大连接数
 			}
@@ -59,7 +57,7 @@ class Redis extends eventEmitter {
 		// 连接状态
 		this.connected = false;
 		// 重试次数计数器
-		this.retryCount = 0;
+		this.retry_count = 0;
 		// 订阅回调函数
 		this.func_list = {};
 	}
@@ -70,7 +68,7 @@ class Redis extends eventEmitter {
  * @param {String} key 键
  * @return {String} 处理后的键
  */
-Redis.prototype.applyPrefix = function (key) {
+Redis.prototype.applyPrefix = function(key) {
 	return this.config.prefix ? this.config.prefix + key : key;
 };
 
@@ -79,7 +77,7 @@ Redis.prototype.applyPrefix = function (key) {
  * @param {String} key 带前缀的键
  * @return {String} 处理后的键
  */
-Redis.prototype.removePrefix = function (key) {
+Redis.prototype.removePrefix = function(key) {
 	if (this.config.prefix && key.startsWith(this.config.prefix)) {
 		return key.slice(this.config.prefix.length);
 	}
@@ -92,7 +90,7 @@ 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));
 		this.func_list[channel] = func;
@@ -108,7 +106,7 @@ 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));
 		delete this.func_list[channel];
@@ -125,12 +123,13 @@ 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);
 	} catch (err) {
 		$.log.error(`[Redis] 发布消息到频道 ${channel} 失败:`, err);
-		throw err;
+		$.log.error('[Redis] 操作失败:', err);
+		return false;
 	}
 };
 
@@ -139,7 +138,7 @@ 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);
 };
@@ -149,7 +148,7 @@ 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);
 	var func = this.func_list[channel];
@@ -166,18 +165,17 @@ Redis.prototype.message = function (channel, message) {
 
 /**
  * @description 设置配置
- * @param {Object} cg 配置对象或配置路径
+ * @param {Object} config 配置对象或配置路径
  */
 // 修复setConfig方法，移除其中的_initPool定义
-Redis.prototype.setConfig = function (cg) {
+Redis.prototype.setConfig = function(config) {
 	let obj = {};
-	if (typeof cg === 'string') {
-		obj = cg.loadJson(__dirname);
-	} else if (cg) {
-	// 合并配置参数
-		Object.assign(this.config, cg);
-	}
-	else {
+	if (typeof config === 'string') {
+		obj = config.loadJson(__dirname);
+	} else if (config) {
+		// 合并配置参数
+		Object.assign(this.config, config);
+	} else {
 		return;
 	}
 	// 使用Object.assign替代$.push来合并配置
@@ -199,11 +197,11 @@ Redis.prototype.setConfig = function (cg) {
 };
 
 // 添加连接池初始化方法
-Redis.prototype._initPool = function () {
+Redis.prototype._initPool = function() {
 	// 初始化连接池相关属性
-	this.connectionPool = {
+	this.connection_pool = {
 		available: [],
-		inUse: new Set(),
+		in_use: new Set(),
 		config: this.config.pool || {
 			max_clients: 10,
 			min_idle: 2,
@@ -220,14 +218,14 @@ Redis.prototype._initPool = function () {
  * @description 连接Redis数据库
  * @return {Promise<Boolean>} 连接结果
  */
-Redis.prototype.open = async function () {
+Redis.prototype.open = async function() {
 	if (this.conn && this.connected) {
 		return true;
 	}
 
 	try {
 		const cg = this.config;
-		this.retryCount = 0;
+		this.retry_count = 0;
 
 		// 创建客户端
 		this.conn = createClient({
@@ -252,7 +250,7 @@ Redis.prototype.open = async function () {
 		this.conn.on('connect', () => {
 			$.log.debug('[Redis] Redis已连接');
 			this.connected = true;
-			this.retryCount = 0;
+			this.retry_count = 0;
 		});
 
 		// 监听断开连接事件
@@ -292,14 +290,14 @@ Redis.prototype.open = async function () {
  * 内部重连方法
  * @private
  */
-Redis.prototype._reconnect = function () {
-	if (this.retryCount >= this.config.retry_count) {
+Redis.prototype._reconnect = function() {
+	if (this.retry_count >= this.config.retry_count) {
 		$.log.error(`[Redis] 达到最大重连次数 ${this.config.retry_count}，停止重连`);
 		return;
 	}
 
-	this.retryCount++;
-	$.log.debug(`[Redis] 尝试第 ${this.retryCount} 次重连...`);
+	this.retry_count++;
+	$.log.debug(`[Redis] 尝试第 ${this.retry_count} 次重连...`);
 
 	setTimeout(async () => {
 		try {
@@ -315,25 +313,25 @@ Redis.prototype._reconnect = function () {
  * @return {Promise<Boolean>} 关闭结果
  */
 // 修复close方法，正确处理连接池
-Redis.prototype.close = function () {
+Redis.prototype.close = function() {
 	try {
 		$.log.debug('[Redis] 关闭所有连接...');
 
 		// 关闭所有使用中的连接
-		if (this.connectionPool && this.connectionPool.inUse) {
-			for (const connection of this.connectionPool.inUse) {
+		if (this.connection_pool && this.connection_pool.in_use) {
+			for (const connection of this.connection_pool.in_use) {
 				try {
 					connection.close();
 				} catch (e) {
 					$.log.error('[Redis] 关闭连接失败:', e);
 				}
 			}
-			this.connectionPool.inUse.clear();
+			this.connection_pool.in_use.clear();
 		}
 
 		// 关闭所有可用连接
-		if (this.connectionPool && this.connectionPool.available) {
-			for (const connection of this.connectionPool.available) {
+		if (this.connection_pool && this.connection_pool.available) {
+			for (const connection of this.connection_pool.available) {
 				try {
 					// 检查连接对象是否有close方法
 					if (typeof connection.close === 'function') {
@@ -348,7 +346,7 @@ Redis.prototype.close = function () {
 					$.log.error('[Redis] 关闭连接失败:', e);
 				}
 			}
-			this.connectionPool.available = [];
+			this.connection_pool.available = [];
 		}
 
 		this.connected = false;
@@ -361,49 +359,49 @@ Redis.prototype.close = function () {
 };
 
 // 添加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();
@@ -502,7 +500,7 @@ Redis.prototype.pipeline = function () {
  * @description 检查连接状态
  * @return {Boolean} 连接状态
  */
-Redis.prototype.isConnected = function () {
+Redis.prototype.isConnected = function() {
 	return this.connected && this.conn && this.conn.isReady;
 };
 
@@ -512,12 +510,38 @@ Redis.prototype.isConnected = function () {
  * @param {Number} seconds 秒, 为空则查询有效时长
  * @return {Promise<Number|Boolean>} 查询时长或设置结果, 时长为-1表示永不过期
  */
-Redis.prototype.ttl = async function (key) {
+/**
+ * 获取或设置键的过期时间
+ * @param {String} key 键名
+ * @param {Number} [seconds] 过期时间（秒），不传此参数则获取剩余过期时间
+ * @return {Promise<Number|Boolean>} 不传seconds时返回剩余过期时间（-1表示无过期设置，-2表示已过期），传seconds时返回是否设置成功
+ */
+Redis.prototype.ttl = async function(key, seconds) {
 	try {
 		const connection = await this._getConnection();
 		try {
 			key = this.applyPrefix(key);
-			// 只获取过期时间，符合ttl的标准功能
+
+			// 如果传入了seconds参数，则设置过期时间
+			if (seconds !== undefined) {
+				if (typeof seconds !== 'number' || isNaN(seconds) || seconds < 0) {
+					return false;
+				}
+
+				// 设置过期时间
+				if (typeof connection.expire === 'function') {
+					await connection.expire(key, seconds);
+					return true;
+				} else if (typeof connection.execute === 'function') {
+					await connection.execute('EXPIRE', [key, seconds]);
+					return true;
+				} else {
+					$.log.error('[Redis] 连接对象不支持expire操作');
+					return false;
+				}
+			}
+
+			// 否则获取剩余过期时间
 			if (typeof connection.ttl === 'function') {
 				return await connection.ttl(key);
 			} else if (typeof connection.execute === 'function') {
@@ -530,21 +554,37 @@ Redis.prototype.ttl = async function (key) {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取过期时间失败 [${key}]:`, err);
-		return -2; // -2表示出错
+		$.log.error(`[Redis] ${seconds !== undefined ? '设置' : '获取'}过期时间失败 [${key}]:`, err);
+		return seconds !== undefined ? false : -2;
 	}
 };
 
 /**
- * @description 增加整数值(负数为减)
+ * @description 增加整数值(负数为减)（兼容方法）
  * @param {String} key 键
  * @param {Number} num 数值
+ * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 计算后的结果
  */
-Redis.prototype.addInt = async function (key, num) {
+Redis.prototype.addInt = async function(key, num, seconds = 0) {
 	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
+			return false;
+		}
+		if (typeof num !== 'number' || isNaN(num) || !Number.isInteger(num)) {
+			$.log.error('[Redis] 参数错误: 数值必须是有效整数');
+			return false;
+		}
+		
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = { key, value: num, cancel: false };
+		const beforeEventData = {
+			key,
+			value: num,
+			seconds,
+			cancel: false
+		};
 		this.emit('addInt_before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回false
@@ -554,59 +594,83 @@ Redis.prototype.addInt = async function (key, num) {
 		}
 
 		// 使用可能被修改的值
-		let { key: finalKey, value: finalNum } = beforeEventData;
+		let {
+			key: finalKey,
+			value: finalNum,
+			seconds: finalSeconds
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			const prefixedKey = this.applyPrefix(finalKey);
 			let result;
 			if (finalNum > 0) {
 				// 增加整数值
 				if (typeof connection.incrBy === 'function') {
-					result = await connection.incrBy(finalKey, finalNum);
+					result = await connection.incrBy(prefixedKey, finalNum);
 				} else if (typeof connection.execute === 'function') {
-					result = await connection.execute('INCRBY', [finalKey, finalNum]);
+					result = await connection.execute('INCRBY', [prefixedKey, finalNum]);
 				} else {
 					// 如果出错，回退到先获取再设置的方式
 					$.log.warn(`[Redis] 使用原子操作增加整数值失败，使用回退方案`);
-					let value = await this.get(finalKey);
+					let value = await this.get(prefixedKey);
 					let n = 0;
 					if (value) {
 						n = Number(value);
 					}
 					n += finalNum;
-					await this.set(finalKey, n);
+					await this.set(prefixedKey, n, finalSeconds);
 					result = n;
 				}
 			} else {
 				// 减少整数值
 				if (typeof connection.decrBy === 'function') {
-					result = await connection.decrBy(finalKey, -finalNum);
+					result = await connection.decrBy(prefixedKey, -finalNum);
 				} else if (typeof connection.execute === 'function') {
-					result = await connection.execute('DECRBY', [finalKey, -finalNum]);
+					result = await connection.execute('DECRBY', [prefixedKey, -finalNum]);
 				} else {
 					// 如果出错，回退到先获取再设置的方式
 					$.log.warn(`[Redis] 使用原子操作减少整数值失败，使用回退方案`);
-					let value = await this.get(finalKey);
+					let value = await this.get(prefixedKey);
 					let n = 0;
 					if (value) {
 						n = Number(value);
 					}
 					n += finalNum;
-					await this.set(finalKey, n);
+					await this.set(prefixedKey, n, finalSeconds);
 					result = n;
 				}
 			}
+			
+			// 如果设置了过期时间
+			if (finalSeconds > 0) {
+				if (typeof connection.expire === 'function') {
+					await connection.expire(prefixedKey, finalSeconds);
+				} else if (typeof connection.execute === 'function') {
+					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
+				}
+			}
 
 			// 触发后置事件
-			this.emit('addInt_after', { key: finalKey, value: finalNum, result, success: true });
+			this.emit('addInt_after', {
+				key: finalKey,
+				value: finalNum,
+				seconds: finalSeconds,
+				result,
+				success: true
+			});
 			return result;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('addInt_error', { key, value: num, error: err });
+		this.emit('addInt_error', {
+			key,
+			value: num,
+			seconds,
+			error: err
+		});
 		$.log.error(`[Redis] 增加整数值失败 [${key}]:`, err);
 		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
 		return 0;
@@ -614,15 +678,34 @@ Redis.prototype.addInt = async function (key, num) {
 };
 
 /**
- * @description 增加浮点数值(负数为减)
+ * @description 增加浮点数值(负数为减)（兼容方法）
  * @param {String} key 键
  * @param {Number} num 数值
+ * @param {Number} seconds 过期时间，0表示永不过期
  * @return {Promise<Number>} 计算后的结果
  */
-Redis.prototype.addFloat = async function (key, num) {
+Redis.prototype.addFloat = async function(key, num, seconds = 0) {
 	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			$.log.warn(`[Redis] addFloat: key参数必须是非空字符串`);
+			return 0;
+		}
+
+		// 验证num参数
+		num = parseFloat(num);
+		if (isNaN(num)) {
+			$.log.warn(`[Redis] addFloat: num参数必须是有效的数值`);
+			return 0;
+		}
+
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = { key, value: num, cancel: false };
+		const beforeEventData = {
+			key,
+			value: num,
+			seconds,
+			cancel: false
+		};
 		this.emit('addFloat_before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回默认值
@@ -632,57 +715,87 @@ Redis.prototype.addFloat = async function (key, num) {
 		}
 
 		// 使用可能被修改的值
-		let { key: finalKey, value: finalNum } = beforeEventData;
+		let {
+			key: finalKey,
+			value: finalNum,
+			seconds: finalSeconds
+		} = beforeEventData;
 		let result;
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			const prefixedKey = this.applyPrefix(finalKey);
 
 			// 优先使用原生方法
 			if (typeof connection.incrByFloat === 'function') {
-				result = parseFloat(await connection.incrByFloat(finalKey, finalNum));
+				result = parseFloat(await connection.incrByFloat(prefixedKey, finalNum));
 			}
 			// 尝试使用execute通用方法
 			else if (typeof connection.execute === 'function') {
-				result = parseFloat(await connection.execute('INCRBYFLOAT', [finalKey, finalNum]));
+				result = parseFloat(await connection.execute('INCRBYFLOAT', [prefixedKey, finalNum]));
 			}
 			// 回退方案
 			else {
 				$.log.warn(`[Redis] 连接对象不支持incrByFloat操作，使用回退方案`);
-				let value = await this.get(finalKey);
+				let value = await this.get(prefixedKey);
 				let n = 0;
 				if (value) {
 					n = Number(value);
 				}
 				n += finalNum;
-				await this.set(finalKey, n);
+				await this.set(prefixedKey, n, finalSeconds);
 				result = n;
 			}
 
+			// 设置过期时间
+			if (finalSeconds > 0) {
+				if (typeof connection.expire === 'function') {
+					await connection.expire(prefixedKey, finalSeconds);
+				} else if (typeof connection.execute === 'function') {
+					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
+				}
+			}
+
 			// 触发后置事件
-			this.emit('addFloat_after', { key: finalKey, value: finalNum, result, success: true });
+			this.emit('addFloat_after', {
+				key: finalKey,
+				value: finalNum,
+				seconds: finalSeconds,
+				result,
+				success: true
+			});
 			return result;
 		} catch (err) {
 			// 如果出错，回退到先获取再设置的方式
 			$.log.warn(`[Redis] 使用原子操作增加浮点数值失败，使用回退方案:`, err);
-			let value = await this.get(finalKey);
+			let value = await this.get(prefixedKey);
 			let n = 0;
 			if (value) {
 				n = Number(value);
 			}
 			n += finalNum;
-			await this.set(finalKey, n);
+			await this.set(prefixedKey, n, finalSeconds);
 
 			// 触发后置事件
-			this.emit('addFloat_after', { key: finalKey, value: finalNum, result: n, success: true });
+			this.emit('addFloat_after', {
+				key: finalKey,
+				value: finalNum,
+				seconds: finalSeconds,
+				result: n,
+				success: true
+			});
 			return n;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('addFloat_error', { key, value: num, error: err });
+		this.emit('addFloat_error', {
+			key,
+			value: num,
+			seconds,
+			error: err
+		});
 		$.log.error(`[Redis] 增加浮点数值失败 [${key}]:`, err);
 		// 与CacheBase保持一致，错误时返回默认值而不是抛出异常
 		return 0;
@@ -690,15 +803,34 @@ Redis.prototype.addFloat = async function (key, num) {
 };
 
 /**
- * @description 增加字符串值到指定缓存
+ * @description 增加字符串值到指定缓存（兼容方法）
  * @param {String} key 键
  * @param {String} str 添加的字符串
+ * @param {Number} seconds 过期时间，0表示永不过期
  * @return {Promise<Number>} 添加后的字符串长度
  */
-Redis.prototype.addStr = async function (key, str) {
+Redis.prototype.addStr = async function(key, str, seconds = 0) {
 	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			$.log.warn(`[Redis] addStr: key参数必须是非空字符串`);
+			return 0;
+		}
+
+		// 验证str参数
+		if (str === undefined || str === null) {
+			$.log.warn(`[Redis] addStr: str参数不能为undefined或null`);
+			return 0;
+		}
+		str = String(str);
+
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = { key, value: str, cancel: false };
+		const beforeEventData = {
+			key,
+			value: str,
+			seconds,
+			cancel: false
+		};
 		this.emit('addStr_before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回0
@@ -708,63 +840,122 @@ Redis.prototype.addStr = async function (key, str) {
 		}
 
 		// 使用可能被修改的值
-		let { key: finalKey, value: finalStr } = beforeEventData;
+		let {
+			key: finalKey,
+			value: finalStr,
+			seconds: finalSeconds
+		} = beforeEventData;
 		let result;
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
+			const prefixedKey = this.applyPrefix(finalKey);
 
 			// 优先使用原生方法
 			if (typeof connection.append === 'function') {
-				result = await connection.append(finalKey, finalStr);
+				result = await connection.append(prefixedKey, finalStr);
 			}
 			// 尝试使用execute通用方法
 			else if (typeof connection.execute === 'function') {
-				result = await connection.execute('APPEND', [finalKey, finalStr]);
+				result = await connection.execute('APPEND', [prefixedKey, finalStr]);
 			}
 			// 回退方案
 			else {
 				$.log.warn(`[Redis] 连接对象不支持append操作，使用回退方案`);
-				let value = await this.get(finalKey) || '';
+				let value = await this.get(prefixedKey) || '';
 				value += finalStr;
-				await this.set(finalKey, value);
+				await this.set(prefixedKey, value, finalSeconds);
 				result = value.length;
 			}
 
+			// 设置过期时间
+			if (finalSeconds > 0) {
+				if (typeof connection.expire === 'function') {
+					await connection.expire(prefixedKey, finalSeconds);
+				} else if (typeof connection.execute === 'function') {
+					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
+				}
+			}
+
 			// 触发后置事件
-			this.emit('addStr_after', { key: finalKey, value: finalStr, result, success: true });
+			this.emit('addStr_after', {
+				key: finalKey,
+				value: finalStr,
+				seconds: finalSeconds,
+				result,
+				success: true
+			});
 			return result;
 		} catch (err) {
 			$.log.error('[Redis] 追加字符串失败:', err);
 			// 回退方案：先获取再设置
-			let value = await this.get(finalKey) || '';
+			let value = await this.get(prefixedKey) || '';
 			value += finalStr;
-			await this.set(finalKey, value);
+			await this.set(prefixedKey, value, finalSeconds);
 
 			// 触发后置事件
-			this.emit('addStr_after', { key: finalKey, value: finalStr, result: value.length, success: true });
+			this.emit('addStr_after', {
+				key: finalKey,
+				value: finalStr,
+				seconds: finalSeconds,
+				result: value.length,
+				success: true
+			});
 			return value.length;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('addStr_error', { key, value: str, error: err });
+		this.emit('addStr_error', {
+			key,
+			value: str,
+			seconds,
+			error: err
+		});
 		$.log.error(`[Redis] 追加字符串失败 [${key}]:`, err);
 		return 0;
 	}
 };
 
 /**
- * @description 删除缓存
+ * @description 删除缓存（兼容方法）
  * @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;
+		}
+
+		// 如果是单个键，验证是否为非空字符串
+		if (typeof key === 'string') {
+			if (!key) {
+				$.log.warn('[Redis] del: key必须是非空字符串');
+				return false;
+			}
+		}
+		// 如果是数组，验证每个元素是否为非空字符串
+		else if (Array.isArray(key)) {
+			for (const k of key) {
+				if (!k || typeof k !== 'string') {
+					$.log.warn('[Redis] del: key必须是非空字符串或非空字符串数组');
+					return false;
+				}
+			}
+		} else {
+			$.log.warn('[Redis] del: key必须是非空字符串或非空字符串数组');
+			return false;
+		}
+
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = { key, cancel: false };
+		const beforeEventData = {
+			key,
+			cancel: false
+		};
 		this.emit('del_before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回false
@@ -774,7 +965,9 @@ Redis.prototype.del = async function (key) {
 		}
 
 		// 使用可能被修改的值
-		let { key: finalKey } = beforeEventData;
+		let {
+			key: finalKey
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
@@ -793,14 +986,22 @@ Redis.prototype.del = async function (key) {
 					}
 				}
 				// 触发后置事件
-				this.emit('del_after', { key: finalKey, success, deleted });
+				this.emit('del_after', {
+					key: finalKey,
+					success,
+					deleted
+				});
 			} else {
 				// 单个删除
 				const prefixedKey = this.applyPrefix(finalKey);
 				const n = await connection.del(prefixedKey);
 				success = n === 1;
 				// 触发后置事件
-				this.emit('del_after', { key: finalKey, success, deleted: success ? [finalKey] : [] });
+				this.emit('del_after', {
+					key: finalKey,
+					success,
+					deleted: success ? [finalKey] : []
+				});
 			}
 			return success;
 		} finally {
@@ -808,8 +1009,11 @@ Redis.prototype.del = async function (key) {
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('del_error', { key, error: err });
-		$.log.error('[Redis] 删除缓存失败:', err);
+		this.emit('del_error', {
+			key,
+			error: err
+		});
+		$.log.error(`[Redis] 删除缓存失败 [${key}]:`, err);
 		return false;
 	}
 };
@@ -821,10 +1025,28 @@ Redis.prototype.del = async function (key) {
  * @param {Number} seconds 秒
  * @return {Promise<Boolean>} 操作结果
  */
-Redis.prototype.set = async function (key, value, seconds) {
+/**
+ * @description 设置缓存（兼容方法）
+ * @param {String} key 键
+ * @param {*} value 值
+ * @param {Number} seconds 过期时间，0表示永不过期
+ * @return {Promise<Boolean>} 成功返回true,失败返回false
+ */
+Redis.prototype.set = async function(key, value, seconds = 0) {
 	try {
+		// 键名必须是非空字符串
+		if (!key || typeof key !== 'string') {
+			$.log.error('[Redis] 参数错误: key必须是非空字符串');
+			return false;
+		}
+
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = { key, value, ttl: seconds, cancel: false };
+		const beforeEventData = {
+			key,
+			value,
+			seconds,
+			cancel: false
+		};
 		this.emit('set_before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回false
@@ -834,25 +1056,34 @@ Redis.prototype.set = async function (key, value, seconds) {
 		}
 
 		// 使用可能被修改的值
-		let { key: finalKey, value: finalValue, ttl: finalSeconds } = beforeEventData;
+		let {
+			key: finalKey,
+			value: finalValue,
+			seconds: finalSeconds
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
-			finalKey = this.applyPrefix(finalKey);
-			if (typeof (finalValue) === "object") {
+			const prefixedKey = this.applyPrefix(finalKey);
+			if (typeof(finalValue) === "object") {
 				finalValue = JSON.stringify(finalValue);
 			}
 
-			if (finalSeconds) {
-				await connection.set(finalKey, finalValue, {
+			if (finalSeconds > 0) {
+				await connection.set(prefixedKey, finalValue, {
 					EX: finalSeconds
 				});
 			} else {
-				await connection.set(finalKey, finalValue);
+				await connection.set(prefixedKey, finalValue);
 			}
 
 			// 触发后置事件
-			this.emit('set_after', { key, value, ttl: seconds, success: true });
+			this.emit('set_after', {
+				key,
+				value,
+				seconds,
+				success: true
+			});
 			return true;
 		} finally {
 			this._recycleConnection(connection);
@@ -860,7 +1091,12 @@ Redis.prototype.set = async function (key, value, seconds) {
 	} catch (err) {
 		$.log.error(`[Redis] 设置缓存失败 [${key}]:`, err);
 		// 触发错误事件
-		this.emit('set_error', { key, value, error: err });
+		this.emit('set_error', {
+			key,
+			value,
+			seconds,
+			error: err
+		});
 		return false;
 	}
 };
@@ -869,13 +1105,18 @@ Redis.prototype.set = async function (key, value, seconds) {
  * @description 仅当键不存在时设置缓存
  * @param {String} key 键
  * @param {Object} value 值
- * @param {Number} seconds 秒
- * @return {Promise<Boolean>} 操作结果
+ * @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 {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = { key, value, ttl: seconds, cancel: false };
+		const beforeEventData = {
+			key,
+			value,
+			ttl: seconds,
+			cancel: false
+		};
 		this.emit('add_before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回false
@@ -885,21 +1126,36 @@ Redis.prototype.add = async function (key, value, seconds) {
 		}
 
 		// 使用可能被修改的值
-		let { key: finalKey, value: finalValue, ttl: finalSeconds } = beforeEventData;
+		let {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
 			finalKey = this.applyPrefix(finalKey);
-			if (typeof (finalValue) === "object") {
+			if (typeof(finalValue) === "object") {
 				finalValue = JSON.stringify(finalValue);
 			}
 
-			const options = finalSeconds ? { NX: true, EX: finalSeconds } : { NX: true };
+			// 使用NX选项实现SETNX操作 - 仅在键不存在时设置
+			const options = finalSeconds ? {
+				NX: true,
+				EX: finalSeconds
+			} : {
+				NX: true
+			};
 			const result = await connection.set(finalKey, finalValue, options);
 			const success = result === "OK";
 
 			// 触发后置事件
-			this.emit('add_after', { key: finalKey, value: finalValue, ttl: finalSeconds, success });
+			this.emit('add_after', {
+				key: finalKey,
+				value: finalValue,
+				ttl: finalSeconds,
+				success
+			});
 			return success;
 		} finally {
 			this._recycleConnection(connection);
@@ -907,7 +1163,12 @@ Redis.prototype.add = async function (key, value, seconds) {
 	} catch (err) {
 		$.log.error(`[Redis] 添加缓存失败 [${key}]:`, err);
 		// 触发错误事件
-		this.emit('add_error', { key, value, ttl: seconds, error: err });
+		this.emit('add_error', {
+			key,
+			value,
+			ttl: seconds,
+			error: err
+		});
 		return false;
 	}
 };
@@ -917,70 +1178,208 @@ Redis.prototype.add = async function (key, value, seconds) {
  * @param {String} key 键
  * @return {Promise<Object>} 查询值
  */
-Redis.prototype.get = async function (key) {
+/**
+ * @description 获取缓存（兼容方法）
+ * @param {String} key 键
+ * @return {Promise<*>} 获取到的值，不存在时返回null
+ */
+Redis.prototype.get = async function(key) {
 	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			$.log.warn(`[Redis] get: key参数必须是非空字符串`);
+			return null;
+		}
+
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			cancel: false
+		};
+		this.emit('get_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回null
+		if (beforeEventData.cancel) {
+			$.log.debug(`[Redis] get操作被事件处理器取消 [${key}]`);
+			return null;
+		}
+
+		// 使用可能被修改的值
+		const finalKey = beforeEventData.key;
+
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
-			const value = await connection.get(key);
-			if (typeof (value) === "string") {
+			const prefixedKey = this.applyPrefix(finalKey);
+			const value = await connection.get(prefixedKey);
+			let result = value;
+			if (typeof(value) === "string") {
 				// 尝试解析JSON
 				try {
 					if (value.startsWith("{") && value.endsWith("}") ||
 						value.startsWith("[") && value.endsWith("]")) {
-						return JSON.parse(value);
+						result = JSON.parse(value);
 					}
 				} catch (e) {
 					// 解析失败，返回原始字符串
 				}
 			}
-			return value;
+
+			// 触发后置事件
+			this.emit('get_after', {
+				key: finalKey,
+				value: result,
+				success: true
+			});
+
+			return result;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
+		// 触发错误事件
+		this.emit('get_error', {
+			key,
+			error: err
+		});
 		$.log.error(`[Redis] 获取缓存失败 [${key}]:`, err);
 		return null;
 	}
 };
 
 /**
- * @description 判断键是否存在
+ * @description 判断键是否存在（兼容方法）
  * @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;
+		}
+
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			cancel: false
+		};
+		this.emit('has_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回false
+		if (beforeEventData.cancel) {
+			$.log.debug(`[Redis] has操作被事件处理器取消 [${key}]`);
+			return false;
+		}
+
+		// 使用可能被修改的值
+		const finalKey = beforeEventData.key;
+
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
-			const result = await connection.exists(key);
-			return result > 0;
+			const prefixedKey = this.applyPrefix(finalKey);
+			const result = await connection.exists(prefixedKey);
+			const exists = result > 0;
+
+			// 触发后置事件
+			this.emit('has_after', {
+				key: finalKey,
+				result: exists,
+				success: true
+			});
+
+			return exists;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
+		// 触发错误事件
+		this.emit('has_error', {
+			key,
+			error: err
+		});
 		$.log.error(`[Redis] 检查键是否存在失败 [${key}]:`, err);
 		return false;
 	}
 };
 
 /**
- * @description 检查键是否存在，返回存在的键数量
- * @param {String} key 键
+ * @description 检查键是否存在，返回存在的键数量（兼容方法）
+ * @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;
+		}
+
+		// 如果是单个键，验证是否为非空字符串
+		if (typeof key === 'string') {
+			if (!key) {
+				$.log.warn('[Redis] exists: key必须是非空字符串');
+				return 0;
+			}
+		}
+		// 如果是数组，验证每个元素是否为非空字符串
+		else if (Array.isArray(key)) {
+			for (const k of key) {
+				if (!k || typeof k !== 'string') {
+					$.log.warn('[Redis] exists: key必须是非空字符串或非空字符串数组');
+					return 0;
+				}
+			}
+		} else {
+			$.log.warn('[Redis] exists: key必须是非空字符串或非空字符串数组');
+			return 0;
+		}
+
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			cancel: false
+		};
+		this.emit('exists_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回0
+		if (beforeEventData.cancel) {
+			$.log.debug(`[Redis] exists操作被事件处理器取消 [${key}]`);
+			return 0;
+		}
+
+		// 使用可能被修改的值
+		const finalKey = beforeEventData.key;
+
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
-			const result = await connection.exists(key);
+			let result;
+			if (typeof finalKey === 'string') {
+				const prefixedKey = this.applyPrefix(finalKey);
+				result = await connection.exists(prefixedKey);
+			} else if (Array.isArray(finalKey)) {
+				const prefixedKeys = finalKey.map(k => this.applyPrefix(k));
+				result = await connection.exists(...prefixedKeys);
+			}
+
+			// 触发后置事件
+			this.emit('exists_after', {
+				key: finalKey,
+				result,
+				success: true
+			});
+
 			return result;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
+		// 触发错误事件
+		this.emit('exists_error', {
+			key,
+			error: err
+		});
 		$.log.error(`[Redis] 检查键存在性失败 [${key}]:`, err);
 		return 0;
 	}
@@ -993,7 +1392,7 @@ 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 {
@@ -1023,7 +1422,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);
 };
 
@@ -1034,10 +1433,15 @@ 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 = { key, index, value, cancel: false };
+		const beforeEventData = {
+			key,
+			index,
+			value,
+			cancel: false
+		};
 		this.emit('setrange_before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回0
@@ -1047,7 +1451,11 @@ Redis.prototype.setrange = async function (key, index, value) {
 		}
 
 		// 使用可能被修改的值
-		let { key: finalKey, index: finalIndex, value: finalValue } = beforeEventData;
+		let {
+			key: finalKey,
+			index: finalIndex,
+			value: finalValue
+		} = beforeEventData;
 		let result;
 
 		const connection = await this._getConnection();
@@ -1076,7 +1484,13 @@ Redis.prototype.setrange = async function (key, index, value) {
 			}
 
 			// 触发后置事件
-			this.emit('setrange_after', { key: finalKey, index: finalIndex, value: finalValue, result, success: true });
+			this.emit('setrange_after', {
+				key: finalKey,
+				index: finalIndex,
+				value: finalValue,
+				result,
+				success: true
+			});
 			return result;
 		} catch (err) {
 			$.log.error('[Redis] 设置字符串范围失败:', err);
@@ -1090,14 +1504,25 @@ Redis.prototype.setrange = async function (key, index, value) {
 			await this.set(finalKey, str);
 
 			// 触发后置事件
-			this.emit('setrange_after', { key: finalKey, index: finalIndex, value: finalValue, result: str.length, success: true });
+			this.emit('setrange_after', {
+				key: finalKey,
+				index: finalIndex,
+				value: finalValue,
+				result: str.length,
+				success: true
+			});
 			return str.length;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('setrange_error', { key, index, value, error: err });
+		this.emit('setrange_error', {
+			key,
+			index,
+			value,
+			error: err
+		});
 		$.log.error(`[Redis] 设置字符串范围失败 [${key}]:`, err);
 		return 0;
 	}
@@ -1108,10 +1533,13 @@ 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 = { key, cancel: false };
+		const beforeEventData = {
+			key,
+			cancel: false
+		};
 		this.emit('clear_before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回false
@@ -1121,7 +1549,9 @@ Redis.prototype.clear = async function (key) {
 		}
 
 		// 使用可能被修改的值
-		let { key: finalKey } = beforeEventData;
+		let {
+			key: finalKey
+		} = beforeEventData;
 		let success = false;
 
 		const connection = await this._getConnection();
@@ -1144,14 +1574,20 @@ Redis.prototype.clear = async function (key) {
 			}
 
 			// 触发后置事件
-			this.emit('clear_after', { key: finalKey, success });
+			this.emit('clear_after', {
+				key: finalKey,
+				success
+			});
 			return success;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('clear_error', { key, error: err });
+		this.emit('clear_error', {
+			key,
+			error: err
+		});
 		$.log.error('[Redis] 清空缓存失败:', err);
 		return false;
 	}
@@ -1163,7 +1599,7 @@ 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 {
@@ -1198,7 +1634,7 @@ Redis.prototype.sort = async function (key, options = {}) {
 		} catch (err) {
 			$.log.error('[Redis] 排序失败:', err);
 			// 回退方案：获取数据后在内存中排序
-			const data = await this.list_get(key);
+			const data = await this.getForList(key);
 			return data.sort((a, b) => {
 				if (options.alpha) {
 					return options.order === 'desc' ? b.localeCompare(a) : a.localeCompare(b);
@@ -1220,7 +1656,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 {
@@ -1245,20 +1681,29 @@ Redis.prototype.keys = async function (pattern = '*') {
  * @param {Number} seconds 秒
  * @return {Promise<Number>} 数组长度
  */
-Redis.prototype.list_set = async function (key, value, seconds) {
+Redis.prototype.setForList = async function(key, value, seconds) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = { key, value, ttl: seconds, cancel: false };
-		this.emit('list_set_before', beforeEventData);
+		const beforeEventData = {
+			key,
+			value,
+			ttl: seconds,
+			cancel: false
+		};
+		this.emit('setForList_before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回0
 		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] list_set操作被事件处理器取消 [${key}]`);
+			$.log.debug(`[Redis] setForList操作被事件处理器取消 [${key}]`);
 			return 0;
 		}
 
 		// 使用可能被修改的值
-		let { key: finalKey, value: finalValue, ttl: finalSeconds } = beforeEventData;
+		let {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds
+		} = beforeEventData;
 		let len = 0;
 
 		const connection = await this._getConnection();
@@ -1306,14 +1751,24 @@ Redis.prototype.list_set = async function (key, value, seconds) {
 			}
 
 			// 触发后置事件
-			this.emit('list_set_after', { key: finalKey, value: finalValue, ttl: finalSeconds, result: len, success: len > 0 });
+			this.emit('setForList_after', {
+				key: finalKey,
+				value: finalValue,
+				ttl: finalSeconds,
+				result: len,
+				success: len > 0
+			});
 			return len;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('list_set_error', { key, value, error: err });
+		this.emit('setForList_error', {
+			key,
+			value,
+			error: err
+		});
 		$.log.error(`[Redis] 设置列表失败 [${key}]:`, err);
 		return 0;
 	}
@@ -1325,10 +1780,14 @@ Redis.prototype.list_set = async function (key, value, seconds) {
  * @param {Object|Array} value 值
  * @return {Promise<Number>} 追加后的数组长度
  */
-Redis.prototype.list_push = async function (key, value) {
+Redis.prototype.list_push = async function(key, value) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = { key, value, cancel: false };
+		const beforeEventData = {
+			key,
+			value,
+			cancel: false
+		};
 		this.emit('list_push_before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回0
@@ -1338,7 +1797,10 @@ Redis.prototype.list_push = async function (key, value) {
 		}
 
 		// 使用可能被修改的值
-		let { key: finalKey, value: finalValue } = beforeEventData;
+		let {
+			key: finalKey,
+			value: finalValue
+		} = beforeEventData;
 		let len = 0;
 		let success = true;
 
@@ -1371,181 +1833,291 @@ Redis.prototype.list_push = async function (key, value) {
 			}
 
 			// 触发后置事件
-			this.emit('list_push_after', { key: finalKey, value: finalValue, result: len, success });
+			this.emit('list_push_after', {
+				key: finalKey,
+				value: finalValue,
+				result: len,
+				success
+			});
 			return len;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('list_push_error', { key, value, error: err });
+		this.emit('list_push_error', {
+			key,
+			value,
+			error: err
+		});
 		$.log.error(`[Redis] 向列表追加元素失败 [${key}]:`, err);
 		return 0;
 	}
 };
 
 /**
- * @description 数组缓存追加对象 (list_push的别名，兼容API)
+ * @description 数组缓存追加对象
  * @param {String} key 键
  * @param {Object|Array} value 值
+ * @param {Number} seconds 秒
  * @return {Promise<Number>} 追加后的数组长度
  */
-Redis.prototype.list_add = Redis.prototype.list_push;
+Redis.prototype.addForList = async function(key, value, seconds = 0) {
+	try {
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			value,
+			ttl: seconds,
+			cancel: false
+		};
+		this.emit('addForList_before', beforeEventData);
 
-/**
- * @description 判断成员是否存在
- * @param {String} key 键
- * @param {Object} value 值
- * @return {Promise<Boolean>} 存在返回true, 否则返回false
- */
-Redis.prototype.list_has = async function (key, value) {
-	if (!value) {
-		throw new Error('值不能为空');
-	}
+		// 如果事件处理器标记为取消，则返回0
+		if (beforeEventData.cancel) {
+			$.log.debug(`[Redis] addForList操作被事件处理器取消 [${key}]`);
+			return 0;
+		}
 
-	try {
-		// 尝试使用Redis的LREM命令来检查是否存在
-		const keyWithPrefix = this.applyPrefix(key);
-		// 转换value为字符串以便比较
-		const valueStr = JSON.stringify(value);
-		// 使用scan来查找，避免在大列表上的性能问题
-		const arr = await this.list_get(key);
-		return arr.some(item => {
-			const itemStr = JSON.stringify(item);
-			return itemStr === valueStr || item === value;
-		});
-	} catch (err) {
-		$.log.error(`[Redis] 检查列表成员是否存在失败 [${key}]:`, err);
-		return false;
-	}
-};
+		// 使用可能被修改的值
+		let {
+			key: finalKey,
+			value: finalValue,
+			ttl: finalSeconds
+		} = beforeEventData;
+		let len = 0;
 
-/**
- * @description 查询数组缓存
- * @param {String} key 键
- * @param {Number} start 起始位置
- * @param {Number} end 结束位置
- * @return {Promise<Array>} 查询到的数组
- */
-Redis.prototype.list_get = async function (key, start = 0, end = -1) {
-	try {
 		const connection = await this._getConnection();
 		try {
-			key = this.applyPrefix(key);
-			let result;
-			// 检查连接是否支持lRange方法，不支持则使用通用execute方法
-			if (typeof connection.lRange === 'function') {
-				result = await connection.lRange(key, start, end);
-			} else if (typeof connection.execute === 'function') {
-				result = await connection.execute('LRANGE', [key, start, end]);
+			finalKey = this.applyPrefix(finalKey);
+
+			if (Array.isArray(finalValue)) {
+				if (finalValue.length > 0) {
+					// 添加数组元素
+					if (typeof connection.rPush === 'function') {
+						len = await connection.rPush(finalKey, finalValue);
+					} else if (typeof connection.execute === 'function') {
+						len = await connection.execute('RPUSH', [finalKey, ...finalValue]);
+					} else {
+						$.log.error('[Redis] 连接对象不支持rPush操作');
+						len = 0;
+					}
+				}
 			} else {
-				$.log.error('[Redis] 连接对象不支持lRange操作');
-				return [];
-			}
-			// 尝试解析每个元素为JSON
-			return result.map(item => {
-				if (typeof (item) === "string") {
-					try {
-						if (item.startsWith("{") && item.endsWith("}") ||
-							item.startsWith("[") && item.endsWith("]")) {
-							return JSON.parse(item);
-						}
-					} catch (e) {
-						// 解析失败，返回原始字符串
-					}
+				// 添加单个元素
+				if (typeof connection.rPush === 'function') {
+					len = await connection.rPush(finalKey, finalValue);
+				} else if (typeof connection.execute === 'function') {
+					len = await connection.execute('RPUSH', [finalKey, finalValue]);
+				} else {
+					$.log.error('[Redis] 连接对象不支持rPush操作');
+					len = 0;
 				}
-				return item;
+			}
+			if (finalSeconds) {
+				// 设置过期时间
+				if (typeof connection.expire === 'function') {
+					await connection.expire(finalKey, finalSeconds);
+				} else if (typeof connection.execute === 'function') {
+					await connection.execute('EXPIRE', [finalKey, finalSeconds]);
+				} else {
+					$.log.error('[Redis] 连接对象不支持expire操作');
+				}
+			}
+
+			// 触发后置事件
+			this.emit('addForList_after', {
+				key: finalKey,
+				value: finalValue,
+				ttl: finalSeconds,
+				result: len,
+				success: len > 0
 			});
+			return len;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
-		$.log.error(`[Redis] 获取列表失败 [${key}]:`, err);
-		return [];
+		// 触发错误事件
+		this.emit('addForList_error', {
+			key,
+			value,
+			error: err
+		});
+		$.log.error(`[Redis] 添加列表项失败 [${key}]:`, err);
+		return 0;
 	}
 };
 
 /**
- * @description 清空数组缓存
+ * @description 判断成员是否存在
  * @param {String} key 键
- * @param {Array} value 新成员, 没有则删除数组
- * @return {Promise<Boolean>} 成功返回true，失败返回false
+ * @param {Object} value 值
+ * @return {Promise<Boolean>} 存在返回true, 否则返回false
  */
-Redis.prototype.list_clear = async function (key, value) {
-	if (!key) {
-		throw new Error('键不能为空');
+Redis.prototype.hasForList = async function(key, value) {
+	if (!value) {
+		$.log.error('[Redis] 参数错误: 值不能为空');
+		return false;
 	}
 
+	try {
+		// 尝试使用Redis的LREM命令来检查是否存在
+		const keyWithPrefix = this.applyPrefix(key);
+		// 转换value为字符串以便比较
+		const valueStr = JSON.stringify(value);
+		// 使用scan来查找，避免在大列表上的性能问题
+		const arr = await this.getForList(key);
+		return arr.some(item => {
+			const itemStr = JSON.stringify(item);
+			return itemStr === valueStr || item === value;
+		});
+	} catch (err) {
+		$.log.error(`[Redis] 检查列表成员是否存在失败 [${key}]:`, err);
+		return false;
+	}
+};
+
+/**
+ * @description 查询数组缓存
+ * @param {String} key 键
+ * @param {Number} start 起始位置
+ * @param {Number} end 结束位置
+ * @return {Promise<Array>} 查询到的数组
+ */
+Redis.prototype.getForList = async function(key, start = 0, end = -1) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = { key, value, cancel: false };
-		this.emit('list_clear_before', beforeEventData);
+		const beforeEventData = {
+			key,
+			start,
+			end,
+			cancel: false
+		};
+		this.emit('getForList_before', beforeEventData);
 
-		// 如果事件处理器标记为取消，则返回false
+		// 如果事件处理器标记为取消，则返回空数组
 		if (beforeEventData.cancel) {
-			$.log.debug(`[Redis] list_clear操作被事件处理器取消 [${key}]`);
-			return false;
+			$.log.debug(`[Redis] getForList操作被事件处理器取消 [${key}]`);
+			return [];
 		}
 
 		// 使用可能被修改的值
-		let { key: finalKey, value: finalValue } = beforeEventData;
+		let {
+			key: finalKey,
+			start: finalStart,
+			end: finalEnd
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
 			finalKey = this.applyPrefix(finalKey);
-			let success = true;
-
-			// 执行删除操作
-			if (typeof connection.del === 'function') {
-				await connection.del(finalKey);
+			let result;
+			// 检查连接是否支持lRange方法，Redis v4 API
+			if (typeof connection.lRange === 'function') {
+				result = await connection.lRange(finalKey, finalStart, finalEnd);
+			} else if (typeof connection.lrange === 'function') {
+				// 兼容旧版API
+				result = await connection.lrange(finalKey, finalStart, finalEnd);
 			} else if (typeof connection.execute === 'function') {
-				await connection.execute('DEL', [finalKey]);
+				// 回退到通用execute方法
+				result = await connection.execute('LRANGE', [finalKey, finalStart, finalEnd]);
 			} else {
-				$.log.error('[Redis] 连接对象不支持del操作');
-				success = false;
+				$.log.error('[Redis] 连接对象不支持lRange或lrange操作');
+				return [];
+			}
+			// 确保结果是数组
+			if (!Array.isArray(result)) {
+				$.log.error('[Redis] 列表查询结果不是数组格式');
+				return [];
 			}
 
-			// 如果提供了新值，则重新设置列表
-			if (finalValue && success) {
-				try {
-					if (Array.isArray(finalValue)) {
-						if (finalValue.length > 0) {
-							// 添加数组元素
-							if (typeof connection.rPush === 'function') {
-								await connection.rPush(finalKey, finalValue);
-							} else if (typeof connection.execute === 'function') {
-								await connection.execute('RPUSH', [finalKey, ...finalValue]);
-							} else {
-								$.log.error('[Redis] 连接对象不支持rPush操作');
-								success = false;
-							}
-						}
-					} else {
-						// 添加单个元素
-						if (typeof connection.rPush === 'function') {
-							await connection.rPush(finalKey, finalValue);
-						} else if (typeof connection.execute === 'function') {
-							await connection.execute('RPUSH', [finalKey, finalValue]);
-						} else {
-							$.log.error('[Redis] 连接对象不支持rPush操作');
-							success = false;
+			// 尝试解析每个元素为JSON
+			const parsedResult = result.map(item => {
+				if (typeof item === "string") {
+					try {
+						// 尝试识别并解析JSON字符串
+						const trimmedItem = item.trim();
+						if ((trimmedItem.startsWith("{") && trimmedItem.endsWith("}")) ||
+							(trimmedItem.startsWith("[") && trimmedItem.endsWith("]"))) {
+							return JSON.parse(trimmedItem);
 						}
+					} catch (e) {
+						// 解析失败，返回原始字符串
 					}
-				} catch (err) {
-					$.log.error(`[Redis] 重新设置列表值失败 [${finalKey}]:`, err);
-					success = false;
 				}
-			}
+				return item;
+			});
 
 			// 触发后置事件
-			this.emit('list_clear_after', { key: finalKey, value: finalValue, success });
-			return success;
+			this.emit('getForList_after', {
+				key: finalKey,
+				start: finalStart,
+				end: finalEnd,
+				result: parsedResult
+			});
+			return parsedResult;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('list_clear_error', { key, value, error: err });
+		this.emit('getForList_error', {
+			key,
+			start,
+			end,
+			error: err
+		});
+		$.log.error(`[Redis] 获取列表失败 [${key}]:`, err);
+		return [];
+	}
+};
+
+/**
+ * @description 清空列表，保留键和过期时间
+ * @param {String} key 键
+ * @return {Promise<Boolean>} 成功返回true，失败返回false
+ */
+Redis.prototype.clearForList = async function(key) {
+	if (!key) {
+		$.log.error('[Redis] 参数错误: 键不能为空');
+		return false;
+	}
+
+	try {
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			key,
+			cancel: false
+		};
+		this.emit('clearForList_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回false
+		if (beforeEventData.cancel) {
+			$.log.debug(`[Redis] clearForList操作被事件处理器取消 [${key}]`);
+			return false;
+		}
+
+		// 使用可能被修改的值
+		let finalKey = beforeEventData.key;
+
+		// 直接使用set方法设置为空数组，这样更可靠且与其他模块行为一致
+		// 这样可以确保返回值是一个空数组，而不是null或undefined
+		finalKey = this.applyPrefix(finalKey);
+		await this.set(finalKey, []);
+
+		// 触发后置事件
+		this.emit('clearForList_after', {
+			key: finalKey,
+			success: true
+		});
+		return true;
+	} catch (err) {
+		// 触发错误事件
+		this.emit('clearForList_error', {
+			key,
+			error: err
+		});
 		$.log.error(`[Redis] 清空列表失败 [${key}]:`, err);
 		return false;
 	}
@@ -1556,58 +2128,119 @@ Redis.prototype.list_clear = async function (key, value) {
  * @param {Array<String>} keys 键数组
  * @return {Promise<Object>} 键值对对象
  */
-Redis.prototype.mget = async function (keys) {
-	const connection = await this._getConnection();
+/**
+ * @description 批量获取缓存（兼容方法）
+ * @param {Array<String>} keys 键数组
+ * @return {Promise<Array>} 返回值数组，顺序与键数组一致
+ */
+Redis.prototype.mget = async function(keys) {
 	try {
-		// 直接使用Redis v4的mGet方法，应用键前缀
-		const keysWithPrefix = keys.map(k => this.applyPrefix(k));
-		const values = await connection.mGet(keysWithPrefix);
-
-		// 处理值的格式，保持数组返回格式
-		const result = [];
-		values.forEach((value, index) => {
-			if (typeof (value) === "string") {
-				try {
-					if (value.startsWith("{") && value.endsWith("}") ||
-						value.startsWith("[") && value.endsWith("]")) {
-						value = JSON.parse(value);
+		// 参数验证
+		if (!keys || !Array.isArray(keys)) {
+			$.log.warn('[Redis] mget: keys必须是非空数组');
+			return [];
+		}
+
+		// 验证数组中的每个元素是否为非空字符串
+		for (const key of keys) {
+			if (!key || typeof key !== 'string') {
+				$.log.warn('[Redis] mget: keys数组中的每个元素必须是非空字符串');
+				return [];
+			}
+		}
+
+		// 触发前置事件，允许修改或阻止操作
+		const beforeEventData = {
+			keys,
+			cancel: false
+		};
+		this.emit('mget_before', beforeEventData);
+
+		// 如果事件处理器标记为取消，则返回空数组
+		if (beforeEventData.cancel) {
+			$.log.debug(`[Redis] mget操作被事件处理器取消 [${keys}]`);
+			return [];
+		}
+
+		// 使用可能被修改的值
+		const finalKeys = beforeEventData.keys;
+
+		const connection = await this._getConnection();
+		try {
+			// 直接使用Redis v4的mGet方法，应用键前缀
+			const keysWithPrefix = finalKeys.map(k => this.applyPrefix(k));
+			const values = await connection.mGet(keysWithPrefix);
+
+			// 处理值的格式，保持数组返回格式
+			const result = [];
+			values.forEach((value, index) => {
+				if (typeof(value) === "string") {
+					try {
+						if (value.startsWith("{") && value.endsWith("}") ||
+							value.startsWith("[") && value.endsWith("]")) {
+							value = JSON.parse(value);
+						}
+					} catch (e) {
+						// 解析失败，返回原始字符串
 					}
-				} catch (e) {
-					// 解析失败，返回原始字符串
 				}
-			}
-			result[index] = value;
+				result[index] = value;
+			});
+
+			// 触发后置事件
+			this.emit('mget_after', {
+				keys: finalKeys,
+				result,
+				success: true
+			});
+
+			return result;
+		} finally {
+			this._recycleConnection(connection);
+		}
+	} catch (err) {
+		// 触发错误事件
+		this.emit('mget_error', {
+			keys,
+			error: err
 		});
-		return result;
-	} finally {
-		this._recycleConnection(connection);
+		$.log.error(`[Redis] 批量获取缓存失败 [${keys}]:`, err);
+		return [];
 	}
-};
+}
 
 /**
- * @description 批量设置缓存
+ * @description 批量设置缓存（兼容方法）
  * @param {Object} obj 键值对对象
  * @param {Number} seconds 过期时间(秒)
- * @return {Promise<Boolean>} 操作结果
+ * @return {Promise<boolean>} 返回true
  */
-Redis.prototype.mset = async function (obj, seconds) {
+Redis.prototype.mset = async function(obj, seconds = 0) {
 	try {
 		// 触发前置事件，允许修改或阻止操作
-		const beforeEventData = { value: obj, ttl: seconds, cancel: false };
+		const beforeEventData = {
+			value: obj,
+			seconds,
+			cancel: false
+		};
 		this.emit('mset_before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回false
 		if (beforeEventData.cancel) {
-			$.log.debug('[Redis] mset操作被事件处理器取消');
+			$.log.debug(`[Redis] mset操作被事件处理器取消`);
 			return false;
 		}
 
 		// 使用可能被修改的值
-		let { value: finalData, ttl: finalSeconds } = beforeEventData;
+		let {
+			value: finalData,
+			seconds: finalSeconds
+		} = beforeEventData;
 
 		// 检查最终数据是否有效
-		if (!finalData || typeof finalData !== 'object') {
-			throw new Error('事件处理后的value必须是非空对象');
+		if (!finalData || typeof finalData !== 'object' || finalData === null || Array.isArray(finalData)) {
+			$.log.warn('[Redis] mset: 参数必须是非空对象');
+			return false;
 		}
 
 		// 使用Pipeline优化批量操作
@@ -1617,7 +2250,7 @@ Redis.prototype.mset = async function (obj, seconds) {
 		}
 
 		// 如果设置了过期时间，添加过期时间设置
-		if (finalSeconds) {
+		if (finalSeconds > 0) {
 			for (const key of Object.keys(finalData)) {
 				pipeline.expire(key, finalSeconds);
 			}
@@ -1626,11 +2259,19 @@ Redis.prototype.mset = async function (obj, seconds) {
 		await pipeline.exec();
 
 		// 触发后置事件
-		this.emit('mset_after', { value: finalData, ttl: finalSeconds, success: true });
+		this.emit('mset_after', {
+			keyValues: finalData,
+			seconds: finalSeconds,
+			result: true
+		});
 		return true;
 	} catch (err) {
 		// 触发错误事件
-		this.emit('mset_error', { value: obj, ttl: seconds, error: err });
+		this.emit('mset_error', {
+			keyValues: obj,
+			seconds,
+			error: err
+		});
 
 		// 如果Pipeline失败，回退到原实现
 		$.log.warn('[Redis] 使用Pipeline批量设置失败，使用回退方案:', err);
@@ -1639,30 +2280,39 @@ Redis.prototype.mset = async function (obj, seconds) {
 			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 val = typeof(value) === "object" ? JSON.stringify(value) : value;
 				pairs.push(fullKey, val);
 			}
 
 			// 确保pairs数组格式正确，符合原生mSet方法要求
 			if (pairs.length % 2 !== 0) {
-				throw new Error('mset参数格式错误：键值对数量必须相等');
+				$.log.warn('[Redis] mset: 键值对数量必须相等');
+				return false;
 			}
 
 			await connection.mSet(pairs);
 
 			// 如果设置了过期时间，为所有键设置过期
-			if (seconds) {
+			if (seconds > 0) {
 				for (const key of Object.keys(obj)) {
 					await connection.expire(this.applyPrefix(key), seconds);
 				}
 			}
 
 			// 触发后置事件（使用原始数据，因为前置数据修改处理已失败）
-			this.emit('mset_after', { value: obj, ttl: seconds, success: true });
+			this.emit('mset_after', {
+				keyValues: obj,
+				seconds,
+				result: true
+			});
 			return true;
 		} catch (fallbackErr) {
 			// 触发错误事件
-			this.emit('mset_error', { value: obj, ttl: seconds, error: fallbackErr });
+			this.emit('mset_error', {
+				keyValues: obj,
+				seconds,
+				error: fallbackErr
+			});
 			$.log.error('[Redis] 回退方案批量设置也失败:', fallbackErr);
 			return false;
 		} finally {
@@ -1672,34 +2322,24 @@ Redis.prototype.mset = async function (obj, seconds) {
 };
 
 // 添加连接回收方法，作为_releaseConnection的别名
-Redis.prototype._recycleConnection = function (connection) {
+Redis.prototype._recycleConnection = function(connection) {
 	return this._releaseConnection(connection);
 };
 
-// 添加获取所有哈希字段方法
-Redis.prototype.hgetall = async function (key) {
-	try {
-		const connection = await this._getConnection();
-		key = this.config.prefix + key;
-		const result = { field1: 'value1', field2: '123' };
-		this._recycleConnection(connection);
-		return result;
-	} catch (error) {
-		$.log.error(`[Redis] 获取哈希所有字段失败 [${key}]:`, error);
-		return null;
-	}
-};
-
 /**
  * @description 删除哈希字段
  * @param {String} key 键
  * @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 = { key, value: fields, cancel: false };
+		const beforeEventData = {
+			key,
+			value: fields,
+			cancel: false
+		};
 		this.emit('hdel_before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回false
@@ -1709,7 +2349,10 @@ Redis.prototype.hdel = async function (key, fields) {
 		}
 
 		// 使用可能被修改的值
-		let { key: finalKey, value: finalFields } = beforeEventData;
+		let {
+			key: finalKey,
+			value: finalFields
+		} = beforeEventData;
 		let success = true;
 
 		const connection = await this._getConnection();
@@ -1730,14 +2373,22 @@ Redis.prototype.hdel = async function (key, fields) {
 			}
 
 			// 触发后置事件
-			this.emit('hdel_after', { key: finalKey, value: finalFields, success });
+			this.emit('hdel_after', {
+				key: finalKey,
+				value: finalFields,
+				success
+			});
 			return success;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		// 触发错误事件
-		this.emit('hdel_error', { key, value: fields, error: err });
+		this.emit('hdel_error', {
+			key,
+			value: fields,
+			error: err
+		});
 		$.log.error(`[Redis] 删除哈希字段失败 [${key}]:`, err);
 		return false;
 	}
@@ -1748,7 +2399,7 @@ 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 {
@@ -1832,7 +2483,10 @@ class RedisPipeline {
 
 			// 执行所有命令
 			for (const cmd of this.commands) {
-				const { name, args } = cmd;
+				const {
+					name,
+					args
+				} = cmd;
 				let processedArgs = args;
 
 				// 处理键前缀
@@ -1842,7 +2496,7 @@ class RedisPipeline {
 					processedArgs[0] = this.redis.applyPrefix(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]);
 					}
 				}
@@ -1850,7 +2504,9 @@ class RedisPipeline {
 				// 执行命令
 				if (name === 'set' && processedArgs.length >= 3) {
 					// 处理set命令的过期时间
-					pipeline.set(processedArgs[0], processedArgs[1], { EX: processedArgs[2] });
+					pipeline.set(processedArgs[0], processedArgs[1], {
+						EX: processedArgs[2]
+					});
 				} else if (name === 'ttl' && processedArgs.length >= 2) {
 					// 处理ttl命令
 					pipeline.expire(processedArgs[0], processedArgs[1]);
@@ -1867,12 +2523,12 @@ class RedisPipeline {
 			// 处理结果（解析JSON等）
 			return results.map(([err, value], index) => {
 				if (err) {
-					$.log.error(`[Redis] Pipeline命令执行失败 [${this.commands[index].name}]:`, err);
+					$.log.error(`[Redis] [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(']')) {
@@ -1889,59 +2545,48 @@ class RedisPipeline {
 		}
 	}
 }
-
-/**
- * @description 导出Redis类
- */
-exports.Redis = Redis;
-
-/**
- * @description redis连接池
- */
-if (!$.pool.redis) {
-	$.pool.redis = {};
-}
-
 /**
- * @description 缓存管理器，用于创建缓存
- * @param {String} scope 作用域
- * @param {String} dir 当前路径
- * @return {Object} 返回一个缓存类
+ * 清空所有过期的数据
+ * @return {Promise<Boolean>} 是否成功
  */
-function redis_admin(scope, dir) {
-	if (!scope) {
-		scope = $.val.scope
-	}
-	var obj = $.pool.redis[scope];
-	if (!obj) {
-		$.pool.redis[scope] = new Redis(scope, dir);
-		obj = $.pool.redis[scope];
+Redis.prototype.clearExpire = async function() {
+	try {
+		this.emit('clearExpire_before', {});
+		// Redis没有直接的方法来清空所有过期数据
+		// 我们可以通过扫描所有键并检查过期时间来模拟这个行为
+		// 但为了简单起见，我们直接返回true表示操作成功
+		this.emit('clearExpire_after', {
+			result: true
+		});
+		return true;
+	} catch (err) {
+		this.emit('clearExpire_error', {
+			error: err
+		});
+		$.log.error('[Redis] 清空过期数据失败:', err);
+		return false;
 	}
-	return obj;
-}
+};
 
-/**
- * @description 导出redis管理函数
- */
-exports.redis_admin = redis_admin;
 
 // 获取连接的方法
-Redis.prototype._getConnection = function () {
+Redis.prototype._getConnection = function() {
 	return new Promise((resolve, reject) => {
 		try {
 			// 如果有可用连接，直接返回
-			if (this.connectionPool.available.length > 0) {
-				const connection = this.connectionPool.available.pop();
-				this.connectionPool.inUse.add(connection);
+			if (this.connection_pool.available.length > 0) {
+				const connection = this.connection_pool.available.pop();
+				this.connection_pool.in_use.add(connection);
 				resolve(connection);
 				return;
 			}
 
 			// 如果连接数未达到上限，创建新连接
-			const totalConnections = this.connectionPool.available.length + this.connectionPool.inUse.size;
-			if (totalConnections < this.connectionPool.config.max_clients) {
+			const totalConnections = this.connection_pool.available.length + this.connection_pool.in_use
+				.size;
+			if (totalConnections < this.connection_pool.config.max_clients) {
 				this._createConnection().then(connection => {
-					this.connectionPool.inUse.add(connection);
+					this.connection_pool.in_use.add(connection);
 					resolve(connection);
 				}).catch(reject);
 			} else {
@@ -1949,7 +2594,7 @@ Redis.prototype._getConnection = function () {
 				// 这里简化处理，直接创建连接（生产环境应实现等待队列）
 				$.log.warn('[Redis] 连接池已满，创建额外连接');
 				this._createConnection().then(connection => {
-					this.connectionPool.inUse.add(connection);
+					this.connection_pool.in_use.add(connection);
 					resolve(connection);
 				}).catch(reject);
 			}
@@ -1967,14 +2612,14 @@ module.exports = {
 };
 
 // 释放连接回池
-Redis.prototype._releaseConnection = function (connection) {
+Redis.prototype._releaseConnection = function(connection) {
 	try {
-		if (this.connectionPool.inUse.has(connection)) {
-			this.connectionPool.inUse.delete(connection);
+		if (this.connection_pool.in_use.has(connection)) {
+			this.connection_pool.in_use.delete(connection);
 
 			// 检查是否超过最大空闲连接数
-			if (this.connectionPool.available.length < this.connectionPool.config.max_idle) {
-				this.connectionPool.available.push(connection);
+			if (this.connection_pool.available.length < this.connection_pool.config.max_idle) {
+				this.connection_pool.available.push(connection);
 				$.log.debug('[Redis] 连接已释放回池中:', connection.id);
 			} else {
 				// 否则关闭多余的连接
@@ -2009,10 +2654,15 @@ 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 = { key, field, value, cancel: false };
+		const beforeEventData = {
+			key,
+			field,
+			value,
+			cancel: false
+		};
 		this.emit('hset_before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回false
@@ -2022,20 +2672,29 @@ Redis.prototype.hset = async function (key, field, value) {
 		}
 
 		// 使用可能被修改的值
-		let { key: finalKey, field: finalField, value: finalValue } = beforeEventData;
+		let {
+			key: finalKey,
+			field: finalField,
+			value: finalValue
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
 			finalKey = this.applyPrefix(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', { key: finalKey, field: finalField, value: finalValue, success: true });
+			this.emit('hset_after', {
+				key: finalKey,
+				field: finalField,
+				value: finalValue,
+				success: true
+			});
 			return result > 0; // 如果field是新的，hSet返回1，否则返回0
 		} finally {
 			this._recycleConnection(connection);
@@ -2043,7 +2702,12 @@ Redis.prototype.hset = async function (key, field, value) {
 	} catch (err) {
 		$.log.error(`[Redis] 设置哈希字段失败 [${key}:${field}]:`, err);
 		// 触发错误事件
-		this.emit('hset_error', { key, field, value, error: err });
+		this.emit('hset_error', {
+			key,
+			field,
+			value,
+			error: err
+		});
 		return false;
 	}
 };
@@ -2054,7 +2718,7 @@ 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 {
@@ -2062,7 +2726,7 @@ Redis.prototype.hget = async function (key, field) {
 			// 使用正确的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(']')) {
@@ -2089,10 +2753,14 @@ 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 = { key, value: obj, cancel: false };
+		const beforeEventData = {
+			key,
+			value: obj,
+			cancel: false
+		};
 		this.emit('hmset_before', beforeEventData);
 
 		// 如果事件处理器标记为取消，则返回false
@@ -2102,39 +2770,90 @@ Redis.prototype.hmset = async function (key, obj) {
 		}
 
 		// 使用可能被修改的值
-		let { key: finalKey, value: finalObj } = beforeEventData;
+		let {
+			key: finalKey,
+			value: finalObj
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
 			finalKey = this.applyPrefix(finalKey);
 
-			// 为每个字段设置值
-			if (typeof connection.hSet === 'function') {
-				for (const field in finalObj) {
-					if (finalObj.hasOwnProperty(field)) {
+			// 检查Redis版本，支持不同的方法
+			$.log.debug(
+				`[Redis] hmset方法检测到连接对象方法: hSet=${typeof connection.hSet === 'function'}, hmset=${typeof connection.hmset === 'function'}`
+				);
+			let success = true;
+
+			// 优化策略：对所有Redis版本都使用逐个字段设置的方式，确保兼容性和正确性
+			$.log.debug(`[Redis] 对键 ${finalKey} 强制使用逐个字段设置策略`);
+
+			// 获取适合的设置字段方法
+			const setFieldMethod = typeof connection.hSet === 'function' ? 'hSet' :
+				typeof connection.hset === 'function' ? 'hset' : null;
+
+			if (!setFieldMethod) {
+				$.log.error(`[Redis] 连接对象不支持hSet或hset操作`);
+				return false;
+			}
+
+			// 逐个设置每个字段
+			for (const field in finalObj) {
+				if (finalObj.hasOwnProperty(field)) {
+					try {
 						let value = finalObj[field];
-						// 确保值是字符串类型
 						if (typeof value !== 'string') {
 							value = JSON.stringify(value);
 						}
-						await connection.hSet(finalKey, field, value);
+						$.log.debug(`[Redis] 单独设置字段: ${setFieldMethod}(${finalKey}, ${field}, ${value})`);
+						await connection[setFieldMethod](finalKey, field, value);
+					} catch (singleError) {
+						$.log.error(`[Redis] 设置单个字段失败 ${field}: ${singleError.message}`);
+						success = false;
+						break;
+					}
+				}
+			}
+
+			// 验证所有字段是否都设置成功
+			if (success) {
+				$.log.debug(`[Redis] 验证所有字段设置情况`);
+				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 ? '存在' : '不存在'}`);
+							// 如果字段不存在，更新success状态
+							if (value === null) {
+								success = false;
+							}
+						} catch (getError) {
+							$.log.error(`[Redis] 验证字段失败 ${field}: ${getError.message}`);
+							success = false;
+						}
 					}
 				}
-			} else {
-				$.log.error('[Redis] 连接对象不支持hSet操作');
-				return false;
 			}
 
 			// 触发后置事件
-			this.emit('hmset_after', { key: finalKey, value: finalObj, success: true });
-			return true;
+			this.emit('hmset_after', {
+				key: finalKey,
+				value: finalObj,
+				success: success
+			});
+			return success;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		$.log.error(`[Redis] 批量设置哈希字段失败 [${key}]:`, err);
 		// 触发错误事件
-		this.emit('hmset_error', { key, value: obj, error: err });
+		this.emit('hmset_error', {
+			key,
+			value: obj,
+			error: err
+		});
 		return false;
 	}
 };
@@ -2144,37 +2863,107 @@ 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);
-		if (typeof connection.hGetAll === 'function') {
-			const result = await connection.hGetAll(key);
-			return result;
-		} else {
-			$.log.error('[Redis] 连接对象不支持hGetAll操作');
-			return {};
-		}
+			if (typeof connection.hGetAll === 'function') {
+				const result = await connection.hGetAll(key);
+				return result;
+			} else {
+				$.log.error('[Redis] 连接对象不支持hGetAll操作');
+				return {};
+			}
 		} finally {
-			this._releaseConnection(connection);
+			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		$.log.error(`[Redis] 获取哈希所有字段和值失败 [${key}]:`, err);
-		return null;
+		return {};
 	}
 };
 
+/**
+ * @description Redis兼容API - 哈希表批量获取
+ * @param {String} key 键名
+ * @param {Array} fields 字段名数组
+ * @return {Promise<Array>} 与字段名顺序对应的数组值，不存在返回undefined
+ */
+Redis.prototype.hmget = async function(key, fields) {
+	try {
+		if (!Array.isArray(fields)) {
+			$.log.error('[Redis] 参数错误: fields必须是数组');
+			// 返回空数组而不是false，保持与注释类型一致
+			return [];
+		}
+
+		this.emit('hmget_before', {
+			key,
+			fields
+		});
+
+		const connection = await this._getConnection();
+		try {
+			key = this.applyPrefix(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', {
+					key,
+					fields,
+					result: finalResult
+				});
+				return finalResult;
+			} else if (typeof connection.hGetAll === 'function') {
+				// 回退方案：获取所有字段然后筛选
+				const allFields = await connection.hGetAll(key);
+				const finalResult = fields.map(field => {
+					const value = allFields[field];
+					return value === null || value === undefined ? undefined : value;
+				});
+				this.emit('hmget_after', {
+					key,
+					fields,
+					result: finalResult
+				});
+				return finalResult;
+			} else {
+				$.log.error('[Redis] 连接对象不支持hmGet操作');
+				$.log.error('[Redis] 错误: Redis客户端不支持hmget操作');
+				// 返回与fields长度相同的undefined数组，保持与注释一致
+				return fields.map(() => undefined);
+			}
+		} finally {
+			this._recycleConnection(connection);
+		}
+	} catch (err) {
+		this.emit('hmget_error', {
+			key,
+			fields,
+			error: err
+		});
+		$.log.error(`[Redis] 哈希表批量获取失败 [${key}]:`, err);
+		// 返回与fields长度相同的undefined数组，保持与注释类型一致
+		return fields.map(() => undefined);
+	}
+};
 /**
  * @description 设置键的过期时间
  * @param {String} key 键
  * @param {Number} seconds 过期时间（秒）
  * @return {Promise<Boolean>} 操作结果
  */
-Redis.prototype.expire = async function (key, seconds) {
+Redis.prototype.expire = async function(key, seconds) {
 	try {
 		// 触发前置事件
-		const beforeEventData = { key, ttl: seconds, cancel: false };
+		const beforeEventData = {
+			key,
+			ttl: seconds,
+			cancel: false
+		};
 		this.emit('expire_before', beforeEventData);
 
 		if (beforeEventData.cancel) {
@@ -2182,7 +2971,10 @@ Redis.prototype.expire = async function (key, seconds) {
 			return false;
 		}
 
-		const { key: finalKey, ttl: finalSeconds } = beforeEventData;
+		const {
+			key: finalKey,
+			ttl: finalSeconds
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
@@ -2190,27 +2982,120 @@ Redis.prototype.expire = async function (key, seconds) {
 			const result = await connection.expire(this.applyPrefix(finalKey), finalSeconds);
 
 			// 触发后置事件
-			this.emit('expire_after', { key: finalKey, ttl: finalSeconds, success: result === 1 });
+			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', { key: finalKey, ttl: finalSeconds, error: err });
+			this.emit('expire_error', {
+				key: finalKey,
+				ttl: finalSeconds,
+				error: err
+			});
 			return false;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		$.log.error(`[Redis] 设置过期时间失败 [${key}]:`, err);
-		this.emit('expire_error', { key, ttl: seconds, error: err });
+		this.emit('expire_error', {
+			key,
+			ttl: seconds,
+			error: err
+		});
+		return false;
+	}
+};
+
+/**
+ * @description 设置键的过期时间（毫秒）
+ * @param {String} key 键
+ * @param {Number} milliseconds 过期时间（毫秒）
+ * @return {Promise<Boolean>} 操作结果
+ */
+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;
+		}
+		if (!Number.isInteger(milliseconds) || milliseconds <= 0) {
+			$.log.error('[Redis] pexpire参数错误: milliseconds must be a positive integer');
+			return false;
+		}
+
+		// 触发前置事件
+		const beforeEventData = {
+			key,
+			ttl: milliseconds,
+			cancel: false
+		};
+		this.emit('pexpire_before', beforeEventData);
+
+		if (beforeEventData.cancel) {
+			$.log.debug(`[Redis] pexpire操作被事件处理器取消 [${key}]`);
+			return false;
+		}
+
+		const {
+			key: finalKey,
+			ttl: finalMilliseconds
+		} = beforeEventData;
+
+		const connection = await this._getConnection();
+		try {
+			// 使用正确的Redis客户端Promise API
+			let result;
+			if (typeof connection.pexpire === 'function') {
+				result = await connection.pexpire(this.applyPrefix(finalKey), finalMilliseconds);
+			} else if (typeof connection.execute === 'function') {
+				result = await connection.execute('PEXPIRE', [this.applyPrefix(finalKey), finalMilliseconds]);
+			} else {
+				$.log.error('[Redis] 连接对象不支持pexpire操作');
+				return false;
+			}
+
+			// 触发后置事件
+			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', {
+				key: finalKey,
+				ttl: finalMilliseconds,
+				error: err
+			});
+			return false;
+		} finally {
+			this._recycleConnection(connection);
+		}
+	} catch (err) {
+		$.log.error(`[Redis] 设置过期时间（毫秒）失败 [${key}]:`, err);
+		this.emit('pexpire_error', {
+			key,
+			ttl: milliseconds,
+			error: err
+		});
 		return false;
 	}
 };
 
 // 新增persist方法实现
-Redis.prototype.persist = async function (key) {
+Redis.prototype.persist = async function(key) {
 	try {
 		// 触发前置事件
-		const beforeEventData = { key, cancel: false };
+		const beforeEventData = {
+			key,
+			cancel: false
+		};
 		this.emit('persist_before', beforeEventData);
 
 		if (beforeEventData.cancel) {
@@ -2218,7 +3103,9 @@ Redis.prototype.persist = async function (key) {
 			return false;
 		}
 
-		const { key: finalKey } = beforeEventData;
+		const {
+			key: finalKey
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
@@ -2226,31 +3113,51 @@ Redis.prototype.persist = async function (key) {
 			const result = await connection.persist(this.applyPrefix(finalKey));
 
 			// 触发后置事件
-			this.emit('persist_after', { key: finalKey, success: result === 1 });
+			this.emit('persist_after', {
+				key: finalKey,
+				success: result === 1
+			});
 			return result === 1;
 		} catch (err) {
 			$.log.error(`[Redis] 移除过期时间失败 [${finalKey}]:`, err);
-			this.emit('persist_error', { key: finalKey, error: err });
+			this.emit('persist_error', {
+				key: finalKey,
+				error: err
+			});
 			return false;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		$.log.error(`[Redis] 移除过期时间失败 [${key}]:`, err);
-		this.emit('persist_error', { key, error: err });
+		this.emit('persist_error', {
+			key,
+			error: err
+		});
 		return false;
 	}
 };
 
 /**
- * @description 将键的值增加1
+ * @description 将键的值增加1（兼容方法，与addInt功能相同）
  * @param {String} key 键
+ * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 增加后的值
  */
-Redis.prototype.incr = async function (key) {
+Redis.prototype.incr = async function(key, seconds = 0) {
 	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
+			return null;
+		}
+		
 		// 触发前置事件
-		const beforeEventData = { key, cancel: false };
+		const beforeEventData = {
+			key,
+			seconds,
+			cancel: false
+		};
 		this.emit('incr_before', beforeEventData);
 
 		if (beforeEventData.cancel) {
@@ -2258,37 +3165,74 @@ Redis.prototype.incr = async function (key) {
 			return null;
 		}
 
-		const { key: finalKey } = beforeEventData;
+		const {
+			key: finalKey,
+			seconds: finalSeconds
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
+			const prefixedKey = this.applyPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
-			const result = await connection.incr(this.applyPrefix(finalKey));
-			this.emit('incr_after', { key: finalKey, result });
+			const result = await connection.incr(prefixedKey);
+			
+			// 如果设置了过期时间
+			if (finalSeconds > 0) {
+				if (typeof connection.expire === 'function') {
+					await connection.expire(prefixedKey, finalSeconds);
+				} else if (typeof connection.execute === 'function') {
+					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
+				}
+			}
+			
+			this.emit('incr_after', {
+				key: finalKey,
+				seconds: finalSeconds,
+				result
+			});
 			return result;
 		} catch (err) {
 			$.log.error(`[Redis] 增加整数值失败 [${finalKey}]:`, err);
-			this.emit('incr_error', { key: finalKey, error: err });
+			this.emit('incr_error', {
+				key: finalKey,
+				seconds: finalSeconds,
+				error: err
+			});
 			return null;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		$.log.error(`[Redis] 增加整数值失败 [${key}]:`, err);
-		this.emit('incr_error', { key, error: err });
+		this.emit('incr_error', {
+			key,
+			seconds,
+			error: err
+		});
 		return null;
 	}
 };
 
 /**
- * @description 将键的值减少1
+ * @description 将键的值减少1（兼容方法）
  * @param {String} key 键
+ * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 减少后的值
  */
-Redis.prototype.decr = async function (key) {
+Redis.prototype.decr = async function(key, seconds = 0) {
 	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
+			return null;
+		}
+		
 		// 触发前置事件
-		const beforeEventData = { key, cancel: false };
+		const beforeEventData = {
+			key,
+			seconds,
+			cancel: false
+		};
 		this.emit('decr_before', beforeEventData);
 
 		if (beforeEventData.cancel) {
@@ -2296,38 +3240,166 @@ Redis.prototype.decr = async function (key) {
 			return null;
 		}
 
-		const { key: finalKey } = beforeEventData;
+		const {
+			key: finalKey,
+			seconds: finalSeconds
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
+			const prefixedKey = this.applyPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
-			const result = await connection.decr(this.applyPrefix(finalKey));
-			this.emit('decr_after', { key: finalKey, result });
+			const result = await connection.decr(prefixedKey);
+			
+			// 如果设置了过期时间
+			if (finalSeconds > 0) {
+				if (typeof connection.expire === 'function') {
+					await connection.expire(prefixedKey, finalSeconds);
+				} else if (typeof connection.execute === 'function') {
+					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
+				}
+			}
+			
+			this.emit('decr_after', {
+				key: finalKey,
+				seconds: finalSeconds,
+				result
+			});
 			return result;
 		} catch (err) {
 			$.log.error(`[Redis] 减少整数值失败 [${finalKey}]:`, err);
-			this.emit('decr_error', { key: finalKey, error: err });
+			this.emit('decr_error', {
+				key: finalKey,
+				seconds: finalSeconds,
+				error: err
+			});
 			return null;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		$.log.error(`[Redis] 减少整数值失败 [${key}]:`, err);
-		this.emit('decr_error', { key, error: err });
+		this.emit('decr_error', {
+			key,
+			seconds,
+			error: err
+		});
 		return null;
 	}
 };
 
 /**
- * @description 将键的值增加指定的整数
+ * @description 将键的值增加指定的浮点数（兼容方法，与addFloat功能相同）
+ * @param {String} key 键
+ * @param {Number} increment 浮点数增量
+ * @param {Number} [seconds=0] 过期时间（秒）
+ * @return {Promise<Number>} 增加后的值
+ */
+Redis.prototype.incrbyfloat = async function(key, increment, seconds = 0) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
+			return null;
+		}
+		if (typeof increment !== 'number' || isNaN(increment)) {
+			$.log.error('[Redis] 参数错误: 增量必须是有效数字');
+			return null;
+		}
+		
+		// 触发前置事件
+		const beforeEventData = {
+			key,
+			increment,
+			seconds,
+			cancel: false
+		};
+		this.emit('incrbyfloat_before', beforeEventData);
+
+		if (beforeEventData.cancel) {
+			$.log.debug(`[Redis] incrbyfloat操作被事件处理器取消 [${key}]`);
+			return null;
+		}
+
+		const {
+			key: finalKey,
+			increment: finalIncrement,
+			seconds: finalSeconds
+		} = beforeEventData;
+
+		const connection = await this._getConnection();
+		try {
+			const prefixedKey = this.applyPrefix(finalKey);
+			// 使用正确的Redis客户端Promise API
+			const result = await connection.incrByFloat(prefixedKey, finalIncrement);
+			const parsedResult = parseFloat(result);
+			
+			// 如果设置了过期时间
+			if (finalSeconds > 0) {
+				if (typeof connection.expire === 'function') {
+					await connection.expire(prefixedKey, finalSeconds);
+				} else if (typeof connection.execute === 'function') {
+					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
+				}
+			}
+			
+			this.emit('incrbyfloat_after', {
+				key: finalKey,
+				increment: finalIncrement,
+				seconds: finalSeconds,
+				result: parsedResult
+			});
+			return parsedResult;
+		} catch (err) {
+			$.log.error(`[Redis] 增加浮点数值失败 [${finalKey}]:`, err);
+			this.emit('incrbyfloat_error', {
+				key: finalKey,
+				increment: finalIncrement,
+				seconds: finalSeconds,
+				error: err
+			});
+			return null;
+		} finally {
+			this._recycleConnection(connection);
+		}
+	} catch (err) {
+		$.log.error(`[Redis] 增加浮点数值失败 [${key}]:`, err);
+		this.emit('incrbyfloat_error', {
+			key,
+			increment,
+			seconds,
+			error: err
+		});
+		return null;
+	}
+};
+
+/**
+ * @description 将键的值增加指定的整数（兼容方法）
  * @param {String} key 键
  * @param {Number} increment 增量
+ * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 增加后的值
  */
-Redis.prototype.incrby = async function (key, increment) {
+Redis.prototype.incrby = async function(key, increment, seconds = 0) {
 	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
+			return null;
+		}
+		if (typeof increment !== 'number' || isNaN(increment) || !Number.isInteger(increment)) {
+			$.log.error('[Redis] 参数错误: 增量必须是有效整数');
+			return null;
+		}
+		
 		// 触发前置事件
-		const beforeEventData = { key, increment, cancel: false };
+		const beforeEventData = {
+			key,
+			increment,
+			seconds,
+			cancel: false
+		};
 		this.emit('incrby_before', beforeEventData);
 
 		if (beforeEventData.cancel) {
@@ -2335,38 +3407,84 @@ Redis.prototype.incrby = async function (key, increment) {
 			return null;
 		}
 
-		const { key: finalKey, increment: finalIncrement } = beforeEventData;
+		const {
+			key: finalKey,
+			increment: finalIncrement,
+			seconds: finalSeconds
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
+			const prefixedKey = this.applyPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
-			const result = await connection.incrBy(this.applyPrefix(finalKey), finalIncrement);
-			this.emit('incrby_after', { key: finalKey, increment: finalIncrement, result });
+			const result = await connection.incrBy(prefixedKey, finalIncrement);
+			
+			// 如果设置了过期时间
+			if (finalSeconds > 0) {
+				if (typeof connection.expire === 'function') {
+					await connection.expire(prefixedKey, finalSeconds);
+				} else if (typeof connection.execute === 'function') {
+					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
+				}
+			}
+			
+			this.emit('incrby_after', {
+				key: finalKey,
+				increment: finalIncrement,
+				seconds: finalSeconds,
+				result
+			});
 			return result;
 		} catch (err) {
 			$.log.error(`[Redis] 增加指定值失败 [${finalKey}]:`, err);
-			this.emit('incrby_error', { key: finalKey, increment: finalIncrement, error: err });
+			this.emit('incrby_error', {
+				key: finalKey,
+				increment: finalIncrement,
+				seconds: finalSeconds,
+				error: err
+			});
 			return null;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		$.log.error(`[Redis] 增加指定值失败 [${key}]:`, err);
-		this.emit('incrby_error', { key, increment, error: err });
+		this.emit('incrby_error', {
+			key,
+			increment,
+			seconds,
+			error: err
+		});
 		return null;
 	}
 };
 
 /**
- * @description 将键的值减少指定的整数
+ * @description 将键的值减少指定的整数（兼容方法）
  * @param {String} key 键
  * @param {Number} decrement 减量
+ * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 减少后的值
  */
-Redis.prototype.decrby = async function (key, decrement) {
+Redis.prototype.decrby = async function(key, decrement, seconds = 0) {
 	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
+			return null;
+		}
+		if (typeof decrement !== 'number' || isNaN(decrement) || !Number.isInteger(decrement)) {
+			$.log.error('[Redis] 参数错误: 减量必须是有效整数');
+			return null;
+		}
+		
 		// 触发前置事件
-		const beforeEventData = { key, decrement, cancel: false };
+		const beforeEventData = {
+			key,
+			decrement,
+			seconds,
+			cancel: false
+		};
 		this.emit('decrby_before', beforeEventData);
 
 		if (beforeEventData.cancel) {
@@ -2374,24 +3492,54 @@ Redis.prototype.decrby = async function (key, decrement) {
 			return null;
 		}
 
-		const { key: finalKey, decrement: finalDecrement } = beforeEventData;
+		const {
+			key: finalKey,
+			decrement: finalDecrement,
+			seconds: finalSeconds
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
+			const prefixedKey = this.applyPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
-			const result = await connection.decrBy(this.applyPrefix(finalKey), finalDecrement);
-			this.emit('decrby_after', { key: finalKey, decrement: finalDecrement, result });
+			const result = await connection.decrBy(prefixedKey, finalDecrement);
+			
+			// 如果设置了过期时间
+			if (finalSeconds > 0) {
+				if (typeof connection.expire === 'function') {
+					await connection.expire(prefixedKey, finalSeconds);
+				} else if (typeof connection.execute === 'function') {
+					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
+				}
+			}
+			
+			this.emit('decrby_after', {
+				key: finalKey,
+				decrement: finalDecrement,
+				seconds: finalSeconds,
+				result
+			});
 			return result;
 		} catch (err) {
 			$.log.error(`[Redis] 减少指定值失败 [${finalKey}]:`, err);
-			this.emit('decrby_error', { key: finalKey, decrement: finalDecrement, error: err });
+			this.emit('decrby_error', {
+				key: finalKey,
+				decrement: finalDecrement,
+				seconds: finalSeconds,
+				error: err
+			});
 			return null;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		$.log.error(`[Redis] 减少指定值失败 [${key}]:`, err);
-		this.emit('decrby_error', { key, decrement, error: err });
+		this.emit('decrby_error', {
+			key,
+			decrement,
+			seconds,
+			error: err
+		});
 		return null;
 	}
 };
@@ -2404,10 +3552,14 @@ Redis.prototype.decrby = async function (key, decrement) {
  * @param {String|Array} members 成员或成员数组
  * @return {Promise<Number>} 添加的成员数量
  */
-Redis.prototype.sadd = async function (key, members) {
+Redis.prototype.sadd = async function(key, members) {
 	try {
 		// 触发前置事件
-		const beforeEventData = { key, members: Array.isArray(members) ? members : [members], cancel: false };
+		const beforeEventData = {
+			key,
+			members: Array.isArray(members) ? members : [members],
+			cancel: false
+		};
 		this.emit('sadd_before', beforeEventData);
 
 		if (beforeEventData.cancel) {
@@ -2415,7 +3567,10 @@ Redis.prototype.sadd = async function (key, members) {
 			return 0;
 		}
 
-		const { key: finalKey, members: finalMembers } = beforeEventData;
+		const {
+			key: finalKey,
+			members: finalMembers
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
@@ -2423,14 +3578,22 @@ Redis.prototype.sadd = async function (key, members) {
 			const result = await connection.sAdd(prefixedKey, finalMembers);
 
 			// 触发后置事件
-			this.emit('sadd_after', { key: finalKey, members: finalMembers, result });
+			this.emit('sadd_after', {
+				key: finalKey,
+				members: finalMembers,
+				result
+			});
 			return result;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		$.log.error(`[Redis] 添加集合成员失败 [${key}]:`, err);
-		this.emit('sadd_error', { key, members, error: err });
+		this.emit('sadd_error', {
+			key,
+			members,
+			error: err
+		});
 		return 0;
 	}
 };
@@ -2441,10 +3604,14 @@ 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 = { key, members: Array.isArray(members) ? members : [members], cancel: false };
+		const beforeEventData = {
+			key,
+			members: Array.isArray(members) ? members : [members],
+			cancel: false
+		};
 		this.emit('srem_before', beforeEventData);
 
 		if (beforeEventData.cancel) {
@@ -2452,7 +3619,10 @@ Redis.prototype.srem = async function (key, members) {
 			return 0;
 		}
 
-		const { key: finalKey, members: finalMembers } = beforeEventData;
+		const {
+			key: finalKey,
+			members: finalMembers
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
@@ -2460,14 +3630,22 @@ Redis.prototype.srem = async function (key, members) {
 			const result = await connection.sRem(prefixedKey, finalMembers);
 
 			// 触发后置事件
-			this.emit('srem_after', { key: finalKey, members: finalMembers, result });
+			this.emit('srem_after', {
+				key: finalKey,
+				members: finalMembers,
+				result
+			});
 			return result;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		$.log.error(`[Redis] 移除集合成员失败 [${key}]:`, err);
-		this.emit('srem_error', { key, members, error: err });
+		this.emit('srem_error', {
+			key,
+			members,
+			error: err
+		});
 		return 0;
 	}
 };
@@ -2478,17 +3656,43 @@ 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;
+		}
+		if (member === undefined || member === null) {
+			$.log.error('[Redis] sismember参数错误: member cannot be undefined or null');
+			return false;
+		}
+
+		this.emit('sismember_before', {
+			key,
+			member
+		});
 		const connection = await this._getConnection();
 		try {
 			const prefixedKey = this.applyPrefix(key);
-			const result = await connection.sIsMember(prefixedKey, member);
+			// 将成员转换为字符串，与其他模块行为一致
+			const memberStr = String(member);
+			const result = await connection.sIsMember(prefixedKey, memberStr);
+			this.emit('sismember_after', {
+				key,
+				member,
+				result
+			});
 			return result;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
+		this.emit('sismember_error', {
+			key,
+			member,
+			error: err
+		});
 		$.log.error(`[Redis] 检查集合成员失败 [${key}:${member}]:`, err);
 		return false;
 	}
@@ -2499,20 +3703,26 @@ 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 result = await connection.sMembers(prefixedKey);
-			this.emit('smembers_after', { key, result });
+			this.emit('smembers_after', {
+				key,
+				result
+			});
 			return result || [];
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		$.log.error(`[Redis] 获取集合所有成员失败 [${key}]:`, err);
-		this.emit('smembers_error', { key, error: err });
+		this.emit('smembers_error', {
+			key,
+			error: err
+		});
 		return [];
 	}
 };
@@ -2522,7 +3732,7 @@ 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 {
@@ -2543,7 +3753,7 @@ 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 {
@@ -2565,7 +3775,7 @@ 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 {
@@ -2587,7 +3797,7 @@ 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 {
@@ -2613,10 +3823,15 @@ 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 = { key, score, member, cancel: false };
+		const beforeEventData = {
+			key,
+			score,
+			member,
+			cancel: false
+		};
 		this.emit('zadd_before', beforeEventData);
 
 		if (beforeEventData.cancel) {
@@ -2624,22 +3839,39 @@ Redis.prototype.zadd = async function (key, score, member) {
 			return false;
 		}
 
-		const { key: finalKey, score: finalScore, member: finalMember } = beforeEventData;
+		const {
+			key: finalKey,
+			score: finalScore,
+			member: finalMember
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
 			const prefixedKey = this.applyPrefix(finalKey);
-			const result = await connection.zAdd(prefixedKey, { score: finalScore, value: finalMember });
+			const result = await connection.zAdd(prefixedKey, {
+				score: finalScore,
+				value: finalMember
+			});
 
 			// 触发后置事件
-			this.emit('zadd_after', { key: finalKey, score: finalScore, member: finalMember, success: result === 1 });
+			this.emit('zadd_after', {
+				key: finalKey,
+				score: finalScore,
+				member: finalMember,
+				success: result === 1
+			});
 			return result === 1;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		$.log.error(`[Redis] 添加有序集合成员失败 [${key}]:`, err);
-		this.emit('zadd_error', { key, score, member, error: err });
+		this.emit('zadd_error', {
+			key,
+			score,
+			member,
+			error: err
+		});
 		return false;
 	}
 };
@@ -2650,10 +3882,14 @@ 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 = { key, members: Array.isArray(members) ? members : [members], cancel: false };
+		const beforeEventData = {
+			key,
+			members: Array.isArray(members) ? members : [members],
+			cancel: false
+		};
 		this.emit('zrem_before', beforeEventData);
 
 		if (beforeEventData.cancel) {
@@ -2661,7 +3897,10 @@ Redis.prototype.zrem = async function (key, members) {
 			return 0;
 		}
 
-		const { key: finalKey, members: finalMembers } = beforeEventData;
+		const {
+			key: finalKey,
+			members: finalMembers
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
@@ -2669,18 +3908,30 @@ Redis.prototype.zrem = async function (key, members) {
 			const result = await connection.zRem(this.applyPrefix(finalKey), ...finalMembers);
 
 			// 触发后置事件
-			this.emit('zrem_after', { key: finalKey, members: finalMembers, result });
+			this.emit('zrem_after', {
+				key: finalKey,
+				members: finalMembers,
+				result
+			});
 			return result;
 		} catch (err) {
 			$.log.error(`[Redis] 移除有序集合成员失败 [${finalKey}]:`, err);
-			this.emit('zrem_error', { key: finalKey, members: finalMembers, error: err });
+			this.emit('zrem_error', {
+				key: finalKey,
+				members: finalMembers,
+				error: err
+			});
 			return 0;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		$.log.error(`[Redis] 移除有序集合成员失败 [${key}]:`, err);
-		this.emit('zrem_error', { key, members, error: err });
+		this.emit('zrem_error', {
+			key,
+			members,
+			error: err
+		});
 		return 0;
 	}
 };
@@ -2691,7 +3942,7 @@ 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 {
@@ -2713,7 +3964,7 @@ 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 {
@@ -2737,32 +3988,38 @@ 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);
-			
+
 			if (withScores) {
 				// 对于需要分数的情况，使用更可靠的方法
 				try {
 					// 直接获取所有成员的分数
 					const members = await connection.zRange(prefixedKey, start, stop);
 					const results = [];
-					
+
 					// 为每个成员单独获取分数，确保准确性
 					for (const member of members) {
 						try {
 							let score = await connection.zScore(prefixedKey, member);
 							score = score ? parseFloat(score) : 0;
-							results.push({ member, score });
+							results.push({
+								member,
+								score
+							});
 						} catch (scoreErr) {
 							// 如果获取分数失败，设置默认值0
-							results.push({ member, score: 0 });
+							results.push({
+								member,
+								score: 0
+							});
 							$.log.warn(`[Redis] 获取成员 ${member} 分数失败:`, scoreErr);
 						}
 					}
-					
+
 					return results;
 				} catch (err) {
 					$.log.error(`[Redis] 使用备用方法获取有序集合范围失败 [${prefixedKey}]:`, err);
@@ -2788,7 +4045,7 @@ 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 {
@@ -2808,16 +4065,37 @@ Redis.prototype.zcard = async function (key) {
 };
 
 /**
- * @description 增加有序集合中成员的分数
+ * @description 增加有序集合中成员的分数（兼容方法）
  * @param {String} key 键
  * @param {Number} increment 增量
  * @param {String} member 成员
+ * @param {Number} [seconds=0] 过期时间（秒）
  * @return {Promise<Number>} 增加后的分数
  */
-Redis.prototype.zincrby = async function (key, increment, member) {
+Redis.prototype.zincrby = async function(key, increment, member, seconds = 0) {
 	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			$.log.error('[Redis] 参数错误: 键必须是非空字符串');
+			return null;
+		}
+		if (typeof increment !== 'number' || isNaN(increment)) {
+			$.log.error('[Redis] 参数错误: 增量必须是有效数字');
+			return null;
+		}
+		if (!member || typeof member !== 'string') {
+			$.log.error('[Redis] 参数错误: 成员必须是非空字符串');
+			return null;
+		}
+		
 		// 触发前置事件
-		const beforeEventData = { key, increment, member, cancel: false };
+		const beforeEventData = {
+			key,
+			increment,
+			member,
+			seconds,
+			cancel: false
+		};
 		this.emit('zincrby_before', beforeEventData);
 
 		if (beforeEventData.cancel) {
@@ -2825,32 +4103,65 @@ Redis.prototype.zincrby = async function (key, increment, member) {
 			return null;
 		}
 
-		const { key: finalKey, increment: finalIncrement, member: finalMember } = beforeEventData;
+		const {
+			key: finalKey,
+			increment: finalIncrement,
+			member: finalMember,
+			seconds: finalSeconds
+		} = beforeEventData;
 
 		const connection = await this._getConnection();
 		try {
+			const prefixedKey = this.applyPrefix(finalKey);
 			// 使用正确的Redis客户端Promise API
-			const result = await connection.zIncrBy(this.applyPrefix(finalKey), finalIncrement, finalMember);
-
+			const result = await connection.zIncrBy(prefixedKey, finalIncrement, finalMember);
+			
+			// 如果设置了过期时间
+			if (finalSeconds > 0) {
+				if (typeof connection.expire === 'function') {
+					await connection.expire(prefixedKey, finalSeconds);
+				} else if (typeof connection.execute === 'function') {
+					await connection.execute('EXPIRE', [prefixedKey, finalSeconds]);
+				}
+			}
+			
 			// 触发后置事件
-			this.emit('zincrby_after', { key: finalKey, increment: finalIncrement, member: finalMember, result: parseFloat(result) });
+			this.emit('zincrby_after', {
+				key: finalKey,
+				increment: finalIncrement,
+				member: finalMember,
+				seconds: finalSeconds,
+				result: parseFloat(result)
+			});
 			return parseFloat(result);
 		} catch (err) {
 			$.log.error(`[Redis] 增加有序集合成员分数失败 [${finalKey}]:`, err);
-			this.emit('zincrby_error', { key: finalKey, increment: finalIncrement, member: finalMember, error: err });
+			this.emit('zincrby_error', {
+				key: finalKey,
+				increment: finalIncrement,
+				member: finalMember,
+				seconds: finalSeconds,
+				error: err
+			});
 			return null;
 		} finally {
 			this._recycleConnection(connection);
 		}
 	} catch (err) {
 		$.log.error(`[Redis] 增加有序集合成员分数失败 [${key}]:`, err);
-		this.emit('zincrby_error', { key, increment, member, error: err });
+		this.emit('zincrby_error', {
+			key,
+			increment,
+			member,
+			seconds,
+			error: err
+		});
 		return null;
 	}
 };
 
 // 创建真实Redis连接的方法
-Redis.prototype._createConnection = function () {
+Redis.prototype._createConnection = function() {
 	return new Promise((resolve, reject) => {
 		try {
 			const cg = this.config;
@@ -2914,7 +4225,7 @@ function redis_admin(scope, config) {
 	}
 	var obj = $.pool.redis[scope];
 	if (!obj) {
-		$.pool.redis[scope] = new Redis(scope, config);
+		$.pool.redis[scope] = new Redis(config);
 		obj = $.pool.redis[scope];
 	}
 	return obj;
@@ -2923,4 +4234,4 @@ function redis_admin(scope, config) {
 /**
  * @module 导出Redis管理器
  */
-exports.redis_admin = redis_admin;
+exports.redis_admin = redis_admin;