项目概述

JSON 与类数据转换是现代应用开发中的核心需求。无论是在 API 通信、数据存储、配置管理还是数据交换中，都需要进行 JSON 和对象之间的相互转换。然而，不同的编程语言和平台对序列化的实现方式各不相同，这导致开发者需要在不同平台上重复编写类似的逻辑。

本文介绍一个基于 Kotlin Multiplatform (KMP) 和 OpenHarmony 平台的 JSON 与类数据转换高级工具库。这个工具库提供了一套完整的序列化能力，包括 JSON 解析、对象序列化、类型转换、数据验证等功能。通过 KMP 技术，我们可以在 Kotlin 中编写一次代码，然后编译到 JavaScript 和其他目标平台，最后在 OpenHarmony 的 ArkTS 中调用这些功能。

技术架构

多平台支持

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

核心功能模块

1. JSON 解析: 解析 JSON 字符串
2. 对象序列化: 将对象转换为 JSON
3. 类型转换: 在不同类型之间转换
4. 数据验证: 验证数据的有效性
5. 嵌套对象处理: 处理复杂的嵌套结构
6. 数组处理: 处理 JSON 数组
7. 错误处理: 处理序列化错误
8. 格式化输出: 格式化 JSON 输出

Kotlin 实现

核心数据转换类

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

/**
 * JSON 与类数据转换工具类
 * 提供 JSON 解析、序列化、转换等功能
 */
class JsonConverter {
    
    data class User(
        val id: Int,
        val name: String,
        val email: String,
        val age: Int,
        val active: Boolean
    )
    
    data class ApiResponse(
        val code: Int,
        val message: String,
        val data: Map<String, Any>
    )
    
