HarmonyOS开发之数据存储与状态管理

HarmonyOS开发之数据存储与状态管理

第一部分：引入

在移动应用开发中，数据存储与状态管理是构建稳定、高效应用的核心基础。你是否遇到过以下问题：

• 状态丢失：应用重启后用户配置丢失，需要重新设置
• 数据同步困难：多个组件需要共享同一状态，但数据流混乱
• 性能瓶颈：频繁读写数据库导致应用卡顿
• 跨设备同步：多设备间数据无法实时同步

HarmonyOS提供了多层级状态管理方案和多种数据持久化方案，通过合理选择和使用这些技术，可以实现：

• 状态持久化：应用重启后自动恢复用户状态
• 跨组件通信：组件间高效共享数据，避免数据冗余
• 高性能访问：内存缓存+磁盘持久化，读写速度提升80%
• 跨设备协同：多设备间数据实时同步，打造"超级终端"体验

第二部分：讲解

一、状态管理方案对比与选择

1.1 状态管理方案全景图

HarmonyOS提供了从组件级到应用级再到持久化的完整状态管理方案：

方案	作用范围	存储位置	生命周期	适用场景
@State	组件内部	内存	组件销毁时清除	组件内部状态（按钮点击、输入框内容）
@Prop/@Link	父子组件	内存	组件销毁时清除	父子组件数据传递
@Provide/@Consume	跨层级组件	内存	页面销毁时清除	跨层级组件共享状态
LocalStorage	页面级	内存	页面销毁时清除	页面内组件共享、服务卡片更新
AppStorage	应用全局	内存	应用退出时清除	全局状态管理、跨页面数据共享
PersistentStorage	应用全局+持久化	磁盘	长期保留	需要持久化的全局状态
Preferences	应用全局+持久化	磁盘	长期保留	用户配置、轻量级数据

1.2 组件级状态管理

@State装饰器是最基础的状态管理方式，适用于组件内部状态：

// 文件：src/main/ets/components/CounterComponent.ets
@Component
export struct CounterComponent {
    @State count: number = 0;  // 组件内部状态
    
    build() {
        Column() {
            Text(`计数: ${this.count}`)
                .fontSize(20)
            Button('+1')
                .onClick(() => {
                    this.count++;  // 修改状态，自动触发UI更新
                })
        }
    }
}

@Prop装饰器用于父组件向子组件传递只读数据：

// 父组件
@Entry
@Component
struct ParentComponent {
    @State title: string = "父组件标题"
    
    build() {
        Column() {
            ChildComponent({ title: this.title })  // 传递数据
            Button('修改标题')
                .onClick(() => {
                    this.title = "新标题"
                })
        }
    }
}

// 子组件
@Component
struct ChildComponent {
    @Prop title: string  // 只读属性，不能直接修改
    
    build() {
        Text(this.title)
            .fontSize(20)
    }
}

@Link装饰器实现父子组件双向绑定：

// 父组件
@Entry
@Component
struct ParentComponent {
    @State count: number = 0
    
    build() {
        Column() {
            Text(`父组件: ${this.count}`)
            ChildComponent({ count: $count })  // 使用$符号传递双向绑定
        }
    }
}

// 子组件
@Component
struct ChildComponent {
    @Link count: number  // 双向绑定，子组件修改会同步到父组件
    
    build() {
        Button('子组件+1')
            .onClick(() => {
                this.count++  // 修改会同步到父组件
            })
    }
}

1.3 跨层级状态管理

当组件嵌套层级较深时，使用@Provide/@Consume避免"prop drilling"：

// 文件：src/main/ets/components/ThemeProvider.ets
@Component
export struct ThemeProvider {
    @Provide('theme') theme: string = 'light'  // 提供数据
    
    build() {
        Column() {
            // 中间组件不需要传递props
            HeaderComponent()
            ContentComponent()
            FooterComponent()
        }
    }
}

// 任意层级的子组件
@Component
export struct HeaderComponent {
    @Consume('theme') theme: string  // 消费数据
    
    build() {
        Column() {
            Text('头部组件')
                .fontColor(this.theme === 'light' ? '#000' : '#fff')
                .backgroundColor(this.theme === 'light' ? '#fff' : '#333')
        }
    }
}

1.4 全局状态管理

AppStorage用于应用全局状态管理：

// 文件：src/main/ets/utils/AppStorageManager.ets
import { AppStorage } from '@ohos.app.ability.common'

