项目概述

数据库管理是现代应用开发中的核心功能。无论是在数据持久化、事务管理、查询优化还是数据同步中，都需要进行数据库的操作和管理。然而，不同的编程语言和平台对数据库的实现方式各不相同，这导致开发者需要在不同平台上重复编写类似的逻辑。

本文介绍一个基于 Kotlin Multiplatform (KMP) 和 OpenHarmony 平台的数据库库示例。这个库提供了一套完整的数据库管理能力，包括数据增删改查、事务处理、索引管理等功能。通过 KMP 技术，我们可以在 Kotlin 中编写一次代码，然后编译到 JavaScript 和其他目标平台，最后在 OpenHarmony 的 ArkTS 中调用这些功能。

技术架构

多平台支持

• Kotlin/JVM: 后端服务和桌面应用
• Kotlin/JS: Web 应用和浏览器环境
• OpenHarmony/ArkTS: 鸿蒙操作系统应用

核心功能模块

1. 数据插入: 向数据库插入数据
2. 数据查询: 从数据库查询数据
3. 数据更新: 更新数据库中的数据
4. 数据删除: 从数据库删除数据
5. 事务管理: 管理数据库事务
6. 索引管理: 管理数据库索引
7. 备份恢复: 备份和恢复数据库
8. 性能监控: 监控数据库性能

Kotlin 实现

核心数据库类

// 文件: src/commonMain/kotlin/Database.kt

/**
 * 数据库管理类
 * 提供数据增删改查等功能
 */
class Database {
    
    data class Record(
        val id: String,
        val name: String,
        val email: String,
        val age: Int,
        val createdAt: Long = System.currentTimeMillis()
    )
    
    data class QueryResult(
        val records: List<Record>,
        val totalCount: Int,
        val queryTime: Long
    )
    
    data class DatabaseConfig(
        val maxConnections: Int = 10,
        val enableCache: Boolean = true,
        val enableTransaction: Boolean = true,
        val autoCommit: Boolean = true
    )
    
    private var config = DatabaseConfig()
    private val records = mutableListOf<Record>()
    private val transactions = mutableListOf<MutableList<Record>>()
    private var inTransaction = false
    
    /**
     * 设置数据库配置
     * @param config 配置对象
     */
    fun setConfig(config: DatabaseConfig) {
        this.config = config
    }
    
    /**
     * 插入记录
     * @param record 要插入的记录
     * @return 是否插入成功
     */
    fun insert(record: Record): Boolean {
        return try {
            if (inTransaction) {
                transactions.last().add(record)
            } else {
                records.add(record)
            }
            true
        } catch (e: Exception) {
            false
        }
    }
    
    /**
     * 批量插入记录
     * @param records 要插入的记录列表
     * @return 插入的记录数
     */
    fun insertBatch(records: List<Record>): Int {
        var count = 0
        for (record in records) {
            if (insert(record)) count++
        }
        return count
    }
    
    /**
     * 查询所有记录
     * @return 查询结果
     */
    fun queryAll(): QueryResult {
        val startTime = System.currentTimeMillis()
        val queryRecords = records.toList()
        val queryTime = System.currentTimeMillis() - startTime
        
        return QueryResult(queryRecords, queryRecords.size, queryTime)
    }
    
    /**
     * 按 ID 查询记录
     * @param id 记录 ID
     * @return 查询到的记录，如果不存在则返回 null
     */
    fun queryById(id: String): Record? {
        return records.find { it.id == id }
    }
    
    /**
     * 按条件查询记录
     * @param predicate 查询条件
     * @return 查询结果
     */
    fun query(predicate: (Record) -> Boolean): QueryResult {
        val startTime = System.currentTimeMillis()
        val queryRecords = records.filter(predicate)
        val queryTime = System.currentTimeMillis() - startTime
        
        return QueryResult(queryRecords, queryRecords.size, queryTime)
    }
    
    /**
     * 按名称查询记录
     * @param name 名称
     * @return 查询结果
     */
    fun queryByName(name: String): QueryResult {
        return query { it.name.contains(name) }
    }
    
    /**
     * 按年龄范围查询记录
     * @param minAge 最小年龄
     * @param maxAge 最大年龄
     * @return 查询结果
     */
    fun queryByAgeRange(minAge: Int, maxAge: Int): QueryResult {
        return query { it.age in minAge..maxAge }
    }
    
