mm_cachebase 1.5.0 → 1.6.0

package/index.js

@@ -1,1169 +1,866 @@
-require('mm_logs');
 const EventEmitter = require('events');
+require('mm_logs');
 
-// 符合Redis API的CacheBase类
 class CacheBase extends EventEmitter {
-  constructor() {
+  /**
+   * 构造函数，初始化缓存
+   * @param {Object} options - 配置选项
+   */
+  constructor(options = {}) {
     super();
+    // 配置选项
+    this.options = options;
+    // 日志实例
+    this.log = options.log || $;
+    // 数据存储对象
     this.data = {};
-    this.dict = this.data; // 为了兼容test.js中的访问
-    this.list = []; // 为了兼容test.js，存储所有键
+    // 键列表，用于存储所有的键名
+    this.list = [];
+    // 为了兼容旧版本，提供dict属性指向data
+    this.dict = this.data;
   }
 
-  // 基本的set方法，包含事件触发
-  async set(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value, 
-          cancel: false 
-        };
-        this.emit('set_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
+  /**
+   * 检查键是否过期
+   * @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;
         }
-
-        // 执行实际操作
-        this.data[key] = { value, expire: 0 };
-        
-        // 如果键不存在于列表中，添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
-        }
-
-        // 触发后置事件
-        this.emit('set_after', { 
-          key, 
-          value, 
-          result: 'OK' 
-        });
-        resolve('OK');
-      } catch (error) {
-        // 触发错误事件
-        this.emit('set_error', { 
-          key, 
-          value, 
-          error 
-        });
-        $.log.error('[cachebase] set操作失败:', error);
-        resolve(null);
       }
-    });
+    }
+    return false;
   }
 
-  // 基本的del方法，包含事件触发
-  async del(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('del_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 检查键是否存在
-        const exists = key in this.data;
-        
-        // 执行删除操作
-        if (exists) {
-          delete this.data[key];
-          // 从列表中移除
-          const index = this.list.indexOf(key);
-          if (index > -1) {
-            this.list.splice(index, 1);
-          }
-        }
-
-        // 触发后置事件
-        this.emit('del_after', { 
-          key, 
-          result: exists ? 1 : 0 
-        });
-        resolve(exists ? 1 : 0);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('del_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] del操作失败:', error);
-        resolve(0);
+  /**
+   * 设置键的过期时间
+   * @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;
       }
-    });
+    }
   }
 
-  // 基本的get方法，包含事件触发
-  async get(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('get_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(null);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = null;
-        if (obj) {
-          result = obj.value;
-        }
-
-        // 触发后置事件
-        this.emit('get_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('get_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] get操作失败:', error);
-        resolve(null);
+  /**
+   * 设置键值
+   * @param {string} key - 键名
+   * @param {*} value - 键值
+   * @param {number} expire - 过期时间(秒)，0表示永不过期
+   * @returns {Promise<string>} - 返回'OK'
+   */
+  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 });
+      this.log.error('[cachebase] set操作失败:', error);
+      throw error;
+    }
   }
 
-  // Redis兼容的getset方法
-  async getset(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value,
-          cancel: false 
-        };
-        this.emit('getset_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(null);
-          return;
-        }
-
-        // 获取旧值
-        const obj = this.data[key];
-        const oldValue = obj ? obj.value : null;
-        
-        // 设置新值
-        this.data[key] = { value, expire: 0 };
-        
-        // 如果键不存在于列表中，添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
-        }
-
-        // 触发后置事件
-        this.emit('getset_after', { 
-          key, 
-          value,
-          result: oldValue 
-        });
-        resolve(oldValue);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('getset_error', { 
-          key, 
-          value,
-          error 
-        });
-        $.log.error('[cachebase] getset操作失败:', error);
-        resolve(null);
+  /**
+   * 获取键值
+   * @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) {
+      this.log.error('[cachebase] get操作失败:', error);
+      throw error;
+    }
   }
-
-  // Redis兼容的append方法
-  async append(key, value) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value,
-          cancel: false 
-        };
-        this.emit('append_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 获取当前值或默认为空字符串
-        const obj = this.data[key];
-        let currentValue = '';
-        if (obj) {
-          currentValue = String(obj.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 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('append_error', { 
-          key, 
-          value,
-          error 
-        });
-        $.log.error('[cachebase] append操作失败:', error);
-        resolve(0);
+  
+  /**
+   * 删除键
+   * @param {string} key - 键名
+   * @returns {Promise<number>} - 返回删除的键数量
+   */
+  async del(key) {
+    try {
+      this.emit('del_before', { key });
+      
+      // 检查键是否存在
+      let deleted = 0;
+      if (this.data.hasOwnProperty(key)) {
+        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 });
+      this.log.error('[cachebase] del操作失败:', error);
+      throw error;
+    }
   }
 
