Harmony学习之应用生命周期管理

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

HarmonyOS应用生命周期管理详解

一、实际应用场景引入

在前一篇文章中，小明实现了登录后的页面跳转功能。接下来，他需要进一步优化应用在不同运行状态下的资源管理能力。例如：当用户将应用切换至后台时，应暂停不必要的网络请求；当应用从前台恢复时，需重新加载最新的用户信息；而在应用被系统销毁前，则必须清除定时器并释放缓存数据。本文将系统性地讲解HarmonyOS中的应用生命周期机制，帮助开发者科学管理资源分配与回收。

二、生命周期架构概览

从HarmonyOS 5 API 12版本开始，其生命周期模型采用分层设计，覆盖了从应用启动到终止的全过程，各层级职责明确：

层级	核心作用	典型使用场景
Application	提供全局上下文，管理共享资源	初始化全局服务、注册异常捕获机制
UIAbility	控制功能模块的生命周期	首页Ability加载用户资产信息
页面（@Entry）	处理页面级UI展示和交互逻辑	转账页面显示时同步刷新账户余额
组件（@Component）	管理独立UI单元的渲染与释放	行情组件销毁时取消实时数据订阅

三、Application 层生命周期详解

Application作为整个应用的全局实例，贯穿应用从创建到销毁的全过程，负责维护所有Ability共用的状态和资源。

1. 关键生命周期方法

import UIAbility from '@ohos.app.ability.UIAbility';
import window from '@ohos.window';
import { EncryptUtil } from '../common/EncryptUtil'; // 加密工具类

export default class EntryAbility extends UIAbility {
  // 1. Ability创建时触发
  onCreate(want: Want, launchParam: AbilityConstant.LaunchParam) {
    console.log('Ability创建:初始化全局状态');
    // 金融场景:解密并加载本地存储的用户Token
    EncryptUtil.decryptUserToken();
    
    // 初始化全局服务
    this.initGlobalServices();
  }

  // 2. 窗口舞台创建时触发
  onWindowStageCreate(windowStage: window.WindowStage) {
    console.log('窗口舞台创建:加载首页UI');
    // 必须在此回调中加载UI页面
    windowStage.loadContent('pages/Index', (err, data) => {
      if (err) {
        console.error('加载页面失败:', err);
        return;
      }
      console.log('页面加载成功');
    });

    // 配置窗口属性
    windowStage.getMainWindow((err, mainWindow) => {
      if (err) {
        console.error('获取主窗口失败:', err);
        return;
      }
      // 设置窗口背景色
      mainWindow.setWindowBackgroundColor('#FFFFFF');
    });
  }

  // 3. Ability进入前台时触发
  onForeground() {
    console.log('Ability回到前台:恢复服务');
    // 恢复在后台时暂停的操作
    this.resumeServices();
  }

  // 4. Ability进入后台时触发
  onBackground() {
    console.log('Ability进入后台:暂停服务');
    // 释放非必要资源，降低内存占用
    this.releaseResources();
  }

  // 5. 窗口舞台销毁时触发
  onWindowStageDestroy() {
    console.log('窗口舞台销毁:清理UI资源');
    // 释放窗口相关资源
    this.cleanupWindowResources();
  }

  // 6. Ability销毁时触发
  onDestroy() {
    console.log('Ability销毁:释放所有资源');
    // 清理全局资源
    this.cleanupGlobalResources();
  }

  // 7. 系统配置变化时触发（如屏幕旋转）
  onConfigurationUpdated(config: Configuration) {
    console.log('系统配置变化:适配新配置');
    // 适配横竖屏布局
    this.adaptLayout(config);
  }

  // 8. 系统内存不足时触发
  onTrimMemory(level: number) {
    console.log('系统内存不足:释放非核心资源');
    // 根据紧急程度释放资源
    this.releaseMemory(level);
  }
}

2. 各方法触发时机与用途说明

生命周期方法	触发条件	常见用途
onCreate()	Ability首次被创建时调用	初始化Ability专属资源，获取运行上下文
onWindowStageCreate()	窗口舞台完成初始化后触发	加载主页面UI，配置窗口样式属性
onForeground()	Ability由后台返回前台时执行	恢复网络连接，刷新界面数据
onBackground()	Ability进入后台运行状态时调用	暂停耗电操作如网络拉取，释放非必要资源
onWindowStageDestroy()	窗口舞台即将被销毁时触发	清理与UI相关的资源引用
onDestroy()	Ability即将被系统销毁时调用	释放全部持有资源，持久化关键数据
onConfigurationUpdated()	设备配置发生变更（如横竖屏切换、语言更改）	动态适配新的界面布局或语言环境
onTrimMemory()	系统内存紧张发出警告	主动释放缓存等非核心资源以降低占用

