HarmonyOS APP开发：资源预加载与启动预加载策略

📌 核心要点：预加载是启动优化的"提前量"艺术——在用户到达之前就把资源准备好，让首页数据"即开即有"、图片"即显即现"、布局"即渲染即完成"。

一、背景与动机

想象你去一家餐厅，刚坐下服务员就端上了你最爱的菜——这种"未卜先知"的体验，就是预加载的魅力。在应用开发中，预加载的核心思想也是一样：在用户需要之前，提前把资源准备好。

上一篇我们优化了热启动的恢复速度，但无论是冷启动还是热启动，用户打开应用后都需要等待数据加载。如果能在启动之前就预加载好首页数据、预渲染好布局、预缓存好图片，用户打开应用的瞬间就能看到完整内容——这才是极致的启动体验。

当然，预加载不是"越多越好"的蛮力活，而是一门需要精确计算"提前量"的艺术。预加载太早，浪费系统资源；预加载太晚，起不到加速效果；预加载太多，可能拖慢当前场景的性能。本文将从策略设计、数据预加载、布局预加载、图片预加载、时机选择五个维度，全面讲解HarmonyOS应用预加载的最佳实践。

二、核心原理

2.1 预加载策略设计

预加载策略的核心是回答三个问题：预加载什么？什么时候预加载？预加载多少？ 这三个问题的答案构成了预加载策略的"铁三角"：

flowchart TD
    classDef strategyStyle fill:#E8EAF6,stroke:#283593,stroke-width:2px,color:#1A237E
    classDef whatStyle fill:#E8F5E9,stroke:#2E7D32,stroke-width:2px,color:#1B5E20
    classDef whenStyle fill:#FFF3E0,stroke:#E65100,stroke-width:2px,color:#BF360C
    classDef howMuchStyle fill:#FCE4EC,stroke:#C62828,stroke-width:2px,color:#B71C1C
    classDef resultStyle fill:#F3E5F5,stroke:#6A1B9A,stroke-width:2px,color:#4A148C

    A[预加载策略铁三角]:::strategyStyle --> B[预加载什么？\nWhat]:::whatStyle
    A --> C[什么时候预加载？\nWhen]:::whenStyle
    A --> D[预加载多少？\nHow Much]:::howMuchStyle

    B --> B1[首页API数据]:::whatStyle
    B --> B2[首屏图片资源]:::whatStyle
    B --> B3[布局组件模板]:::whatStyle
    B --> B4[配置信息]:::whatStyle

    C --> C1[应用安装后首次启动]:::whenStyle
    C --> C2[应用升级后首次启动]:::whenStyle
    C --> C3[后台空闲时]:::whenStyle
    C --> C4[用户操作预测]:::whenStyle

    D --> D1[首屏可见区域数据]:::howMuchStyle
    D --> D2[1~2屏预加载量]:::howMuchStyle
    D --> D3[不超过总数据30%]:::howMuchStyle

    B1 & B2 & B3 & B4 & C1 & C2 & C3 & C4 & D1 & D2 & D3 --> E[🎯 最优预加载策略]:::resultStyle

2.2 预加载时机选择矩阵

三、代码实战

3.1 基础示例：首页数据预加载

首页数据预加载是最常见也最有效的预加载策略。在Ability.onCreate中提前发起数据请求，让数据和UI并行准备：

// PreloadManager.ets - 预加载管理器
import hilog from '@ohos.hilog';
import http from '@ohos.net.http';

const TAG = 'PreloadManager';
const DOMAIN = 0x0001;

/**
 * 预加载任务定义
 */
interface PreloadTask {
  taskId: string;              // 任务唯一标识
  url: string;                 // 请求地址
  params?: Object;             // 请求参数
  priority: number;            // 优先级（0最高）
  callback?: (data: Object) => void;  // 数据就绪回调
  status: 'pending' | 'loading' | 'done' | 'failed';  // 任务状态
  result?: Object;             // 预加载结果
  timestamp?: number;          // 完成时间
}

/**
 * 预加载管理器
 * 管理数据预加载任务的创建、执行和结果获取
 */
export class PreloadManager {
  private static instance: PreloadManager;
  private tasks: Map<string, PreloadTask> = new Map();  // 任务池
  private maxConcurrent: number = 3;                     // 最大并发数
  private activeCount: number = 0;                       // 当前活跃任务数

  private constructor() {}