-  // Redis兼容的strlen方法
-  async strlen(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key,
-          cancel: false 
-        };
-        this.emit('strlen_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
+  /**
+   * 检查键是否存在
+   * @param {string|Array<string>} key - 键名或键名数组
+   * @returns {Promise<number>} - 返回存在的键数量
+   */
+  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++;
+            }
+          }
         }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = 0;
-        if (obj) {
-          result = String(obj.value).length;
+      } else {
+        // 处理单键检查
+        if (this.data.hasOwnProperty(key)) {
+          // 检查是否过期
+          const item = this.data[key];
+          if (!(item.expire > 0 && Date.now() > item.expire)) {
+            existsCount = 1;
+          }
         }
-
-        // 触发后置事件
-        this.emit('strlen_after', { 
-          key,
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('strlen_error', { 
-          key,
-          error 
-        });
-        $.log.error('[cachebase] strlen操作失败:', error);
-        resolve(0);
       }
-    });
+      
+      return existsCount;
+    } catch (error) {
+      this.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) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件，将field作为value的一部分
-        const beforeEventData = { 
-          key, 
-          value: { field, value }, 
-          cancel: false 
-        };
-        this.emit('hset_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 确保哈希表存在
-        if (!this.data[key]) {
-          this.data[key] = { value: {}, expire: 0 };
-          // 添加到列表
-          if (!this.list.includes(key)) {
-            this.list.push(key);
-          }
-        } else if (typeof this.data[key].value !== 'object') {
-          this.data[key].value = {};
-        }
-
-        // 记录是否是新字段
-        const isNewField = !this.data[key].value.hasOwnProperty(field);
-        
-        // 设置字段值
-        this.data[key].value[field] = value;
-
-        // 触发后置事件
-        this.emit('hset_after', { 
-          key, 
-          value: { field, value }, 
-          result: isNewField ? 1 : 0 
-        });
-        resolve(isNewField ? 1 : 0);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('hset_error', { 
-          key, 
-          value: { field, value }, 
-          error 
-        });
-        $.log.error('[cachebase] hset操作失败:', error);
-        resolve(0);
+    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 });
+      this.log.error('[cachebase] hset操作失败:', error);
+      throw error;
+    }
   }
 
-  // 哈希表获取字段值方法 - 模拟实现
+  /**
+   * 获取哈希表字段
+   * @param {string} key - 键名
+   * @param {string} field - 字段名
+   * @returns {Promise<*>} - 返回字段值，不存在返回undefined
+   */
   async hget(key, field) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { field }, 
