JNI基础知识总结

什么是JNI

JNI（Java Native Interface）是Java提供的一种编程框架，用于实现Java代码与本地（Native）代码（如C、C++等）之间的交互。JNI允许Java应用程序调用本地代码，并且本地代码可以调用Java代码，实现更高性能的操作或访问底层资源。

JNI的主要用途

1. 访问本地库：JNI允许Java应用程序调用本地库中的函数。本地库通常是用C或C++编写的，可以提供高性能的计算、操作系统级别的功能或与硬件交互等。

2. 平台特定功能：JNI允许Java应用程序访问底层操作系统或硬件的功能，以实现与特定平台相关的操作，如文件系统访问、网络编程、图形界面等。

3. 性能优化：JNI可以在Java应用程序中使用本地代码来提高性能。对于某些计算密集型任务或需要直接访问硬件的任务，使用本地代码可以比纯Java代码更高效。

JNI的工作原理

1. Java代码调用本地方法：Java代码通过JNI调用本地方法。本地方法是用`native`关键字声明的Java方法，它们的实现在本地代码中。

2. 生成JNI头文件：使用Java的`javah`命令可以生成JNI头文件（.h文件），该文件包含了Java类的本地方法的声明。

3. 实现本地方法：在本地代码中，使用JNI提供的函数和数据类型实现Java类的本地方法。本地代码可以使用C、C++等编程语言编写。

4. 编译和链接本地库：将本地代码编译为本地库（如.so文件或.dll文件），并将其链接到Java应用程序中。

5. 运行Java应用程序：Java应用程序运行时，可以调用本地方法，JNI将负责将调用传递给本地库。

总之，JNI提供了一个桥梁，使得Java应用程序可以与本地代码进行交互，从而获得更高的性能和更广泛的功能。但需要注意的是，使用JNI需要小心处理内存管理和跨平台兼容性等问题。

JNI调用Java方法

1、编写Java类和方法：首先，在Java中编写一个类，其中包含需要被JNI调用的方法。这些方法必须被声明为native，并且不能有方法体。例如，我们可以创建一个名为HelloJNI的Java类，其中包含一个native方法sayHello。

public class HelloJNI {
    public native void sayHello();
}

2、生成Java头文件：使用Java的javac命令编译Java类，并使用javah命令生成Java头文件。Java头文件是一个包含了JNI方法的声明的C/C++头文件。在命令行中执行以下命令：

javac HelloJNI.java
javah HelloJNI

执行完上述命令后，将生成一个名为HelloJNI.h的头文件，其中包含了sayHello方法的声明。

3、实现本地方法：实现本地方法：在C/C++中实现Java头文件中声明的本地方法。打开HelloJNI.h文件，可以看到sayHello方法的声明，通常在C/C++源文件中实现该方法。例如，我们可以创建一个名为HelloJNI.cpp的C++源文件，其中实现了sayHello方法。

#include 
#include 
#include "HelloJNI.h"

JNIEXPORT void JNICALL Java_HelloJNI_sayHello(JNIEnv *env, jobject obj) {
    std::cout << "Hello from JNI!" << std::endl;
}

4、编译本地方法：使用C/C++的编译器将C++源文件编译成动态链接库（或者静态链接库），以便Java程序可以加载和调用。例如，使用GCC编译器可以执行以下命令：

g++ -shared -o libhello.so HelloJNI.cpp -I -I

上述命令将生成一个名为libhello.so的动态链接库，其中包含了实现了sayHello方法的代码。

5、加载和调用本地方法：在Java程序中加载生成的动态链接库，并调用其中的本地方法。可以使用System.loadLibrary()方法加载动态链接库。例如，我们可以创建一个名为Main.java的Java类，其中调用了sayHello方法。

public class Main {
    static {
        System.loadLibrary("hello");
    }

    public static void main(String[] args) {
        HelloJNI hello = new HelloJNI();
        hello.sayHello();
    }
}

以上就是JNI调用Java方法的详细过程。通过JNI，可以在Java程序中调用本地方法，实现与底层系统或其他本地库的交互，提高程序的性能和功能。

JNI和Java之间参数传递

以下是一些常用的参数传递方式：

