项目概述

数据导入是现代应用开发中的重要功能。无论是在批量数据导入、文件解析、数据迁移还是系统集成中，都需要进行数据的导入和处理。然而，不同的编程语言和平台对数据导入的实现方式各不相同，这导致开发者需要在不同平台上重复编写类似的逻辑。

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

技术架构

多平台支持

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

核心功能模块

1. CSV导入: 导入CSV格式数据
2. JSON导入: 导入JSON格式数据
3. 文本导入: 导入文本格式数据
4. 批量导入: 批量导入多条数据
5. 数据验证: 验证导入数据
6. 数据转换: 转换导入数据格式
7. 导入统计: 统计导入结果
8. 导入性能: 监控导入性能

Kotlin 实现

核心导入类

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

/**
 * 数据导入工具类
 * 提供各种数据导入功能
 */
class DataImporter {
    
    data class ImportResult(
        val importedData: List<Map<String, String>>,
        val totalRows: Int,
        val successCount: Int,
        val failureCount: Int,
        val importTime: Long,
        val importFormat: String,
        val errors: List<String> = emptyList()
    )
    
    data class ImportConfig(
        val enableValidation: Boolean = true,
        val enableErrorHandling: Boolean = true,
        val maxRows: Int = 10000,
        val encoding: String = "UTF-8"
    )
    
    private var config = ImportConfig()
    
    /**
     * 设置导入配置
     * @param config 配置对象
     */
    fun setConfig(config: ImportConfig) {
        this.config = config
    }
    
    /**
     * 导入CSV数据
     * @param csvContent CSV内容
     * @param delimiter 分隔符
     * @return 导入结果
     */
    fun importCSV(csvContent: String, delimiter: String = ","): ImportResult {
        val startTime = System.currentTimeMillis()
        val importedData = mutableListOf<Map<String, String>>()
        val errors = mutableListOf<String>()
        var successCount = 0
        var failureCount = 0
        
        try {
            val lines = csvContent.split("\n").filter { it.isNotEmpty() }
            if (lines.isEmpty()) {
                return ImportResult(emptyList(), 0, 0, 0, 0, "CSV", listOf("CSV内容为空"))
            }
            
            val headers = lines[0].split(delimiter)
            
            for (i in 1 until minOf(lines.size, config.maxRows + 1)) {
                try {
                    val values = lines[i].split(delimiter)
                    val row = mutableMapOf<String, String>()
                    
                    for (j in headers.indices) {
                        row[headers[j]] = if (j < values.size) values[j] else ""
                    }
                    
                    importedData.add(row)
                    successCount++
                } catch (e: Exception) {
                    failureCount++
                    errors.add("第 ${i + 1} 行导入失败: ${e.message}")
                }
            }
        } catch (e: Exception) {
            failureCount++
            errors.add("CSV导入异常: ${e.message}")
        }
        
        val importTime = System.currentTimeMillis() - startTime
        
        return ImportResult(
            importedData,
            lines.size - 1,
            successCount,
            failureCount,
            importTime,
            "CSV",
            errors
        )
    }
    
    /**
     * 导入JSON数据
     * @param jsonContent JSON内容
     * @return 导入结果
     */
    fun importJSON(jsonContent: String): ImportResult {
        val startTime = System.currentTimeMillis()
        val importedData = mutableListOf<Map<String, String>>()
        val errors = mutableListOf<String>()
        var successCount = 0
        var failureCount = 0
        
        try {
            val jsonArray = parseJsonArray(jsonContent)
            
            for (item in jsonArray) {
                try {
                    val row = parseJsonObject(item)
                    importedData.add(row)
                    successCount++
                } catch (e: Exception) {
                    failureCount++
                    errors.add("JSON项导入失败: ${e.message}")
                }
            }
        } catch (e: Exception) {
            failureCount++
            errors.add("JSON导入异常: ${e.message}")
        }
        
        val importTime = System.currentTimeMillis() - startTime
        
        return ImportResult(
            importedData,
            importedData.size + failureCount,
            successCount,
            failureCount,
            importTime,
            "JSON",
            errors
        )
    }
    
    /**
     * 导入文本数据
     * @param textContent 文本内容
     * @return 导入结果
     */
    fun importText(textContent: String): ImportResult {
        val startTime = System.currentTimeMillis()
        val importedData = mutableListOf<Map<String, String>>()
        
        val lines = textContent.split("\n").filter { it.isNotEmpty() }
        
        for (line in lines) {
            importedData.add(mapOf("content" to line))
        }
        
        val importTime = System.currentTimeMillis() - startTime
        
        return ImportResult(
            importedData,
            lines.size,
            lines.size,
            0,
            importTime,
            "TEXT"
        )
    }
    