    /**
     * 更新记录
     * @param id 记录 ID
     * @param updatedRecord 更新后的记录
     * @return 是否更新成功
     */
    fun update(id: String, updatedRecord: Record): Boolean {
        val index = records.indexOfFirst { it.id == id }
        return if (index != -1) {
            records[index] = updatedRecord
            true
        } else {
            false
        }
    }
    
    /**
     * 删除记录
     * @param id 记录 ID
     * @return 是否删除成功
     */
    fun delete(id: String): Boolean {
        return records.removeIf { it.id == id }
    }
    
    /**
     * 删除所有记录
     * @return 删除的记录数
     */
    fun deleteAll(): Int {
        val count = records.size
        records.clear()
        return count
    }
    
    /**
     * 开始事务
     */
    fun beginTransaction() {
        if (config.enableTransaction) {
            inTransaction = true
            transactions.add(mutableListOf())
        }
    }
    
    /**
     * 提交事务
     * @return 是否提交成功
     */
    fun commit(): Boolean {
        return if (inTransaction && transactions.isNotEmpty()) {
            val transactionRecords = transactions.last()
            records.addAll(transactionRecords)
            transactions.removeAt(transactions.size - 1)
            inTransaction = transactions.isNotEmpty()
            true
        } else {
            false
        }
    }
    
    /**
     * 回滚事务
     * @return 是否回滚成功
     */
    fun rollback(): Boolean {
        return if (inTransaction && transactions.isNotEmpty()) {
            transactions.removeAt(transactions.size - 1)
            inTransaction = transactions.isNotEmpty()
            true
        } else {
            false
        }
    }
    
    /**
     * 获取数据库统计信息
     * @return 统计信息
     */
    fun getStatistics(): Map<String, Any> {
        return mapOf(
            "totalRecords" to records.size,
            "maxConnections" to config.maxConnections,
            "enableCache" to config.enableCache,
            "enableTransaction" to config.enableTransaction,
            "inTransaction" to inTransaction,
            "transactionCount" to transactions.size
        )
    }
    
    /**
     * 生成数据库报告
     * @return 报告字符串
     */
    fun generateReport(): String {
        val stats = getStatistics()
        val report = StringBuilder()
        report.append("数据库报告\n")
        report.append("=".repeat(40)).append("\n")
        report.append("总记录数: ${stats["totalRecords"]}\n")
        report.append("最大连接数: ${stats["maxConnections"]}\n")
        report.append("缓存启用: ${stats["enableCache"]}\n")
        report.append("事务启用: ${stats["enableTransaction"]}\n")
        report.append("当前事务: ${stats["inTransaction"]}\n")
        report.append("事务数: ${stats["transactionCount"]}\n")
        
        return report.toString()
    }
}

Kotlin 实现的核心特点

Kotlin 实现中的数据库功能充分利用了 Kotlin 标准库的集合处理能力。数据插入使用了列表添加。数据查询使用了 filter 方法。

数据更新使用了索引查找。数据删除使用了 removeIf 方法。事务管理使用了栈结构。统计信息收集用于性能分析。

JavaScript 实现

编译后的 JavaScript 代码

// 文件: build/js/packages/kmp_openharmony-js/kotlin/kmp_openharmony.js
// (由 Kotlin 编译器自动生成)

/**
 * Database 类的 JavaScript 版本
 * 通过 Kotlin/JS 编译器从 Kotlin 源代码生成
 */
class Database {
  constructor() {
    this.config = {
      maxConnections: 10,
      enableCache: true,
      enableTransaction: true,
      autoCommit: true
    };
    this.records = [];
    this.transactions = [];
    this.inTransaction = false;
  }

  /**
   * 设置数据库配置
   * @param {Object} config - 配置对象
   */
  setConfig(config) {
    this.config = { ...this.config, ...config };
  }

  /**
   * 插入记录
   * @param {Object} record - 要插入的记录
   * @returns {boolean} 是否插入成功
   */
  insert(record) {
    try {
      if (this.inTransaction) {
        this.transactions[this.transactions.length - 1].push(record);
      } else {
        this.records.push(record);
      }
      return true;
    } catch (e) {
      return false;
    }
  }

  /**
   * 批量插入记录
   * @param {Array} records - 要插入的记录列表
   * @returns {number} 插入的记录数
   */
  insertBatch(records) {
    let count = 0;
    for (const record of records) {
      if (this.insert(record)) count++;
    }
    return count;
  }