  static getInstance(): PreloadManager {
    if (!PreloadManager.instance) {
      PreloadManager.instance = new PreloadManager();
    }
    return PreloadManager.instance;
  }

  // 注册预加载任务
  registerTask(taskId: string, url: string, params?: Object, priority: number = 0): void {
    if (this.tasks.has(taskId)) {
      hilog.warn(DOMAIN, TAG, `预加载任务已存在: ${taskId}`);
      return;
    }

    const task: PreloadTask = {
      taskId,
      url,
      params,
      priority,
      status: 'pending',
    };

    this.tasks.set(taskId, task);
    hilog.info(DOMAIN, TAG, `注册预加载任务: ${taskId}, 优先级: ${priority}`);
  }

  // 执行预加载（在Ability.onCreate中调用）
  async executePreload(taskIds: string[]): Promise<void> {
    // 按优先级排序
    const sortedTasks = taskIds
      .map(id => this.tasks.get(id))
      .filter(task => task && task.status === 'pending')
      .sort((a, b) => a!.priority - b!.priority);

    // 并行执行（控制并发数）
    const promises: Promise<void>[] = [];
    for (const task of sortedTasks) {
      if (this.activeCount < this.maxConcurrent) {
        promises.push(this.executeTask(task!));
      }
    }

    await Promise.all(promises);
  }

  // 执行单个预加载任务
  private async executeTask(task: PreloadTask): Promise<void> {
    task.status = 'loading';
    this.activeCount++;

    try {
      const httpRequest = http.createHttp();
      const response = await httpRequest.request(task.url, {
        method: http.RequestMethod.GET,
        connectTimeout: 5000,
        readTimeout: 5000,
      });

      if (response.responseCode === 200) {
        task.result = JSON.parse(response.result as string);
        task.status = 'done';
        task.timestamp = Date.now();
        hilog.info(DOMAIN, TAG, `预加载完成: ${task.taskId}`);

        // 通知回调
        if (task.callback) {
          task.callback(task.result);
        }
      } else {
        task.status = 'failed';
        hilog.warn(DOMAIN, TAG, `预加载失败: ${task.taskId}, 状态码: ${response.responseCode}`);
      }

      httpRequest.destroy();
    } catch (error) {
      task.status = 'failed';
      hilog.error(DOMAIN, TAG, `预加载异常: ${task.taskId}, ${JSON.stringify(error)}`);
    } finally {
      this.activeCount--;
    }
  }

  // 获取预加载结果（在页面aboutToAppear中调用）
  getPreloadResult(taskId: string): Object | null {
    const task = this.tasks.get(taskId);
    if (task && task.status === 'done' && task.result) {
      hilog.info(DOMAIN, TAG, `预加载命中: ${taskId}`);
      return task.result;
    }
    hilog.info(DOMAIN, TAG, `预加载未命中: ${taskId}, 状态: ${task?.status || '不存在'}`);
    return null;
  }

  // 检查预加载是否就绪
  isPreloadReady(taskId: string): boolean {
    const task = this.tasks.get(taskId);
    return task?.status === 'done';
  }

  // 清理过期的预加载结果
  cleanupExpiredTasks(maxAge: number = 10 * 60 * 1000): void {
    const now = Date.now();
    for (const [taskId, task] of this.tasks) {
      if (task.timestamp && (now - task.timestamp > maxAge)) {
        this.tasks.delete(taskId);
        hilog.info(DOMAIN, TAG, `清理过期预加载: ${taskId}`);
      }
    }
  }
}

3.2 进阶示例：布局预加载与图片预加载

布局预加载利用ArkUI的组件复用能力，提前创建组件模板；图片预加载利用Image组件的缓存机制，提前下载图片到内存：

// LayoutPreloader.ets - 布局预加载器
import hilog from '@ohos.hilog';

const TAG = 'LayoutPreloader';
const DOMAIN = 0x0001;

/**
 * 布局预加载器
 * 提前创建和缓存常用组件模板，减少首帧渲染耗时
 */
export class LayoutPreloader {
  private static instance: LayoutPreloader;
  private cachedTemplates: Map<string, Object> = new Map();

  private constructor() {}

  static getInstance(): LayoutPreloader {
    if (!LayoutPreloader.instance) {
      LayoutPreloader.instance = new LayoutPreloader();
    }
    return LayoutPreloader.instance;
  }

