分布式数据服务：HarmonyOS开发中跨设备数据同步

分布式数据服务：HarmonyOS开发中跨设备数据同步

📌 核心要点：分布式数据服务让多设备间的数据同步变得简单，支持自动同步、手动同步和冲突处理机制

一、背景与动机

你有没有想过，为什么在手机上编辑的备忘录，打开平板就能无缝继续？或者手表上的运动数据，怎么就自动跑到手机上了？这些看似"魔法"的体验，背后都离不开分布式数据服务。

说白了，分布式数据服务就是给数据装上了"腿"，让它能在不同设备间自由流动。传统开发模式下，实现跨设备数据同步你得自己搞定：设备发现、连接建立、数据传输、冲突处理……这一套下来，头发都得掉几把。HarmonyOS的分布式数据服务把这些脏活累活都封装好了，你只需要关注业务逻辑就行。

这个服务最香的地方在于——它跟关系型数据库（RDB）无缝集成。你想想，本地数据库该怎么用还怎么用，同步的事儿完全透明，这不就是开发者梦寐以求的状态吗？

二、核心原理

分布式数据服务的核心思想是"数据跟着设备走"。每个设备既是数据的生产者，也可能是消费者。服务内部维护着一个分布式数据库实例，通过同步引擎协调各设备间的数据状态。

2.1 同步架构

整个分布式数据服务由几个关键组件构成：

• DistributedDB：分布式数据库核心，负责本地存储和同步协调
• SyncEngine：同步引擎，管理同步策略和冲突解决
• DeviceManager：设备管理器，处理设备上下线和网络状态
• DataObserver：数据观察者，监听数据变化并触发回调

2.2 同步流程

graph TD
    A[应用写入数据]:::primary --> B[本地RDB存储]
    B --> C{同步策略判断}
    C -->|自动同步| D[SyncEngine触发同步]
    C -->|手动同步| E[等待手动触发]
    D --> F[DeviceManager获取在线设备]
    E --> F
    F --> G[建立分布式连接]
    G --> H[数据序列化传输]
    H --> I{远端接收处理}
    I -->|成功| J[更新远端数据库]
    I -->|冲突| K[ConflictResolver处理]
    K --> L[应用冲突解决策略]
    L --> J
    J --> M[通知数据变更]
    M --> N[UI刷新]
    
    classDef primary fill:#4CAF50,stroke:#388E3C,color:#fff
    classDef warning fill:#FF9800,stroke:#F57C00,color:#fff
    classDef info fill:#2196F3,stroke:#1976D2,color:#fff

2.3 同步策略

分布式数据支持三种同步模式，各有适用场景：

同步模式	触发时机	适用场景	性能影响
SYNC_MODE_AUTO	数据变更即同步	实时协作场景（备忘录、待办）	较高，频繁网络请求
SYNC_MODE_MANUAL	手动调用触发	批量同步场景（离线编辑）	低，可控同步频率
SYNC_MODE_PULL	仅拉取远端	只读场景（配置同步）	中等，按需拉取

2.4 冲突处理机制

多设备同时修改同一数据时，冲突不可避免。分布式数据服务内置了几种冲突解决策略：

• 本地优先（LOCAL）：本地数据覆盖远端，适合离线优先场景
• 远端优先（REMOTE）：远端数据覆盖本地，适合服务端权威场景
• 时间戳优先（TIMESTAMP）：最后修改时间戳大的胜出，最常用的策略
• 自定义（CUSTOM）：完全由开发者控制合并逻辑

三、代码实战

3.1 基础用法：创建分布式数据库

先从最简单的开始——创建一个支持分布式同步的数据库实例。

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

// 分布式数据库配置
interface DistributedConfig {
  storeId: string;           // 数据库标识
  bundleName: string;        // 应用包名
  syncMode: distributedData.SyncMode;  // 同步模式
}

@Entry
@Component
struct DistributedDataDemo {
  private rdbStore: relationalStore.RdbStore | null = null;
  private distributedDb: distributedData.DistributedDB | null = null;
  
  async aboutToAppear(): Promise<void> {
    await this.initDistributedDB();
  }
  
