跳至主要內容

数据存储

添码座原创大约 5 分钟移动端HarmonyOS移动端HarmonyOS

HarmonyOS的数据存储

HarmonyOS的数据存储包括本地数据存储和分布式数据存储两大类，其中本地数据存储包含首选项数据存储、键值对数据存储和关系型数据存储三个小类。

  • 首选项数据存储：是一种基于Preferences文件的持久化存储方式，它一般用于保存用户的个性化全局设置。例如，字体大小、免打扰模式等。

  • 键值对数据存储：和应用场景紧密相关，存储应用中使用到的键值对数据。例如，商品ID、名称、价格等JSON数据。

  • 关系型数据存储：适用于存储包含复杂关系的应用数据。例如，商品数据、用户数据和订单数据等。

分布式数据存储则提供了不同数据存储方式的跨设备数据同步。


首选项数据存储

首选项数据存储最终是将数据存储在HarmonyOS的文件中，系统提供对底层文件读写的封装，并把底层文件映射成Preferences对象的实例。

用户首选项运作机制
用户首选项运作机制

首选项数据存储的数据格式也是基于键值对结构实现的，其功能都在@ohos.data.preferences包中，使用时导入。

import { defaultColor } from '../pages/Index';
import { defaultSize } from '../pages/Index';
// 导入Preferences功能包
import Pref from '@ohos.data.preferences';

// 存储名
const DB_NAME = 'myBb';
// 键，字体大小
const KEY_SIZE = 'keySize';
// 键，字体颜色
const KEY_COLOR = 'keyColor';

class PreferencesStorage {
    defineGetFontPreferences(context) {
        // 定义全局对象
        globalThis.getFontPreferences = (() => {
            let pref = Pref.getPreferences(context, DB_NAME);
            return pref;
        });
    }

    // 保存样式，包括大小和颜色
    saveFontStyle(fontSize: number, fontColor: string) {
        globalThis.getFontPreferences().then((preferences) => {
            preferences.put(KEY_SIZE, fontSize);
            preferences.put(KEY_COLOR, fontColor);
            preferences.flush();
        }).catch((err) => {
            console.error('保存失败, err: ' + err);
        });
    }

    // 获得字体大小
    async getFontSize() {
        let fontSize: number = defaultSize;
        const preferences = await globalThis.getFontPreferences();
        fontSize = await preferences.get(KEY_SIZE, fontSize);
        return fontSize;
    }

    // 获得字体颜色
    async getFontColor() {
        let fontColor: string = defaultColor;
        const preferences = await globalThis.getFontPreferences();
        // 从数据库中获得颜色，如果无则使用默认值
        fontColor = await preferences.get(KEY_COLOR, fontColor);
        return fontColor;
    }
}

// 导出对象
export default new PreferencesStorage();

除了使用场景内不同，其实键值对数据存储和首选项数据存储几乎没有什么本质上的不同。


关系型数据存储

HarmonyOS底层使用SQLite作为持久化的关系存储引擎，其功能都在@ohos.data.relationalStore包中，使用时导入。

关系型数据存储运作机制
关系型数据存储运作机制

首先引入要使用的关系数据库，存放于Rdb.ts文件中。

import dataRdb from '@ohos.data.relationalStore'

/**
 * 创建关系数据库和表
 * 
 */
export class Rdb {
    rdbStore: dataRdb.RdbStore = null;
    private sqlCreateTable: string = ''
    private STORE_CONFIG: dataRdb.StoreConfig = {name: 'my.db', securityLevel: 1};

    constructor(sqlCreateTable: string) {
        this.sqlCreateTable = sqlCreateTable;
    }

    // 获取rdbStore
    async getRdbStore() {
        if (this.rdbStore != null) {
            return this.rdbStore.executeSql(this.sqlCreateTable);
        }
        let getPromiseRdb = dataRdb.getRdbStore(globalThis.context, this.STORE_CONFIG);
        await getPromiseRdb.then(async (rdbStore) => {
            this.rdbStore = rdbStore;
            // 创建表
            rdbStore.executeSql(this.sqlCreateTable);
        }).catch((err) => {
            console.log("getRdbStore err." + JSON.stringify(err));
        });
    }
}

