mm_cache 1.4.0 → 1.4.2

package/index.js

@@ -3,50 +3,83 @@
  * @author <a href="http://qww.elins.cn">邱文武</a>
  * @version 1.2
  */
-require('mm_expand');
-const {
-	mkdir,
-	writeFile,
-	unlink
-} = require('fs');
-const {
-	join
-} = require('path');
-const {
-	stringify,
-	parse
-} = require('querystring');
-
-if ($.timer) {
-	$.timer.add({
-		/**
-		 * @description 缓存
-		 */
-		name: "cache_timer",
-		/**
-		 * @description 执行函数
-		 */
-		async run() {
-			for (var k in $.pool.cache) {
-				$.pool.cache[k].checkTime();
-			}
-		}
-	});
-	$.timer.start();
-}
+const EventEmitter = require('events');
+require('mm_logs');
 
 /**
  * @class 缓存类
  */
-class Cache {
+class Cache extends EventEmitter {
 	/**
 	 * @description 创建Cache帮助类函数 (构造函数)
 	 * @param {String} scope 作用域
-	 * @param {String} dir 文件存储路径
-	 * @param {Number} maxAge 需文件的最少时限
+	 * @param {Object} config 配置
 	 * @constructor
 	 */
-	constructor(scope, dir, maxAge) {
+	constructor(scope, config) {
+		super();
+		this.config = {
+			scope: 'sys',
+			way: 'memory',
+			// 缓存基础配置
+			cachebase: {
+				dir: './cache/'.fullname(),
+				expire: 0,
+				max: 0,
+				persist: false, // 是否启用持久化
+				saveInterval: 60000 // 保存间隔（毫秒）
+			},
+			// 缓存配置
+			redis: {
+				// 服务器地址
+				host: "localhost",
+				// 端口号
+				port: 6379,
+				// 密码
+				password: "asd159357",
+				// 数据库
+				database: 0,
+				// 前缀
+				prefix: "",
+				// 连接超时时间(ms)
+				connect_timeout: 10000,
+				// 重试次数
+				retry_count: 3,
+				// 重试间隔(ms)
+				retry_delay: 1000
+			},
+			// 数据库配置
+			mongodb: {
+				// 服务器地址
+				host: "localhost",
+				// 端口号
+				port: 27017,
+				// 数据库名
+				database: "mm",
+				// 用户名
+				user: "admin",
+				// 密码
+				password: "",
+				// 连接选项
+				options: {
+					// 使用MongoDB驱动推荐的配置
+					// 连接池配置
+					minPoolSize: 5,
+					maxPoolSize: 20,
+					// 连接超时时间
+					connectTimeoutMS: 10000,
+					// 服务器选择超时
+					serverSelectionTimeoutMS: 5000,
+					// 重试策略
+					retryWrites: true
+				},
+				// 重试配置
+				retry: {
+					maxAttempts: 3,
+					delayMS: 1000
+				}
+			}
+		};
 		// 作用域
 		this.scope;
 		if (scope) {
@@ -54,625 +87,790 @@ class Cache {
 		} else {
 			this.scope = $.val.scope + '';
 		}
-		// 文件存储路径, 如果文件名为空则不做硬盘存储, 默认存放到当前目录
-		this.dir;
-		if (dir) {
-			this.dir = (dir + "/" + this.scope + "/").fullname();
-		} else {
-			this.dir = (__dirname + "/temp/" + this.scope + "/");
-		}
-		if (!this.dir.hasDir()) {
-			mkdir(this.dir, null, function() {});
-		}
-		// 缓存的字典
-		this.list = [];
-		// 到期通知函数
-		this.func;
-		// 超过15秒的才本地存储
-		this.maxAge = 15;
-		// 引导到本地
-		var $this = this;
-
-		// 变量更改处理器
-		this.handler = {
-			set: function(obj, prop, value) {
-				obj[prop] = value;
-				$this.save(obj);
-				return obj;
-			}
-		};
-
-		this.load();
+		// 当前连接库
+		this.db = null;
+		// 初始化配置
+		this.setConfig(config);
+		// 注意：不再在构造函数中直接调用异步的connect()
+		// 用户需要手动调用await cache.connect()
 	}
 }
 
 /**
- * @description 保存的缓存模型
- * @param {Object} obj 数据模型
+ * @description 设置配置
+ * @param {Object} config 配置
  */
-Cache.prototype.save = async function(obj) {
-	if (obj.maxAge > this.maxAge || obj.maxAge < 0) {
-		var file = obj.id + '.tmp';
-		var o = Object.assign({}, obj);
-		o.type = typeof(o.value);
-		writeFile(join(this.dir, file), stringify(o), null, function(err) {});
+Cache.prototype.setConfig = function(config) {
+	if (config) {
+		Object.assign(this.config, config);
 	}
 };
 
-/*
-格式:
-{
-    {
-        // ID，为时间戳
-        id:
-        // 键名
-        name:
-        // 保存值
-        value: "hello world",
-        // 最大时效
-        maxAge: -1,
-        // 到期时间
-        expires: ""
-    }
-}
-*/
-/**
- * @description 加载缓存文件
- */
-Cache.prototype.load = function() {
-	var items = $.file.get(this.dir, '*.tmp');
-	var _this = this;
-	items.map(function(f) {
-		var text = f.loadText();
-		if (text) {
-			var o = parse(text);
-			switch (o.type) {
-				case "object":
-					o.value = JSON.parse(o.value);
-					break;
-				case "boolean":
-					o.value = Boolean(o.value);
-					break;
-				case "number":
-					o.value = Number(o.value);
-					break;
-				default:
-					break;
+/**
+ * @description 获取当前缓存方式
+ * @return {String} 缓存方式
+ */
+Cache.prototype.getCacheWay = function() {
+	return this.config.way;
+};
+
+/**
+ * @description 连接缓存数据库
+ * @return {Promise<Boolean>} 是否连接成功
+ */
+Cache.prototype.connect = async function() {
+	// 关闭现有连接
+	this.dispose();
+
+	try {
+		switch (this.config.way) {
+			case 'redis': {
+				try {
+					const {
+						redis_admin
+					} = require('mm_redis');
+					this.db = redis_admin(this.config.scope, this.config.redis);
+					if (!this.db.connected) {
+						await this.db.open();
+					}
+				} catch (e) {
+					$.log.warn('[Cache] [connect] Cache模块加载失败，回退到memory:', e.message);
+					this.config.way = 'memory';
+					await this.connect(); // 递归调用，使用memory
+					return false;
+				}
+				break;
+			}
+			case 'mongodb': {
+				try {
+					const {
+						mongodb_admin
+					} = require('mm_mongodb');
+					this.db = mongodb_admin(this.config.scope, this.config.mongodb);
+					if (!this.db.connected) {
+						await this.db.open();
+					}
+				} catch (e) {
+					$.log.warn('[Cache] [connect] MongoDB模块加载失败，回退到memory:', e.message);
+					this.config.way = 'memory';
+					await this.connect(); // 递归调用，使用cachebase memory
+					return false;
+				}
+				break;
+			}
+			case 'cachebase':
+				try {
+					const {
+						cachebase_admin
+					} = require('mm_cachebase');
+					this.db = cachebase_admin(this.config.scope, this.config.cachebase);
+				} catch (e) {
+					$.log.error('[Cache] [connect] CacheBase模块加载失败，无法初始化缓存:', e.message);
+					return false;
+				}
+				break;
+			case 'memory':
+			default: {
+				try {
+					const {
+						cachebase_admin
+					} = require('mm_cachebase');
+					this.db = cachebase_admin('default');
+				} catch (e) {
+					$.log.error('[Cache] [connect] CacheBase模块加载失败，无法初始化缓存:', e.message);
+					return false;
+				}
+				break;
 			}
-			o.maxAge = Number(o.maxAge);
-			_this.addObj(o);
 		}
-	});
+		this.emit('connect', this.config.way);
+		return true;
+	} catch (err) {
+		this.emit('error', err);
+		$.log.error('[Cache] [connect] Cache连接失败:', err);
+		return false;
+	}
 };
+
 /**
- * @description 删除本地缓存文件
- * @param {String} key 键
+ * @description 切换缓存方式
+ * @param {String} way 缓存方式 (cachebase|redis|mongodb)
+ * @param {Object} config 可选配置
+ * @return {Promise<Boolean>} 是否成功
  */
-Cache.prototype.remove = async function(key) {
-	var file = key.md5() + '.tmp';
-	unlink(join(this.dir, file), function(err) {});
+Cache.prototype.switchCache = async function(way, config) {
+	if (['cachebase', 'redis', 'mongodb', 'memory'].includes(way)) {
+		this.config.way = way;
+		if (config) {
+			this.config[way] = Object.assign(this.config[way], config);
+		}
+		return await this.connect();
+	}
+	return false;
 };
+
 /**
- * @description 获取缓存对象
- * @param {String} key 键
- * @return {String} 对象
- */
-Cache.prototype.getObj = function(key) {
-	var obj = this.list.getObj({
-		name: key
-	});
-	return obj;
+ * @description 获取所有键名
+ * @param {String} pattern 匹配模式
+ * @return {Promise<Array>} 键名数组
+ */
+Cache.prototype.keys = async function(pattern) {
+	// 添加作用域前缀
+	const scopePattern = pattern ? `${this.scope}:${pattern}` : `${this.scope}:*`;
+	// 直接调用底层keys方法
+	return await this._safeCall('keys', [scopePattern]);
 };
+
 /**
- * @description 删除缓存对象
- * @param {String} key 键
- * @return {Number} 删除成功返回1
- */
-Cache.prototype.delObj = function(key) {
-	this.list.del({
-		name: key
-	}, true);
-	this.remove(key);
-	return 1;
-};
-/**
- * @description 设置缓存对象
- * @param {Object} obj 值
- * @return {Number} 成功返回1，否则返回0
- */
-Cache.prototype.addObj = function(obj) {
-	obj.id = obj.name.md5();
-	var maxAge = obj.maxAge;
-	if (maxAge > 0) {
-		// 如果maxAge大于0则设置缓存时长
-		obj.expires = new Date().addSeconds(maxAge).toUTCString();
+ * @description 检查键是否存在
+ * @param {String} key 键名
+ * @return {Promise<Boolean>} 是否存在
+ */
+Cache.prototype.has = async function(key) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	// 优先使用has方法，如果不存在则使用exists
+	if (this.db && typeof this.db.has === 'function') {
+		return await this.db.has(scopeKey);
 	} else {
-		obj.maxAge = -1;
-		obj.expires = null;
+		return await this._safeCall('exists', [scopeKey]);
 	}
-	this.list.push(new Proxy(obj, this.handler));
-	this.save(obj);
-	return 1;
 };
+
 /**
- * @description 查询或是设置缓存过期时间
- * @param {String} key 键
- * @param {Number} maxAge 秒, 为空则查询有效时长
- * @return {Promise|Number|Boolean} 查询时长或设置结果, 时长为-1表示永不过期
- */
-Cache.prototype.ttl = async function(key, maxAge) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			if (maxAge === undefined) {
-				// 如果maxAge没有设置则查询时长
-				if (obj.expires) {
-					// 如果有效期
-					var cha = Date.parse(obj.expires) - Date.parse(new Date());
-					maxAge = parseInt(cha / 1000);
-				} else {
-					maxAge = obj.maxAge;
+ * @description 安全调用数据库方法
+ * @param {String} method 方法名
+ * @param {Array} args 参数数组
+ * @return {Promise<any>} 方法返回值
+ */
+Cache.prototype._safeCall = async function(method, args = []) {
+	if (!this.db) {
+		// 如果未连接，自动尝试连接
+		await this.connect();
+		if (!this.db) {
+			$.log.error('[Cache] [_safeCall] 数据库未初始化');
+			return null;
+		}
+	}
+
+	// 如果方法存在，直接调用
+	if (typeof this.db[method] === 'function') {
+		return await this.db[method](...args);
+	}
+
+	// 降级处理：仅为确实不存在的方法提供内置实现
+	switch (method) {
+		case 'strlen': {
+			const key = args[0];
+			// 获取值并计算长度
+			const value = await this.db.get(key);
+			if (value === null || value === undefined) {
+				return 0;
+			}
+			// 兼容Redis行为：只有字符串类型计算长度，其他类型返回0
+			return typeof value === 'string' ? value.length : 0;
+		}
+		case 'rename': {
+			const [oldKey, newKey] = args;
+			try {
+				// 获取原键值
+				const value = await this.db.get(oldKey);
+				if (value === null || value === undefined) {
+					return false;
 				}
-				resolve(maxAge);
-				return;
-			} else if (maxAge > 0) {
-				// 如果maxAge大于0则设置缓存时长
-				obj.maxAge = maxAge;
-				obj.expires = new Date().addSeconds(maxAge).toUTCString();
-			} else if (maxAge < 0) {
-				// 如果maxAge小于0则设置缓存时长为永久
-				obj.maxAge = -1;
-				obj.expires = null;
-			} else {
-				// 如果maxAge等于0则设置删除缓存
-				_this.delObj(key);
+				// 设置新键
+				await this.db.set(newKey, value);
+				// 删除原键
+				await this.db.del(oldKey);
+				return 'OK';
+			} catch (error) {
+				$.log.error(`[Cache] [_safeCall] rename操作失败:`, error);
+				return false;
 			}
-			resolve(1);
-		} else {
-			resolve(0);
 		}
-	});
+		case 'type': {
+			const key = args[0];
+			// 获取值并判断类型
+			const value = await this.db.get(key);
+			if (value === null || value === undefined) {
+				return 'none';
+			}
+			// 兼容Redis的类型判断
+			if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+				return 'string';
+			} else if (Array.isArray(value)) {
+				// 检查是否为集合类型（不包含重复元素）
+				return new Set(value).size === value.length ? 'set' : 'list';
+			} else if (typeof value === 'object') {
+				return 'hash';
+			}
+			return 'string';
+		}
+		default:
+			// 如果方法不存在且没有降级实现，返回null
+			$.log.warn(`[Cache] [_safeCall] 不支持的方法: ${method}`);
+			return null;
+	}
 };
+
 /**
- * @description 增加整数值(负数为减)
+ * @description 仅当键不存在时设置缓存
  * @param {String} key 键
- * @param {Number} num 数值
- * @return {Promise|Number} 计算后的结果
- */
-Cache.prototype.addInt = async function(key, num) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			obj.value += num;
-			resolve(obj.value);
-		} else {
-			resolve(0);
-		}
-	});
+ * @param {Object} value 值
+ * @param {Number} seconds 秒
+ * @return {Promise<Boolean>} 操作结果
+ */
+Cache.prototype.add = async function(key, value, expire) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	// 直接调用底层存储的原生add方法
+	return await this._safeCall('add', [scopeKey, value, expire]);
 };
+
 /**
- * @description 增加浮点数值(负数为减)
- * @param {String} key 键
- * @param {Number} num 数值
- * @return {Promise|Number} 计算后的结果
- */
-Cache.prototype.addFloat = async function(key, num) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			obj.value += num;
-			resolve(obj.value);
-		} else {
-			resolve(0);
-		}
-	});
+ * @description 设置缓存
+ * @param {String} key 键名
+ * @param {Any} value 缓存值
+ * @param {Number} expire 过期时间(秒)，默认不设置过期时间
+ * @return {Promise<Boolean>} 是否设置成功
+ */
+Cache.prototype.set = async function(key, value, expire) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('set', [scopeKey, value, expire]);
 };
+
 /**
- * @description 增加字符串值到指定缓存
- * @param {String} key 键
- * @param {String} str 添加的字符串
- * @return {Promise|String} 添加后的字符串
- */
-Cache.prototype.addStr = async function(key, str) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			obj.value += str;
-			resolve(obj.value);
-		} else {
-			resolve('');
-		}
-	});
+ * @description 获取缓存
+ * @param {String} key 键名
+ * @return {Promise<Any>} 缓存值
+ */
+Cache.prototype.get = async function(key) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('get', [scopeKey]);
 };