-          cancel: false 
-        };
-        this.emit('hget_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(null);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = null;
-        if (obj && typeof obj.value === 'object' && field in obj.value) {
-          result = obj.value[field];
-        }
-
-        // 触发后置事件
-        this.emit('hget_after', { 
-          key, 
-          value: { field }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('hget_error', { 
-          key, 
-          value: { field }, 
-          error 
-        });
-        $.log.error('[cachebase] hget操作失败:', error);
-        resolve(null);
+    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) {
+      this.log.error('[cachebase] hget操作失败:', error);
+      throw error;
+    }
   }
 
-  // 哈希表获取所有字段和值方法 - 模拟实现
+  /**
+   * 获取哈希表所有字段
+   * @param {string} key - 键名
+   * @returns {Promise<Object>} - 返回哈希表对象，不存在或不是哈希表返回{}
+   */
   async hgetall(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          cancel: false 
-        };
-        this.emit('hgetall_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve({});
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = {};
-        if (obj && typeof obj.value === 'object') {
-          result = {...obj.value};
-        }
-
-        // 触发后置事件
-        this.emit('hgetall_after', { 
-          key, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('hgetall_error', { 
-          key, 
-          error 
-        });
-        $.log.error('[cachebase] hgetall操作失败:', error);
-        resolve({});
+    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) {
+      this.log.error('[cachebase] hgetall操作失败:', error);
+      throw error;
+    }
   }
 
-  // 哈希表删除字段方法 - 模拟实现
+  /**
+   * 删除哈希表字段
+   * @param {string} key - 键名
+   * @param {string} field - 字段名
+   * @returns {Promise<number>} - 返回删除的字段数量
+   */
   async hdel(key, field) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key, 
-          value: { field }, 
-          cancel: false 
-        };
-        this.emit('hdel_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        let result = 0;
-        const obj = this.data[key];
-        if (obj && typeof obj.value === 'object' && field in obj.value) {
-          delete obj.value[field];
-          // 如果哈希表变空了，删除整个键
-          if (Object.keys(obj.value).length === 0) {
-            delete this.data[key];
-            const index = this.list.indexOf(key);
-            if (index > -1) {
-              this.list.splice(index, 1);
-            }
-          }
-          result = 1;
+    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)) {
+        this.emit('hdel_after', { key, field, result: 0 });
+        return 0;
+      }
+      
+      // 删除字段
+      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);
         }
-
-        // 触发后置事件
-        this.emit('hdel_after', { 
-          key, 
-          value: { field }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('hdel_error', { 
-          key, 
-          value: { field }, 
-          error 
-        });
-        $.log.error('[cachebase] hdel操作失败:', error);
-        resolve(0);
       }
-    });
+      
+      this.emit('hdel_after', { key, field, result: 1 });
+      return 1;
+    } catch (error) {
+      this.emit('hdel_error', { key, field, error });
+      this.log.error('[cachebase] hdel操作失败:', error);
+      throw error;
+    }
   }
 
-  // 修复的mset方法 - Redis兼容格式
-  async mset(...args) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件，将args作为value的一部分
-        const beforeEventData = { 
-          value: { args }, 
-          cancel: false 
-        };
-        this.emit('mset_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(null);
-          return;
-        }
-
-        // 参数校验
-        if (args.length % 2 !== 0) {
-          $.log.error('[cachebase] mset参数数量不正确');
-          resolve('ERR');
-          return;
-        }
-
-        // 执行实际操作
-        for (let i = 0; i < args.length; i += 2) {
-          const key = args[i];
-          const value = args[i + 1];
-          this.data[key] = { value, expire: 0 };
-          // 添加到列表
+  /**
+   * 批量设置键值
+   * @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', { 
-          value: { args }, 
-          result: 'OK' 
-        });
-        resolve('OK');
-      } catch (error) {
-        // 触发错误事件
-        this.emit('mset_error', { 
-          value: { args }, 
-          error 
-        });
-        $.log.error('[cachebase] mset操作失败:', error);
-        resolve('ERR');
       }
-    });
+      
+      this.emit('mset_after', { keyValues, result: 'OK' });
+      return 'OK';
+    } catch (error) {
+      this.emit('mset_error', { keyValues, error });
+      this.log.error('[cachebase] mset操作失败:', error);
+      throw error;
+    }
   }
 
-  // 修复的mget方法 - 返回数组格式，与Redis保持一致
-  async mget(...keys) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          value: { keys }, 
-          cancel: false 
-        };
-        this.emit('mget_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve([]);
-          return;
-        }
-
-        // 执行实际操作 - 返回数组格式，与Redis保持一致
-        const result = keys.map(key => {
-          const obj = this.data[key];
-          return obj ? obj.value : null;
-        });
-
-        // 触发后置事件
-        this.emit('mget_after', { 
-          value: { keys }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('mget_error', { 
-          value: { keys }, 
-          error 
-        });
-        $.log.error('[cachebase] mget操作失败:', error);
-        resolve([]);
+  /**
+   * 批量获取键值
+   * @param {Array<string>} keys - 键名数组
+   * @returns {Promise<Array>} - 返回值数组
+   */
+  async mget(keys) {
+    try {
+      if (!Array.isArray(keys)) {
+        throw new Error('[cachebase] mget参数必须是数组');
       }
-    });
-  }
-
-  // Redis兼容的exists方法，支持多个键
-  async exists(...keys) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          value: { keys }, 
-          cancel: false 
-        };
-        this.emit('exists_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
+      
+      // 批量获取键值
+      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);
         }