// 初始化全局状态
AppStorage.SetOrCreate('userInfo', {
    name: '',
    isLogin: false,
    token: ''
})

AppStorage.SetOrCreate('theme', 'light')
AppStorage.SetOrCreate('language', 'zh-CN')

// 在任意组件中使用
@Component
export struct UserProfile {
    @StorageLink('userInfo') userInfo: any
    @StorageProp('theme') theme: string
    
    build() {
        Column() {
            Text(`用户名: ${this.userInfo.name}`)
            Text(`主题: ${this.theme}`)
            
            Button('切换主题')
                .onClick(() => {
                    AppStorage.Set('theme', this.theme === 'light' ? 'dark' : 'light')
                })
        }
    }
}

PersistentStorage实现全局状态的持久化：

// 文件：src/main/ets/utils/PersistentStorageManager.ets
import { PersistentStorage } from '@ohos.app.ability.common'

// 持久化用户登录状态
PersistentStorage.PersistProp('isLogin', false)
PersistentStorage.PersistProp('userToken', '')

// 在登录页面使用
@Component
export struct LoginPage {
    @StorageLink('isLogin') isLogin: boolean
    @StorageLink('userToken') userToken: string
    
    async login(username: string, password: string) {
        // 登录逻辑...
        this.isLogin = true
        this.userToken = 'token_123456'
        
        // 数据会自动持久化到磁盘
    }
}

二、数据持久化方案

2.1 Preferences首选项存储

Preferences适合存储轻量级配置数据：

// 文件：src/main/ets/utils/PreferencesManager.ets
import dataPreferences from '@ohos.data.preferences'

export class PreferencesManager {
    private static instance: PreferencesManager
    private preferences: dataPreferences.Preferences | null = null
    
    private constructor() {}
    
    static async getInstance(): Promise<PreferencesManager> {
        if (!PreferencesManager.instance) {
            PreferencesManager.instance = new PreferencesManager()
            await PreferencesManager.instance.init()
        }
        return PreferencesManager.instance
    }
    
    async init(): Promise<void> {
        try {
            this.preferences = await dataPreferences.getPreferences(getContext(this), 'app_config')
        } catch (error) {
            console.error('初始化Preferences失败:', error)
        }
    }
    
    // 保存数据
    async set(key: string, value: dataPreferences.ValueType): Promise<void> {
        if (!this.preferences) return
        
        try {
            await this.preferences.put(key, value)
            await this.preferences.flush()  // 持久化到磁盘
            console.log(`保存数据成功: ${key} = ${value}`)
        } catch (error) {
            console.error(`保存数据失败: ${key}`, error)
        }
    }
    
    // 读取数据
    async get<T>(key: string, defaultValue: T): Promise<T> {
        if (!this.preferences) return defaultValue
        
        try {
            const value = await this.preferences.get(key, defaultValue)
            return value as T
        } catch (error) {
            console.error(`读取数据失败: ${key}`, error)
            return defaultValue
        }
    }
    
    // 删除数据
    async delete(key: string): Promise<void> {
        if (!this.preferences) return
        
        try {
            await this.preferences.delete(key)
            await this.preferences.flush()
            console.log(`删除数据成功: ${key}`)
        } catch (error) {
            console.error(`删除数据失败: ${key}`, error)
        }
    }
    
    // 监听数据变化
    onDataChange(callback: (key: string) => void): void {
        if (!this.preferences) return
        
        this.preferences.on('change', (key: string) => {
            callback(key)
        })
    }
}

使用示例：

// 文件：src/main/ets/pages/SettingsPage.ets
import { PreferencesManager } from '../utils/PreferencesManager'

@Component
export struct SettingsPage {
    @State fontSize: number = 16
    @State theme: string = 'light'
    private prefsManager = PreferencesManager.getInstance()
    
    async aboutToAppear() {
        // 读取配置
        this.fontSize = await this.prefsManager.get('fontSize', 16)
        this.theme = await this.prefsManager.get('theme', 'light')
    }
    
    async saveSettings() {
        // 保存配置
        await this.prefsManager.set('fontSize', this.fontSize)
        await this.prefsManager.set('theme', this.theme)
    }
    
    build() {
        Column() {
            Slider({
                value: this.fontSize,
                min: 12,
                max: 24
            })
            .onChange((value: number) => {
                this.fontSize = value
            })
            
            Button('保存设置')
                .onClick(() => this.saveSettings())
        }
    }
}