四、页面级生命周期管理

页面是通过

@Entry

装饰的特殊组件类型，在继承基本组件生命周期的基础上，额外支持页面可见性相关的回调函数。

1. 页面生命周期方法图示

@Entry
@Component
struct HomePage {
  @State userBalance: number = 0;
  private timerId: number = -1;

  // 1. 组件即将显示时触发（在build()之前）
  aboutToAppear() {
    console.log('页面即将显示:初始化数据');
    // 加载页面数据
    this.loadUserData();
  }

  // 2. 页面每次显示时触发
  onPageShow() {
    console.log('页面显示:刷新实时数据');
    // 启动定时器刷新数据
    this.startDataRefresh();
  }

  // 3. 页面每次隐藏时触发
  onPageHide() {
    console.log('页面隐藏:暂停操作');
    // 停止定时器
    this.stopDataRefresh();
  }

  // 4. 组件即将销毁时触发
  aboutToDisappear() {
    console.log('页面即将销毁:清理资源');
    // 清理定时器、解绑事件
    this.cleanup();
  }

  // 5. build()执行完毕后触发（API 12新增）
  onDidBuild() {
    console.log('页面构建完成:初始化UI');
    // 不建议在此修改状态变量
    this.initUI();
  }

  // 6. 用户点击返回按钮时触发
  onBackPress(): boolean {
    console.log('返回按钮被点击');
    // 返回true表示拦截返回，false表示允许返回
    return this.confirmExit();
  }

  build() {
    Column({ space: 20 }) {
      Text('我的资产')
        .fontSize(20)
        .fontWeight(FontWeight.Bold)
      
      Text(`总资产:${this.userBalance.toFixed(2)}元`)
        .fontSize(18)
    }
    .width('100%')
    .padding(16)
  }

  // 模拟数据加载
  private loadUserData() {
    // 实际场景:调用API获取用户数据
    this.userBalance = 50000;
  }

  // 启动数据刷新定时器
  private startDataRefresh() {
    this.timerId = setInterval(() => {
      // 模拟数据变化
      this.userBalance += Math.random() * 100 - 50;
    }, 5000);
  }

  // 停止数据刷新
  private stopDataRefresh() {
    if (this.timerId !== -1) {
      clearInterval(this.timerId);
      this.timerId = -1;
    }
  }

  // 清理资源
  private cleanup() {
    this.stopDataRefresh();
  }

  // 确认退出
  private confirmExit(): boolean {
    // 实际场景:检查是否有未保存的数据
    return false; // 允许返回
  }
}

2. 方法对比与使用场景分析

方法	触发时机	执行次数	典型用途
aboutToAppear()	组件第一次被构建时	仅一次	初始化数据源，注册事件监听
onPageShow()	每次页面重新显示时触发	可多次	更新实时数据，启动过渡动画
onPageHide()	页面被隐藏（跳转或最小化）时调用	可多次	暂停播放、保存临时状态
aboutToDisappear()	组件即将被销毁前执行	仅一次	清除定时任务，移除事件绑定
onDidBuild()	build()方法执行完成后调用	仅一次	完成UI初始化，上报页面加载性能指标
onBackPress()	用户点击返回按钮时触发	可多次	弹出确认对话框，拦截误操作

五、组件级生命周期管理

普通组件由

@Component

装饰，其生命周期相对简洁，主要集中在创建与销毁两个阶段。

1. 组件生命周期方法示意图

@Component
struct MarketCard {
  @State price: number = 0;
  private timerId: number = -1;

  build() {
    Column() {
      Text(`实时金价:${this.price.toFixed(2)}元/g`)
        .fontSize(16)
        .padding(10)
    }
    .backgroundColor('#f5f5f5')
    .borderRadius(8)
  }

  // 组件即将显示时触发
  aboutToAppear() {
    console.log('行情卡片:开始监听实时价格');
    this.startPriceRefresh();
  }

  // 组件即将销毁时触发
  aboutToDisappear() {
    console.log('行情卡片:即将销毁,准备清理资源');
    this.stopPriceRefresh();
  }

