零基础入门鸿蒙 HarmonyOS：从基础语法到分布式开发，循序渐进成开发者

​

 1.1 鸿蒙生态与技术架构

鸿蒙生态全景：

HarmonyOS作为面向全场景的分布式操作系统，已构建起覆盖18大行业的完整生态。截至2025年，鸿蒙设备数量突破10亿台，应用数量超过20万款，形成了包括手机、平板、智慧屏、智能穿戴、车机等在内的全场景智能生态。

技术架构解析：

鸿蒙系统采用分层架构，从下到上分为：

1. 内核层：基于微内核设计，提供进程管理、内存管理等基础能力
2. 系统服务层：提供分布式软总线、分布式数据管理等核心服务
3. 框架层：提供ArkUI、ArkTS等应用开发框架
4. 应用层：包含传统应用和原子化服务

核心技术优势：

• 分布式能力：打破设备边界，实现多设备协同
• 声明式UI：简化界面开发，提高开发效率
• 一次开发，多端部署：一套代码适配多种设备
• 低代码开发：减少代码量，降低开发门槛
• 跨设备数据同步：实现应用状态在不同设备间无缝流转

学习路径规划：

从零基础到鸿蒙开发者，建议按以下路径循序渐进学习：

表格

复制

阶段	核心内容	目标能力	学习时间
入门阶段	开发环境、基础语法、UI开发	开发简单应用界面	1-2个月
进阶阶段	状态管理、数据存储、网络请求	开发功能完善的应用	2-3个月
高级阶段	分布式能力、性能优化	开发跨设备应用	2-3个月
专家阶段	架构设计、系统集成	开发复杂分布式应用	3-6个月

1.2 鸿蒙开发工具链

开发工具全景：

鸿蒙开发工具链围绕DevEco Studio构建，提供从编码到发布的全流程支持：

1. DevEco Studio：集成开发环境，支持代码编辑、调试、构建
2. HarmonyOS SDK：软件开发工具包，提供API和开发框架
3. 模拟器：提供多种设备类型的模拟环境
4. 性能分析工具：包括CPU、内存、网络性能分析
5. 分布式调试工具：支持多设备联合调试

DevEco Studio核心功能：

• 智能代码提示：基于上下文的代码补全和建议
• UI预览器：实时预览界面效果，支持多设备预览
• 分布式调试：多设备联动调试，支持跨设备断点
• 性能分析：定位性能瓶颈，优化应用性能
• 一键打包发布：简化应用打包和发布流程

工具链优势：

• 全流程支持：从开发到发布的一站式工具支持
• 智能化：AI辅助编程，提高开发效率
• 可视化：界面设计和布局可视化，所见即所得
• 多设备支持：一套工具支持多种设备开发
• 学习友好：集成教程和示例，降低学习门槛

二、ArkTS基础语法

2.1 开发环境搭建

环境搭建步骤：

Step 1：安装DevEco Studio

1. 访问华为开发者官网，下载最新版DevEco Studio
2. 运行安装程序，使用默认设置完成安装
3. 首次启动时，选择"HarmonyOS开发"

Step 2：配置SDK

1. 首次启动会提示安装HarmonyOS SDK，点击"Next"
2. 选择需要安装的SDK版本（建议选择最新稳定版）
3. 接受许可协议，等待SDK下载安装完成

Step 3：创建项目

1. 点击"Create Project"，选择"Empty Ability"模板

2. 填写项目信息：

   • Project Name：项目名称（如"MyFirstApp"）
   • Package Name：应用包名（如"com.example.myfirstapp"）
   • Save Location：项目保存路径
   • Language：选择"ArkTS"
   • Device Type：选择"Phone"

3. 点击"Finish"，等待项目创建完成

Step 4：运行应用

