JNI开发_jni静态注册和动态注册-CSDN博客

本文链接：https://blog.csdn.net/qq_34358193/article/details/140570051

1、静态与动态注册

JNI（Java Native Interface）是Java平台提供的一种机制，允许Java代码与其他语言编写的应用程序或库（如C或C++）进行交互。在JNI开发中，注册本地（native）方法是必要的步骤，以便Java代码能够调用这些本地方法。JNI支持两种注册方法：静态注册和动态注册。

一、静态注册

1. 定义

静态注册是指按照JNI规范书写函数名，将本地方法的名称和实现直接映射到Java类的静态方法。这种注册方式在编译时就确定了Java方法与本地方法的对应关系。

2. 命名规则

静态注册的函数名遵循特定的命名约定，即Java_包名_类名_方法名（包名中的.替换为_）。例如，对于com.example.MyClass类中的myMethod方法，其对应的本地方法名应为Java_com_example_MyClass_myMethod。

3. 示例

// Java代码
public class MyClass {
    static {
        System.loadLibrary("mylib"); // 加载本地库
    }

    public native void myMethod(); // 声明native方法
}

// C/C++代码
extern "C" JNIEXPORT void JNICALL
Java_com_example_MyClass_myMethod(JNIEnv *env, jobject obj) {
    // 实现myMethod方法
}

4. 优缺点

优点：实现简单，无需编写额外的JNI注册代码。
缺点：灵活性差，一旦Java类的包名或类名发生变化，需要同时修改C/C++代码中的函数名。

二、动态注册

1. 定义

动态注册是指在Java代码中使用JNI提供的一组API（如RegisterNatives）在运行时动态地将本地方法与Java类的实例方法绑定。这种方式允许在程序运行时根据需要注册本地方法。

2. 实现流程

定义JNINativeMethod结构体数组，记录Java方法与本地方法的对应关系。
实现JNI_OnLoad方法，在加载动态库时执行动态注册。
在JNI_OnLoad方法中，调用FindClass获取Java类对象，然后调用RegisterNatives将本地方法注册到JVM中。

3. 示例

// C/C++代码
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/MyClass");
    if (cls == NULL) {
        return JNI_ERR;
    }

    static const JNINativeMethod methods[] = {
        {"myMethod", "()V", (void *)myMethod}
    };

    if ((*env)->RegisterNatives(env, cls, methods, sizeof(methods) / sizeof(methods[0])) < 0) {
        return JNI_ERR;
    }

    return JNI_VERSION_1_6;
}

extern "C" void myMethod(JNIEnv *env, jobject obj) {
    // 实现myMethod方法
}

4. 优缺点

优点：灵活性高，可以在运行时动态地添加或删除本地方法，而无需重新编译Java或C/C++代码。
缺点：实现相对复杂，需要编写额外的JNI注册代码，并且在性能上可能略逊于静态注册（因为涉及到运行时动态查找和绑定）。

总结

静态注册和动态注册各有优缺点，开发者应根据具体需求选择合适的方法。在大多数情况下，如果本地方法的数量和类型相对稳定，且对性能要求较高，可以选择静态注册。如果需要更高的灵活性或动态加载本地库，则可以选择动态注册。

2、如何在Java中动态注册本地方法

在Java的JNI（Java Native Interface）中，通常所说的“动态注册”并不直接指在Java代码运行时动态地改变或添加已经编译好的Java类中的native方法。JNI中的动态注册通常指的是在JNI库被加载时（即JNI_OnLoad函数被调用时），通过RegisterNatives函数将C/C++中实现的本地方法与Java中的native方法声明进行绑定。

然而，这种“动态”是在库加载时发生的，而不是在Java程序运行时随时发生的。一旦库被加载并注册了native方法，这些方法就固定下来了，除非库被卸载并重新加载。

以下是如何在JNI中实现动态注册的步骤：

1. 定义Java类中的native方法

首先，在Java类中定义native方法，并加载包含native方法实现的库。

public class NativeLib {
    static {
        System.loadLibrary("mylib"); // 加载名为libmylib.so或mylib.dll的库
    }

    // 声明native方法
    public native void myNativeMethod();
}

2. 实现JNI函数JNI_OnLoad

在C/C++代码中，实现JNI_OnLoad函数。这个函数在库被加载时由JVM调用。

#include <jni.h>
#include "NativeLib.h" // 假设这个头文件是由javah工具生成的，或者手动编写

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;
    }

    // 获取Java类
    cls = (*env)->FindClass(env, "NativeLib");
    if (cls == NULL) {
        return JNI_ERR;
    }

    // 准备JNINativeMethod结构体数组
    static const JNINativeMethod methods[] = {
        {"myNativeMethod", "()V", (void *)myNativeMethodImplementation}
    };

    // 注册native方法
    if ((*env)->RegisterNatives(env, cls, methods, sizeof(methods) / sizeof(methods[0])) < 0) {
        return JNI_ERR;
    }

    // 返回JNI版本
    return JNI_VERSION_1_6;
}

