JNI 中 C 与 C++ 的深度差异分析

JNI开发中C与C++的差异主要体现在语法结构、内存管理和开发范式上。C语言通过(*env)->函数(env,...)双重解引用方式调用JNI接口，需要手动管理内存和异常检查；而C++采用更简洁的env->函数(...)面向对象风格，支持RAII自动资源管理和异常机制。C语言更适合嵌入式等资源受限场景，代码简洁但安全性较低；C++凭借更好的类型安全、STL库支持和现代特性，更适合复杂业务逻辑和大型项目。两种语言在性能上差异微小，选择应基于项目需求、团队技能和维护考量，理解JNI原理和跨语言边界处理才是成功关键。

博主博客

• https://blog.uso6.com
• https://blog.csdn.net/dxk539687357

一、引言：为什么需要关注 JNI 中 C/C++ 的差异？

在 Java Native Interface (JNI) 开发中，选择使用 C 还是 C++ 实现本地方法不仅影响代码风格，更关系到性能、可维护性和开发效率。虽然两者都能实现相同的功能，但在语法、内存管理、异常处理和代码组织等方面存在显著差异。理解这些差异对于做出正确的技术选型和编写高质量的 JNI 代码至关重要。

二、JNIEnv 结构：根本差异的源头

2.1 C 语言的 JNIEnv 实现

// jni.h 中对 C 的定义
typedef const struct JNINativeInterface* JNIEnv;

struct JNINativeInterface {
    jint (JNICALL *GetVersion)(JNIEnv *env);
    jclass (JNICALL *FindClass)(JNIEnv* env, const char* name);
    jmethodID (JNICALL *GetMethodID)(JNIEnv* env, jclass clazz, 
                                     const char* name, const char* sig);
    // ... 数百个函数指针
};

// 使用方式：必须双重解引用
jclass clazz = (*env)->FindClass(env, "java/lang/String");

关键特点：

• JNIEnv 是指向函数表指针的指针
• 每次调用都需要显式传递 env 参数
• 函数调用通过函数指针进行

2.2 C++ 语言的 JNIEnv 实现

// jni.h 中对 C++ 的定义
class _JNIEnv {
    const struct JNINativeInterface* functions;
    
public:
    jint GetVersion() { 
        return functions->GetVersion(this); 
    }
    
    jclass FindClass(const char* name) {
        return functions->FindClass(this, name);
    }
    
    // 内联函数封装了所有JNI函数
    // ...
};

typedef _JNIEnv JNIEnv;

// 使用方式：直接成员函数调用
jclass clazz = env->FindClass("java/lang/String");

关键特点：

• JNIEnv 是一个包含函数指针表的类
• 使用内联成员函数封装调用
• 语法更接近标准 C++ 风格

三、语法差异的全面对比

3.1 基本调用语法

3.2 完整的代码示例对比

/* ---------- C 语言完整示例 ---------- */
#include <jni.h>
#include <string.h>
#include <stdlib.h>

// C语言辅助函数
static jstring convertToUpper_C(JNIEnv* env, jstring input) {
    const char* str = (*env)->GetStringUTFChars(env, input, NULL);
    if (str == NULL) {
        return NULL; // 内存不足
    }
    
    size_t len = strlen(str);
    char* result = (char*)malloc(len + 1);
    for (size_t i = 0; i < len; i++) {
        result[i] = toupper(str[i]);
    }
    result[len] = '\0';
    
    (*env)->ReleaseStringUTFChars(env, input, str);
    
    jstring jresult = (*env)->NewStringUTF(env, result);
    free(result);
    return jresult;
}

JNIEXPORT jstring JNICALL Java_com_example_NativeLib_toUpperCase_C
    (JNIEnv* env, jobject thiz, jstring input) {
    
    return convertToUpper_C(env, input);
}

/* ---------- C++ 语言完整示例 ---------- */
#include <jni.h>
#include <string>
#include <cctype>

// C++辅助类，利用RAII管理资源
class JStringConverter {
private:
    JNIEnv* env;
    const char* cstr;
    jstring original;
    bool released;
    
public:
    JStringConverter(JNIEnv* env, jstring str) 
        : env(env), original(str), released(false) {
        cstr = env->GetStringUTFChars(original, NULL);
    }
    
    ~JStringConverter() {
        if (!released && cstr != NULL) {
            env->ReleaseStringUTFChars(original, cstr);
            released = true;
        }
    }
    
