mm_cache 1.5.3 → 1.5.5

package/index.js

@@ -1,877 +1,23 @@
-/**
- * @fileOverview 本地缓存类 (带本地持久存储)
- * @author <a href="http://qww.elins.cn">邱文武</a>
- * @version 1.2
- */
-const { Base } = require('mm_expand');
-
-/** 
- * @class 缓存类
- */
-class Cache extends Base {
-	static 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: "",
-			// 密码
-			password: "",
-			// 连接选项 (MongoDB驱动7.x版本支持的参数)
-			min_pool_size: 10,
-			max_pool_size: 100,
-			connect_timeout_ms: 10000,
-			server_selection_timeout_ms: 5000,
-			retry_writes: true
-		}
-	};
-
-	/**
-	 * @description 创建Cache帮助类函数 (构造函数)
-	 * @param {Object} config 配置
-	 * @constructor
-	 */
-	constructor(config) {
-		super(Cache.config);
-		// 作用域
-		this.scope;
-		// 当前连接库
-		this._client = null;
-		// 初始化配置
-		this.setConfig(config);
-		// 注意：不再在构造函数中直接调用异步的connect()
-		// 用户需要手动调用await cache.connect()
-	}
-}
-
-/**
- * @description 设置配置
- * @param {Object} config 配置
- */
-Cache.prototype.setConfig = function (config) {
-	// 确保this.config存在
-	if (!this.config) {
-		this.config = {};
-	}
-	
-	if (config) {
-		// 使用$.push合并配置
-		$.push(this.config, config);
-	}
-	
-	// 确保way属性存在
-	if (!this.config.way) {
-		this.config.way = 'memory'; // 默认缓存方式
-	}
-	
-	if (this.config.scope) {
-		this.scope = this.config.scope;
-	} else {
-		this.scope = $.val.scope + '';
-	}
-};
-
-/**
- * @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 {
-						redisAdmin
-					} = require('mm_redis');
-					this._client = redisAdmin(this.config.scope, this.config.redis);
-					if (!this._client.connected) {
-						await this._client.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 {
-						mongodbAdmin
-					} = require('mm_mongodb');
-					this._client = mongodbAdmin(this.config.scope, this.config.mongodb);
-					if (!this._client.connected) {
-						await this._client.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 {
-						cachebaseAdmin
-					} = require('mm_cachebase');
-					this._client = cachebaseAdmin(this.config.scope, this.config.cachebase);
-				} catch (e) {
-					$.log.error('[Cache] [connect] CacheBase模块加载失败，无法初始化缓存:', e.message);
-					return false;
-				}
-				break;
-			case 'memory':
-			default: {
-				try {
-					const {
-						cachebaseAdmin
-					} = require('mm_cachebase');
-					this._client = cachebaseAdmin('default');
-				} catch (e) {
-					$.log.error('[Cache] [connect] CacheBase模块加载失败，无法初始化缓存:', e.message);
-					return false;
-				}
-				break;
-			}
-		}
-		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} way 缓存方式 (cachebase|redis|mongodb)
- * @param {Object} config 可选配置
- * @return {Promise<Boolean>} 是否成功
- */
-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} 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 {Promise<Boolean>} 是否存在
- */
-Cache.prototype.has = async function (key) {
-	// 添加作用域前缀
-	const scopeKey = `${this.scope}:${key}`;
-	// 优先使用has方法，如果不存在则使用exists
-	if (this._client && typeof this._client.has === 'function') {
-		return await this._client.has(scopeKey);
-	} else {
-		return await this._safeCall('exists', [scopeKey]);
-	}
-};
-
-/**
- * @description 安全调用数据库方法
- * @param {String} method 方法名
- * @param {Array} args 参数数组
- * @return {Promise<any>} 方法返回值
- */
-Cache.prototype._safeCall = async function (method, args = []) {
-	if (!this._client) {
-		// 如果未连接，自动尝试连接
-		await this.connect();
-		if (!this._client) {
-			$.log.error('[Cache] [_safeCall] 数据库未初始化');
-			return null;
-		}
-	}
-
-	// 如果方法存在，直接调用
-	if (typeof this._client[method] === 'function') {
-		return await this._client[method](...args);
-	}
+const Cache = require('./lib/cache');
+const Admin = require('mm_corejs').Admin;
 
-	// 降级处理：仅为确实不存在的方法提供内置实现
-	switch (method) {
-		case 'strlen': {
-			const key = args[0];
-			// 获取值并计算长度
-			const value = await this._client.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._client.get(oldKey);
-				if (value === null || value === undefined) {
-					return false;
-				}
-				// 设置新键
-				await this._client.set(newKey, value);
-				// 删除原键
-				await this._client.del(oldKey);
-				return 'OK';
-			} catch (error) {
-				$.log.error(`[Cache] [_safeCall] rename操作失败:`, error);
-				return false;
-			}
-		}
-		case 'type': {
-			const key = args[0];
-			// 获取值并判断类型
-			const value = await this._client.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 仅当键不存在时设置缓存
- * @param {String} key 键
- * @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 {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 键名
- * @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>} 是否删除成功
- */
-Cache.prototype.del = async function (key) {
-	// 添加作用域前缀
-	const scopeKey = `${this.scope}:${key}`;
-	return await this._safeCall('del', [scopeKey]);
-};
-
-/**
- * @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 {
-		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._client.get(key);
-				} catch (error) {
-					return null;
-				}
-			});
-
-			// 等待所有Promise完成并返回结果数组
-			return await Promise.all(promises);
-		} catch (error) {
-			return [];
-		}
-	};
-};
-
-/**
- * @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._client && typeof this._client.incr === 'function') {
-		return await this._client.incr(scopeKey, step);
-	} else {
-		return await this._safeCall('addInt', [scopeKey, step]);
-	}
-};
-
-/**
- * @description 原子递增
- * @param {String} key 键名
- * @param {Number} step 步长，默认1
- * @return {Promise<Number>} 递增后的值
- */
-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 {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 键名
- * @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.incrby = async function (key, value, options) {
-	// 添加作用域前缀
-	const scopeKey = `${this.scope}:${key}`;
-	return await this._safeCall('incrby', [scopeKey, value], options);
-};
-
-/**
- * @description 减少指定的值
- * @param {String} key 键名
- * @param {Number} value 要减少的值
- * @param {Object} options 配置选项
- * @return {Promise<Number>} 减少后的值
- */
-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} 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 {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 键名
- * @param {String} field 字段名
- * @param {Any} value 字段值
- * @return {Promise<Number>} 1表示新字段，0表示更新已有字段
- */
-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} 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<Object>} 所有字段和值
- */
-Cache.prototype.hgetall = async function (key) {
-	// 添加作用域前缀
-	const scopeKey = `${this.scope}:${key}`;
-	return await this._safeCall('hgetall', [scopeKey]);
-};
-
-/**
- * @description 哈希表删除字段
- * @param {String} key 键名
- * @param {String} field 字段名
- * @return {Promise<Number>} 删除的字段数量
- */
-Cache.prototype.hdel = async function (key, field) {
-	// 添加作用域前缀
-	const scopeKey = `${this.scope}:${key}`;
-	return await this._safeCall('hdel', [scopeKey, field]);
-};
-
-/**
- * @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 {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 键名
- * @return {Promise<Number>} 字段数量
- */
-Cache.prototype.hlen = async function (key) {
-	// 添加作用域前缀
-	const scopeKey = `${this.scope}:${key}`;
-	return await this._safeCall('hlen', [scopeKey]);
-};
-
-/**
- * @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 {String} key 键名
- * @param {Array} members 成员数组
- * @return {Promise<Number>} 新增的成员数量
- */
-Cache.prototype.sadd = async function (key, ...members) {
-	// 添加作用域前缀
-	const scopeKey = `${this.scope}:${key}`;
-	return await this._safeCall('sadd', [scopeKey, ...members]);
-};
-
-/**
- * @description 集合删除成员
- * @param {String} key 键名
- * @param {Array} members 成员数组
- * @return {Promise<Number>} 删除的成员数量
- */
-Cache.prototype.srem = async function (key, ...members) {
-	// 添加作用域前缀
-	const scopeKey = `${this.scope}:${key}`;
-	return await this._safeCall('srem', [scopeKey, ...members]);
-};
-
-/**
- * @description 检查成员是否在集合中
- * @param {String} key 键名
- * @param {String} member 成员
- * @return {Promise<Boolean>} 是否存在
- */
-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 关闭数据库连接
- * @return {Promise<Boolean>} 是否关闭成功
- */
-Cache.prototype.dispose = async function () {
-	if (this._client && typeof this._client.dispose === 'function') {
-		return await this._client.dispose();
-	}
-	return true;
-};
-
-
-
-/**
- * 确保连接池对象存在
- */
-if (!$.pool) {
-	$.pool = {};
-}
-if (!$.pool.cache) {
-	$.pool.cache = {};
-}
-
-/**
- * @description Cache管理器，用于创建缓存
- * @param {String} scope 作用域
- * @param {Object} config 配置参数
- * @return {Object} 返回一个Cache类实例
- */
-function cacheAdmin(scope, config = {}) {
-	if (!scope) {
-		scope = 'sys';
-	}
-	var obj = $.pool.cache[scope];
-	if (!obj) {
-		config.scope = scope;
-		$.pool.cache[scope] = new Cache(config);
-		obj = $.pool.cache[scope];
-	}
-	return obj;
-}
+let admin = new Admin();
+admin.setClass(Cache);
 
 /**
  * @module 导出Cache管理器
  */
 module.exports = {
 	Cache,
-	cacheAdmin
+	admin,
+	cacheAdmin(scope, config = {}) {
+		if (!scope) {
+			scope = 'os';
+		}
+		return admin.get(scope, { name: scope, ...config });
+	},
+	getCache() {
+		return admin.get('os');
+	}
 };