鸿蒙6.0 Ability Kit实战解析：Stage模型与组件开发全攻略

鸿蒙专家

Ability Kit 是鸿蒙（HarmonyOS）应用框架的核心组件，作为应用原子化服务的载体，它定义了应用的呈现方式、交互逻辑和生命周期管理。在鸿蒙 6.0 版本中，Ability Kit 迎来了深度优化：更高效的生命周期调度、增强的跨设备流转能力，以及对 HAR/HSP 模块化开发的原生支持。这些改进为构建复杂分布式应用提供了坚实基础。

本文将从 Stage 模型架构入手，通过可执行代码演示 UIAbility 生命周期、Context 体系、Want 通信机制以及 ExtensionAbility 的后台服务能力，帮助开发者快速掌握鸿蒙 6.0 的组件开发实践。

一、Stage 模型核心架构

鸿蒙应用模型经历了从 FA 模型到 Stage 模型的升级。Stage 模型在鸿蒙 3.0 引入，将应用组件划分为 UIAbility 和 ExtensionAbility 两大类，配合 AbilityStage 组件容器层，实现了更细粒度的资源管控和业务解耦。

Stage 模型采用三层架构：应用层（Application）→ 组件容器层（AbilityStage）→ 组件层（UIAbility / ExtensionAbility）。编译期每个 Module 对应一个 AbilityStage 实例，运行期按需创建 UIAbility 或 ExtensionAbility。核心优势包括多实例支持、精细化资源管控、模块化开发友好（通过 HAR 和 HSP 实现跨模块共享）。

核心概念中，HAP 是最终交付包（Entry / Feature），HAR 是静态共享包（源码编译到依赖方 bundle），HSP 是鸿蒙 6.0 主推的动态共享方案（运行时按需加载）。Context 体系分三层：ApplicationContext（应用级）、AbilityStageContext（模块级）、UIAbilityContext（组件级）。WindowStage 是 Ability 的窗口管理器，每个 UIAbility 对应一个 WindowStage 实例。

二、UIAbility 生命周期实战

UIAbility 生命周期包含六个核心回调：onCreate() → onWindowStageCreate() → onForeground() → onBackground() → onWindowStageDestroy() → onDestroy()。其中 onCreate 适合非 UI 资源初始化（数据库、网络配置）；onWindowStageCreate 用于加载页面内容；onForeground / onBackground 对应前台/后台状态切换；onWindowStageDestroy 清理窗口资源；onDestroy 做最终释放。

以下是一个完整的 EntryAbility 实现，展示了每个回调的标准用法：

2. // EntryAbility.ets - 入口Ability完整实现
3. import { UIAbility, AbilityConstant, Want } from '@kit.AbilityKit';
4. import { window } from '@kit.ArkUI';
5. import { hilog } from '@kit.PerformanceAnalysisKit';
7. const TAG = 'EntryAbility';
8. const DOMAIN = 0x0001;
10. export default class EntryAbility extends UIAbility {
11.   onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
12.     hilog.info(DOMAIN, TAG, 'onCreate called');
13.     if (launchParam.launchReason === AbilityConstant.LaunchReason.APP_START) {
14.       hilog.info(DOMAIN, TAG, '应用冷启动');
15.     } else if (launchParam.launchReason === AbilityConstant.LaunchReason.COLD_START) {
16.       hilog.info(DOMAIN, TAG, '组件冷启动');
17.     }
18.     this.initDatabase();
19.   }
21.   onWindowStageCreate(windowStage: window.WindowStage): void {
22.     hilog.info(DOMAIN, TAG, 'onWindowStageCreate called');
23.     windowStage.getMainWindow().then((win) => {
24.       win.setWindowLayoutFullScreen(true);
25.     });
26.     windowStage.loadContent('pages/Index', (err, data) => {
27.       if (err.code) {
28.         hilog.error(DOMAIN, TAG, '页面加载失败: %{public}s', JSON.stringify(err));
29.         return;
30.       }
31.       hilog.info(DOMAIN, TAG, '页面加载成功');
32.     });
33.   }
35.   onForeground(): void {
36.     hilog.info(DOMAIN, TAG, 'onForeground - 恢复前台操作');
37.     AppStorage.setOrCreate('appState', 'foreground');
38.   }
40.   onBackground(): void {
41.     hilog.info(DOMAIN, TAG, 'onBackground - 进入后台');
42.     AppStorage.setOrCreate('appState', 'background');
43.   }
45.   onWindowStageDestroy(): void {
46.     hilog.info(DOMAIN, TAG, 'onWindowStageDestroy - 清理窗口');
47.   }
49.   onDestroy(): void {
50.     hilog.info(DOMAIN, TAG, 'onDestroy - 执行最终清理');
51.     this.closeDatabase();
52.   }
54.   onNewWant(want: Want, launchParam: AbilityConstant.LaunchParam): void {
55.     hilog.info(DOMAIN, TAG, 'onNewWant called');
56.     if (launchParam.launchReason === AbilityConstant.LaunchReason.START_ABILITY) {
57.       // 处理新的启动请求
58.     }
59.   }
61.   private initDatabase(): void {
62.     hilog.info(DOMAIN, TAG, '初始化数据库连接');
63.   }
65.   private closeDatabase(): void {
66.     hilog.info(DOMAIN, TAG, '关闭数据库连接');
67.   }
68. }

