HarmonyOS鸿蒙Next开发者技术支持-系统缓存查询与删除优化方案

鸿蒙系统缓存查询与删除优化方案

1.1 问题说明

问题场景：鸿蒙应用开发中经常需要进行缓存管理，但现有缓存操作存在以下痛点：

• 缓存查询接口分散，缺乏统一管理
• 删除缓存时需要手动计算路径，易出错
• 缺乏有效的缓存统计和清理机制
• 缓存大小监控缺失，可能导致存储溢出
• 异步删除大缓存时容易阻塞主线程

1.2 解决方案

2.1 缓存管理器核心类实现

// CacheManager.ets

import fs from ‘@ohos.file.fs’; import common from ‘@ohos.app.ability.common’; import { BusinessError } from ‘@ohos.base’;

export class CacheManager { private context: common.UIAbilityContext; private cacheDir: string = ‘’;

// 缓存类型定义 public static CacheType = { IMAGE: ‘image’, DATA: ‘data’, LOG: ‘log’, TEMP: ‘temp’ } as const;

constructor(context: common.UIAbilityContext) { this.context = context; this.initCacheDir(); }

// 初始化缓存目录 private async initCacheDir(): Promise<void> { try { const fileDir = this.context.filesDir; this.cacheDir = ${fileDir}/cache; await this.ensureDirectory(this.cacheDir); } catch (error) { console.error(初始化缓存目录失败: ${error.message}); } }

// 获取指定类型缓存大小 public async getCacheSize(cacheType?: string): Promise<number> { try { let targetDir = this.cacheDir; if (cacheType) { targetDir = ${this.cacheDir}/${cacheType}; }

  if (!await this.isDirectoryExist(targetDir)) {
    return 0;
  }
  
  return await this.calculateDirectorySize(targetDir);
} catch (error) {
  console.error(`获取缓存大小失败: ${error.message}`);
  return 0;
}

}

// 获取所有缓存信息 public async getAllCacheInfo(): Promise<CacheInfo[]> { const cacheInfo: CacheInfo[] = []; const types = Object.values(CacheManager.CacheType);

for (const type of types) {
  const size = await this.getCacheSize(type);
  if (size > 0) {
    cacheInfo.push({
      type: type,
      size: size,
      fileCount: await this.getFileCount(type),
      lastModified: await this.getLastModifiedTime(type)
    });
  }
}

return cacheInfo;

}

// 删除指定类型缓存 public async deleteCache(cacheType: string): Promise<boolean> { try { const targetDir = ${this.cacheDir}/${cacheType};

  if (!await this.isDirectoryExist(targetDir)) {
    return true;
  }
  
  await this.deleteDirectory(targetDir);
  console.info(`已删除${cacheType}缓存`);
  return true;
} catch (error) {
  console.error(`删除${cacheType}缓存失败: ${error.message}`);
  return false;
}

}

// 异步批量删除缓存 public async deleteMultipleCaches(cacheTypes: string[]): Promise<DeleteResult[]> { const results: DeleteResult[] = [];

const deletePromises = cacheTypes.map(async (type) => {
  const startTime = new Date().getTime();
  const success = await this.deleteCache(type);
  const duration = new Date().getTime() - startTime;
  
  results.push({
    cacheType: type,
    success: success,
    duration: duration
  });
});

await Promise.all(deletePromises);
return results;

}

// 智能清理 - 按时间或大小 public async smartCleanup(options: CleanupOptions): Promise<CleanupResult> { const result: CleanupResult = { totalFreed: 0, filesDeleted: 0, typesCleaned: [] };

const cacheInfo = await this.getAllCacheInfo();

for (const info of cacheInfo) {
  // 按时间清理
  if (options.beforeDate && info.lastModified < options.beforeDate.getTime()) {
    const beforeSize = await this.getCacheSize(info.type);
    await this.deleteCache(info.type);
    const afterSize = await this.getCacheSize(info.type);
    
    result.totalFreed += (beforeSize - afterSize);
    result.filesDeleted += info.fileCount;
    result.typesCleaned.push(info.type);
  }
  
  // 按大小清理
  if (options.maxSizePerType && info.size > options.maxSizePerType) {
    await this.clearOldestFiles(info.type, options.maxSizePerType);
    result.typesCleaned.push(info.type);
  }
}