    const char* getCString() const { return cstr; }
    
    // 禁用复制构造和赋值
    JStringConverter(const JStringConverter&) = delete;
    JStringConverter& operator=(const JStringConverter&) = delete;
};

// C++实现，使用标准库和RAII
static jstring convertToUpper_CPP(JNIEnv* env, jstring input) {
    JStringConverter converter(env, input);
    const char* str = converter.getCString();
    
    if (str == NULL) {
        return NULL;
    }
    
    std::string result(str);
    for (char& c : result) {
        c = std::toupper(c);
    }
    
    return env->NewStringUTF(result.c_str());
}

JNIEXPORT jstring JNICALL Java_com_example_NativeLib_toUpperCase_CPP
    (JNIEnv* env, jobject thiz, jstring input) {
    
    return convertToUpper_CPP(env, input);
}

四、内存管理的差异

4.1 本地引用管理

/* ---------- C 语言本地引用 ---------- */
void processReferences_C(JNIEnv* env) {
    // 创建多个本地引用
    jclass clazz1 = (*env)->FindClass(env, "java/lang/String");
    jclass clazz2 = (*env)->FindClass(env, "java/lang/Integer");
    
    // 必须手动管理局部引用帧
    (*env)->PushLocalFrame(env, 10); // 创建局部引用帧
    
    // 在这个帧内创建的引用会自动管理
    jclass clazz3 = (*env)->FindClass(env, "java/lang/Long");
    
    // 弹出帧，释放clazz3
    (*env)->PopLocalFrame(env, NULL);
    
    // 手动删除不再需要的引用
    (*env)->DeleteLocalRef(env, clazz1);
    (*env)->DeleteLocalRef(env, clazz2);
}

/* ---------- C++ 语言本地引用 ---------- */
void processReferences_CPP(JNIEnv* env) {
    // C++可以使用智能指针风格封装
    class LocalRef {
    private:
        JNIEnv* env;
        jobject ref;
        
    public:
        LocalRef(JNIEnv* e, jobject r) : env(e), ref(r) {}
        ~LocalRef() { if (ref) env->DeleteLocalRef(ref); }
        jobject get() const { return ref; }
        
        // 禁止复制
        LocalRef(const LocalRef&) = delete;
        LocalRef& operator=(const LocalRef&) = delete;
        
        // 允许移动
        LocalRef(LocalRef&& other) : env(other.env), ref(other.ref) {
            other.ref = nullptr;
        }
    };
    
    LocalRef clazz1(env, env->FindClass("java/lang/String"));
    LocalRef clazz2(env, env->FindClass("java/lang/Integer"));
    
    // 使用局部引用帧
    env->PushLocalFrame(10);
    
    jclass clazz3 = env->FindClass("java/lang/Long");
    
    env->PopLocalFrame(nullptr); // clazz3自动释放
}

4.2 全局引用和弱全局引用

/* ---------- C 语言全局引用 ---------- */
static jclass g_stringClass = NULL;

void initGlobalRef_C(JNIEnv* env) {
    if (g_stringClass == NULL) {
        jclass localClass = (*env)->FindClass(env, "java/lang/String");
        g_stringClass = (*env)->NewGlobalRef(env, localClass);
        (*env)->DeleteLocalRef(env, localClass);
    }
}

void cleanupGlobalRef_C(JNIEnv* env) {
    if (g_stringClass != NULL) {
        (*env)->DeleteGlobalRef(env, g_stringClass);
        g_stringClass = NULL;
    }
}

/* ---------- C++ 语言全局引用 ---------- */
class GlobalRefManager {
private:
    JNIEnv* env;
    jobject globalRef;
    
public:
    GlobalRefManager(JNIEnv* e, jobject obj) : env(e), globalRef(nullptr) {
        if (obj) {
            globalRef = env->NewGlobalRef(obj);
        }
    }
    
    ~GlobalRefManager() {
        if (globalRef) {
            env->DeleteGlobalRef(globalRef);
        }
    }
    
    jobject get() const { return globalRef; }
    
    // 禁用复制，允许移动
    GlobalRefManager(const GlobalRefManager&) = delete;
    GlobalRefManager& operator=(const GlobalRefManager&) = delete;
    
    GlobalRefManager(GlobalRefManager&& other) 
        : env(other.env), globalRef(other.globalRef) {
        other.globalRef = nullptr;
    }
};

