Android JNI机制概述

Android JNI（Java Native Interface）机制是Android系统中一个非常重要的技术，它允许Java代码与本地C/C++代码进行交互。以下是对Android JNI机制的详细介绍。

一、JNI概述

1.1. 定义与作用

JNI是Java Native Interface的缩写，即“Java本地调用”，它提供了一种机制，允许Java代码与其他语言（尤其是C和C++）编写的应用程序或库进行交互。这种机制使得Java程序能够调用本地应用程序或库中的函数，这些本地方法通常用于执行与硬件直接交互、性能要求较高的任务，如图形处理、音频处理等。同时也允许本地代码调用Java层的函数，从而增强了Java程序的灵活性和扩展性。

1.2. 背景与原因

Android系统划分为Native（本地）和Java两部分的原因可以归结为以下几点.

1. 性能需求

• Native代码的性能优势：Native代码（主要是C/C++编写的）通常比Java代码更接近硬件，因此能够提供更高的执行效率和性能。这对于需要高性能处理的应用场景（如图像处理、视频编码解码、游戏等）尤为重要。
• Java虚拟机的性能开销：Java代码在运行时需要通过Java虚拟机（JVM）进行解释执行或即时编译（JIT），这会增加一定的性能开销。而Native代码则直接由操作系统执行，减少了这一层开销。

2. 历史遗留和复用

• 历史原因：在Java诞生之前，已经有很多程序和库是用Native语言编写的。这些程序和库在Android系统或其他平台上已经得到了广泛的应用和验证，因此重用这些资源是非常必要的。
• 复用现有库：Native语言编写的库往往具有更好的性能和稳定性，且经过长时间的优化和更新。Android系统通过JNI（Java Native Interface）桥接Java和Native代码，可以方便地复用这些现有的Native库，从而避免重复开发。

3. 跨平台与平台特定功能的平衡

• Java的跨平台性：Java语言的一个主要优势是跨平台性，即“一次编写，到处运行”。这使得Java代码可以在不同的操作系统和硬件平台上运行，而无需进行大量的修改。
• Native代码的平台依赖性：然而，某些平台特定的功能（如直接访问硬件资源、操作系统级别的优化等）可能需要通过Native代码来实现。因此，将Android系统划分为Java和Native两部分，可以在保持Java跨平台性的同时，利用Native代码实现平台特定的功能。

4. 开发效率和灵活性的考虑

• Java的开发效率：Java语言具有简洁的语法、丰富的类库和强大的开发工具支持，这使得Java成为Android应用开发的主要语言。使用Java可以提高开发效率，缩短开发周期。
• Native代码的灵活性：对于需要高性能或平台特定功能的场景，Native代码提供了更高的灵活性和控制力。开发者可以根据需要选择使用Java或Native代码来实现特定的功能。

二、JNI的作用

Android JNI（Java Native Interface）在Android开发中扮演着至关重要的角色，其作用主要体现在以下几个方面。

1. 扩展Java功能： JNI允许Java代码调用用C或C++编写的本地方法（Native Methods）。由于Java语言本身可能无法直接支持某些特定的功能或优化，比如直接与硬件交互、执行复杂的数学运算、使用已有的C/C++库等，通过JNI，Java程序可以扩展其功能，利用C/C++的强大能力。
2. 提高性能：上面有讲到。
3. 复用现有代码： 在Android开发过程中，经常需要复用已有的C/C++代码库，比如开源的图像处理库、加密算法库等。JNI提供了一种机制，使得这些用C/C++编写的代码库可以被Java代码直接调用，从而避免了重复造轮子，提高了开发效率。
4. 保护代码安全： 将关键算法或逻辑实现在C/C++代码中，并通过JNI暴露给Java层调用，可以在一定程度上增加代码的安全性。因为C/C++代码相对较难被逆向工程破解，所以这种方式可以保护应用的核心技术和商业机密。
5. 实现系统级功能： 在Android系统中，许多系统级的功能和服务都是通过JNI来实现的。例如，Android的图形渲染系统Skia、音频处理系统OpenSL ES等，都是基于JNI与本地C/C++代码进行交互的。通过JNI，Android应用可以访问和控制系统级的功能和服务。
6. 跨平台开发： 虽然JNI主要用于Java与C/C++之间的交互，但它也间接支持了跨平台开发。因为C/C++代码具有较好的可移植性，所以通过JNI编写的本地方法可以在不同的操作系统和硬件平台上运行，从而实现了Android应用的跨平台开发。