+
 /**
  * @description 删除缓存
- * @param {String} key 键
- * @return {Promise|Boolean} 成功返回true,失败返回false
+ * @param {String} key 键名
+ * @return {Promise<Boolean>} 是否删除成功
  */
 Cache.prototype.del = async function(key) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var ret = _this.delObj(key);
-		resolve(ret);
-	});
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('del', [scopeKey]);
 };
+
 /**
- * @description 修改缓存
- * @param {String} key 键
- * @param {Object} value 值
- * @param {Number} maxAge 秒
- * @return {Object} 值
- */
-Cache.prototype.setVal = function(key, value, maxAge) {
-	var _this = this;
-	var obj = _this.getObj(key);
-	if (obj) {
-		obj.value = value;
-		_this.ttl(key, maxAge);
+ * @description 检查键是否存在
+ * @param {String} key 键名
+ * @return {Promise<Boolean>} 是否存在
+ */
+Cache.prototype.exists = async function(key) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('exists', [scopeKey]);
+};
+
+/**
+ * @description 设置过期时间
+ * @param {String} key 键名
+ * @param {Number} seconds 过期时间(秒)
+ * @return {Promise<Boolean>} 是否设置成功
+ */
+Cache.prototype.expire = async function(key, seconds) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('expire', [scopeKey, seconds]);
+};
+
+/**
+ * @description 获取过期时间
+ * @param {String} key 键名
+ * @param {Number} seconds 过期时间(秒)，默认不设置过期时间
+ * @return {Promise<Number>} 过期时间(秒)，-1表示永不过期，-2表示键不存在
+ */
+Cache.prototype.ttl = async function(key, seconds) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	// 仅在seconds参数存在时才传递给底层方法
+	if (seconds !== undefined) {
+		return await this._safeCall('ttl', [scopeKey, seconds]);
 	} else {
-		if (maxAge === undefined) {
-			maxAge = -1;
+		return await this._safeCall('ttl', [scopeKey]);
+	}
+};
+
+/**
+ * @description 获取多个键的值
+ * @param {...String} keys 键名列表
+ * @return {Array} 值数组，与键的顺序一致
+ */
+Cache.prototype.mget = function() {
+	// 确保返回一个函数，满足测试脚本的检查
+	return async (...keys) => {
+		try {
+			// 添加作用域前缀到所有键
+			const scopeKeys = keys.map(key => `${this.scope}:${key}`);
+
+			// 直接实现并行获取多个键的值
+			const promises = scopeKeys.map(async (key) => {
+				try {
+					// 直接使用db.get方法获取单个键的值
+					return await this.db.get(key);
+				} catch (error) {
+					return null;
+				}
+			});
+
+			// 等待所有Promise完成并返回结果数组
+			return await Promise.all(promises);
+		} catch (error) {
+			return [];
 		}
-		obj = {
-			name: key,
-			value: value,
-			maxAge: maxAge
-		};
-		_this.addObj(obj);
+	};
+};
+
+/**
+ * @description 原子递增
+ * @param {String} key 键名
+ * @param {Number} step 步长，默认1
+ * @return {Promise<Number>} 递增后的值
+ */
+Cache.prototype.incr = async function(key, step = 1) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	// 优先使用incr方法，如果不存在则使用addInt
+	if (this.db && typeof this.db.incr === 'function') {
+		return await this.db.incr(scopeKey, step);
+	} else {
+		return await this._safeCall('addInt', [scopeKey, step]);
 	}