// 使用示例
static std::unique_ptr<GlobalRefManager> g_stringClass;

void initGlobalRef_CPP(JNIEnv* env) {
    if (!g_stringClass) {
        jclass localClass = env->FindClass("java/lang/String");
        g_stringClass = std::make_unique<GlobalRefManager>(env, localClass);
        env->DeleteLocalRef(localClass);
    }
}

五、异常处理的差异

5.1 异常检查和处理

/* ---------- C 语言异常处理 ---------- */
jstring safeOperation_C(JNIEnv* env, jobject obj) {
    jclass clazz = (*env)->GetObjectClass(env, obj);
    if (clazz == NULL) {
        // 检查是否发生了异常
        if ((*env)->ExceptionCheck(env)) {
            (*env)->ExceptionDescribe(env); // 打印异常信息
            (*env)->ExceptionClear(env);    // 清除异常
        }
        return NULL;
    }
    
    jmethodID method = (*env)->GetMethodID(env, clazz, "getName", "()Ljava/lang/String;");
    if (method == NULL) {
        // 同样的异常检查
        if ((*env)->ExceptionCheck(env)) {
            (*env)->ExceptionDescribe(env);
            (*env)->ExceptionClear(env);
        }
        (*env)->DeleteLocalRef(env, clazz);
        return NULL;
    }
    
    jstring result = (*env)->CallObjectMethod(env, obj, method);
    (*env)->DeleteLocalRef(env, clazz);
    
    return result;
}

/* ---------- C++ 语言异常处理 ---------- */
jstring safeOperation_CPP(JNIEnv* env, jobject obj) {
    // C++可以使用RAII管理局部引用
    class LocalRef {
        JNIEnv* env;
        jobject ref;
    public:
        LocalRef(JNIEnv* e, jobject r) : env(e), ref(r) {}
        ~LocalRef() { if (ref) env->DeleteLocalRef(ref); }
        operator jobject() const { return ref; }
    };
    
    LocalRef clazz(env, env->GetObjectClass(obj));
    if (env->ExceptionCheck()) {
        env->ExceptionDescribe();
        env->ExceptionClear();
        return nullptr;
    }
    
    jmethodID method = env->GetMethodID((jclass)clazz, "getName", "()Ljava/lang/String;");
    if (env->ExceptionCheck()) {
        env->ExceptionDescribe();
        env->ExceptionClear();
        return nullptr;
    }
    
    return (jstring)env->CallObjectMethod(obj, method);
}

5.2 结合 C++ 异常和 JNI 异常

/* ---------- C++ 异常与JNI异常结合 ---------- */
class JNIException : public std::runtime_error {
private:
    std::string jniDescription;
    
public:
    JNIException(const std::string& msg, JNIEnv* env = nullptr)
        : std::runtime_error(msg) {
        if (env && env->ExceptionCheck()) {
            // 获取异常信息
            jthrowable exc = env->ExceptionOccurred();
            jclass clazz = env->GetObjectClass(exc);
            jmethodID toString = env->GetMethodID(clazz, "toString", "()Ljava/lang/String;");
            jstring jstr = (jstring)env->CallObjectMethod(exc, toString);
            
            const char* cstr = env->GetStringUTFChars(jstr, nullptr);
            jniDescription = cstr;
            env->ReleaseStringUTFChars(jstr, cstr);
            
            env->ExceptionClear();
        }
    }
    
    const std::string& getJNIDescription() const { return jniDescription; }
};

jstring advancedOperation_CPP(JNIEnv* env, jobject obj) {
    try {
        jclass clazz = env->GetObjectClass(obj);
        if (clazz == nullptr) {
            throw JNIException("Failed to get object class", env);
        }
        
        jmethodID method = env->GetMethodID(clazz, "compute", "(I)D");
        if (method == nullptr) {
            throw JNIException("Method not found", env);
        }
        
        jdouble result = env->CallDoubleMethod(obj, method, 42);
        
        // 转换结果为字符串
        std::stringstream ss;
        ss << "Result: " << result;
        
        return env->NewStringUTF(ss.str().c_str());
        
    } catch (const JNIException& e) {
        // 记录日志或进行其他处理
        std::cerr << "JNI Exception: " << e.what() << std::endl;
        if (!e.getJNIDescription().empty()) {
            std::cerr << "Java Exception: " << e.getJNIDescription() << std::endl;
        }
        return nullptr;
    } catch (const std::exception& e) {
        std::cerr << "Standard Exception: " << e.what() << std::endl;
        return nullptr;
    }
}

