一、学习笔记
1.java源码中的JNI函数本机方法声明必须使用native修饰。
2.相对反编译 Java 的 class 字节码文件来说，反汇编.so动态库来分析程序的逻辑要复杂得多,为了应用的安全性，会将一些复杂的逻辑和
算法通过本地代码（C或C++）来实现，然后打包成.so动态库文件
3.使用了 JNI 接口的 JAVA 程序，不再像以前那样*的跨平台。如果要实现跨平台，就必须将本地代码在不同的操作系统平台下编译出相
应的动态库。
4.JNI 开发流程主要分为以下 6 步：
(1)编写声明了 native 方法的 Java 类。
(2)将 Java 源代码编译成 class 字节码文件。
(3)用 javah -jni 命令生成.h头文件（-jni 参数表示将 class 中用native 声明的函数生成 JNI 规则的函数）。
(4)用本地代码实现.h头文件中的函数。
(5)将本地代码编译成动态库。
(6)拷贝动态库至 java.library.path 本地库搜索目录下，并运行 Java 程序。
5.JVM 查找 native 方法的两种方式：
(1)按照 JNI 规范的命名规则
(2)调用 JNI 提供的 RegisterNatives 函数，将本地函数注册到 JVM 中。
6.Native方法签名中的 JNIEXPORT 和 JNICALL 在 Linux/Unix 系统中，这两个宏可以省略不加。
7.本地实现方法的第二个参数为：如果这个 native 方法是实例方法，则该参数是 jobject，如果是静态方法，则是 jclass。
8.JNI 把 Java 中的所有对象当作一个C指针传递到本地方法中，这个指针指向 JVM 中的内部数据结构，而内部的数据结构在内存中的存储方
式是不可见的。只能从 JNIEnv 指针指向的函数表中选择合适的 JNI 函数来操作 JVM 中的数据结构。
9.JNI 的异常和 Java 中的异常处理流程是不一样的，Java 遇到异常如果没有捕获，程序会立即停止运行。而 JNI 遇到未决的异常不会改变
程序的运行流程，也就是程序会继续往下走。
10.字符串操作
(1)GetStringChars/GetStringUTFChars和ReleaseStringChars/ReleaseStringUTFChars
用于获取和释放以 Unicode/UTF-8 格式编码的字符串。后者是用于释放。
(2)GetStringLength/GetStringUTFLength
由于 UTF-8 编码的字符串以'\0'结尾(也可以使用strlen获取长度)，而 Unicode 字符串不是。上面函数获取字符串长度。
(3)GetStringCritical和ReleaseStringCritical
提高 JVM 返回源字符串直接指针的可能性，但是获取和释放之间是不能阻塞的也不能调用其它JNI函数。因为获取这个直接指针后会导致暂停
GC(垃圾回收) 线程，当 GC 被暂停后，如果其它线程触发 GC 继续运行的话，都会导致被阻塞。
(4)GetStringRegion和GetStringUTFRegion
分别表示获取 Unicode 和 UTF-8 编码字符串指定范围内的内容到一个预先分配好的缓冲区中，这个函数不会分配内存，因此也没有释放的函数。
11.JNI 中的数组分为基本类型数组和对象数组，它们的处理方式是不一样的，基本类型数组中的所有元素都是 JNI 的基本数据类型，可以直
接访问。而对象数组中的所有元素是一个类的实例或其它数组的引用，和字符串操作一样，不能直接访问 Java 传递给 JNI 层的数组，必须选
择合适的 JNI 函数来访问和设置 Java 层的数组对象。
12.GC 会实时扫描所有创建的对象是否还有引用，如果没有引用则会立即清理掉。当我们创建一个像 int 数组对象的时候，当我们在本地代码
想去访问时，发现这个对象正被 GC 线程占用了，这时本地代码会一直处于阻塞状态，直到等待 GC 释放这个对象的锁之后才能继续访问。为了
避免这种现象的发生，JNI 提供了 Get/ReleasePrimitiveArrayCritical 这对函数，本地代码在访问数组对象时会暂停 GC 线程。同样这两个函
数之间不能阻塞或调用其它JNI函数
13.在 JNI 中，只有 jobject 以及子类属于引用变量，会占用引用表的空间，jint，jfloat，jboolean 等都是基本类型变量，不会占用引用
表空间，即不需要释放。引用表最大空间为 512 个，如果超出这个范围，JVM 就会挂掉。
14.本地代码调用 Java 层某个对象的方法或属性，这就是来自 C/C++层本地函数的 callback（回调）。
15.引用类型统一调用CallStaticObjectMethod 函数.(不存在CallStaticStringMethod)。
16.GetMethodID/GetStaticMethodID 和 CallIntMethod/CallStaticIntMethod 和 SetIntField/SetStaticIntField，对应static和非static成员方法的调用函数不同。
17.JNI方法签名的格式为：(形参参数类型列表)返回值。形参参数列表中，引用类型以 L 开头，后面紧跟类的全路径名（需将.全部替换成/），
以分号结尾。
18.GetMethodID()返回的jmethodID应该不是引用，不需要对它调用DeleteLocalRef()。
19.调用 GetMethodID 获取方法 ID 和调用 FindClass 获取 Class 实例后，要做异常判断
20.在 Java 中任何一个类的.class字节码文件被加载到内存中之后，该class子节码文件统一使用 Class 类来表示该类的一个引用（相当于
Java 中所有类的基类是 Object一样）。然后就可以从该类的 Class 引用中动态的获取类中的任意方法和属性。
21.在本地代码中可以调用 JNI 函数可以访问 Java 对象中的非 public(eg private) 属性和方法。
22.由于 ID 对于特定类是相同的，因此只需要查找一次，然后便可重复使用。同样，查找类对象的开销也很大，因此也应该缓存它们。
23.class 和 member id 在一定范围内是稳定的，但在动态加载的 class loader 下，保存全局的 class 要么可能失效，要么可能造成无法卸载classloader。
24.(*env)->FindClass()返回的jclass类型的变量是local referenced的，不能被缓存，因为一次JNI调用返回后它引用的已经回收了，下次在
调用JNI函数时出问题。
25.方法ID和域ID应该是可以缓存的(它不是引用，而且是稳定存在的)。
26.如果在用使用时缓存的 ID，要注意只要本地代码依赖于这个 ID 的值，那么这个类就不会被 unload。另外一方面，如果缓存发生在静态初
始化时，当类被 unload 或 reload 时，ID 会被重新计算。因此，尽量在类静态初始化时就缓存字段 ID、方法 ID。
27.有两种域ID的缓存方法：
静态缓存：在静态代码块中调用JNI native函数缓存。
使用时缓存：就是在正常调用native函数时进行缓存。
28.三种引用介绍
(1)局部引用：
通过 NewLocalRef() 和各种 JNI 接口创建（FindClass、NewObject、GetObjectClass和NewCharArray等）。LocalRef 会阻止 GC 回收所引用
的对象。JNI函数返回后局部引用所引用的对象会被 JVM 自动释放，或在JNI函数中调用 DeleteLocalRef 释放。(*env)->DeleteLocalRef(env,local_ref)
局部引用只有在创建它的本地方法返回前有效，本地方法返回到 Java 层之后，如果 Java 层没有对return的局部引用使用的话，局部引用就会被
JVM 自动释放。在JNI函数中将局部引用存储在静态变量中缓存起来，供下次调用时使用是错误的。
JNI 会将创建的局部引用都存储在一个局部引用表中，如果这个表超过了最大容量限制，就会造成局部引用表溢出，使程序崩溃。经测试，Android 上的
JNI 局部引用表最大数量是 512 个。不用时注意及时调用DeleteLocalRef().
JNI 提供了一系列函数来管理局部引用的生命周期。这些函数包括：EnsureLocalCapacity、NewLocalRef、PushLocalFrame、PopLocalFrame、DeleteLocalRef。
局部引用不能跨线程使用，只在创建它的线程有效。不要试图在一个线程中创建局部引用并存储到全局引用中，然后在另外一个线程中使用。
(2)全局引用：
调用 NewGlobalRef() 基于局部引用创建，会阻止 GC 回收所引用的对象。可以跨方法、跨线程使用。JVM 不会自动释放，必须调用 DeleteGlobalRef() 手
动释放。(*env)->DeleteGlobalRef(env, g_cls_string)
只能通过 NewGlobalRef 函数创建全局引用。
(3)弱全局引用:
调用 NewWeakGlobalRef() 基于局部引用或全局引用创建，不会阻止 GC 回收所引用的对象，可以跨方法、跨线程使用。引用不会自动释放，在 JVM 认为应
该回收它的时候（比如内存紧张的时候）进行回收而被释放。或调用DeleteWeakGlobalRef() 手动释放。(*env)->DeleteWeakGlobalRef(env,g_cls_string)
29.在管理局部引用的生命周期中，Push/PopLocalFrame 是非常方便且安全的。我们可以在本地函数的入口处调用PushLocalFrame，然后在出口处调用
PopLocalFrame，这样的话，在函数内任何位置创建的局部引用都会被释放。而且，这两个函数是非常高效的，强烈建议使用它们。需要注意的是，
如果在函数的入口处调用了PushLocalFrame，记住要在函数所有出口（有 return 语句出现的地方）都要调用 PopLocalFrame。
30.JNI函数签名
JNIEXPORT void JNICALL Java_HelloWorld_print(JNIEnv *, jobject); //这两个宏可以忽略
JNIEnv：JNIEnv接口指针指向包含指向函数表的指针的位置。函数表中的每个条目都指向一个JNI函数。本机方法始终通过其中一个JNI函数访问Java虚拟机中的数据结构。
jobject：是对HelloWorld对象本身的引用（有点像C ++中的“this”指针），若是java中的静态native方法，参数二是jclass.
JNIEXPORT和JNICALL宏（在jni.h头文件中定义）确保从本机库导出此函数和C编译器生成具有此函数的正确调用约定的代码。
在/usr/lib/jvm/java-1.7.0-openjdk-amd64/include/jni_md.h中(jni.h中包含它)：
#define JNIEXPORT __attribute__((visibility("default")))
#define JNICALL //空宏
31.编译本地方法
$ gcc -fPIC -shared HelloWorld.c -o libHelloWorld.so -I /usr/lib/jvm/java-1.7.0-openjdk-amd64/include/
5.运行
$ export LD_LIBRARY_PATH=./ 或 setenv LD_LIBRARY_PATH . 或 不设置环境变量运行$ java -Djava.library.path=. HelloWorld
$ java HelloWorld
32.JNI以不同方式处理原始类型(java中的8种基本类型)和引用类型; 实例方法和静态方法。
33.C和C++使用JNI的区别
从jni.h中关于__cplusplus的条件编译来看，native中的类型和JNIenv中提供的函数都是不同的！
#ifdef __cplusplus
typedef JNIEnv_ JNIEnv; //C++使用这个JNIEnv函数集合，它里面的functions域内嵌了JNINativeInterface_！
#else
typedef const struct JNINativeInterface_ *JNIEnv; //C使用这个JNIEnv函数集合
#endif
二、试验Demo
1.互传基本类型测试
/* hello_world.c */
#include <jni.h>
#include <stdio.h>
#include "com_study_jnilearn_HelloWorld.h" JNIEXPORT jint JNICALL Java_com_study_jnilearn_HelloWorld_test
(JNIEnv *env, jclass cls, jshort s, jint i, jlong l, jfloat f, jdouble d, jchar c, jboolean z, jbyte b)
{
jint ret = ; printf("C: s=%hd, i=%d, l=%ld, f=%f, d=%lf, c=%c, z=%d, b=%d\n", s, i, l, f, d, c, z, b); return ret;
}
/* HelloWorld.java */
package com.study.jnilearn; public class HelloWorld { public static native int test(short s, int i, long l, float f, double d, char c, boolean z, byte b); public static void main(String[] args) {
short s = 1;
long l = 20;
byte b = 127;
int ret;
ret = test(s, 1, l, 1.0f, 10.5, 'A', true, b);
System.out.println("java: ret=" + ret);
} static {
System.loadLibrary("hello_world");
}
}
编译：
$ javac HelloWorld.java -d ./
$ javah -jni com.study.jnilearn.HelloWorld
$ gcc -shared -fPIC hello_world.c -I /usr/lib/jvm/java-1.7.-openjdk-amd64/include/ -o libhello_world.so
运行：
$ java com.study.jnilearn.HelloWorld
C: s=, i=, l=, f=1.000000, d=10.500000, c=A, z=, b=
java: ret=
2.互传String类型测试
/* StringTest.java */
package com.study.jnilearn; public class StringTest { public native static String sayHello(String text); public static void main(String[] args) {
System.out.println("Java send: Hello, I am Java");
String text = sayHello("Hello, I am Java");
System.out.println("Java get: " + text);
} static {
System.loadLibrary("string_test");
}
}
/* string_test.c */
#include <stdio.h>
#include <jni.h> JNIEXPORT jstring JNICALL Java_com_study_jnilearn_StringTest_sayHello
(JNIEnv *env, jclass cls, jstring j_str)
{
const char *str_get = NULL;
const char *str_send = "Hello I am C";
jboolean isCopy; //返回JNI_TRUE表示原字符串的拷贝，返回JNI_FALSE表示返回原字符串的指针 str_get = (*env)->GetStringUTFChars(env, j_str, &isCopy);
if(str_get == NULL) {
return NULL;
}
printf("C get: %s, isCopy=%d\n", str_get, isCopy);
(*env)->ReleaseStringUTFChars(env, j_str, str_get); printf("C send: %s\n", str_send);
return (*env)->NewStringUTF(env, str_send);
}
编译：
$ javac StringTest.java -d ./
$ javah -jni com.study.jnilearn.StringTest
$ gcc -shared -fPIC string_test.c -I /usr/lib/jvm/java-1.7.-openjdk-amd64/include/ -o libstring_test.so
运行：
$ java com.study.jnilearn.StringTest
Java send: Hello, I am Java
C get: Hello, I am Java, isCopy=
C send: Hello I am C
Java get: Hello I am C
3.基本类型数组类型双向传参
/*IntArray.java*/
class IntArray { private native int[] sortArray(int[] arr); public static void main(String[] args) {
IntArray obj = new IntArray();
int arr1[] = new int[10]; for (int i = 0; i < 10; i++) {
arr1[i] = i;
} int arr2[] = obj.sortArray(arr1); for (int i = 0; i < 10; i++) {
System.out.print(arr2[i] + " ");
}
System.out.println("");
} static {
System.loadLibrary("IntArray");
}
}
/* IntArray.c */
#include <jni.h>
#include <stdio.h>
#include <string.h>
#include "IntArray.h" void arr_short(jint *arr, jint num) {
jint i, j, tmp; for (i = ; i < num; i++) {
for (j = i; j < num; j++) {
if (arr[i] < arr[j]) {
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
}
} JNIEXPORT jintArray JNICALL Java_IntArray_sortArray
(JNIEnv *env, jobject obj, jintArray jarr)
{
jint *array, length;
jint buff[] = {};
array = (*env)->GetIntArrayElements(env, jarr, NULL);
if (array == NULL) {
return ; /* exception occurred */
}
length = (*env)->GetArrayLength(env, jarr);
memcpy(buff, array, length * sizeof(jint));
(*env)->ReleaseIntArrayElements(env, jarr, array, ); /*不能直接传jarr然后返回jarr，因为其是一个local reference, native调用后就被回收了*/
arr_short(buff, length); jintArray new_arr = (*env)->NewIntArray(env, length);
(*env)->SetIntArrayRegion(env, new_arr, , length, buff); return new_arr;
}
编译：
$ javac IntArray.java
$ javah -jni IntArray
$ gcc -shared -fPIC IntArray.c -I /usr/lib/jvm/java-1.7.-openjdk-amd64/include/ -o libIntArray.so
运行：
$ java IntArray
4.JNI函数中回调类的静态方法和实例方法
/* AccessMethod.java */
package com.study.jnilearn; class ClassMethod { private static int javaStaticCallback(String str, int i) {
int ret = 1;
System.out.format("Java: javaStaticCallback: str=%s " + " i=%d\n", str, i);
return ret;
} private int javaInstanceCallback(String str, int i) {
int ret = 2;
System.out.format("Java: javaInstanceCallback: str=%s " + "i=%d\n", str, i);
return ret;
}
} public class AccessMethod { public static native int javaStaticMethod();
public static native int javaInstaceMethod(); public static void main(String[] args) {
int ret1, ret2;
ret1 = javaStaticMethod();
ret2 = javaInstaceMethod();
System.out.println("ret1=" + ret1 + " ret2=" + ret2);
} static {
System.loadLibrary("AccessMethod");
}
}
/* AccessMethod.c */
#include <stdio.h>
#include "com_study_jnilearn_AccessMethod.h" JNIEXPORT jint JNICALL Java_com_study_jnilearn_AccessMethod_javaStaticMethod(JNIEnv *env, jclass cls)
{
jclass clazz = NULL;
jstring str_arg = NULL;
jmethodID method_id;
jint ret = ; // 1、从classpath路径下搜索ClassMethod这个类，并返回该类的Class对象
clazz =(*env)->FindClass(env, "com/study/jnilearn/ClassMethod");
if (clazz == NULL) {
printf("Couldn't find class: com/study/jnilearn/ClassMethod");
return;
} // 2、从clazz类中查找javaStaticCallback方法
method_id = (*env)->GetStaticMethodID(env, clazz, "javaStaticCallback", "(Ljava/lang/String;I)I");
if (method_id == NULL) {
printf("Couldn't find method: javaStaticCallback");
return;
} // 3、调用clazz类的callStaticMethod静态方法
str_arg = (*env)->NewStringUTF(env, "C: str pass to java static method");
ret = (*env)->CallStaticIntMethod(env, clazz, method_id, str_arg, ); // 4.删除局部引用
(*env)->DeleteLocalRef(env, clazz);
(*env)->DeleteLocalRef(env, str_arg); // id is not reference,needn't to delete return ret;
} JNIEXPORT jint JNICALL Java_com_study_jnilearn_AccessMethod_javaInstaceMethod(JNIEnv *env, jclass cls)
{
jclass clazz = NULL;
jobject jobj = NULL;
jmethodID mid_construct = NULL;
jmethodID mid_instance = NULL;
jstring str_arg = NULL;
jint ret = ; // 1、从classpath路径下搜索ClassMethod这个类，并返回该类的Class对象
clazz = (*env)->FindClass(env, "com/study/jnilearn/ClassMethod");
if (clazz == NULL) {
printf("Couldn't find class: com/study/jnilearn/ClassMethod");
return;
} // 2、获取类的默认构造方法ID
mid_construct = (*env)->GetMethodID(env,clazz, "<init>", "()V");
if (mid_construct == NULL) {
printf("Couldn't find construct method");
return;
} // 3、查找实例方法的ID
mid_instance = (*env)->GetMethodID(env, clazz, "javaInstanceCallback", "(Ljava/lang/String;I)I");
if (mid_instance == NULL) {
return;
} // 4、创建该类的实例
jobj = (*env)->NewObject(env, clazz, mid_construct);
if (jobj == NULL) {
printf("Couldn't create new object");
return;
} // 5、调用对象的实例方法
str_arg = (*env)->NewStringUTF(env, "C: str pass to java instance method");
ret = (*env)->CallIntMethod(env, jobj, mid_instance, str_arg, ); // 删除局部引用
(*env)->DeleteLocalRef(env, clazz);
(*env)->DeleteLocalRef(env, jobj);
(*env)->DeleteLocalRef(env, str_arg); return ret;
}
编译：
$ javac AccessMethod.java -d ./
$ javah -jni com.study.jnilearn.AccessMethod
$ gcc -shared -fPIC AccessMethod.c -I /usr/lib/jvm/java-1.7.-openjdk-amd64/include/ -o libAccessMethod.so
运行：
$ java com.study.jnilearn.AccessMethod
Java: javaStaticCallback: str=C: str pass to java static method i=
Java: javaInstanceCallback: str=C: str pass to java instance method i=
ret1= ret2=
5.JNI函数中使用静态和非静态成员属性
/* AccessField.java */
package com.study.jnilearn; class ClassField { private static int num;
private String str; public int getNum() {
return num;
} public void setNum(int num) {
this.num = num;
} public String getStr() {
return str;
} public void setStr(String str) {
this.str = str;
}
} public class AccessField { private native static void accessInstanceField(ClassField obj); private native static void accessStaticField(); public static void main(String[] args) {
ClassField obj = new ClassField();
obj.setNum(10);
obj.setStr("Hello"); // 本地代码访问和修改ClassField为中的静态属性num
accessStaticField();
accessInstanceField(obj); System.out.println("Java: ClassField.num = " + obj.getNum());
System.out.println("Java: ClassField.str = " + obj.getStr());
} static {
System.loadLibrary("AccessField");
}
}
#include "com_study_jnilearn_AccessField.h" JNIEXPORT void JNICALL Java_com_study_jnilearn_AccessField_accessInstanceField
(JNIEnv *env, jclass cls, jobject obj)
{
jclass clazz;
jfieldID fid;
jstring j_str;
jstring j_newStr;
const char *c_str = NULL; // 1.获取AccessField类的Class引用
clazz = (*env)->GetObjectClass(env, obj);
if (clazz == NULL) {
return;
} // 2. 获取AccessField类实例变量str的属性ID
fid = (*env)->GetFieldID(env, clazz, "str", "Ljava/lang/String;");
if (clazz == NULL) {
return;
} // 3. 获取实例变量str的值
j_str = (jstring)(*env)->GetObjectField(env, obj, fid); // 4. 将unicode编码的java字符串转换成C风格字符串
c_str = (*env)->GetStringUTFChars(env, j_str, NULL);
if (c_str == NULL) {
return;
}
printf("C: ClassField.str = %s\n", c_str);
(*env)->ReleaseStringUTFChars(env, j_str, c_str); // 5. 修改实例变量str的值
j_newStr = (*env)->NewStringUTF(env, "World");
if (j_newStr == NULL) {
return;
} (*env)->SetObjectField(env, obj, fid, j_newStr); // 6.删除局部引用
(*env)->DeleteLocalRef(env, clazz);
(*env)->DeleteLocalRef(env, j_str);
(*env)->DeleteLocalRef(env, j_newStr);
} JNIEXPORT void JNICALL Java_com_study_jnilearn_AccessField_accessStaticField
(JNIEnv *env, jclass cls)
{
jclass clazz;
jfieldID fid;
jint num; // 1.获取ClassField类的Class引用
clazz = (*env)->FindClass(env, "com/study/jnilearn/ClassField");
if (clazz == NULL) {
return;
} // 2.获取ClassField类静态变量num的属性ID
fid = (*env)->GetStaticFieldID(env, clazz, "num", "I");
if (fid == NULL) {
return;
} // 3.获取静态变量num的值
num = (*env)->GetStaticIntField(env, clazz, fid);
printf("C: ClassField.num = %d\n", num); // 4.修改静态变量num的值
(*env)->SetStaticIntField(env, clazz, fid, ); // 删除属部引用
(*env)->DeleteLocalRef(env, clazz);
}
编译：
$ javac AccessField.java -d ./
$ javah -jni com.study.jnilearn.AccessField
$ gcc -shared -fPIC AccessField.c -I /usr/lib/jvm/java-1.7.-openjdk-amd64/include/ -o libAccessField.so
运行：
$ java com.study.jnilearn.AccessField
C: ClassField.num =
C: ClassField.str = Hello
Java: ClassField.num =
Java: ClassField.str = World
6.优化：类静态初始化缓存
/* AccessCache.java */
public class AccessCache { public static native void initIDs(); public native void nativeMethod();
public void callback() {
System.out.println("Java: AccessCache.callback invoked!");
} public static void main(String[] args) {
AccessCache accessCache = new AccessCache();
accessCache.nativeMethod();
} static {
System.loadLibrary("AccessCache");
initIDs();
}
}
#include <stdio.h>
#include "AccessCache.h" jmethodID MID_AccessCache_callback; JNIEXPORT void JNICALL Java_AccessCache_initIDs(JNIEnv *env, jclass cls)
{
printf("initIDs called!\n");
MID_AccessCache_callback = (*env)->GetMethodID(env, cls, "callback", "()V");
} JNIEXPORT void JNICALL Java_AccessCache_nativeMethod(JNIEnv *env, jobject obj)
{
printf("C: call java's callback()\n");
(*env)->CallVoidMethod(env, obj, MID_AccessCache_callback);
}
编译：
javac AccessCache.java
javah -jni AccessCache
$ gcc -shared -fPIC AccessCache.c -I /usr/lib/jvm/java-1.7.-openjdk-amd64/include/ -o libAccessCache.so
运行：
$ java AccessCache
initIDs called!
C: call java's callback()
Java: AccessCache.callback invoked!
jni.pdf翻译总结版：http://wiki.jikexueyuan.com/project/jni-ndk-developer-guide/recommend.html