一、键值型数据库

EntryAbility

//导入
import KVStoreUtil from '../utils/KVStoreUtil';

  onWindowStageCreate(windowStage: window.WindowStage): void {
    // 创建键值型数据库的实例
    let context = this.context;
    const kvManagerConfig: distributedKVStore.KVManagerConfig = {
      context: context,
      bundleName: 'com.xt.myApplication'
    };
    try {
      // 创建KVManager实例
      let kvManager: distributedKVStore.KVManager | undefined = distributedKVStore.createKVManager(kvManagerConfig);
      console.info('Succeeded in creating KVManager.');
      // 创建数据库
      let kvStore: distributedKVStore.SingleKVStore | undefined = undefined;
      try {
        const options: distributedKVStore.Options = {
          createIfMissing: true,
          encrypt: false,
          backup: false,
          autoSync: false,
          // kvStoreType不填时，默认创建多设备协同数据库
          kvStoreType: distributedKVStore.KVStoreType.SINGLE_VERSION,
          // 多设备协同数据库：kvStoreType: distributedKVStore.KVStoreType.DEVICE_COLLABORATION,
          securityLevel: distributedKVStore.SecurityLevel.S1
        };
        kvManager.getKVStore<distributedKVStore.SingleKVStore>('storeId', 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;
            // 保存数据库
            KVStoreUtil.setKVStore(kvStore)
          });
      } catch (e) {
        let error = e as BusinessError;
        console.error(`An unexpected error occurred. Code:${error.code},message:${error.message}`);
      }

    } catch (e) {
      let error = e as BusinessError;
      console.error(`Failed to create KVManager. Code:${error.code},message:${error.message}`);
    }


    // Main window is created, set main page for this ability
    hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageCreate');

    windowStage.loadContent('pages/Index', (err) => {
      if (err.code) {
        hilog.error(0x0000, 'testTag', 'Failed to load the content. Cause: %{public}s', JSON.stringify(err) ?? '');
        return;
      }
      hilog.info(0x0000, 'testTag', 'Succeeded in loading the content.');
    });
  }

KVStoreUtil.ets

import { distributedKVStore } from '@kit.ArkData';

export default class KVStoreUtil {
  private static kvStore: distributedKVStore.SingleKVStore

  static setKVStore(kvStore: distributedKVStore.SingleKVStore) {
    KVStoreUtil.kvStore = kvStore;
  }

  static getKVStore(): distributedKVStore.SingleKVStore {
    return KVStoreUtil.kvStore;
  }

  /**
   * 保存数据
   * @param key
   * @param value
   * @returns
  */
  static insert(key: string, value: string): Promise<string> {
    return new Promise((resolve, reject) => {
      KVStoreUtil.kvStore.put(key, value, (err) => {
        if (err !== undefined) {
          console.error(`Failed to put data. Code:${err.code},message:${err.message}`);
          reject(err)
        }
        console.info('Succeeded in putting data.');
        resolve(key + ':' + value)
      });
    })
  }

  /**
   * 获取
   * @param key
   * @returns
   */
  static get(key: string): Promise<string | number | boolean | Uint8Array | void> {
    return new Promise((resolve, reject) => {
      KVStoreUtil.kvStore.get(key, (err, data) => {
        if (err != undefined) {
          console.error(`Failed to get data. Code:${err.code},message:${err.message}`);
          reject(err)
        }
        console.info(`Succeeded in getting data. Data:${data}`);
        resolve(key + ':' + data)
      });
    })
  }


  /**
   * 删除
   * @param key
   * @returns
   */
  static delete(key: string): Promise<string> {
    return new Promise((resolve, reject) => {
      KVStoreUtil.kvStore.delete(key, (err) => {
        if (err !== undefined) {
          console.error(`Failed to delete data. Code:${err.code},message:${err.message}`);
          reject(err)
        }
        console.info('Succeeded in deleting data.');
        resolve(key)
      });
    })
  }
}

调用

import KVStoreUtil from '../utils/KVStoreUtil'
import { promptAction } from '@kit.ArkUI'
import { BusinessError } from '@ohos.base';