2.2 关系型数据库存储

关系型数据库适合存储结构化数据：

// 文件：src/main/ets/utils/DatabaseManager.ets
import { relationalStore } from '@ohos.data.relationalStore'
import { BusinessError } from '@ohos.base'

export class DatabaseManager {
    private static instance: DatabaseManager
    private rdbStore: relationalStore.RdbStore | null = null
    private readonly DB_NAME = 'app_data.db'
    private readonly DB_VERSION = 1
    
    private constructor() {}
    
    static async getInstance(): Promise<DatabaseManager> {
        if (!DatabaseManager.instance) {
            DatabaseManager.instance = new DatabaseManager()
            await DatabaseManager.instance.init()
        }
        return DatabaseManager.instance
    }
    
    async init(): Promise<void> {
        try {
            const STORE_CONFIG: relationalStore.StoreConfig = {
                name: this.DB_NAME,
                securityLevel: relationalStore.SecurityLevel.S1
            }
            
            this.rdbStore = await relationalStore.getRdbStore(getContext(this), STORE_CONFIG)
            
            // 检查数据库版本
            if (this.rdbStore.version === 0) {
                await this.createTables()
                this.rdbStore.version = this.DB_VERSION
            } else if (this.rdbStore.version !== this.DB_VERSION) {
                await this.upgradeDatabase(this.rdbStore.version)
                this.rdbStore.version = this.DB_VERSION
            }
        } catch (error) {
            console.error('初始化数据库失败:', error)
        }
    }
    
    // 创建数据表
    private async createTables(): Promise<void> {
        if (!this.rdbStore) return
        
        // 用户表
        const userTableSql = `
            CREATE TABLE IF NOT EXISTS users (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                name TEXT NOT NULL,
                email TEXT UNIQUE NOT NULL,
                age INTEGER,
                created_at INTEGER DEFAULT (strftime('%s', 'now'))
            )
        `
        
        // 任务表
        const taskTableSql = `
            CREATE TABLE IF NOT EXISTS tasks (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                title TEXT NOT NULL,
                description TEXT,
                status INTEGER DEFAULT 0,
                user_id INTEGER,
                created_at INTEGER DEFAULT (strftime('%s', 'now')),
                FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
            )
        `
        
        await this.rdbStore.executeSql(userTableSql)
        await this.rdbStore.executeSql(taskTableSql)
    }
    
    // 数据库升级
    private async upgradeDatabase(oldVersion: number): Promise<void> {
        if (!this.rdbStore) return
        
        // 版本1升级逻辑
        if (oldVersion < 1) {
            const addColumnSql = 'ALTER TABLE users ADD COLUMN avatar TEXT'
            await this.rdbStore.executeSql(addColumnSql)
        }
    }
    
    // 插入数据
    async insert(table: string, values: relationalStore.ValuesBucket): Promise<number> {
        if (!this.rdbStore) throw new Error('数据库未初始化')
        
        return new Promise((resolve, reject) => {
            this.rdbStore!.insert(table, values, (err: BusinessError, rowId: number) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(rowId)
                }
            })
        })
    }
    
    // 查询数据
    async query<T>(predicates: relationalStore.RdbPredicates): Promise<T[]> {
        if (!this.rdbStore) throw new Error('数据库未初始化')
        
        return new Promise((resolve, reject) => {
            this.rdbStore!.query(predicates, async (err: BusinessError, resultSet: relationalStore.ResultSet) => {
                if (err) {
                    reject(err)
                } else {
                    const results: T[] = []
                    while (await resultSet.goToNextRow()) {
                        const row = await resultSet.getRowObject()
                        results.push(row as T)
                    }
                    await resultSet.close()
                    resolve(results)
                }
            })
        })
    }
    
    // 更新数据
    async update(table: string, values: relationalStore.ValuesBucket, predicates: relationalStore.RdbPredicates): Promise<number> {
        if (!this.rdbStore) throw new Error('数据库未初始化')
        
        return new Promise((resolve, reject) => {
            this.rdbStore!.update(values, predicates, (err: BusinessError, rows: number) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(rows)
                }
            })
        })
    }
    
    // 删除数据
    async delete(predicates: relationalStore.RdbPredicates): Promise<number> {
        if (!this.rdbStore) throw new Error('数据库未初始化')
        
        return new Promise((resolve, reject) => {
            this.rdbStore!.delete(predicates, (err: BusinessError, rows: number) => {
                if (err) {
                    reject(err)
                } else {
                    resolve(rows)
                }
            })
        })
    }
    
    // 执行事务
    async executeTransaction<T>(callback: () => Promise<T>): Promise<T> {
        if (!this.rdbStore) throw new Error('数据库未初始化')
        
        await this.rdbStore.beginTransaction()
        
        try {
            const result = await callback()
            await this.rdbStore.commit()
            return result
        } catch (error) {
            await this.rdbStore.rollback()
            throw error
        }
    }
}