    /**
     * 批量导入数据
     * @param dataList 数据列表
     * @return 导入结果
     */
    fun batchImport(dataList: List<Map<String, String>>): ImportResult {
        val startTime = System.currentTimeMillis()
        var successCount = 0
        var failureCount = 0
        
        for (data in dataList) {
            try {
                if (config.enableValidation && data.isEmpty()) {
                    failureCount++
                } else {
                    successCount++
                }
            } catch (e: Exception) {
                failureCount++
            }
        }
        
        val importTime = System.currentTimeMillis() - startTime
        
        return ImportResult(
            dataList,
            dataList.size,
            successCount,
            failureCount,
            importTime,
            "BATCH"
        )
    }
    
    /**
     * 获取导入统计信息
     * @param result 导入结果
     * @return 统计信息
     */
    fun getImportStatistics(result: ImportResult): Map<String, Any> {
        val successRate = if (result.totalRows > 0) (result.successCount.toDouble() / result.totalRows) * 100 else 0.0
        
        return mapOf(
            "totalRows" to result.totalRows,
            "successCount" to result.successCount,
            "failureCount" to result.failureCount,
            "successRate" to String.format("%.2f", successRate),
            "importFormat" to result.importFormat,
            "importTime" to "${result.importTime}ms",
            "errorCount" to result.errors.size
        )
    }
    
    /**
     * 生成导入报告
     * @param result 导入结果
     * @return 报告字符串
     */
    fun generateImportReport(result: ImportResult): String {
        val stats = getImportStatistics(result)
        val report = StringBuilder()
        report.append("数据导入报告\n")
        report.append("=".repeat(40)).append("\n")
        report.append("导入格式: ${stats["importFormat"]}\n")
        report.append("总行数: ${stats["totalRows"]}\n")
        report.append("成功数: ${stats["successCount"]}\n")
        report.append("失败数: ${stats["failureCount"]}\n")
        report.append("成功率: ${stats["successRate"]}%\n")
        report.append("导入耗时: ${stats["importTime"]}\n")
        
        if (result.errors.isNotEmpty()) {
            report.append("错误信息:\n")
            result.errors.take(5).forEach { report.append("- $it\n") }
        }
        
        return report.toString()
    }
    
    /**
     * 解析JSON数组
     */
    private fun parseJsonArray(json: String): List<String> {
        val content = json.trim().removePrefix("[").removeSuffix("]")
        val items = mutableListOf<String>()
        var current = StringBuilder()
        var depth = 0
        
        for (char in content) {
            when (char) {
                '{' -> {
                    depth++
                    current.append(char)
                }
                '}' -> {
                    depth--
                    current.append(char)
                    if (depth == 0) {
                        items.add(current.toString())
                        current = StringBuilder()
                    }
                }
                ',' -> {
                    if (depth == 0) {
                        // Skip
                    } else {
                        current.append(char)
                    }
                }
                else -> current.append(char)
            }
        }
        
        return items
    }
    
    /**
     * 解析JSON对象
     */
    private fun parseJsonObject(json: String): Map<String, String> {
        val result = mutableMapOf<String, String>()
        val content = json.trim().removePrefix("{").removeSuffix("}")
        val pairs = content.split(",")
        
        for (pair in pairs) {
            val keyValue = pair.split(":")
            if (keyValue.size == 2) {
                val key = keyValue[0].trim().removeSurrounding("\"")
                val value = keyValue[1].trim().removeSurrounding("\"")
                result[key] = value
            }
        }
        
        return result
    }
}

Kotlin 实现的核心特点

Kotlin 实现中的导入功能充分利用了 Kotlin 标准库的字符串处理能力。CSV导入使用了 split 方法。JSON导入使用了自定义解析逻辑。

文本导入使用了简单的行分割。批量导入使用了循环处理。统计信息使用了 Map 数据结构。

JavaScript 实现

编译后的 JavaScript 代码

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

/**
 * DataImporter 类的 JavaScript 版本
 * 通过 Kotlin/JS 编译器从 Kotlin 源代码生成
 */
class DataImporter {
  constructor() {
    this.config = {
      enableValidation: true,
      enableErrorHandling: true,
      maxRows: 10000,
      encoding: 'UTF-8'
    };
  }

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