1. 点击工具栏中的"Run"按钮
2. 在弹出的设备选择窗口中，点击"New Device"创建模拟器
3. 选择设备类型（如"Phone"）和系统版本
4. 点击"Finish"创建模拟器
5. 等待模拟器启动和应用部署完成
6. 应用成功运行后，将在模拟器中显示"Hello World"界面

常见问题解决：

• 模拟器启动失败：进入BIOS开启虚拟化技术（VT-x/AMD-V）
• SDK下载缓慢：配置国内镜像源
• 项目创建失败：确保路径中无中文和空格
• 编译错误：检查SDK版本和项目配置

2.2 基础语法详解

变量与数据类型：

变量声明：

在ArkTS中，使用let关键字声明变量，使用const声明常量：

let count: number = 10; // 声明数字类型变量
const message: string = "Hello HarmonyOS"; // 声明字符串常量
let isReady: boolean = true; // 声明布尔类型变量

基本数据类型：

ArkTS提供以下基本数据类型：

• number：数字类型，包括整数和浮点数
• string：字符串类型，用于表示文本
• boolean：布尔类型，值为true或false
• Array：数组类型，用于存储多个相同类型的值
• Object：对象类型，用于存储键值对集合

示例：

// 数组类型
let numbers: number[] = [1, 2, 3, 4, 5];
let fruits: string[] = ["apple", "banana", "orange"];

// 对象类型
let person: { name: string, age: number } = {
  name: "Alice",
  age: 25
};

函数定义：

使用function关键字定义函数：

// 定义函数
function add(a: number, b: number): number {
  return a + b;
}

// 调用函数
let result: number = add(3, 5);
console.log(`3 + 5 = ${result}`); // 输出：3 + 5 = 8

箭头函数：

使用箭头函数简化函数定义：

// 箭头函数
const multiply = (a: number, b: number): number => a * b;

// 调用箭头函数
let product: number = multiply(4, 5);
console.log(`4 * 5 = ${product}`); // 输出：4 * 5 = 20

控制流语句：

条件语句：

let score: number = 85;

if (score >= 90) {
  console.log("优秀");
} else if (score >= 60) {
  console.log("及格");
} else {
  console.log("不及格");
}

循环语句：

// for循环
for (let i = 0; i < 5; i++) {
  console.log(`i = ${i}`);
}

// for...of循环
let languages: string[] = ["ArkTS", "Java", "C++"];
for (let lang of languages) {
  console.log(`Language: ${lang}`);
}

// while循环
let count: number = 0;
while (count < 3) {
  console.log(`Count: ${count}`);
  count++;
}

2.3 面向对象基础

类与对象：

// 定义类
class Person {
  // 属性
  name: string;
  age: number;
  
  // 构造函数
  constructor(name: string, age: number) {
    this.name = name;
    this.age = age;
  }
  
  // 方法
  sayHello(): void {
    console.log(`Hello, my name is ${this.name}, I'm ${this.age} years old.`);
  }
  
  // 方法重载
  getAge(): number;
  getAge(format: boolean): string;
  getAge(format?: boolean): number | string {
    if (format) {
      return `${this.age}岁`;
    }
    return this.age;
  }
}

// 创建对象
let person = new Person("Alice", 25);
person.sayHello(); // 输出: Hello, my name is Alice, I'm 25 years old.
console.log(person.getAge()); // 输出: 25
console.log(person.getAge(true)); // 输出: 25岁

继承：

// 父类
class Animal {
  name: string;
  
  constructor(name: string) {
    this.name = name;
  }
  
  makeSound(): void {
    console.log("Some sound");
  }
}

// 子类
class Dog extends Animal {
  breed: string;
  
  constructor(name: string, breed: string) {
    super(name);
    this.breed = breed;
  }
  
  // 重写父类方法
  makeSound(): void {
    console.log("Woof! Woof!");
  }
  
  // 新增方法
  fetch(): void {
    console.log(`${this.name} is fetching the ball.`);
  }
}