  // 初始化分布式数据库
  async initDistributedDB(): Promise<void> {
    try {
      // 1. 先创建本地RDB数据库
      const config: relationalStore.StoreConfig = {
        name: 'DistributedNotes.db',
        securityLevel: relationalStore.SecurityLevel.S1
      };
      
      this.rdbStore = await relationalStore.getRdbStore(getContext(this), config);
      
      // 2. 创建分布式数据库实例
      const distributedConfig: distributedData.DistributedDBConfig = {
        appId: 'com.example.notes',      // 应用ID
        storeId: 'notes_store',          // 存储ID，用于区分不同数据集
        syncMode: distributedData.SyncMode.SYNC_MODE_AUTO  // 自动同步模式
      };
      
      this.distributedDb = await distributedData.getDistributedDB(
        getContext(this),
        distributedConfig
      );
      
      console.info('[分布式数据] 初始化成功');
      
      // 3. 注册数据变更监听
      this.registerDataObserver();
      
    } catch (error) {
      console.error(`[分布式数据] 初始化失败: ${JSON.stringify(error)}`);
    }
  }
  
  // 注册数据变更观察者
  registerDataObserver(): void {
    if (!this.distributedDb) return;
    
    this.distributedDb.on('dataChange', (changeInfo: distributedData.ChangeInfo) => {
      console.info(`[数据变更] 设备: ${changeInfo.deviceId}`);
      console.info(`[数据变更] 变更类型: ${changeInfo.changeType}`);
      console.info(`[数据变更] 受影响数据: ${JSON.stringify(changeInfo.changedKeys)}`);
      
      // 触发UI刷新
      this.refreshUI();
    });
  }
  
  refreshUI(): void {
    // 实际项目中这里会更新状态变量，触发界面刷新
    console.info('[UI] 数据已更新，刷新界面');
  }
  
  build() {
    Column() {
      Text('分布式数据服务示例')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
    }
    .width('100%')
    .height('100%')
  }
}

3.2 进阶用法：数据同步与冲突处理

实际项目中，光能存数据还不够，还得处理各种同步场景和冲突。

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

@Entry
@Component
struct SyncWithConflict {
  @State syncStatus: string = '空闲';
  @State conflictCount: number = 0;
  private distributedDb: distributedData.DistributedDB | null = null;
  
  // 插入数据并自动同步
  async insertWithSync(note: NoteItem): Promise<void> {
    if (!this.distributedDb) {
      console.error('[同步] 数据库未初始化');
      return;
    }
    
    try {
      this.syncStatus = '同步中...';
      
      // 构造分布式数据条目
      const entry: distributedData.Entry = {
        key: `note_${note.id}`,
        value: JSON.stringify({
          ...note,
          timestamp: Date.now(),      // 时间戳用于冲突解决
          deviceId: this.getDeviceId() // 设备标识
        })
      };
      
      // 写入数据（自动触发同步）
      await this.distributedDb.put(entry);
      
      console.info(`[同步] 数据已写入: ${entry.key}`);
      this.syncStatus = '同步完成';
      
    } catch (error) {
      console.error(`[同步] 写入失败: ${JSON.stringify(error)}`);
      this.syncStatus = '同步失败';
    }
  }
  
  // 手动触发全量同步
  async manualSync(): Promise<void> {
    if (!this.distributedDb) return;
    
    try {
      this.syncStatus = '全量同步中...';
      
      // 获取在线设备列表
      const devices = await this.distributedDb.getConnectedDevices();
      console.info(`[同步] 在线设备数: ${devices.length}`);
      
      // 向所有在线设备发起同步
      for (const device of devices) {
        await this.distributedDb.sync(device.deviceId, distributedData.SyncMode.SYNC_MODE_PUSH_PULL);
        console.info(`[同步] 已与 ${device.deviceName} 同步`);
      }
      
      this.syncStatus = '全量同步完成';
      
    } catch (error) {
      console.error(`[同步] 手动同步失败: ${JSON.stringify(error)}`);
    }
  }
  