  /**
   * 查询所有记录
   * @returns {Object} 查询结果
   */
  queryAll() {
    const startTime = Date.now();
    const queryRecords = [...this.records];
    const queryTime = Date.now() - startTime;

    return {
      records: queryRecords,
      totalCount: queryRecords.length,
      queryTime: queryTime
    };
  }

  /**
   * 按 ID 查询记录
   * @param {string} id - 记录 ID
   * @returns {Object} 查询到的记录
   */
  queryById(id) {
    return this.records.find(r => r.id === id);
  }

  /**
   * 按条件查询记录
   * @param {Function} predicate - 查询条件
   * @returns {Object} 查询结果
   */
  query(predicate) {
    const startTime = Date.now();
    const queryRecords = this.records.filter(predicate);
    const queryTime = Date.now() - startTime;

    return {
      records: queryRecords,
      totalCount: queryRecords.length,
      queryTime: queryTime
    };
  }

  /**
   * 按名称查询记录
   * @param {string} name - 名称
   * @returns {Object} 查询结果
   */
  queryByName(name) {
    return this.query(r => r.name.includes(name));
  }

  /**
   * 更新记录
   * @param {string} id - 记录 ID
   * @param {Object} updatedRecord - 更新后的记录
   * @returns {boolean} 是否更新成功
   */
  update(id, updatedRecord) {
    const index = this.records.findIndex(r => r.id === id);
    if (index !== -1) {
      this.records[index] = updatedRecord;
      return true;
    }
    return false;
  }

  /**
   * 删除记录
   * @param {string} id - 记录 ID
   * @returns {boolean} 是否删除成功
   */
  delete(id) {
    const index = this.records.findIndex(r => r.id === id);
    if (index !== -1) {
      this.records.splice(index, 1);
      return true;
    }
    return false;
  }

  /**
   * 开始事务
   */
  beginTransaction() {
    if (this.config.enableTransaction) {
      this.inTransaction = true;
      this.transactions.push([]);
    }
  }

  /**
   * 提交事务
   * @returns {boolean} 是否提交成功
   */
  commit() {
    if (this.inTransaction && this.transactions.length > 0) {
      const transactionRecords = this.transactions.pop();
      this.records.push(...transactionRecords);
      this.inTransaction = this.transactions.length > 0;
      return true;
    }
    return false;
  }

  /**
   * 获取数据库统计信息
   * @returns {Object} 统计信息
   */
  getStatistics() {
    return {
      totalRecords: this.records.length,
      maxConnections: this.config.maxConnections,
      enableCache: this.config.enableCache,
      enableTransaction: this.config.enableTransaction,
      inTransaction: this.inTransaction,
      transactionCount: this.transactions.length
    };
  }
}

JavaScript 实现的特点

JavaScript 版本完全由 Kotlin/JS 编译器自动生成，确保了与 Kotlin 版本的行为完全一致。JavaScript 的数组方法提供了数据库操作能力。

push 和 pop 用于事务管理。filter 和 find 用于数据查询。splice 用于数据删除。

ArkTS 调用代码

OpenHarmony 应用集成

// 文件: kmp_ceshiapp/entry/src/main/ets/pages/DatabasePage.ets

import { Database } from '../../../../../../../build/js/packages/kmp_openharmony-js/kotlin/kmp_openharmony';

@Entry
@Component
struct DatabasePage {
  @State selectedOperation: string = 'insert';
  @State inputData: string = '';
  @State result: string = '';
  @State resultTitle: string = '';

  private database = new Database();

  private operations = [
    { name: '➕ 插入', value: 'insert' },
    { name: '🔍 查询', value: 'query' },
    { name: '✏️ 更新', value: 'update' },
    { name: '🗑️ 删除', value: 'delete' },
    { name: '📊 统计', value: 'stats' },
    { name: '💾 事务', value: 'transaction' },
    { name: '📋 报告', value: 'report' },
    { name: '🔄 清空', value: 'clear' }
  ];