六、性能对比分析

6.1 函数调用开销

/* ---------- C 语言性能测试 ---------- */
// 大量JNI调用的C版本
void benchmark_C(JNIEnv* env, jobjectArray array, jint iterations) {
    jsize len = (*env)->GetArrayLength(env, array);
    
    for (jint i = 0; i < iterations; i++) {
        for (jsize j = 0; j < len; j++) {
            jstring element = (*env)->GetObjectArrayElement(env, array, j);
            // 每次调用都需要(*env)->和传递env
            jint strLen = (*env)->GetStringLength(env, element);
            (*env)->DeleteLocalRef(env, element);
        }
    }
}

/* ---------- C++ 语言性能测试 ---------- */
// 大量JNI调用的C++版本
void benchmark_CPP(JNIEnv* env, jobjectArray array, jint iterations) {
    jsize len = env->GetArrayLength(array);
    
    for (jint i = 0; i < iterations; i++) {
        for (jsize j = 0; j < len; j++) {
            jstring element = env->GetObjectArrayElement(array, j);
            // 调用语法更简洁
            jint strLen = env->GetStringLength(element);
            env->DeleteLocalRef(element);
        }
    }
}

性能分析结果：

1. 编译期优化：C++ 的内联函数通常会被编译器优化，减少函数调用开销
2. 代码大小：C 版本通常生成更小的代码，但现代编译器优化后差异不大
3. 可读性影响：C++ 更简洁的语法减少了出错概率，间接影响性能

6.2 内存访问模式

/* ---------- C 语言直接内存访问 ---------- */
jint processArray_C(JNIEnv* env, jintArray array) {
    jint* elements = (*env)->GetIntArrayElements(env, array, NULL);
    jsize length = (*env)->GetArrayLength(env, array);
    
    jint sum = 0;
    // C风格直接指针操作
    for (jsize i = 0; i < length; i++) {
        sum += elements[i];
    }
    
    (*env)->ReleaseIntArrayElements(env, array, elements, 0);
    return sum;
}

/* ---------- C++ 语言带边界检查 ---------- */
jint processArray_CPP(JNIEnv* env, jintArray array) {
    jint* elements = env->GetIntArrayElements(array, nullptr);
    jsize length = env->GetArrayLength(array);
    
    jint sum = 0;
    // 可以使用标准库算法
    std::vector<jint> temp(elements, elements + length);
    sum = std::accumulate(temp.begin(), temp.end(), 0);
    
    env->ReleaseIntArrayElements(array, elements, 0);
    return sum;
}

七、开发体验和工具支持

7.1 调试支持差异

/* ---------- C 语言调试挑战 ---------- */
// C语言缺乏类型安全的容器，调试困难
void debugExample_C(JNIEnv* env, jobject obj) {
    // 容易出错的类型转换
    jclass clazz = (*env)->FindClass(env, "com/example/MyClass");
    jfieldID field = (*env)->GetFieldID(env, clazz, "data", "I");
    
    // 错误的类型假设
    jlong wrongValue = (*env)->GetLongField(env, obj, field); // 运行时错误
    
    // 缺乏编译期检查
    (*env)->CallVoidMethod(env, obj, (jmethodID)0x1234); // 编译通过，运行时崩溃
}

/* ---------- C++ 语言类型安全 ---------- */
// C++提供更好的类型安全和调试支持
void debugExample_CPP(JNIEnv* env, jobject obj) {
    // 可以使用类型安全的包装器
    class TypeSafeJNI {
    private:
        JNIEnv* env;
        
    public:
        TypeSafeJNI(JNIEnv* e) : env(e) {}
        
        template<typename T>
        T getField(jobject obj, const char* fieldName, const char* signature) {
            jclass clazz = env->GetObjectClass(obj);
            jfieldID field = env->GetFieldID(clazz, fieldName, signature);
            
            // 根据类型调用正确的函数
            if constexpr (std::is_same_v<T, jint>) {
                return env->GetIntField(obj, field);
            } else if constexpr (std::is_same_v<T, jlong>) {
                return env->GetLongField(obj, field);
            }
            // ... 其他类型
        }
    };
    
    TypeSafeJNI safe(env);
    // 编译期类型检查
    jint value = safe.getField<jint>(obj, "data", "I");
}