  // 设置冲突解决策略
  setupConflictResolver(): void {
    if (!this.distributedDb) return;
    
    // 注册自定义冲突解决器
    this.distributedDb.on('conflict', (conflict: distributedData.ConflictInfo) => {
      this.conflictCount++;
      console.warn(`[冲突] 检测到数据冲突: ${conflict.key}`);
      
      // 解析本地和远端数据
      const localData = JSON.parse(conflict.localValue);
      const remoteData = JSON.parse(conflict.remoteValue);
      
      // 策略：时间戳优先，相同则本地优先
      let resolvedValue: string;
      
      if (localData.timestamp > remoteData.timestamp) {
        console.info('[冲突] 采用本地数据');
        resolvedValue = conflict.localValue;
      } else if (localData.timestamp < remoteData.timestamp) {
        console.info('[冲突] 采用远端数据');
        resolvedValue = conflict.remoteValue;
      } else {
        // 时间戳相同，合并策略：合并修改内容
        const merged = this.mergeData(localData, remoteData);
        resolvedValue = JSON.stringify(merged);
        console.info('[冲突] 采用合并数据');
      }
      
      // 返回解决后的数据
      return resolvedValue;
    });
  }
  
  // 数据合并逻辑（业务相关）
  private mergeData(local: NoteItem, remote: NoteItem): NoteItem {
    return {
      id: local.id,
      title: local.title || remote.title,  // 标题取非空
      content: `${local.content}\n---\n${remote.content}`,  // 内容合并
      timestamp: Date.now(),  // 更新时间戳
      deviceId: local.deviceId
    };
  }
  
  // 获取当前设备ID
  private getDeviceId(): string {
    // 实际项目中应从设备管理模块获取
    return 'device_local_' + Math.random().toString(36).substr(2, 9);
  }
  
  build() {
    Column({ space: 20 }) {
      Text('数据同步与冲突处理')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
      
      // 同步状态显示
      Row() {
        Text('同步状态: ')
        Text(this.syncStatus)
          .fontColor(this.syncStatus.includes('失败') ? Color.Red : Color.Green)
      }
      
      // 冲突计数
      Text(`已处理冲突: ${this.conflictCount} 次`)
      
      // 操作按钮
      Button('插入测试数据')
        .onClick(() => {
          const testNote: NoteItem = {
            id: Date.now(),
            title: '测试备忘录',
            content: '这是一条测试数据',
            timestamp: Date.now(),
            deviceId: ''
          };
          this.insertWithSync(testNote);
        })
      
      Button('手动全量同步')
        .onClick(() => this.manualSync())
    }
    .width('100%')
    .padding(20)
  }
}

// 备忘录数据结构
interface NoteItem {
  id: number;
  title: string;
  content: string;
  timestamp: number;
  deviceId: string;
}

3.3 完整示例：多设备备忘录同步

来个完整点的例子——一个支持多设备同步的备忘录应用核心逻辑。

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

@Entry
@Component
struct MultiDeviceNotes {
  @State notes: NoteItem[] = [];
  @State onlineDevices: DeviceInfo[] = [];
  @State isSyncing: boolean = false;
  
  private distributedDb: distributedData.DistributedDB | null = null;
  private deviceMgr: deviceManager.DeviceManager | null = null;
  
  async aboutToAppear(): Promise<void> {
    await this.initServices();
    await this.loadLocalNotes();
  }
  
  // 初始化服务
  async initServices(): Promise<void> {
    try {
      // 初始化设备管理器
      this.deviceMgr = deviceManager.createDeviceManager('com.example.notes');
      
      // 监听设备状态变化
      this.deviceMgr.on('deviceStateChange', (state: deviceManager.DeviceState) => {
        this.updateDeviceList();
      });
      
      // 初始化分布式数据库
      const config: distributedData.DistributedDBConfig = {
        appId: 'com.example.notes',
        storeId: 'notes_sync',
        syncMode: distributedData.SyncMode.SYNC_MODE_AUTO
      };
      
      this.distributedDb = await distributedData.getDistributedDB(getContext(this), config);
      
      // 设置冲突解决
      this.setupConflictResolver();
      
      // 监听远端数据变更
      this.distributedDb.on('dataChange', async (changeInfo) => {
        if (changeInfo.changeType === distributedData.ChangeType.INSERT ||
            changeInfo.ChangeType === distributedData.ChangeType.UPDATE) {
          await this.loadLocalNotes();  // 重新加载数据
        }
      });
      
      console.info('[服务] 初始化完成');
      
    } catch (error) {
      console.error(`[服务] 初始化失败: ${JSON.stringify(error)}`);
    }
  }
  