1、基本数据类型：可以直接在JNI代码中使用对应的JNI数据类型来传递基本数据类型的参数。例如，jint表示Java中的int类型，jfloat表示Java中的float类型，以此类推。

2、字符串：可以使用JNI提供的jstring类型来传递Java中的字符串。在JNI代码中，可以使用GetStringUTFChars函数将jstring转换为C字符串，并使用ReleaseStringUTFChars函数释放字符串。

JNIEXPORT void JNICALL Java_MyClass_printString(JNIEnv *env, jobject obj, jstring str) {
    const char *c_str = env->GetStringUTFChars(str, NULL);
    if (c_str != NULL) {
        printf("%s\n", c_str);
        env->ReleaseStringUTFChars(str, c_str);
    }
}

3、数组：可以使用JNI提供的jarray类型来传递Java中的数组。在JNI代码中，可以使用GetArrayLength函数获取数组的长度，使用GetIntArrayElements函数获取整型数组的指针，并使用ReleaseIntArrayElements函数释放数组。

JNIEXPORT void JNICALL Java_MyClass_printIntArray(JNIEnv *env, jobject obj, jintArray arr) {
    jint *c_arr = env->GetIntArrayElements(arr, NULL);
    jsize length = env->GetArrayLength(arr);
    for (int i = 0; i < length; i++) {
        printf("%d ", c_arr[i]);
    }
    printf("\n");
    env->ReleaseIntArrayElements(arr, c_arr, 0);
}

 4、对象：可以使用JNI提供的jobject类型来传递Java中的对象。在JNI代码中，可以使用GetObjectClass函数获取对象的类，使用GetMethodID函数获取对象的方法ID，并使用CallVoidMethod函数调用对象的方法。

JNIEXPORT void JNICALL Java_MyClass_callObjectMethod(JNIEnv *env, jobject obj, jobject object) {
    jclass cls = env->GetObjectClass(object);
    jmethodID mid = env->GetMethodID(cls, "methodName", "()V");
    env->CallVoidMethod(object, mid);
}

通过使用JNI提供的数据类型和函数，可以在JNI代码和Java代码之间传递参数，实现参数的传递和交互。

方法签名

字段签名是一个字符串，用于表示字段的类型。下面是一些常见的字段签名示例：