    /**
     * 将 JSON 字符串解析为 Map
     * @param json JSON 字符串
     * @return 解析结果 Map
     */
    fun parseJson(json: String): Map<String, Any>? {
        return try {
            val trimmed = json.trim()
            if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
                return null
            }
            
            val content = trimmed.substring(1, trimmed.length - 1)
            val pairs = mutableMapOf<String, Any>()
            
            var current = ""
            var inString = false
            var depth = 0
            
            for (char in content) {
                when {
                    char == '"' && (current.isEmpty() || current.last() != '\\') -> inString = !inString
                    char == '{' && !inString -> depth++
                    char == '}' && !inString -> depth--
                    char == ',' && !inString && depth == 0 -> {
                        parsePair(current.trim(), pairs)
                        current = ""
                        continue
                    }
                }
                current += char
            }
            
            if (current.isNotEmpty()) {
                parsePair(current.trim(), pairs)
            }
            
            pairs
        } catch (e: Exception) {
            null
        }
    }
    
    /**
     * 解析键值对
     */
    private fun parsePair(pair: String, map: MutableMap<String, Any>) {
        val colonIndex = pair.indexOf(':')
        if (colonIndex > 0) {
            val key = pair.substring(0, colonIndex).trim().removeSurrounding("\"")
            val value = pair.substring(colonIndex + 1).trim()
            
            map[key] = when {
                value == "null" -> "null"
                value == "true" -> true
                value == "false" -> false
                value.startsWith("\"") && value.endsWith("\"") -> value.removeSurrounding("\"")
                value.toDoubleOrNull() != null -> value.toDouble()
                else -> value
            }
        }
    }
    
    /**
     * 将对象转换为 JSON 字符串
     * @param obj 对象
     * @return JSON 字符串
     */
    fun toJson(obj: Any?): String {
        return when (obj) {
            null -> "null"
            is String -> "\"${obj.replace("\"", "\\\"")}\""
            is Number -> obj.toString()
            is Boolean -> obj.toString()
            is Map<*, *> -> {
                val pairs = obj.entries.joinToString(",") { (k, v) ->
                    "\"$k\":${toJson(v)}"
                }
                "{$pairs}"
            }
            is List<*> -> {
                val items = obj.joinToString(",") { toJson(it) }
                "[$items]"
            }
            is User -> {
                "{\"id\":${obj.id},\"name\":\"${obj.name}\",\"email\":\"${obj.email}\",\"age\":${obj.age},\"active\":${obj.active}}"
            }
            else -> "\"${obj.toString()}\""
        }
    }
    
    /**
     * 将 JSON 字符串转换为 User 对象
     * @param json JSON 字符串
     * @return User 对象
     */
    fun jsonToUser(json: String): User? {
        return try {
            val map = parseJson(json) ?: return null
            User(
                id = (map["id"] as? Number)?.toInt() ?: 0,
                name = map["name"]?.toString() ?: "",
                email = map["email"]?.toString() ?: "",
                age = (map["age"] as? Number)?.toInt() ?: 0,
                active = map["active"] as? Boolean ?: false
            )
        } catch (e: Exception) {
            null
        }
    }
    
    /**
     * 将 User 对象转换为 JSON 字符串
     * @param user User 对象
     * @return JSON 字符串
     */
    fun userToJson(user: User): String {
        return toJson(user)
    }
    
    /**
     * 验证 JSON 格式
     * @param json JSON 字符串
     * @return 是否有效
     */
    fun isValidJson(json: String): Boolean {
        return try {
            val trimmed = json.trim()
            (trimmed.startsWith("{") && trimmed.endsWith("}")) ||
            (trimmed.startsWith("[") && trimmed.endsWith("]"))
        } catch (e: Exception) {
            false
        }
    }
    
    /**
     * 格式化 JSON 字符串
     * @param json JSON 字符串
     * @param indent 缩进空格数
     * @return 格式化后的 JSON
     */
    fun formatJson(json: String, indent: Int = 2): String {
        if (!isValidJson(json)) return json
        
        val result = StringBuilder()
        var indentLevel = 0
        var inString = false
        
        for (i in json.indices) {
            val char = json[i]
            
            when {
                char == '"' && (i == 0 || json[i - 1] != '\\') -> inString = !inString
                !inString && (char == '{' || char == '[') -> {
                    result.append(char)
                    indentLevel++
                    result.append("\n").append(" ".repeat(indentLevel * indent))
                }
                !inString && (char == '}' || char == ']') -> {
                    indentLevel--
                    result.append("\n").append(" ".repeat(indentLevel * indent))
                    result.append(char)
                }
                !inString && char == ',' -> {
                    result.append(char)
                    result.append("\n").append(" ".repeat(indentLevel * indent))
                }
                !inString && char == ':' -> {
                    result.append(char).append(" ")
                }
                char != ' ' || inString -> result.append(char)
            }
        }
        
        return result.toString()
    }
    
    /**
     * 获取 JSON 统计信息
     * @param json JSON 字符串
     * @return 统计信息映射
     */
    fun getJsonStatistics(json: String): Map<String, Any> {
        return mapOf(
            "isValid" to isValidJson(json),
            "length" to json.length,
            "keyCount" to (json.count { it == ':' }),
            "arrayCount" to (json.count { it == '[' }),
            "objectCount" to (json.count { it == '{' }),
            "stringCount" to (json.count { it == '"' } / 2)
        )
    }
    
    /**
     * 合并两个 JSON 对象
     * @param json1 第一个 JSON
     * @param json2 第二个 JSON
     * @return 合并后的 JSON
     */
    fun mergeJson(json1: String, json2: String): String? {
        return try {
            val map1 = parseJson(json1) ?: return null
            val map2 = parseJson(json2) ?: return null
            
            val merged = map1.toMutableMap()
            merged.putAll(map2)
            
            toJson(merged)
        } catch (e: Exception) {
            null
        }
    }
}

Kotlin 实现的核心特点

Kotlin 实现中的 JSON 转换功能充分利用了 Kotlin 标准库的字符串处理和集合操作能力。JSON 解析使用了手动字符遍历来处理复杂的嵌套结构。对象序列化使用了 when 表达式来处理不同类型。

类型转换使用了安全的类型转换操作符。格式化功能使用了递归缩进算法。验证功能使用了基本的格式检查。

JavaScript 实现

编译后的 JavaScript 代码

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

/**
 * JsonConverter 类的 JavaScript 版本
 * 通过 Kotlin/JS 编译器从 Kotlin 源代码生成
 */
class JsonConverter {
  /**
   * 将 JSON 字符串解析为对象
   * @param {string} json - JSON 字符串
   * @returns {Object} 解析结果
   */
  parseJson(json) {
    try {
      return JSON.parse(json);
    } catch (e) {
      return null;
    }
  }

  /**
   * 将对象转换为 JSON 字符串
   * @param {*} obj - 对象
   * @returns {string} JSON 字符串
   */
  toJson(obj) {
    try {
      return JSON.stringify(obj);
    } catch (e) {
      return null;
    }
  }

