发布于 由admin

Java JNI：Java Native Interface

好的，各位观众，各位朋友，各位正在与Java代码“相爱相杀”的程序员们，大家好！我是你们的老朋友，人称“代码界的段子手”，今天咱们来聊聊Java世界里一个有点神秘，又不得不学的家伙——JNI！

开场白：Java的“异地恋”？

想象一下，你是一位Java程序员，手握着一把锋利的Java语言利剑，所向披靡。但是，有一天，你突然发现，有些事情Java搞不定，或者效率太低，比如，直接操作硬件，或者调用一些历史悠久的C/C++库。这个时候，你就像谈了一场“异地恋”，明明很想在一起，却隔着千山万水。

JNI（Java Native Interface）就是这座桥梁，连接着Java世界和Native世界（通常指C/C++）。它允许Java代码调用Native代码，也允许Native代码反过来调用Java代码。这就像给Java程序员插上了一双翅膀，让你的Java程序拥有了无限可能！🚀

第一章：JNI是什么？—— “跨界合作”的秘密武器

JNI，全称Java Native Interface，翻译过来就是“Java本地接口”。它本质上是一个协议，一套规范，定义了Java虚拟机（JVM）如何与Native代码进行交互。

1.1 JNI的诞生：历史的必然

Java最初的设计理念是“Write Once, Run Anywhere”，但是，理想很丰满，现实很骨感。有些底层操作，Java天生不擅长，比如：

  • 性能瓶颈： 有些计算密集型任务，Java的解释执行效率较低，不如编译型的C/C++。
  • 硬件交互： Java无法直接访问操作系统底层API，比如串口、USB等。
  • 遗留代码： 很多优秀的C/C++库已经存在，重新用Java实现成本太高。

JNI的出现，就是为了解决这些问题，让Java程序可以充分利用Native代码的优势，扬长避短。

1.2 JNI的工作原理：一座精密的“翻译器”

JNI的工作原理可以简单概括为以下几个步骤：

  1. Java代码声明Native方法： 在Java类中，使用native关键字声明一个方法，告诉JVM这个方法是用Native代码实现的。
  2. 生成Native方法头文件： 使用javah工具（JDK自带）根据Java类生成C/C++头文件，头文件中包含了Native方法的函数签名。
  3. 实现Native方法： 使用C/C++语言编写Native方法的实现代码，遵循头文件中定义的函数签名。
  4. 编译Native代码： 将C/C++代码编译成动态链接库（Windows下是.dll，Linux下是.so，macOS下是.dylib）。
  5. Java代码加载动态链接库： 在Java代码中使用System.loadLibrary()或System.load()方法加载动态链接库。
  6. Java代码调用Native方法： Java代码像调用普通Java方法一样调用Native方法，JVM会自动找到对应的Native代码执行。

这个过程就像一个精密的“翻译器”，Java代码把请求翻译成Native代码可以理解的语言，Native代码执行完毕后，再把结果翻译回Java代码可以理解的语言。

1.3 JNI的优势与劣势：一把双刃剑

JNI就像一把双刃剑，用得好可以事半功倍，用不好可能会伤到自己。

优势 劣势
提升性能，解决性能瓶颈 增加代码复杂性，调试难度大
访问底层硬件和操作系统API 平台依赖性强，需要针对不同平台编译Native代码
重用现有的C/C++代码 安全性风险，Native代码可能存在内存泄漏等问题
可以实现一些Java无法实现的功能 学习成本高，需要同时掌握Java和C/C++

第二章：JNI实战：从“Hello, World!”开始

理论讲得再多，不如动手实践一下。咱们从一个简单的“Hello, World!”例子开始，一步一步揭开JNI的神秘面纱。

2.1 准备工作：磨刀不误砍柴工

  • JDK： 确保你已经安装了JDK，并且配置好了环境变量。
  • C/C++编译器： 你需要一个C/C++编译器，比如GCC（Linux）、MinGW（Windows）、Clang（macOS）。
  • 开发工具： 选择你喜欢的IDE，比如Eclipse、IntelliJ IDEA、Visual Studio等。

2.2 创建Java类：定义你的“需求”

创建一个名为HelloJNI.java的Java类，代码如下：

public class HelloJNI {
    // 声明Native方法
    public native String sayHello();