  // 加载本地数据
  async loadLocalNotes(): Promise<void> {
    if (!this.distributedDb) return;
    
    try {
      // 获取所有备忘录数据
      const entries = await this.distributedDb.getEntries('note_');
      
      this.notes = entries.map(entry => {
        return JSON.parse(entry.value) as NoteItem;
      }).sort((a, b) => b.timestamp - a.timestamp);  // 按时间倒序
      
      console.info(`[数据] 已加载 ${this.notes.length} 条备忘录`);
      
    } catch (error) {
      console.error(`[数据] 加载失败: ${JSON.stringify(error)}`);
    }
  }
  
  // 新增备忘录
  async addNote(title: string, content: string): Promise<void> {
    if (!this.distributedDb) return;
    
    const newNote: NoteItem = {
      id: Date.now(),
      title: title,
      content: content,
      timestamp: Date.now(),
      deviceId: this.getLocalDeviceId(),
      isDeleted: false
    };
    
    try {
      const entry: distributedData.Entry = {
        key: `note_${newNote.id}`,
        value: JSON.stringify(newNote)
      };
      
      await this.distributedDb.put(entry);
      await this.loadLocalNotes();  // 刷新列表
      
      console.info(`[备忘录] 新增成功: ${newNote.title}`);
      
    } catch (error) {
      console.error(`[备忘录] 新增失败: ${JSON.stringify(error)}`);
    }
  }
  
  // 更新备忘录
  async updateNote(note: NoteItem): Promise<void> {
    if (!this.distributedDb) return;
    
    const updatedNote = {
      ...note,
      timestamp: Date.now(),  // 更新时间戳
      deviceId: this.getLocalDeviceId()
    };
    
    try {
      const entry: distributedData.Entry = {
        key: `note_${note.id}`,
        value: JSON.stringify(updatedNote)
      };
      
      await this.distributedDb.put(entry);
      await this.loadLocalNotes();
      
      console.info(`[备忘录] 更新成功: ${note.title}`);
      
    } catch (error) {
      console.error(`[备忘录] 更新失败: ${JSON.stringify(error)}`);
    }
  }
  
  // 删除备忘录（软删除）
  async deleteNote(noteId: number): Promise<void> {
    if (!this.distributedDb) return;
    
    try {
      // 获取原数据
      const entry = await this.distributedDb.get(`note_${noteId}`);
      const note = JSON.parse(entry.value) as NoteItem;
      
      // 标记删除并同步
      const deletedNote = {
        ...note,
        isDeleted: true,
        timestamp: Date.now(),
        deviceId: this.getLocalDeviceId()
      };
      
      await this.distributedDb.put({
        key: `note_${noteId}`,
        value: JSON.stringify(deletedNote)
      });
      
      // 本地立即移除
      this.notes = this.notes.filter(n => n.id !== noteId);
      
      console.info(`[备忘录] 删除成功: ${noteId}`);
      
    } catch (error) {
      console.error(`[备忘录] 删除失败: ${JSON.stringify(error)}`);
    }
  }
  
  // 更新设备列表
  async updateDeviceList(): Promise<void> {
    if (!this.deviceMgr) return;
    
    try {
      const devices = this.deviceMgr.getAvailableDeviceListSync();
      this.onlineDevices = devices.map(d => ({
        deviceId: d.deviceId,
        deviceName: d.deviceName,
        deviceType: d.deviceType
      }));
      
      console.info(`[设备] 在线设备数: ${this.onlineDevices.length}`);
      
    } catch (error) {
      console.error(`[设备] 获取设备列表失败: ${JSON.stringify(error)}`);
    }
  }
  
  // 设置冲突解决器
  private setupConflictResolver(): void {
    if (!this.distributedDb) return;
    
    this.distributedDb.on('conflict', (conflict) => {
      const local = JSON.parse(conflict.localValue) as NoteItem;
      const remote = JSON.parse(conflict.remoteValue) as NoteItem;
      
      // 删除操作优先
      if (remote.isDeleted || local.isDeleted) {
        return JSON.stringify({ ...remote, isDeleted: true });
      }
      
      // 时间戳优先策略
      if (local.timestamp >= remote.timestamp) {
        return conflict.localValue;
      } else {
        return conflict.remoteValue;
      }
    });
  }
  
  // 获取本地设备ID
  private getLocalDeviceId(): string {
    if (this.deviceMgr) {
      return this.deviceMgr.getLocalDeviceId();
    }
    return 'unknown';
  }
  