  /**
   * 将 JSON 字符串转换为 User 对象
   * @param {string} json - JSON 字符串
   * @returns {Object} User 对象
   */
  jsonToUser(json) {
    try {
      const obj = this.parseJson(json);
      if (!obj) return null;
      
      return {
        id: obj.id || 0,
        name: obj.name || '',
        email: obj.email || '',
        age: obj.age || 0,
        active: obj.active || false
      };
    } catch (e) {
      return null;
    }
  }

  /**
   * 将 User 对象转换为 JSON 字符串
   * @param {Object} user - User 对象
   * @returns {string} JSON 字符串
   */
  userToJson(user) {
    return this.toJson(user);
  }

  /**
   * 验证 JSON 格式
   * @param {string} json - JSON 字符串
   * @returns {boolean} 是否有效
   */
  isValidJson(json) {
    try {
      JSON.parse(json);
      return true;
    } catch (e) {
      return false;
    }
  }

  /**
   * 格式化 JSON 字符串
   * @param {string} json - JSON 字符串
   * @param {number} indent - 缩进空格数
   * @returns {string} 格式化后的 JSON
   */
  formatJson(json, indent = 2) {
    try {
      const obj = JSON.parse(json);
      return JSON.stringify(obj, null, indent);
    } catch (e) {
      return json;
    }
  }

