HarmonyOS 分布式 KV 存储管理器的简单封装鸿蒙的分布式 KV 存储（Key-Value Store）是一种非

鸿蒙的分布式 KV 存储（Key-Value Store）是一种非关系型数据库，用于存储键值对（Key-Value Pairs）。在 HarmonyOS 中，分布式 KV 存储允许多个设备之间的数据共享和同步，提供了一种高效的数据存储和管理方式。

实现分布式 KV 存储管理器

第一步：导入必要的模块

首先，导入必要的模块： import distributedKVStore from '@ohos.data.distributedKVStore';

第二步：创建分布式 KV 存储管理器

接下来，我们创建一个 DistributedKVStoreManager 类来封装分布式 KV 存储的操作。

class DistributedKVStoreManager {
  private kvManager: any = null;
  private kvStore: any = null;
  private storeId: string = Const.H_STORE;

  // 初始化 KVManager
  public async initialize(context: any) {
    const kvManagerConfig = {
      context: context,
      bundleName: 'com.example.startmanage'
    };

    try {
      this.kvManager = await distributedKVStore.createKVManager(kvManagerConfig);
      console.info('成功创建 KVManager');
      await this.initKVStore();
    } catch (e) {
      console.error(`创建 KVManager 失败。错误码: ${e.code}, 错误信息: ${e.message}`);
    }
  }

  // 初始化 KVStore
  private async initKVStore() {
    const options = {
      createIfMissing: true, // 当数据库文件不存在时是否创建数据库，默认创建
      encrypt: false, // 设置数据库文件是否加密，默认不加密
      backup: false, // 设置数据库文件是否备份，默认备份
      kvStoreType: distributedKVStore.KVStoreType.SINGLE_VERSION, // 设置要创建的数据库类型，默认为多设备协同数据库
      securityLevel: distributedKVStore.SecurityLevel.S2 // 设置数据库安全级别
    };

    try {
      this.kvStore = await new Promise((resolve, reject) => {
        this.kvManager.getKVStore(this.storeId, options, (err, kvStore) => {
          if (err) {
            console.error(`获取 KVStore 失败。错误码: ${err.code}, 错误信息: ${err.message}`);
            reject(err);
          } else {
            console.info('成功获取 KVStore');
            resolve(kvStore);
          }
        });
      });
    } catch (e) {
      console.error(`发生意外错误。错误码: ${e.code}, 错误信息: ${e.message}`);
    }
  }

  // 存储数据
  public async put(key: string, value: any) {
    if (this.kvStore) {
      try {
        await new Promise((resolve, reject) => {
          this.kvStore.put(key, value, (err) => {
            if (err !== undefined) {
              console.error(`存储数据失败。错误码: ${err.code}, 错误信息: ${err.message}`);
              reject(err);
            } else {
              console.info('成功存储数据');
              resolve(value);
            }
          });
        });
      } catch (e) {
        console.error(`发生意外错误。错误码: ${e.code}, 错误信息: ${e.message}`);
      }
    }
  }

  // 获取数据
  public async get(key: string) {
    if (this.kvStore) {
      try {
        const value = await new Promise((resolve, reject) => {
          this.kvStore.get(key, (err, data) => {
            if (err !== undefined) {
              console.error(`获取数据失败。错误码: ${err.code}, 错误信息: ${err.message}`);
              reject(err);
            } else {
              console.info(`成功获取数据。数据: ${data}`);
              resolve(data);
            }
          });
        });
        return value;
      } catch (e) {
        console.error(`发生意外错误。错误码: ${e.code}, 错误信息: ${e.message}`);
        return null;
      }
    }
    return null;
  }

  // 删除数据
  public async delete(key: string) {
    if (this.kvStore) {
      try {
        await new Promise((resolve, reject) => {
          this.kvStore.delete(key, (err) => {
            if (err !== undefined) {
              console.error(`删除数据失败。错误码: ${err.code}, 错误信息: ${err.message}`);
              reject(err);
            } else {
              console.info('成功删除数据');
              resolve(key);
            }
          });
        });
      } catch (e) {
        console.error(`发生意外错误。错误码: ${e.code}, 错误信息: ${e.message}`);
      }
    }
  }

  // 同步数据
  public async sync() {
    if (this.kvStore) {
      try {
        await new Promise((resolve, reject) => {
          this.kvStore.sync((err) => {
            if (err !== undefined) {
              console.error(`同步数据失败。错误码: ${err.code}, 错误信息: ${err.message}`);
              reject(err);
            } else {
              console.info('成功同步数据');
            }
          });
        });
      } catch (e) {
        console.error(`发生意外错误。错误码: ${e.code}, 错误信息: ${e.message}`);
      }
    }
  }
}

const kvManager = new DistributedKVStoreManager();
export default kvManager as DistributedKVStoreManager;

第三步：在 `EntryAbility` 中初始化

我们在 EntryAbility 中初始化 DistributedKVStoreManager。

import kvManager from './path/to/DistributedKVStoreManager';

export default class EntryAbility extends UIAbility {
  onCreate(want, launchParam) {
    console.info('EntryAbility onCreate');
    kvManager.initialize(this.context);
  }
}

使用示例

以下是如何在您的应用程序中使用 DistributedKVStoreManager 进行数据存储、获取和删除操作的示例。

存储数据

async function storeData() {
  await kvManager.put('testKey', 'testValue');
}

获取数据

async function getData() {
  const value = await kvManager.get('testKey');
  console.info(`获取的数据: ${value}`);
}

删除数据

async function deleteData() {
  await kvManager.delete('testKey');
}

同步数据

async function syncData() {
  await kvManager.sync();
}

HarmonyOS 分布式 KV 存储管理器的简单封装