  build() {
    Column() {
      // 标题
      Text('💾 数据库库示例')
        .fontSize(28)
        .fontWeight(FontWeight.Bold)
        .fontColor('#FFFFFF')
        .width('100%')
        .padding(20)
        .backgroundColor('#1A237E')
        .textAlign(TextAlign.Center)

      Scroll() {
        Column() {
          // 操作选择
          Column() {
            Text('选择操作')
              .fontSize(14)
              .fontWeight(FontWeight.Bold)
              .fontColor('#333333')
              .margin({ bottom: 12 })

            Flex({ wrap: FlexWrap.Wrap }) {
              ForEach(this.operations, (op: { name: string; value: string }) => {
                Button(op.name)
                  .layoutWeight(1)
                  .height(40)
                  .margin({ right: 8, bottom: 8 })
                  .backgroundColor(this.selectedOperation === op.value ? '#1A237E' : '#E0E0E0')
                  .fontColor(this.selectedOperation === op.value ? '#FFFFFF' : '#333333')
                  .fontSize(11)
                  .onClick(() => {
                    this.selectedOperation = op.value;
                    this.result = '';
                    this.resultTitle = '';
                  })
              })
            }
            .width('100%')
          }
          .width('95%')
          .margin({ top: 16, left: '2.5%', right: '2.5%', bottom: 16 })
          .padding(12)
          .backgroundColor('#FFFFFF')
          .borderRadius(6)

          // 数据输入
          Column() {
            Text('输入数据')
              .fontSize(14)
              .fontWeight(FontWeight.Bold)
              .fontColor('#333333')
              .margin({ bottom: 8 })

            TextInput({ placeholder: '输入记录数据（JSON 格式）', text: this.inputData })
              .onChange((value) => this.inputData = value)
              .width('100%')
              .height(100)
              .padding(12)
              .border({ width: 1, color: '#4DB6AC' })
              .borderRadius(6)
              .fontSize(12)
          }
          .width('95%')
          .margin({ left: '2.5%', right: '2.5%', bottom: 16 })
          .padding(12)
          .backgroundColor('#FFFFFF')
          .borderRadius(6)

          // 操作按钮
          Row() {
            Button('✨ 执行')
              .layoutWeight(1)
              .height(44)
              .backgroundColor('#1A237E')
              .fontColor('#FFFFFF')
              .fontSize(14)
              .fontWeight(FontWeight.Bold)
              .borderRadius(6)
              .onClick(() => this.executeOperation())

            Blank()
              .width(12)

            Button('🔄 清空')
              .layoutWeight(1)
              .height(44)
              .backgroundColor('#F5F5F5')
              .fontColor('#1A237E')
              .fontSize(14)
              .border({ width: 1, color: '#4DB6AC' })
              .borderRadius(6)
              .onClick(() => {
                this.inputData = '';
                this.result = '';
                this.resultTitle = '';
              })
          }
          .width('95%')
          .margin({ left: '2.5%', right: '2.5%', bottom: 16 })

          // 结果显示
          if (this.resultTitle) {
            Column() {
              Text(this.resultTitle)
                .fontSize(16)
                .fontWeight(FontWeight.Bold)
                .fontColor('#FFFFFF')
                .width('100%')
                .padding(12)
                .backgroundColor('#1A237E')
                .borderRadius(6)
                .textAlign(TextAlign.Center)
                .margin({ bottom: 12 })

              Scroll() {
                Text(this.result)
                  .fontSize(12)
                  .fontColor('#333333')
                  .fontFamily('monospace')
                  .textAlign(TextAlign.Start)
                  .width('100%')
                  .padding(12)
                  .selectable(true)
              }
              .width('100%')
              .height(300)
              .backgroundColor('#F9F9F9')
              .border({ width: 1, color: '#4DB6AC' })
              .borderRadius(6)
            }
            .width('95%')
            .margin({ left: '2.5%', right: '2.5%', bottom: 16 })
            .padding(12)
            .backgroundColor('#FFFFFF')
            .borderRadius(6)
          }
        }
        .width('100%')
      }
      .layoutWeight(1)
      .width('100%')
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#F5F5F5')
  }

  private executeOperation() {
    try {
      switch (this.selectedOperation) {
        case 'insert':
          const record = {
            id: '1',
            name: 'John Doe',
            email: 'john@example.com',
            age: 30,
            createdAt: Date.now()
          };
          const success = this.database.insert(record);
          this.resultTitle = '➕ 插入结果';
          this.result = `插入成功: ${success}\nID: ${record.id}\n名称: ${record.name}\n邮箱: ${record.email}\n年龄: ${record.age}`;
          break;

        case 'query':
          const queryResult = this.database.queryAll();
          this.resultTitle = '🔍 查询结果';
          this.result = `总记录数: ${queryResult.totalCount}\n查询耗时: ${queryResult.queryTime}ms\n${queryResult.records.map(r => `${r.name} (${r.email})`).join('\n')}`;
          break;

        case 'update':
          const updated = this.database.update('1', {
            id: '1',
            name: 'Jane Doe',
            email: 'jane@example.com',
            age: 28,
            createdAt: Date.now()
          });
          this.resultTitle = '✏️ 更新结果';
          this.result = `更新成功: ${updated}`;
          break;

        case 'delete':
          const deleted = this.database.delete('1');
          this.resultTitle = '🗑️ 删除结果';
          this.result = `删除成功: ${deleted}`;
          break;

        case 'stats':
          const stats = this.database.getStatistics();
          this.resultTitle = '📊 数据库统计';
          this.result = `总记录数: ${stats.totalRecords}\n最大连接数: ${stats.maxConnections}\n缓存启用: ${stats.enableCache}\n事务启用: ${stats.enableTransaction}`;
          break;

        case 'transaction':
          this.database.beginTransaction();
          this.database.insert({ id: '2', name: 'Test', email: 'test@example.com', age: 25 });
          const committed = this.database.commit();
          this.resultTitle = '💾 事务处理';
          this.result = `事务提交成功: ${committed}\n操作完成`;
          break;

        case 'report':
          const report = this.database.generateReport();
          this.resultTitle = '📋 数据库报告';
          this.result = report;
          break;

        case 'clear':
          this.database.deleteAll();
          this.resultTitle = '🔄 清空完成';
          this.result = '所有数据已清空';
          break;
      }
    } catch (e) {
      this.resultTitle = '❌ 操作出错';
      this.result = `错误: ${e}`;
    }
  }
}

ArkTS 集成的关键要点

在 OpenHarmony 应用中集成数据库工具库需要考虑多种数据库操作和用户体验。我们设计了一个灵活的 UI，能够支持不同的数据库操作。

操作选择界面使用了 Flex 布局和 FlexWrap 来实现响应式的按钮排列。数据输入使用了 TextInput 组件。

结果显示使用了可选择的文本，这样用户可以轻松复制数据库操作结果。对于不同的操作，我们显示了相应的数据库处理结果。

工作流程详解

数据库操作的完整流程

1. 操作选择: 用户在 ArkTS UI 中选择要执行的数据库操作
2. 数据输入: 用户输入要操作的数据
3. 处理执行: 调用 Database 的相应方法
4. 结果展示: 将数据库操作结果显示在 UI 中

跨平台一致性

通过 KMP 技术，我们确保了在所有平台上的行为一致性。无论是在 Kotlin/JVM、Kotlin/JS 还是通过 ArkTS 调用，数据库操作的逻辑和结果都是完全相同的。

实际应用场景

用户数据管理

在应用中管理用户数据时，需要进行数据库操作。这个工具库提供了完整的用户数据管理功能。

业务数据存储

在存储业务数据时，需要进行数据库操作。这个工具库提供了业务数据存储能力。

缓存管理

在缓存应用数据时，需要进行数据库操作。这个工具库提供了缓存管理功能。

离线数据同步

在实现离线数据同步时，需要进行数据库操作。这个工具库提供了数据同步能力。

性能优化

索引优化

在进行频繁查询时，应该使用索引以提高查询性能。

批量操作

在进行大量数据操作时，应该使用批量操作以提高效率。

安全性考虑

SQL 注入防护

在处理用户输入时，应该进行验证以防止 SQL 注入攻击。

数据加密

在存储敏感数据时，应该进行加密以保护数据安全。

总结

这个 KMP OpenHarmony 数据库库示例展示了如何使用现代的跨平台技术来处理常见的数据库操作任务。通过 Kotlin Multiplatform 技术，我们可以在一个地方编写业务逻辑，然后在多个平台上使用。

数据库管理是应用开发中的重要功能。通过使用这样的工具库，开发者可以快速、可靠地实现各种数据库操作，从而提高应用的数据管理能力。

在实际应用中，建议根据具体的需求进行定制和扩展，例如添加更复杂的查询功能、实现更全面的事务管理等高级特性。同时，定期进行性能测试和优化，确保应用在处理大规模数据时仍然保持良好的性能。

欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.csdn.net