return result;

}

// 辅助方法 private async ensureDirectory(path: string): Promise<void> { if (!await this.isDirectoryExist(path)) { await fs.mkdir(path); } }

private async isDirectoryExist(path: string): Promise<boolean> { try { const stat = await fs.stat(path); return stat.isDirectory(); } catch { return false; } }

private async calculateDirectorySize(dirPath: string): Promise<number> { let totalSize = 0; try { const dir = await fs.opendir(dirPath); let entry = await dir.read();

  while (entry !== undefined) {
    const fullPath = `${dirPath}/${entry.name}`;
    const stat = await fs.stat(fullPath);
    
    if (stat.isFile()) {
      totalSize += stat.size;
    } else if (stat.isDirectory()) {
      totalSize += await this.calculateDirectorySize(fullPath);
    }
    
    entry = await dir.read();
  }
  
  await dir.close();
} catch (error) {
  console.error(`计算目录大小失败: ${error.message}`);
}

return totalSize;

}

private async deleteDirectory(dirPath: string): Promise<void> { try { const dir = await fs.opendir(dirPath); let entry = await dir.read();

  while (entry !== undefined) {
    const fullPath = `${dirPath}/${entry.name}`;
    const stat = await fs.stat(fullPath);
    
    if (stat.isFile()) {
      await fs.unlink(fullPath);
    } else if (stat.isDirectory()) {
      await this.deleteDirectory(fullPath);
    }
    
    entry = await dir.read();
  }
  
  await dir.close();
  await fs.rmdir(dirPath);
} catch (error) {
  throw new Error(`删除目录失败: ${error.message}`);
}

} }

// 类型定义 interface CacheInfo { type: string; size: number; fileCount: number; lastModified: number; }

interface DeleteResult { cacheType: string; success: boolean; duration: number; }

interface CleanupOptions { beforeDate?: Date; maxSizePerType?: number; maxTotalSize?: number; }

interface CleanupResult { totalFreed: number; filesDeleted: number; typesCleaned: string[]; }

2.2 缓存监控器组件

// CacheMonitor.ets

