问题思维导图

                  数据序列化与传输问题
                         |
            ┌────────────┼────────────┐
            |            |            |
        数据类型    序列化格式    传输机制
        转换问题    选择问题      问题
            |            |            |
    ┌───────┴────┐  ┌────┴────┐  ┌────┴────┐
    |            |  |         |  |         |
  基本类型  复杂对象  JSON   Protocol  同步调用  异步回调
  转换失败  序列化难  解析慢  Buffer   阻塞问题  丢失问题

---

问题一：Java与C++的数据类型不匹配

问题描述

Java和C++的数据类型存在差异，直接转换会导致数据丢失或错误：

• Java的long是64位，C++的long在32位系统上是32位
• Java没有无符号整数，C++有
• Java的String是Unicode，C++的char*通常是UTF-8或ASCII
• 复杂对象无法直接转换

问题流程图

Qt应用 (C++)              JNI层              鸿蒙应用 (Java)
    |                      |                      |
    ├─→ long (64bit) ─────→ 转换 ─────→ long (64bit) ✓
    |
    ├─→ unsigned int ─────→ 转换 ─────→ ❌ Java无符号类型！
    |
    ├─→ char* (UTF-8) ────→ 转换 ─────→ String (Unicode) ⚠️ 编码问题
    |
    └─→ QMap<QString, int> → 序列化 ─→ ❌ 无法直接转换！

解决方案：统一的数据转换框架

// data_converter.h
#ifndef DATA_CONVERTER_H
#define DATA_CONVERTER_H

#include <jni.h>
#include <QString>
#include <QVariant>
#include <QMap>
#include <QList>

class DataConverter {
public:
    // ========== 基本类型转换 ==========
    
    // C++ -> Java
    static jint toJavaInt(int value);
    static jlong toJavaLong(long long value);
    static jfloat toJavaFloat(float value);
    static jdouble toJavaDouble(double value);
    static jboolean toJavaBoolean(bool value);
    static jstring toJavaString(const QString &str, JNIEnv *env);
    static jbyteArray toJavaByteArray(const QByteArray &data, JNIEnv *env);
    
    // Java -> C++
    static int fromJavaInt(jint value);
    static long long fromJavaLong(jlong value);
    static float fromJavaFloat(jfloat value);
    static double fromJavaDouble(jdouble value);
    static bool fromJavaBoolean(jboolean value);
    static QString fromJavaString(jstring str, JNIEnv *env);
    static QByteArray fromJavaByteArray(jbyteArray arr, JNIEnv *env);
    
    // ========== 复杂类型转换 ==========
    
    // 将QVariant转换为Java对象
    static jobject variantToJavaObject(const QVariant &var, JNIEnv *env);
    
    // 将Java对象转换为QVariant
    static QVariant javaObjectToVariant(jobject obj, JNIEnv *env);
    
    // ========== 集合类型转换 ==========
    
    // QList -> Java ArrayList
    static jobject qlistToJavaList(const QList<QVariant> &list, JNIEnv *env);
    
    // Java ArrayList -> QList
    static QList<QVariant> javaListToQList(jobject javaList, JNIEnv *env);
    
    // QMap -> Java HashMap
    static jobject qmapToJavaMap(const QMap<QString, QVariant> &map, JNIEnv *env);
    
    // Java HashMap -> QMap
    static QMap<QString, QVariant> javaMapToQMap(jobject javaMap, JNIEnv *env);

private:
    // 辅助方法
    static jclass getJavaClass(const QString &className, JNIEnv *env);
};

#endif // DATA_CONVERTER_H

文字解释：

这个转换器类提供了C++和Java之间的双向数据转换。对于基本类型（int、long、float等），转换相对简单。对于复杂类型（对象、集合等），需要通过JNI创建相应的Java对象。通过统一的转换接口，上层代码不需要关心具体的转换细节。

// data_converter.cpp
#include "data_converter.h"
#include <QDebug>
#include <QJsonDocument>
#include <QJsonObject>

// ========== 基本类型转换实现 ==========

jint DataConverter::toJavaInt(int value)
{
    return static_cast<jint>(value);
}

jlong DataConverter::toJavaLong(long long value)
{
    return static_cast<jlong>(value);
}

jstring DataConverter::toJavaString(const QString &str, JNIEnv *env)
{
    if (env == nullptr) {
        return nullptr;
    }
    
    // 将QString转换为UTF-8字节数组
    QByteArray utf8 = str.toUtf8();
    
    // 创建Java String
    return env->NewStringUTF(utf8.constData());
}

