【鸿蒙HarmonyOS.4】健身APP项目 第五天（借鉴b站某厂程序员）

已于 2024-06-29 20:36:55 修改
阅读量180 收藏
点赞数 1
文章标签： harmonyos 华为
于 2024-06-22 22:47:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linanchunyuchuji/article/details/139885281
版权

目录

数据库初始化

增删方法

改查方法

开始制作数据模型

  • 数据库初始化

  • 在viewmodel文件夹中新建ColumnInfo.ets存储数据库列信息
  • 该部分现阶段ColumnInfo.ets代码
//存储数据库列信息

export interface ColumnInfo {
  name: string;
  columnName: string;   //列名字
  type: ColumnType;     //类型，存储到数据库里面每一列他需要的什么数据类型
}

export enum ColumnType {    //在创建列时，就可以通过枚举类来规定他的类型
  LONG,
  DOUBLE,
  STRING,
  BLOB
}
  • 在utils文件夹中新建DBUtil.ets数据库工具类
  • 该部分现阶段DBUtil.ets代码
//数据库工具类

import relationalStore from '@ohos.data.relationalStore'
import common from '@ohos.app.ability.common';
import Logger from './Logger';

//定义一个变量，数据库的名字
const DB_FILENAME: string = 'BaiZhanKeep.db'

class DBUtil {
  //规定一下数据类型
  rdbStore: relationalStore.RdbStore;

  //初始化数据库
  initDB(context: common.UIAbilityContext): Promise<void> {  //生命周期UIAbilityContext，泛型处理Promise<void>
    let config: relationalStore.StoreConfig = {
      name: DB_FILENAME,      //配置数据库的名字
      //配置安全等级
      securityLevel: relationalStore.SecurityLevel.S1  //最低等级S1,不是什么重要的数据
    }

    //返回
    return new Promise<void>((resolve, reject) => {  //初始化成功后返回resolve，失败返回reject
      relationalStore.getRdbStore(context, config)
        .then(rdbStore => {       //异步处理
          this.rdbStore = rdbStore
          Logger.debug('rdbStore 初始化完成')    //记录
          resolve()
        })
        .catch(reason => {
          Logger.debug('rdbStore 初始化异常', JSON.stringify(reason))  //将reason转化成JSON模式，以便于看懂
          reject(reason)
        })
    })
  }

//导出
let dbUtil: DBUtil = new DBUtil()
export default dbUtil as DBUtil
  • 在EntryAbility.ets中完成数据初始化
import UIAbility from '@ohos.app.ability.UIAbility';
import hilog from '@ohos.hilog';
import window from '@ohos.window';
import RecordModel from '../model/RecordModel';
import DateUtil from '../utils/DateUtil';
import DBUtil from '../utils/DBUtil';
import Logger from '../utils/Logger';
import PreferencesUtil from '../utils/PreferencesUtil';

export default class EntryAbility extends UIAbility {
  async onCreate(want, launchParam) {  //变成一个异步操作，在onCreate前添加async  //onCreate里的内容在项目完成加载的时候就已经完成了
    //加载用户首选项
    PreferencesUtil.loadPreference(this.context)
    Logger.debug('加载用户首选项')
    //初始化日期
    AppStorage.SetOrCreate('selectedDate', DateUtil.beginTimeOfDay(new Date()))
    Logger.debug('初始化日期')
    //初始化数据库（异步操作，使用await）
    await DBUtil.initDB(this.context)
    Logger.debug('初始化数据库')
    hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onCreate');
    //创建数据库表
    DBUtil.createTable(RecordModel.getCreateTableSql())
    Logger.debug('创建record表')
  }

  onDestroy() {
    hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onDestroy');
  }

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

    windowStage.loadContent('pages/SplashIndex', (err, data) => {
      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. Data: %{public}s', JSON.stringify(data) ?? '');
    });
  }

  onWindowStageDestroy() {
    // Main window is destroyed, release UI related resources
    hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onWindowStageDestroy');
  }

  onForeground() {
    // Ability has brought to foreground
    hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onForeground');
  }

  onBackground() {
    // Ability has back to background
    hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onBackground');
  }
}

  • 增删方法

  • 该部分现阶段DBUtil.ets代码
//数据库工具类

import relationalStore from '@ohos.data.relationalStore'
import common from '@ohos.app.ability.common';
import Logger from './Logger';
import { ColumnInfo, ColumnType } from '../viewmodel/ColumnInfo';

//定义一个变量，数据库的名字
const DB_FILENAME: string = 'BaiZhanKeep.db'

class DBUtil {
  //规定一下数据类型
  rdbStore: relationalStore.RdbStore;