-
-        // 执行实际操作
-        const result = keys.filter(key => key in this.data).length;
-
-        // 触发后置事件
-        this.emit('exists_after', { 
-          value: { keys }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('exists_error', { 
-          value: { keys }, 
-          error 
-        });
-        $.log.error('[cachebase] exists操作失败:', error);
-        resolve(0);
       }
-    });
+      
+      return results;
+    } catch (error) {
+      this.log.error('[cachebase] mget操作失败:', error);
+      throw error;
+    }
   }
 
-  // 查询/设置过期时间方法，包含事件触发
+  /**
+   * 获取键的剩余生存时间
+   * @param {string} key - 键名
+   * @returns {Promise<number>} - 返回剩余时间（秒），-1表示永不过期，-2表示键不存在
+   */
   async ttl(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key,
-          cancel: false 
-        };
-        this.emit('ttl_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(-2);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result;
-        
-        if (!obj) {
-          result = -2; // 键不存在
-        } else {
-          // 查询过期时间
-          if (obj.expire === 0) {
-            result = -1; // 永不过期
-          } else {
-            const remaining = Math.floor((obj.expire - Date.now()) / 1000);
-            result = remaining > 0 ? remaining : -2; // -2表示已过期
+    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 ttl = Math.floor((item.expire - Date.now()) / 1000);
+          return ttl;
         }
-
-        // 触发后置事件
-        this.emit('ttl_after', { 
-          key,
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('ttl_error', { 
-          key,
-          error 
-        });
-        $.log.error('[cachebase] ttl操作失败:', error);
-        resolve(-2);
+      } else {
+        // 永不过期
+        return -1;
       }
-    });
+    } catch (error) {
+      this.log.error('[cachebase] ttl操作失败:', error);
+      throw error;
+    }
   }
 
-  // Redis兼容的expire方法
+  /**
+   * 设置键的过期时间
+   * @param {string} key - 键名
+   * @param {number} seconds - 过期时间（秒）
+   * @returns {Promise<number>} - 返回1表示设置成功，0表示键不存在
+   */
   async expire(key, seconds) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key,
-          value: { seconds },
-          cancel: false 
-        };
-        this.emit('expire_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = 0;
-        
-        if (obj) {
-          if (seconds === 0) {
-            obj.expire = 0; // 永不过期
-          } else {
-            obj.expire = Date.now() + (parseInt(seconds, 10) * 1000);
-          }
-          result = 1;
-        }
-
-        // 触发后置事件
-        this.emit('expire_after', { 
-          key,
-          value: { seconds },
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('expire_error', { 
-          key,
-          value: { seconds },
-          error 
-        });
-        $.log.error('[cachebase] expire操作失败:', error);
-        resolve(0);
+    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 });
+      this.log.error('[cachebase] expire操作失败:', error);
+      throw error;
+    }
   }
 