QString DataConverter::fromJavaString(jstring str, JNIEnv *env)
{
    if (env == nullptr || str == nullptr) {
        return QString();
    }
    
    // 获取UTF-8字符串
    const char *nativeString = env->GetStringUTFChars(str, nullptr);
    QString result = QString::fromUtf8(nativeString);
    
    // 释放字符串
    env->ReleaseStringUTFChars(str, nativeString);
    
    return result;
}

jbyteArray DataConverter::toJavaByteArray(const QByteArray &data, JNIEnv *env)
{
    if (env == nullptr) {
        return nullptr;
    }
    
    jbyteArray result = env->NewByteArray(data.size());
    env->SetByteArrayRegion(result, 0, data.size(), 
                           reinterpret_cast<const jbyte *>(data.constData()));
    
    return result;
}

QByteArray DataConverter::fromJavaByteArray(jbyteArray arr, JNIEnv *env)
{
    if (env == nullptr || arr == nullptr) {
        return QByteArray();
    }
    
    jsize length = env->GetArrayLength(arr);
    jbyte *elements = env->GetByteArrayElements(arr, nullptr);
    
    QByteArray result(reinterpret_cast<const char *>(elements), length);
    
    env->ReleaseByteArrayElements(arr, elements, JNI_ABORT);
    
    return result;
}

// ========== 复杂类型转换实现 ==========

jobject DataConverter::variantToJavaObject(const QVariant &var, JNIEnv *env)
{
    if (env == nullptr) {
        return nullptr;
    }
    
    switch (var.type()) {
    case QVariant::Int:
        return env->NewObject(
            getJavaClass("java/lang/Integer", env),
            env->GetMethodID(getJavaClass("java/lang/Integer", env), 
                           "<init>", "(I)V"),
            toJavaInt(var.toInt()));
    
    case QVariant::String:
        return toJavaString(var.toString(), env);
    
    case QVariant::Double:
        return env->NewObject(
            getJavaClass("java/lang/Double", env),
            env->GetMethodID(getJavaClass("java/lang/Double", env),
                           "<init>", "(D)V"),
            toJavaDouble(var.toDouble()));
    
    case QVariant::Bool:
        return env->NewObject(
            getJavaClass("java/lang/Boolean", env),
            env->GetMethodID(getJavaClass("java/lang/Boolean", env),
                           "<init>", "(Z)V"),
            toJavaBoolean(var.toBool()));
    
    default:
        qWarning() << "Unsupported variant type:" << var.type();
        return nullptr;
    }
}

// ========== 集合类型转换实现 ==========

jobject DataConverter::qlistToJavaList(const QList<QVariant> &list, JNIEnv *env)
{
    if (env == nullptr) {
        return nullptr;
    }
    
    // 获取ArrayList类
    jclass arrayListClass = getJavaClass("java/util/ArrayList", env);
    jmethodID constructor = env->GetMethodID(arrayListClass, "<init>", "()V");
    jmethodID addMethod = env->GetMethodID(arrayListClass, "add", 
                                          "(Ljava/lang/Object;)Z");
    
    // 创建ArrayList实例
    jobject javaList = env->NewObject(arrayListClass, constructor);
    
    // 添加元素
    for (const QVariant &item : list) {
        jobject javaItem = variantToJavaObject(item, env);
        env->CallBooleanMethod(javaList, addMethod, javaItem);
        env->DeleteLocalRef(javaItem);
    }
    
    return javaList;
}

QList<QVariant> DataConverter::javaListToQList(jobject javaList, JNIEnv *env)
{
    QList<QVariant> result;
    
    if (env == nullptr || javaList == nullptr) {
        return result;
    }
    
    // 获取ArrayList类
    jclass arrayListClass = getJavaClass("java/util/ArrayList", env);
    jmethodID sizeMethod = env->GetMethodID(arrayListClass, "size", "()I");
    jmethodID getMethod = env->GetMethodID(arrayListClass, "get", 
                                          "(I)Ljava/lang/Object;");
    
    // 获取列表大小
    jint size = env->CallIntMethod(javaList, sizeMethod);
    
    // 提取元素
    for (jint i = 0; i < size; ++i) {
        jobject item = env->CallObjectMethod(javaList, getMethod, i);
        result.append(javaObjectToVariant(item, env));
        env->DeleteLocalRef(item);
    }
    
    return result;
}

jclass DataConverter::getJavaClass(const QString &className, JNIEnv *env)
{
    if (env == nullptr) {
        return nullptr;
    }
    
    return env->FindClass(className.toStdString().c_str());
}