  // build()执行完毕后触发
  onDidBuild() {
    console.log('行情卡片:构建完成');
    // 不建议在此修改状态变量
  }

  // 启动价格刷新定时器
  private startPriceRefresh() {
    this.timerId = setInterval(() => {
      this.price += Math.random() * 2 - 1; // 模拟价格波动
    }, 3000);
  }

  // 停止价格刷新
  private stopPriceRefresh() {
    if (this.timerId !== -1) {
      clearInterval(this.timerId);
      this.timerId = -1;
    }
  }
}

2. 生命周期方法对比表

方法	触发时机	执行次数	典型用途
aboutToAppear()	组件首次被实例化时	仅一次	初始化内部状态，启动周期性任务
aboutToDisappear()	组件即将被卸载时	仅一次	停止定时器，解绑事件监听器
onDidBuild()	UI构建流程结束后触发	仅一次	执行UI相关初始化逻辑，发送埋点数据

六、生命周期调用顺序流程图

了解各个阶段的方法调用顺序有助于精准控制资源行为：

• 应用启动过程：

  App进程启动
  ↓
  Application.onCreate() → 初始化全局服务
  ↓
  UIAbility.onCreate() → 初始化Ability级资源
  ↓
  UIAbility.onWindowStageCreate() → 加载UI页面
  ↓
  UIAbility.onForeground() → 应用进入前台
  ↓
  页面.aboutToAppear() → 页面即将显示
  ↓
  页面.build() → 构建UI结构
  ↓
  页面.onDidBuild() → build执行完毕
  ↓
  页面.onPageShow() → 页面显示

• 应用退至后台：

  用户切换到其他应用
  ↓
  页面.onPageHide() → 页面隐藏
  ↓
  UIAbility.onBackground() → 应用进入后台

• 应用从前台恢复：

  用户切回应用
  ↓
  UIAbility.onForeground() → 应用回到前台
  ↓
  页面.onPageShow() → 页面显示

• 应用最终销毁：

  用户退出应用
  ↓
  页面.onPageHide() → 页面隐藏
  ↓
  页面.aboutToDisappear() → 页面即将销毁
  ↓
  UIAbility.onWindowStageDestroy() → 窗口舞台销毁
  ↓
  UIAbility.onDestroy() → Ability销毁
  ↓
  Application.onDestroy() → 应用销毁

七、实战案例：登录状态全链路管理

以下是一个整合多层级生命周期的完整示例，用于实现稳定的登录状态维护。

1. Application 层全局状态维护

// src/main/ets/Application.ts
import { Application } from '@ohos.app.ability.Application';
import { GlobalStateManager } from './common/GlobalStateManager';

export default class MyApplication extends Application {
  onCreate() {
    console.log('应用启动:初始化全局状态');
    // 初始化全局状态管理器
    GlobalStateManager.getInstance().init();
    
    // 注册崩溃监控
    this.registerCrashMonitor();
  }

  onDestroy() {
    console.log('应用销毁:清理全局资源');
    // 清理全局资源
    GlobalStateManager.getInstance().cleanup();
  }

  private registerCrashMonitor() {
    // 实际场景:注册崩溃监控服务
  }
}

2. UIAbility 层登录逻辑处理

// src/main/ets/entryability/EntryAbility.ts
import UIAbility from '@ohos.app.ability.UIAbility';
import window from '@ohos.window';
import { UserManager } from '../common/UserManager';

export default class EntryAbility extends UIAbility {
  onCreate(want: Want, launchParam: AbilityConstant.LaunchParam) {
    console.log('Ability创建:初始化用户状态');
    // 检查用户登录状态
    const isLoggedIn = UserManager.getInstance().isLoggedIn();
    
    if (isLoggedIn) {
      // 已登录，直接跳转到首页
      this.navigateToHome();
    } else {
      // 未登录，跳转到登录页
      this.navigateToLogin();
    }
  }

  onWindowStageCreate(windowStage: window.WindowStage) {
    console.log('窗口舞台创建:加载UI页面');
    // 根据登录状态加载不同页面
    const isLoggedIn = UserManager.getInstance().isLoggedIn();
    const targetPage = isLoggedIn ? 'pages/Home' : 'pages/Login';
    
    windowStage.loadContent(targetPage, (err, data) => {
      if (err) {
        console.error('加载页面失败:', err);
        return;
      }
      console.log('页面加载成功');
    });
  }