-  // Redis兼容的persist方法
+  /**
+   * 移除键的过期时间
+   * @param {string} key - 键名
+   * @returns {Promise<number>} - 返回1表示移除成功，0表示键不存在或没有过期时间
+   */
   async persist(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key,
-          cancel: false 
-        };
-        this.emit('persist_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 执行实际操作
-        const obj = this.data[key];
-        let result = 0;
-        
-        if (obj && obj.expire !== 0) {
-          obj.expire = 0; // 移除过期时间
-          result = 1;
-        }
-
-        // 触发后置事件
-        this.emit('persist_after', { 
-          key,
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('persist_error', { 
-          key,
-          error 
-        });
-        $.log.error('[cachebase] persist操作失败:', error);
-        resolve(0);
+    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 });
+      this.log.error('[cachebase] persist操作失败:', error);
+      throw error;
+    }
   }
 
-  // 获取所有匹配键方法，包含事件触发
-  async keys(pattern) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          value: { pattern }, 
-          cancel: false 
-        };
-        this.emit('keys_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve([]);
-          return;
-        }
-
-        // 执行实际操作
-        let result;
-        if (!pattern || pattern === '*') {
-          result = [...this.list];
-        } else {
-          // 转换模式为正则表达式
-          const regexPattern = pattern
-            .replace(/\./g, '\\.')
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.');
-          const regex = new RegExp(`^${regexPattern}$`);
-
-          // 过滤匹配的键
-          result = this.list.filter(key => regex.test(key));
-        }
-
-        // 触发后置事件
-        this.emit('keys_after', { 
-          value: { pattern }, 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('keys_error', { 
-          value: { pattern }, 
-          error 
-        });
-        $.log.error('[cachebase] keys操作失败:', error);
-        resolve([]);
+  /**
+   * 获取所有键名
+   * @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) {
+      this.log.error('[cachebase] keys操作失败:', error);
+      throw error;
+    }
   }
 
-  // Redis兼容的dbsize方法
+  /**
+   * 获取键数量
+   * @returns {Promise<number>} - 返回键数量
+   */
   async dbsize() {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          cancel: false 
-        };
-        this.emit('dbsize_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
+    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++;
+          }
         }
-
-        // 执行实际操作
-        const result = this.list.length;
-
-        // 触发后置事件
-        this.emit('dbsize_after', { 
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('dbsize_error', { 
-          error 
-        });
-        $.log.error('[cachebase] dbsize操作失败:', error);
-        resolve(0);
       }
-    });
+      
+      return count;
+    } catch (error) {
+      this.log.error('[cachebase] dbsize操作失败:', error);
+      throw error;
+    }
   }
 
-  // Redis兼容的flushdb方法
-  async flushdb() {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          cancel: false 
-        };
-        this.emit('flushdb_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(null);
-          return;
+  /**
+   * 设置键值并返回旧值
+   * @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 = {};
-        this.list = [];
-        this.dict = this.data; // 同步dict引用
-
-        // 触发后置事件
-        this.emit('flushdb_after', { 
-          result: 'OK' 
-        });
-        resolve('OK');
-      } catch (error) {
-        // 触发错误事件
-        this.emit('flushdb_error', { 
-          error 
-        });
-        $.log.error('[cachebase] flushdb操作失败:', error);
-        resolve(null);
       }
-    });
+      
+      // 设置新值
+      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 });
+      this.log.error('[cachebase] getset操作失败:', error);
+      throw error;
+    }
   }
 
-  // Redis兼容的incr方法
+  /**
+   * 数值递增
+   * @param {string} key - 键名
+   * @returns {Promise<number>} - 返回递增后的值
+   */
   async incr(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key,
-          cancel: false 
-        };
-        this.emit('incr_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 获取当前值或默认为0
-        let currentValue = 0;
-        if (this.data[key] && !isNaN(this.data[key].value)) {
-          currentValue = parseInt(this.data[key].value, 10);
-        }
-
-        // 执行递增
-        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 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('incr_error', { 
-          key,
-          error 
-        });
-        $.log.error('[cachebase] incr操作失败:', error);
-        resolve(0);
+    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 });
+      this.log.error('[cachebase] incr操作失败:', error);
+      throw error;
+    }
   }
 