文字解释：

这段实现代码展示了具体的数据转换逻辑。toJavaString()将QString转换为UTF-8字节数组，然后创建Java String。fromJavaString()反向转换。toJavaByteArray()和fromJavaByteArray()处理二进制数据。variantToJavaObject()根据QVariant的类型创建相应的Java对象。qlistToJavaList()创建ArrayList并逐个添加元素。这些方法都进行了适当的内存管理，及时释放临时对象。

---

问题二：序列化格式的选择与性能

问题描述

在JNI通信中，需要选择合适的序列化格式：

• JSON：易读易调试，但解析速度慢，数据量大
• Protocol Buffers：高效紧凑，但需要定义schema
• 二进制格式：最快最紧凑，但难以调试

问题流程图

数据序列化选择
    |
    ├─→ JSON格式
    |   ├─→ 优点：易读易调试
    |   └─→ 缺点：解析慢，数据量大 ⚠️
    |
    ├─→ Protocol Buffers
    |   ├─→ 优点：高效紧凑
    |   └─→ 缺点：需要定义schema ⚠️
    |
    └─→ 二进制格式
        ├─→ 优点：最快最紧凑
        └─→ 缺点：难以调试 ⚠️

解决方案：自适应序列化框架

// serializer.h
#ifndef SERIALIZER_H
#define SERIALIZER_H

#include <QString>
#include <QByteArray>
#include <QVariantMap>
#include <QJsonDocument>

enum class SerializationFormat {
    JSON,           // JSON格式
    BINARY,         // 二进制格式
    COMPACT         // 紧凑二进制格式
};

class Serializer {
public:
    // 序列化数据
    static QByteArray serialize(const QVariantMap &data, 
                               SerializationFormat format = SerializationFormat::JSON);
    
    // 反序列化数据
    static QVariantMap deserialize(const QByteArray &data,
                                  SerializationFormat format = SerializationFormat::JSON);
    
    // 获取序列化格式的MIME类型
    static QString getMimeType(SerializationFormat format);

private:
    // JSON序列化
    static QByteArray serializeToJSON(const QVariantMap &data);
    static QVariantMap deserializeFromJSON(const QByteArray &data);
    
    // 二进制序列化
    static QByteArray serializeToBinary(const QVariantMap &data);
    static QVariantMap deserializeFromBinary(const QByteArray &data);
    
    // 紧凑二进制序列化
    static QByteArray serializeToCompact(const QVariantMap &data);
    static QVariantMap deserializeFromCompact(const QByteArray &data);
};

#endif // SERIALIZER_H

文字解释：

这个序列化器类提供了多种序列化格式的支持。通过SerializationFormat枚举，应用可以根据需要选择合适的格式。JSON格式适合调试和跨平台通信，二进制格式适合性能要求高的场景，紧凑二进制格式是两者的折中。

// serializer.cpp
#include "serializer.h"
#include <QJsonObject>
#include <QJsonArray>
#include <QDataStream>
#include <QDebug>

QByteArray Serializer::serialize(const QVariantMap &data, SerializationFormat format)
{
    switch (format) {
    case SerializationFormat::JSON:
        return serializeToJSON(data);
    case SerializationFormat::BINARY:
        return serializeToBinary(data);
    case SerializationFormat::COMPACT:
        return serializeToCompact(data);
    default:
        return QByteArray();
    }
}

QVariantMap Serializer::deserialize(const QByteArray &data, SerializationFormat format)
{
    switch (format) {
    case SerializationFormat::JSON:
        return deserializeFromJSON(data);
    case SerializationFormat::BINARY:
        return deserializeFromBinary(data);
    case SerializationFormat::COMPACT:
        return deserializeFromCompact(data);
    default:
        return QVariantMap();
    }
}

// ========== JSON序列化实现 ==========

QByteArray Serializer::serializeToJSON(const QVariantMap &data)
{
    QJsonObject jsonObj = QJsonObject::fromVariantMap(data);
    QJsonDocument doc(jsonObj);
    return doc.toJson(QJsonDocument::Compact);
}

QVariantMap Serializer::deserializeFromJSON(const QByteArray &data)
{
    QJsonDocument doc = QJsonDocument::fromJson(data);
    if (doc.isObject()) {
        return doc.object().toVariantMap();
    }
    return QVariantMap();
}

// ========== 二进制序列化实现 ==========