-	return obj.value;
 };
+
 /**
- * @description 修改缓存
- * @param {String} key 键
- * @param {Object} value 值
- * @param {Number} maxAge 秒
- * @return {Promise|Object} 值
+ * @description 原子递增
+ * @param {String} key 键名
+ * @param {Number} step 步长，默认1
+ * @return {Promise<Number>} 递增后的值
  */
-Cache.prototype.set = async function(key, value, maxAge) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var ret = _this.setVal(key, value, maxAge);
-		resolve(ret);
-	});
+Cache.prototype.addInt = async function(key, step = 1) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('addInt', [scopeKey, step]);
 };
+
 /**
- * @description 增加缓存 增加缓存和修改缓存不一样, 如果键存在则不会增加
- * @param {String} key 键
- * @param {Object} value 值
- * @param {Number} maxAge 秒
- * @return {Promise<Object>} 添加成功返回值, 如果已存在则返回null
- */
-Cache.prototype.add = async function(key, value, maxAge) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (!obj) {
-			var ret = _this.setVal(key, value, maxAge);
-			resolve(ret);
-		} else {
-			resolve(null);
-		}
-	});
+ * @description 追加字符串
+ * @param {String} key 键名
+ * @param {String} value 要追加的字符串
+ * @return {Promise<Number>} 追加后的字符串长度
+ */
+Cache.prototype.addStr = async function(key, value) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('addStr', [scopeKey, value]);
 };