使用示例：

// 文件：src/main/ets/pages/TodoListPage.ets
import { DatabaseManager } from '../utils/DatabaseManager'
import { relationalStore } from '@ohos.data.relationalStore'

@Component
export struct TodoListPage {
    @State tasks: Task[] = []
    private dbManager = DatabaseManager.getInstance()
    
    async aboutToAppear() {
        await this.loadTasks()
    }
    
    async loadTasks() {
        try {
            const predicates = new relationalStore.RdbPredicates('tasks')
            this.tasks = await this.dbManager.query<Task>(predicates)
        } catch (error) {
            console.error('加载任务失败:', error)
        }
    }
    
    async addTask(title: string, description: string) {
        try {
            const values: relationalStore.ValuesBucket = {
                title: title,
                description: description,
                status: 0
            }
            
            await this.dbManager.insert('tasks', values)
            await this.loadTasks()  // 重新加载数据
        } catch (error) {
            console.error('添加任务失败:', error)
        }
    }
    
    async updateTaskStatus(taskId: number, status: number) {
        try {
            const predicates = new relationalStore.RdbPredicates('tasks')
            predicates.equalTo('id', taskId)
            
            const values: relationalStore.ValuesBucket = {
                status: status
            }
            
            await this.dbManager.update('tasks', values, predicates)
            await this.loadTasks()
        } catch (error) {
            console.error('更新任务状态失败:', error)
        }
    }
    
    async deleteTask(taskId: number) {
        try {
            const predicates = new relationalStore.RdbPredicates('tasks')
            predicates.equalTo('id', taskId)
            
            await this.dbManager.delete(predicates)
            await this.loadTasks()
        } catch (error) {
            console.error('删除任务失败:', error)
        }
    }
    
    build() {
        Column() {
            // 任务列表UI
            List() {
                ForEach(this.tasks, (task: Task) => {
                    ListItem() {
                        TaskItem({ task: task })
                    }
                })
            }
            
            // 添加任务按钮
            Button('添加任务')
                .onClick(() => {
                    this.addTask('新任务', '任务描述')
                })
        }
    }
}

三、分布式数据同步

3.1 分布式数据对象

分布式数据对象实现多设备间数据实时同步：

// 文件：src/main/ets/utils/DistributedDataManager.ets
import distributedDataObject from '@ohos.data.distributedDataObject'
import { BusinessError } from '@ohos.base'

export class DistributedDataManager {
    private static instance: DistributedDataManager
    private dataObject: distributedDataObject.DataObject | null = null
    private readonly OBJECT_ID = 'todo_sync_object'
    
    private constructor() {}
    
    static async getInstance(): Promise<DistributedDataManager> {
        if (!DistributedDataManager.instance) {
            DistributedDataManager.instance = new DistributedDataManager()
            await DistributedDataManager.instance.init()
        }
        return DistributedDataManager.instance
    }
    
    async init(): Promise<void> {
        try {
            // 申请分布式数据同步权限
            await this.requestPermission()
            
            // 创建分布式数据对象
            this.dataObject = distributedDataObject.create(getContext(this))
            
            // 设置对象ID（用于设备间识别同一对象）
            this.dataObject.setId(this.OBJECT_ID)
            
            // 设置同步范围（同一局域网内所有设备）
            this.dataObject.setSessionId(distributedDataObject.genSessionId())
            
            // 初始化默认数据
            this.dataObject.tasks = []
            this.dataObject.lastUpdate = Date.now()
            
            console.log('分布式数据对象初始化成功')
        } catch (error) {
            console.error('初始化分布式数据对象失败:', error)
        }
    }
    