复制代码

UIAbility 支持三种启动模式，通过 module.json5 的 launchType 配置：singleton（单实例）、standard（多实例）、specified（指定实例）。配置示例：

2. {
3.   "abilities": [
4.     {
5.       "name": "EntryAbility",
6.       "srcEntry": "./ets/entryability/EntryAbility.ets",
7.       "description": "$string:entryability_desc",
8.       "icon": "$media:icon",
9.       "label": "$string:entryability_label",
10.       "startWindowIcon": "$media:icon",
11.       "startWindowBackground": "$color:start_window_background",
12.       "exported": true,
13.       "launchType": "singleton",
14.       "skills": [
15.         {
16.           "entities": ["entity.system.home"],
17.           "actions": ["action.system.home"]
18.         }
19.       ]
20.     }
21.   ]
22. }

复制代码

三、Context 与组件交互

Context 是访问系统能力的入口。三层关系：UIAbilityContext ⊂ AbilityStageContext ⊂ ApplicationContext。子层级可访问父层级全部能力并获得组件特有权限。

在 ArkUI 页面中，使用 getContext(this) 获取当前 UIAbilityContext，然后可启动其他 Ability、获取结果、终止自身等。以下为完整示例：

2. // ContextDemo.ets - Context使用完整示例
3. import { common, Want } from '@kit.AbilityKit';
4. import { BusinessError } from '@kit.BasicServicesKit';
5. import { hilog } from '@kit.PerformanceAnalysisKit';
7. const TAG = 'ContextDemo';
8. const DOMAIN = 0x0002;
10. @Entry
11. @Component
12. struct ContextDemo {
13.   private abilityContext = getContext(this) as common.UIAbilityContext;
15.   async startTargetAbility(): Promise<void> {
16.     let want: Want = {
17.       bundleName: this.abilityContext.abilityInfo.bundleName,
18.       abilityName: 'TargetAbility',
19.       moduleName: this.abilityContext.abilityInfo.moduleName,
20.       parameters: {
21.         message: '来自Ability Kit的问候',
22.         timestamp: Date.now(),
23.         userData: {
24.           name: 'HarmonyOS',
25.           version: '6.0'
26.         }
27.       }
28.     };
29.     try {
30.       this.abilityContext.startAbility(want, (err: BusinessError) => {
31.         if (err.code) {
32.           hilog.error(DOMAIN, TAG, '启动失败: %{public}s', err.message);
33.           return;
34.         }
35.         hilog.info(DOMAIN, TAG, 'TargetAbility启动成功');
36.       });
37.     } catch (err) {
38.       let error = err as BusinessError;
39.       hilog.error(DOMAIN, TAG, '启动异常: %{public}d %{public}s', error.code, error.message);
40.     }
41.   }
43.   async startByImplicitWant(): Promise<void> {
44.     let want: Want = {
45.       action: 'ohos.want.action.viewData',
46.       entities: ['entity.system.browser'],
47.       uri: 'https://www.example.com'
48.     };
49.     try {
50.       await this.abilityContext.startAbility(want);
51.     } catch (err) {
52.       let error = err as BusinessError;
53.       hilog.error(DOMAIN, TAG, '隐式启动失败: %{public}d', error.code);
54.     }
55.   }
57.   async startForResult(): Promise<void> {
58.     let want: Want = {
59.       bundleName: 'com.example.target',
60.       abilityName: 'ResultAbility',
61.       parameters: {
62.         requestCode: 'SELECT_IMAGE'
63.       }
64.     };
65.     this.abilityContext.startAbilityForResult(want).then((result) => {
66.       if (result.resultCode === 0) {
67.         hilog.info(DOMAIN, TAG, '获取结果: %{public}s', JSON.stringify(result.want?.parameters));
68.       }
69.     }).catch((err: BusinessError) => {
70.       hilog.error(DOMAIN, TAG, '获取结果失败: %{public}s', err.message);
71.     });
72.   }
74.   terminateCurrent(): void {
75.     this.abilityContext.terminateSelf();
76.   }
78.   terminateWithResult(): void {
79.     let want: Want = {
80.       parameters: {
81.         result: '操作完成',
82.         success: true
83.       }
84.     };
85.     this.abilityContext.terminateSelfWithResult(want);
86.   }
88.   getAppContext(): void {
89.     let appContext = this.abilityContext.getApplicationContext();
90.     hilog.info(DOMAIN, TAG, '应用ID: %{public}s', appContext.info.bundleName);
91.   }
93.   build() {
94.     Column({ space: 16 }) {
95.       Text('Context 操作演示')
96.         .fontSize(24).fontWeight(FontWeight.Bold).width('100%').textAlign(TextAlign.Center);
97.       Divider().color('#E0E0E0');
98.       Column({ space: 12 }) {
99.         Text('启动Ability').fontSize(16).fontWeight(FontWeight.Medium).width('100%');
100.         Button('显式启动目标Ability').width('100%').height(48)
101.           .onClick(() => this.startTargetAbility());
102.         Button('隐式启动浏览器').width('100%').height(48)
103.           .onClick(() => this.startByImplicitWant());
104.         Button('启动并获取结果').width('100%').height(48).type(ButtonType.Normal)
105.           .onClick(() => this.startForResult());
106.       }
107.       Divider().color('#E0E0E0').margin({ top: 16, bottom: 16 });
108.       Column({ space: 12 }) {
109.         Text('终止操作').fontSize(16).fontWeight(FontWeight.Medium).width('100%');
110.         Button('终止当前Ability').width('100%').height(48).backgroundColor(Color.Red)
111.           .onClick(() => this.terminateCurrent());
112.         Button('携带结果终止').width('100%').height(48).backgroundColor(Color.Orange)
113.           .onClick(() => this.terminateWithResult());
114.       }
115.       Divider().color('#E0E0E0').margin({ top: 16, bottom: 16 });
116.       Button('获取应用Context').width('100%').height(48).type(ButtonType.Normal)
117.         .onClick(() => this.getAppContext());
118.     }
119.     .padding(20).width('100%').height('100%');
120.   }
121. }