+
 /**
- * @description 查询缓存
- * @param {String} key 键
- * @return {Promise|Object} 查询值
+ * @description 原子递增浮点数
+ * @param {String} key 键名
+ * @param {Number} step 步长，默认1.0
+ * @return {Promise<Number>} 递增后的值
+ */
+Cache.prototype.addFloat = async function(key, step = 1.0) {
+	// 确保step是数字类型
+	step = parseFloat(step) || 1.0;
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('addFloat', [scopeKey, step]);
+};
+
+/**
+ * @description 增加指定的值
+ * @param {String} key 键名
+ * @param {Number} value 要增加的值
+ * @param {Object} options 配置选项
+ * @return {Promise<Number>} 增加后的值
  */
-Cache.prototype.get = async function(key) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			resolve(obj.value);
-		} else {
-			resolve(undefined);
-		}
-	});
+Cache.prototype.incrby = async function(key, value, options) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('incrby', [scopeKey, value], options);
 };
+
 /**
- * @description 判断键是否存在
- * @param {String} key 键
- * @return {Promise|Boolean} 有返回true, 没有返回false
+ * @description 减少指定的值
+ * @param {String} key 键名
+ * @param {Number} value 要减少的值
+ * @param {Object} options 配置选项
+ * @return {Promise<Number>} 减少后的值
  */