-  // Redis兼容的decr方法
+  /**
+   * 数值递减
+   * @param {string} key - 键名
+   * @returns {Promise<number>} - 返回递减后的值
+   */
   async decr(key) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key,
-          cancel: false 
-        };
-        this.emit('decr_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 获取当前值或默认为0
-        let currentValue = 0;
-        if (this.data[key] && !isNaN(this.data[key].value)) {
-          currentValue = parseInt(this.data[key].value, 10);
-        }
-
-        // 执行递减
-        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 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('decr_error', { 
-          key,
-          error 
-        });
-        $.log.error('[cachebase] decr操作失败:', error);
-        resolve(0);
+    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 });
+      this.log.error('[cachebase] decr操作失败:', error);
+      throw error;
+    }
   }
 
-  // Redis兼容的incrby方法
+  /**
+   * 数值增加指定值
+   * @param {string} key - 键名
+   * @param {number} increment - 增加的值
+   * @returns {Promise<number>} - 返回增加后的值
+   */
   async incrby(key, increment) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key,
-          value: { increment },
-          cancel: false 
-        };
-        this.emit('incrby_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 获取当前值或默认为0
-        let currentValue = 0;
-        if (this.data[key] && !isNaN(this.data[key].value)) {
-          currentValue = parseInt(this.data[key].value, 10);
-        }
-
-        // 执行递增
-        const result = currentValue + parseInt(increment, 10);
-        
-        // 保存结果
-        this.data[key] = { value: result, expire: 0 };
-        
-        // 如果键不存在于列表中，添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
-        }
-
-        // 触发后置事件
-        this.emit('incrby_after', { 
-          key,
-          value: { increment },
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('incrby_error', { 
-          key,
-          value: { increment },
-          error 
-        });
-        $.log.error('[cachebase] incrby操作失败:', error);
-        resolve(0);
+    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 });
+      this.log.error('[cachebase] incrby操作失败:', error);
+      throw error;
+    }
   }
 
-  // Redis兼容的decrby方法
+  /**
+   * 数值减少指定值
+   * @param {string} key - 键名
+   * @param {number} decrement - 减少的值
+   * @returns {Promise<number>} - 返回减少后的值
+   */
   async decrby(key, decrement) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key,
-          value: { decrement },
-          cancel: false 
-        };
-        this.emit('decrby_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 获取当前值或默认为0
-        let currentValue = 0;
-        if (this.data[key] && !isNaN(this.data[key].value)) {
-          currentValue = parseInt(this.data[key].value, 10);
-        }
-
-        // 执行递减
-        const result = currentValue - parseInt(decrement, 10);
-        
-        // 保存结果
-        this.data[key] = { value: result, expire: 0 };
-        
-        // 如果键不存在于列表中，添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
-        }
-
-        // 触发后置事件
-        this.emit('decrby_after', { 
-          key,
-          value: { decrement },
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('decrby_error', { 
-          key,
-          value: { decrement },
-          error 
-        });
-        $.log.error('[cachebase] decrby操作失败:', error);
-        resolve(0);
+    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 });
+      this.log.error('[cachebase] decrby操作失败:', error);
+      throw error;
+    }
   }
 