  onForeground() {
    console.log('Ability回到前台:验证登录状态');
    // 检查登录状态是否过期
    this.checkLoginStatus();
  }

  onBackground() {
    console.log('Ability进入后台:保存用户数据');
    // 保存用户数据到本地
    UserManager.getInstance().saveUserData();
  }

  onDestroy() {
    console.log('Ability销毁:清理资源');
    // 清理资源
    UserManager.getInstance().cleanup();
  }

  private navigateToHome() {
    // 实际场景:跳转到首页
  }

  private navigateToLogin() {
    // 实际场景:跳转到登录页
  }

  private checkLoginStatus() {
    // 实际场景:检查登录状态是否过期
    const isExpired = UserManager.getInstance().isTokenExpired();
    if (isExpired) {
      // 登录过期，跳转到登录页
      this.navigateToLogin();
    }
  }
}

3. 页面层数据同步策略

// src/main/ets/pages/Home.ets
import router from '@ohos.router';
import { UserManager } from '../common/UserManager';

@Entry
@Component
struct Home {
  @State userInfo: any = {};
  @State balance: number = 0;
  private dataRefreshTimer: number = -1;

  aboutToAppear() {
    console.log('首页即将显示:加载用户数据');
    // 加载用户信息
    this.loadUserInfo();
  }

  onPageShow() {
    console.log('首页显示:启动数据刷新');
    // 启动定时器刷新数据
    this.startDataRefresh();
  }

  onPageHide() {
    console.log('首页隐藏:停止数据刷新');
    // 停止定时器
    this.stopDataRefresh();
  }

  aboutToDisappear() {
    console.log('首页即将销毁:清理资源');
    // 清理资源
    this.cleanup();
  }

  onBackPress(): boolean {
    console.log('返回按钮被点击');
    // 确认退出应用
    promptAction.showDialog({
      title: '确认退出',
      message: '确定要退出应用吗？',
      buttons: [
        { text: '取消', color: '#666666' },
        { text: '确定', color: '#FF3B30' }
      ]
    }).then((result) => {
      if (result.index === 1) {
        // 确定退出
        this.exitApp();
      }
    });
    return true; // 拦截默认返回行为
  }

  build() {
    Column({ space: 20 }) {
      Text(`欢迎回来，${this.userInfo.name || '用户'}`)
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
      
      Text(`账户余额: ${this.balance.toFixed(2)}元`)
        .fontSize(18)
      
      Button('退出登录')
        .width(200)
        .onClick(() => {
          this.logout();
        })
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
  }

  // 加载用户信息
  private loadUserInfo() {
    const userInfo = UserManager.getInstance().getUserInfo();
    this.userInfo = userInfo;
    this.balance = userInfo.balance || 0;
  }

  // 启动数据刷新定时器
  private startDataRefresh() {
    this.dataRefreshTimer = setInterval(() => {
      // 模拟数据刷新
      this.balance += Math.random() * 10 - 5;
    }, 10000);
  }

  // 停止数据刷新
  private stopDataRefresh() {
    if (this.dataRefreshTimer !== -1) {
      clearInterval(this.dataRefreshTimer);
      this.dataRefreshTimer = -1;
    }
  }

  // 清理资源
  private cleanup() {
    this.stopDataRefresh();
  }

  // 退出登录
  private logout() {
    promptAction.showDialog({
      title: '确认退出登录',
      message: '确定要退出登录吗？',
      buttons: [
        { text: '取消', color: '#666666' },
        { text: '确定', color: '#FF3B30' }
      ]
    }).then((result) => {
      if (result.index === 1) {
        // 清除登录状态
        UserManager.getInstance().logout();
        // 跳转到登录页
        router.replaceUrl({
          url: 'pages/Login'
        });
      }
    });
  }

  // 退出应用
  private exitApp() {
    // 实际场景:退出应用
    AppControl.terminate();
  }
}

八、最佳实践与注意事项

1. 生命周期方法使用建议对照表

方法	推荐操作	应避免的操作
onCreate()	设置全局配置项，获取应用上下文	执行耗时任务，直接操作UI渲染
onWindowStageCreate()	加载主页面，设定窗口特性	发起大量网络请求导致阻塞
onForeground()	恢复网络通信，拉取最新数据	进行长时间计算或密集I/O操作
onBackground()	暂停网络活动，释放视觉资源	执行复杂逻辑影响响应速度
aboutToAppear()	准备页面所需初始数据，订阅消息	在其中进行高开销运算
onPageShow()	刷新动态内容，播放入场动画	执行阻塞性任务
onPageHide()	暂停媒体播放，记录当前状态	执行耗时保存操作
aboutToDisappear()	清理定时器，解除事件绑定	修改页面状态变量引发重绘

2. 性能优化建议

• 禁止在生命周期钩子中执行耗时操作：