// 使用子类
let dog = new Dog("Buddy", "Golden Retriever");
dog.makeSound(); // 输出: Woof! Woof!
dog.fetch(); // 输出: Buddy is fetching the ball.

接口：

// 定义接口
interface Shape {
  area(): number;
  perimeter(): number;
}

// 实现接口
class Circle implements Shape {
  radius: number;
  
  constructor(radius: number) {
    this.radius = radius;
  }
  
  area(): number {
    return Math.PI * this.radius * this.radius;
  }
  
  perimeter(): number {
    return 2 * Math.PI * this.radius;
  }
}

class Rectangle implements Shape {
  width: number;
  height: number;
  
  constructor(width: number, height: number) {
    this.width = width;
    this.height = height;
  }
  
  area(): number {
    return this.width * this.height;
  }
  
  perimeter(): number {
    return 2 * (this.width + this.height);
  }
}

// 使用接口
function printShapeInfo(shape: Shape): void {
  console.log(`Area: ${shape.area()}`);
  console.log(`Perimeter: ${shape.perimeter()}`);
}

let circle = new Circle(5);
printShapeInfo(circle);

let rectangle = new Rectangle(4, 6);
printShapeInfo(rectangle);

三、UI开发与交互

3.1 声明式UI基础

声明式UI概念：

声明式UI是一种"描述UI应该是什么样子"的开发范式，开发者只需描述界面应该呈现的样子，系统负责将状态映射到UI并处理更新。

与命令式UI对比：

• 命令式UI：需要开发者手动操作界面元素，如创建按钮、设置文本、添加点击事件等
• 声明式UI：只需描述界面结构和交互逻辑，无需手动操作DOM

ArkUI核心思想：

• 状态驱动UI：UI是状态的函数，状态变化自动更新UI
• 组件化：通过组件组合构建复杂界面
• 声明式描述：直观描述UI结构和交互逻辑

Hello World示例：

@Entry
@Component
struct HelloWorld {
  build() {
    Column() {
      Text('Hello HarmonyOS')
        .fontSize(30)
        .fontWeight(FontWeight.Bold)
        .margin(10)
        
      Button('Click Me')
        .type(ButtonType.Capsule)
        .backgroundColor('#007DFF')
        .onClick(() => {
          console.log('Button clicked');
        })
    }
    .width('100%')
    .height('100%')
    .justifyContent(FlexAlign.Center)
  }
}

代码解析：

• @Entry：标记为应用入口组件
• @Component：声明自定义组件
• build()：组件构建函数，描述UI结构
• Column()：垂直布局容器
• Text()：文本组件
• Button()：按钮组件
• .fontSize()：设置字体大小，类似CSS的链式调用

3.2 常用组件与布局

基础组件：

ArkUI提供丰富的内置组件，常用基础组件包括：

1. Text：文本显示组件

Text('Hello World')
  .fontSize(24)          // 字体大小
  .fontColor('#333333')  // 字体颜色
  .fontWeight(FontWeight.Bold) // 字体粗细
  .textAlign(TextAlign.Center) // 文本对齐方式
  .maxLines(2)           // 最大行数
  .lineHeight(32)        // 行高
  .margin(10)            // 外边距

1. Button：按钮组件

Button('Click Me')
  .type(ButtonType.Capsule) // 按钮类型
  .width(120)              // 宽度
  .height(40)              // 高度
  .backgroundColor('#007DFF') // 背景颜色
  .fontSize(16)            // 字体大小
  .onClick(() => {         // 点击事件
    console.log('Button clicked');
  })

1. Image：图片组件

Image($r('app.media.icon')) // 引用资源图片
  .width(100)              // 宽度
  .height(100)             // 高度
  .objectFit(ImageFit.Cover) // 图片缩放方式
  .borderRadius(10)        // 圆角
  .margin(10)              // 外边距
  .onClick(() => {         // 点击事件
    console.log('Image clicked');
  })

1. TextInput：输入框组件