QByteArray Serializer::serializeToBinary(const QVariantMap &data)
{
    QByteArray result;
    QDataStream stream(&result, QIODevice::WriteOnly);
    stream.setVersion(QDataStream::Qt_5_15);
    
    // 写入数据项数量
    stream << static_cast<quint32>(data.size());
    
    // 写入每个键值对
    for (auto it = data.begin(); it != data.end(); ++it) {
        stream << it.key();
        stream << it.value();
    }
    
    return result;
}

QVariantMap Serializer::deserializeFromBinary(const QByteArray &data)
{
    QVariantMap result;
    QDataStream stream(data);
    stream.setVersion(QDataStream::Qt_5_15);
    
    quint32 count;
    stream >> count;
    
    for (quint32 i = 0; i < count; ++i) {
        QString key;
        QVariant value;
        stream >> key >> value;
        result[key] = value;
    }
    
    return result;
}

// ========== 紧凑二进制序列化实现 ==========

QByteArray Serializer::serializeToCompact(const QVariantMap &data)
{
    QByteArray result;
    QDataStream stream(&result, QIODevice::WriteOnly);
    
    // 使用更紧凑的格式
    stream << static_cast<quint16>(data.size());
    
    for (auto it = data.begin(); it != data.end(); ++it) {
        // 使用字符串哈希来压缩键
        quint32 keyHash = qHash(it.key());
        stream << keyHash;
        
        // 根据值的类型使用不同的编码
        const QVariant &value = it.value();
        quint8 typeCode = static_cast<quint8>(value.type());
        stream << typeCode;
        stream << value;
    }
    
    return result;
}

QVariantMap Serializer::deserializeFromCompact(const QByteArray &data)
{
    QVariantMap result;
    QDataStream stream(data);
    
    quint16 count;
    stream >> count;
    
    for (quint16 i = 0; i < count; ++i) {
        quint32 keyHash;
        quint8 typeCode;
        QVariant value;
        
        stream >> keyHash >> typeCode >> value;
        
        // 注意：这里使用哈希作为键，实际应用中需要维护哈希表
        result[QString::number(keyHash)] = value;
    }
    
    return result;
}

QString Serializer::getMimeType(SerializationFormat format)
{
    switch (format) {
    case SerializationFormat::JSON:
        return "application/json";
    case SerializationFormat::BINARY:
    case SerializationFormat::COMPACT:
        return "application/octet-stream";
    default:
        return "application/octet-stream";
    }
}

文字解释：

这段实现代码展示了三种序列化格式的具体实现。JSON序列化使用Qt的QJsonDocument，简单直观。二进制序列化使用QDataStream，更紧凑高效。紧凑二进制序列化进一步优化，使用哈希压缩键名，使用类型码标记值的类型。在实际应用中，可以根据数据大小和性能要求选择合适的格式。

---

问题三：异步数据传输与回调管理

问题描述

JNI调用通常是同步的，但很多操作（网络请求、文件I/O等）是异步的。需要一个机制来：

• 追踪异步操作
• 在操作完成时调用回调
• 处理超时和错误

问题流程图

发起异步操作
    |
    ├─→ 操作ID: 1001
    |   ├─→ 等待完成...
    |   ├─→ 超时？ ──→ ❌ 回调丢失！
    |   └─→ 完成 ──→ 调用回调
    |
    ├─→ 操作ID: 1002
    |   ├─→ 等待完成...
    |   ├─→ 错误 ──→ 调用错误回调
    |   └─→ ✓ 成功
    |
    └─→ 操作ID: 1003
        ├─→ 等待完成...
        └─→ 应用崩溃 ──→ ❌ 内存泄漏！

解决方案：异步操作管理器

// async_operation_manager.h
#ifndef ASYNC_OPERATION_MANAGER_H
#define ASYNC_OPERATION_MANAGER_H

#include <QString>
#include <QMap>
#include <QMutex>
#include <functional>
#include <memory>
#include <chrono>

class AsyncOperationManager {
public:
    using SuccessCallback = std::function<void(const QVariant &)>;
    using ErrorCallback = std::function<void(const QString &)>;
    
    struct Operation {
        int operationId;
        QString operationType;
        SuccessCallback onSuccess;
        ErrorCallback onError;
        std::chrono::steady_clock::time_point startTime;
        int timeoutMs;
        bool completed;
    };
    
    static AsyncOperationManager &instance();
    
    // 注册异步操作
    int registerOperation(const QString &operationType,
                        SuccessCallback onSuccess,
                        ErrorCallback onError,
                        int timeoutMs = 30000);
    
    // 操作完成时调用
    void completeOperation(int operationId, const QVariant &result);
    
    // 操作失败时调用
    void failOperation(int operationId, const QString &error);
    