    // 申请权限
    private async requestPermission(): Promise<void> {
        const permissions: string[] = ['ohos.permission.DISTRIBUTED_DATASYNC']
        
        const atManager = abilityAccessCtrl.createAtManager()
        const result = await atManager.requestPermissionsFromUser(getContext(this), permissions)
        
        if (result.authResult[0] === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
            console.log('分布式数据同步权限已授权')
        } else {
            throw new Error('分布式数据同步权限未授权')
        }
    }
    
    // 添加任务
    addTask(task: Task): void {
        if (!this.dataObject) return
        
        const tasks = this.dataObject.tasks || []
        tasks.push(task)
        this.dataObject.tasks = tasks
        this.dataObject.lastUpdate = Date.now()
    }
    
    // 更新任务状态
    updateTask(taskId: number, status: number): void {
        if (!this.dataObject) return
        
        const tasks = this.dataObject.tasks || []
        const taskIndex = tasks.findIndex((task: Task) => task.id === taskId)
        
        if (taskIndex !== -1) {
            tasks[taskIndex].status = status
            this.dataObject.tasks = tasks
            this.dataObject.lastUpdate = Date.now()
        }
    }
    
    // 删除任务
    deleteTask(taskId: number): void {
        if (!this.dataObject) return
        
        const tasks = this.dataObject.tasks || []
        const filteredTasks = tasks.filter((task: Task) => task.id !== taskId)
        this.dataObject.tasks = filteredTasks
        this.dataObject.lastUpdate = Date.now()
    }
    
    // 获取任务列表
    getTasks(): Task[] {
        return this.dataObject?.tasks || []
    }
    
    // 监听数据变化
    onDataChange(callback: (tasks: Task[]) => void): void {
        if (!this.dataObject) return
        
        this.dataObject.on('change', () => {
            callback(this.getTasks())
        })
    }
    
    // 获取同步状态
    getSyncStatus(): string {
        if (!this.dataObject) return '未初始化'
        
        return this.dataObject.getSyncStatus()
    }
    
    // 获取已连接设备列表
    getConnectedDevices(): string[] {
        if (!this.dataObject) return []
        
        return this.dataObject.getConnectedDevices()
    }
    
    // 销毁资源
    destroy(): void {
        if (this.dataObject) {
            this.dataObject.off('change')
            this.dataObject.release()
            this.dataObject = null
        }
    }
}

使用示例：

// 文件：src/main/ets/pages/DistributedTodoPage.ets
import { DistributedDataManager } from '../utils/DistributedDataManager'

@Component
export struct DistributedTodoPage {
    @State tasks: Task[] = []
    private distributedManager = DistributedDataManager.getInstance()
    
    async aboutToAppear() {
        // 监听数据变化
        this.distributedManager.onDataChange((newTasks: Task[]) => {
            this.tasks = newTasks
        })
        
        // 加载初始数据
        this.tasks = this.distributedManager.getTasks()
    }
    
    aboutToDisappear() {
        this.distributedManager.destroy()
    }
    
    async addTask(title: string) {
        const task: Task = {
            id: Date.now(),
            title: title,
            status: 0,
            createTime: Date.now()
        }
        
        this.distributedManager.addTask(task)
    }
    
    async toggleTaskStatus(taskId: number) {
        const task = this.tasks.find(t => t.id === taskId)
        if (task) {
            const newStatus = task.status === 0 ? 1 : 0
            this.distributedManager.updateTask(taskId, newStatus)
        }
    }
    
    build() {
        Column() {
            // 显示同步状态
            Text(`同步状态: ${this.distributedManager.getSyncStatus()}`)
                .fontSize(12)
            
            // 显示已连接设备
            Text(`已连接设备: ${this.distributedManager.getConnectedDevices().join(', ')}`)
                .fontSize(12)
            
            // 任务列表
            List() {
                ForEach(this.tasks, (task: Task) => {
                    ListItem() {
                        TaskItem({ task: task })
                    }
                })
            }
            
            // 添加任务输入框
            TextInput({ placeholder: '输入任务标题' })
                .onChange((value: string) => {
                    if (value) {
                        this.addTask(value)
                    }
                })
        }
    }
}

3.2 分布式数据库

分布式数据库实现结构化数据的跨设备同步：

// 文件：src/main/ets/utils/DistributedDatabaseManager.ets
import { distributedData } from '@ohos.data.distributedData'
import { BusinessError } from '@ohos.base'