TextInput({ placeholder: '请输入文本' })
  .width('100%')           // 宽度
  .height(40)              // 高度
  .padding(10)             // 内边距
  .backgroundColor('#FFFFFF') // 背景颜色
  .borderRadius(5)         // 圆角
  .margin(10)              // 外边距
  .onChange((value) => {   // 内容变化事件
    console.log(`输入内容: ${value}`);
  })

常用布局容器：

1. Column/Row：线性布局容器

// 垂直布局
Column() {
  Text('Item 1')
  Text('Item 2')
  Text('Item 3')
}
.width('100%')
.spacing(10) // 子组件间距
.padding(10) // 内边距
.backgroundColor('#F5F5F5')

// 水平布局
Row() {
  Text('Left')
  Text('Center')
  Text('Right')
}
.width('100%')
.justifyContent(FlexAlign.SpaceBetween) // 主轴对齐方式
.alignItems(ItemAlign.Center) // 交叉轴对齐方式
.padding(10)

1. Flex：弹性布局容器

Flex({ 
  direction: FlexDirection.Row, // 布局方向
  justifyContent: FlexAlign.SpaceAround, // 主轴对齐方式
  alignItems: ItemAlign.Center // 交叉轴对齐方式
}) {
  Text('Item 1')
    .flexGrow(1) // 弹性系数
  Text('Item 2')
    .flexGrow(2) // 弹性系数
  Text('Item 3')
    .flexGrow(1) // 弹性系数
}
.width('100%')
.height(100)
.padding(10)

1. List：列表布局容器

List({ space: 10 }) {
  ForEach([
    { name: 'Item 1' },
    { name: 'Item 2' },
    { name: 'Item 3' }
  ], (item) => {
    ListItem() {
      Text(item.name)
        .width('100%')
        .height(50)
        .textAlign(TextAlign.Center)
        .backgroundColor('#FFFFFF')
    }
  })
}
.width('100%')
.backgroundColor('#F5F5F5')
.padding(10)

3.3 状态管理基础

状态管理概念：

状态管理是声明式UI的核心，ArkUI提供多种状态管理装饰器，用于不同场景：

1. @State：组件内部状态

@Component
struct CounterComponent {
  @State count: number = 0 // 组件内部状态
  
  build() {
    Column() {
      Text(`Count: ${this.count}`)
        .fontSize(24)
        .margin(10)
        
      Row({ space: 10 }) {
        Button('-')
          .onClick(() => {
            this.count--; // 修改状态，自动更新UI
          })
          
        Button('+')
          .onClick(() => {
            this.count++; // 修改状态，自动更新UI
          })
      }
    }
  }
}

1. @Prop：父子组件单向绑定

// 子组件
@Component
struct ChildComponent {
  @Prop message: string // 父组件传递的状态，单向绑定
  
  build() {
    Text(this.message)
      .fontSize(18)
      .margin(10)
  }
}

// 父组件
@Entry
@Component
struct ParentComponent {
  @State parentMessage: string = "Hello from Parent"
  
  build() {
    Column() {
      ChildComponent({ message: this.parentMessage })
      
      Button('Change Message')
        .onClick(() => {
          this.parentMessage = "Hello from Parent (Updated)";
        })
    }
  }
}

1. @Link：父子组件双向绑定

// 子组件
@Component
struct ChildComponent {
  @Link message: string // 父子组件双向绑定
  
  build() {
    Column() {
      Text(this.message)
        .fontSize(18)
        .margin(10)
        
      Button('Change in Child')
        .onClick(() => {
          this.message = "Hello from Child"; // 修改会同步到父组件
        })
    }
  }
}

// 父组件
@Entry
@Component
struct ParentComponent {
  @State parentMessage: string = "Hello from Parent"
  
  build() {
    Column() {
      ChildComponent({ message: $parentMessage }) // 使用$符号双向绑定
      
      Button('Change in Parent')
        .onClick(() => {
          this.parentMessage = "Hello from Parent (Updated)";
        })
    }
  }
}