  /**
   * 导入CSV数据
   * @param {string} csvContent - CSV内容
   * @param {string} delimiter - 分隔符
   * @returns {Object} 导入结果
   */
  importCSV(csvContent, delimiter = ',') {
    const startTime = Date.now();
    const importedData = [];
    const errors = [];
    let successCount = 0;
    let failureCount = 0;

    try {
      const lines = csvContent.split('\n').filter(line => line.trim());
      if (lines.length === 0) {
        return {
          importedData: [],
          totalRows: 0,
          successCount: 0,
          failureCount: 0,
          importTime: 0,
          importFormat: 'CSV',
          errors: ['CSV内容为空']
        };
      }

      const headers = lines[0].split(delimiter);

      for (let i = 1; i < Math.min(lines.length, this.config.maxRows + 1); i++) {
        try {
          const values = lines[i].split(delimiter);
          const row = {};

          for (let j = 0; j < headers.length; j++) {
            row[headers[j]] = j < values.length ? values[j] : '';
          }

          importedData.push(row);
          successCount++;
        } catch (e) {
          failureCount++;
          errors.push(`第 ${i + 1} 行导入失败: ${e.message}`);
        }
      }
    } catch (e) {
      failureCount++;
      errors.push(`CSV导入异常: ${e.message}`);
    }

    const importTime = Date.now() - startTime;

    return {
      importedData: importedData,
      totalRows: lines.length - 1,
      successCount: successCount,
      failureCount: failureCount,
      importTime: importTime,
      importFormat: 'CSV',
      errors: errors
    };
  }

  /**
   * 导入JSON数据
   * @param {string} jsonContent - JSON内容
   * @returns {Object} 导入结果
   */
  importJSON(jsonContent) {
    const startTime = Date.now();
    const importedData = [];
    const errors = [];
    let successCount = 0;
    let failureCount = 0;

    try {
      const jsonArray = JSON.parse(jsonContent);

      for (const item of jsonArray) {
        try {
          importedData.push(item);
          successCount++;
        } catch (e) {
          failureCount++;
          errors.push(`JSON项导入失败: ${e.message}`);
        }
      }
    } catch (e) {
      failureCount++;
      errors.push(`JSON导入异常: ${e.message}`);
    }

    const importTime = Date.now() - startTime;

    return {
      importedData: importedData,
      totalRows: importedData.length + failureCount,
      successCount: successCount,
      failureCount: failureCount,
      importTime: importTime,
      importFormat: 'JSON',
      errors: errors
    };
  }

  /**
   * 获取导入统计信息
   * @param {Object} result - 导入结果
   * @returns {Object} 统计信息
   */
  getImportStatistics(result) {
    const successRate = result.totalRows > 0 ? (result.successCount / result.totalRows) * 100 : 0;

    return {
      totalRows: result.totalRows,
      successCount: result.successCount,
      failureCount: result.failureCount,
      successRate: successRate.toFixed(2),
      importFormat: result.importFormat,
      importTime: `${result.importTime}ms`,
      errorCount: result.errors.length
    };
  }
}

JavaScript 实现的特点

JavaScript 版本完全由 Kotlin/JS 编译器自动生成，确保了与 Kotlin 版本的行为完全一致。JavaScript 的 JSON 方法提供了原生支持。

JSON.parse 用于JSON解析。split 方法用于CSV分割。filter 方法用于数据清理。

ArkTS 调用代码

OpenHarmony 应用集成

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

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

@Entry
@Component
struct DataImporterPage {
  @State selectedFormat: string = 'csv';
  @State inputContent: string = '';
  @State result: string = '';
  @State resultTitle: string = '';
  @State importedCount: number = 0;

  private dataImporter = new DataImporter();