  build() {
    Column({ space: 16 }) {
      // 标题栏
      Row() {
        Text('分布式备忘录')
          .fontSize(24)
          .fontWeight(FontWeight.Bold)
        
        Blank()
        
        // 设备数量指示
        Badge({ count: this.onlineDevices.length }) {
          Icon($r('app.media.ic_device'))
            .width(24)
            .height(24)
        }
      }
      .width('100%')
      .padding({ left: 20, right: 20 })
      
      // 备忘录列表
      List({ space: 12 }) {
        ForEach(this.notes, (note: NoteItem) => {
          ListItem() {
            NoteCard({ 
              note: note,
              onUpdate: (n: NoteItem) => this.updateNote(n),
              onDelete: () => this.deleteNote(note.id)
            })
          }
        }, (note: NoteItem) => note.id.toString())
      }
      .width('100%')
      .layoutWeight(1)
      .padding({ left: 16, right: 16 })
      
      // 新增按钮
      Button('新增备忘录')
        .width('90%')
        .onClick(() => {
          // 实际项目中应弹出编辑界面
          this.addNote('新备忘录', '请输入内容...');
        })
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#F5F5F5')
  }
}

// 备忘录卡片组件
@Component
struct NoteCard {
  @Prop note: NoteItem;
  onUpdate: (note: NoteItem) => void = () => {};
  onDelete: () => void = () => {};
  
  build() {
    Column({ space: 8 }) {
      Row() {
        Text(this.note.title)
          .fontSize(18)
          .fontWeight(FontWeight.Medium)
        
        Blank()
        
        Text(this.formatTime(this.note.timestamp))
          .fontSize(12)
          .fontColor('#999')
      }
      .width('100%')
      
      Text(this.note.content)
        .fontSize(14)
        .fontColor('#666')
        .maxLines(2)
        .textOverflow({ overflow: TextOverflow.Ellipsis })
      
      // 设备来源标识
      Row() {
        Text(`来自: ${this.note.deviceId}`)
          .fontSize(10)
          .fontColor('#AAA')
      }
    }
    .width('100%')
    .padding(16)
    .backgroundColor(Color.White)
    .borderRadius(12)
    .shadow({ radius: 4, color: '#1A000000', offsetY: 2 })
  }
  