1. @Provide/@Consume：跨层级状态共享

// 祖先组件
@Entry
@Component
struct GrandparentComponent {
  @Provide theme: string = "light" // 提供状态
  
  build() {
    Column() {
      ParentComponent()
      
      Button('切换主题')
        .onClick(() => {
          this.theme = this.theme === "light" ? "dark" : "light";
        })
    }
  }
}

// 父组件
@Component
struct ParentComponent {
  build() {
    Column() {
      ChildComponent()
    }
  }
}

// 子组件
@Component
struct ChildComponent {
  @Consume theme: string // 消费状态
  
  build() {
    Text(`当前主题: ${this.theme}`)
      .fontSize(18)
      .backgroundColor(this.theme === "light" ? "#FFFFFF" : "#333333")
      .color(this.theme === "light" ? "#000000" : "#FFFFFF")
      .padding(10)
      .borderRadius(5)
  }
}

四、数据管理与网络

4.1 本地存储

数据存储方案：

鸿蒙提供多种本地存储方案，适用于不同场景：

1. Preferences：轻量级键值对存储

import preferences from '@ohos.data.preferences';

class PreferenceService {
  private pref: preferences.Preferences | null = null;
  
  // 初始化Preferences
  async init(context: Context) {
    try {
      this.pref = await preferences.getPreferences(context, 'app_prefs');
    } catch (error) {
      console.error('初始化Preferences失败', error);
    }
  }
  
  // 存储数据
  async setData(key: string, value: preferences.ValueType): Promise<boolean> {
    if (!this.pref) return false;
    
    try {
      await this.pref.put(key, value);
      await this.pref.flush();
      return true;
    } catch (error) {
      console.error(`存储数据失败: ${key}`, error);
      return false;
    }
  }
  
  // 获取数据
  async getData(key: string, defaultValue: preferences.ValueType): Promise<preferences.ValueType> {
    if (!this.pref) return defaultValue;
    
    try {
      return await this.pref.get(key, defaultValue);
    } catch (error) {
      console.error(`获取数据失败: ${key}`, error);
      return defaultValue;
    }
  }
  
  // 删除数据
  async deleteData(key: string): Promise<boolean> {
    if (!this.pref) return false;
    
    try {
      await this.pref.delete(key);
      await this.pref.flush();
      return true;
    } catch (error) {
      console.error(`删除数据失败: ${key}`, error);
      return false;
    }
  }
}

1. 关系型数据库：结构化数据存储

import relationalStore from '@ohos.data.relationalStore';

class DatabaseService {
  private db: relationalStore.RdbStore | null = null;
  
  // 初始化数据库
  async init(context: Context) {
    try {
      const storeConfig: relationalStore.StoreConfig = {
        name: 'my_database.db',
        securityLevel: relationalStore.SecurityLevel.S1
      };
      
      this.db = await relationalStore.getRdbStore(context, storeConfig);
      
      // 创建表
      await this.db.executeSql(`
        CREATE TABLE IF NOT EXISTS user (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          name TEXT NOT NULL,
          age INTEGER,
          email TEXT UNIQUE
        )
      `);
    } catch (error) {
      console.error('初始化数据库失败', error);
    }
  }
  
  // 插入数据
  async insertUser(user: { name: string, age: number, email: string }): Promise<number> {
    if (!this.db) return -1;
    
    const valuesBucket = {
      name: user.name,
      age: user.age,
      email: user.email
    };
    
    try {
      return await this.db.insert('user', valuesBucket);
    } catch (error) {
      console.error('插入数据失败', error);
      return -1;
    }
  }
  
  // 查询数据
  async getUsers(): Promise<relationalStore.ResultSet | null> {
    if (!this.db) return null;
    
    try {
      const query = relationalStore.SqlBuilder.select().from('user').build();
      return await this.db.query(query, []);
    } catch (error) {
      console.error('查询数据失败', error);
      return null;
    }
  }
}

