Harmony开发之分布式数据管理——跨设备数据同步

Harmony开发之分布式数据管理——跨设备数据同步

引入：手机编辑文档，平板接着看

在日常工作中，我们经常需要在多个设备间切换使用同一个应用。比如在手机上编辑文档，回到家后想在平板上继续编辑；或者在手机上添加购物车商品，在平板上查看购物车内容。传统方案需要手动同步数据，或者依赖云端存储，操作繁琐且存在数据延迟。HarmonyOS的分布式数据管理技术，让数据能够在可信设备组网内自由流动，实现"一次操作，多端同步"的无缝体验。

一、分布式数据管理核心概念

1.1 什么是分布式数据管理？

分布式数据管理是HarmonyOS实现"超级终端"体验的核心技术基础，它打破了传统单设备数据孤岛的限制，让数据能够在可信设备组网内自由流动。与传统的云同步方案不同，HarmonyOS的分布式数据管理基于分布式软总线技术，实现了设备间的直接数据同步，具有低延迟、高可靠和离线可用的特点。

1.2 核心价值与优势

传统数据同步的痛点：

• 需要手动建立通信连接和消息处理逻辑
• 数据冲突解决复杂，调试难度随设备数量增加而倍增
• 网络依赖性强，离线场景体验差

HarmonyOS分布式数据管理的优势：

• 自动同步：系统自动完成设备发现、连接建立和数据同步
• 透明访问：开发者像操作本地数据一样访问跨设备数据
• 实时性高：毫秒级响应，设备间数据修改可实时感知
• 离线支持：网络中断时数据暂存本地，恢复后自动补同步

1.3 技术架构层次

HarmonyOS分布式数据管理采用分层架构设计：

• 应用层：提供开发者友好的API接口
• 服务层：数据管理、同步调度、冲突解决等核心服务
• 通信层：分布式软总线，负责设备间数据传输
• 存储层：本地数据持久化存储

二、分布式数据对象详解

2.1 核心特性与运作机制

生命周期状态：分布式数据对象的生命周期包含四种状态：

• 未初始化：对象未创建或已销毁
• 本地数据对象：已创建但未加入同步组网
• 分布式数据对象：设备在线且相同sessionId的设备数≥2，可跨设备同步
• 已销毁：内存释放，磁盘数据清除

数据同步机制：分布式数据对象建立在分布式内存数据库之上，采用JS对象型封装机制。当开发者对对象属性进行"读取"或"赋值"时，会自动映射到数据库的get/put操作。

2.2 完整开发实战

以下是一个完整的分布式数据对象实现示例：

// TodoItem.ts - 定义待办事项数据结构
export class TodoItem {
  id: string;
  title: string;
  completed: boolean;
  
  constructor(id: string, title: string, completed: boolean = false) {
    this.id = id;
    this.title = title;
    this.completed = completed;
  }
}
// TodoService.ts - 分布式数据对象管理
import { distributedData } from '@ohos.data.distributedData';
import { BusinessError } from '@ohos.BasicServicesKit';

export class TodoService {
  private kvManager: distributedData.KVManager | null = null;
  private kvStore: distributedData.KVStore | null = null;
  
  // 初始化分布式数据对象
  async init(): Promise<void> {
    try {
      // 创建KVManager
      const config = {
        bundleName: 'com.example.todoapp',
        userInfo: {
          userId: 'defaultUser',
          userType: distributedData.UserType.SAME_USER_ID
        }
      };
      
      this.kvManager = distributedData.createKVManager(config);
      
      // 创建KVStore并开启自动同步
      const options = {
        createIfMissing: true,
        encrypt: false,
        backup: false,
        autoSync: true,  // 开启自动同步
        kvStoreType: distributedData.KVStoreType.DEVICE_COLLABORATION
      };
      
      this.kvStore = await this.kvManager.getKVStore('todo_store', options);
      
      // 订阅数据变更通知
      this.kvStore.on('dataChange', distributedData.SubscribeType.SUBSCRIBE_TYPE_ALL, (data) => {
        this.handleDataChange(data);
      });
      
    } catch (error) {
      console.error('初始化分布式数据对象失败:', error);
    }
  }
  
  // 添加待办事项
  async addTodo(todo: TodoItem): Promise<void> {
    if (!this.kvStore) {
      await this.init();
    }
    
    try {
      await this.kvStore.put(todo.id, JSON.stringify(todo));
      console.log('待办事项已添加并同步');
    } catch (error) {
      console.error('添加待办事项失败:', error);
    }
  }
  