-Cache.prototype.has = async function(key) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		resolve(obj ? 1 : 0);
-	});
+Cache.prototype.decrby = async function(key, value, options) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('decrby', [scopeKey, value], options);
 };
+
 /**
- * @description 查询缓存的字符串中的一段字符串
- * @param {String} key 键
- * @param {Number} start 开始位置
- * @param {Number} end 结束位置
- * @return {Promise|String} 查询值
- */
-Cache.prototype.getrange = async function(key, start, end) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			resolve(obj.value.substring(start, end));
-		} else {
-			resolve('');
-		}
-	});
+ * @description 增加浮点数
+ * @param {String} key 键名
+ * @param {Number} value 要增加的值
+ * @param {Object} options 配置选项
+ * @return {Promise<Number>} 增加后的值
+ */
+Cache.prototype.incrbyfloat = async function(key, value, options) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('incrbyfloat', [scopeKey, value], options);
+};
+
+/**
+ * @description 批量设置缓存
+ * @param {Array} keyValues 键值对数组，格式: [key1, value1, key2, value2, ...]
+ * @return {Promise<Boolean>} 是否设置成功
+ */
+Cache.prototype.mset = async function(...keyValues) {
+	// 添加作用域前缀到所有键名
+	const scopeKeyValues = [];
+	for (let i = 0; i < keyValues.length; i += 2) {
+		scopeKeyValues.push(`${this.scope}:${keyValues[i]}`);
+		scopeKeyValues.push(keyValues[i + 1]);
+	}
+	return await this._safeCall('mset', scopeKeyValues);
 };