然而，需要注意的是，JNI的使用也带来了一些挑战和限制。例如，JNI调用涉及Java和C/C++之间的上下文切换，可能会引入额外的性能开销；JNI编程相对复杂，需要开发者具备较高的C/C++编程能力；以及JNI调用中容易出现内存泄漏等问题。因此，在决定是否使用JNI时，需要权衡其利弊，并根据具体的应用场景和需求来做出决策。

三、JNI的使用方法

Android JNI（Java Native Interface）的使用方法主要包括以下几个步骤。

3.1. 在Java中声明Native方法

首先，在Java类中声明需要使用JNI调用的本地方法（Native Methods）。这些方法的声明与普通Java方法相似，但需要使用native关键字进行标记。例如：

public class JniTest {  
    static {  
        System.loadLibrary("jni_test"); // 加载动态库  
    }  
  
    public native String get(); // 声明本地方法  
    public native void set(String str);  
  
    public static void main(String[] args) {  
        JniTest jniTest = new JniTest();  
        System.out.println(jniTest.get()); // 调用本地方法  
        jniTest.set("Hello JNI");  
    }  
}

3.2. 加载本地库

在Java类中，使用System.loadLibrary("库名")来加载本地库（动态链接库，如.so文件在Android上）。库名不需要前缀lib和后缀.so，但实际的库文件名需要是lib库名.so。

3.3. 生成JNI头文件

接下来，需要生成JNI头文件。这通常可以通过Java编译器（javac）和javah工具（在JDK 10及以后版本中，javah已被废弃，但可以通过javac的-h选项来生成）完成。生成的头文件中会包含本地方法的签名，这些签名是C/C++代码中实现这些本地方法时所需的。

例如，使用javac -h . JniTest.java（假设当前目录是源文件的目录）来生成头文件。

3.4. 实现Native方法（编写C/C++代码）

在C/C++代码中，根据JNI头文件中的方法签名来实现相应的本地方法。这包括处理JNI接口指针（JNIEnv*），访问Java层的对象和数据，以及执行具体的操作。

#include "JniTest.h" // 包含JNI头文件  
#include <jni.h>  
  
JNIEXPORT jstring JNICALL Java_JniTest_get(JNIEnv *env, jobject obj) {  
    return (*env)->NewStringUTF(env, "Hello from JNI");  
}  
  
JNIEXPORT void JNICALL Java_JniTest_set(JNIEnv *env, jobject obj, jstring str) {  
    // 处理字符串str，例如打印输出  
    const char *cStr = (*env)->GetStringUTFChars(env, str, 0);  
    printf("Received string: %s\n", cStr);  
    (*env)->ReleaseStringUTFChars(env, str, cStr);  
}

3.5. 编译和链接本地代码

将C/C++代码编译成动态链接库（.so文件），并确保它在Android应用的可执行文件中被正确链接和加载。这通常涉及到使用NDK（Native Development Kit）进行编译和构建。

3.6. 在Android项目中配置JNI

在Android Studio项目中，你需要在build.gradle文件中配置NDK和CMake（或ndk-build），以支持JNI开发。同时，确保你的C/C++源文件放置在正确的目录下（如src/main/cpp），并且已经正确配置了CMakeLists.txt文件。

3.7. 运行和测试

构建并运行你的Android应用，测试JNI调用的功能是否按预期工作。注意处理可能出现的JNI异常和错误，并确保Java层和Native层之间的交互是安全和稳定的。

四、JNI方法注册

JNI（Java Native Interface）方法注册建立了Java层方法和本地层函数之间的映射关系。JNI方法注册主要有两种方式：静态注册和动态注册。这两种注册方式各有优缺点，适用于不同的开发场景和需求。