  // 获取所有待办事项
  async getAllTodos(): Promise<TodoItem[]> {
    if (!this.kvStore) {
      await this.init();
    }
    
    try {
      const entries = await this.kvStore.getEntries('');
      const todos: TodoItem[] = [];
      
      for (const entry of entries) {
        try {
          const todo = JSON.parse(entry.value as string);
          todos.push(new TodoItem(todo.id, todo.title, todo.completed));
        } catch (parseError) {
          console.error('解析待办事项失败:', parseError);
        }
      }
      
      return todos;
    } catch (error) {
      console.error('获取待办事项失败:', error);
      return [];
    }
  }
  
  // 处理数据变更
  private handleDataChange(data: distributedData.ChangeNotification): void {
    console.log('数据发生变化:', data);
    // 这里可以触发UI更新或其他业务逻辑
  }
}
// TodoListPage.ets - 待办事项列表页面
import { TodoService } from '../service/TodoService';
import { TodoItem } from '../model/TodoItem';

@Entry
@Component
struct TodoListPage {
  @State todoList: TodoItem[] = [];
  private todoService: TodoService = new TodoService();
  
  aboutToAppear() {
    this.loadTodos();
  }
  
  async loadTodos() {
    this.todoList = await this.todoService.getAllTodos();
  }
  
  async addNewTodo() {
    const newTodo = new TodoItem(
      Date.now().toString(),
      '新的待办事项',
      false
    );
    await this.todoService.addTodo(newTodo);
    await this.loadTodos(); // 重新加载列表
  }
  
  build() {
    Column() {
      Button('添加待办事项')
        .onClick(() => this.addNewTodo())
        .margin({ top: 20 })
      
      List() {
        ForEach(this.todoList, (item: TodoItem) => {
          ListItem() {
            Row() {
              Text(item.title)
                .fontSize(18)
                .fontColor(item.completed ? '#666' : '#000')
              Checkbox()
                .checked(item.completed)
                .onChange((value: boolean) => {
                  // 更新完成状态
                  item.completed = value;
                  this.todoService.addTodo(item);
                })
            }
            .padding(10)
          }
        })
      }
      .layoutWeight(1)
    }
  }
}

三、分布式数据库实战

3.1 关系型数据库跨设备同步

对于需要持久化存储的场景，HarmonyOS提供了分布式关系型数据库解决方案：

// 文件：services/DatabaseService.ts
import { relationalStore } from '@ohos.data.relationalStore';
import { BusinessError } from '@ohos.BasicServicesKit';

export class DatabaseService {
  private db: relationalStore.RdbStore | null = null;
  
  // 初始化分布式数据库
  async init(): Promise<void> {
    try {
      const config = {
        name: 'todo_app.db',
        securityLevel: relationalStore.SecurityLevel.S1,
        distributed: true  // 关键配置：启用分布式
      };
      
      this.db = await relationalStore.getRdbStore(getContext(this), config);
      
      // 创建表
      await this.createTables();
      
      console.log('分布式数据库初始化成功');
    } catch (error) {
      console.error('数据库初始化失败:', error);
    }
  }
  
  // 创建数据表
  private async createTables(): Promise<void> {
    if (!this.db) {
      return;
    }
    
    try {
      // 创建待办事项表
      await this.db.executeSql(`
        CREATE TABLE IF NOT EXISTS todos (
          id INTEGER PRIMARY KEY AUTOINCREMENT,
          title TEXT NOT NULL,
          completed INTEGER DEFAULT 0,
          created_at INTEGER,
          updated_at INTEGER
        )
      `);
      
      // 设置分布式表
      await this.db.setDistributedTables(['todos']);
      
      console.log('数据表创建成功');
    } catch (error) {
      console.error('创建表失败:', error);
    }
  }
  
  // 添加待办事项
  async addTodo(title: string): Promise<number> {
    if (!this.db) {
      await this.init();
    }
    
    try {
      const now = Date.now();
      const value = {
        title: title,
        completed: 0,
        created_at: now,
        updated_at: now
      };
      
      const result = await this.db.insert('todos', value);
      console.log('待办事项添加成功，ID:', result);
      return result;
    } catch (error) {
      console.error('添加待办事项失败:', error);
      throw error;
    }
  }
  