  // 预加载常用布局模板
  preloadTemplates(): void {
    hilog.info(DOMAIN, TAG, '开始预加载布局模板');
    
    // 预加载首页各区域的布局配置
    this.cachedTemplates.set('banner_layout', this.createBannerTemplate());
    this.cachedTemplates.set('feed_item_layout', this.createFeedItemTemplate());
    this.cachedTemplates.set('category_layout', this.createCategoryTemplate());
    
    hilog.info(DOMAIN, TAG, `布局模板预加载完成, 共 ${this.cachedTemplates.size} 个`);
  }

  // 获取布局模板
  getTemplate(key: string): Object | null {
    return this.cachedTemplates.get(key) || null;
  }

  private createBannerTemplate(): Object {
    return { type: 'banner', height: 180, borderRadius: 8, autoPlay: true };
  }

  private createFeedItemTemplate(): Object {
    return { type: 'feed_item', imageWidth: 60, imageHeight: 60, titleLines: 2 };
  }

  private createCategoryTemplate(): Object {
    return { type: 'category', columns: 4, itemSize: 80 };
  }
}

// ImagePreloader.ets - 图片预加载器
import hilog from '@ohos.hilog';
import http from '@ohos.net.http';
import image from '@ohos.multimedia.image';

const TAG = 'ImagePreloader';
const DOMAIN = 0x0001;

/**
 * 图片预加载器
 * 提前下载首屏图片到内存缓存，加速图片显示
 */
export class ImagePreloader {
  private static instance: ImagePreloader;
  private imageCache: Map<string, image.PixelMap> = new Map();  // 图片内存缓存
  private preloadQueue: string[] = [];                           // 预加载队列
  private isPreloading: boolean = false;                         // 是否正在预加载

  private constructor() {}

  static getInstance(): ImagePreloader {
    if (!ImagePreloader.instance) {
      ImagePreloader.instance = new ImagePreloader();
    }
    return ImagePreloader.instance;
  }

  // 添加预加载图片URL
  addToPreloadQueue(urls: string[]): void {
    for (const url of urls) {
      if (!this.imageCache.has(url) && !this.preloadQueue.includes(url)) {
        this.preloadQueue.push(url);
      }
    }
    hilog.info(DOMAIN, TAG, `预加载队列: ${this.preloadQueue.length} 张图片`);
  }

  // 执行图片预加载
  async executePreload(): Promise<void> {
    if (this.isPreloading) {
      hilog.info(DOMAIN, TAG, '图片预加载已在进行中');
      return;
    }

    this.isPreloading = true;
    hilog.info(DOMAIN, TAG, '开始图片预加载');

    while (this.preloadQueue.length > 0) {
      const url = this.preloadQueue.shift()!;
      try {
        const pixelMap = await this.downloadAndDecode(url);
        if (pixelMap) {
          this.imageCache.set(url, pixelMap);
          hilog.info(DOMAIN, TAG, `图片预加载完成: ${url.substring(0, 50)}...`);
        }
      } catch (error) {
        hilog.warn(DOMAIN, TAG, `图片预加载失败: ${url}`);
      }
    }

    this.isPreloading = false;
    hilog.info(DOMAIN, TAG, `图片预加载全部完成, 缓存: ${this.imageCache.size} 张`);
  }

  // 获取预加载的图片
  getPreloadedImage(url: string): image.PixelMap | null {
    return this.imageCache.get(url) || null;
  }

  // 下载并解码图片
  private async downloadAndDecode(url: string): Promise<image.PixelMap | null> {
    try {
      const httpRequest = http.createHttp();
      const response = await httpRequest.request(url, {
        method: http.RequestMethod.GET,
        connectTimeout: 3000,
        readTimeout: 5000,
      });

      if (response.responseCode === 200) {
        // 将下载数据解码为PixelMap
        const imageData = response.result as ArrayBuffer;
        const imageSource = image.createImageSource(imageData);
        const pixelMap = await imageSource.createPixelMap();
        imageSource.release();
        httpRequest.destroy();
        return pixelMap;
      }
      httpRequest.destroy();
    } catch (error) {
      hilog.error(DOMAIN, TAG, `图片下载解码失败: ${JSON.stringify(error)}`);
    }
    return null;
  }

  // 清理图片缓存
  clearCache(): void {
    for (const [, pixelMap] of this.imageCache) {
      pixelMap.release();
    }
    this.imageCache.clear();
    hilog.info(DOMAIN, TAG, '图片缓存已清理');
  }
}

3.3 完整示例：首页数据预加载实战