4.1. 静态注册

1. 定义

静态注册是指通过编译器自动生成JNI方法的注册信息，并将这些信息注册到JNI环境中。在Android开发中，这通常是通过编写包含native声明的Java类，并使用javah（在JDK 10及以后版本中已被废弃，但可通过javac -h命令替代）或Android Studio的自动工具生成对应的JNI头文件，然后在C/C++代码中实现这些native方法，并遵循特定的命名规则来让JNI环境自动识别并注册这些方法。

2. 实现原理

静态注册通过函数命名约定来建立Java方法和JNI函数之间的一一对应关系。JNI函数名通常遵循“Java_”+包名（全路径，使用下划线“_”替换点“.”）+类名+方法名的规则。

3. 实现过程

• 编写Java代码：在Java中声明native方法。
• 编译Java代码：使用javac编译Java类，并生成.class文件。
• 生成JNI头文件（可选，但通常使用IDE自动生成）：使用javah（注意：在JDK 10及以后版本中，javah已被废弃，IDE通常会自动处理这部分工作）或IDE的内置功能，根据.class文件生成JNI的.h头文件。该头文件中包含了Java方法在JNI层的声明。
• 实现JNI函数：在C或C++文件中实现JNI函数，函数名需遵循上述命名规则。
• 生成动态链接库：编译C/C++代码生成动态链接库（.so文件）。
• 加载库：在Java中使用System.loadLibrary方法加载包含JNI函数的本地库（.so或.dll文件）。

4. 优点

• 理解和使用方式简单，属于傻瓜式操作，出错率低。
• 使用相关工具按流程操作即可，不需要编写额外的注册代码。

5. 缺点

• 当需要更改类名、包名或方法时，需要按照之前的方法重新生成头文件，灵活性不高。
• 方法名通常较长，包含完整的包名、类名和方法名，可读性较差。

6. 示例

假设我们有一个Java类com.example.MyNativeClass，其中包含一个native方法sayHello。

Java代码 (MyNativeClass.java):

package com.example;  
  
public class MyNativeClass {  
    // 声明native方法  
    public native void sayHello();  
  
    // 加载包含native方法实现的库  
    static {  
        System.loadLibrary("mynativelib");  
    }  
}

C/C++代码 (mynativelib.c):

#include <jni.h>  
#include "com_example_MyNativeClass.h" // 注意：这个头文件是由javah或IDE自动生成的  
  
// 实现JNI函数，注意函数名遵循静态注册的命名规则  
JNIEXPORT void JNICALL Java_com_example_MyNativeClass_sayHello(JNIEnv *env, jobject obj) {  
    printf("Hello from C!\n");  
}

注意：在上面的C代码中，com_example_MyNativeClass.h是通过javah（或IDE的相应功能）根据MyNativeClass.class文件自动生成的JNI头文件。然而，从JDK 10开始，javah工具已被废弃，但大多数IDE（如Android Studio）都提供了自动生成JNI头文件的功能。

4.2. 动态注册

1. 定义

动态注册是指在JNI_OnLoad函数中，通过调用JNI提供的RegisterNatives方法来手动注册Java层与C/C++层之间的方法映射关系。这种方式需要开发者在C/C++代码中编写注册逻辑，并显式地指定哪些Java native方法对应哪些C/C++函数。

2. 原理 动态注册通过调用JNI的RegisterNatives函数来显式地将Java方法和JNI函数绑定起来，而不是通过函数命名约定。

3. 实现过程

• 编写Java代码：在Java中声明native方法。
• 实现JNI函数：在C或C++文件中实现JNI函数，函数名可以自定义，无需遵循静态注册的命名规则。
• 定义JNINativeMethod数组：在C或C++代码中定义一个JNINativeMethod数组，该数组的每个元素包含Java方法名、方法签名和对应的JNI函数指针。
• 实现JNI_OnLoad函数：在本地代码中实现JNI_OnLoad函数，该函数在库被加载时由JVM调用。在JNI_OnLoad函数中，调用RegisterNatives函数将JNINativeMethod数组中的元素注册到JVM中。
• 生成动态链接库：编译C/C++代码生成动态链接库（.so文件）。
• 加载库：在Java中使用System.loadLibrary方法加载包含JNI函数的本地库。