复制代码

四、Want 通信机制

Want 是 HarmonyOS 组件间通信的核心载体，包含 bundleName、abilityName、moduleName、uri、action、entities、parameters 等字段。显式 Want 直接指定包名和能力名；隐式 Want 通过 action/entities/uri 让系统匹配，适用于跨应用调用。

以下演示显式 Want 和隐式 Want 的使用：

2. // WantStructDemo.ets - Want使用示例
3. import { Want, common } from '@kit.AbilityKit';
4. import { BusinessError } from '@kit.BasicServicesKit';
6. @Entry
7. @Component
8. struct WantStructDemo {
9.   private context = getContext(this) as common.UIAbilityContext;
11.   startExplicitAbility(): void {
12.     const want: Want = {
13.       bundleName: 'com.example.myapp',
14.       abilityName: 'DetailAbility',
15.       moduleName: 'entry',
16.       parameters: {
17.         id: '12345',
18.         type: 'product',
19.         from: 'list'
20.       }
21.     };
22.     this.context.startAbility(want)
23.       .then(() => console.info('显式启动成功'))
24.       .catch((err: BusinessError) => console.error(`启动失败: ${err.code}`));
25.   }
27.   startImplicitAbility(): void {
28.     const want: Want = {
29.       action: 'ohos.want.action.viewData',
30.       entities: ['entity.system.browsable'],
31.       uri: 'https://www.harmonyos.com',
32.       type: 'text/plain',
33.       parameters: {
34.         key: 'customValue'
35.       }
36.     };
37.     this.context.startAbility(want)
38.       .then(() => console.info('隐式启动成功'))
39.       .catch((err: BusinessError) => console.error(`隐式启动失败: ${err.code}`));
40.   }
42.   build() {
43.     Column({ space: 20 }) {
44.       Text('Want 通信机制演示').fontSize(20).fontWeight(FontWeight.Bold);
45.       Button('显式启动').onClick(() => this.startExplicitAbility());
46.       Button('隐式启动').onClick(() => this.startImplicitAbility());
47.     }.padding(20);
48.   }
49. }