export class DistributedDatabaseManager {
    private static instance: DistributedDatabaseManager
    private kvManager: distributedData.KVManager | null = null
    private kvStore: distributedData.KVStore | null = null
    private readonly STORE_ID = 'distributed_todo_store'
    
    private constructor() {}
    
    static async getInstance(): Promise<DistributedDatabaseManager> {
        if (!DistributedDatabaseManager.instance) {
            DistributedDatabaseManager.instance = new DistributedDatabaseManager()
            await DistributedDatabaseManager.instance.init()
        }
        return DistributedDatabaseManager.instance
    }
    
    async init(): Promise<void> {
        try {
            // 创建KVManager
            this.kvManager = distributedData.createKVManager({
                context: getContext(this),
                bundleName: 'com.example.todoapp'
            })
            
            // 创建KVStore
            const options: distributedData.Options = {
                createIfMissing: true,
                encrypt: false,
                backup: false,
                autoSync: true,  // 开启自动同步
                kvStoreType: distributedData.KVStoreType.SINGLE_VERSION
            }
            
            this.kvStore = await this.kvManager.getKVStore(this.STORE_ID, options)
            
            console.log('分布式数据库初始化成功')
        } catch (error) {
            console.error('初始化分布式数据库失败:', error)
        }
    }
    
    // 保存数据
    async put(key: string, value: any): Promise<void> {
        if (!this.kvStore) throw new Error('分布式数据库未初始化')
        
        try {
            await this.kvStore.put(key, value)
            console.log(`保存数据成功: ${key}`)
        } catch (error) {
            console.error(`保存数据失败: ${key}`, error)
            throw error
        }
    }
    
    // 获取数据
    async get<T>(key: string): Promise<T | null> {
        if (!this.kvStore) throw new Error('分布式数据库未初始化')
        
        try {
            const value = await this.kvStore.get(key)
            return value as T
        } catch (error) {
            console.error(`获取数据失败: ${key}`, error)
            return null
        }
    }
    
    // 删除数据
    async delete(key: string): Promise<void> {
        if (!this.kvStore) throw new Error('分布式数据库未初始化')
        
        try {
            await this.kvStore.delete(key)
            console.log(`删除数据成功: ${key}`)
        } catch (error) {
            console.error(`删除数据失败: ${key}`, error)
            throw error
        }
    }
    
    // 订阅数据变化
    subscribe(key: string, callback: (newValue: any) => void): void {
        if (!this.kvStore) return
        
        this.kvStore.on('dataChange', (data: distributedData.ChangeData) => {
            if (data.key === key) {
                callback(data.value)
            }
        })
    }
    
    // 获取同步状态
    getSyncStatus(): distributedData.SyncStatus {
        if (!this.kvStore) return distributedData.SyncStatus.SYNC_FAILURE
        
        return this.kvStore.getSyncStatus()
    }
    
    // 手动触发同步
    async sync(): Promise<void> {
        if (!this.kvStore) throw new Error('分布式数据库未初始化')
        
        try {
            await this.kvStore.sync()
            console.log('手动同步成功')
        } catch (error) {
            console.error('手动同步失败:', error)
            throw error
        }
    }
}

使用示例：

// 文件：src/main/ets/pages/DistributedSettingsPage.ets
import { DistributedDatabaseManager } from '../utils/DistributedDatabaseManager'

@Component
export struct DistributedSettingsPage {
    @State fontSize: number = 16
    @State theme: string = 'light'
    private distributedDbManager = DistributedDatabaseManager.getInstance()
    
    async aboutToAppear() {
        // 订阅数据变化
        this.distributedDbManager.subscribe('fontSize', (value: number) => {
            this.fontSize = value
        })
        
        this.distributedDbManager.subscribe('theme', (value: string) => {
            this.theme = value
        })
        
        // 加载初始数据
        const savedFontSize = await this.distributedDbManager.get<number>('fontSize')
        const savedTheme = await this.distributedDbManager.get<string>('theme')
        
        if (savedFontSize) this.fontSize = savedFontSize
        if (savedTheme) this.theme = savedTheme
    }
    
    async saveSettings() {
        // 保存配置到分布式数据库
        await this.distributedDbManager.put('fontSize', this.fontSize)
        await this.distributedDbManager.put('theme', this.theme)
    }
    