4. 优点

• 灵活性高，当需要更改类名、包名或方法时，只需对更改模块进行少量修改，不需要重新生成头文件。
• 可以动态地根据需要注册方法，提高了代码的灵活性和可维护性。

5. 缺点

• 对新手来说稍微有点难理解，需要掌握JNI的注册机制和RegisterNatives方法的使用。
• 如果注册信息有误（如类名、方法名或签名错误），可能导致注册失败，进而影响应用的正常运行。

6. 示例

Java代码 (MyNativeClass.java) 与静态注册示例相同。

C/C++代码 (mynativelib.c):

#include <jni.h>  
#include "com_example_MyNativeClass.h" // 假设这个头文件存在，但通常不需要静态注册的头文件  
  
// 自定义的JNI函数名  
JNIEXPORT void JNICALL customSayHello(JNIEnv *env, jobject obj) {  
    printf("Hello from C (dynamic registration)!\n");  
}  
  
// JNINativeMethod数组，用于动态注册  
static JNINativeMethod methods[] = {  
    {"sayHello", "()V", (void *)customSayHello}  
};  
  
// JNI_OnLoad函数，用于在库加载时注册native方法  
JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved) {  
    JNIEnv *env;  
    jclass cls;  
  
    if ((*vm)->GetEnv(vm, (void **)&env, JNI_VERSION_1_6) != JNI_OK) {  
        return JNI_ERR;  
    }  
  
    cls = (*env)->FindClass(env, "com/example/MyNativeClass");  
    if (cls == NULL) {  
        return JNI_ERR;  
    }  
  
    if ((*env)->RegisterNatives(env, cls, methods, sizeof(methods) / sizeof(methods[0])) < 0) {  
        return JNI_ERR;  
    }  
  
    return JNI_VERSION_1_6;  
}

注意：在动态注册中，我们不需要（也不应该）包含由javah或IDE生成的JNI头文件，因为我们没有遵循静态注册的命名规则。相反，我们定义了一个JNINativeMethod数组，并在JNI_OnLoad函数中将其注册到JVM中。

此外，请注意，在动态注册示例中，我假设了com_example_MyNativeClass.h头文件的存在，但在实际动态注册场景中，通常不需要这个头文件。我保留它只是为了说明如果已经有了一个静态注册的头文件，可以忽略它并直接进行动态注册。

最后，请确保本地库（在这个例子中是mynativelib）已经正确编译并链接到Java应用程序中。在Android项目中，这通常意味着将.so文件放置在正确的libs或jniLibs目录下。

4.3.总结

静态注册和动态注册各有优缺点，开发者应根据具体需求和场景选择合适的注册方式。在大多数NDK开发场景中，静态注册因其简单性和易用性而更为常见；而在需要高度灵活性和动态性的场景中，动态注册则更具优势。

五、JNI的优缺点

优点：

• 提高了Java程序的性能，特别是在需要执行大量计算或调用系统级功能时。
• 允许重用现有的Native代码和库，减少了重复开发的工作量。
• 增加了Java程序的灵活性和可扩展性。

缺点：

• JNI编程相对复杂，需要掌握Java和C/C++两种语言的语法和特性。
• JNI调用可能引入额外的性能开销和内存管理问题。
• JNI编程时需要注意类型匹配、错误处理和内存泄漏等问题，以避免程序崩溃和不稳定。

六、总结

Android JNI机制为Java代码与C/C++代码之间的交互提供了强有力的支持。通过JNI，Java程序可以充分利用C/C++在性能、硬件控制等方面的优势，从而开发出功能更加强大、性能更加优异的Android应用。同时，JNI也是Android系统架构中不可或缺的一部分，它使得Android系统能够兼容并充分利用现有的C/C++代码库和库资源。