项目概述

数据校验是现代应用开发中的重要功能。无论是在数据完整性检查、数据质量保证、错误检测还是数据一致性维护中，都需要进行数据的校验和处理。然而，不同的编程语言和平台对数据校验的实现方式各不相同，这导致开发者需要在不同平台上重复编写类似的逻辑。

本文介绍一个基于 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/DataValidator.kt

class DataValidator {
    
    data class ValidationResult(
        val data: String,
        val checksum: String,
        val isValid: Boolean,
        val validationTime: Long,
        val errorCount: Int,
        val message: String = ""
    )
    
    data class ValidationConfig(
        val enableDetailedCheck: Boolean = true,
        val enableErrorReporting: Boolean = true,
        val maxErrorsToReport: Int = 10
    )
    
    private var config = ValidationConfig()
    private val validationHistory = mutableListOf<ValidationResult>()
    
    fun setConfig(config: ValidationConfig) {
        this.config = config
    }
    
    fun calculateChecksum(data: String): String {
        var checksum = 0L
        for (char in data) {
            checksum += char.code.toLong()
        }
        return checksum.toString()
    }
    
    fun validate(data: String): ValidationResult {
        val startTime = System.currentTimeMillis()
        val checksum = calculateChecksum(data)
        val isValid = data.isNotEmpty() && checksum.isNotEmpty()
        val errorCount = if (isValid) 0 else 1
        
        val validationTime = System.currentTimeMillis() - startTime
        
        val result = ValidationResult(
            data,
            checksum,
            isValid,
            validationTime,
            errorCount
        )
        
        validationHistory.add(result)
        return result
    }
    
    fun verifyChecksum(data: String, expectedChecksum: String): Boolean {
        val calculatedChecksum = calculateChecksum(data)
        return calculatedChecksum == expectedChecksum
    }
    
    fun validateFormat(data: String, pattern: String): Boolean {
        return try {
            Regex(pattern).matches(data)
        } catch (e: Exception) {
            false
        }
    }
    
    fun validateLength(data: String, minLength: Int, maxLength: Int): Boolean {
        return data.length in minLength..maxLength
    }
    
    fun validateEmail(email: String): Boolean {
        val emailPattern = "^[A-Za-z0-9+_.-]+@(.+)$"
        return validateFormat(email, emailPattern)
    }
    
    fun validatePhone(phone: String): Boolean {
        val phonePattern = "^\\d{10,15}$"
        return validateFormat(phone, phonePattern)
    }
    
    fun batchValidate(dataList: List<String>): List<ValidationResult> {
        return dataList.map { validate(it) }
    }
    
    fun getValidationStatistics(): Map<String, Any> {
        val totalValidations = validationHistory.size
        val validCount = validationHistory.count { it.isValid }
        val invalidCount = totalValidations - validCount
        val averageTime = if (validationHistory.isNotEmpty()) {
            validationHistory.map { it.validationTime }.average()
        } else {
            0.0
        }
        
        return mapOf(
            "totalValidations" to totalValidations,
            "validCount" to validCount,
            "invalidCount" to invalidCount,
            "validRate" to if (totalValidations > 0) String.format("%.2f", (validCount.toDouble() / totalValidations) * 100) else "0.00",
            "averageTime" to String.format("%.2f", averageTime)
        )
    }
    
    fun generateValidationReport(): String {
        val stats = getValidationStatistics()
        val report = StringBuilder()
        report.append("数据校验报告\n")
        report.append("=".repeat(40)).append("\n")
        report.append("校验总数: ${stats["totalValidations"]}\n")
        report.append("有效数据: ${stats["validCount"]}\n")
        report.append("无效数据: ${stats["invalidCount"]}\n")
        report.append("有效率: ${stats["validRate"]}%\n")
        report.append("平均耗时: ${stats["averageTime"]}ms\n")
        
        return report.toString()
    }
}

Kotlin 实现的核心特点

Kotlin 实现中的校验功能充分利用了 Kotlin 标准库的字符串处理能力。校验和计算使用了字符遍历。格式验证使用了正则表达式。

长度验证使用了范围检查。批量校验使用了 map 方法。统计信息使用了集合操作。

JavaScript 实现

编译后的 JavaScript 代码

// 文件: build/js/packages/kmp_openharmony-js/kotlin/kmp_openharmony.js

class DataValidator {
  constructor() {
    this.config = {
      enableDetailedCheck: true,
      enableErrorReporting: true,
      maxErrorsToReport: 10
    };
    this.validationHistory = [];
  }

  setConfig(config) {
    this.config = { ...this.config, ...config };
  }

  calculateChecksum(data) {
    let checksum = 0;
    for (let i = 0; i < data.length; i++) {
      checksum += data.charCodeAt(i);
    }
    return checksum.toString();
  }

  validate(data) {
    const startTime = Date.now();
    const checksum = this.calculateChecksum(data);
    const isValid = data.length > 0 && checksum.length > 0;
    const errorCount = isValid ? 0 : 1;
    
    const validationTime = Date.now() - startTime;
    
    const result = {
      data: data,
      checksum: checksum,
      isValid: isValid,
      validationTime: validationTime,
      errorCount: errorCount,
      message: ''
    };
    
    this.validationHistory.push(result);
    return result;
  }

  verifyChecksum(data, expectedChecksum) {
    const calculatedChecksum = this.calculateChecksum(data);
    return calculatedChecksum === expectedChecksum;
  }

  validateFormat(data, pattern) {
    try {
      const regex = new RegExp(pattern);
      return regex.test(data);
    } catch (e) {
      return false;
    }
  }

  validateLength(data, minLength, maxLength) {
    return data.length >= minLength && data.length <= maxLength;
  }