  // ? 不推荐：在生命周期方法中执行耗时操作
  aboutToAppear() {
    // 耗时网络请求
    this.fetchDataFromServer(); // 可能导致页面卡顿
  }
  
  // ? 推荐：使用异步任务
  aboutToAppear() {
    // 启动异步任务
    TaskPool.execute(async () => {
      const data = await this.fetchDataFromServer();
      // 更新UI
      this.updateUI(data);
    });
  }

• 合理规划资源释放时机：

  onBackground() {
    // 释放非必要资源
    this.releaseMemory();
    
    // 保存用户数据
    this.saveUserData();
  }
  
  aboutToDisappear() {
    // 清理定时器
    this.cleanupTimers();
    
    // 解绑事件监听
    this.unbindEvents();
  }

3. 常见问题及应对方案

• 问题一：内存泄漏 —— 未及时注销监听或清除引用

  // ? 错误：未清理定时器
  aboutToAppear() {
    this.timerId = setInterval(() => {
      // 定时任务
    }, 1000);
  }
  
  // ? 正确：在aboutToDisappear中清理
  aboutToDisappear() {
    if (this.timerId !== -1) {
      clearInterval(this.timerId);
      this.timerId = -1;
    }
  }

• 问题二：界面状态不一致 —— 生命周期回调未正确同步数据

  // ? 错误：在onPageHide中修改状态
  onPageHide() {
    this.userInfo = null; // 可能导致状态不一致
  }
  
  // ? 正确：在aboutToDisappear中清理
  aboutToDisappear() {
    this.userInfo = null;
  }

• 问题三：后台仍存在网络请求 —— 未在onBackground中取消订阅

  // ? 错误：未取消网络请求
  aboutToAppear() {
    this.requestId = http.request({
      // 请求配置
    });
  }
  
  // ? 正确：在aboutToDisappear中取消请求
  aboutToDisappear() {
    if (this.requestId) {
      http.cancelRequest(this.requestId);
      this.requestId = undefined;
    }
  }

九、总结与后续行动指南

核心知识点回顾

生命周期体系结构：熟练掌握Application、UIAbility、页面、组件四个层级的生命周期管理机制。

关键生命周期方法：深入理解以下核心方法的作用与调用时机：

• onCreate

• onWindowStageCreate

• onForeground

• onBackground

• onDestroy

页面级生命周期方法：重点掌握以下方法的应用场景：

• aboutToAppear

• onPageShow

• onPageHide

• aboutToDisappear

• onBackPress

组件级生命周期方法：熟悉以下常用方法的使用规范：

• aboutToAppear

• aboutToDisappear

组件级方法的调用顺序是理解应用运行机制的关键。掌握在应用启动、前后台切换以及应用销毁过程中生命周期方法的执行流程，有助于开发者合理组织代码逻辑，确保程序行为符合预期。

建议通过实际操作加深理解：

• 动手实践：参考本文提供的示例，完整实现登录状态的管理逻辑，巩固对生命周期的应用能力。
• 生命周期调试：在各个生命周期方法中插入日志输出，观察其调用时机与顺序，明确不同场景下的执行路径。
• 性能优化：审查现有代码结构，确认耗时操作或资源加载是否在合适的生命周期阶段执行，避免造成卡顿或异常。
• 资源管理：确保定时器、网络请求、事件监听等动态资源在组件销毁时被及时释放，防止内存泄漏或后台无效运行。
• 状态管理：合理运用

  @State

  、

  @Prop

  、

  @Link

  等装饰器来维护和更新组件的状态数据。

onDidBuild

通过本篇文章的学习，你已经掌握了 HarmonyOS 应用生命周期管理的核心技能。下一篇文章将聚焦于网络请求与数据获取的实现方式，指导你如何从服务器拉取数据并将其展示在界面中。

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏0 回帖

关键词：Harmony 生命周期 Harm ARM Mon