4.2 网络请求

HTTP请求：

import http from '@ohos.net.http';

class HttpService {
  // GET请求
  async get(url: string, headers?: Record<string, string>): Promise<any> {
    // 创建HTTP请求
    let request = http.createHttp();
    
    try {
      // 发起GET请求
      let response = await request.request(
        url,
        {
          method: http.RequestMethod.GET,
          header: headers || {
            'Content-Type': 'application/json'
          },
          connectTimeout: 60000,
          readTimeout: 60000
        }
      );
      
      // 处理响应
      if (response.responseCode === 200) {
        return JSON.parse(response.result as string);
      } else {
        console.error(`HTTP请求失败: ${response.responseCode}`);
        return null;
      }
    } catch (error) {
      console.error('HTTP请求异常', error);
      return null;
    } finally {
      // 销毁HTTP请求
      request.destroy();
    }
  }
  
  // POST请求
  async post(url: string, data: any, headers?: Record<string, string>): Promise<any> {
    // 创建HTTP请求
    let request = http.createHttp();
    
    try {
      // 发起POST请求
      let response = await request.request(
        url,
        {
          method: http.RequestMethod.POST,
          header: headers || {
            'Content-Type': 'application/json'
          },
          extraData: JSON.stringify(data),
          connectTimeout: 60000,
          readTimeout: 60000
        }
      );
        
      // 处理响应
      if (response.responseCode === 200) {
        return JSON.parse(response.result as string);
      } else {
        console.error(`HTTP请求失败: ${response.responseCode}`);
        return null;
      }
    } catch (error) {
      console.error('HTTP请求异常', error);
      return null;
    } finally {
      // 销毁HTTP请求
      request.destroy();
    }
  }
}

网络请求最佳实践：

1. 请求封装：封装网络请求模块，统一处理请求和响应
2. 错误处理：统一处理网络错误、服务器错误和业务错误
3. 请求取消：支持取消正在进行的请求，避免内存泄漏
4. 请求缓存：实现请求缓存，减少重复请求
5. 请求重试：实现失败重试机制，提高成功率
6. 进度监听：支持上传下载进度监听
7. 超时控制：设置合理的超时时间

五、分布式能力开发

5.1 分布式基础

分布式核心概念：

鸿蒙分布式能力打破设备边界，实现多设备协同，核心概念包括：

1. 分布式软总线：设备间通信的统一基座，实现设备发现和数据传输
2. 分布式数据管理：实现跨设备数据同步和共享
3. 分布式任务调度：实现任务在不同设备间迁移和协同
4. 分布式设备虚拟化：将多设备硬件资源虚拟化为统一资源池

分布式开发准备：

1. 配置权限：在config.json中声明分布式权限

"reqPermissions": [
  {
    "name": "ohos.permission.DISTRIBUTED_DATASYNC"
  },
  {
    "name": "ohos.permission.GET_DISTRIBUTED_DEVICE_INFO"
  } 
]

1. 初始化分布式环境：

import distributedDeviceManager from '@ohos.distributedDeviceManager';

class DeviceService {
  private dmInstance: distributedDeviceManager.DistributedDeviceManager | null = null;
  
  // 初始化分布式设备管理器
  init(context: Context) {
    this.dmInstance = distributedDeviceManager.createDistributedDeviceManager(context);
    if (!this.dmInstance) {
      console.error('初始化分布式设备管理器失败');
    }
  }
  
  // 获取可信设备列表
  getTrustedDevices(): distributedDeviceManager.DeviceInfo[] {
    if (!this.dmInstance) return [];
    
    try {
      return this.dmInstance.getTrustedDeviceListSync() || [];
    } catch (error) {
      console.error('获取可信设备列表失败', error);
      return [];
    }
  }
  