  //初始化数据库
  initDB(context: common.UIAbilityContext): Promise<void> {  //生命周期UIAbilityContext，泛型处理Promise<void>
    let config: relationalStore.StoreConfig = {
      name: DB_FILENAME,      //配置数据库的名字
      //配置安全等级
      securityLevel: relationalStore.SecurityLevel.S1  //最低等级S1,不是什么重要的数据
    }

    //返回
    return new Promise<void>((resolve, reject) => {  //初始化成功后返回resolve，失败返回reject
      relationalStore.getRdbStore(context, config)
        .then(rdbStore => {       //异步处理
          this.rdbStore = rdbStore
          Logger.debug('rdbStore 初始化完成')    //记录
          resolve()
        })
        .catch(reason => {
          Logger.debug('rdbStore 初始化异常', JSON.stringify(reason))  //将reason转化成JSON模式，以便于看懂
          reject(reason)
        })
    })
  }
  /*
  创建数据库表
   */
  createTable(createSQL: string): Promise<void> {
    return new Promise((resolve, reject) => {
      this.rdbStore.executeSql(createSQL)
        .then(() => {
          Logger.debug('成功创建表', createSQL)  //记录日志
          resolve()
        }).catch((err) => {
        Logger.error('创建表失败，' + err.message, JSON.stringify(err))
        reject(err)
      })
    })
  }

  /*
  增
   */
  insert(tableName: string, obj: any, columns: ColumnInfo[]) {    //传入的数据，表名，数据对象，全部的列
    return new Promise((resolve, reject) => {
      //构建新增数据
      //每一列都不同的数据类型，所以这不可能知道他每一列的数据类型，所以重新写一个buildValueBucket方法转换表中列的数据类型
      let value = this.buildValueBucket(obj, columns)
      //实现新增
      this.rdbStore.insert(tableName, value, (err, id) => {   //在新增完成后会有两个结果，新增失败err，新增成功id
        if(err) {
          Logger.error('新增失败', JSON.stringify(err))
          reject(err)
        } else {
          Logger.debug('新增成功，新增数据ID：' + id.toString())
          resolve(id)
        }
      })
    })
  }

  /*
  删
   */
  delete(predicates: relationalStore.RdbPredicates) {   //只需传一个参数即可
    return new Promise((resolve, reject) => {
      this.rdbStore.delete(predicates, (err, rows) => {
        if(err) {
          Logger.error('删除失败', JSON.stringify(err))
          reject(err)
        } else {
          Logger.debug('删除成功，删除第' + rows.toString() + '行数据')
          resolve(rows)
        }
      })
    })
  }

  /*
  转换表中列的数据类型
   */
  buildValueBucket(obj: any, columns: ColumnInfo[]): relationalStore.ValuesBucket {
    let value = {}
    columns.forEach(info => {
      let val = obj[info.name]
      if(typeof val !== 'undefined') {
        value[info.columnName] = val
      }
    })
    return value
  }

}


//导出
let dbUtil: DBUtil = new DBUtil()
export default dbUtil as DBUtil

  • 改查方法

  • 该部分现阶段DBUtil.ets代码
//数据库工具类

import relationalStore from '@ohos.data.relationalStore'
import common from '@ohos.app.ability.common';
import Logger from './Logger';
import { ColumnInfo, ColumnType } from '../viewmodel/ColumnInfo';

//定义一个变量，数据库的名字
const DB_FILENAME: string = 'BaiZhanKeep.db'

class DBUtil {
  //规定一下数据类型
  rdbStore: relationalStore.RdbStore;

  //初始化数据库
  initDB(context: common.UIAbilityContext): Promise<void> {  //生命周期UIAbilityContext，泛型处理Promise<void>
    let config: relationalStore.StoreConfig = {
      name: DB_FILENAME,      //配置数据库的名字
      //配置安全等级
      securityLevel: relationalStore.SecurityLevel.S1  //最低等级S1,不是什么重要的数据
    }

    //返回
    return new Promise<void>((resolve, reject) => {  //初始化成功后返回resolve，失败返回reject
      relationalStore.getRdbStore(context, config)
        .then(rdbStore => {       //异步处理
          this.rdbStore = rdbStore
          Logger.debug('rdbStore 初始化完成')    //记录
          resolve()
        })
        .catch(reason => {
          Logger.debug('rdbStore 初始化异常', JSON.stringify(reason))  //将reason转化成JSON模式，以便于看懂
          reject(reason)
        })
    })
  }
  /*
  创建数据库表
   */
  createTable(createSQL: string): Promise<void> {
    return new Promise((resolve, reject) => {
      this.rdbStore.executeSql(createSQL)
        .then(() => {
          Logger.debug('成功创建表', createSQL)  //记录日志
          resolve()
        }).catch((err) => {
        Logger.error('创建表失败，' + err.message, JSON.stringify(err))
        reject(err)
      })
    })
  }