复制代码

五、ExtensionAbility 扩展能力

ExtensionAbility 用于实现后台服务、自定义功能等。以 ServiceExtensionAbility 为例，它支持长时间运行的 background 任务和跨进程通信。以下示例展示了后台服务 Ability 的实现，通过 RPC 与客户端通信：

2. // MyServiceExtensionAbility.ets - 后台服务Ability
3. import { ServiceExtensionAbility, Want, AbilityConstant } from '@kit.AbilityKit';
4. import { rpc } from '@kit.IPCKit';
5. import { hilog } from '@kit.PerformanceAnalysisKit';
7. const TAG = 'MyServiceExtension';
8. const DOMAIN = 0x0003;
10. class MyRemoteStub extends rpc.RemoteStub {
11.   onRemoteRequest(code: number, data: rpc.MessageParcel): boolean {
12.     hilog.info(DOMAIN, TAG, '收到请求: code=%{public}d', code);
13.     switch (code) {
14.       case 1: // 获取数据
15.         let response = data.readString();
16.         hilog.info(DOMAIN, TAG, '客户端数据: %{public}s', response);
17.         break;
18.       default:
19.         return false;
20.     }
21.     return true;
22.   }
23. }

复制代码

实际开发中，需在 module.json5 中声明 extensionAbility，并配置后台权限。ServiceExtensionAbility 常与前台 UIAbility 配合，通过 Want 通信交互，适合处理下载、数据同步等后台任务。

总结
鸿蒙 6.0 的 Ability Kit 在 Stage 模型基础上，提供了更加精细的生命周期管理、灵活的 Context 体系以及强大的 Want 通信机制。通过本文提供的完整代码示例，开发者可以快速搭建起具备多实例、模块化、跨组件通信能力的应用。后续实践中，可结合最新 HSP 动态加载技术，进一步优化大型应用的结构和包体积。

热心网友7

感谢楼主分享这么详细的实战解析！代码示例很清晰，特别是 onCreate 里区分冷启动类型和 onWindowStageCreate 设置全屏的逻辑，很实用。想请教一下楼主，在鸿蒙 6.0 中，HSP 动态共享包和之前的 HAR 包在使用上有什么特别注意的地方吗？另外帖子提到增强的跨设备流转能力，能否再具体说说在代码层面是怎么对接 Want 通信来实现的？期待后续更多干货！