  // 查询所有待办事项
  async getAllTodos(): Promise<any[]> {
    if (!this.db) {
      await this.init();
    }
    
    try {
      const predicates = new relationalStore.RdbPredicates('todos');
      const resultSet = await this.db.query(predicates, ['id', 'title', 'completed', 'created_at', 'updated_at']);
      
      const todos: any[] = [];
      while (resultSet.goToNextRow()) {
        todos.push({
          id: resultSet.getLong(resultSet.getColumnIndex('id')),
          title: resultSet.getString(resultSet.getColumnIndex('title')),
          completed: resultSet.getLong(resultSet.getColumnIndex('completed')),
          created_at: resultSet.getLong(resultSet.getColumnIndex('created_at')),
          updated_at: resultSet.getLong(resultSet.getColumnIndex('updated_at'))
        });
      }
      
      return todos;
    } catch (error) {
      console.error('查询待办事项失败:', error);
      return [];
    }
  }
  
  // 手动触发数据同步
  async syncData(): Promise<void> {
    if (!this.db) {
      await this.init();
    }
    
    try {
      const predicates = new relationalStore.RdbPredicates('todos');
      await this.db.sync(relationalStore.SyncMode.SYNC_MODE_PUSH_PULL, predicates);
      console.log('数据同步成功');
    } catch (error) {
      console.error('数据同步失败:', error);
    }
  }
}

3.2 数据同步冲突解决策略

在分布式环境中，数据同步冲突是常见问题。HarmonyOS提供了多种冲突解决机制：

// 配置冲突解决策略
const storeConfig: relationalStore.StoreConfig = {
  conflictResolution: relationalStore.ConflictResolutionPolicy.LAST_WIN  // 最后写入胜利
};

// 创建数据库时应用冲突策略
this.db = await relationalStore.getRdbStore(getContext(this), config, storeConfig);

内置冲突解决策略：

• LAST_WIN：最后写入胜利，保留最新数据
• ROLLBACK：回滚事务
• ABORT：中止操作
• REPLACE：替换旧数据

自定义冲突解决函数：

// 自定义冲突解决策略
store.setConflictResolver((localData, remoteData) => {
  // 规则1：价格冲突时取最低价
  if (localData.price !== remoteData.price) {
    return localData.price < remoteData.price ? localData : remoteData;
  }
  
  // 规则2：数量冲突时求和
  return { 
    ...localData, 
    count: localData.count + remoteData.count 
  };
});

四、权限配置与安全机制

4.1 权限申请

使用分布式数据管理需要申请相关权限：

// module.json5
{
  "module": {
    "requestPermissions": [
      {
        "name": "ohos.permission.DISTRIBUTED_DATASYNC"
      },
      {
        "name": "ohos.permission.ACCESS_NETWORK_STATE"
      }
    ]
  }
}

4.2 数据安全等级

HarmonyOS将数据分为5个安全等级（S0-S4），从生成开始，在存储、使用、传输的整个生命周期都需要根据对应的安全策略提供不同强度的安全防护。

// 配置数据库安全等级
const config = {
  name: 'secure_data.db',
  securityLevel: relationalStore.SecurityLevel.S2,  // S2安全等级
  encrypt: true  // 启用加密
};

五、性能优化与最佳实践

5.1 数据同步优化

批量操作：减少跨设备通信次数

// 批量插入数据
async batchInsertTodos(todos: any[]) {
  await this.db.batchInsert('todos', todos);
}

// 批量更新数据
async batchUpdateTodos(todos: any[]) {
  const updates = todos.map(todo => ({
    table: 'todos',
    values: todo,
    predicates: new relationalStore.RdbPredicates('todos')
      .equalTo('id', todo.id)
  }));
  
  await this.db.batchUpdate(updates);
}

增量同步：只同步变化部分，而不是整个数据集

// 只同步24小时内的数据
await this.db.sync(
  relationalStore.SyncMode.SYNC_MODE_PUSH_PULL,
  new relationalStore.RdbPredicates('todos')
    .greaterThan('updated_at', Date.now() - 86400000)
);

5.2 索引优化

为高频查询字段添加索引提升性能：

// 为completed字段添加索引
await this.db.executeSql('CREATE INDEX idx_completed ON todos(completed)');

// 为created_at字段添加索引
await this.db.executeSql('CREATE INDEX idx_created_at ON todos(created_at)');

5.3 网络状态感知

import { network } from '@ohos.network';

// 监听网络状态变化
network.on('networkStateChange', (state) => {
  if (state.isConnected) {
    // 网络恢复，触发数据同步
    this.syncData();
  } else {
    // 网络断开，启用离线模式
    this.enableOfflineMode();
  }
});