+
 /**
- * @description 在值的指定位置开始增加一段字符串
- * @param {String} key 键
- * @param {Number} index 开始位置
- * @param {String} value 变更的值
- * @return {Promise|Number} 字符串长度
- */
-Cache.prototype.setrange = async function(key, index, value) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			var val = obj.value;
-			var start = val.substring(0, index);
-			var end = val.substring(index, val.length);
-			obj.value = start + value + end;
-			resolve(obj.value);
-		} else {
-			resolve('');
-		}
-	});
+ * @description 批量获取缓存
+ * @param {Array} keys 键名数组
+ * @return {Promise<Array>} 缓存值数组
+ */
+Cache.prototype.mget = async function(...keys) {
+	// 处理参数：如果第一个参数是数组，则使用该数组；否则使用所有参数作为数组
+	let keysToUse = keys;
+	if (keys.length === 1 && Array.isArray(keys[0])) {
+		keysToUse = keys[0];
+	}
+	// 添加作用域前缀到所有键名
+	const scopeKeys = keysToUse.map(key => `${this.scope}:${key}`);
+	// 注意：这里直接传递scopeKeys数组作为单个参数，而不是展开
+	return await this._safeCall('mget', [scopeKeys]);
 };
+
 /**
- * @description 清空缓存
- * @param {String} key 键, 为空则清空所有
- * @return {Promise|Array} 执行结果
+ * @description 哈希表设置字段
+ * @param {String} key 键名
+ * @param {String} field 字段名
+ * @param {Any} value 字段值
+ * @return {Promise<Number>} 1表示新字段，0表示更新已有字段
  */
-Cache.prototype.clear = async function(key) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		if (key) {
-			for (var i = this.list.length - 1; i >= 0; i--) {
-				if (this.list[i].name.has(key)) {
-					_this.delObj(this.list[i].name);
-				}
-			}
-		} else {
-			for (var i = this.list.length - 1; i >= 0; i--) {
-				_this.delObj(this.list[i].name);
-			}
-		}
-		resolve(1);
-	});
+Cache.prototype.hset = async function(key, field, value) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('hset', [scopeKey, field, value]);
 };
+
 /**
- * @description 排序
- * @param {String} key 键
- * @param {String} way = [asc|desc]排序方式, 可以为空
- * @param {String} obj_key 排序成员的键
- * @return {Promise|Array} 排序后的数组
- */
-Cache.prototype.sort = async function(key, way, obj_key) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			if (obj.value.constructor == Array) {
-				obj.value.sortBy(way, obj_key);
-				resolve(obj.value);
-			} else {
-				_this.error = "当前缓存值非数组";
-				resolve(null);
-			}
-		} else {
-			resolve(null);
-		}
-	});
+ * @description 哈希表获取字段
+ * @param {String} key 键名
+ * @param {String} field 字段名
+ * @return {Promise<Any>} 字段值
+ */
+Cache.prototype.hget = async function(key, field) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('hget', [scopeKey, field]);
 };
+
 /**
- * @description 获取所有键名
- * @param {String} key 键 支持*号, 前面加*表示后面名称一致, 前后加*表示包含名称, 后面加*表示前面名称一致
- * @return {Promise|Array} 键数组
+ * @description 哈希表获取所有字段和值
+ * @param {String} key 键名
+ * @return {Promise<Object>} 所有字段和值
  */
-Cache.prototype.keys = async function(key) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var list = _this.list.search(key, 'name');
-		resolve(list.toArr('name'));
-	});
+Cache.prototype.hgetall = async function(key) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('hgetall', [scopeKey]);
 };
+
 /**
- * @description 修改数组缓存
- * @param {String} key 键
- * @param {Object} value 值
- * @param {Number} maxAge 秒
- * @return {Promise|Array} 执行结果
+ * @description 哈希表删除字段
+ * @param {String} key 键名
+ * @param {String} field 字段名
+ * @return {Promise<Number>} 删除的字段数量
  */
-Cache.prototype.list_set = async function(key, value, maxAge) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var ret = _this.setVal(key, value, maxAge);
-		resolve(ret);
-	});
+Cache.prototype.hdel = async function(key, field) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('hdel', [scopeKey, field]);
 };
+
 /**
- * @description 数组缓存追加对象
- * @param {String} key 键
- * @param {Object} value 值
- * @return {Promise|String} 追加后的数组
- */
-Cache.prototype.list_add = async function(key, value) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			var arr = obj.value;
-			if (arr.constructor == Array) {
-				arr.push(value);
-				obj.value = arr;
-				resolve(obj.value);
-			} else {
-				_this.error = "当前缓存值非数组";
-				resolve(null);
-			}
-		} else {
-			resolve(null);
-		}
-	});
+ * @description 哈希表批量设置字段
+ * @param {String} key 键名
+ * @param {Array} fieldValues 字段值对数组，格式: [field1, value1, field2, value2, ...]
+ * @return {Promise<Number>} 设置的字段数量
+ */
+Cache.prototype.hmset = async function(key, ...fieldValues) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('hmset', [scopeKey, ...fieldValues]);
 };