• Z：boolean类型
• B：byte类型
• C：char类型
• S：short类型
• I：int类型
• J：long类型
• F：float类型
• D：double类型
• [：数组类型，例如[I表示int数组
• L;：引用类型，例如Ljava/lang/String;表示String类型

对于数组类型和引用类型，需要使用方括号[]和分号;来表示。其中，fully-qualified-classname是完全限定的类名，使用斜杠/分隔包名和类名。

例如，如果要表示一个int类型的字段，字段签名为I；如果要表示一个String类型的字段，字段签名为Ljava/lang/String;。

需要注意的是，字段签名在JNI中是严格区分大小写的，所以要确保签名的大小写与实际类型的大小写一致。

以下是一些示例字段签名的用法：

jfieldID boolean_field_id = env->GetFieldID(cls, "booleanField", "Z");
jfieldID int_array_field_id = env->GetFieldID(cls, "intArrayField", "[I");
jfieldID string_field_id = env->GetFieldID(cls, "stringField", "Ljava/lang/String;");

在上述示例中，我们分别获取了booleanField、intArrayField和stringField字段的ID，它们的字段签名分别为Z、[I和Ljava/lang/String;。

如果要表示一个ByteArray类型的字段，字段签名使用[B。其中，[表示数组类型，B表示byte类型。

以下是一个示例，假设有一个Java对象obj，其中有一个ByteArray类型的字段byteArrayField：

jclass cls = env->GetObjectClass(obj);
jfieldID byte_array_field_id = env->GetFieldID(cls, "byteArrayField", "[B");
jbyteArray byte_array = (jbyteArray) env->GetObjectField(obj, byte_array_field_id);

JNI访问Java字段

在JNI中，可以通过以下步骤访问Java对象的字段：

1. 在JNI中获取Java类的引用。

2. 获取字段的ID。

3. 使用ID访问字段值。

以下是一个示例代码，演示如何在JNI中访问Java对象的字段：

JNIEXPORT jstring JNICALL Java_com_example_MyClass_getName(JNIEnv* env, jobject obj) {
    // 获取Java类的引用
    jclass cls = env->GetObjectClass(obj);
    if (cls == NULL) {
        return NULL;
    }

    // 获取字段的ID
    jfieldID nameId = env->GetFieldID(cls, "name", "Ljava/lang/String;");
    if (nameId == NULL) {
        return NULL;
    }

    // 使用ID访问字段值
    jstring name = (jstring)env->GetObjectField(obj, nameId);
    if (name == NULL) {
        return NULL;
    }

    // 将jstring转换为C字符串
    const char* nameStr = env->GetStringUTFChars(name, NULL);
    if (nameStr == NULL) {
        return NULL;
    }

    // 创建一个新的jstring对象并返回
    jstring result = env->NewStringUTF(nameStr);
    env->ReleaseStringUTFChars(name, nameStr);
    return result;
}

其中，env表示JNIEnv指针，obj表示Java对象的引用。首先，使用GetObjectClass函数获取Java类的引用。然后，使用GetFieldID函数获取字段的ID。最后，使用GetObjectField函数获取字段的值，并将其转换为C字符串。最后，使用NewStringUTF函数创建一个新的jstring对象并返回。

JNI数组操作

在JNI中，可以通过以下方式操作Java数组：

1、获取数组长度：可以使用GetArrayLength函数获取Java数组的长度。该函数接受一个jarray参数，返回一个jsize类型的值表示数组的长度。

JNIEXPORT void JNICALL Java_MyClass_printArrayLength(JNIEnv *env, jobject obj, jintArray arr) {
    jsize length = env->GetArrayLength(arr);
    printf("Array length: %d\n", length);
}

2、获取数组元素：可以使用GetIntArrayElements等函数获取Java整型数组的元素。这些函数接受一个jarray参数和一个指向元素的指针，返回一个指向元素的指针。

JNIEXPORT void JNICALL Java_MyClass_printIntArray(JNIEnv *env, jobject obj, jintArray arr) {
    jint *c_arr = env->GetIntArrayElements(arr, NULL);
    jsize length = env->GetArrayLength(arr);
    for (int i = 0; i < length; i++) {
        printf("%d ", c_arr[i]);
    }
    printf("\n");
    env->ReleaseIntArrayElements(arr, c_arr, 0);
}

3、修改数组元素：可以使用SetIntArrayRegion等函数修改Java整型数组的元素。这些函数接受一个jarray参数、一个起始索引和一个指向要设置的元素的指针。

JNIEXPORT void JNICALL Java_MyClass_modifyIntArray(JNIEnv *env, jobject obj, jintArray arr) {
    jsize length = env->GetArrayLength(arr);
    jint *c_arr = new jint[length];
    env->GetIntArrayRegion(arr, 0, length, c_arr);
    for (int i = 0; i < length; i++) {
        c_arr[i] += 1;
    }
    env->SetIntArrayRegion(arr, 0, length, c_arr);
    delete[] c_arr;
}

4、创建新数组：可以使用NewIntArray等函数在JNI中创建新的Java数组。这些函数接受一个jsize参数表示数组的长度，并返回一个jarray类型的值。

JNIEXPORT jintArray JNICALL Java_MyClass_createIntArray(JNIEnv *env, jobject obj, jint length) {
    jintArray arr = env->NewIntArray(length);
    return arr;
}

通过以上方法，就可以在JNI中对Java数组进行操作，包括获取数组长度、获取和修改数组元素，以及创建新数组。

JNI字符串操作

在JNI中，可以使用以下方法来操作Java字符串：

1、获取字符串内容：可以使用GetStringUTFChars函数获取Java字符串的UTF-8格式的字符数组。该函数接受一个jstring参数和一个指向字符数组的指针，返回一个指向字符数组的指针。

JNIEXPORT void JNICALL Java_MyClass_printString(JNIEnv *env, jobject obj, jstring str) {
    const char *c_str = env->GetStringUTFChars(str, NULL);
    if (c_str != NULL) {
        printf("%s\n", c_str);
        env->ReleaseStringUTFChars(str, c_str);
    }
}

2、创建新字符串：可以使用NewStringUTF函数在JNI中创建新的Java字符串。该函数接受一个指向UTF-8格式的字符数组的指针，并返回一个jstring类型的值。

JNIEXPORT jstring JNICALL Java_MyClass_createString(JNIEnv *env, jobject obj) {
    const char *c_str = "Hello, JNI!";
    jstring str = env->NewStringUTF(c_str);
    return str;
}

3、获取字符串长度：可以使用GetStringUTFLength函数获取Java字符串的UTF-8格式的长度。该函数接受一个jstring参数，返回一个jsize类型的值表示字符串的长度。

JNIEXPORT void JNICALL Java_MyClass_printStringLength(JNIEnv *env, jobject obj, jstring str) {
    jsize length = env->GetStringUTFLength(str);
    printf("String length: %d\n", length);
}

4、修改字符串内容：JNI中的字符串是不可变的，无法直接修改。如果需要修改字符串内容，可以先将字符串转换为可修改的字符数组，然后再将修改后的字符数组转换回字符串。

JNIEXPORT jstring JNICALL Java_MyClass_modifyString(JNIEnv *env, jobject obj, jstring str) {
    const char *c_str = env->GetStringUTFChars(str, NULL);
    if (c_str != NULL) {
        // 修改字符数组
        char *modified_str = new char[strlen(c_str) + 1];
        strcpy(modified_str, c_str);
        strcat(modified_str, " (modified)");

        // 将修改后的字符数组转换为字符串
        jstring modified_jstr = env->NewStringUTF(modified_str);

        // 释放原始字符数组和修改后的字符数组
        env->ReleaseStringUTFChars(str, c_str);
        delete[] modified_str;

        return modified_jstr;
    }
    return NULL;
}

通过以上方法，可以在JNI中对Java字符串进行操作，包括获取字符串内容、创建新字符串、获取字符串长度和修改字符串内容。

JNI异常处理

在JNI中处理异常的方法如下：

1、检查是否发生异常：可以使用ExceptionCheck函数来检查当前JNI环境中是否有未处理的异常。该函数返回一个jboolean类型的值，如果有未处理的异常，则返回JNI_TRUE；否则返回JNI_FALSE。

if (env->ExceptionCheck()) {
    // 处理异常
}

2、获取异常信息：可以使用ExceptionOccurred函数来获取当前JNI环境中的异常对象。该函数返回一个jthrowable类型的值，表示异常对象。如果没有异常发生，该函数返回NULL。

jthrowable exception = env->ExceptionOccurred();
if (exception != NULL) {
    // 处理异常
}

3、清除异常：可以使用ExceptionClear函数来清除当前JNI环境中的异常。该函数将清除当前JNI环境中的异常状态，使得后续的JNI调用不会受到之前的异常影响。

env->ExceptionClear();

4、抛出异常：可以使用ThrowNew函数来在JNI中抛出一个Java异常。该函数接受一个jclass参数表示异常类，一个字符串参数表示异常消息。

jclass exceptionClass = env->FindClass("java/lang/Exception");
env->ThrowNew(exceptionClass, "An exception occurred");

通过以上方法，可以在JNI中处理异常，包括检查是否发生异常、获取异常信息、清除异常和抛出异常。在JNI中处理异常非常重要，可以保证JNI调用的稳定性和可靠性。

JNI性能优化

在JNI中进行性能优化可以从以下几个方面入手：

1. 减少JNI调用次数：JNI调用涉及Java和Native之间的上下文切换，开销较大。可以通过减少JNI调用次数来提高性能。例如，可以将多个操作合并为一个JNI调用，减少Java和Native之间的切换。

2. 使用原生数据类型：JNI支持原生数据类型的传递，使用原生数据类型可以避免数据类型的转换和拷贝，提高性能。例如，可以使用jint代替Integer，jfloat代替Float。

3. 使用本地数组：JNI支持本地数组，可以在Native中直接操作本地数组，避免数据的拷贝和转换。可以使用GetArrayElements和ReleaseArrayElements函数来访问本地数组。

4. 缓存对象和方法：在JNI中，获取对象和方法的引用是比较耗时的操作。可以将对象和方法的引用缓存起来，在需要使用时直接使用缓存的引用，避免重复获取。

5. 避免频繁的JNI调用：如果在Native中需要频繁地调用Java方法，可以考虑将相关的数据传递给Native，然后在Native中进行处理，减少JNI调用的次数。

6. 使用JNI的高级特性：JNI提供了一些高级特性，如直接访问Java对象的成员变量和调用Java对象的方法。使用这些特性可以避免通过JNI调用Java方法，提高性能。

7. 使用本地线程：在JNI中，可以创建本地线程来执行一些耗时的操作，避免阻塞Java线程，提高性能。

8. 避免内存泄漏：在JNI中，需要手动管理内存。需要确保在不使用的时候及时释放JNI分配的内存，避免内存泄漏。

小结：JNI中进行性能优化，提高JNI调用的效率和性能。需要根据具体的场景和需求来选择合适的优化方法。

JNI调试技巧

在JNI调试过程中，可以使用以下技巧来定位和解决问题：

1. 使用日志输出：在JNI代码中添加日志输出语句，可以打印出关键信息，帮助定位问题。可以使用`__android_log_print`函数来输出日志，该函数类似于C语言中的`printf`函数。

2. 使用调试器：可以使用调试器来逐步执行JNI代码，并观察变量的值和程序的执行流程。常用的调试器有GDB和LLDB。可以在Android Studio中配置和使用调试器，或者使用命令行工具进行调试。

3. 使用断言：在JNI代码中添加断言语句，可以验证某些条件是否满足。如果断言失败，程序会中断，并打印出相应的错误信息。可以使用`assert`宏来添加断言。

4. 检查返回值：在JNI调用Java方法或JNI函数时，需要检查返回值，确保操作成功。如果返回值为NULL或其他错误码，可以根据返回值进行相应的处理。

5. 检查异常：在JNI调用Java方法后，需要检查是否发生了异常。可以使用`ExceptionCheck`函数或`ExceptionOccurred`函数来检查是否有未处理的异常。如果有异常，可以使用`ExceptionDescribe`函数来打印异常信息。

6. 分析堆栈：在JNI代码中可以使用`GetStackTrace`函数来获取当前线程的堆栈信息。可以打印堆栈信息，帮助定位问题。

7. 使用调试工具：可以使用一些专门的JNI调试工具来辅助调试，例如Intel VTune和Android NDK Profiler。这些工具可以提供更详细的性能分析和调试信息。

JNI最佳实践

以下是一些JNI的最佳实践：

1. 尽量减少JNI调用的次数：JNI调用涉及Java和Native之间的上下文切换和数据转换，开销较大。因此，尽量减少JNI调用的次数，可以提高性能。

2. 使用原生数据类型：JNI支持原生数据类型的传递，使用原生数据类型可以避免数据类型的转换和拷贝，提高性能。例如，可以使用jint代替Integer，jfloat代替Float。

3. 使用本地数组：JNI支持本地数组，可以在Native中直接操作本地数组，避免数据的拷贝和转换。可以使用GetArrayElements和ReleaseArrayElements函数来访问本地数组。

4. 缓存对象和方法：在JNI中，获取对象和方法的引用是比较耗时的操作。可以将对象和方法的引用缓存起来，在需要使用时直接使用缓存的引用，避免重复获取。

5. 避免频繁的JNI调用：如果在Native中需要频繁地调用Java方法，可以考虑将相关的数据传递给Native，然后在Native中进行处理，减少JNI调用的次数。

6. 使用JNI的高级特性：JNI提供了一些高级特性，如直接访问Java对象的成员变量和调用Java对象的方法。使用这些特性可以避免通过JNI调用Java方法，提高性能。

7. 使用本地线程：在JNI中，可以创建本地线程来执行一些耗时的操作，避免阻塞Java线程，提高性能。

8. 避免内存泄漏：在JNI中，需要手动管理内存。需要确保在不使用的时候及时释放JNI分配的内存，避免内存泄漏。

9. 错误处理和异常处理：在JNI中，需要正确处理错误和异常，以避免程序崩溃或出现未定义的行为。可以使用错误码或异常来进行错误处理和异常处理。

10. 进行性能优化：可以使用一些性能分析工具来分析JNI的性能瓶颈，并进行相应的优化。例如，可以使用Intel VTune和Android NDK Profiler等工具。

通过以上最佳实践，可以在JNI中提高性能和效率，并减少潜在的问题和错误。需要根据具体的场景和需求来选择合适的最佳实践。