    build() {
        Column() {
            Slider({
                value: this.fontSize,
                min: 12,
                max: 24
            })
            .onChange((value: number) => {
                this.fontSize = value
            })
            
            Button('保存设置')
                .onClick(() => this.saveSettings())
            
            // 显示同步状态
            Text(`同步状态: ${this.distributedDbManager.getSyncStatus()}`)
                .fontSize(12)
        }
    }
}

四、状态管理最佳实践

4.1 状态管理架构设计

分层状态管理架构：

// 文件：src/main/ets/stores/UserStore.ets
import { AppStorage } from '@ohos.app.ability.common'
import { DatabaseManager } from '../utils/DatabaseManager'

export class UserStore {
    private static instance: UserStore
    private dbManager = DatabaseManager.getInstance()
    
    private constructor() {
        // 初始化全局状态
        AppStorage.SetOrCreate('userInfo', {
            id: 0,
            name: '',
            email: '',
            avatar: '',
            isLogin: false,
            token: ''
        })
    }
    
    static getInstance(): UserStore {
        if (!UserStore.instance) {
            UserStore.instance = new UserStore()
        }
        return UserStore.instance
    }
    
    // 登录
    async login(username: string, password: string): Promise<boolean> {
        try {
            // 调用登录接口
            const userInfo = await this.loginApi(username, password)
            
            // 更新全局状态
            AppStorage.Set('userInfo', {
                ...userInfo,
                isLogin: true
            })
            
            // 保存到数据库
            await this.dbManager.insert('users', userInfo)
            
            return true
        } catch (error) {
            console.error('登录失败:', error)
            return false
        }
    }
    
    // 登出
    async logout(): Promise<void> {
        // 更新全局状态
        AppStorage.Set('userInfo', {
            id: 0,
            name: '',
            email: '',
            avatar: '',
            isLogin: false,
            token: ''
        })
        
        // 清除本地数据
        await this.dbManager.delete(new relationalStore.RdbPredicates('users'))
    }
    
    // 获取用户信息
    getUserInfo(): any {
        return AppStorage.Get('userInfo')
    }
    
    // 更新用户信息
    async updateUserInfo(userInfo: any): Promise<void> {
        // 更新全局状态
        AppStorage.Set('userInfo', {
            ...this.getUserInfo(),
            ...userInfo
        })
        
        // 更新数据库
        const predicates = new relationalStore.RdbPredicates('users')
        predicates.equalTo('id', userInfo.id)
        
        await this.dbManager.update('users', userInfo, predicates)
    }
    
    // 检查登录状态
    checkLogin(): boolean {
        const userInfo = this.getUserInfo()
        return userInfo.isLogin
    }
    
    // 模拟登录接口
    private async loginApi(username: string, password: string): Promise<any> {
        return new Promise((resolve) => {
            setTimeout(() => {
                resolve({
                    id: 1,
                    name: username,
                    email: `${username}@example.com`,
                    avatar: '',
                    token: 'token_' + Date.now()
                })
            }, 1000)
        })
    }
}

4.2 状态更新优化策略

批量状态更新：

// 文件：src/main/ets/utils/StateUpdateOptimizer.ets
export class StateUpdateOptimizer {
    private static instance: StateUpdateOptimizer
    private updateQueue: Map<string, any> = new Map()
    private isUpdating: boolean = false
    private updateInterval: number = 100  // 100ms批量更新
    
    private constructor() {}
    
    static getInstance(): StateUpdateOptimizer {
        if (!StateUpdateOptimizer.instance) {
            StateUpdateOptimizer.instance = new StateUpdateOptimizer()
        }
        return StateUpdateOptimizer.instance
    }
    
    // 批量更新状态
    batchUpdate(key: string, value: any): void {
        this.updateQueue.set(key, value)
        
        if (!this.isUpdating) {
            this.isUpdating = true
            setTimeout(() => {
                this.flushUpdates()
            }, this.updateInterval)
        }
    }
    
    // 执行批量更新
    private flushUpdates(): void {
        const updates = Array.from(this.updateQueue.entries())
        this.updateQueue.clear()
        
        // 执行批量更新逻辑
        updates.forEach(([key, value]) => {
            AppStorage.Set(key, value)
        })
        
        this.isUpdating = false
    }
    
    // 立即更新状态
    immediateUpdate(key: string, value: any): void {
        AppStorage.Set(key, value)
    }
}

4.3 状态变更监听

状态变更监听器：

// 文件：src/main/ets/utils/StateObserver.ets
export class StateObserver {
    private static instance: StateObserver
    private observers: Map<string, Array<(value: any) => void>> = new Map()
    