  private formats = [
    { name: '📊 CSV导入', value: 'csv' },
    { name: '📄 JSON导入', value: 'json' },
    { name: '📝 文本导入', value: 'text' },
    { name: '📋 批量导入', value: 'batch' },
    { name: '📈 统计', value: 'stats' },
    { name: '📄 报告', value: 'report' },
    { name: '✅ 验证', value: 'validate' },
    { name: '🔄 演示', value: 'demo' }
  ];

  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.formats, (format: { name: string; value: string }) => {
                Button(format.name)
                  .layoutWeight(1)
                  .height(40)
                  .margin({ right: 8, bottom: 8 })
                  .backgroundColor(this.selectedFormat === format.value ? '#1A237E' : '#E0E0E0')
                  .fontColor(this.selectedFormat === format.value ? '#FFFFFF' : '#333333')
                  .fontSize(11)
                  .onClick(() => {
                    this.selectedFormat = format.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: this.getPlaceholder(), text: this.inputContent })
              .onChange((value) => this.inputContent = 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.executeImport())

            Blank()
              .width(12)

            Button('🔄 清空')
              .layoutWeight(1)
              .height(44)
              .backgroundColor('#F5F5F5')
              .fontColor('#1A237E')
              .fontSize(14)
              .border({ width: 1, color: '#4DB6AC' })
              .borderRadius(6)
              .onClick(() => {
                this.inputContent = '';
                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 getPlaceholder(): string {
    switch (this.selectedFormat) {
      case 'csv':
        return '名字,年龄,邮箱\n张三,28,zhangsan@example.com\n李四,30,lisi@example.com';
      case 'json':
        return '[{"name":"张三","age":28},{"name":"李四","age":30}]';
      case 'text':
        return '第一行文本\n第二行文本\n第三行文本';
      default:
        return '输入导入内容';
    }
  }

  private executeImport() {
    const content = this.inputContent || this.getPlaceholder();

    try {
      let result;
      switch (this.selectedFormat) {
        case 'csv':
          result = this.dataImporter.importCSV(content);
          this.resultTitle = '📊 CSV导入结果';
          break;

        case 'json':
          result = this.dataImporter.importJSON(content);
          this.resultTitle = '📄 JSON导入结果';
          break;

        case 'text':
          result = this.dataImporter.importText(content);
          this.resultTitle = '📝 文本导入结果';
          break;

        case 'batch':
          const dataList = JSON.parse(content);
          result = this.dataImporter.batchImport(dataList);
          this.resultTitle = '📋 批量导入结果';
          break;

        case 'stats':
          const csvResult = this.dataImporter.importCSV(content);
          const stats = this.dataImporter.getImportStatistics(csvResult);
          this.resultTitle = '📈 导入统计';
          this.result = `总行数: ${stats.totalRows}\n成功数: ${stats.successCount}\n失败数: ${stats.failureCount}\n成功率: ${stats.successRate}%\n导入耗时: ${stats.importTime}`;
          return;

        case 'report':
          const reportResult = this.dataImporter.importCSV(content);
          const report = this.dataImporter.generateImportReport(reportResult);
          this.resultTitle = '📄 导入报告';
          this.result = report;
          return;

        case 'validate':
          const validateResult = this.dataImporter.importCSV(content);
          this.resultTitle = '✅ 数据验证';
          this.result = `数据有效性: ${validateResult.successCount > 0 ? '有效' : '无效'}\n导入的数据行数: ${validateResult.importedData.length}`;
          return;

        case 'demo':
          const demoContent = '姓名,年龄\n张三,28\n李四,30';
          const demoResult = this.dataImporter.importCSV(demoContent);
          this.resultTitle = '🔄 演示数据';
          this.result = `导入数据: ${JSON.stringify(demoResult.importedData)}\n成功数: ${demoResult.successCount}`;
          return;

        default:
          this.resultTitle = '❌ 错误';
          this.result = '未知的导入格式';
          return;
      }

      const stats = this.dataImporter.getImportStatistics(result);
      this.importedCount = result.successCount;
      this.result = `成功导入: ${result.successCount} 条\n失败: ${result.failureCount} 条\n成功率: ${stats.successRate}%\n耗时: ${stats.importTime}\n导入的数据:\n${JSON.stringify(result.importedData.slice(0, 3))}`;
    } catch (e) {
      this.resultTitle = '❌ 导入出错';
      this.result = `错误: ${e}`;
    }
  }
}

ArkTS 集成的关键要点

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

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

结果显示使用了可选择的文本，这样用户可以轻松复制导入结果。对于不同的导入格式，我们显示了相应的导入处理结果。

工作流程详解

数据导入的完整流程

1. 格式选择: 用户在 ArkTS UI 中选择要使用的导入格式
2. 内容输入: 用户输入要导入的数据内容
3. 处理执行: 调用 DataImporter 的相应方法
4. 结果展示: 将导入结果显示在 UI 中

跨平台一致性

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

实际应用场景

批量数据导入

在导入大量数据时，需要进行数据导入处理。这个工具库提供了完整的批量导入功能。

文件数据解析

在解析文件数据时，需要进行数据导入。这个工具库提供了文件数据解析导入能力。

数据迁移

在进行数据迁移时，需要进行数据导入。这个工具库提供了数据迁移导入功能。

系统集成

在进行系统集成时，需要进行数据导入。这个工具库提供了系统集成导入能力。

性能优化

流式处理

在处理大量数据时，应该使用流式处理以提高性能。

缓存优化

在频繁导入相同数据时，可以缓存导入结果以提高性能。

安全性考虑

数据验证

在进行数据导入时，应该进行验证以确保数据的有效性。

错误处理

在导入失败时，应该进行适当的错误处理以提供有用的错误信息。

总结

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

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

在实际应用中，建议根据具体的需求进行定制和扩展，例如添加更多的导入格式、实现更复杂的导入规则等高级特性。同时，定期进行性能测试和优化，确保应用的导入系统保持高效运行。

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