将数据预加载、布局预加载、图片预加载整合到首页启动流程中，实现"即开即有"的首页体验：

// Index.ets - 集成预加载的首页
import { PreloadManager } from '../preload/PreloadManager';
import { LayoutPreloader } from '../preload/LayoutPreloader';
import { ImagePreloader } from '../preload/ImagePreloader';
import hilog from '@ohos.hilog';

const TAG = 'Index';
const DOMAIN = 0x0001;

// 首页数据模型
interface HomeData {
  banners: BannerItem[];
  feeds: FeedItem[];
  categories: CategoryItem[];
}

interface BannerItem {
  id: string;
  imageUrl: string;
  linkUrl: string;
  title: string;
}

interface FeedItem {
  id: string;
  title: string;
  coverUrl: string;
  author: string;
}

interface CategoryItem {
  id: string;
  name: string;
  icon: string;
}

@Entry
@Component
struct Index {
  @State bannerList: BannerItem[] = [];
  @State feedList: FeedItem[] = [];
  @State categoryList: CategoryItem[] = [];
  @State isLoading: boolean = true;
  @State isPreloaded: boolean = false;  // 是否命中预加载

  // 预加载管理器实例
  private preloadManager = PreloadManager.getInstance();
  private imagePreloader = ImagePreloader.getInstance();

  aboutToAppear(): void {
    // 尝试从预加载结果获取数据
    this.tryGetPreloadedData();
  }

  // 尝试获取预加载数据
  private tryGetPreloadedData(): void {
    const preloadedHomeData = this.preloadManager.getPreloadResult('home_data');

    if (preloadedHomeData) {
      // 预加载命中！直接使用预加载数据渲染
      this.isPreloaded = true;
      const data = preloadedHomeData as HomeData;
      this.bannerList = data.banners;
      this.feedList = data.feeds;
      this.categoryList = data.categories;
      this.isLoading = false;

      hilog.info(DOMAIN, TAG, '✅ 预加载命中，首页数据即时可用');
    } else {
      // 预加载未命中，正常请求
      this.isPreloaded = false;
      this.loadHomeData();
      hilog.info(DOMAIN, TAG, '⏳ 预加载未命中，正常请求首页数据');
    }
  }

  // 正常加载首页数据
  private async loadHomeData(): Promise<void> {
    try {
      // 并行请求所有首页数据
      const [banners, feeds, categories] = await Promise.all([
        this.fetchBanners(),
        this.fetchFeeds(),
        this.fetchCategories(),
      ]);

      this.bannerList = banners;
      this.feedList = feeds;
      this.categoryList = categories;
      this.isLoading = false;

      // 预加载首页图片
      this.preloadHomeImages(banners, feeds);
    } catch (error) {
      this.isLoading = false;
      hilog.error(DOMAIN, TAG, `首页数据加载失败: ${JSON.stringify(error)}`);
    }
  }

  // 预加载首页图片
  private preloadHomeImages(banners: BannerItem[], feeds: FeedItem[]): void {
    const imageUrls: string[] = [];
    // 收集轮播图URL
    for (const banner of banners.slice(0, 3)) {
      imageUrls.push(banner.imageUrl);
    }
    // 收集信息流封面URL
    for (const feed of feeds.slice(0, 6)) {
      imageUrls.push(feed.coverUrl);
    }

    this.imagePreloader.addToPreloadQueue(imageUrls);
    // 在空闲时预加载图片
    this.imagePreloader.executePreload();
  }