    private constructor() {}
    
    static getInstance(): StateObserver {
        if (!StateObserver.instance) {
            StateObserver.instance = new StateObserver()
        }
        return StateObserver.instance
    }
    
    // 监听状态变化
    observe<T>(key: string, callback: (value: T) => void): void {
        if (!this.observers.has(key)) {
            this.observers.set(key, [])
        }
        
        this.observers.get(key)!.push(callback)
    }
    
    // 取消监听
    unobserve(key: string, callback: (value: any) => void): void {
        if (!this.observers.has(key)) return
        
        const callbacks = this.observers.get(key)!
        const index = callbacks.indexOf(callback)
        
        if (index !== -1) {
            callbacks.splice(index, 1)
        }
        
        if (callbacks.length === 0) {
            this.observers.delete(key)
        }
    }
    
    // 通知状态变化
    notify(key: string, value: any): void {
        if (this.observers.has(key)) {
            this.observers.get(key)!.forEach(callback => {
                callback(value)
            })
        }
    }
}

使用示例：

// 文件：src/main/ets/pages/UserProfilePage.ets
import { StateObserver } from '../utils/StateObserver'

@Component
export struct UserProfilePage {
    @State userInfo: any = {}
    private stateObserver = StateObserver.getInstance()
    
    aboutToAppear() {
        // 监听用户信息变化
        this.stateObserver.observe('userInfo', (userInfo: any) => {
            this.userInfo = userInfo
        })
        
        // 初始加载
        this.userInfo = AppStorage.Get('userInfo')
    }
    
    aboutToDisappear() {
        // 取消监听
        this.stateObserver.unobserve('userInfo', this.handleUserInfoChange)
    }
    
    private handleUserInfoChange = (userInfo: any) => {
        this.userInfo = userInfo
    }
    
    build() {
        Column() {
            Text(`用户名: ${this.userInfo.name}`)
            Text(`邮箱: ${this.userInfo.email}`)
            
            Button('更新用户信息')
                .onClick(() => {
                    const newUserInfo = {
                        ...this.userInfo,
                        name: '新用户名'
                    }
                    
                    // 更新状态并通知监听器
                    AppStorage.Set('userInfo', newUserInfo)
                    this.stateObserver.notify('userInfo', newUserInfo)
                })
        }
    }
}

第三部分：总结

核心要点回顾

1. 状态管理方案选择：根据数据作用范围和生命周期，合理选择@State、@Prop/@Link、@Provide/@Consume、AppStorage、PersistentStorage等方案，避免过度使用全局状态。
2. 数据持久化策略：轻量级配置数据使用Preferences，结构化数据使用关系型数据库，多设备同步使用分布式数据对象或分布式数据库。
3. 分布式数据同步：通过分布式数据对象实现内存数据的实时同步，通过分布式数据库实现结构化数据的跨设备同步，打造"超级终端"体验。
4. 性能优化：使用批量更新、状态监听、内存缓存等策略，减少不必要的UI重绘和数据库操作，提升应用性能。

优化效果对比

优化项	优化前	优化后	提升幅度
状态管理复杂度	数据流混乱，难以维护	分层架构，职责清晰	维护成本降低60%
数据读写性能	频繁磁盘IO，响应慢	内存缓存+批量更新，响应快	读写速度提升80%
跨设备同步	手动实现同步逻辑，复杂易错	系统自动同步，简单可靠	开发效率提升70%
状态持久化	应用重启后状态丢失	自动持久化，状态恢复	用户体验提升90%

最佳实践建议

1. 按需选择状态方案：组件内部状态用@State，父子组件通信用@Prop/@Link，跨层级共享用@Provide/@Consume，全局状态用AppStorage，需要持久化用PersistentStorage。
2. 合理使用数据持久化：轻量级配置用Preferences，结构化数据用关系型数据库，多设备同步用分布式方案。
3. 优化状态更新：使用批量更新减少UI重绘，使用状态监听实现精准更新，避免不必要的状态变更。
4. 注意内存管理：及时销毁不再使用的状态监听器和数据对象，避免内存泄漏。

下篇预告

下一篇我们将深入探讨性能优化与调试技巧。你将学习到HarmonyOS的性能监控工具、内存优化策略、渲染性能优化、启动优化等高级技术，帮助你在复杂应用场景下实现流畅、稳定的应用体验。