    // 检查超时的操作
    void checkTimeouts();
    
    // 获取操作信息
    Operation *getOperation(int operationId);
    
    // 清理已完成的操作
    void cleanup();

private:
    AsyncOperationManager() = default;
    
    QMap<int, std::shared_ptr<Operation>> m_operations;
    QMutex m_mutex;
    int m_nextOperationId;
};

#endif // ASYNC_OPERATION_MANAGER_H

文字解释：

这个管理器类维护所有进行中的异步操作。每个操作都有唯一的ID、类型、成功和失败回调、超时时间等信息。通过registerOperation()注册操作，通过completeOperation()或failOperation()完成操作。checkTimeouts()定期检查是否有超时的操作，并调用错误回调。

// async_operation_manager.cpp
#include "async_operation_manager.h"
#include <QDebug>
#include <QTimer>

AsyncOperationManager &AsyncOperationManager::instance()
{
    static AsyncOperationManager manager;
    return manager;
}

int AsyncOperationManager::registerOperation(const QString &operationType,
                                             SuccessCallback onSuccess,
                                             ErrorCallback onError,
                                             int timeoutMs)
{
    QMutexLocker locker(&m_mutex);
    
    int operationId = ++m_nextOperationId;
    
    auto operation = std::make_shared<Operation>();
    operation->operationId = operationId;
    operation->operationType = operationType;
    operation->onSuccess = onSuccess;
    operation->onError = onError;
    operation->startTime = std::chrono::steady_clock::now();
    operation->timeoutMs = timeoutMs;
    operation->completed = false;
    
    m_operations[operationId] = operation;
    
    qDebug() << "Registered operation" << operationId << "of type" << operationType;
    
    return operationId;
}

void AsyncOperationManager::completeOperation(int operationId, const QVariant &result)
{
    QMutexLocker locker(&m_mutex);
    
    auto it = m_operations.find(operationId);
    if (it != m_operations.end()) {
        auto operation = it.value();
        operation->completed = true;
        
        if (operation->onSuccess) {
            operation->onSuccess(result);
        }
        
        qDebug() << "Operation" << operationId << "completed successfully";
    } else {
        qWarning() << "Operation" << operationId << "not found";
    }
}

void AsyncOperationManager::failOperation(int operationId, const QString &error)
{
    QMutexLocker locker(&m_mutex);
    
    auto it = m_operations.find(operationId);
    if (it != m_operations.end()) {
        auto operation = it.value();
        operation->completed = true;
        
        if (operation->onError) {
            operation->onError(error);
        }
        
        qDebug() << "Operation" << operationId << "failed:" << error;
    }
}

void AsyncOperationManager::checkTimeouts()
{
    QMutexLocker locker(&m_mutex);
    
    auto now = std::chrono::steady_clock::now();
    
    for (auto it = m_operations.begin(); it != m_operations.end(); ) {
        auto operation = it.value();
        
        if (!operation->completed) {
            auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
                now - operation->startTime).count();
            
            if (elapsed > operation->timeoutMs) {
                qWarning() << "Operation" << operation->operationId << "timed out";
                
                if (operation->onError) {
                    operation->onError("Operation timed out");
                }
                
                operation->completed = true;
            }
        }
        
        ++it;
    }
}

void AsyncOperationManager::cleanup()
{
    QMutexLocker locker(&m_mutex);
    
    // 删除所有已完成的操作
    for (auto it = m_operations.begin(); it != m_operations.end(); ) {
        if (it.value()->completed) {
            it = m_operations.erase(it);
        } else {
            ++it;
        }
    }
}

Operation *AsyncOperationManager::getOperation(int operationId)
{
    QMutexLocker locker(&m_mutex);
    
    auto it = m_operations.find(operationId);
    if (it != m_operations.end()) {
        return it.value().get();
    }
    
    return nullptr;
}

文字解释：

这段实现代码展示了异步操作的完整生命周期管理。registerOperation()创建新操作并分配ID。completeOperation()和failOperation()在操作完成时调用相应的回调。checkTimeouts()定期检查超时，防止回调永远不被调用。cleanup()删除已完成的操作，释放资源。所有操作都使用互斥锁保护，确保线程安全。

---

最佳实践总结

问题	解决方案	关键点
数据类型转换	统一转换框架	处理所有基本和复杂类型
序列化格式	自适应序列化	根据需求选择合适格式
异步传输	操作管理器	追踪、超时、回调管理
内存管理	RAII和智能指针	自动释放资源

通过这些方案，可以构建一个可靠的数据传输层。