  /**
   * 获取 JSON 统计信息
   * @param {string} json - JSON 字符串
   * @returns {Object} 统计信息
   */
  getJsonStatistics(json) {
    return {
      isValid: this.isValidJson(json),
      length: json.length,
      keyCount: (json.match(/:/g) || []).length,
      arrayCount: (json.match(/\[/g) || []).length,
      objectCount: (json.match(/\{/g) || []).length,
      stringCount: Math.floor((json.match(/"/g) || []).length / 2)
    };
  }

  /**
   * 合并两个 JSON 对象
   * @param {string} json1 - 第一个 JSON
   * @param {string} json2 - 第二个 JSON
   * @returns {string} 合并后的 JSON
   */
  mergeJson(json1, json2) {
    try {
      const obj1 = this.parseJson(json1);
      const obj2 = this.parseJson(json2);
      
      if (!obj1 || !obj2) return null;
      
      const merged = { ...obj1, ...obj2 };
      return this.toJson(merged);
    } catch (e) {
      return null;
    }
  }
}

JavaScript 实现的特点

JavaScript 版本完全由 Kotlin/JS 编译器自动生成，确保了与 Kotlin 版本的行为完全一致。JavaScript 的原生 JSON 对象提供了强大的序列化能力。

JSON.parse 用于解析 JSON。JSON.stringify 用于序列化对象。正则表达式用于统计信息计算。

ArkTS 调用代码

OpenHarmony 应用集成

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

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

@Entry
@Component
struct JsonConverterPage {
  @State selectedOperation: string = 'parse';
  @State inputJson: string = '';
  @State result: string = '';
  @State resultTitle: string = '';

  private converter = new JsonConverter();

  private operations = [
    { name: '解析 JSON', value: 'parse' },
    { name: '序列化对象', value: 'serialize' },
    { name: '格式化 JSON', value: 'format' },
    { name: '验证格式', value: 'validate' },
    { name: '统计信息', value: 'statistics' },
    { name: '转换为用户', value: 'toUser' },
    { name: '用户转 JSON', value: 'userJson' },
    { name: '合并 JSON', value: 'merge' },
    { name: '美化输出', value: 'pretty' },
    { name: '数据转换', value: 'convert' }
  ];

  build() {
    Column() {
      // 标题
      Text('🔄 JSON与类数据转换高级工具库')
        .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('输入 JSON')
              .fontSize(14)
              .fontWeight(FontWeight.Bold)
              .fontColor('#333333')
              .margin({ bottom: 8 })

            TextInput({ placeholder: '输入 JSON 数据', text: this.inputJson })
              .onChange((value) => this.inputJson = value)
              .width('100%')
              .height(120)
              .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.inputJson = '';
                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 sampleJson = '{"id":1,"name":"John","email":"john@example.com","age":30,"active":true}';

    try {
      switch (this.selectedOperation) {
        case 'parse':
          const parsed = this.converter.parseJson(this.inputJson || sampleJson);
          this.resultTitle = '📊 解析结果';
          this.result = JSON.stringify(parsed, null, 2);
          break;

        case 'serialize':
          const obj = { name: 'Alice', age: 25, city: 'Beijing' };
          const serialized = this.converter.toJson(obj);
          this.resultTitle = '🔗 序列化结果';
          this.result = serialized;
          break;

        case 'format':
          const formatted = this.converter.formatJson(this.inputJson || sampleJson, 2);
          this.resultTitle = '✨ 格式化结果';
          this.result = formatted;
          break;

        case 'validate':
          const isValid = this.converter.isValidJson(this.inputJson || sampleJson);
          this.resultTitle = isValid ? '✅ 格式有效' : '❌ 格式无效';
          this.result = `JSON 有效性: ${isValid ? '有效' : '无效'}`;
          break;

        case 'statistics':
          const stats = this.converter.getJsonStatistics(this.inputJson || sampleJson);
          this.resultTitle = '📈 统计信息';
          this.result = `长度: ${stats.length}\n键数: ${stats.keyCount}\n数组数: ${stats.arrayCount}\n对象数: ${stats.objectCount}\n字符串数: ${stats.stringCount}`;
          break;

        case 'toUser':
          const user = this.converter.jsonToUser(this.inputJson || sampleJson);
          this.resultTitle = '👤 用户对象';
          this.result = user ? `ID: ${user.id}\n名称: ${user.name}\n邮箱: ${user.email}\n年龄: ${user.age}\n活跃: ${user.active}` : '转换失败';
          break;

        case 'userJson':
          const userObj = { id: 1, name: 'Bob', email: 'bob@example.com', age: 28, active: true };
          const userJson = this.converter.userToJson(userObj);
          this.resultTitle = '📝 用户 JSON';
          this.result = userJson;
          break;

        case 'merge':
          const json1 = '{"a":1,"b":2}';
          const json2 = '{"c":3,"d":4}';
          const merged = this.converter.mergeJson(json1, json2);
          this.resultTitle = '🔗 合并结果';
          this.result = merged || '合并失败';
          break;

        case 'pretty':
          const pretty = this.converter.formatJson(this.inputJson || sampleJson, 4);
          this.resultTitle = '🎨 美化输出';
          this.result = pretty;
          break;

        case 'convert':
          const converted = this.converter.parseJson(this.inputJson || sampleJson);
          this.resultTitle = '🔄 数据转换';
          this.result = converted ? `转换成功\n键数: ${Object.keys(converted).length}\n值数: ${Object.values(converted).length}` : '转换失败';
          break;
      }
    } catch (e) {
      this.resultTitle = '❌ 处理出错';
      this.result = `错误: ${e}`;
    }
  }
}

ArkTS 集成的关键要点

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

操作选择界面使用了 Flex 布局和 FlexWrap 来实现响应式的按钮排列。输入区域使用了较大的高度以容纳多行 JSON 内容。

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

工作流程详解

JSON 转换的完整流程

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

跨平台一致性

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

实际应用场景

API 通信

在 API 通信中，需要将对象序列化为 JSON 并解析响应。这个工具库提供了完整的序列化功能。

数据存储

在本地存储中，需要将对象转换为 JSON 格式。这个工具库提供了高效的序列化能力。

配置管理

在配置管理中，需要解析和生成 JSON 配置文件。这个工具库提供了配置处理功能。

数据交换

在系统间数据交换中，需要统一的 JSON 格式。这个工具库提供了标准化的转换方法。

性能优化

缓存转换结果

在频繁进行相同的转换时，可以缓存转换结果以避免重复计算。

流式处理

在处理大型 JSON 文件时，应该考虑使用流式处理的方式以提高效率。

安全性考虑

输入验证

在处理用户输入的 JSON 时，应该进行验证以确保数据的有效性。

类型检查

在进行类型转换时，应该进行严格的类型检查以防止错误。

总结

这个 KMP OpenHarmony JSON 与类数据转换高级工具库展示了如何使用现代的跨平台技术来处理常见的数据序列化任务。通过 Kotlin Multiplatform 技术，我们可以在一个地方编写业务逻辑，然后在多个平台上使用。

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

在实际应用中，建议根据具体的需求进行定制和扩展，例如添加更复杂的类型映射、实现更全面的验证功能等高级特性。同时，定期进行性能测试和优化，确保应用在处理大量 JSON 数据时仍然保持良好的性能。欢迎加入开源鸿蒙跨平台社区：https://openharmonycrossplatform.csdn.net