  private formatTime(timestamp: number): string {
    const date = new Date(timestamp);
    return `${date.getMonth() + 1}/${date.getDate()} ${date.getHours()}:${date.getMinutes()}`;
  }
}

// 数据结构定义
interface NoteItem {
  id: number;
  title: string;
  content: string;
  timestamp: number;
  deviceId: string;
  isDeleted: boolean;
}

interface DeviceInfo {
  deviceId: string;
  deviceName: string;
  deviceType: string;
}

四、踩坑与注意事项

4.1 同步时机陷阱

坑点：自动同步模式下，频繁写入会导致大量网络请求，严重影响性能。

解决方案：

// ❌ 错误做法：循环中频繁写入
for (const item of items) {
  await distributedDb.put(item);  // 每次都触发同步
}

// ✅ 正确做法：批量写入
const entries: distributedData.Entry[] = items.map(item => ({
  key: item.key,
  value: JSON.stringify(item)
}));

await distributedDb.putBatch(entries);  // 批量写入，一次同步

4.2 设备离线处理

坑点：设备离线时写入的数据，上线后可能不会自动同步。

解决方案：注册设备状态监听，设备上线时主动触发同步。

deviceMgr.on('deviceOnline', async (device) => {
  console.info(`[设备上线] ${device.deviceName}`);
  await distributedDb.sync(device.deviceId, distributedData.SyncMode.SYNC_MODE_PUSH);
});

4.3 冲突解决遗漏

坑点：忘记设置冲突解决器，导致冲突时数据丢失或异常。

最佳实践：始终注册冲突处理器，即使使用默认策略也要显式声明。

// 即使使用默认策略，也建议显式设置
distributedDb.setConflictResolution(distributedData.ConflictResolution.TIMESTAMP);

4.4 数据大小限制

坑点：单条数据超过1MB会导致同步失败。

解决方案：大数据采用分片或外部存储+引用的方式。

// 大文件处理示例
if (dataSize > 1024 * 1024) {
  // 存储到分布式文件系统
  const filePath = await saveToDistributedFile(largeData);
  // 数据库只存引用
  await distributedDb.put({
    key: 'large_data_ref',
    value: JSON.stringify({ filePath, size: dataSize })
  });
}

4.5 网络权限配置

坑点：忘记配置分布式网络权限，导致同步静默失败。

解决方案：在module.json5中添加权限声明。

{
  "requestPermissions": [
    {
      "name": "ohos.permission.DISTRIBUTED_DATASYNC"
    },
    {
      "name": "ohos.permission.GET_NETWORK_INFO"
    }
  ]
}

五、HarmonyOS 6适配说明

HarmonyOS 6对分布式数据服务进行了重要更新，主要体现在以下几个方面：

5.1 API变更

新增API：

• getSyncStatistics()：获取同步统计信息，包括成功率、延迟等
• setSyncPriority()：设置同步优先级，支持高、中、低三档
• enableIncrementalSync()：启用增量同步，减少数据传输量

废弃API：

• syncAllDevices()：改用sync()配合设备列表参数
• getRemoteData()：改用getEntries()配合设备过滤参数

5.2 行为变更

1. 默认同步策略调整：HarmonyOS 6默认采用增量同步，而非全量同步
2. 冲突检测增强：新增基于内容哈希的冲突检测，减少误判
3. 网络适配优化：自动适配WiFi/蓝牙/蜂窝网络，优先使用高速通道

5.3 适配代码示例

// HarmonyOS 6适配代码
import distributedData from '@ohos.data.distributedData';

async function setupDistributedDB_HarmonyOS6(): Promise<void> {
  const config: distributedData.DistributedDBConfig = {
    appId: 'com.example.app',
    storeId: 'data_sync',
    syncMode: distributedData.SyncMode.SYNC_MODE_AUTO,
    // HarmonyOS 6新增配置项
    options: {
      enableIncrementalSync: true,    // 启用增量同步
      syncPriority: distributedData.SyncPriority.HIGH,  // 高优先级
      maxRetryCount: 3,               // 最大重试次数
      retryInterval: 5000             // 重试间隔（毫秒）
    }
  };
  
  const db = await distributedData.getDistributedDB(getContext(this), config);
  
  // 获取同步统计信息（HarmonyOS 6新增）
  const stats = await db.getSyncStatistics();
  console.info(`[同步统计] 成功率: ${stats.successRate}%`);
  console.info(`[同步统计] 平均延迟: ${stats.avgLatency}ms`);
  
  // 设置网络状态监听（HarmonyOS 6增强）
  db.on('networkChange', (networkInfo) => {
    console.info(`[网络] 类型: ${networkInfo.type}, 速度: ${networkInfo.speed}`);
    // 根据网络状态调整同步策略
    if (networkInfo.type === 'cellular' && networkInfo.speed < 1000) {
      db.setSyncPriority(distributedData.SyncPriority.LOW);
    }
  });
}

5.4 性能优化建议

HarmonyOS 6环境下，建议采用以下优化策略：

// 性能优化配置
const optimizedConfig = {
  // 启用数据压缩（网络传输量减少60%+）
  enableCompression: true,
  
  // 设置合理的同步批次大小
  syncBatchSize: 50,  // 每批同步50条
  
  // 启用本地缓存，减少远端读取
  enableLocalCache: true,
  cacheExpireTime: 300000  // 缓存5分钟
};

六、总结

维度	评价
学习难度	⭐⭐⭐⭐
使用频率	⭐⭐⭐⭐
重要程度	⭐⭐⭐⭐⭐
调试难度	⭐⭐⭐

核心收获：

1. 分布式数据服务是HarmonyOS分布式能力的基石，理解其原理对构建多设备协同应用至关重要
2. 同步策略选择要因地制宜，实时场景用自动同步，批量场景用手动同步
3. 冲突处理不可回避，时间戳优先策略适用于大多数场景，但业务逻辑复杂的需要自定义
4. 性能优化从批量操作开始，避免频繁单条写入，善用批量API
5. HarmonyOS 6的增量同步是重大改进，显著降低了网络开销和同步延迟

下一步建议：

• 结合分布式文件系统，实现大文件跨设备同步
• 探索分布式数据与云端存储的混合架构
• 研究分布式事务，保证多设备数据一致性