    // 加载动态链接库
    static {
        System.loadLibrary("hello"); // hello是动态链接库的名字，去掉lib前缀和.so/.dll/.dylib后缀
    }

    public static void main(String[] args) {
        HelloJNI helloJNI = new HelloJNI();
        String result = helloJNI.sayHello();
        System.out.println(result);
    }
}

代码解释：

  • native String sayHello();：使用native关键字声明了一个名为sayHello()的Native方法，它返回一个字符串。
  • System.loadLibrary("hello");：加载名为hello的动态链接库。注意，这里只需要写库的名字，不需要写完整的文件名和后缀。

2.3 生成Native方法头文件：生成“翻译规范”

打开命令行，进入HelloJNI.java所在的目录，执行以下命令：

javah HelloJNI

这条命令会生成一个名为HelloJNI.h的头文件，它包含了sayHello()方法的函数签名。

2.4 实现Native方法：编写“翻译内容”

创建一个名为HelloJNI.c的C文件，代码如下：

#include <jni.h>
#include "HelloJNI.h"

JNIEXPORT jstring JNICALL Java_HelloJNI_sayHello(JNIEnv *env, jobject obj) {
    return (*env)->NewStringUTF(env, "Hello, World! From Native Code!");
}

代码解释：

  • #include <jni.h>：包含JNI头文件，它定义了JNI相关的函数和数据类型。
  • #include "HelloJNI.h"：包含生成的头文件，它定义了sayHello()方法的函数签名。
  • JNIEXPORT jstring JNICALL Java_HelloJNI_sayHello(JNIEnv *env, jobject obj)：这是sayHello()方法的C实现。
    • JNIEXPORT和JNICALL是JNI的宏，用于声明函数的可见性和调用约定。
    • JNIEnv *env：指向JNI环境的指针，可以通过它调用JNI提供的函数。
    • jobject obj：指向Java对象的指针，可以通过它访问Java对象的属性和方法。
    • (*env)->NewStringUTF(env, "Hello, World! From Native Code!");：调用JNI提供的NewStringUTF()函数创建一个Java字符串，并返回。

2.5 编译Native代码：打包“翻译内容”

使用C/C++编译器将HelloJNI.c编译成动态链接库。

  • Windows (MinGW):

    gcc -I"%JAVA_HOME%include" -I"%JAVA_HOME%includewin32" -Wl,--add-stdcall-alias -shared -o hello.dll HelloJNI.c

  • Linux (GCC):

    gcc -I"$JAVA_HOME/include" -I"$JAVA_HOME/include/linux" -shared -fPIC -o libhello.so HelloJNI.c

  • macOS (Clang):

    clang -I"$JAVA_HOME/include" -I"$JAVA_HOME/include/darwin" -shared -o libhello.dylib HelloJNI.c

注意：

  • -I选项用于指定头文件的搜索路径，%JAVA_HOME%或$JAVA_HOME是JDK的安装目录。
  • -shared选项用于生成动态链接库。
  • -fPIC选项用于生成位置无关代码（Position Independent Code），Linux下必须加上这个选项。
  • Windows下需要加上-Wl,--add-stdcall-alias选项，否则可能会出现找不到函数的问题。
  • Linux和macOS下动态链接库的名字需要以lib开头。

2.6 运行Java代码：见证“跨界合作”的奇迹

将生成的动态链接库（hello.dll、libhello.so或libhello.dylib）放到Java程序的运行目录下，或者添加到系统的环境变量中。然后，运行HelloJNI.java，你将会看到以下输出：

Hello, World! From Native Code!

恭喜你，你已经成功地完成了你的第一个JNI程序！🎉

第三章：JNI进阶：掌握更多“跨界技能”

学会了“Hello, World!”，只是JNI之旅的开始。接下来，咱们来学习一些更高级的JNI技巧。

3.1 数据类型映射：理解“语言差异”

Java和C/C++的数据类型是不同的，JNI定义了一套数据类型映射规则，用于在Java和Native代码之间传递数据。