// 实现native方法
JNIEXPORT void JNICALL myNativeMethodImplementation(JNIEnv *env, jobject obj) {
    // 本地方法的实现
}

3. 编译和链接C/C++代码

将C/C++代码编译成动态链接库（DLL或.so文件），并确保库名与Java代码中System.loadLibrary调用中指定的名称相匹配。

4. 运行Java程序

当Java程序运行时，它会加载指定的JNI库，并调用JNI_OnLoad函数。在JNI_OnLoad函数中，通过RegisterNatives函数将C/C++中实现的本地方法与Java中的native方法声明进行绑定。

注意事项

确保JNI库与Java应用程序的体系结构和操作系统平台相匹配。
在调用RegisterNatives之前，必须确保已经通过FindClass找到了对应的Java类。
JNI_OnLoad函数返回一个整数，表示JNI的版本号。如果返回JNI_ERR，则JNI库将不会被加载。
JNI编程需要谨慎处理内存管理和异常处理，因为C/C++和Java在这些方面的处理方式有很大不同。

3、如何在Java中调用本地方法

在Java中调用本地方法（即使用其他编程语言如C或C++编写的方法）通常涉及到Java Native Interface (JNI)。JNI是Java平台的一部分，它提供了一套标准的API，允许Java代码和其他语言编写的应用程序或库进行交互。

以下是调用本地方法的基本步骤：

1. 定义Java中的native方法

首先，你需要在Java类中声明一个或多个native方法。这些方法没有方法体，只是作为占位符，告诉JVM这个方法将在其他地方（即本地代码中）实现。

public class NativeMethods {
    // 加载包含本地方法实现的库
    static {
        System.loadLibrary("nativeLib"); // 假设库名为"nativeLib"
    }

    // 声明native方法
    public native void myNativeMethod();
}

注意：System.loadLibrary("nativeLib");这行代码加载了名为libnativeLib.so（在Linux/Mac上）或nativeLib.dll（在Windows上）的本地库。库文件的名称根据平台和命名约定可能会有所不同。

2. 实现本地方法

接下来，你需要在C或C++中实现这个native方法。实现时，需要遵循JNI的命名规则和函数签名。

#include <jni.h>
#include "NativeMethods.h" // 这通常是由javah工具自动生成的

JNIEXPORT void JNICALL Java_NativeMethods_myNativeMethod
  (JNIEnv *env, jobject obj) {
    // 实现本地方法的逻辑
    printf("Hello from native code!\n");
}

注意：

JNIEXPORT 和 JNICALL 是宏，用于确保方法能够正确地从本地代码导出到Java代码中。
Java_NativeMethods_myNativeMethod 是按照JNI的命名规则来命名的。
JNIEnv 指针 (env) 用于访问JNI函数。
jobject 是指向调用该方法的Java对象的指针（如果是静态方法，则为jclass）。

3. 编译和链接本地代码

将你的C或C++代码编译成动态链接库（DLL或.so文件）。这通常涉及到使用适当的编译器（如gcc或clang）和链接器选项。

4. 在Java中调用native方法

一旦你的Java代码加载了包含native方法实现的库，你就可以像调用任何其他Java方法一样调用这些方法了。

public class Main {
    public static void main(String[] args) {
        NativeMethods nm = new NativeMethods();
        nm.myNativeMethod(); // 调用native方法
    }
}

5. 注意事项

确保JNI库与你的Java应用程序的体系结构（如32位或64位）和操作系统平台相匹配。
JNI编程需要谨慎处理内存管理和异常处理，因为C/C++和Java在这些方面的处理方式有很大不同。
使用JNI可能会引入额外的性能开销，因为它涉及到Java和本地代码之间的转换。

以上就是在Java中调用本地方法的基本步骤。通过JNI，Java应用程序可以访问底层系统资源，执行高效的系统级操作，或与其他语言编写的库进行交互。

4、JNI开发的方法签名

在JNI（Java Native Interface）开发中，方法签名（Method Signature）的概念与在Java内部有所不同，因为JNI需要一种方式来在Java和本地代码（如C或C++）之间映射方法。JNI使用了一种特殊的字符串格式来描述方法的签名，这个字符串包含了方法的返回类型、参数类型以及参数的数量和顺序。

JNI方法签名用于FindClass、GetMethodID、GetFieldID等JNI函数中，以便JNI库能够准确地找到和调用Java中的方法或访问Java对象中的字段。

JNI方法签名遵循以下规则：