  validateEmail(email) {
    const emailPattern = '^[A-Za-z0-9+_.-]+@(.+)$';
    return this.validateFormat(email, emailPattern);
  }

  validatePhone(phone) {
    const phonePattern = '^\\d{10,15}$';
    return this.validateFormat(phone, phonePattern);
  }

  batchValidate(dataList) {
    return dataList.map(data => this.validate(data));
  }

  getValidationStatistics() {
    const totalValidations = this.validationHistory.length;
    const validCount = this.validationHistory.filter(v => v.isValid).length;
    const invalidCount = totalValidations - validCount;
    const averageTime = totalValidations > 0
      ? this.validationHistory.reduce((sum, v) => sum + v.validationTime, 0) / totalValidations
      : 0;
    
    return {
      totalValidations: totalValidations,
      validCount: validCount,
      invalidCount: invalidCount,
      validRate: totalValidations > 0 ? ((validCount / totalValidations) * 100).toFixed(2) : '0.00',
      averageTime: averageTime.toFixed(2)
    };
  }
}

JavaScript 实现的特点

JavaScript 版本完全由 Kotlin/JS 编译器自动生成，确保了与 Kotlin 版本的行为完全一致。JavaScript 的正则表达式提供了格式验证能力。

charCodeAt 用于字符编码。RegExp 用于模式匹配。filter 用于统计。

ArkTS 调用代码

OpenHarmony 应用集成

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

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

@Entry
@Component
struct DataValidatorPage {
  @State selectedOperation: string = 'validate';
  @State inputData: string = '';
  @State result: string = '';
  @State resultTitle: string = '';

  private dataValidator = new DataValidator();

  private operations = [
    { name: '✅ 校验数据', value: 'validate' },
    { name: '🔐 校验和', value: 'checksum' },
    { name: '📧 邮箱验证', value: 'email' },
    { name: '📱 电话验证', value: 'phone' },
    { name: '📏 长度验证', value: 'length' },
    { name: '📦 批量校验', value: 'batch' },
    { name: '📊 统计', value: 'stats' },
    { name: '📄 报告', value: 'report' }
  ];

  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: '输入要校验的数据', text: this.inputData })
              .onChange((value) => this.inputData = value)
              .width('100%')
              .height(80)
              .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() {
    const data = this.inputData || '测试数据';

    try {
      switch (this.selectedOperation) {
        case 'validate':
          const valResult = this.dataValidator.validate(data);
          this.resultTitle = '✅ 校验数据';
          this.result = `数据: ${valResult.data}\n校验和: ${valResult.checksum}\n有效: ${valResult.isValid}\n耗时: ${valResult.validationTime}ms`;
          break;

        case 'checksum':
          const checksum = this.dataValidator.calculateChecksum(data);
          this.resultTitle = '🔐 校验和';
          this.result = `数据: ${data}\n校验和: ${checksum}`;
          break;

        case 'email':
          const isEmail = this.dataValidator.validateEmail(data);
          this.resultTitle = '📧 邮箱验证';
          this.result = `邮箱: ${data}\n有效: ${isEmail ? '是' : '否'}\n格式: ${isEmail ? '正确' : '错误'}`;
          break;

        case 'phone':
          const isPhone = this.dataValidator.validatePhone(data);
          this.resultTitle = '📱 电话验证';
          this.result = `电话: ${data}\n有效: ${isPhone ? '是' : '否'}\n格式: ${isPhone ? '正确' : '错误'}`;
          break;

        case 'length':
          const isValidLength = this.dataValidator.validateLength(data, 5, 20);
          this.resultTitle = '📏 长度验证';
          this.result = `数据: ${data}\n长度: ${data.length}\n有效范围: 5-20\n有效: ${isValidLength ? '是' : '否'}`;
          break;

        case 'batch':
          const batchData = [data, data, data];
          const batchResults = this.dataValidator.batchValidate(batchData);
          this.resultTitle = '📦 批量校验';
          this.result = `批量数据数: ${batchData.length}\n有效数据: ${batchResults.filter(r => r.isValid).length}\n无效数据: ${batchResults.filter(r => !r.isValid).length}`;
          break;

        case 'stats':
          const stats = this.dataValidator.getValidationStatistics();
          this.resultTitle = '📊 校验统计';
          this.result = `校验总数: ${stats.totalValidations}\n有效数据: ${stats.validCount}\n无效数据: ${stats.invalidCount}\n有效率: ${stats.validRate}%\n平均耗时: ${stats.averageTime}ms`;
          break;

        case 'report':
          const report = this.dataValidator.generateValidationReport();
          this.resultTitle = '📄 校验报告';
          this.result = report;
          break;
      }
    } catch (e) {
      this.resultTitle = '❌ 操作出错';
      this.result = `错误: ${e}`;
    }
  }
}

ArkTS 集成的关键要点

在 OpenHarmony 应用中集成校验工具库需要考虑数据质量和用户体验。我们设计了一个完整的校验 UI，包括操作选择、数据输入和结果展示。

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

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

工作流程详解

数据校验的完整流程

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

跨平台一致性

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

实际应用场景

数据完整性检查

在检查数据完整性时，需要进行数据校验。这个工具库提供了完整的完整性检查功能。

数据质量保证

在保证数据质量时，需要进行数据校验。这个工具库提供了质量保证校验能力。

错误检测

在检测数据错误时，需要进行数据校验。这个工具库提供了错误检测校验功能。

数据一致性维护

在维护数据一致性时，需要进行数据校验。这个工具库提供了一致性维护校验能力。

性能优化

校验缓存

在频繁校验相同数据时，应该缓存校验结果以提高性能。

校验优化

在处理大量数据时，应该使用高效的校验算法以提高性能。

安全性考虑

数据验证

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

校验验证

在校验完成后，应该进行验证以确保校验的正确性。

总结

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

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

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

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