mm_cachebase 1.8.5 → 1.8.7

package/index.js

@@ -1,1632 +1,1765 @@
-const EventEmitter = require('events');
-require('mm_logs');
-
-class CacheBase extends EventEmitter {
-  /**
-   * 构造函数，初始化缓存
-   * @param {Object} config - 配置选项
-   */
-  constructor(scope = 'sys', config = {}) {
-    super();
-
-    // 持久化相关属性
-    this.scope = scope;
-    // 配置选项
-    this.config = {
-      dir: './cache/'.fullname(),
-      expire: 0,
-      max: 0,
-      persist: false,  // 是否启用持久化
-      saveInterval: 60000 // 保存间隔（毫秒）
-    };
-    // 数据存储对象
-    this.data = {};
-    // 键列表，用于存储所有的键名
-    this.list = [];
-    this.saveTimer = null;
-    this.dir = this.config.dir;
-    this.setConfig(config);
-    this.init();
-  }
-
-  /**
-   * 初始化方法
-   * @private
-   */
-  init() {
-    // 如果启用了持久化，尝试加载数据
-    if (this.config.persist) {
-      this._loadData().catch(error => {
-        $.log.error('[cachebase] 数据加载失败:', error);
-      });
-    }
-  }
-
-  /**
-   * 启动定时保存功能
-   * @returns {Promise<boolean>} 是否成功连接
-   */
-  async connect() {
-    try {
-      this.emit('connect_before');
-
-      // 只有在启用持久化时才启动定时保存
-      if (this.config.persist) {
-        // 先立即保存一次
-        await this._saveData();
-
-        // 清除已存在的定时器（如果有）
-        if (this.saveTimer) {
-          clearInterval(this.saveTimer);
-        }
-
-        // 设置新的定时器
-        const interval = this.config.saveInterval || 60000;
-        this.saveTimer = setInterval(() => {
-          this._saveData().catch(error => {
-            $.log.error('[cachebase] 定时保存失败:', error);
-          });
-        }, interval);
-
-        $.log.info(`[cachebase] 定时保存已启动，间隔 ${interval}ms`);
-      }
-
-      this.emit('connect_after');
-      return true;
-    } catch (error) {
-      this.emit('connect_error', { error });
-      $.log.error('[cachebase] 连接失败:', error);
-      return false;
-    }
-  }
-
-  /**
-   * 手动保存数据到文件
-   * @returns {Promise<boolean>} 是否保存成功
-   */
-  async save() {
-    try {
-      this.emit('save_before');
-      await this._saveData();
-      this.emit('save_after');
-      return true;
-    } catch (error) {
-      this.emit('save_error', { error });
-      $.log.error('[cachebase] 保存失败:', error);
-      return false;
-    }
-  }
-
-  /**
-   * 保存数据到文件
-   * @private
-   * @returns {Promise<void>}
-   */
-  async _saveData() {
-    if (!this.config.persist) return;
-
-    try {
-      // 确保目录存在
-      this.dir.addDir();
-
-      // 过滤过期数据
-      const now = Date.now();
-      const validData = {};
-      const validList = [];
-
-      for (const key of this.list) {
-        if (this.data.hasOwnProperty(key)) {
-          const item = this.data[key];
-          // 检查是否过期
-          if (!item.expire || item.expire === 0 || item.expire > now) {
-            validData[key] = item;
-            validList.push(key);
-          }
-        }
-      }
-
-      // 准备保存的数据
-      const saveData = {
-        data: validData,
-        list: validList,
-        timestamp: now
-      };
-
-      // 保存到文件
-      const file = `./${this.scope}.cache.json`.fullname(this.dir);
-      file.saveJson(saveData);
-      $.log.debug(`[cachebase] 数据已保存到 ${file}，共 ${validList.length} 个键`);
-    } catch (error) {
-      $.log.error('[cachebase] 数据保存失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 从文件加载数据
-   * @private
-   * @returns {Promise<void>}
-   */
-  async _loadData() {
-    if (!this.config.persist) return;
-
-    try {
-      // 确保目录存在
-      this.dir.addDir();
-
-      // 只加载当前scope的缓存文件
-      const file = `./${this.scope}.cache.json`.fullname(this.dir);
-
-      if (!file.hasFile()) {
-        $.log.debug(`[cachebase] 未找到当前scope的缓存文件: ${file}`);
-        return;
-      }
-
-      $.log.debug(`[cachebase] 尝试从 ${file} 加载数据`);
-
-      try {
-        try {
-          const savedData = file.loadJson();
-          $.log.debug(`[cachebase] 解析数据成功，包含data: ${savedData.data ? '是' : '否'}, list: ${savedData.list ? '是' : '否'}`);
-
-          if (savedData.data && savedData.list && Array.isArray(savedData.list)) {
-            $.log.debug(`[cachebase] 数据格式正确，list长度: ${savedData.list.length}`);
-
-            // 验证数据并过滤过期项
-            const now = Date.now();
-            const validData = {};
-            const validList = [];
-
-            for (const key of savedData.list) {
-              if (savedData.data.hasOwnProperty(key)) {
-                const item = savedData.data[key];
-                $.log.debug(`[cachebase] 检查键 ${key}，过期时间: ${item.expire || 0}`);
-                // 检查是否过期
-                if (!item.expire || item.expire === 0 || item.expire > now) {
-                  validData[key] = item;
-                  validList.push(key);
-                } else {
-                  $.log.debug(`[cachebase] 键 ${key} 已过期，跳过`);
-                }
-              }
-            }
-
-            // 直接使用加载的数据替换当前数据
-            this.data = validData;
-            this.list = validList;
-            this.dict = this.data; // 确保dict指向最新的data
-
-            $.log.info(`[cachebase] 从 ${this.scope}.cache.json 加载数据成功，共 ${validList.length} 个键`);
-            if (validList.length > 0) {
-              $.log.debug(`[cachebase] 加载的键: ${validList.join(', ')}`);
-            }
-          } else {
-            $.log.warn(`[cachebase] 缓存文件格式不正确，缺少必要字段`);
-          }
-        } catch (parseError) {
-          $.log.error(`[cachebase] 文件JSON解析失败:`, parseError);
-        }
-      } catch (readError) {
-        $.log.error(`[cachebase] 读取文件失败:`, readError);
-      }
-    } catch (error) {
-      $.log.error('[cachebase] 数据加载失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 设置缓存配置
-   * @param {Object} config 
-   */
-  setConfig(config) {
-    if (config) {
-      Object.assign(this.config, config);
-      this.dir = this.config.dir.fullname(__dirname)
-    }
-  }
-
-  /**
-   * 检查键是否过期
-   * @private
-   * @param {string} key - 键名
-   * @returns {boolean} - 是否已过期
-   */
-  _checkExpire(key) {
-    if (this.data.hasOwnProperty(key)) {
-      const item = this.data[key];
-      if (item && typeof item === 'object' && item.expire > 0) {
-        // 检查是否过期
-        if (Date.now() > item.expire) {
-          // 删除过期键
-          this.del(key);
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-  /**
-   * 设置键的过期时间
-   * @private
-   * @param {string} key - 键名
-   * @param {number} seconds - 过期时间（秒）
-   */
-  _setExpire(key, seconds) {
-    if (this.data.hasOwnProperty(key)) {
-      const item = this.data[key];
-      if (item && typeof item === 'object') {
-        item.expire = seconds > 0 ? Date.now() + seconds * 1000 : 0;
-      }
-    }
-  }
-
-  /**
-   * 设置键值 - 兼容方法
-   * @param {string} key - 键名
-   * @param {*} value - 键值
-   * @param {number} expire - 过期时间(秒)，0表示永不过期
-   * @returns {Promise<string>} - 返回'OK'
-   * @note 确保行为与Redis兼容，支持所有Redis的参数模式
-   */
-  async set(key, value, expire = 0) {
-    try {
-      this.emit('set_before', { key, value, expire });
-
-      // 设置值和过期时间
-      this.data[key] = { value, expire: expire > 0 ? Date.now() + expire * 1000 : 0 };
-
-      // 如果键不存在于列表中，添加到列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('set_after', { key, value, expire, result: 'OK' });
-      return 'OK';
-    } catch (error) {
-      this.emit('set_error', { key, value, expire, error });
-      $.log.error('[cachebase] set操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取键值
-   * @param {string} key - 键名
-   * @returns {Promise<*>} - 返回键值，不存在返回undefined
-   */
-  async get(key) {
-    try {
-      // 检查键是否存在
-      if (!this.data.hasOwnProperty(key)) {
-        return undefined;
-      }
-
-      const item = this.data[key];
-
-      // 检查是否过期
-      if (item.expire > 0 && Date.now() > item.expire) {
-        // 删除过期键
-        delete this.data[key];
-        const index = this.list.indexOf(key);
-        if (index !== -1) {
-          this.list.splice(index, 1);
-        }
-        return undefined;
-      }
-
-      return item.value;
-    } catch (error) {
-      $.log.error('[cachebase] get操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 删除键 - 兼容方法
-   * @param {string} key - 键名
-   * @returns {Promise<number>} - 返回删除的键数量
-   * @note 确保与Redis行为一致，只删除存在且未过期的键
-   */
-  async del(key) {
-    try {
-      this.emit('del_before', { key });
-
-      // 检查键是否存在且未过期
-      let deleted = 0;
-      if (this.data.hasOwnProperty(key)) {
-        const item = this.data[key];
-        // 检查是否过期
-        if (!(item.expire > 0 && Date.now() > item.expire)) {
-          delete this.data[key];
-          const index = this.list.indexOf(key);
-          if (index !== -1) {
-            this.list.splice(index, 1);
-          }
-          deleted = 1;
-        }
-      }
-
-      this.emit('del_after', { key, result: deleted });
-      return deleted;
-    } catch (error) {
-      this.emit('del_error', { key, error });
-      $.log.error('[cachebase] del操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 检查键是否存在 - 兼容方法
-   * @param {string|Array<string>} key - 键名或键名数组
-   * @returns {Promise<number>} - 返回存在的键数量
-   * @note 确保与Redis行为一致，只计算存在且未过期的键
-   */
-  async exists(key) {
-    try {
-      let existsCount = 0;
-
-      // 检查输入类型并处理
-      if (Array.isArray(key)) {
-        // 处理多键检查
-        for (const k of key) {
-          if (this.data.hasOwnProperty(k)) {
-            // 检查是否过期
-            const item = this.data[k];
-            if (!(item.expire > 0 && Date.now() > item.expire)) {
-              existsCount++;
-            }
-          }
-        }
-      } else {
-        // 处理单键检查
-        if (this.data.hasOwnProperty(key)) {
-          // 检查是否过期
-          const item = this.data[key];
-          if (!(item.expire > 0 && Date.now() > item.expire)) {
-            existsCount = 1;
-          }
-        }
-      }
-
-      return existsCount;
-    } catch (error) {
-      $.log.error('[cachebase] exists操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 设置哈希表字段
-   * @param {string} key - 键名
-   * @param {string} field - 字段名
-   * @param {*} value - 字段值
-   * @returns {Promise<number>} - 返回1表示新建字段，0表示更新字段
-   */
-  async hset(key, field, value) {
-    try {
-      this.emit('hset_before', { key, field, value });
-
-      // 初始化哈希表
-      if (!this.data.hasOwnProperty(key)) {
-        this.data[key] = { value: {}, expire: 0 };
-        this.list.push(key);
-      } else if (this.data[key].expire > 0 && Date.now() > this.data[key].expire) {
-        // 键已过期，重新初始化
-        this.data[key] = { value: {}, expire: 0 };
-      } else if (typeof this.data[key].value !== 'object') {
-        // 类型错误
-        throw new Error(`[cachebase] 键 ${key} 不是哈希表类型`);
-      }
-
-      // 检查字段是否存在
-      const isNewField = !this.data[key].value.hasOwnProperty(field);
-      this.data[key].value[field] = value;
-
-      const result = isNewField ? 1 : 0;
-      this.emit('hset_after', { key, field, value, result });
-      return result;
-    } catch (error) {
-      this.emit('hset_error', { key, field, value, error });
-      $.log.error('[cachebase] hset操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取哈希表字段
-   * @param {string} key - 键名
-   * @param {string} field - 字段名
-   * @returns {Promise<*>} - 返回字段值，不存在返回undefined
-   */
-  async hget(key, field) {
-    try {
-      // 检查键是否存在且未过期
-      if (!this.data.hasOwnProperty(key) ||
-        (this.data[key].expire > 0 && Date.now() > this.data[key].expire) ||
-        typeof this.data[key].value !== 'object') {
-        return undefined;
-      }
-
-      return this.data[key].value[field];
-    } catch (error) {
-      $.log.error('[cachebase] hget操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取哈希表所有字段
-   * @param {string} key - 键名
-   * @returns {Promise<Object>} - 返回哈希表对象，不存在或不是哈希表返回{}
-   */
-  async hgetall(key) {
-    try {
-      // 检查键是否存在且未过期
-      if (!this.data.hasOwnProperty(key) ||
-        (this.data[key].expire > 0 && Date.now() > this.data[key].expire) ||
-        typeof this.data[key].value !== 'object') {
-        return {};
-      }
-
-      // 返回哈希表的副本
-      return { ...this.data[key].value };
-    } catch (error) {
-      $.log.error('[cachebase] hgetall操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 删除哈希表字段
-   * @param {string} key - 键名
-   * @param {string} field - 字段名
-   * @returns {Promise<number>} - 始终返回0以保持兼容性，但实际会删除字段
-   */
-  async hdel(key, field) {
-    try {
-      this.emit('hdel_before', { key, field });
-
-      // 检查键是否存在且未过期
-      if (this.data.hasOwnProperty(key) &&
-        !(this.data[key].expire > 0 && Date.now() > this.data[key].expire) &&
-        typeof this.data[key].value === 'object' &&
-        this.data[key].value.hasOwnProperty(field)) {
-        
-        // 删除字段
-        delete this.data[key].value[field];
-
-        // 检查哈希表是否为空
-        const hashKeys = Object.keys(this.data[key].value);
-        if (hashKeys.length === 0) {
-          // 删除空哈希表
-          delete this.data[key];
-          const index = this.list.indexOf(key);
-          if (index !== -1) {
-            this.list.splice(index, 1);
-          }
-        }
-      }
-
-      // 始终返回0以保持兼容性
-      this.emit('hdel_after', { key, field, result: 0 });
-      return 0;
-    } catch (error) {
-      this.emit('hdel_error', { key, field, error });
-      $.log.error('[cachebase] hdel操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 批量设置键值
-   * @param {Object} keyValues - 键值对对象
-   * @returns {Promise<string>} - 返回'OK'
-   */
-  async mset(keyValues) {
-    try {
-      this.emit('mset_before', { keyValues });
-
-      if (typeof keyValues !== 'object' || keyValues === null) {
-        throw new Error('[cachebase] mset参数必须是对象');
-      }
-
-      // 批量设置键值
-      for (const key in keyValues) {
-        if (keyValues.hasOwnProperty(key)) {
-          this.data[key] = { value: keyValues[key], expire: 0 };
-          if (!this.list.includes(key)) {
-            this.list.push(key);
-          }
-        }
-      }
-
-      this.emit('mset_after', { keyValues, result: 'OK' });
-      return 'OK';
-    } catch (error) {
-      this.emit('mset_error', { keyValues, error });
-      $.log.error('[cachebase] mset操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 批量获取键值
-   * @param {Array<string>} keys - 键名数组
-   * @returns {Promise<Array>} - 返回值数组
-   */
-  async mget(keys) {
-    try {
-      if (!Array.isArray(keys)) {
-        throw new Error('[cachebase] mget参数必须是数组');
-      }
-
-      // 批量获取键值
-      const results = [];
-      for (const key of keys) {
-        if (this.data.hasOwnProperty(key)) {
-          // 检查是否过期
-          const item = this.data[key];
-          if (item.expire === 0 || Date.now() <= item.expire) {
-            results.push(item.value);
-          } else {
-            // 删除过期键
-            delete this.data[key];
-            const index = this.list.indexOf(key);
-            if (index !== -1) {
-              this.list.splice(index, 1);
-            }
-            results.push(undefined);
-          }
-        } else {
-          results.push(undefined);
-        }
-      }
-
-      return results;
-    } catch (error) {
-      $.log.error('[cachebase] mget操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 移除键的过期时间，使其永不过期
-   * @param {string} key - 键名
-   * @returns {Promise<number>} - 返回1表示成功移除过期时间，0表示键不存在
-   */
-  async persist(key) {
-    try {
-      this.emit('persist_before', { key });
-      
-      // 检查键是否存在
-      if (!this.data.hasOwnProperty(key)) {
-        this.emit('persist_after', { key, result: 0 });
-        return 0;
-      }
-      
-      const item = this.data[key];
-      
-      // 检查是否已过期
-      if (item.expire > 0 && Date.now() > item.expire) {
-        // 键已过期，删除并返回0
-        delete this.data[key];
-        const index = this.list.indexOf(key);
-        if (index !== -1) {
-          this.list.splice(index, 1);
-        }
-        this.emit('persist_after', { key, result: 0 });
-        return 0;
-      }
-      
-      // 设置为永不过期
-      item.expire = 0;
-      
-      this.emit('persist_after', { key, result: 1 });
-      return 1;
-    } catch (error) {
-      this.emit('persist_error', { key, error });
-      $.log.error('[cachebase] persist操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取键的剩余生存时间 - 兼容方法
-   * @param {string} key - 键名
-   * @returns {Promise<number>} - 返回剩余时间（秒），-1表示永不过期，-2表示键不存在
-   * @note 确保与Redis行为完全一致，精确计算剩余时间
-   */
-  async ttl(key) {
-    try {
-      // 检查键是否存在
-      if (!this.data.hasOwnProperty(key)) {
-        return -2;
-      }
-
-      const item = this.data[key];
-
-      // 检查是否过期
-      if (item.expire > 0) {
-        if (Date.now() > item.expire) {
-          // 键已过期，删除并返回-2
-          delete this.data[key];
-          const index = this.list.indexOf(key);
-          if (index !== -1) {
-            this.list.splice(index, 1);
-          }
-          return -2;
-        } else {
-          // 精确计算剩余时间
-          const remainingMs = item.expire - Date.now();
-          // 确保返回整数秒，向下取整
-          const ttl = Math.floor(remainingMs / 1000);
-          return ttl;
-        }
-      } else {
-        // 永不过期
-        return -1;
-      }
-    } catch (error) {
-      $.log.error('[cachebase] ttl操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 设置键的过期时间
-   * @param {string} key - 键名
-   * @param {number} seconds - 过期时间（秒）
-   * @returns {Promise<number>} - 返回1表示设置成功，0表示键不存在
-   */
-  async expire(key, seconds) {
-    try {
-      this.emit('expire_before', { key, seconds });
-
-      // 检查键是否存在
-      if (!this.data.hasOwnProperty(key)) {
-        this.emit('expire_after', { key, seconds, result: 0 });
-        return 0;
-      }
-
-      // 检查是否已过期
-      const item = this.data[key];
-      if (item.expire > 0 && Date.now() > item.expire) {
-        // 键已过期，删除并返回0
-        delete this.data[key];
-        const index = this.list.indexOf(key);
-        if (index !== -1) {
-          this.list.splice(index, 1);
-        }
-        this.emit('expire_after', { key, seconds, result: 0 });
-        return 0;
-      }
-
-      // 设置过期时间
-      this.data[key].expire = Date.now() + seconds * 1000;
-
-      this.emit('expire_after', { key, seconds, result: 1 });
-      return 1;
-    } catch (error) {
-      this.emit('expire_error', { key, seconds, error });
-      $.log.error('[cachebase] expire操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 移除键的过期时间
-   * @param {string} key - 键名
-   * @returns {Promise<number>} - 返回1表示移除成功，0表示键不存在或没有过期时间
-   */
-  async persist(key) {
-    try {
-      this.emit('persist_before', { key });
-
-      // 检查键是否存在
-      if (!this.data.hasOwnProperty(key)) {
-        this.emit('persist_after', { key, result: 0 });
-        return 0;
-      }
-
-      // 检查是否已过期
-      const item = this.data[key];
-      if (item.expire > 0 && Date.now() > item.expire) {
-        // 键已过期，删除并返回0
-        delete this.data[key];
-        const index = this.list.indexOf(key);
-        if (index !== -1) {
-          this.list.splice(index, 1);
-        }
-        this.emit('persist_after', { key, result: 0 });
-        return 0;
-      }
-
-      // 检查是否有过期时间
-      if (item.expire === 0) {
-        // 没有过期时间，返回0
-        this.emit('persist_after', { key, result: 0 });
-        return 0;
-      }
-
-      // 移除过期时间
-      this.data[key].expire = 0;
-
-      this.emit('persist_after', { key, result: 1 });
-      return 1;
-    } catch (error) {
-      this.emit('persist_error', { key, error });
-      $.log.error('[cachebase] persist操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取所有键名
-   * @param {string} pattern - 模式匹配
-   * @returns {Promise<Array>} - 返回键名数组
-   */
-  async keys(pattern = '*') {
-    try {
-      // 支持通配符匹配
-      let filteredKeys = [];
-      if (pattern === '*') {
-        // 通配符匹配所有
-        filteredKeys = [...this.list];
-      } else {
-        // 简单的通配符匹配
-        const regex = new RegExp(pattern.replace(/\*/g, '.*'));
-        filteredKeys = this.list.filter(key => regex.test(key));
-      }
-
-      return filteredKeys;
-    } catch (error) {
-      $.log.error('[cachebase] keys操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取键数量
-   * @returns {Promise<number>} - 返回键数量
-   */
-  async dbsize() {
-    try {
-      // 过滤掉已过期的键
-      let count = 0;
-      for (const key of this.list) {
-        if (this.data.hasOwnProperty(key)) {
-          const item = this.data[key];
-          if (item.expire === 0 || Date.now() <= item.expire) {
-            count++;
-          }
-        }
-      }
-
-      return count;
-    } catch (error) {
-      $.log.error('[cachebase] dbsize操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 设置键值并返回旧值
-   * @param {string} key - 键名
-   * @param {*} value - 键值
-   * @returns {Promise<*>} - 返回旧值
-   */
-  async getset(key, value) {
-    try {
-      this.emit('getset_before', { key, value });
-
-      // 获取旧值
-      let oldValue = undefined;
-      if (this.data.hasOwnProperty(key)) {
-        const item = this.data[key];
-        if (!(item.expire > 0 && Date.now() > item.expire)) {
-          oldValue = item.value;
-        }
-      }
-
-      // 设置新值
-      this.data[key] = { value, expire: 0 };
-
-      // 添加到键列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('getset_after', { key, value, result: oldValue });
-      return oldValue;
-    } catch (error) {
-      this.emit('getset_error', { key, value, error });
-      $.log.error('[cachebase] getset操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 数值递增
-   * @param {string} key - 键名
-   * @returns {Promise<number>} - 返回递增后的值
-   */
-  async incr(key) {
-    try {
-      this.emit('incr_before', { key });
-
-      // 获取当前值或默认为0
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        currentValue = parseFloat(this.data[key].value) || 0;
-      }
-
-      // 递增
-      const result = currentValue + 1;
-
-      // 保存结果
-      this.data[key] = { value: result, expire: 0 };
-
-      // 如果键不存在于列表中，添加到列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('incr_after', { key, result });
-      return result;
-    } catch (error) {
-      this.emit('incr_error', { key, error });
-      $.log.error('[cachebase] incr操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 数值递减
-   * @param {string} key - 键名
-   * @returns {Promise<number>} - 返回递减后的值
-   */
-  async decr(key) {
-    try {
-      this.emit('decr_before', { key });
-
-      // 获取当前值或默认为0
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        currentValue = parseFloat(this.data[key].value) || 0;
-      }
-
-      // 递减
-      const result = currentValue - 1;
-
-      // 保存结果
-      this.data[key] = { value: result, expire: 0 };
-
-      // 如果键不存在于列表中，添加到列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('decr_after', { key, result });
-      return result;
-    } catch (error) {
-      this.emit('decr_error', { key, error });
-      $.log.error('[cachebase] decr操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 数值增加指定值
-   * @param {string} key - 键名
-   * @param {number} increment - 增加的值
-   * @returns {Promise<number>} - 返回增加后的值
-   */
-  async incrby(key, increment) {
-    try {
-      this.emit('incrby_before', { key, increment });
-
-      // 获取当前值或默认为0
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        currentValue = parseFloat(this.data[key].value) || 0;
-      }
-
-      // 增加指定值
-      const result = currentValue + parseFloat(increment);
-
-      // 保存结果
-      this.data[key] = { value: result, expire: 0 };
-
-      // 如果键不存在于列表中，添加到列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('incrby_after', { key, increment, result });
-      return result;
-    } catch (error) {
-      this.emit('incrby_error', { key, increment, error });
-      $.log.error('[cachebase] incrby操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 数值减少指定值
-   * @param {string} key - 键名
-   * @param {number} decrement - 减少的值
-   * @returns {Promise<number>} - 返回减少后的值
-   */
-  async decrby(key, decrement) {
-    try {
-      this.emit('decrby_before', { key, decrement });
-
-      // 获取当前值或默认为0
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        currentValue = parseFloat(this.data[key].value) || 0;
-      }
-
-      // 减少指定值
-      const result = currentValue - parseFloat(decrement);
-
-      // 保存结果
-      this.data[key] = { value: result, expire: 0 };
-
-      // 如果键不存在于列表中，添加到列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('decrby_after', { key, decrement, result });
-      return result;
-    } catch (error) {
-      this.emit('decrby_error', { key, decrement, error });
-      $.log.error('[cachebase] decrby操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 浮点数增加指定值
-   * @param {string} key - 键名
-   * @param {number} increment - 增加的值
-   * @returns {Promise<number>} - 返回增加后的值
-   */
-  async incrbyfloat(key, increment) {
-    try {
-      this.emit('incrbyfloat_before', { key, increment });
-
-      // 获取当前值或默认为0
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        currentValue = parseFloat(this.data[key].value) || 0;
-      }
-
-      // 增加指定值
-      const result = currentValue + parseFloat(increment);
-
-      // 保存结果
-      this.data[key] = { value: result, expire: 0 };
-
-      // 如果键不存在于列表中，添加到列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('incrbyfloat_after', { key, increment, result });
-      return result;
-    } catch (error) {
-      this.emit('incrbyfloat_error', { key, increment, error });
-      $.log.error('[cachebase] incrbyfloat操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 字符串追加
-   * @param {string} key - 键名
-   * @param {string} value - 追加的字符串
-   * @returns {Promise<number>} - 返回追加后的字符串长度
-   */
-  async append(key, value) {
-    try {
-      this.emit('append_before', { key, value });
-
-      // 获取当前值或默认为空字符串
-      let currentValue = '';
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        currentValue = String(this.data[key].value);
-      }
-
-      // 执行字符串拼接
-      const newValue = currentValue + String(value);
-      const result = newValue.length;
-
-      // 保存结果
-      this.data[key] = { value: newValue, expire: 0 };
-
-      // 如果键不存在于列表中，添加到列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('append_after', { key, value, result });
-      return result;
-    } catch (error) {
-      this.emit('append_error', { key, value, error });
-      $.log.error('[cachebase] append操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 获取字符串长度
-   * @param {string} key - 键名
-   * @returns {Promise<number>} - 返回字符串长度
-   */
-  async strlen(key) {
-    try {
-      this.emit('strlen_before', { key });
-
-      // 检查键是否存在且未过期
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        const result = String(this.data[key].value).length;
-        this.emit('strlen_after', { key, result });
-        return result;
-      }
-
-      this.emit('strlen_after', { key, result: 0 });
-      return 0;
-    } catch (error) {
-      this.emit('strlen_error', { key, error });
-      $.log.error('[cachebase] strlen操作失败:', error);
-      throw error;
-    }
-  }
-
-  // 保持兼容性的方法
-  async has(key) {
-    try {
-      const exists = await this.exists(key);
-      return exists > 0;
-    } catch (error) {
-      $.log.error('[cachebase] has操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 清空缓存 - 兼容方法
-   * @param {string} pattern - 可选的键匹配模式
-   * @returns {Promise<string>} - 返回'OK'
-   * @note 支持模式匹配，与Redis行为一致
-   */
-  async clear(pattern) {
-    try {
-      this.emit('clear_before', { pattern });
-
-      if (pattern) {
-        // 支持通配符匹配删除
-        const regex = new RegExp(pattern.replace(/\*/g, '.*'));
-        const keysToDelete = this.list.filter(key => regex.test(key));
-        
-        for (const key of keysToDelete) {
-          delete this.data[key];
-        }
-        
-        // 更新列表
-        this.list = this.list.filter(key => !regex.test(key));
-      } else {
-        // 清空所有数据
-        this.data = {};
-        this.list = [];
-      }
-
-      this.emit('clear_after', { pattern, result: 'OK' });
-      return 'OK';
-    } catch (error) {
-      this.emit('clear_error', { pattern, error });
-      $.log.error('[cachebase] clear操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 添加缓存（如果不存在则添加）- 兼容方法
-   * @param {string} key - 键名
-   * @param {any} value - 要添加的值（不限定类型）
-   * @param {number} maxAge - 过期时间（秒），0表示永不过期
-   * @returns {Promise<boolean>} - 键不存在并添加成功返回true，键已存在返回false
-   */
-  async add(key, value, maxAge = 0) {
-    try {
-      this.emit('add_before', { key, value, maxAge });
-
-      // 检查key是否已存在且未过期
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        // 键已存在，不添加
-        this.emit('add_after', { key, value, maxAge, result: false });
-        return false;
-      }
-
-      // 键不存在或已过期，添加值
-      this.data[key] = {
-        value,
-        expire: maxAge > 0 ? Date.now() + maxAge * 1000 : 0
-      };
-
-      // 更新列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('add_after', { key, value, maxAge, result: true });
-      return true;
-    } catch (error) {
-      this.emit('add_error', { key, value, maxAge, error });
-      $.log.error('[cachebase] add操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 设置列表项 - 兼容Redis LPUSH/RPUSH行为
-   * @param {string} key - 键名
-   * @param {any} value - 值（通常应为数组）
-   * @param {number} maxAge - 过期时间（秒），0表示永不过期
-   * @returns {Promise<number>} - 设置后列表的长度
-   * @note 兼容Redis的列表设置行为，返回列表长度
-   */
-  async list_set(key, value, maxAge = 0) {
-    try {
-      this.emit('list_set_before', { key, value, maxAge });
-      
-      // 确保值是数组类型
-      const arrayValue = Array.isArray(value) ? value : [value];
-      
-      // 设置值和过期时间
-      this.data[key] = {
-        value: arrayValue,
-        expire: maxAge > 0 ? Date.now() + maxAge * 1000 : 0
-      };
-      
-      // 更新列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-      
-      const length = arrayValue.length;
-      this.emit('list_set_after', { key, value: arrayValue, maxAge, result: length });
-      return length;
-    } catch (error) {
-      this.emit('list_set_error', { key, value, maxAge, error });
-      $.log.error('[cachebase] list_set操作失败:', error);
-      throw error;
-    }
-  }
-  
-  /**
-   * 添加列表项 - 兼容Redis LPUSH/RPUSH行为
-   * @param {string} key - 键名
-   * @param {any} value - 值
-   * @param {number} maxAge - 过期时间（秒），0表示永不过期
-   * @returns {Promise<number>} - 添加后列表的长度
-   * @note 兼容Redis的列表追加行为，返回列表长度
-   */
-  async list_add(key, value, maxAge = 0) {
-    try {
-      this.emit('list_add_before', { key, value, maxAge });
-      
-      // 获取现有列表或创建新列表
-      let list = [];
-      let existingExpire = 0;
-      
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        // 确保现有值是数组类型
-        list = Array.isArray(this.data[key].value) ? this.data[key].value : [];
-        existingExpire = this.data[key].expire;
-      }
-      
-      // 添加值到列表
-      list.push(value);
-      
-      // 设置值和过期时间
-      // 如果提供了新的过期时间，则使用新的，否则保持原来的
-      const expireTime = maxAge > 0 ? Date.now() + maxAge * 1000 : existingExpire;
-      
-      this.data[key] = {
-        value: list,
-        expire: expireTime
-      };
-      
-      // 更新列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-      
-      const length = list.length;
-      this.emit('list_add_after', { key, value, maxAge, result: length });
-      return length;
-    } catch (error) {
-      this.emit('list_add_error', { key, value, maxAge, error });
-      $.log.error('[cachebase] list_add操作失败:', error);
-      throw error;
-    }
-  }
-  
-  /**
-   * 检查列表是否包含指定项 - 兼容Redis SISMEMBER行为
-   * @param {string} key - 键名
-   * @param {any} value - 值
-   * @returns {Promise<number>} - 包含返回1，不包含返回0
-   * @note 兼容Redis的SISMEMBER命令，返回数字而非布尔值
-   */
-  async list_has(key, value) {
-    try {
-      this.emit('list_has_before', { key, value });
-      
-      // 检查键是否存在且未过期
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        // 确保将值视为数组
-        const list = Array.isArray(this.data[key].value) ? this.data[key].value : [];
-        
-        // 对于对象类型的值，使用深度比较
-        let result = 0;
-        if (typeof value === 'object' && value !== null) {
-          const valueStr = JSON.stringify(value);
-          result = list.some(item => {
-            try {
-              return typeof item === 'object' && item !== null && JSON.stringify(item) === valueStr;
-            } catch (e) {
-              // 如果JSON序列化失败，回退到严格相等
-              return item === value;
-            }
-          }) ? 1 : 0;
-        } else {
-          // 对于基本类型，使用严格相等
-          result = list.includes(value) ? 1 : 0;
-        }
-        
-        this.emit('list_has_after', { key, value, result });
-        return result;
-      }
-      
-      this.emit('list_has_after', { key, value, result: 0 });
-      return 0;
-    } catch (error) {
-      this.emit('list_has_error', { key, value, error });
-      $.log.error('[cachebase] list_has操作失败:', error);
-      throw error;
-    }
-  }
-  
-  /**
-   * 获取列表 - 兼容Redis LRANGE行为
-   * @param {string} key - 键名
-   * @param {number} start - 可选的起始索引，默认为0
-   * @param {number} stop - 可选的结束索引，默认为-1（全部）
-   * @returns {Promise<Array>} - 列表数据，确保始终返回数组类型
-   * @note 兼容Redis的LRANGE命令，支持范围获取
-   */
-  async list_get(key, start = 0, stop = -1) {
-    try {
-      this.emit('list_get_before', { key, start, stop });
-      
-      // 检查键是否存在且未过期
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        // 确保返回数组类型，如果不是数组则转换为空数组
-        const list = Array.isArray(this.data[key].value) ? [...this.data[key].value] : [];
-        
-        // 处理Redis风格的索引范围
-        let result = [];
-        if (start >= 0 && stop >= -1) {
-          if (stop === -1) {
-            result = list.slice(start);
-          } else {
-            result = list.slice(start, stop + 1);
-          }
-        }
-        
-        this.emit('list_get_after', { key, start, stop, result });
-        return result;
-      }
-      
-      // 键不存在或已过期时返回空数组
-      this.emit('list_get_after', { key, start, stop, result: [] });
-      return [];
-    } catch (error) {
-      this.emit('list_get_error', { key, start, stop, error });
-      $.log.error('[cachebase] list_get操作失败:', error);
-      throw error;
-    }
-  }
-  
-  /**
-   * 清空列表 - 兼容方法
-   * @param {string} key - 键名
-   * @returns {Promise<boolean>} - 是否成功
-   * @note 确保操作对象始终被视为数组以保持兼容性
-   */
-  async list_clear(key) {
-    try {
-      this.emit('list_clear_before', { key });
-      
-      // 检查键是否存在
-      if (this.data.hasOwnProperty(key)) {
-        // 检查是否过期
-        if (this.data[key].expire > 0 && Date.now() > this.data[key].expire) {
-          // 键已过期，删除键
-          delete this.data[key];
-          const index = this.list.indexOf(key);
-          if (index !== -1) {
-            this.list.splice(index, 1);
-          }
-          this.emit('list_clear_after', { key, result: false });
-          return false;
-        }
-        
-        // 保持过期时间不变，将列表清空为[]
-        const expire = this.data[key].expire;
-        this.data[key] = {
-          value: [],
-          expire: expire
-        };
-        
-        this.emit('list_clear_after', { key, result: true });
-        return true;
-      }
-      
-      // 键不存在，创建一个新的空列表键
-      this.data[key] = {
-        value: [],
-        expire: 0
-      };
-      
-      // 更新列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-      
-      this.emit('list_clear_after', { key, result: true });
-      return true;
-    } catch (error) {
-      this.emit('list_clear_error', { key, error });
-      $.log.error('[cachebase] list_clear操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 减少整数值（兼容Redis decr命令）
-   * @param {string} key - 键名
-   * @param {number} maxAge - 过期时间（秒），0表示永不过期
-   * @returns {Promise<number>} - 减少后的值
-   * @note 兼容Redis decr命令，初始值为0
-   */
-  async decr(key, maxAge = 0) {
-    try {
-      this.emit('decr_before', { key, maxAge });
-
-      // 获取当前值或初始化为0
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(key) && !this._checkExpire(key)) {
-        const existingValue = this.data[key].value;
-        if (typeof existingValue === 'number') {
-          currentValue = existingValue;
-        }
-      }
-
-      // 减少1
-      const newValue = currentValue - 1;
-
-      // 设置新值和过期时间
-      this.data[key] = {
-        value: newValue,
-        expire: maxAge > 0 ? Date.now() + maxAge * 1000 : (this.data.hasOwnProperty(key) ? this.data[key].expire : 0)
-      };
-
-      // 更新列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('decr_after', { key, maxAge, result: newValue });
-      return newValue;
-    } catch (error) {
-      this.emit('decr_error', { key, maxAge, error });
-      $.log.error('[cachebase] decr操作失败:', error);
-      throw error;
-    }
-  }
-  
-  /**
-   * 增加浮点数（兼容方法）
-   * @param {string} key - 键名
-   * @param {number} num - 要增加的浮点数
-   * @param {number} maxAge - 过期时间（秒），0表示永不过期
-   * @returns {Promise<number>} - 计算后的结果
-   */
-  async addFloat(key, num, maxAge = 0) {
-    try {
-      this.emit('addFloat_before', { key, num, maxAge });
-
-      // 原生实现浮点数递增逻辑
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(key)) {
-        const item = this.data[key];
-        if (item.expire === 0 || Date.now() < item.expire) {
-          currentValue = Number(item.value) || 0;
-        }
-      }
-      const result = currentValue + Number(num);
-
-      // 设置值和过期时间
-      this.data[key] = {
-        value: result,
-        expire: maxAge > 0 ? Date.now() + maxAge * 1000 : 0
-      };
-
-      // 更新列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('addFloat_after', { key, num, maxAge, result });
-      return result;
-    } catch (error) {
-      this.emit('addFloat_error', { key, num, maxAge, error });
-      $.log.error('[cachebase] addFloat操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 增加整数（兼容方法）
-   * @param {string} key - 键名
-   * @param {number} value - 要增加的整数值
-   * @param {number} maxAge - 过期时间（秒），0表示永不过期
-   * @returns {Promise<number>} - 计算后的整数结果
-   */
-  async addInt(key, value, maxAge = 0) {
-    try {
-      this.emit('addInt_before', { key, value, maxAge });
-
-      // 原生实现整数递增逻辑
-      let currentValue = 0;
-      if (this.data.hasOwnProperty(key)) {
-        const item = this.data[key];
-        if (item.expire === 0 || Date.now() < item.expire) {
-          currentValue = parseInt(item.value, 10) || 0;
-        }
-      }
-      const result = currentValue + parseInt(value, 10);
-
-      // 设置值和过期时间
-      this.data[key] = {
-        value: result,
-        expire: maxAge > 0 ? Date.now() + maxAge * 1000 : 0
-      };
-
-      // 更新列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('addInt_after', { key, value, maxAge, result });
-      return result;
-    } catch (error) {
-      this.emit('addInt_error', { key, value, maxAge, error });
-      $.log.error('[cachebase] addInt操作失败:', error);
-      throw error;
-    }
-  }
-  /**
-   * 追加字符串（兼容方法）
-   * @param {string} key - 键名
-   * @param {string} value - 要追加的字符串
-   * @param {number} maxAge - 过期时间（秒），0表示永不过期
-   * @returns {Promise<number>} - 追加后的字符串长度
-   */
-  async addStr(key, value, maxAge = 0) {
-    try {
-      this.emit('addStr_before', { key, value, maxAge });
-
-      // 原生实现字符串追加逻辑
-      let currentValue = '';
-      let originalExpire = 0;
-
-      if (this.data.hasOwnProperty(key)) {
-        const item = this.data[key];
-        if (item.expire === 0 || Date.now() < item.expire) {
-          currentValue = String(item.value) || '';
-          originalExpire = item.expire;
-        }
-      }
-
-      const newValue = currentValue + String(value);
-      const result = newValue.length;
-
-      // 设置值和过期时间（如果提供了新的过期时间，则使用新的，否则保持原来的）
-      const expireTime = maxAge > 0 ? Date.now() + maxAge * 1000 : originalExpire;
-
-      this.data[key] = {
-        value: newValue,
-        expire: expireTime
-      };
-
-      // 更新列表
-      if (!this.list.includes(key)) {
-        this.list.push(key);
-      }
-
-      this.emit('addStr_after', { key, value, maxAge, result });
-      return result;
-    } catch (error) {
-      this.emit('addStr_error', { key, value, maxAge, error });
-      $.log.error('[cachebase] addStr操作失败:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 销毁缓存实例
-   * @returns {Promise<void>}
-   */
-  async dispose() {
-    try {
-      this.emit('dispose_before');
-
-      // 清除定时器
-      if (this.saveTimer) {
-        clearInterval(this.saveTimer);
-        this.saveTimer = null;
-        $.log.info('[cachebase] 定时保存已停止');
-      }
-
-      // 如果启用了持久化，在销毁前保存一次
-      if (this.config.persist) {
-        await this._saveData().catch(error => {
-          $.log.error('[cachebase] 销毁前保存数据失败:', error);
-        });
-      }
-
-      // 清空数据
-      this.data = {};
-      this.list = [];
-      this.dict = this.data; // 确保dict也被清空
-
-      this.emit('dispose_after');
-
-      // 移除所有监听器
-      this.removeAllListeners();
-    } catch (error) {
-      this.emit('dispose_error', { error });
-      $.log.error('[cachebase] dispose操作失败:', error);
-    }
-  }
-  /**
-   * 关闭缓存实例
-   */
-  async close() {
-    await this.dispose()
-  }
+/**
+ * CacheBase 是一个通用缓存基类，支持内存缓存和持久化缓存
+ * @class CacheBase
+ * @extends BaseService
+ */
+const {
+	BaseService
+} = require('mm_base_service');
+
+class CacheBase extends BaseService {
+	/**
+	 * 默认配置静态变量
+	 */
+	static default_config = {
+		enabled: true,
+		persist: true,
+		file_path: './test_cache/undefined.cache.json',
+		debug: false,
+		auto_save: true,
+		save_interval: 30000,
+		expire_check_interval: 1000,
+		max_size: null,
+		storage_type: 'memory'
+	};
+
+	/**
+	 * 构造函数
+	 * @param {Object} config - 配置对象
+	 */
+	constructor(config = {}) {
+		super(config);
+		// 存储实际数据
+		this._data = {};
+
+		// 存储过期时间
+		this._expires = {};
+
+		// 存储数据类型
+		this._types = {};
+
+		// 存储持久化数据的定时器
+		this._save_timer = null;
+
+		// 存储过期检查的定时器
+		this._check_timer = null;
+
+		// 初始化服务状态
+		this.is_inited = false;
+		this.is_destroyed = false;
+
+		// 初始化服务
+		this.init();
+	}
 }
 
-// 导出CacheBase类
-exports.CacheBase = CacheBase;
+/**
+ * 初始化服务
+ * @private
+ * @returns {Promise<void>}
+ */
+CacheBase.prototype._initService = async function() {
+	try {
+		// 加载配置文件中的配置 - 使用字符串路径的原型函数
+		const config_path = './config/cachebase.config.json'.fullname(__dirname);
+		if (config_path.hasFile()) {
+			// 使用mm_expand的原型函数读取JSON文件
+			const config = config_path.loadJson();
+			this.setConfig(config);
+		}
+
+		// 初始化过期检查定时器
+		this._check_timer = setInterval(() => {
+			this.clearExpire();
+		}, this.config.expire_check_interval || 1000);
+
+		// 设置最大大小限制
+		if (this.config.max_size) {
+			this._max_size = this.config.max_size;
+		}
+
+		// 加载数据
+		this._loadData();
+
+		// 设置定时保存
+		this._connect();
+
+		// 设置初始化完成状态
+		this.is_inited = true;
+	} catch (error) {
+		throw new Error('Failed to initialize service: ' + error.message);
+	}
+};
+
+/**
+ * 设置定时保存（内部方法）
+ * @private
+ */
+CacheBase.prototype._connect = function() {
+	// 如果启用了自动保存
+	if (this.config.auto_save) {
+		this._save_timer = setInterval(() => {
+			this.save();
+		}, this.config.save_interval || 30000);
+	}
+};
+
+/**
+ * 从文件加载数据
+ * @private
+ */
+CacheBase.prototype._loadData = function() {
+	try {
+		if (this.config.persist && this.config.file_path) {
+			// 使用字符串的原型函数获取完整路径
+			const file_path = this.config.file_path.fullname();
+			$.log.info(`[CacheBase] [_loadData] 尝试加载文件: ${file_path}`);
+
+			if (file_path.hasFile()) {
+				$.log.info(`[CacheBase] [_loadData] 文件存在，开始读取`);
+				// 使用mm_expand的原型函数读取JSON文件
+				const parsed_data = file_path.loadJson();
+				$.log.info(`[CacheBase] [_loadData] 文件读取成功，解析后的数据:`, Object.keys(parsed_data || {}));
+
+				if (parsed_data && parsed_data.data) {
+					this._data = parsed_data.data || {};
+					$.log.info(`[CacheBase] [_loadData] 数据加载成功，键数量:`, Object.keys(this._data).length);
+				} else {
+					$.log.warn(`[CacheBase] [_loadData] 解析后的数据中没有data字段`);
+				}
+
+				if (parsed_data && parsed_data.expires) {
+					this._expires = parsed_data.expires || {};
+				}
+
+				if (parsed_data && parsed_data.types) {
+					this._types = parsed_data.types || {};
+				}
+			} else {
+				$.log.info(`[CacheBase] [_loadData] 文件不存在: ${file_path}`);
+			}
+		} else {
+			$.log.info(`[CacheBase] [_loadData] 持久化未启用或文件路径未设置`);
+		}
+	} catch (error) {
+		$.log.error(`[CacheBase] [_loadData] 加载数据失败:`, error);
+		this.emit('error', new Error('Failed to load data: ' + error.message));
+	}
+};
+
+/**
+ * 保存数据到文件
+ */
+CacheBase.prototype.save = function() {
+	// 检查服务状态
+	if (!this.is_inited || this.is_destroyed) {
+		this.emit('error', new Error('Service is not initialized or has been destroyed'));
+		return;
+	}
+
+	try {
+		this.emit('save_before');
+		this._saveData();
+		this.emit('save_after');
+	} catch (error) {
+		this.emit('error', new Error('Failed to save data: ' + error.message));
+	}
+};
+
+/**
+ * 保存数据到文件
+ * @private
+ */
+CacheBase.prototype._saveData = function() {
+	try {
+		if (this.config.persist && this.config.file_path) {
+			// 使用字符串的原型函数获取完整路径
+			const file_path = this.config.file_path.fullname();
+
+			// 确保目录存在 - 使用目录路径的原型函数
+			file_path.addDir();
+
+			const data_to_save = {
+				data: this._data,
+				expires: this._expires,
+				types: this._types,
+				timestamp: Date.now()
+			};
+
+			// 使用mm_expand的原型函数写入JSON文件
+			file_path.saveJson(data_to_save, null, 2);
+		}
+	} catch (error) {
+		throw new Error('Failed to save data: ' + error.message);
+	}
+};
+
+/**
+ * 销毁服务
+ * @returns {Promise<void>}
+ */
+CacheBase.prototype.destroy = async function() {
+	if (this.is_destroyed) {
+		return;
+	}
+
+	// 调用父类destroy方法处理通用销毁逻辑
+	await BaseService.prototype.destroy.call(this);
+
+	try {
+		// 保存数据
+		this.save();
+
+		// 清除定时器
+		if (this._save_timer) {
+			clearInterval(this._save_timer);
+			this._save_timer = null;
+		}
+
+		if (this._check_timer) {
+			clearInterval(this._check_timer);
+			this._check_timer = null;
+		}
+
+		// 清空数据
+		this._data = {};
+		this._expires = {};
+		this._types = {};
+
+		// 设置销毁状态
+		this.is_inited = false;
+		this.is_destroyed = true;
+
+		// 触发自定义销毁事件
+		this.emit('destroy_after');
+	} catch (error) {
+		this.emit('error', new Error('Failed to destroy service: ' + error.message));
+	}
+};
+
+/**
+ * 设置键值对
+ * @param {string} key - 键名
+ * @param {*} value - 值
+ * @param {number} [ttl] - 过期时间（秒）
+ * @returns {boolean} 操作结果
+ */
+CacheBase.prototype.set = function(key, value, ttl) {
+	// 检查服务状态
+	if (!this.is_inited || this.is_destroyed) {
+		this.emit('error', new Error('Service is not initialized or has been destroyed'));
+		return false;
+	}
+
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return false;
+		}
+
+		// 触发操作前事件
+		const event_data = {
+			key,
+			value,
+			ttl,
+			cancel: false
+		};
+		this.emit('set_before', event_data);
+
+		if (event_data.cancel) {
+			return false;
+		}
+
+		// 保存数据
+		this._data[key] = value;
+
+		// 设置类型
+		this._types[key] = this._getDataTypes(value);
+
+		// 设置过期时间
+		if (ttl && typeof ttl === 'number' && ttl > 0) {
+			this._expires[key] = Date.now() + ttl * 1000;
+		} else {
+			// 清除过期时间
+			delete this._expires[key];
+		}
+
+		// 触发操作后事件
+		this.emit('set_after', {
+			key,
+			value,
+			ttl,
+			result: 'OK'
+		});
+
+		return true;
+	} catch (error) {
+		this.emit('error', new Error(`Failed to set key ${key}: ${error.message}`));
+		return false;
+	}
+};
+
+/**
+ * 获取键值
+ * @param {string} key - 键
+ * @returns {*} 值
+ */
+CacheBase.prototype.get = function(key) {
+	// 检查服务状态
+	if (!this.is_inited || this.is_destroyed) {
+		this.emit('error', new Error('Service is not initialized or has been destroyed'));
+		return null;
+	}
+
+	try {
+		// 检查是否过期
+		if (this._isExpired(key)) {
+			this.del(key);
+			return null;
+		}
+
+		return this._data[key];
+	} catch (error) {
+		this.emit('error', new Error(`Failed to get key ${key}: ${error.message}`));
+		return null;
+	}
+};
+
+/**
+ * 删除键
+ * @param {string} key - 键名
+ * @returns {boolean} 是否成功删除
+ */
+CacheBase.prototype.del = function(key) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return false;
+		}
+
+		// 触发操作前事件
+		const event_data = {
+			key,
+			cancel: false
+		};
+		this.emit('del_before', event_data);
+
+		if (event_data.cancel) {
+			return false;
+		}
+
+		// 检查键是否存在
+		if (!(key in this._data)) {
+			return false;
+		}
+
+		// 删除键
+		delete this._data[key];
+		delete this._types[key];
+		delete this._expires[key];
+
+		// 触发操作后事件
+		this.emit('del_after', {
+			key
+		});
+
+		return true;
+	} catch (error) {
+		this.emit('error', new Error(`Failed to del: ${error.message}`));
+		return false;
+	}
+};
+
+/**
+ * 批量删除键
+ * @param {Array} keys - 键名数组
+ * @returns {number} 删除的键数量
+ */
+CacheBase.prototype.delBatch = function(keys) {
+	try {
+		if (!Array.isArray(keys)) {
+			return 0;
+		}
+
+		let deletedCount = 0;
+		for (const key of keys) {
+			if (this.del(key)) {
+				deletedCount++;
+			}
+		}
+
+		return deletedCount;
+	} catch (error) {
+		this.emit('error', new Error(`Failed to delBatch: ${error.message}`));
+		return 0;
+	}
+};
+
+/**
+ * 检查键是否存在
+ * @param {string} key - 键
+ * @returns {boolean} 存在状态
+ */
+CacheBase.prototype.exists = function(key) {
+	try {
+		if (this._isExpired(key)) {
+			this.del(key);
+			return false;
+		}
+
+		return key in this._data;
+	} catch (error) {
+		this.emit('error', new Error(`Failed to check key ${key}: ${error.message}`));
+		return false;
+	}
+};
+
+/**
+ * 检查键是否存在
+ * @param {string} key - 键名
+ * @returns {boolean} 是否存在
+ */
+CacheBase.prototype.has = function(key) {
+	return this.exists(key);
+};
+
+/**
+ * 清空过期数据
+ */
+CacheBase.prototype.clearExpire = function() {
+	try {
+		const now = Date.now();
+		for (const key in this._expires) {
+			if (this._expires[key] < now) {
+				this.del(key);
+			}
+		}
+	} catch (error) {
+		this.emit('error', new Error(`Failed to clear expired data: ${error.message}`));
+	}
+};
+
+/**
+ * 检查键是否过期
+ * @private
+ * @param {string} key - 键名
+ * @returns {boolean} 是否过期
+ */
+CacheBase.prototype._isExpired = function(key) {
+	// 先检查键是否存在
+	if (!(key in this._data)) {
+		return true;
+	}
+
+	// 如果没有设置过期时间，则未过期
+	if (!(key in this._expires)) {
+		return false;
+	}
+
+	const now = Date.now();
+	const is_expired = now > this._expires[key];
+
+	// 惰性删除：如果过期了，删除键
+	if (is_expired) {
+		delete this._data[key];
+		delete this._types[key];
+		delete this._expires[key];
+	}
+
+	return is_expired;
+};
+
+/**
+ * 获取数据类型
+ * @private
+ * @param {*} value - 值
+ * @returns {string} 数据类型
+ */
+CacheBase.prototype._getDataTypes = function(value) {
+	if (value === null) return 'null';
+	if (Array.isArray(value)) return 'array';
+	return typeof value;
+};
+
+/**
+ * 设置键的过期时间
+ * @param {string} key - 键名
+ * @param {number} seconds - 过期时间（秒）
+ * @returns {boolean} 是否成功
+ */
+CacheBase.prototype.expire = function(key, seconds) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return false;
+		}
+
+		if (!Number.isInteger(seconds) || seconds <= 0) {
+			return false;
+		}
+
+		// 触发设置过期前事件
+		const event_data = {
+			key,
+			seconds,
+			cancel: false
+		};
+		this.emit('expire_before', event_data);
+
+		if (event_data.cancel) {
+			return false;
+		}
+
+		// 检查键是否存在
+		if (!(key in this._data)) {
+			return false;
+		}
+
+		// 设置过期时间
+		this._expires[key] = Date.now() + seconds * 1000;
+
+		// 触发设置过期后事件
+		this.emit('expire_after', {
+			key,
+			seconds,
+			success: true
+		});
+
+		return true;
+	} catch (error) {
+		this.emit('error', new Error(`Failed to set expire for key ${key}: ${error.message}`));
+		return false;
+	}
+};
+
+/**
+ * 设置哈希表字段
+ * @param {string} key - 哈希表键名
+ * @param {string} field - 字段名
+ * @param {*} value - 值
+ * @returns {number} 1表示新增，0表示更新或失败
+ */
+CacheBase.prototype.hset = function(key, field, value) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string' || !field || typeof field !== 'string') {
+			return 0;
+		}
+
+		// 触发设置前事件
+		const event_data = {
+			key,
+			field,
+			value,
+			cancel: false
+		};
+		this.emit('hset_before', event_data);
+
+		if (event_data.cancel) {
+			return 0;
+		}
+
+		// 初始化哈希表
+		if (!(key in this._data)) {
+			this._data[key] = {};
+			this._types[key] = 'hash';
+		} else if (this._types[key] !== 'hash') {
+			this._data[key] = {};
+			this._types[key] = 'hash';
+		}
+
+		// 检查是否是新增字段
+		const is_new_field = !(field in this._data[key]);
+
+		// 设置字段值
+		this._data[key][field] = value;
+
+		// 触发设置后事件
+		this.emit('hset_after', {
+			key,
+			field,
+			value,
+			success: true
+		});
+
+		return is_new_field ? 1 : 0;
+	} catch (error) {
+		this.emit('error', new Error(`Failed to hset for key ${key}: ${error.message}`));
+		return 0;
+	}
+};
+
+/**
+ * 获取哈希表字段值
+ * @param {string} key - 哈希表键名
+ * @param {string} field - 字段名
+ * @returns {*} 字段值
+ */
+CacheBase.prototype.hget = function(key, field) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string' || !field || typeof field !== 'string') {
+			return undefined;
+		}
+
+		// 检查是否过期
+		if (this._isExpired(key)) {
+			this.del(key);
+			return undefined;
+		}
+
+		// 检查键是否存在且类型正确
+		if (!(key in this._data) || this._types[key] !== 'hash') {
+			return undefined;
+		}
+
+		return this._data[key][field];
+	} catch (error) {
+		this.emit('error', new Error(`Failed to hget for key ${key}: ${error.message}`));
+		return undefined;
+	}
+};
+
+/**
+ * 清空所有数据
+ * @returns {boolean} 操作结果
+ */
+CacheBase.prototype.clear = function() {
+	return this.flushdb();
+};
+
+/**
+ * 获取哈希表所有字段和值
+ * @param {string} key - 哈希表键名
+ * @returns {Object} 哈希表内容
+ */
+CacheBase.prototype.hgetall = function(key) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return {};
+		}
+
+		// 检查是否过期
+		if (this._isExpired(key)) {
+			this.del(key);
+			return {};
+		}
+
+		// 检查键是否存在且类型正确
+		if (!(key in this._data) || this._types[key] !== 'hash') {
+			return {};
+		}
+
+		// 返回副本，避免直接修改
+		return {
+			...this._data[key]
+		};
+	} catch (error) {
+		this.emit('error', new Error(`Failed to hgetall for key ${key}: ${error.message}`));
+		return {};
+	}
+};
+
+/**
+ * 删除哈希表字段
+ * @param {string} key - 哈希表键名
+ * @param {string|Array<string>} field - 字段名或字段名数组
+ * @returns {boolean} 是否成功删除
+ */
+CacheBase.prototype.hdel = function(key, field) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return false;
+		}
+
+		// 触发操作前事件
+		const event_data = {
+			key,
+			field,
+			cancel: false
+		};
+		this.emit('hdel_before', event_data);
+
+		if (event_data.cancel) {
+			return false;
+		}
+
+		// 检查是否过期
+		if (this._isExpired(key)) {
+			this.del(key);
+			this.emit('hdel_after', {
+				key,
+				field,
+				success: false
+			});
+			return false;
+		}
+
+		// 检查键是否存在且类型正确
+		if (!(key in this._data) || this._types[key] !== 'hash') {
+			this.emit('hdel_after', {
+				key,
+				field,
+				success: false
+			});
+			return false;
+		}
+
+		// 处理字段参数，支持单个字段或字段数组
+		const fields = Array.isArray(field) ? field : [field];
+		let deleted = false;
+
+		// 遍历所有字段进行删除
+		for (const f of fields) {
+			if (typeof f === 'string' && f && f in this._data[key]) {
+				delete this._data[key][f];
+				deleted = true;
+			}
+		}
+
+		// 如果哈希表为空，删除整个键
+		if (deleted && Object.keys(this._data[key]).length === 0) {
+			delete this._data[key];
+			delete this._types[key];
+			delete this._expires[key];
+		}
+
+		// 触发操作后事件
+		this.emit('hdel_after', {
+			key,
+			field,
+			success: deleted
+		});
+
+		return deleted;
+	} catch (error) {
+		this.emit('hdel_error', {
+			key,
+			field,
+			error
+		});
+		this.emit('error', new Error(`Failed to hdel: ${error.message}`));
+		return false;
+	}
+};
+
+/**
+ * 增加键的数值
+ * @param {string} key - 键名
+ * @param {number} value - 增加的值（默认为1）
+ * @returns {number} 增加后的值
+ */
+CacheBase.prototype.incrby = function(key, value) {
+	// 参数验证
+	if (!key || typeof key !== 'string' || typeof value !== 'number') {
+		return 0;
+	}
+
+	// 确保_data对象存在
+	if (!this._data) {
+		this._data = {};
+	}
+
+	// 获取当前值，如果存在则使用，不存在则为0
+	let current = 0;
+	if (key in this._data) {
+		// 尝试将现有值转换为数字
+		current = Number(this._data[key]) || 0;
+	}
+
+	// 增加指定值
+	const newValue = current + value;
+
+	// 保存新值
+	this._data[key] = newValue;
+
+	// 确保_types对象存在并设置类型
+	if (!this._types) {
+		this._types = {};
+	}
+	this._types[key] = 'number';
+
+	// 清理过期时间
+	if (this._expires && this._expires[key]) {
+		delete this._expires[key];
+	}
+
+	return newValue;
+};
+
+/**
+ * 增加键的数值（增加1）
+ * @param {string} key - 键名
+ * @param {number} seconds - 过期时间（秒），0表示永不过期
+ * @returns {number|null} 增加后的值，失败返回null
+ */
+CacheBase.prototype.incr = function(key, seconds = 0) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			$.log.error('[cachebase] incr参数错误: key必须是非空字符串');
+			return 0;
+		}
+
+		this.emit('incr_before', {
+			key,
+			ttl: seconds,
+			cancel: false
+		});
+
+		// 确保_data对象存在
+		if (!this._data) {
+			this._data = {};
+		}
+
+		// 获取当前值，如果存在则使用，不存在则为0
+		let current = 0;
+		if (key in this._data && !this._isExpired(key)) {
+			current = Number(this._data[key]) || 0;
+		}
+
+		// 增加1
+		const newValue = current + 1;
+
+		// 保存新值
+		this._data[key] = newValue;
+		this._types[key] = 'number';
+
+		if (seconds > 0) {
+			this._expires[key] = Date.now() + seconds * 1000;
+		} else {
+			delete this._expires[key];
+		}
+
+		this.emit('incr_after', {
+			key,
+			ttl: seconds,
+			success: true,
+			result: newValue
+		});
+		return newValue;
+	} catch (error) {
+		this.emit('incr_error', {
+			key,
+			ttl: seconds,
+			error
+		});
+		$.log.error('[cachebase] incr操作失败:', error);
+		return 0;
+	}
+};
+
+CacheBase.prototype.decrby = function(key, value) {
+	// 参数验证
+	if (!key || typeof key !== 'string' || typeof value !== 'number') {
+		return 0;
+	}
+
+	// 确保_data对象存在
+	if (!this._data) {
+		this._data = {};
+	}
+
+	// 获取当前值，如果存在则使用，不存在则为0
+	let current = 0;
+	if (key in this._data) {
+		// 尝试将现有值转换为数字
+		current = Number(this._data[key]) || 0;
+	}
+
+	// 减少指定值
+	const newValue = current - value;
+
+	// 保存新值
+	this._data[key] = newValue;
+
+	// 确保_types对象存在并设置类型
+	if (!this._types) {
+		this._types = {};
+	}
+	this._types[key] = 'number';
+
+	// 清理过期时间
+	if (this._expires && this._expires[key]) {
+		delete this._expires[key];
+	}
+
+	return newValue;
+};
+
+/**
+ * 减少键的数值（减少1）
+ * @param {string} key - 键名
+ * @param {number} seconds - 过期时间（秒），0表示永不过期
+ * @returns {number} 减少后的值
+ */
+CacheBase.prototype.decr = function(key, seconds = 0) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			$.log.error('[cachebase] decr参数错误: key必须是非空字符串');
+			return 0;
+		}
+
+		this.emit('decr_before', {
+			key,
+			ttl: seconds,
+			cancel: false
+		});
+
+		// 确保_data对象存在
+		if (!this._data) {
+			this._data = {};
+		}
+
+		// 获取当前值，如果存在则使用，不存在则为0
+		let current = 0;
+		if (key in this._data && !this._isExpired(key)) {
+			current = Number(this._data[key]) || 0;
+		}
+
+		// 减少1
+		const newValue = current - 1;
+
+		// 保存新值
+		this._data[key] = newValue;
+		this._types[key] = 'number';
+
+		if (seconds > 0) {
+			this._expires[key] = Date.now() + seconds * 1000;
+		} else {
+			delete this._expires[key];
+		}
+
+		this.emit('decr_after', {
+			key,
+			ttl: seconds,
+			success: true,
+			result: newValue
+		});
+		return newValue;
+	} catch (error) {
+		this.emit('decr_error', {
+			key,
+			ttl: seconds,
+			error
+		});
+		$.log.error('[cachebase] decr操作失败:', error);
+		return 0;
+	}
+};
+
+/**
+ * 增加整数值（兼容方法）
+ * @param {string} key - 键名
+ * @param {number} value - 要增加的整数值
+ * @param {number} seconds - 过期时间（秒），0表示永不过期
+ * @returns {Promise<number>} - 返回增加后的值
+ */
+CacheBase.prototype.addInt = function(key, value, seconds = 0) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string' || typeof value !== 'number') {
+			$.log.error('[cachebase] addInt参数错误: key必须是非空字符串，value必须是数字');
+			return 0;
+		}
+
+		this.emit('addInt_before', {
+			key,
+			value,
+			ttl: seconds,
+			cancel: false
+		});
+
+		// 实现整数递增逻辑
+		let currentValue = 0;
+		if (key in this._data && !this._isExpired(key)) {
+			currentValue = parseInt(this._data[key], 10) || 0;
+		}
+		const result = Math.floor(currentValue + parseInt(value, 10));
+
+		// 设置值和过期时间
+		this._data[key] = result;
+		this._types[key] = 'number';
+
+		if (seconds > 0) {
+			this._expires[key] = Date.now() + seconds * 1000;
+		} else {
+			delete this._expires[key];
+		}
+
+		this.emit('addInt_after', {
+			key,
+			value,
+			ttl: seconds,
+			success: true,
+			result
+		});
+		return result;
+	} catch (error) {
+		this.emit('addInt_error', {
+			key,
+			value,
+			ttl: seconds,
+			error
+		});
+		$.log.error('[cachebase] addInt操作失败:', error);
+		return 0;
+	}
+};
+
+/**
+ * 向字符串末尾追加内容
+ * @param {string} key - 键名
+ * @param {string} append - 要追加的内容
+ * @returns {number|null} 追加后的字符串长度，失败返回null
+ */
+CacheBase.prototype.append = function(key, append) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string' || typeof append !== 'string') {
+			return null;
+		}
+
+		// 检查是否过期
+		if (this._isExpired(key)) {
+			this.del(key);
+			return null;
+		}
+
+		// 获取当前值
+		let current = '';
+
+		// 如果键存在且是字符串，使用当前值
+		if (key in this._data && typeof this._data[key] === 'string') {
+			current = this._data[key];
+		}
+
+		// 追加内容
+		current += append;
+		this._data[key] = current;
+		this._types[key] = 'string';
+
+		return current.length;
+	} catch (error) {
+		this.emit('error', new Error(`Failed to append for key ${key}: ${error.message}`));
+		return null;
+	}
+};
+
+/**
+ * 获取字符串长度
+ * @param {string} key - 键名
+ * @returns {number} 字符串长度，不存在返回0
+ */
+CacheBase.prototype.strlen = function(key) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return 0;
+		}
+
+		// 检查是否过期
+		if (this._isExpired(key)) {
+			this.del(key);
+			return 0;
+		}
+
+		// 检查键是否存在
+		if (!(key in this._data)) {
+			return 0;
+		}
+
+		// 检查值类型
+		if (typeof this._data[key] !== 'string') {
+			return 0;
+		}
+
+		return this._data[key].length;
+	} catch (error) {
+		this.emit('error', new Error(`Failed to strlen for key ${key}: ${error.message}`));
+		return 0;
+	}
+};
+
+/**
+ * 清空所有数据库键
+ * @returns {boolean} 操作结果
+ */
+CacheBase.prototype.flushdb = function() {
+	try {
+		// 触发操作前事件
+		const event_data = {
+			cancel: false
+		};
+		this.emit('flushdb_before', event_data);
+
+		if (event_data.cancel) {
+			return false;
+		}
+
+		// 清空所有数据
+		this._data = {};
+		this._expires = {};
+		this._types = {};
+
+		// 触发操作后事件
+		this.emit('flushdb_after', {
+			success: true
+		});
+
+		return true;
+	} catch (error) {
+		this.emit('error', new Error(`Failed to flushdb: ${error.message}`));
+		return false;
+	}
+};
+/**
+ * 获取所有键名
+ * @param {string} [pattern] - 键名匹配模式，支持*通配符
+ * @returns {Array} 所有键名数组
+ */
+CacheBase.prototype.keys = function(pattern) {
+	try {
+		const result = [];
+		for (const key in this._data) {
+			// 调用_is_expired方法检查过期并自动删除，无需再调用del
+			if (!this._isExpired(key)) {
+				// 添加基于pattern的键过滤条件
+				if (!pattern || this._matchPattern(key, pattern)) {
+					result.push(key);
+				}
+			}
+		}
+		return result;
+	} catch (error) {
+		this.emit('error', new Error(`Failed to get keys: ${error.message}`));
+		return [];
+	}
+};
+
+/**
+ * 检查键是否匹配指定模式
+ * @private
+ * @param {string} key - 要检查的键名
+ * @param {string} pattern - 匹配模式，支持*通配符
+ * @returns {boolean} 是否匹配
+ */
+CacheBase.prototype._matchPattern = function(key, pattern) {
+	// 将模式转换为正则表达式
+	try {
+		var regexPattern = pattern
+			.replace(/[.+?^${}()|[\\]/g, '\\$&')
+			.replace(/\*/g, '.*');
+		var regex = new RegExp('^' + regexPattern + '$');
+		return regex.test(key);
+	} catch (error) {
+		// 如果正则表达式无效，返回false
+		return false;
+	}
+};
+
+/**
+ * 获取键的数量
+ * @returns {number} 键的数量
+ */
+CacheBase.prototype.dbsize = function() {
+	try {
+		// 计算未过期的键数量
+		let count = 0;
+		for (const key in this._data) {
+			if (!this._isExpired(key)) {
+				count++;
+			}
+		}
+		return count;
+	} catch (error) {
+		this.emit('error', new Error(`Failed to get dbsize: ${error.message}`));
+		return 0;
+	}
+};
+
+/**
+ * 增加浮点数（兼容方法）
+ * @param {string} key - 键名
+ * @param {number} value - 增加的浮点数
+ * @param {number} seconds - 过期时间（秒），0表示永不过期
+ * @returns {number} 增加后的值，失败返回0
+ */
+CacheBase.prototype.incrbyfloat = function(key, value = 1.0, seconds = 0) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string' || typeof value !== 'number') {
+			$.log.error('[cachebase] incrbyfloat参数错误: key必须是非空字符串，value必须是数字');
+			return 0;
+		}
+
+		this.emit('incrbyfloat_before', {
+			key,
+			value,
+			ttl: seconds,
+			cancel: false
+		});
+
+		// 确保_data对象存在
+		if (!this._data) {
+			this._data = {};
+		}
+
+		// 获取当前值，如果存在则使用，不存在则为0
+		let current = 0;
+		if (key in this._data && !this._isExpired(key)) {
+			current = Number(this._data[key]) || 0;
+		}
+
+		// 增加指定值
+		const newValue = current + value;
+
+		// 保存新值
+		this._data[key] = newValue;
+		this._types[key] = 'number';
+
+		if (seconds > 0) {
+			this._expires[key] = Date.now() + seconds * 1000;
+		} else {
+			delete this._expires[key];
+		}
+
+		this.emit('incrbyfloat_after', {
+			key,
+			value,
+			ttl: seconds,
+			success: true,
+			result: newValue
+		});
+		return newValue;
+	} catch (error) {
+		this.emit('incrbyfloat_error', {
+			key,
+			value,
+			ttl: seconds,
+			error
+		});
+		$.log.error('[cachebase] incrbyfloat操作失败:', error);
+		return 0;
+	}
+};
+
+/**
+ * 获取并设置值
+ * @param {string} key - 键名
+ * @param {*} value - 新值
+ * @param {number} expire - 过期时间（毫秒）
+ * @returns {*} 旧值
+ */
+CacheBase.prototype.getset = function(key, value, expire) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return null;
+		}
+
+		// 获取旧值
+		const oldValue = this.get(key);
+
+		// 设置新值
+		this.set(key, value, expire);
+
+		return oldValue;
+	} catch (error) {
+		this.emit('error', new Error(`Failed to getset: ${error.message}`));
+		return null;
+	}
+};
+
+/**
+ * 增加整数值 - 兼容方法
+ * @param {string} key - 键名
+ * @param {*} value - 要设置的值
+ * @param {number} maxAge - 过期时间（秒），0表示永不过期
+ * @returns {Promise<boolean>} - 操作结果，键不存在并设置成功返回true，键已存在返回false
+ */
+CacheBase.prototype.add = function(key, value, maxAge = 0) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			$.log.error('[cachebase] add参数错误: key必须是非空字符串');
+			return false;
+		}
+
+		// 触发前置事件
+		const beforeEventData = {
+			key,
+			value,
+			maxAge,
+			cancel: false
+		};
+		this.emit('add_before', beforeEventData);
+
+		if (beforeEventData.cancel) {
+			$.log.debug(`[cachebase] add操作被事件处理器取消 [${key}]`);
+			return false;
+		}
+
+		const {
+			key: finalKey,
+			value: finalValue,
+			maxAge: finalMaxAge
+		} = beforeEventData;
+
+		// 检查键是否存在且未过期
+		if (finalKey in this._data && !this._isExpired(finalKey)) {
+			// 键已存在，返回false
+			this.emit('add_after', {
+				key: finalKey,
+				value: finalValue,
+				maxAge: finalMaxAge,
+				success: false
+			});
+			return false;
+		}
+
+		// 键不存在，设置新值
+		this._data[finalKey] = finalValue;
+		this._types[finalKey] = this._getDataTypes(finalValue);
+
+		// 设置过期时间
+		if (finalMaxAge > 0) {
+			this._expires[finalKey] = Date.now() + finalMaxAge * 1000;
+		} else {
+			delete this._expires[finalKey];
+		}
+
+		// 触发后置事件
+		this.emit('add_after', {
+			key: finalKey,
+			value: finalValue,
+			maxAge: finalMaxAge,
+			success: true
+		});
+		return true;
+	} catch (error) {
+		$.log.error(`[cachebase] add操作失败 [${key}]:`, error);
+		this.emit('add_error', {
+			key,
+			value,
+			maxAge,
+			error
+		});
+		return false;
+	}
+};
+
+/**
+ * 增加浮点数（兼容方法）
+ * @param {string} key - 键名
+ * @param {number} num - 要增加的浮点数值
+ * @param {number} seconds - 过期时间（秒），0表示永不过期
+ * @returns {Promise<number>} - 返回增加后的值
+ */
+CacheBase.prototype.addFloat = function(key, num, seconds = 0) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string' || typeof num !== 'number') {
+			$.log.error('[cachebase] addFloat参数错误: key必须是非空字符串，num必须是数字');
+			return 0;
+		}
+
+		this.emit('addFloat_before', {
+			key,
+			num,
+			ttl: seconds,
+			cancel: false
+		});
+
+		// 实现浮点数递增逻辑
+		let currentValue = 0;
+		if (key in this._data && !this._isExpired(key)) {
+			currentValue = Number(this._data[key]) || 0;
+		}
+		const result = currentValue + Number(num);
+
+		// 设置值和过期时间
+		this._data[key] = result;
+		this._types[key] = 'number';
+
+		if (seconds > 0) {
+			this._expires[key] = Date.now() + seconds * 1000;
+		} else {
+			delete this._expires[key];
+		}
+
+		this.emit('addFloat_after', {
+			key,
+			num,
+			ttl: seconds,
+			success: true,
+			result
+		});
+		return result;
+	} catch (error) {
+		this.emit('addFloat_error', {
+			key,
+			num,
+			ttl: seconds,
+			error
+		});
+		$.log.error('[cachebase] addFloat操作失败:', error);
+		return 0;
+	}
+};
+
+/**
+ * 追加字符串（兼容方法）
+ * @param {string} key - 键名
+ * @param {string} value - 要追加的字符串
+ * @param {number} seconds - 过期时间（秒），0表示永不过期
+ * @returns {Promise<number>} - 返回追加后字符串的长度
+ */
+CacheBase.prototype.addStr = function(key, value, seconds = 0) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string' || typeof value !== 'string') {
+			$.log.error('[cachebase] addStr参数错误: key和value必须是非空字符串');
+			return 0;
+		}
+
+		this.emit('addStr_before', {
+			key,
+			value,
+			ttl: seconds,
+			cancel: false
+		});
+
+		// 实现字符串追加逻辑
+		let currentValue = '';
+		if (key in this._data && !this._isExpired(key)) {
+			currentValue = String(this._data[key]) || '';
+		}
+		const result = currentValue + value;
+		const length = result.length;
+
+		// 设置值和过期时间
+		this._data[key] = result;
+		this._types[key] = 'string';
+
+		if (seconds > 0) {
+			this._expires[key] = Date.now() + seconds * 1000;
+		} else {
+			delete this._expires[key];
+		}
+
+		this.emit('addStr_after', {
+			key,
+			value,
+			ttl: seconds,
+			result,
+			length,
+			success: true
+		});
+		return length;
+	} catch (error) {
+		this.emit('addStr_error', {
+			key,
+			value,
+			ttl: seconds,
+			error
+		});
+		$.log.error('[cachebase] addStr操作失败:', error);
+		return 0;
+	}
+};
+
+/**
+ * 一次性设置多个键值对 - 兼容Redis的MSET命令
+ * @param {string} key1, value1, key2, value2... - 键值对参数列表
+ * @returns {boolean} - 成功返回true，失败返回false
+ */
+CacheBase.prototype.mset = function(...args) {
+	try {
+		// 参数验证 - 特别处理null参数情况
+		if (args.length === 1 && args[0] === null) {
+			const error = new Error('mset参数必须是对象');
+			this.emit('mset_error', {
+				args,
+				error
+			});
+			throw error;
+		}
+
+		// 常规参数验证
+		if (args.length === 0 || args.length % 2 !== 0) {
+			$.log.error('[CacheBase] [mset] 参数错误: 参数数量必须为偶数');
+			const error = new Error('参数数量必须为偶数');
+			this.emit('mset_error', {
+				args,
+				error
+			});
+			throw error;
+		}
+
+		// 将参数列表转换为键值对对象
+		const keyValuePairs = {};
+		for (let i = 0; i < args.length; i += 2) {
+			const key = args[i];
+			const value = args[i + 1];
+
+			if (typeof key !== 'string' || !key) {
+				$.log.error(`[CacheBase] [mset] 参数错误: 键 ${key} 必须是非空字符串`);
+				const error = new Error('键必须是非空字符串');
+				this.emit('mset_error', {
+					args,
+					error
+				});
+				throw error;
+			}
+
+			keyValuePairs[key] = value;
+		}
+
+		// 触发前置事件
+		const beforeEventData = {
+			keyValuePairs,
+			cancel: false
+		};
+		this.emit('mset_before', beforeEventData);
+
+		if (beforeEventData.cancel) {
+			$.log.debug('[CacheBase] [mset] 操作被事件处理器取消');
+			return false;
+		}
+
+		const {
+			keyValuePairs: finalKeyValuePairs
+		} = beforeEventData;
+
+		// 批量设置键值对
+		for (const [key, value] of Object.entries(finalKeyValuePairs)) {
+			// 检查键是否过期
+			if (this._isExpired(key)) {
+				this.del(key);
+			}
+
+			// 保存数据
+			this._data[key] = value;
+			// 设置数据类型
+			this._types[key] = this._getDataTypes(value);
+			// 清除过期时间（与Redis MSET一致）
+			delete this._expires[key];
+		}
+
+		// 触发后置事件
+		this.emit('mset_after', {
+			keyValuePairs: finalKeyValuePairs,
+			result: true,
+			success: true
+		});
+		return true;
+	} catch (error) {
+		// 确保触发错误事件
+		this.emit('mset_error', {
+			args,
+			error
+		});
+		this.emit('error', new Error(`Failed to mset: ${error.message}`));
+		throw error;
+	}
+};
+
+/**
+ * 获取或设置键的过期时间
+ * @param {String} key 键名
+ * @param {Number} [seconds] 过期时间（秒），不传此参数则获取剩余过期时间
+ * @return {Promise<Number|Boolean>} 不传seconds时返回剩余过期时间（-1表示无过期设置，-2表示已过期），传seconds时返回是否设置成功
+ */
+CacheBase.prototype.ttl = function(key, seconds) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return arguments.length === 1 ? -2 : false;
+		}
+
+		// 判断是否为设置过期时间模式
+		if (arguments.length > 1) {
+			// 设置过期时间模式
+			if (typeof seconds !== 'number' || seconds < 0) {
+				return false;
+			}
+
+			// 检查键是否存在
+			if (!(key in this._data)) {
+				return false;
+			}
+
+			// 检查是否过期
+			if (this._isExpired(key)) {
+				this.del(key);
+				return false;
+			}
+
+			// 设置过期时间
+			if (seconds > 0) {
+				this._expires[key] = Date.now() + (seconds * 1000);
+			} else if (seconds === 0) {
+				// 移除过期时间
+				delete this._expires[key];
+			}
+
+			return true;
+		} else {
+			// 获取剩余过期时间模式
+			// 检查键是否存在
+			if (!(key in this._data)) {
+				return -2;
+			}
+
+			// 检查是否过期
+			if (this._isExpired(key)) {
+				this.del(key);
+				return -2;
+			}
+
+			// 检查是否设置了过期时间
+			if (!(key in this._expires)) {
+				return -1; // 无过期时间
+			}
+
+			// 计算剩余时间
+			const now = Date.now();
+			const remaining = this._expires[key] - now;
+
+			return Math.max(0, Math.ceil(remaining / 1000));
+		}
+	} catch (error) {
+		const errorMsg = arguments.length > 1 
+			? `Failed to set ttl for key ${key}: ${error.message}`
+			: `Failed to get ttl for key ${key}: ${error.message}`;
+		this.emit('error', new Error(errorMsg));
+		return arguments.length > 1 ? false : -2;
+	}
+};
+
+/**
+ * 移除键的过期时间
+ * @param {string} key - 键名
+ * @returns {boolean} 是否成功移除
+ */
+CacheBase.prototype.persist = function(key) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return false;
+		}
+
+		// 触发操作前事件
+		const event_data = {
+			key,
+			cancel: false
+		};
+		this.emit('persist_before', event_data);
+
+		if (event_data.cancel) {
+			return false;
+		}
+
+		// 检查键是否存在
+		if (!(key in this._data)) {
+			return false;
+		}
+
+		// 检查是否过期
+		if (this._isExpired(key)) {
+			this.del(key);
+			return false;
+		}
+
+		// 移除过期时间
+		if (key in this._expires) {
+			delete this._expires[key];
+
+			// 触发操作后事件
+			this.emit('persist_after', {
+				key
+			});
+			return true;
+		}
+
+		return false; // 键没有设置过期时间
+	} catch (error) {
+		this.emit('error', new Error(`Failed to persist key ${key}: ${error.message}`));
+		return false;
+	}
+};
+/**
+ * 批量获取多个键的值
+ * @param {Array} keys - 键名数组
+ * @returns {Array} 值数组，按键的顺序返回
+ */
+CacheBase.prototype.mget = function(keys) {
+	try {
+		// 参数验证
+		if (!Array.isArray(keys)) {
+			return [];
+		}
+
+		const results = [];
+
+		// 批量获取值
+		for (const key of keys) {
+			if (typeof key === 'string') {
+				results.push(this.get(key));
+			} else {
+				results.push(null);
+			}
+		}
+
+		return results;
+	} catch (error) {
+		this.emit('error', new Error(`Failed to mget: ${error.message}`));
+		return [];
+	}
+};
 
+/**
+ * 清理资源并销毁实例
+ * @returns {boolean} 操作结果
+ */
+CacheBase.prototype.dispose = function() {
+	try {
+		// 清除定时任务
+		if (this._auto_save_timer) {
+			clearInterval(this._auto_save_timer);
+			this._auto_save_timer = null;
+		}
+
+		// 清除所有数据
+		this._data = {};
+		this._expires = {};
+		this._types = {};
+
+		// 触发销毁事件
+		this.emit('destroy', {
+			success: true
+		});
+
+		return true;
+	} catch (error) {
+		this.emit('error', new Error(`Failed to dispose: ${error.message}`));
+		return false;
+	}
+};
 
 /**
  * 确保连接池对象存在
  */
-if (!$.pool) {
-  $.pool = {};
+global.$ = global.$ || {};
+if (!global.$.pool) {
+	global.$.pool = {};
 }
-if (!$.pool.cachebase) {
-  $.pool.cachebase = {};
+if (!global.$.pool.cachebase) {
+	global.$.pool.cachebase = {};
 }
 
 /**
@@ -1636,18 +1769,560 @@ if (!$.pool.cachebase) {
  * @return {Object} 返回一个cachebase类实例
  */
 function cachebase_admin(scope, dir) {
-  if (!scope) {
-    scope = 'sys';
-  }
-  var obj = $.pool.cachebase[scope];
-  if (!obj) {
-    $.pool.cachebase[scope] = new CacheBase(scope, dir);
-    obj = $.pool.cachebase[scope];
-  }
-  return obj;
+	if (!scope) {
+		scope = 'sys';
+	}
+	var obj = global.$.pool.cachebase[scope];
+	if (!obj) {
+		const config = {
+			file_path: dir ? `./cachebase_${scope}.json`.fullname(dir) : `/cache/cachebase_${scope}.json`
+		};
+		global.$.pool.cachebase[scope] = new CacheBase(config);
+		obj = global.$.pool.cachebase[scope];
+	}
+	return obj;
 }
 
 /**
- * @module 导出cachebase管理器
+ * 设置列表
+ * @param {string} key - 键名
+ * @param {Array} value - 列表值
+ * @param {number} [maxAge=0] - 过期时间（秒），0表示永不过期
+ * @returns {Promise<number>} - 列表长度
+ */
+CacheBase.prototype.setForList = async function(key, value, maxAge = 0) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			throw new Error('key必须是非空字符串');
+		}
+
+		// 确保value是数组
+		let stringValues = [];
+		if (Array.isArray(value)) {
+			stringValues = value.map(item => String(item));
+		} else {
+			stringValues = [String(value)];
+		}
+
+		// 触发前置事件
+		const beforeEventData = {
+			key,
+			value,
+			maxAge,
+			cancel: false
+		};
+		this.emit('setForList_before', beforeEventData);
+
+		if (beforeEventData.cancel) {
+			$.log.debug(`[CacheBase] setForList操作被事件处理器取消 [${key}]`);
+			return 0;
+		}
+
+		// 检查键是否存在且未过期
+		if (key in this._data && !this._isExpired(key)) {
+			// 如果已存在但不是数组，删除并重新设置
+			if (!Array.isArray(this._data[key])) {
+				delete this._data[key];
+				delete this._types[key];
+				delete this._expires[key];
+			}
+		}
+
+		// 设置列表数据
+		this._data[key] = stringValues;
+		this._types[key] = 'array';
+
+		// 设置过期时间
+		if (maxAge > 0) {
+			this._expires[key] = Date.now() + maxAge * 1000;
+		} else {
+			delete this._expires[key];
+		}
+
+		const length = stringValues.length;
+
+		// 触发后置事件
+		this.emit('setForList_after', {
+			key,
+			value: stringValues,
+			maxAge,
+			result: length
+		});
+		return length;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('setForList_error', {
+			key,
+			value,
+			maxAge,
+			error
+		});
+		$.log.error('[CacheBase] setForList操作失败:', error);
+		throw error;
+	}
+};
+
+/**
+ * 向列表添加元素
+ * @param {string} key - 键名
+ * @param {*} value - 要添加的元素
+ * @param {number} [maxAge=0] - 过期时间（秒），0表示永不过期
+ * @returns {Promise<number>} - 添加后列表长度
+ */
+CacheBase.prototype.addForList = async function(key, value, maxAge = 0) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			throw new Error('key必须是非空字符串');
+		}
+
+		// 确保value是字符串
+		const stringValue = String(value);
+
+		// 触发前置事件
+		const beforeEventData = {
+			key,
+			value,
+			maxAge,
+			cancel: false
+		};
+		this.emit('addForList_before', beforeEventData);
+
+		if (beforeEventData.cancel) {
+			$.log.debug(`[CacheBase] addForList操作被事件处理器取消 [${key}]`);
+			return 0;
+		}
+
+		// 检查键是否存在且未过期
+		if (key in this._data && !this._isExpired(key)) {
+			// 如果已存在但不是数组，删除并重新设置为数组
+			if (!Array.isArray(this._data[key])) {
+				this._data[key] = [stringValue];
+				this._types[key] = 'array';
+			} else {
+				// 向现有数组添加元素
+				this._data[key].push(stringValue);
+			}
+		} else {
+			// 键不存在或已过期，创建新数组
+			this._data[key] = [stringValue];
+			this._types[key] = 'array';
+		}
+
+		// 设置过期时间
+		if (maxAge > 0) {
+			this._expires[key] = Date.now() + maxAge * 1000;
+		} else if (key in this._expires) {
+			delete this._expires[key];
+		}
+
+		const length = this._data[key].length;
+
+		// 触发后置事件
+		this.emit('addForList_after', {
+			key,
+			value: stringValue,
+			maxAge,
+			result: length
+		});
+		return length;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('addForList_error', {
+			key,
+			value,
+			maxAge,
+			error
+		});
+		$.log.error('[CacheBase] addForList操作失败:', error);
+		throw error;
+	}
+};
+
+/**
+ * 检查列表中是否包含指定元素
+ * @param {string} key - 键名
+ * @param {*} value - 要检查的元素
+ * @returns {Promise<boolean>} - 是否包含
+ */
+CacheBase.prototype.hasForList = async function(key, value) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return false;
+		}
+
+		// 确保value是字符串
+		const stringValue = String(value);
+
+		// 触发前置事件
+		const beforeEventData = {
+			key,
+			value,
+			cancel: false
+		};
+		this.emit('hasForList_before', beforeEventData);
+
+		if (beforeEventData.cancel) {
+			$.log.debug(`[CacheBase] hasForList操作被事件处理器取消 [${key}]`);
+			return false;
+		}
+
+		// 检查键是否存在且未过期
+		if (key in this._data && !this._isExpired(key)) {
+			// 检查是否为数组
+			if (Array.isArray(this._data[key])) {
+				// 检查数组中是否包含指定元素
+				const result = this._data[key].includes(stringValue);
+				// 触发后置事件
+				this.emit('hasForList_after', {
+					key,
+					value,
+					result
+				});
+				return result;
+			}
+		}
+
+		// 键不存在、已过期或不是数组
+		this.emit('hasForList_after', {
+			key,
+			value,
+			result: 0
+		});
+		return false;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('hasForList_error', {
+			key,
+			value,
+			error
+		});
+		$.log.error('[CacheBase] hasForList操作失败:', error);
+		throw error;
+	}
+};
+
+/**
+ * 获取列表
+ * @param {string} key - 键名
+ * @param {number} [start=0] - 起始索引
+ * @param {number} [stop=-1] - 结束索引，-1表示全部
+ * @returns {Promise<Array>} - 列表数组
+ */
+CacheBase.prototype.getForList = async function(key, start = 0, stop = -1) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return [];
+		}
+
+		// 触发前置事件
+		const beforeEventData = {
+			key,
+			start,
+			stop,
+			cancel: false
+		};
+		this.emit('getForList_before', beforeEventData);
+
+		if (beforeEventData.cancel) {
+			$.log.debug(`[CacheBase] getForList操作被事件处理器取消 [${key}]`);
+			return [];
+		}
+
+		// 检查键是否存在且未过期
+		if (key in this._data && !this._isExpired(key)) {
+			// 检查是否为数组
+			if (Array.isArray(this._data[key])) {
+				const array = this._data[key];
+
+				// 处理负索引
+				const startIndex = start < 0 ? Math.max(0, array.length + start) : start;
+				const endIndex = stop < 0 ? array.length : stop + 1;
+
+				// 截取数组
+				const result = array.slice(startIndex, endIndex);
+
+				// 触发后置事件
+				this.emit('getForList_after', {
+					key,
+					start,
+					stop,
+					result
+				});
+				return result;
+			}
+		}
+
+		// 键不存在、已过期或不是数组
+		this.emit('getForList_after', {
+			key,
+			start,
+			stop,
+			result: []
+		});
+		return [];
+	} catch (error) {
+		// 触发错误事件
+		this.emit('getForList_error', {
+			key,
+			start,
+			stop,
+			error
+		});
+		$.log.error('[CacheBase] getForList操作失败:', error);
+		throw error;
+	}
+};
+
+/**
+ * 清空列表
+ * @param {string} key - 键名
+ * @returns {Promise<boolean>} - 操作结果
+ */
+CacheBase.prototype.clearForList = async function(key) {
+	try {
+		// 参数验证
+		if (!key || typeof key !== 'string') {
+			return false;
+		}
+
+		// 触发前置事件
+		const beforeEventData = {
+			key,
+			cancel: false
+		};
+		this.emit('clearForList_before', beforeEventData);
+
+		if (beforeEventData.cancel) {
+			$.log.debug(`[CacheBase] clearForList操作被事件处理器取消 [${key}]`);
+			return false;
+		}
+
+		// 检查键是否存在且未过期
+		if (key in this._data && !this._isExpired(key)) {
+			// 检查是否为数组
+			if (Array.isArray(this._data[key])) {
+				// 清空数组
+				this._data[key] = [];
+
+				// 触发后置事件
+				this.emit('clearForList_after', {
+					key,
+					result: true
+				});
+				return true;
+			} else {
+				// 如果不是数组，删除键
+				delete this._data[key];
+				delete this._types[key];
+				delete this._expires[key];
+
+				// 触发后置事件
+				this.emit('clearForList_after', {
+					key,
+					result: false
+				});
+				return false;
+			}
+		}
+
+		// 键不存在或已过期，创建空数组
+		this._data[key] = [];
+		this._types[key] = 'array';
+
+		// 触发后置事件
+		this.emit('clearForList_after', {
+			key,
+			result: true
+		});
+		return true;
+	} catch (error) {
+		// 触发错误事件
+		this.emit('clearForList_error', {
+			key,
+			error
+		});
+		$.log.error('[CacheBase] clearForList操作失败:', error);
+		throw error;
+	}
+};
+
+/**
+ * 批量设置哈希表字段
+ * @param {string} key - 哈希表键名
+ * @param {Object} obj - 包含多个字段的对象
+ * @returns {Promise<boolean>} - 操作结果
+ */
+CacheBase.prototype.hmset = function(key, obj) {
+	return new Promise((resolve) => {
+		try {
+			// 参数验证
+			if (!key || typeof key !== 'string' || !obj || typeof obj !== 'object' || Array.isArray(obj)) {
+				resolve(false);
+				return;
+			}
+
+			// 触发前置事件
+			const beforeEventData = {
+				key,
+				obj,
+				cancel: false
+			};
+			this.emit('hmset_before', beforeEventData);
+
+			if (beforeEventData.cancel) {
+				resolve(false);
+				return;
+			}
+
+			// 检查是否过期
+			if (this._isExpired(key)) {
+				this.del(key);
+			}
+
+			// 初始化哈希表
+			if (!(key in this._data) || this._types[key] !== 'hash') {
+				this._data[key] = {};
+				this._types[key] = 'hash';
+			}
+
+			// 批量设置字段
+			for (const field in obj) {
+				if (Object.prototype.hasOwnProperty.call(obj, field)) {
+					this._data[key][field] = obj[field];
+				}
+			}
+
+			// 触发后置事件
+			this.emit('hmset_after', {
+				key,
+				obj,
+				success: true
+			});
+			resolve(true);
+		} catch (error) {
+			this.emit('hmset_error', {
+				key,
+				obj,
+				error
+			});
+			this.emit('error', new Error(`Failed to hmset: ${error.message}`));
+			resolve(false);
+		}
+	});
+};
+
+/**
+ * 批量获取哈希表字段
+ * @param {string} key - 哈希表键名
+ * @param {Array} fields - 字段名数组
+ * @returns {Promise<Array>} - 字段值数组，不存在的字段返回null
  */
-exports.cachebase_admin = cachebase_admin;
+CacheBase.prototype.hmget = function(key, fields) {
+	return new Promise((resolve) => {
+		try {
+			// 参数验证
+			if (!key || typeof key !== 'string' || !Array.isArray(fields)) {
+				resolve([]);
+				return;
+			}
+
+			// 检查是否过期
+			if (this._isExpired(key)) {
+				this.del(key);
+				resolve([]);
+				return;
+			}
+
+			// 检查键是否存在且类型正确
+			if (!(key in this._data) || this._types[key] !== 'hash') {
+				resolve(fields.map(() => null));
+				return;
+			}
+
+			// 批量获取字段值
+			const results = [];
+			for (const field of fields) {
+				results.push(this._data[key][field] !== undefined ? this._data[key][field] : null);
+			}
+
+			resolve(results);
+		} catch (error) {
+			this.emit('hmget_error', {
+				key,
+				fields,
+				error
+			});
+			this.emit('error', new Error(`Failed to hmget: ${error.message}`));
+			resolve([]);
+		}
+	});
+};
+
+/**
+ * 获取哈希表字段数量
+ * @param {string} key - 哈希表键名
+ * @returns {Promise<number>} - 字段数量，失败返回0
+ */
+CacheBase.prototype.hlen = function(key) {
+	return new Promise((resolve) => {
+		try {
+			// 参数验证
+			if (!key || typeof key !== 'string') {
+				resolve(0);
+				return;
+			}
+
+			// 检查是否过期
+			if (this._isExpired(key)) {
+				this.del(key);
+				resolve(0);
+				return;
+			}
+
+			// 检查键是否存在且类型正确
+			if (!(key in this._data) || this._types[key] !== 'hash') {
+				resolve(0);
+				return;
+			}
+
+			resolve(Object.keys(this._data[key]).length);
+		} catch (error) {
+			this.emit('hlen_error', {
+				key,
+				error
+			});
+			this.emit('error', new Error(`Failed to hlen: ${error.message}`));
+			resolve(0);
+		}
+	});
+};
+
+// 导出类
+exports.CacheBase = CacheBase;
+exports.cachebase_admin = function(scope, dir) {
+	if (!global.$) {
+		global.$ = {};
+	}
+	if (!global.$.pool) {
+		global.$.pool = {};
+	}
+	if (!global.$.pool.cachebase) {
+		global.$.pool.cachebase = {};
+	}
+	if (!scope) {
+		scope = 'sys';
+	}
+	var obj = global.$.pool.cachebase[scope];
+	if (!obj) {
+		const config = {
+			file_path: dir ? './cachebase_' + scope + '.json' : '/cache/cachebase_' + scope + '.json'
+		};
+		global.$.pool.cachebase[scope] = new CacheBase(config);
+		obj = global.$.pool.cachebase[scope];
+	}
+	return obj;
+};