+
 /**
- * @description 判断成员是否存在
- * @param {String} key 键
- * @param {Object} value 值
- * @return {Promise|Boolean} 存在返回true, 否则返回false
- */
-Cache.prototype.list_has = async function(key, value) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			if (obj.value.constructor == Array) {
-				resolve(obj.value.has(value));
-			} else {
-				_this.error = "当前缓存值非数组";
-				resolve(-1);
-			}
-		} else {
-			resolve(0);
-		}
-	});
+ * @description 哈希表批量获取字段
+ * @param {String} key 键名
+ * @param {Array} fields 字段名数组
+ * @return {Promise<Array>} 字段值数组
+ */
+Cache.prototype.hmget = async function(key, ...fields) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('hmget', [scopeKey, ...fields]);
 };
+
 /**
- * @description 查询数组缓存
- * @param {String} key 键
- * @param {Number} start 起始位置
- * @param {Number} end 结束位置
- * @return {Promise|Array} 查询到的数组
- */
-Cache.prototype.list_get = async function(key, start, end) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		var obj = _this.getObj(key);
-		if (obj) {
-			if (obj.value.constructor == Array) {
-				var lt = obj.value;
-				if (!end) {
-					end = lt.length;
-				}
-				if (!start) {
-					start = 0;
-				}
-				var list = [];
-				for (var i = start; i < end; i++) {
-					list.push(lt[i]);
-				}
-				resolve(list);
-			} else {
-				_this.error = "当前缓存值非数组";
-				resolve(null);
-			}
-		} else {
-			resolve(null);
-		}
-	});
+ * @description 获取哈希表字段数量
+ * @param {String} key 键名
+ * @return {Promise<Number>} 字段数量
+ */
+Cache.prototype.hlen = async function(key) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('hlen', [scopeKey]);
 };
+
 /**
- * @description 清空数组缓存
- * @param {String} key 键
- * @param {Array} value 新成员, 没有则删除数组
- * @return {Promise|Boolean} 成功返回true，是否返回false
- */
-Cache.prototype.list_clear = async function(key, value) {
-	var _this = this;
-	return new Promise((resolve, reject) => {
-		if (value) {
-			var obj = _this.getObj(key);
-			if (obj) {
-				obj.value = value;
-				resolve(1);
-			} else {
-				resolve(0);
-			}
-		} else {
-			var ret = _this.del(key);
-			resolve(ret);
-		}
-	});
+ * @description 获取字符串长度
+ * @param {String} key 键名
+ * @return {Promise<Number>} 字符串长度
+ */
+Cache.prototype.strlen = async function(key) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('strlen', [scopeKey]);
 };
+
 /**
- * @description 到期通知
- * @param {Object} obj 对象
+ * @description 集合添加成员
+ * @param {String} key 键名
+ * @param {Array} members 成员数组
+ * @return {Promise<Number>} 新增的成员数量
  */
-Cache.prototype.notity = function(obj) {
-	// console.log('过期了：' + obj.toJson());
-	if (this.func) {
-		this.func(obj);
-	}
+Cache.prototype.sadd = async function(key, ...members) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('sadd', [scopeKey, ...members]);
 };
+
 /**
- * @description 检查时间是否到期, 到期则删除数据库
+ * @description 集合删除成员
+ * @param {String} key 键名
+ * @param {Array} members 成员数组
+ * @return {Promise<Number>} 删除的成员数量
  */
-Cache.prototype.checkTime = async function() {
-	var sp = Date.parse(new Date());
-	var lt = [];
-	for (var i = this.list.length - 1; i >= 0; i--) {
-		var o = this.list[i];
-		if (o.expires) {
-			var t = Date.parse(o.expires) - sp;
-			if (t < 1) {
-				this.notity(o);
-				this.delObj(o.name);
-			}
-		}
-	}
+Cache.prototype.srem = async function(key, ...members) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('srem', [scopeKey, ...members]);
 };
+
 /**
- * @description 销毁对象
+ * @description 检查成员是否在集合中
+ * @param {String} key 键名
+ * @param {String} member 成员
+ * @return {Promise<Boolean>} 是否存在
  */