@Entry
@Component
struct Index {
  build() {
    Column() {
      Button('插入数据')
        .onClick(() => {
          KVStoreUtil.insert('username', '谢佳瑞').then((data) => {
            promptAction.openToast({
              message: '保存数据成功' + data
            })
          }).catch((error: BusinessError) => {
            promptAction.openToast({
              message: '保存数据失败 ' + error
            })
          })

        }).margin({ bottom: 50 })

      Button('查询数据')
        .onClick(() => {
          KVStoreUtil.get('username').then((data) => {
            promptAction.openToast({
              message: '查询数据成功:' + data
            })
          }).catch((error: BusinessError) => {
            promptAction.openToast({
              message: '查询数据失败 ' + error
            })
          })
        }).margin({ bottom: 50 })

      Button('删除数据')
        .onClick(() => {
          KVStoreUtil.delete('username').then((data) => {
            promptAction.openToast({
              message: '删除数据成功:' + data
            })
          }).catch((error: BusinessError) => {
            promptAction.openToast({
              message: '删除数据失败:' + error
            })
          })
        }).margin({ bottom: 50 })
    }
    .height('100%')
    .width('100%')
  }
}

二、通过用户首选项实现数据持久化

                ⑴封装用户首选项工具类

import { preferences } from "@kit.ArkData"

class PreferencesUtil {
  //创建一个变量来保存preferences的实例
  private Preferences: preferences.Preferences | null = null

  //获取Preferences实例
  createPreferences(context: Context) {
    //获取preferences的实例【第一个参数是context（应用场下文），第二个参数是实例的名称】
    preferences.getPreferences(context, 'Preferences')
      .then((object) => {
        //成功时会返回preferences实例
        this.Preferences = object
        console.log('testTag', '成功获取preferences实例')
      })
      .catch(() => {
        console.log('testTag', '获取preferences实例失败')
      })
  }

  //将数据写入preferences实例
  async writePreferenceValue(key: string, value: preferences.ValueType) {
    //判断一下preferences是否实例化
    if (!this.Preferences) {
      console.log('testTag,写入数据 未实例化')
      return
    }
    try { //实例化后，调用put方法来写入数据【第一个值传入要写入的string类型的Key,第二个值是要写入的数据】
      await this.Preferences.put(key, value)
      console.log('testTag,写入数据中 key:', key, "value:", value)
      //通过flash方法将preferences实例持久化
      await this.Preferences.flush()
      console.log('testTag,写入数据中 实例持久化',)
      console.log('testTag,写入数据成功')
    } catch (e) {
      console.log('testTag,写入数据失败')
    }
  }

  //读数据的操作
  //获取键对应的值
  async readPreferenceValue(key: string, defaultValue: preferences.ValueType) {
    //判断一下preferences是否实例化
    if (!this.Preferences) {
      console.log('testTag, preferences未实例化，返回默认值')
      return defaultValue // 未实例化时返回默认值
    }
    try { //实例化后，调用get方法获取数据【第一个值传入要获取的string类型的Key,第二个值表示默认值】
      let value = await this.Preferences.get(key, defaultValue)
      return value
    } catch (e) {
      console.log('testTag,写入数据失败')
      return defaultValue // 出错时返回默认值
    }
  }

  //删除数据的操作
  async deletePreferenceValue(key: string) {
    try {
      await this.Preferences?.delete(key)
      try {
        await this.Preferences?.flush()
        console.log('testTag,删除数据成功')
      } catch (error) {
        console.log('testTag,删除数据失败', error)
      }
    } catch (error) {
      console.log('testTag,删除数据失败', error)
    }

  }
}

export default new PreferencesUtil()

                ⑵初始化用户首选项

import PreferencesUtil from '../utils/PreferencesUtil'

const DOMAIN = 0x0000;

export default class EntryAbility extends UIAbility {
  async onWindowStageCreate(windowStage: window.WindowStage): Promise<void> {
     …… ……
    //实例化preferences
    PreferencesUtil.createPreferences(this.context)
  }
}

                ⑶使用用户首选项

import PreferencesUtil from '../util/PreferencesUtil'

@Entry
@Component
struct Preferences {
  @State message: string = ''

  build() {
    Column({ space: 25 }) {
      Button('记录数据')
        .onClick(() => {
          PreferencesUtil.writePreferenceValue("name", "RAY")
        })
      Button('读取数据')
        .onClick(async () => {
          this.message = await PreferencesUtil.readPreferenceValue("name", "nameRead") as string
        })
      Button('删除数据')
        .onClick(async () => {
          await PreferencesUtil.deletePreferenceValue("name")
        })
      Text(`数据为：${this.message}`)
    }.width('100%')
    .height('100%')
  }
}

三、通过关系型数据库实现数据库持久化

                ①、定义类

import relationalStore from "@ohos.data.relationalStore";
import MemoModel from "../models/MemoModel";

class rdb {
  private rdbStore: relationalStore.RdbStore | null = null
  private tableName: string
  private sql: string
  private columns: Array<string>