Java类型 JNI类型 C/C++类型 说明
boolean jboolean unsigned char
byte jbyte char
char jchar unsigned short
short jshort short
int jint int
long jlong long long
float jfloat float
double jdouble double
void void void
String jstring JNI提供了NewStringUTF()和GetStringUTFChars()等函数用于创建和访问Java字符串。
Object jobject 所有Java对象的基类。
Class jclass 代表Java类。
Throwable jthrowable 代表Java异常。
boolean[] jbooleanArray JNI提供了GetBooleanArrayElements()和ReleaseBooleanArrayElements()等函数用于访问Java数组。
byte[] jbyteArray JNI提供了GetByteArrayElements()和ReleaseByteArrayElements()等函数用于访问Java数组。
char[] jcharArray JNI提供了GetCharArrayElements()和ReleaseCharArrayElements()等函数用于访问Java数组。
short[] jshortArray JNI提供了GetShortArrayElements()和ReleaseShortArrayElements()等函数用于访问Java数组。
int[] jintArray JNI提供了GetIntArrayElements()和ReleaseIntArrayElements()等函数用于访问Java数组。
long[] jlongArray JNI提供了GetLongArrayElements()和ReleaseLongArrayElements()等函数用于访问Java数组。
float[] jfloatArray JNI提供了GetFloatArrayElements()和ReleaseFloatArrayElements()等函数用于访问Java数组。
double[] jdoubleArray JNI提供了GetDoubleArrayElements()和ReleaseDoubleArrayElements()等函数用于访问Java数组。
Object[] jobjectArray JNI提供了GetObjectArrayElement()和SetObjectArrayElement()等函数用于访问Java数组。

3.2 访问Java对象的属性和方法：深入“内部”

JNI允许Native代码访问Java对象的属性和方法，这为Native代码提供了更大的灵活性。

  • 获取类的引用： 使用FindClass()函数获取Java类的引用。
  • 获取字段的ID： 使用GetFieldID()函数获取Java字段的ID。
  • 获取方法的ID： 使用GetMethodID()函数获取Java方法的ID。
  • 访问字段的值： 使用Get<Type>Field()和Set<Type>Field()函数访问Java字段的值，其中<Type>是字段的类型，比如Int、Float、Object等。
  • 调用方法： 使用Call<Type>Method()函数调用Java方法，其中<Type>是方法的返回类型，比如Int、Float、Object、Void等。

3.3 异常处理：确保“安全”

Native代码可能会抛出异常，JNI提供了一套机制来处理这些异常。

  • 检查异常： 使用ExceptionCheck()函数检查是否有异常发生。
  • 获取异常信息： 使用ExceptionOccurred()函数获取异常对象。
  • 清除异常： 使用ExceptionClear()函数清除异常。
  • 抛出异常： 使用ThrowNew()函数抛出一个新的Java异常。

3.4 内存管理：避免“灾难”

Native代码需要手动管理内存，JNI提供了一些函数来分配和释放内存。

  • 分配内存： 使用malloc()函数分配内存。
  • 释放内存： 使用free()函数释放内存。

注意： 在Native代码中分配的内存，必须在Native代码中释放，否则会造成内存泄漏。

第四章：JNI最佳实践：成为“大师”

掌握了JNI的基本知识和技巧，还需要遵循一些最佳实践，才能写出高质量的JNI代码。

  • 尽量减少JNI的调用次数： JNI调用有一定的开销，尽量将多个操作合并成一个JNI调用。
  • 避免在Native代码中长时间持有Java对象的引用： 这可能会导致Java对象无法被垃圾回收。
  • 使用本地引用（Local Reference）和全局引用（Global Reference）： 本地引用只在当前函数有效，全局引用可以跨函数使用。
  • 注意线程安全： JNI方法可能会被多个线程同时调用，需要保证线程安全。
  • 编写清晰的注释： JNI代码通常比较复杂，编写清晰的注释可以提高代码的可读性和可维护性。

总结：JNI，不止是“跨界合作”

JNI不仅仅是一种技术，更是一种思想，一种“跨界合作”的思想。它让我们意识到，不同的技术之间可以相互融合，相互补充，共同解决问题。

学习JNI，不仅可以提升你的编程技能，还可以开阔你的视野，让你在编程的世界里更加自由地翱翔！ 🦅

希望这篇文章能够帮助你理解JNI，并在你的编程生涯中发挥作用。记住，学习JNI是一个循序渐进的过程，需要不断地实践和探索。

最后，祝大家编程愉快，Bug少一点，头发多一点！😉

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注