六、实战案例：跨设备购物车

6.1 场景描述

用户可以在手机上添加商品到购物车，然后在平板上查看购物车内容，实现多设备购物车同步。

6.2 核心代码实现

// model/CartItem.ts
export class CartItem {
  id: string;
  productId: string;
  name: string;
  price: number;
  quantity: number;
  imageUrl: string;
  
  constructor(data?: any) {
    if (data) {
      this.id = data.id || '';
      this.productId = data.productId || '';
      this.name = data.name || '';
      this.price = data.price || 0;
      this.quantity = data.quantity || 1;
      this.imageUrl = data.imageUrl || '';
    }
  }
  
  toObject(): any {
    return {
      id: this.id,
      productId: this.productId,
      name: this.name,
      price: this.price,
      quantity: this.quantity,
      imageUrl: this.imageUrl
    };
  }
}
// service/CartService.ts
import { distributedData } from '@ohos.data.distributedData';
import { CartItem } from '../model/CartItem';

export class CartService {
  private kvManager: distributedData.KVManager | null = null;
  private kvStore: distributedData.KVStore | null = null;
  private readonly CART_KEY = 'shopping_cart';
  
  async init(): Promise<void> {
    try {
      const config = {
        bundleName: 'com.example.shopping',
        userInfo: {
          userId: 'defaultUser',
          userType: distributedData.UserType.SAME_USER_ID
        }
      };
      
      this.kvManager = distributedData.createKVManager(config);
      
      const options = {
        createIfMissing: true,
        encrypt: false,
        backup: false,
        autoSync: true,
        kvStoreType: distributedData.KVStoreType.DEVICE_COLLABORATION
      };
      
      this.kvStore = await this.kvManager.getKVStore('cart_store', options);
      
      // 订阅购物车数据变化
      this.kvStore.on('dataChange', distributedData.SubscribeType.SUBSCRIBE_TYPE_ALL, (data) => {
        this.handleCartChange(data);
      });
      
    } catch (error) {
      console.error('购物车服务初始化失败:', error);
    }
  }
  
  // 添加商品到购物车
  async addToCart(product: any): Promise<void> {
    if (!this.kvStore) {
      await this.init();
    }
    
    try {
      // 获取当前购物车
      const cartItems = await this.getCartItems();
      
      // 检查商品是否已存在
      const existingItem = cartItems.find(item => item.productId === product.id);
      
      if (existingItem) {
        // 增加数量
        existingItem.quantity += 1;
      } else {
        // 添加新商品
        const newItem = new CartItem({
          id: Date.now().toString(),
          productId: product.id,
          name: product.name,
          price: product.price,
          quantity: 1,
          imageUrl: product.imageUrl
        });
        cartItems.push(newItem);
      }
      
      // 保存购物车
      await this.kvStore.put(this.CART_KEY, JSON.stringify(cartItems.map(item => item.toObject())));
      console.log('商品已添加到购物车');
      
    } catch (error) {
      console.error('添加商品到购物车失败:', error);
    }
  }
  
  // 获取购物车商品列表
  async getCartItems(): Promise<CartItem[]> {
    if (!this.kvStore) {
      await this.init();
    }
    
    try {
      const cartData = await this.kvStore.get(this.CART_KEY);
      if (cartData) {
        const items = JSON.parse(cartData as string);
        return items.map((item: any) => new CartItem(item));
      }
      return [];
    } catch (error) {
      console.error('获取购物车商品失败:', error);
      return [];
    }
  }
  
  // 更新商品数量
  async updateQuantity(productId: string, quantity: number): Promise<void> {
    if (!this.kvStore) {
      await this.init();
    }
    
    try {
      const cartItems = await this.getCartItems();
      const item = cartItems.find(item => item.productId === productId);
      
      if (item) {
        item.quantity = quantity;
        if (item.quantity <= 0) {
          // 数量为0，移除商品
          const index = cartItems.findIndex(i => i.productId === productId);
          if (index !== -1) {
            cartItems.splice(index, 1);
          }
        }
        
        await this.kvStore.put(this.CART_KEY, JSON.stringify(cartItems.map(item => item.toObject())));
        console.log('商品数量已更新');
      }
    } catch (error) {
      console.error('更新商品数量失败:', error);
    }
  }
  
  // 清空购物车
  async clearCart(): Promise<void> {
    if (!this.kvStore) {
      await this.init();
    }
    
    try {
      await this.kvStore.delete(this.CART_KEY);
      console.log('购物车已清空');
    } catch (error) {
      console.error('清空购物车失败:', error);
    }
  }
  
