HarmonyOS--数据持久化--键值型数据库

键值型数据库

场景介绍

键值型数据库存储键值对形式的数据，当需要存储的数据没有复杂的关系模型，比如存储商品名称及对应价格、员工工号及今日是否已出勤等，由于数据复杂度低，更容易兼容不同数据库版本和设备类型，因此推荐使用键值型数据库持久化此类数据。

约束限制

1、设备协同数据库，针对每条记录，Key的长度≤896 Byte，Value的长度<4 MB。

2、单版本数据库，针对每条记录，Key的长度≤1 KB，Value的长度<4 MB。

3、每个应用程序最多支持同时打开16个键值型分布式数据库。

4、键值型数据库事件回调方法中不允许进行阻塞操作，例如修改UI组件。

接口说明

1、创建一个KVManager对象实例，用于管理数据库对象。

createKVManager(config: KVManagerConfig): KVManager

参数：

config：当前UIAbility的上下文、应用唯一标识信息

config参数详情：

const config: distributedKVStore.KVManagerConfig = {

    context: context,

    bundleName: 'com.example.datamanagertest'

};

调用者：distributedKVStore

2、指定options和storeId，创建并得到指定类型的KVStore数据库。

getKVStore<T>(storeId: string, options: Options, callback: AsyncCallback<T>): void

参数：

storeId：数据库的唯一标识

options：创建数据库时的一些限制信息

callback：创建数据库是否成功，如果成功拿到store信息

options参数详情：

const options: distributedKVStore.Options = {
        // 当数据库文件不存在时是否创建数据库，默认为true
        createIfMissing: true,
        // 设置数据库文件是否加密，默认为false，即不加密
        encrypt: false,
        // 设置数据库文件是否备份，默认为true，即备份
        backup: false,
        // 设置数据库文件是否自动同步。默认为false，即手动同步
        autoSync: true,
        // kvStoreType不填时，默认创建多设备协同数据库
        kvStoreType: distributedKVStore.KVStoreType.SINGLE_VERSION,
        // 多设备协同数据库：kvStoreType: distributedKVStore.KVStoreType.DEVICE_COLLABORATION,
        securityLevel: distributedKVStore.SecurityLevel.S1
      }

调用者：kvManager

3、添加指定类型的键值对到数据库。

put(key: string, value: Uint8Array|string|number|boolean, callback: AsyncCallback<void>): void

参数：

key: 添加的key值

value： 注意value值的类型

callback：回调函数

调用者：kvManager

4、获取指定键的值。

get(key: string, callback: AsyncCallback<Uint8Array|string|boolean|number>): void

参数：

key：查询的key值

callback：回调函数

调用者：kvManager

5、从数据库中删除指定键值的数据。

delete(key: string, callback: AsyncCallback<void>): void

参数：

key：删除的值

调用者：kvManager

封装键值型数据库使用

// 导入模块
import distributedKVStore from '@ohos.data.distributedKVStore';
 
const BUNDLE_NAME = "dbName_tengyu"
 
let context = getContext(this)
// 数据库对象
let kvManager: distributedKVStore.KVManager | undefined = undefined;
// KVStore数据库
let kvStore: distributedKVStore.SingleKVStore | undefined = undefined;
 
class DistributedUtil {
  constructor() {
    this.createKeyValueDB();
  }
 
  async getKvManager(bundleName?: string) {
    const kvStoreConfig: distributedKVStore.KVManagerConfig = {
      context: context,
      bundleName: bundleName || BUNDLE_NAME
    };
    try {
      kvManager = distributedKVStore.createKVManager(kvStoreConfig);
    }
    catch (err) {
      console.error(`error:${err}`)
    }
  }
 
  // 创建并得到指定类型的KVStore数据库
  async createKeyValueDB(op?: distributedKVStore.Options) {
    if (kvManager === undefined) {
      this.getKvManager();
    }
    try {
      const options: distributedKVStore.Options = {
        // 当数据库文件不存在时是否创建数据库，默认为true
        createIfMissing: true,
        // 设置数据库文件是否加密，默认为false，即不加密
        encrypt: false,
        // 设置数据库文件是否备份，默认为true，即备份
        backup: false,
        // 设置数据库文件是否自动同步。默认为false，即手动同步
        autoSync: true,
        // kvStoreType不填时，默认创建多设备协同数据库
        kvStoreType: distributedKVStore.KVStoreType.SINGLE_VERSION,
        // 多设备协同数据库：kvStoreType: distributedKVStore.KVStoreType.DEVICE_COLLABORATION,
        securityLevel: distributedKVStore.SecurityLevel.S1
      };
      // storeId为数据库唯一标识
      kvManager.getKVStore<distributedKVStore.SingleKVStore>('storeId', op || options, (err, store: distributedKVStore.SingleKVStore) => {
        if (err) {
          console.error(`Failed to get KVStore: Code:${err.code},message:${err.message}`);
          return;
        }
        console.info('Succeeded in getting KVStore.');
        // 进行相关数据操作
        kvStore = store;
      });
    } catch (e) {
      console.error(`An unexpected error occurred. Code:${e.code},message:${e.message}`);
    }
    return kvStore;
  }
 
  // 删除指定键值的数据
  async deleteStoreData(key: string) {
    if (!kvStore) {
      return;
    }
 
    try {
      kvStore.delete(key, (err) => {
        if (err !== undefined) {
          console.error(`Failed to delete data. Code:${err.code},message:${err.message}`);
          return;
        }
        console.info('Succeeded in deleting data.');
      });
    } catch (e) {
      console.error(`An unexpected error occurred. Code:${e.code},message:${e.message}`);
    }
  }
 
  // 向键值数据库中插入数据
  async putStoreData(key: string, value: any) {
    if (!key || !value) {
      return
    }
 
    if (!kvStore) {
      kvStore = await this.createKeyValueDB();
    }
 
    try {
      kvStore.put(key, value, (err) => {
        if (err !== undefined) {
          console.error(`Failed to put data. Code:${err.code},message:${err.message}`);
          return;
        }
        console.info('Succeeded in putting data.');
      });
    } catch (e) {
      console.error(`An unexpected error occurred. Code:${e.code},message:${e.message}`);
    }
  }
 
  // 获取指定键的值
  async getStoreData(key: string) {
    if (!key) {
      return
    }
 
    if (!kvStore) {
      kvStore = await this.createKeyValueDB();
    }
 
    return new Promise((resolve, reject) => {
      try {
        kvStore.get(key, (err, data) => {
          if (err != undefined) {
            console.error(`Failed to get data. Code:${err.code},message:${err.message}`);
            reject(err)
            return;
          }
          resolve(data)
        });
      } catch (err) {
        reject(err)
        console.error('TAG', `Failed to get value, Cause: ${err}`)
      }
    });
  }
}
 
export default new DistributedUtil();