所有的类型都用字符来表示。
基本数据类型（如int、boolean等）和对象类型（如Ljava/lang/String;）都有各自的表示方法。
数组类型通过在类型字符前加上[来表示，多维数组则通过多个[来表示。
方法签名以(开头，以)结尾，中间是参数类型的字符表示，如果有返回类型，则在)之后加上返回类型的字符表示。

以下是一些JNI方法签名的例子：

一个无参数、返回void的方法的签名是()V。
一个接受一个int参数并返回void的方法的签名是(I)V，其中I代表int。
一个返回String对象的方法，没有参数，其签名是()Ljava/lang/String;。
一个接受一个String参数和一个int参数，返回boolean的方法的签名是(Ljava/lang/String;I)Z，其中Z代表boolean。

在JNI中，你通常会使用GetMethodID等函数来获取一个方法的ID，这个函数需要JNI方法签名作为参数之一。例如，在C/C++代码中，你可能会这样获取一个方法的ID：

#include <jni.h>

JNIEXPORT void JNICALL Java_MyClass_myNativeMethod(JNIEnv *env, jobject obj) {
    jclass cls = (*env)->GetObjectClass(env, obj);
    jmethodID mid = (*env)->GetMethodID(env, cls, "myJavaMethod", "(ILjava/lang/String;)Z");
    if (mid == NULL) {
        // 处理错误：未找到方法
    }
    // 现在可以使用mid来调用Java中的myJavaMethod方法
}

在这个例子中，GetMethodID函数试图找到名为myJavaMethod、接受一个int和一个String参数、并返回一个boolean值的方法的ID。如果找到了这个方法，GetMethodID将返回一个非NULL的jmethodID；否则，它将返回NULL，表示没有找到匹配的方法。

4、与Java通信

JNI（Java Native Interface）是Java提供的一种机制，用于在Java和本地C/C++代码之间进行通信。以下是JNI与Java通信的详细过程：

一、JNI与Java通信的基本步骤

编写Java代码：

在Java代码中声明本地方法（native method），使用native关键字。这些方法将在本地C/C++代码中实现。

例如：

public class MyJavaClass {
    // 声明本地方法
    public native void myNativeMethod();

    // 其他Java代码
    public static void main(String[] args) {
        new MyJavaClass().myNativeMethod();
    }

    // 加载本地库
    static {
        System.loadLibrary("myNativeLibrary");
    }
}

生成JNI头文件：
- 使用Java JDK提供的javah命令行工具（注意：从JDK 10开始，javah工具已被废弃，其功能已集成到javac中，但通常可以通过javac命令和-h选项来生成头文件）。
- 命令示例（对于旧版本JDK）：javah -jni MyJavaClass。
- 这将生成一个包含本地方法声明的头文件（如MyJavaClass.h），该文件包含了本地方法实现的函数签名。
实现本地方法：
- 在C/C++代码中，包含JNI头文件（如jni.h和自动生成的MyJavaClass.h）。
- 实现本地方法。方法名必须与JNI头文件中声明的名称完全匹配。
- 例如：
```
#include <jni.h>
#include "MyJavaClass.h"

JNIEXPORT void JNICALL Java_MyJavaClass_myNativeMethod(JNIEnv *env, jobject obj) {
    // 实现本地方法的代码
}
```
编译C/C++代码为动态链接库：
- 使用C/C++编译器（如gcc或g++）将C/C++代码编译为动态链接库（如.dll文件在Windows上，.so文件在Linux上）。
- 编译过程取决于使用的编译器和操作系统。
在Java代码中加载本地库：
- 在Java代码中，使用System.loadLibrary()方法加载动态链接库。库名不包括平台特定的前缀和后缀（如lib和.so、.dll）。
运行Java程序：
- 运行Java程序时，当调用本地方法时，Java虚拟机（JVM）将调用相应的本地代码实现。

二、JNI与Java通信的注意事项

内存管理：
- JNI涉及到Java和本地代码的交互，需要仔细处理内存管理，避免内存泄漏或数据损坏的问题。
数据类型转换：
- Java和C/C++的数据类型不完全相同，JNI提供了相应的转换机制。在编写本地代码时，需要了解如何转换这些数据类型。
性能考虑：
- JNI的开销相对较大，因为涉及到Java和本地代码之间的上下文切换。在设计时需要考虑性能方面的因素。
错误处理：
- 在本地代码中，需要适当地处理错误情况，并将错误信息传递给Java层。
平台依赖性：
- 使用JNI编写的代码可能具有平台依赖性，因为不同的操作系统和硬件平台可能需要不同的编译和链接选项。

通过以上步骤和注意事项，可以实现JNI与Java之间的有效通信。这种机制使得Java程序能够利用本地代码的性能优势，同时保持Java平台的可移植性和安全性。

5、本地引用与全局引用

在JNI（Java Native Interface）中，本地引用（Local Reference）和全局引用（Global Reference）是两种不同类型的引用，它们用于在本地代码（如C/C++）中管理和访问Java对象。

本地引用（Local Reference）

本地引用是JNI中最常见的引用类型。它通常是在调用JNI函数时创建的，比如GetObjectClass、GetMethodID、NewObject等，并且只在创建它的本地方法执行期间有效。一旦本地方法执行完毕返回Java层，所有的本地引用都会自动失效并被垃圾回收器回收，除非它们被转换成了全局引用。

本地引用的一个主要限制是它们的作用域局限于创建它们的本地方法调用。这意味着你不能在一个本地方法中创建一个本地引用，然后在另一个本地方法中访问它，除非你将其转换为全局引用。