-  // Redis兼容的incrbyfloat方法
+  /**
+   * 浮点数增加指定值
+   * @param {string} key - 键名
+   * @param {number} increment - 增加的值
+   * @returns {Promise<number>} - 返回增加后的值
+   */
   async incrbyfloat(key, increment) {
-    return new Promise((resolve) => {
-      try {
-        // 触发前置事件
-        const beforeEventData = { 
-          key,
-          value: { increment },
-          cancel: false 
-        };
-        this.emit('incrbyfloat_before', beforeEventData);
-
-        // 如果事件处理器设置了cancel为true，则取消操作
-        if (beforeEventData.cancel) {
-          resolve(0);
-          return;
-        }
-
-        // 获取当前值或默认为0
-        let currentValue = 0;
-        if (this.data[key] && !isNaN(this.data[key].value)) {
-          currentValue = parseFloat(this.data[key].value);
-        }
-
-        // 执行浮点递增
-        const result = currentValue + parseFloat(increment);
-        
-        // 保存结果
-        this.data[key] = { value: result, expire: 0 };
-        
-        // 如果键不存在于列表中，添加到列表
-        if (!this.list.includes(key)) {
-          this.list.push(key);
-        }
+    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 });
+      this.log.error('[cachebase] incrbyfloat操作失败:', error);
+      throw error;
+    }
+  }
 
-        // 触发后置事件
-        this.emit('incrbyfloat_after', { 
-          key,
-          value: { increment },
-          result 
-        });
-        resolve(result);
-      } catch (error) {
-        // 触发错误事件
-        this.emit('incrbyfloat_error', { 
-          key,
-          value: { increment },
-          error 
-        });
-        $.log.error('[cachebase] incrbyfloat操作失败:', error);
-        resolve(0);
+  /**
+   * 字符串追加
+   * @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 });
+      this.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 });
+      this.log.error('[cachebase] strlen操作失败:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * 清空数据库
+   * @returns {Promise<string>} - 返回'OK'
+   */
+  async flushdb() {
+    try {
+      this.emit('flushdb_before');
+      
+      // 清空数据
+      this.data = {};
+      this.list = [];
+      
+      this.emit('flushdb_after', { result: 'OK' });
+      return 'OK';
+    } catch (error) {
+      this.emit('flushdb_error', { error });
+      this.log.error('[cachebase] flushdb操作失败:', error);
+      throw error;
+    }
   }
 
   // 保持兼容性的方法
   async has(key) {
-    return this.exists(key);
+    try {
+      const exists = await this.exists(key);
+      return exists > 0;
+    } catch (error) {
+      this.log.error('[cachebase] has操作失败:', error);
+      throw error;
+    }
   }
 
   async clear(pattern) {
@@ -1182,36 +879,61 @@ class CacheBase extends EventEmitter {
     return this.append(key, value);
   }
 
-  // 资源销毁方法，包含事件触发
+  /**
+   * 资源销毁方法
+   */
   dispose() {
     try {
-      // 触发前置事件
-      const beforeEventData = { cancel: false };
-      this.emit('dispose_before', beforeEventData);
-
-      // 如果事件处理器设置了cancel为true，则取消操作
-      if (beforeEventData.cancel) {
-        return;
-      }
-
-      // 执行实际操作
+      this.emit('dispose_before');
+      
+      // 清空数据
       this.data = {};
       this.list = [];
-      this.dict = this.data; // 同步dict引用
       
-      // 触发后置事件
-      this.emit('dispose_after', {});
+      this.emit('dispose_after');
       
-      // 最后移除所有监听器（在触发后置事件后）
+      // 移除所有监听器
       this.removeAllListeners();
     } catch (error) {
-      // 触发错误事件
       this.emit('dispose_error', { error });
-      $.log.error('[cachebase] dispose操作失败:', error);
+      this.log.error('[cachebase] dispose操作失败:', error);
     }
   }
 }
 
 // 导出CacheBase类
-module.exports = CacheBase;
+exports.CacheBase = CacheBase;
+
+
+/**
+ * 确保连接池对象存在
+ */
+if (!$.pool) {
+	$.pool = {};
+}
+if (!$.pool.cachebase) {
+	$.pool.cachebase = {};
+}
+
+/**
+ * @description cachebase管理器，用于创建缓存
+ * @param {String} scope 作用域
+ * @param {String} dir 当前路径
+ * @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;
+}
 
+/**
+ * @module 导出cachebase管理器
+ */
+exports.cachebase_admin = cachebase_admin;