  build() {
    Column() {
      if (this.isLoading) {
        this.SkeletonView();
      } else {
        // 轮播图区域
        Swiper() {
          ForEach(this.bannerList, (item: BannerItem) => {
            Image(item.imageUrl)
              .width('100%')
              .height(180)
              .borderRadius(8)
              .objectFit(ImageFit.Cover)
              .interpolation(ImageInterpolation.High)
          }, (item: BannerItem) => item.id);
        }
        .autoPlay(true)
        .interval(3000)
        .indicator(true)
        .height(180)
        .margin({ top: 12, left: 16, right: 16 })

        // 分类区域
        GridRow({ columns: 4 }) {
          ForEach(this.categoryList, (item: CategoryItem) => {
            GridCol() {
              Column() {
                Image(item.icon).width(40).height(40)
                Text(item.name).fontSize(12).margin({ top: 4 })
              }
              .justifyContent(FlexAlign.Center)
              .alignItems(HorizontalAlign.Center)
            }
          }, (item: CategoryItem) => item.id);
        }
        .margin({ top: 16, left: 16, right: 16 })

        // 信息流列表
        List({ space: 8 }) {
          ForEach(this.feedList, (item: FeedItem) => {
            ListItem() {
              Row() {
                Image(item.coverUrl)
                  .width(80)
                  .height(80)
                  .borderRadius(8)
                  .objectFit(ImageFit.Cover)
                Column() {
                  Text(item.title)
                    .fontSize(16)
                    .fontWeight(FontWeight.Bold)
                    .maxLines(2)
                    .textOverflow({ overflow: TextOverflow.Ellipsis })
                  Text(item.author)
                    .fontSize(12)
                    .fontColor('#999999')
                    .margin({ top: 8 })
                }
                .layoutWeight(1)
                .alignItems(HorizontalAlign.Start)
                .margin({ left: 12 })
              }
              .width('100%')
              .padding(12)
              .backgroundColor(Color.White)
              .borderRadius(8)
            }
          }, (item: FeedItem) => item.id);
        }
        .layoutWeight(1)
        .margin({ top: 16 })
        .padding({ left: 16, right: 16 })
      }
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#F5F5F5')
  }

  // 骨架屏
  @Builder
  SkeletonView() {
    Column() {
      Row() {
        Rect().width('100%').height(180).fill('#E0E0E0').radius(8);
      }.width('100%').padding(16);

      Row() {
        ForEach([1, 2, 3, 4], (item: number) => {
          Column() {
            Rect().width(40).height(40).fill('#E0E0E0').radius(20);
            Rect().width(30).height(10).fill('#E0E0E0').radius(4).margin({ top: 4 });
          }.layoutWeight(1);
        }, (item: number) => item.toString());
      }.width('100%').padding({ left: 16, right: 16, top: 16 });

      Column() {
        ForEach([1, 2, 3], (item: number) => {
          Row() {
            Rect().width(80).height(80).fill('#E0E0E0').radius(8);
            Column() {
              Rect().width('60%').height(16).fill('#E0E0E0').radius(4);
              Rect().width('40%').height(12).fill('#E0E0E0').radius(4).margin({ top: 8 });
            }.margin({ left: 12 });
          }.width('100%').padding(12).margin({ top: 8 });
        }, (item: number) => item.toString());
      }.padding({ left: 16, right: 16 });
    }
  }

  // 模拟数据请求
  private async fetchBanners(): Promise<BannerItem[]> { return []; }
  private async fetchFeeds(): Promise<FeedItem[]> { return []; }
  private async fetchCategories(): Promise<CategoryItem[]> { return []; }
}

// EntryAbility.ets - 在Ability中注册和执行预加载
import UIAbility from '@ohos.app.ability.UIAbility';
import { PreloadManager } from '../preload/PreloadManager';
import { LayoutPreloader } from '../preload/LayoutPreloader';
import { ImagePreloader } from '../preload/ImagePreloader';
import hilog from '@ohos.hilog';

const TAG = 'EntryAbility';
const DOMAIN = 0x0001;

export default class EntryAbility extends UIAbility {
  onCreate(want, launchParam): void {
    hilog.info(DOMAIN, TAG, 'Ability onCreate');

    // 第1步：注册预加载任务
    const preloadManager = PreloadManager.getInstance();
    preloadManager.registerTask('home_data', 'https://api.example.com/home', undefined, 0);
    preloadManager.registerTask('config_data', 'https://api.example.com/config', undefined, 1);

    // 第2步：立即执行预加载（与UI创建并行）
    preloadManager.executePreload(['home_data', 'config_data']);

    // 第3步：预加载布局模板
    const layoutPreloader = LayoutPreloader.getInstance();
    layoutPreloader.preloadTemplates();
  }

  onWindowStageCreate(windowStage): void {
    hilog.info(DOMAIN, TAG, 'WindowStage create');
    windowStage.loadContent('pages/Index');
  }

  onForeground(): void {
    hilog.info(DOMAIN, TAG, 'Ability onForeground');
  }