-Cache.prototype.dispose = function() {
-	for (var k in $.pool.cache) {
-		$.pool.cache[k].clear();
-		delete $.pool.cache[k];
-	}
+Cache.prototype.sismember = async function(key, member) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('sismember', [scopeKey, member]);
+};
+
+/**
+ * @description 获取集合所有成员
+ * @param {String} key 键名
+ * @return {Promise<Array>} 成员数组
+ */
+Cache.prototype.smembers = async function(key) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('smembers', [scopeKey]);
+};
+
+/**
+ * @description 以毫秒为单位设置过期时间
+ * @param {String} key 键名
+ * @param {Number} milliseconds 过期时间(毫秒)
+ * @return {Promise<Boolean>} 是否设置成功
+ */
+Cache.prototype.pexpire = async function(key, milliseconds) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('pexpire', [scopeKey, milliseconds]);
+};
+
+/**
+ * @description 移除键的过期时间
+ * @param {String} key 键名
+ * @return {Promise<Boolean>} 是否移除成功
+ */
+Cache.prototype.persist = async function(key) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('persist', [scopeKey]);
+};
+
+/**
+ * @description 重命名键
+ * @param {String} oldKey 旧键名
+ * @param {String} newKey 新键名
+ * @return {Promise<Boolean>} 是否重命名成功
+ */
+Cache.prototype.rename = async function(oldKey, newKey) {
+	// 添加作用域前缀
+	const scopeOldKey = `${this.scope}:${oldKey}`;
+	const scopeNewKey = `${this.scope}:${newKey}`;
+	return await this._safeCall('rename', [scopeOldKey, scopeNewKey]);
+};
+
+/**
+ * @description 获取键的类型
+ * @param {String} key 键名
+ * @return {Promise<String>} 类型(none|string|list|set|zset|hash)
+ */
+Cache.prototype.type = async function(key) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('type', [scopeKey]);
+};
+
+/**
+ * @description 设置列表内容
+ * @param {String} key 键名
+ * @param {Array} value 列表值
+ * @param {Number} expire 过期时间（秒）
+ * @return {Promise<Boolean>} 是否成功
+ */
+Cache.prototype.setForList = async function(key, value, expire) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('setForList', [scopeKey, value, expire]);
+};
+
+/**
+ * @description 向列表添加元素
+ * @param {String} key 键名
+ * @param {*} value 要添加的元素
+ * @return {Promise<Boolean>} 是否成功
+ */
+Cache.prototype.addForList = async function(key, value) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('addForList', [scopeKey, value]);
+};
+
+/**
+ * @description 检查列表中是否包含指定元素
+ * @param {String} key 键名
+ * @param {*} value 要检查的元素
+ * @return {Promise<Boolean>} 是否包含
+ */
+Cache.prototype.hasForList = async function(key, value) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('hasForList', [scopeKey, value]);
+};
+
+/**
+ * @description 获取列表指定范围的元素
+ * @param {String} key 键名
+ * @param {Number} start 起始索引，默认0
+ * @param {Number} stop 结束索引，默认-1（表示到末尾）
+ * @return {Promise<Array>} 元素数组
+ */
+Cache.prototype.getForList = async function(key, start = 0, stop = -1) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('getForList', [scopeKey, start, stop]);
+};
+
+/**
+ * @description 清空列表，保留键和过期时间
+ * @param {String} key 键名
+ * @return {Promise<Boolean>} 是否成功
+ */
+Cache.prototype.clearForList = async function(key) {
+	// 添加作用域前缀
+	const scopeKey = `${this.scope}:${key}`;
+	return await this._safeCall('clearForList', [scopeKey]);
+};
+
+/**
+ * @description 清理缓存
+ * @param {String} key 匹配模式
+ * @return {Promise<Boolean>} 是否清理成功
+ */
+Cache.prototype.clear = async function(key) {
+	// 添加作用域前缀
+	const scopeKey = key ? `${this.scope}:${key}` : `${this.scope}:*`;
+	return await this._safeCall('clear', [scopeKey]);
+};
+
+/**
+ * @description 清理过期缓存
+ * @return {Promise<Boolean>} 是否清理成功
+ */
+Cache.prototype.clearExpire = async function() {
+	return await this._safeCall('clearExpire', []);
 };
 
 /**
- * @description 导出Cache函数
+ * @description 关闭数据库连接
+ * @return {Promise<Boolean>} 是否关闭成功
  */
+Cache.prototype.dispose = async function() {
+	if (this.db && typeof this.db.dispose === 'function') {
+		return await this.db.dispose();
+	}
+	return true;
+};
+
+
+
+// 修改导出方式以支持多种导入格式
 exports.Cache = Cache;
 
 /**
- * @description 缓存池
+ * 确保连接池对象存在
  */
+if (!$.pool) {
+	$.pool = {};
+}
 if (!$.pool.cache) {
 	$.pool.cache = {};
 }
 
 /**
- * @description API管理器，用于创建缓存
+ * @description Cache管理器，用于创建缓存
  * @param {String} scope 作用域
- * @param {String} dir 当前路径
- * @param {String} maxAge 当前路径
- * @return {Object} 返回一个缓存类
+ * @param {Object} config 配置参数
+ * @return {Object} 返回一个Cache类实例
  */
-function cache_admin(scope, dir, maxAge) {
+function cacheAdmin(scope, config) {
 	if (!scope) {
-		scope = $.val.scope + '';
+		scope = 'sys';
 	}
 	var obj = $.pool.cache[scope];
 	if (!obj) {
-		$.pool.cache[scope] = new Cache(scope, dir, maxAge);
+		$.pool.cache[scope] = new Cache(scope, config);
 		obj = $.pool.cache[scope];
 	}
 	return obj;
 }
 
-
 /**
- * @description 导出API管理器
+ * @module 导出Cache管理器
  */
-exports.cache_admin = cache_admin;
+exports.cacheAdmin = cacheAdmin;