  /*
  增
   */
  insert(tableName: string, obj: any, columns: ColumnInfo[]) {    //传入的数据，表名，数据对象，全部的列
    return new Promise((resolve, reject) => {
      //构建新增数据
      //每一列都不同的数据类型，所以这不可能知道他每一列的数据类型，所以重新写一个buildValueBucket方法转换表中列的数据类型
      let value = this.buildValueBucket(obj, columns)
      //实现新增
      this.rdbStore.insert(tableName, value, (err, id) => {   //在新增完成后会有两个结果，新增失败err，新增成功id
        if(err) {
          Logger.error('新增失败', JSON.stringify(err))
          reject(err)
        } else {
          Logger.debug('新增成功，新增数据ID：' + id.toString())
          resolve(id)
        }
      })
    })
  }

  /*
  删
   */
  delete(predicates: relationalStore.RdbPredicates) {   //只需传一个参数即可
    return new Promise((resolve, reject) => {
      this.rdbStore.delete(predicates, (err, rows) => {
        if(err) {
          Logger.error('删除失败', JSON.stringify(err))
          reject(err)
        } else {
          Logger.debug('删除成功，删除第' + rows.toString() + '行数据')
          resolve(rows)
        }
      })
    })
  }

  /*
  查
   */
  queryForList<T> (predicates: relationalStore.RdbPredicates, columns: ColumnInfo[]): Promise<T[]> {
    return new Promise((resolve, reject) => {
      this.rdbStore.query(predicates, columns.map(info => info.columnName), (err, result) => {    //获取到每一列的名字
        if(err) {
          Logger.error('查询失败', JSON.stringify(err))
          reject(err)
        } else {
          Logger.debug('查询成功，查询到 ' + result.rowCount.toString() + ' 行')   //查询到的行数
          //写一个可以让resolve读取result的parseResulSet方法
          resolve(this.parseResulSet(result, columns))
        }
      })
    })
  }

  /*
  改
   */
  update(obj: any, columns: ColumnInfo[], predicates: relationalStore.RdbPredicates) {
    return new Promise((resolve, reject) => {
      let value = this.buildValueBucket(obj, columns)
      this.rdbStore.update(value, predicates, (err, id) => {
        if(err) {
          Logger.error('修改失败', JSON.stringify(err))
          reject(err)
        } else {
          Logger.debug('修改成功，修改数据ID为：' + id)
          resolve(id)
        }
      })
    })
  }

  /*
  处理查询方法返回的Promise类型数据
   */
  parseResulSet<T> (result: relationalStore.ResultSet, columns: ColumnInfo[]): T[] {
    let arr = []

    //如果result的行数为<=0, 那就说明没有查询到东西，直接把控数组return
    if(result.rowCount <= 0) {
      return arr
    }

    //如果有东西，则需要循环处理，因为数据不仅只有一条
    //循环处理结果,循环条件：当所在行不是最后一行
    while (!result.isAtLastRow) {       //当result不处于最后一行时进行循环，如果已经是最后一行，则循环结束
      //去往下一行
      result.goToNextRow() //在这直接去往下一行，那第一行就不会读取到了，原因：因为在数据表中第一行一般为列名什么，所以需要获取的是列名以外的数据
      //解析数据，转换成对象
      let obj = {}
      columns.forEach(info => {
        let val = null
        //因为不知道每一列的数据类型，所以需要判断他的数据类型是什么，循环判断
        switch (info.type) {
          case ColumnType.LONG:  //使用ColumnType枚举类型判断
            val = result.getLong(result.getColumnIndex(info.columnName))
            break;
          case ColumnType.DOUBLE:
            val = result.getDouble(result.getColumnIndex(info.columnName))
            break;
          case ColumnType.STRING:
            val = result.getString(result.getColumnIndex(info.columnName))
            break;
          case ColumnType.BLOB:
            val = result.getBlob(result.getColumnIndex(info.columnName))
            break;
        }
        obj[info.name] = val    //确定到数据类型
      })
      //将对象填入结果数组
      arr.push(obj)
      Logger.debug('查询到的数据：' + JSON.stringify(obj))
    }
    return arr
  }

  /*
  转换表中列的数据类型
   */
  buildValueBucket(obj: any, columns: ColumnInfo[]): relationalStore.ValuesBucket {
    let value = {}
    columns.forEach(info => {
      let val = obj[info.name]
      if(typeof val !== 'undefined') {
        value[info.columnName] = val
      }
    })
    return value
  }

}


//导出
let dbUtil: DBUtil = new DBUtil()
export default dbUtil as DBUtil

0疗伤烧肉粽
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值