  constructor(tableName: string, sql: string, columns: Array<string>) {
    this.tableName = tableName
    this.sql = sql
    this.columns = columns
  }

  getRdbStore(callback: Function = () => {
  }) {
    let context: Context = getContext(this)
    let StoreConfig: relationalStore.StoreConfig = {
      name: 'xie.db',
      securityLevel: relationalStore.SecurityLevel.S2
    }
    relationalStore.getRdbStore(context, StoreConfig, (err, rdb) => {
      if (err) {
        console.log('testTag gerRdbStore() 失败, err:', err)
      }
      this.rdbStore = rdb
      this.rdbStore.executeSql(this.sql)
      console.log('testTag gerRdbStore() 成功')
      callback()
    })
  }

  insert(memo: MemoModel, callback: Function = () => {
  }) {
    if (this.rdbStore) {
      let data: relationalStore.ValuesBucket = generateBucket(memo);
      this.rdbStore.insert(this.tableName, data, (err, res) => {
        if (err) {
          console.log('testTag insertData() 失败,', err)
        }
        console.log('testTag insertData() 完成')
        callback(res)
      })
    }
  }

  delete(memo: MemoModel) {
    if (this.rdbStore) {
      let Predicates: relationalStore.RdbPredicates = new relationalStore.RdbPredicates(this.tableName)
      Predicates.equalTo('id', memo.id)
      this.rdbStore.delete(Predicates, (err, res) => {
        if (err) {
          console.log('testTag deleteData() 失败, ', err)
        }
        console.log('testTag deleteData() 成功 ', res)
      })
    }
  }

  update(memo: MemoModel) {
    if (this.rdbStore) {
      let data: relationalStore.ValuesBucket = generateBucket(memo);
      let Predicates: relationalStore.RdbPredicates = new relationalStore.RdbPredicates(this.tableName)
      Predicates.equalTo('id', memo.id);
      this.rdbStore.update(data, Predicates, (err, res) => {
        if (err) {
          console.log('testTag updateData() 失败,', err)
        }
        console.log('testTag updateData() 成功', res)
      })
    }
  }

  query(
    callback: Function
  ) {
    if (this.rdbStore) {
      let Predicates: relationalStore.RdbPredicates = new relationalStore.RdbPredicates(this.tableName)
      this.rdbStore.query(Predicates, this.columns, (err, res) => {
        if (err) {
          console.log('testTag query() 失败, err:', err)
        }
        // 创建局部变量，存储结果的行数
        let count: number = res.rowCount;
        // 如果查询的结果为0，执行回调函数，传入空数组
        if (count === 0 || typeof count === 'string') {
          console.log('testTag' + 'Query no results!');
          callback([]);
        } else {
          // 如果有结果，将结果集指向第一行
          res.goToFirstRow();
          // 创建局部变量，存储最后将返回的结果数组
          const result: MemoModel[] = [];
          // 使用循环为结果添加内容
          for (let i = 0; i < count; i++) {
            let tmp = new MemoModel(0, 0, '');
            tmp.id = res.getDouble(res.getColumnIndex('id'));
            tmp.updateTime = res.getDouble(res.getColumnIndex('updateTime'));
            tmp.contest = res.getString(res.getColumnIndex('content'));
            result[i] = tmp;
            // 转至下一行
            res.goToNextRow();
          }
          console.log('testTag query() 成功', JSON.stringify(res))
          callback(result)
          res.close()
        }
      })
    }
  }
}

function generateBucket(memo: MemoModel): relationalStore.ValuesBucket {
  let obj: relationalStore.ValuesBucket = {};
  obj.updateTime = memo.updateTime
  obj.content = memo.contest
  return obj;
}

export default new rdb('memoTable',
  'CREATE TABLE IF NOT EXISTS memoTable(id INTEGER PRIMARY KEY AUTOINCREMENT, updateTime INTEGER, content TEXT)',
  ['id', 'updateTime', 'content'])

                ②、导入类、进行调用

Button('创建数据库表')
        .onClick(() => {
          rdb.getRdbStore()
        })

      Button('插入数据')
        .onClick(() => {
          rdb.insert(new MemoModel(1, 11, ''))
        })

      Button('查询数据')
        .onClick(() => {
          rdb.query((res: MemoModel[]) => {
            this.memoList = res
          })
        })

      Button('修改数据')
        .onClick(() => {
          rdb.update(this.memoList[0])
        })


      Button('删除数据')
        .onClick(() => {
          rdb.delete(this.memoList[0])
        })