7.2 IDE 和静态分析支持

C 语言项目：

• 较少的现代IDE智能提示
• 有限的模板和重构支持
• 静态分析工具较少（如Clang静态分析器）

C++ 项目：

• 完整的IDE支持（智能提示、重构、导航）
• 强大的模板支持
• 丰富的静态分析工具（Clang-Tidy、Cppcheck）
• 更好的文档生成工具（Doxygen）

八、最佳实践和选择建议

8.1 何时选择 C？

适用场景：

1. 小型简单项目：功能简单，不需要复杂的数据结构
2. 嵌入式环境：资源受限，需要最小化内存占用
3. 与现有C代码库集成：避免C++异常和RTTI的开销
4. 跨平台兼容性：某些平台C编译器支持更好

代码示例：

// 简单的C JNI实现
JNIEXPORT jint JNICALL Java_com_example_SimpleLib_add
    (JNIEnv* env, jobject thiz, jint a, jint b) {
    return a + b;
}

8.2 何时选择 C++？

适用场景：

1. 复杂业务逻辑：需要面向对象设计和复杂数据结构
2. 性能关键代码：可以利用C++模板元编程和内联优化
3. 需要RAII和异常安全：自动资源管理很重要
4. 大型项目：需要更好的代码组织和维护性
5. 与现代C++标准库集成：使用STL容器和算法

代码示例：

// 使用现代C++的JNI实现
class ComplexCalculator {
private:
    JNIEnv* env;
    std::vector<jobject> managedObjects;
    
public:
    ComplexCalculator(JNIEnv* e) : env(e) {}
    
    jdouble computeComplex(jobject context) {
        // 使用RAII管理资源
        auto stringResult = getStringProperty(context, "config");
        auto config = parseConfig(stringResult);
        
        // 使用STL算法
        std::vector<jdouble> inputs = getInputArray(context);
        jdouble result = std::accumulate(inputs.begin(), inputs.end(), 0.0,
            [&config](jdouble acc, jdouble val) {
                return acc + val * config.factor;
            });
        
        return result;
    }
};

8.3 混合使用策略

// 最佳实践：C接口暴露，C++内部实现
#ifdef __cplusplus
extern "C" {
#endif

// 纯C接口声明
JNIEXPORT jlong JNICALL Java_com_example_NativeLib_createEngine
    (JNIEnv* env, jobject thiz);
    
JNIEXPORT void JNICALL Java_com_example_NativeLib_processData
    (JNIEnv* env, jobject thiz, jlong enginePtr, jbyteArray data);
    
JNIEXPORT void JNICALL Java_com_example_NativeLib_destroyEngine
    (JNIEnv* env, jobject thiz, jlong enginePtr);

#ifdef __cplusplus
}
#endif

// C++实现
class EngineImpl {
private:
    std::vector<uint8_t> buffer;
    std::mutex dataMutex;
    
public:
    void process(const uint8_t* data, size_t size) {
        std::lock_guard<std::mutex> lock(dataMutex);
        buffer.assign(data, data + size);
        // 复杂处理逻辑
    }
};

// C接口的实现
JNIEXPORT jlong JNICALL Java_com_example_NativeLib_createEngine
    (JNIEnv* env, jobject thiz) {
    
    try {
        EngineImpl* engine = new EngineImpl();
        return reinterpret_cast<jlong>(engine);
    } catch (const std::exception& e) {
        env->ThrowNew(env->FindClass("java/lang/OutOfMemoryError"),
                      e.what());
        return 0;
    }
}

九、总结：核心差异对比表

十、最终建议

1. 新项目优先选择C++：受益于更好的类型安全、异常处理和现代特性
2. 维护现有C代码保持一致性：除非有充分理由，否则不要混合使用
3. 复杂逻辑用C++，简单接口用C：混合使用时要明确边界
4. 始终进行充分测试：无论选择哪种语言，都需要全面的单元测试
5. 考虑团队技能：选择团队更熟悉的语言

最重要的一点：无论选择C还是C++，理解JNI的基本原理、正确处理内存管理和异常、编写线程安全的代码，才是确保JNI程序稳定可靠的关键。语言选择只是工具，开发者的理解和技能才是决定项目成功的关键因素。