  // 发现周边设备
  startDeviceDiscovery() {
    if (!this.dmInstance) return;
    
    try {
      this.dmInstance.startDeviceDiscovery();
      
      // 监听设备发现事件
      this.dmInstance.on('deviceFound', (device) => {
        console.log(`发现设备: ${device.deviceName}, ID: ${device.deviceId}`);
      });
      
      // 监听设备状态变化
      this.dmInstance.on('deviceStateChange', (device) => {
        console.log(`设备状态变化: ${device.deviceName}, 状态: ${device.status}`);
      });
    } catch (error) {
      console.error('启动设备发现失败', error);
    }
  }
  
  // 停止设备发现
  stopDeviceDiscovery() {
    if (!this.dmInstance) return;
    
    try {
      this.dmInstance.stopDeviceDiscovery();
    } catch (error) {
      console.error('停止设备发现失败', error);
    }
  }
}

5.2 分布式数据同步

分布式数据管理：

鸿蒙提供多种分布式数据同步方案，适用于不同场景：

1. DistributedPreferences：分布式键值对存储

import distributedData from '@ohos.data.distributedData';

class DistributedDataService {
  private kvManager: distributedData.KVManager | null = null;
  private kvStore: distributedData.KVStore | null = null;
  
  // 初始化分布式数据管理
  async init(context: Context) {
    try {
      // 创建KVManager
      this.kvManager = distributedData.createKVManager({
        context: context,
        bundleName: 'com.example.myapp'
      });
      
      // 创建KVStore
      this.kvStore = await this.kvManager.getKVStore('my_kvstore', {
        createIfMissing: true,
        encrypt: false,
        backup: false,
        autoSync: true // 开启自动同步
      });
      
      // 注册数据变化监听
      this.kvStore.on('dataChange', distributedData.SubscribeType.SUBSCRIBE_TYPE_ALL, (data) => {
        console.log(`数据变化: key=${data.key}, value=${data.value}`);
      });
    } catch (error) {
      console.error('初始化分布式数据管理失败', error);
    }
  }
  
  // 写入数据
  async putData(key: string, value: string): Promise<boolean> {
    if (!this.kvStore) return false;
    
    try {
      await this.kvStore.put(key, value);
      return true;
    } catch (error) {
      console.error(`写入数据失败: ${key}`, error);
      return false;
    }
  }
  
  // 获取数据
  async getData(key: string): Promise<string | null> {
    if (!this.kvStore) return null;
    
    try {
      return await this.kvStore.get(key) as string;
    } catch (error) {
      console.error(`获取数据失败: ${key}`, error);
      return null;
    }
  }
  
  // 删除数据
  async deleteData(key: string): Promise<boolean> {
    if (!this.kvStore) return false;
    
    try {
      await this.kvStore.delete(key); 
      return true;
    } catch (error) {
      console.error(`删除数据失败: ${key}`, error);
      return false;
    }
  }
  
  // 同步数据到指定设备
  async syncData(deviceId: string): Promise<boolean> {
    if (!this.kvStore) return false;
    
    try {
      await this.kvStore.sync(deviceId, distributedData.SyncMode.PUSH_PULL);
      return true;
    } catch (error) {
      console.error(`同步数据失败到设备: ${deviceId}`, error);
      return false;
    }
  }
}

1. 分布式关系型数据库：

import relationalStore from '@ohos.data.relationalStore';

class DistributedRdbService {
  private db: relationalStore.RdbStore | null = null;
  
  // 初始化分布式数据库
  async init(context: Context) {
    try {
      const config = {
        name: 'distributed_db.db',
        securityLevel: relationalStore.SecurityLevel.S1, 
        distributed: true // 启用分布式能力
      };
      
      this.db = await relationalStore.getRdbStore(context, config);
      
      // 创建表
      await this.db.executeSql(`
        CREATE TABLE IF NOT EXISTS note (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          content TEXT NOT NULL,
          createTime INTEGER,
          deviceId TEXT
        )
      `);
      
      // 注册数据变化监听
      this.db.on('dataChange', (data) => {
        console.log(`分布式数据变化: ${JSON.stringify(data)}`);
      });
    } catch (error) {
      console.error('初始化分布式数据库失败', error);
    }
  }
  