然后定义用户实体类，存放于文件User.ts中。

/**
 * 定义用户实体
 */
export class User {
    id: number;
    name: string;
    sex: string;
    age: number
    tel: string;

    constructor(id, name, sex, age, tel) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.tel = tel;
    }

    toString() {
        return this.id + ' ' + this.name + ' ' + this.sex + ' ' + this.age + ' ' + this.tel + '\n';
    }
}

然后定义对数据的操作，相当于实现DAO层操作。

import dataRdb from '@ohos.data.relationalStore'
import { User } from '../db/User'
import { Rdb } from '../db/Rdb'
import promptAction from '@ohos.promptAction';

/**
 * 定义数据读取方法，相当于DAO层
 *
 */
class UserAPI {
    private tableName: string = ''
    private columns: Array<string> = []
    private rdb: Rdb = null
    private sql_create_table = ''

    constructor(version: number) {
        if (version == 1) {
            this.tableName = 'user'
            this.columns = ['id', 'name', 'sex', 'age', 'tel']
            this.sql_create_table = 'CREATE TABLE IF NOT EXISTS '
                + this.tableName + '('
                + 'id INTEGER PRIMARY KEY AUTOINCREMENT, '
                + 'name TEXT NOT NULL, '
                + 'sex TEXT, '
                + 'age INTEGER, '
                + 'tel TEXT)';
            this.rdb = new Rdb(this.sql_create_table)
        }
        this.rdb.getRdbStore()
    }

    // 插入数据
    insertUser(user) {
        const valueBucket = JSON.parse(JSON.stringify(user));
        this.rdb.rdbStore.insert(this.tableName, valueBucket, function (err, ret) {
            console.log('insert done: ' + ret);
            promptAction.showToast({ message: '添加用户成功！' });
        });
    }

    // 根据用户名查询用户信息
    async queryUserByName(name) {
        let resultList;
        let predicates = new dataRdb.RdbPredicates(this.tableName);
        predicates.equalTo('name', name);
        let ret = await this.queryFromDB(predicates);
        resultList = this.getListFromResultSet(ret);
        return resultList;
    }

    // 查询全部用户信息
    async queryUserAll() {
        let resultList;
        let predicates = new dataRdb.RdbPredicates(this.tableName);
        let ret = await this.queryFromDB(predicates);
        resultList = this.getListFromResultSet(ret);
        return resultList;
    }

    // 根据条件查询数据库
    async queryFromDB(predicates) {
        let resultList;
        let promiseQuery = this.rdb.rdbStore.query(predicates, this.columns);
        await promiseQuery.then((resultSet) => {
            resultList = resultSet;
        }).catch((err) => {
            console.log("query err" + JSON.stringify(err));
        });
        return resultList;
    }

    // 将查询到的结果封装用户列表
    getListFromResultSet(resultSet) {
        let userList = [];
        for (let i = 0; i < resultSet.rowCount; i++) {
            resultSet.goToNextRow();
            let user = new User(resultSet.getDouble(resultSet.getColumnIndex('id')),
                resultSet.getString(resultSet.getColumnIndex('name')),
                resultSet.getString(resultSet.getColumnIndex('sex')),
                resultSet.getString(resultSet.getColumnIndex('age')),
                resultSet.getString(resultSet.getColumnIndex('tel')));
            userList.push(user);
        }
        return userList;
    }

    // 删除全部数据
    async deleteAll() {
        let result
        let predicates = new dataRdb.RdbPredicates(this.tableName);
        await this.rdb.rdbStore.delete(predicates).then((rows) => {
            result = rows;
            promptAction.showToast({ message: '删除数据，rows:' + rows });
        });
        return result
    }

    // 更新数据，暂时未使用
    updateUser(user) {
        const valueBucket = JSON.parse(JSON.stringify(user));
        let predicates = new dataRdb.RdbPredicates(this.tableName);
        predicates.equalTo('id', user.id);
        this.rdb.rdbStore.update(valueBucket, predicates, function (err, ret) {
            promptAction.showToast({ message: '更新数据，ret:' + ret });
        });
    }