export class CacheMonitor { private cacheManager: CacheManager; private monitoring: boolean = false; private thresholds: MonitorThresholds; private listeners: CacheEventListener[] = [];

constructor(cacheManager: CacheManager) { this.cacheManager = cacheManager; this.thresholds = { warning: 50 * 1024 * 1024, // 50MB critical: 100 * 1024 * 1024 // 100MB }; }

// 开始监控 public startMonitoring(interval: number = 30000): void { if (this.monitoring) return;

this.monitoring = true;
this.monitorLoop(interval);

}

// 停止监控 public stopMonitoring(): void { this.monitoring = false; }

// 添加监听器 public addListener(listener: CacheEventListener): void { this.listeners.push(listener); }

// 移除监听器 public removeListener(listener: CacheEventListener): void { const index = this.listeners.indexOf(listener); if (index > -1) { this.listeners.splice(index, 1); } }

private async monitorLoop(interval: number): Promise<void> { while (this.monitoring) { await this.checkCacheStatus(); await this.sleep(interval); } }

private async checkCacheStatus(): Promise<void> { try { const totalSize = await this.cacheManager.getCacheSize(); const cacheInfo = await this.cacheManager.getAllCacheInfo();

  // 检查阈值
  if (totalSize >= this.thresholds.critical) {
    this.notifyListeners('critical', {
      totalSize,
      threshold: this.thresholds.critical,
      suggestion: '立即清理缓存'
    });
    
    // 自动清理临时文件
    await this.cacheManager.deleteCache(CacheManager.CacheType.TEMP);
  } else if (totalSize >= this.thresholds.warning) {
    this.notifyListeners('warning', {
      totalSize,
      threshold: this.thresholds.warning,
      suggestion: '建议清理缓存'
    });
  }
  
  // 检测异常缓存
  this.detectAnomalies(cacheInfo);
  
} catch (error) {
  this.notifyListeners('error', { error: error.message });
}

}

private detectAnomalies(cacheInfo: CacheInfo[]): void { for (const info of cacheInfo) { // 检测单个类型缓存过大 if (info.size > 10 * 1024 * 1024) { // 10MB this.notifyListeners(‘type_oversize’, { type: info.type, size: info.size }); }

  // 检测文件数量异常
  if (info.fileCount > 1000) {
    this.notifyListeners('too_many_files', {
      type: info.type,
      fileCount: info.fileCount
    });
  }
}

}

private notifyListeners(event: string, data: any): void { this.listeners.forEach(listener => { listener.onCacheEvent(event, data); }); }

private sleep(ms: number): Promise<void> { return new Promise(resolve => setTimeout(resolve, ms)); } }

interface MonitorThresholds { warning: number; critical: number; }

interface CacheEventListener { onCacheEvent(event: string, data: any): void; }

2.3 使用示例

// 使用示例 @Entry @Component struct CacheManagementExample { private cacheManager: CacheManager = new CacheManager(getContext(this) as common.UIAbilityContext); private cacheMonitor: CacheMonitor = new CacheMonitor(this.cacheManager);

aboutToAppear() { // 启动缓存监控 this.cacheMonitor.startMonitoring();

// 添加监控监听器
this.cacheMonitor.addListener({
  onCacheEvent: (event: string, data: any) => {
    console.info(`缓存事件: ${event}`, data);
    
    if (event === 'critical') {
      // 显示清理提示
      AlertDialog.show({
        message: `缓存已满(${this.formatSize(data.totalSize)})，建议立即清理`
      });
    }
  }
});

}

// 显示缓存信息 async showCacheInfo() { const cacheInfo = await this.cacheManager.getAllCacheInfo(); const totalSize = await this.cacheManager.getCacheSize();

console.info('缓存统计:');
cacheInfo.forEach(info => {
  console.info(`${info.type}: ${this.formatSize(info.size)} (${info.fileCount}个文件)`);
});
console.info(`总计: ${this.formatSize(totalSize)}`);

}

// 清理所有缓存 async clearAllCache() { const types = Object.values(CacheManager.CacheType); const results = await this.cacheManager.deleteMultipleCaches(types);

let successCount = 0;
results.forEach(result => {
  if (result.success) successCount++;
});

console.info(`清理完成: ${successCount}/${types.length} 成功`);

}

// 智能清理 async smartClean() { const oneWeekAgo = new Date(); oneWeekAgo.setDate(oneWeekAgo.getDate() - 7);

const result = await this.cacheManager.smartCleanup({
  beforeDate: oneWeekAgo,
  maxSizePerType: 10 * 1024 * 1024 // 每个类型最大10MB
});

console.info(`智能清理释放: ${this.formatSize(result.totalFreed)}`);

}

private formatSize(bytes: number): string { const units = [‘B’, ‘KB’, ‘MB’, ‘GB’]; let size = bytes; let unitIndex = 0;

while (size >= 1024 && unitIndex < units.length - 1) {
  size /= 1024;
  unitIndex++;
}

return `${size.toFixed(2)} ${units[unitIndex]}`;

}

build() { Column({ space: 20 }) { Button(‘显示缓存信息’) .onClick(() => this.showCacheInfo())

  Button('清理图片缓存')
    .onClick(() => this.cacheManager.deleteCache(CacheManager.CacheType.IMAGE))
    
  Button('智能清理')
    .onClick(() => this.smartClean())
    
  Button('清理所有缓存')
    .onClick(() => this.clearAllCache())
}
.padding(20)

} }

2.4 结果展示

性能提升

1. 查询效率：缓存大小计算从同步改为异步遍历，UI响应更流畅
2. 删除效率：批量异步删除，大文件删除不阻塞主线程
3. 内存优化：智能清理机制防止缓存无限增长

可复用成果

1. CacheManager类：可直接复用于任何鸿蒙应用
2. CacheMonitor组件：提供开箱即用的缓存监控
3. 统一API接口：简化缓存操作调用方式
4. 类型安全：完整的TypeScript类型定义
5. 扩展机制：支持自定义缓存策略和监听器