  // 插入分布式数据
  async insertNote(note: { content: string, deviceId: string }): Promise<number> {
    if (!this.db) return -1;
    
    const valuesBucket = {
      content: note.content,
      createTime: Date.now(),
      deviceId: note.deviceId
    };
    
    try {
      return await this.db.insert('note', valuesBucket);
    } catch (error) {
      console.error('插入分布式数据失败', error);
      return -1;
    }
  }
}

5.3 分布式任务调度

分布式任务迁移：

实现应用在不同设备间无缝迁移：

import featureAbility from '@ohos.ability.featureAbility';
import distributedTaskManager from '@ohos.distributedTaskManager';

class DistributedTaskService {
  // 发起任务迁移
  async migrateTask(deviceId: string, data: any): Promise<boolean> {
    try {
      // 创建任务描述
      const taskInfo = {
        bundleName: 'com.example.myapp',
        abilityName: 'MainAbility',
        parameters: data
      };
      
      // 发起任务迁移
      const result = await distributedTaskManager.startRemoteTask(deviceId, taskInfo);
      
      if (result.code === 0) {
        console.log('任务迁移成功');
        // 本地任务暂停
        await featureAbility.terminateSelf();
        return true;
      } else {
        console.error(`任务迁移失败: ${result.code}`);
        return false;
      }
    } catch (error) {
      console.error('任务迁移异常', error);
      return false;
    }
  }
  
  // 接收任务迁移
  onTaskReceived(callback: (data: any) => void) {
    // 监听任务迁移事件
    distributedTaskManager.on('remoteTaskReceived', (taskInfo) => {
      console.log('接收到远程任务', taskInfo);
      callback(taskInfo.parameters);
    });
  }
}

分布式UI流转：

实现UI界面在不同设备间无缝流转：

// 发起UI流转
async function transferUI(deviceId: string) {
  try {
    // 创建流转请求
    const want = {
      deviceId: deviceId,
      bundleName: 'com.example.myapp',
      abilityName: 'MainAbility',
      parameters: {
        data: '需要传递的数据'
      }
    };
    
    // 发起UI流转
    await featureAbility.startAbility(want);
    
    // 当前设备隐藏UI
    const window = await featureAbility.getCurrentWindow();
    window.hide();
  } catch (error) {
    console.error('UI流转失败', error);
  }
}

// 接收UI流转
function onUITransferred() {
  featureAbility.getWant((err, want) => {
    if (!err && want.parameters) {
      console.log('接收到UI流转数据', want.parameters.data);
      // 恢复UI状态
      restoreUIState(want.parameters.data);
    }
  });
}

六、项目实战与进阶

6.1 基础项目：待办事项应用

项目概述：

开发一个简单的待办事项应用,实现添加、标记完成、删除待办事项等功能。

功能模块：

1. 待办事项列表：显示所有待办事项
2. 添加待办事项：输入框添加新的待办事项
3. 标记完成：点击复选框标记待办事项为完成
4. 删除待办事项：滑动删除待办事项
5. 数据持久化：使用Preferences保存待办事项

项目结构：

TodoApp/
├── entry/
│   ├── src/main/ets/
│   │   ├── MainAbility/
│   │   ├── pages/
│   │   │   └── Index.ets        // 主页面
│   │   ├── components/
│   │   │   └── TodoItem.ets     // 待办事项项组件
│   │   ├── model/
│   │   │   └── TodoModel.ets    // 数据模型
│   │   └── service/
│   │       └── TodoService.ets   // 业务服务
│   └── resources/               // 资源文件
└── build-profile.json5          // 项目配置

社区资源分享：码牛教育官方的动态 - 哔哩哔哩

​