    // 删除数据，暂时未使用
    deleteUserById(userId) {
        let predicates = new dataRdb.RdbPredicates(this.tableName);
        predicates.equalTo('id', userId);
        this.rdb.rdbStore.delete(predicates, function (err, rows) {
            promptAction.showToast({ message: '删除数据，rows::' + rows });
        });
    }
}

export default new UserAPI(1)

最后实现对数据的操作，相当于定义了Controller层。

import prompt from '@system.prompt';
import router from '@ohos.router';
import { User } from '../db/User';
import UserAPI from '../db/UserAPI'

/**
 * 定义操作界面，相当于定义Controller层
 * 
 */
@Entry
@Component
struct Index {
    @State username: string = '张三'
    @State userList: User[] = []
    @State result: string = ''
    private userTableApi = UserAPI

    build() {
        Flex({ direction: FlexDirection.Column, justifyContent: FlexAlign.Start, alignItems: ItemAlign.Center }) {
            Text('用户信息')
                .margin(10).width('90%').fontSize(35).align(Alignment.Center)
            TextInput({ placeholder: '请输入用户名', text: this.username })
                .margin(10).width('95%').fontSize(28)
                .onChange((v) => {
                    this.username = v
                })
            Row() {
                Button('按姓名查询', { type: ButtonType.Capsule, stateEffect: true })
                    .width('30%')
                    .padding(0)
                    .margin(1)
                    .fontSize(20)
                    .backgroundColor('#1890FF')
                    .onClick(() => {
                        // 用户数据校验
                        if (!this.checkUserData()) {
                            return;
                        }
                        // 查询用户
                        this.queryUser();
                    });
                Button('查询全部', { type: ButtonType.Capsule, stateEffect: true })
                    .width('30%')
                    .padding(0)
                    .margin(1)
                    .fontSize(20)
                    .backgroundColor('#1890FF')
                    .onClick(() => {
                        this.queryAllUser();
                    });
                Button('删除全部', { type: ButtonType.Capsule, stateEffect: true })
                    .width('30%')
                    .padding(0)
                    .margin(1)
                    .fontSize(20)
                    .backgroundColor('#1890FF')
                    .onClick(() => {
                        this.deleteAllUser();
                    });
            }

            // 用于显示结果文本
            Text(this.result)
                .fontSize(25)
                .margin(10)
                .align(Alignment.TopStart)
                .layoutWeight(1)
                .width('95%')
                .backgroundColor(0xEEEEEE)

            // 跳转到添加界面
            Text("添加用户")
                .fontColor('#0000FF')
                .fontSize(25)
                .margin(10)
                .onClick(() => {
                    router.pushUrl({
                        url: 'pages/adduser'
                    });
                });
        }
        .width('100%')
        .height('100%')
    }

    // 户名数据校验，这里仅仅校验了用户名
    checkUserData() {
        if (this.username == '') {
            prompt.showToast({
                message: '请输入用户名！',
                duration: 3000,
                bottom: '40%'
            });
            return false;
        }
        return true;
    }

    // 查询用户，采用的同步await执行方式
    queryUser() {
        this.userTableApi.queryUserByName(this.username).then((ret) => {
            this.userList = ret;
            if (this.userList.length === 0) {
                prompt.showToast({
                    message: '用户不存在！',
                    duration: 3000,
                    bottom: '40%'
                });
            }
            this.display();
        })
    }

    // 查询所有用户,回调方式
    queryAllUser() {
        this.userTableApi.queryUserAll().then((ret) => {
            this.userList = ret;
            if (this.userList.length === 0) {
                this.result = '';
                prompt.showToast({
                    message: '暂无用户！',
                    duration: 3000,
                    bottom: '40%'
                });
            }
            this.display();
        })
    }

    // 查询所有用户,回调方式
    deleteAllUser() {
        this.userTableApi.deleteAll().then((ret) => {
            if (ret > 0) {
                this.result = ''
            }
        })
    }

    // 用户列表转成字符串显示
    display() {
        let s = ''
        for (let i = 0; i < this.userList.length; i++) {
            s += this.userList[i].toString()
        }
        this.result = s
    }
}
```

<br>
<hr>
<br>

::: important 感谢支持
更多内容，请移步[《超级个体》](/about/planet.html)。
:::