  onBackground(): void {
    // 后台时预加载下一页数据
    const preloadManager = PreloadManager.getInstance();
    preloadManager.registerTask('next_page_data', 'https://api.example.com/home?page=2', undefined, 5);
    preloadManager.executePreload(['next_page_data']);
  }
}

四、踩坑与注意事项

坑点1：预加载请求与正常请求重复

预加载发起的请求和页面正常加载的请求如果URL和参数完全相同，就会造成重复请求，浪费流量和服务器资源。解决方案：预加载管理器必须提供结果查询接口，页面加载前先检查预加载结果，命中则直接使用，未命中再发请求。

坑点2：预加载数据过期导致显示旧内容

预加载的数据可能已经过期，如果直接使用而不做新鲜度校验，用户可能看到过时的内容。解决方案：预加载结果必须携带时间戳，使用前检查是否在有效期内；同时支持"先展示缓存，后台刷新"的策略。

坑点3：预加载图片占用过多内存

预加载大量高清图片到内存中，虽然显示快了，但内存占用可能飙升，在低端设备上甚至导致OOM。解决方案：图片预加载使用降采样策略，只缓存适合屏幕尺寸的缩略图；同时设置缓存上限，超过上限自动淘汰最久未使用的图片。

坑点4：预加载时机不当拖慢启动

如果在Application.onCreate中发起了过多的预加载请求，反而会与启动流程竞争网络和CPU资源，导致启动变慢。解决方案：预加载请求应该分优先级，高优先级的在onCreate中发起，低优先级的延迟到首帧后或空闲时发起。

坑点5：预加载失败未做降级处理

预加载请求可能因为网络原因失败，如果页面只依赖预加载结果而不做降级处理，用户可能看到空白页面。解决方案：预加载失败时必须回退到正常加载流程，确保即使预加载全部失败，页面也能正常显示。

坑点6：忽略用户隐私和数据安全

预加载可能涉及用户个人信息（如个人主页数据），如果在未登录状态下就预加载这些数据，可能暴露用户信息。解决方案：预加载任务必须检查登录状态，涉及隐私的数据仅在已登录时预加载。

坑点7：预加载策略不随网络环境调整

在WiFi环境下可以大量预加载，但在移动数据环境下应该限制预加载量，否则用户可能投诉"你的App太费流量了"。解决方案：预加载策略应该根据当前网络类型动态调整——WiFi全量预加载、4G精简预加载、3G/2G不预加载。

五、HarmonyOS 6适配说明

API差异表

行为变更

1. 预加载请求自动去重：HarmonyOS 6的AppPreload框架自动识别和合并相同的预加载请求
2. 图片缓存自动管理：ImageCache根据内存压力自动淘汰缓存，无需手动管理
3. 预加载结果版本化：预加载结果携带版本号，自动处理数据格式变更

适配代码

// HarmonyOS 6 预加载适配 - 利用AppPreload框架
import AppPreload from '@ohos.app.ability.AppPreload';
import ImageCache from '@ohos.multimedia.ImageCache';

// preload_config.json - 声明式预加载配置
/*
{
  "preloadTasks": [
    {
      "taskId": "home_data",
      "url": "https://api.example.com/home",
      "priority": "critical",
      "networkPolicy": {
        "wifi": "full",
        "cellular": "essential",
        "offline": "skip"
      },
      "cachePolicy": {
        "ttl": 300000,
        "maxSize": "1MB"
      }
    },
    {
      "taskId": "home_images",
      "type": "image",
      "urls": [
        "https://cdn.example.com/banner1.jpg",
        "https://cdn.example.com/banner2.jpg"
      ],
      "priority": "high",
      "downsample": true,
      "targetWidth": 720
    }
  ]
}
*/

export default class HarmonyOS6PreloadAbility extends UIAbility {
  onCreate(want, launchParam): void {
    // 使用AppPreload框架执行声明式预加载
    const appPreload = AppPreload.getInstance();
    appPreload.execute('preload_config.json').then(() => {
      hilog.info(DOMAIN, TAG, '声明式预加载全部完成');
    }).catch((error) => {
      hilog.error(DOMAIN, TAG, `预加载执行失败: ${JSON.stringify(error)}`);
    });

    // 配置图片缓存
    const imageCache = ImageCache.getInstance();
    imageCache.setMaxMemorySize(50 * 1024 * 1024);  // 50MB缓存上限
    imageCache.setDownsampleEnabled(true);            // 启用降采样
  }
}

六、总结

三维度评价表

一句话总结：预加载是启动优化的"提前量"策略——在用户还没到达之前就把资源准备好，让首页数据"即开即有"，但必须精确计算预加载的时机、范围和量，避免过犹不及。

下篇预告：《HarmonyOS开发：延迟初始化与懒加载策略》——预加载是"提前做"，懒加载是"延后做"，两者如何平衡？下一篇为你揭晓！