  // 处理购物车数据变化
  private handleCartChange(data: distributedData.ChangeNotification): void {
    console.log('购物车数据发生变化:', data);
    // 这里可以触发UI更新或其他业务逻辑
  }
}

6.3 购物车页面实现

// pages/CartPage.ets
import { CartService } from '../service/CartService';
import { CartItem } from '../model/CartItem';

@Entry
@Component
struct CartPage {
  @State cartItems: CartItem[] = [];
  private cartService: CartService = new CartService();
  
  aboutToAppear() {
    this.loadCart();
  }
  
  async loadCart() {
    this.cartItems = await this.cartService.getCartItems();
  }
  
  async updateQuantity(productId: string, quantity: number) {
    await this.cartService.updateQuantity(productId, quantity);
    await this.loadCart();
  }
  
  async clearCart() {
    await this.cartService.clearCart();
    await this.loadCart();
  }
  
  build() {
    Column() {
      // 购物车标题
      Row() {
        Text('购物车')
          .fontSize(24)
          .fontWeight(FontWeight.Bold)
        Button('清空')
          .onClick(() => this.clearCart())
          .margin({ left: 20 })
      }
      .padding(16)
      .width('100%')
      
      // 购物车列表
      if (this.cartItems.length === 0) {
        Column() {
          Image($r('app.media.empty_cart'))
            .width(120)
            .height(120)
          Text('购物车为空')
            .fontSize(18)
            .margin({ top: 20 })
        }
        .width('100%')
        .height('100%')
        .justifyContent(FlexAlign.Center)
      } else {
        List() {
          ForEach(this.cartItems, (item: CartItem) => {
            ListItem() {
              Row() {
                // 商品图片
                Image(item.imageUrl)
                  .width(80)
                  .height(80)
                  .objectFit(ImageFit.Cover)
                  .borderRadius(8)
                  .margin({ right: 12 })
                
                // 商品信息
                Column() {
                  Text(item.name)
                    .fontSize(16)
                    .fontWeight(FontWeight.Medium)
                  Text(`¥${item.price.toFixed(2)}`)
                    .fontSize(14)
                    .fontColor('#ff5000')
                }
                .layoutWeight(1)
                
                // 数量控制
                Row() {
                  Button('-')
                    .onClick(() => this.updateQuantity(item.productId, item.quantity - 1))
                  Text(item.quantity.toString())
                    .width(30)
                    .textAlign(TextAlign.Center)
                  Button('+')
                    .onClick(() => this.updateQuantity(item.productId, item.quantity + 1))
                }
              }
              .padding(12)
            }
          })
        }
        .layoutWeight(1)
        
        // 底部结算栏
        Row() {
          Text(`合计：¥${this.cartItems.reduce((total, item) => total + item.price * item.quantity, 0).toFixed(2)}`)
            .fontSize(18)
            .fontWeight(FontWeight.Bold)
          Button('结算')
            .backgroundColor('#ff5000')
            .fontColor(Color.White)
            .margin({ left: 20 })
        }
        .padding(16)
        .backgroundColor('#f5f5f5')
        .width('100%')
      }
    }
  }
}

七、总结与行动建议

7.1 核心要点回顾

1. 分布式数据对象：适合临时数据同步，数据存储在内存中，应用关闭后数据不保留
2. 分布式数据库：适合持久化数据存储，支持关系型数据模型，数据持久化到磁盘
3. 自动同步机制：系统自动完成设备发现、连接建立和数据同步，开发者无需关心底层细节
4. 冲突解决策略：提供多种内置冲突解决机制，支持自定义冲突解决函数
5. 安全机制：支持数据加密、权限控制和设备认证，确保数据安全

7.2 行动建议

1. 场景选择：根据业务需求选择合适的存储方案 临时数据（如购物车、草稿）→ 分布式数据对象 持久化数据（如用户信息、订单）→ 分布式数据库
2. 性能优化： 使用批量操作减少网络请求 为高频查询字段添加索引 合理设置数据同步频率
3. 错误处理： 添加网络状态监听，处理离线场景 实现数据同步失败的重试机制 记录操作日志便于问题排查
4. 测试验证： 在不同网络环境下测试数据同步 模拟多设备同时操作，验证冲突解决机制 测试离线场景下的数据恢复能力

通过合理运用HarmonyOS的分布式数据管理能力，可以轻松构建跨设备协同应用，为用户提供无缝的多设备使用体验。