深入浅出 - Android系统移植与平台开发（十二）- Android JNI机制
第五章、JNI机制
4.1 JNI概述
由前面基础知识可知，Android的应用层由Java语言编写，Framework框架层则是由Java代码与C/C++语言实现，之所以由两种不同的语言组合开发框架层，是因为Java代码是与硬件环境彻底“隔离”的跨平台语言，Java代码无法直接操作硬件。比如：Android系统支持大量传感器，Java运行在虚拟机中，无法直接得到传感器数据，而Android系统基于Linux操作系统，在Linux操作系统中C/C++通过Linux提供的系统调用接口可以直接访问传感器硬件驱动，Java代码可以将自己的请求，交给底层的本地C/C++代码实现间接的对传感器的访问。另外，Java代码的执行效率要比C/C++执行效率要低，在一些对性能要求比较高的场合，也要使用C/C++来实现程序逻辑。
既然Java代码要请求本地C/C++代码，那么二者必须要通过一种媒介或桥梁联系起来，这种媒介就是Java本地接口（Java NativeInterface）,它是Java语言支持的一种本地语言访问方式，JNI提供了一系列接口，它允许Java与C/C++语言之间通过特定的方式相互调用、参数传递等交互操作。
通常在以下几种情况下考虑使用JNI：
Ø 对处理速度有要求
Java代码执行速度要比本地代码（C/C++）执行速度慢一些，如果对程序的执行速度有较高的要求，可以考虑使用C/C++编写代码，然后在通过Java代码调用基于C/C++编写的部分。
Ø 硬件控制
如前面所述，Java运行在虚拟机中，和真实运行的物理硬件之间是相互隔离的，通常我们使用本地代码C实现对硬件驱动的控制，然后再通过Java代码调用本地硬件控制代码。
Ø 复用本地代码
如果程序的处理逻辑已经由本地代码实现并封装成了库，就没有必要再重新使用Java代码实现一次，直接复用该本地代码，即提高了编程效率，又确保了程序的安全性和健壮性。
4.2 JNI原理
在计算机中，每种编程语言都有一个执行环境（Runtime），执行环境用来解释执行语言中的语句，不同的编程语言的执行环境就好比如西游记中的“阴阳两界”一样，一般人不能同时生存在阴阳两界中，只有“黑白无常”能自由穿梭在阴阳两界之间，“黑白无常”往返于阴阳两界时手持生死簿，“黑白无常”按生死簿上记录着的人名“索魂”。
4.2.1 JavaVM与JNIEnv
Java语言的执行环境是Java虚拟机（JVM)，JVM其实是主机环境中的一个进程，每个JVM虚拟机进程在本地环境中都有一个JavaVM结构体，该结构体在创建Java虚拟机时被返回，在JNI中创建JVM的函数为JNI_CreateJavaVM。
JNI_CreateJavaVM(JavaVM **pvm, void **penv, void*args);
JavaVM结构中封装了一些函数指针（或叫函数表结构），JavaVM中封装的这些函数指针主要是对JVM操作接口，如下面代码所示：
@jni.h
struct JNIInvokeInterface_ {
void *reserved0;
void *reserved1;
void *reserved2;
jint (JNICALL *DestroyJavaVM)(JavaVM *vm); // 销毁Java虚拟机并回收资源，只有JVM主线程可以销毁
jint (JNICALL *AttachCurrentThread)(JavaVM *vm,void **penv, void *args); // 连接当前线程为Java线程
jint (JNICALL *DetachCurrentThread)(JavaVM*vm); // 释放当前Java线程
jint (JNICALL *GetEnv)(JavaVM *vm, void**penv, jint version); // 获得当前线程的Java运行环境
jint (JNICALL*AttachCurrentThreadAsDaemon)(JavaVM *vm, void **penv, void *args);// 连接当前线程作为守护线程
};
struct JavaVM_ {
const struct JNIInvokeInterface_*functions;
jint DestroyJavaVM() {
returnfunctions->DestroyJavaVM(this);
}
…省略部分代码
jint GetEnv(void **penv, jintversion) {
returnfunctions->GetEnv(this, penv, version);
}
…省略部分代码
};
#ifdef __cplusplus
typedef JavaVM_ JavaVM;
#else
typedef const structJNIInvokeInterface_ *JavaVM;
#endif
通过上面代码分析可知，JNIInvokeInterface_结构封装了几个和JVM相关的功能函数，如销毁JVM，获得当前线程的Java执行环境。另外，在C和C++中JavaVM的定义有所不同，在C中JavaVM是JNIInvokeInterface_类型指针，而在C++中又对JNIInvokeInterface_进行了一次封装，比C中少了一个参数，这也是为什么JNI代码更推荐用C++来编写的原因。
JNIEnv是当前Java线程的执行环境，一个JVM对应一个JavaVM结构，而一个JVM中可能创建多个Java线程，每个线程对应一个JNIEnv结构，它们保存在线程本地存储（TLS）中。因此，不同的线程的JNIEnv是不同，也不能相互共享使用。
JNIEnv结构也是一个函数表，在本地代码中通过JNIEnv的函数表来操作Java数据或调用Java方法。也就是说，只要在本地代码中拿到了JNIEnv结构，就可以在本地代码中调用Java代码。
@jni.h中对JNIEnv的定义如下：
struct JNINativeInterface_ {
…
jclass (JNICALL*FindClass) (JNIEnv *env, const char *name);
…定义大量JNI函数指针
};
struct JNIEnv_ {
const structJNINativeInterface_ *functions;
jclass FindClass(constchar *name) {
return functions->FindClass(this, name); //调用JNINativeInterface_中的函数指针
}
…省略部分代码
};
#ifdef __cplusplus
typedef JNIEnv_ JNIEnv;
#else
typedef const structJNINativeInterface_ *JNIEnv;
#endif
由上面代码可知，和JavaVM类似，JNIEnv在C代码和C++代码中的使用方式也是不一样的，在C++中对JNINativeInterface_结构又进行了一次封装，调用起来更方便。
总体来说，JNI其实就是定义了Java语言与本地语言间的一种沟通方式，这种沟通方式依赖于JavaVM和JNIEnv结构中定义的函数表，这些函数表负责将Java中的方法调用转换成对本地语言的函数调用。
4.3 JNI中的数据传递
4.3.1 JNI基本类型
当Java代码与本地C\C++代码相互调用时，肯定会有参数数据的传递。两者属于不同的编程语言，在数据类型上有很多差别。JNI要保证它们两者之间的数据类型和数据空间大小的匹配。尽管C和Java中都拥有int和char的数据类型，但是他们的长度却不尽相同。在C语言中，int类型的长度取决与平台，char类型为1个字节，而在Java语言中，int类型恒为4字节，char类型为2字节。为了使Java语言和本地语言类型、长度匹配，JNI中定义了jint，jchar等类型，在JNI中定义了一些新的数据类型，如下表所示。
表xx-xx
Java Language Type |
JNI Type |
boolean |
jboolean |
byte |
jbyte |
char |
jchar |
short |
jshort |
int |
jint |
long |
jlong |
float |
jfloat |
double |
jdouble |
All Reference type |
jobject |
由Java类型和JNI数据类型的对应关系可以看到，这些新定义的JNI类型名称和Java类型名称具有一致性，只是在前面加了个j，如int对应jint，long对应jlong。我们可以通过JDK目录中的jni.h和jni_md.h来更直观的了解：
@ jni_md.h
…省略部分代码
typedef long jint;
typedef __int64 jlong;
typedef signed char jbyte;
…省略部分代码
@jni.h
// JNI类型与C/C++类型对应关系声明
typedef unsigned char jboolean;
typedef unsigned short jchar;
typedef short jshort;
typedef float jfloat;
typedef double jdouble;
typedef jint jsize;
由jni头文件可以看出，jint对应的是C/C++中的long类型，即32位整数，而不是C中的int类型（C中的int类型长度依赖于平台）。所以如果要在本地方法中要定义一个jint类型的数据，规范的写法应该是 jinti=123L;
再比如jchar代表的是Java类型的char类型，实际上在C/C++中却是unsigned short类型，因为Java中的char类型为两个字节，jchar相当于C/C++中的宽字符。所以如果要在本地方法中要定义一个jchar类型的数据，规范的写法应该是jcharc=L'C';
实际上，所有带j的类型，都是JNI对应的Java的类型，并且jni中的类型接口与本地代码在类型的空间大小是完全匹配的，而在语言层次却不一定相同。在本地方法中与JNI接口调用时，要在内部都要转换，我们在使用的时候也需要小心。
4.3.2 JNI引用类型
在本地代码中为了访问Java运行环境中的引用类型，在JNI中也定义了一套对应的引用类型，它们的对应关系如下：
JNI引用类型 |
Java引用类型 |
jobject |
所有引用类型父类Object |
jclass |
java.lang.Class类型 |
jstring |
java.lang.String类型 |
jarray |
数组类型 |
jobjectArray |
对象数组类型 |
jbooleanArray |
布尔数组类型 |
jbyteArray |
字节数组类型 |
jcharArray |
字符数组类型 |
jshortArray |
短整形数组类型 |
jintArray |
整形数组类型 |
jlongArray |
长整形数组类型 |
jfloatArray |
浮点数组类型 |
jdoubleArray |
双精度数组类型 |
jthrowable |
java.lang.Throwadble类型 |
由上表内容可知，JNI引用类型都是以j开头类型。与Java中所有类的父类为Object一样，所有的JNI中的引用类型都是jobject的子类，JNI这些j类型和Java中的类一一对应，只不过名字稍有不同而已。
4.4 Java访问本地方法
由4.1节可知，在某些情况下一些功能由本地代码来实现，这时Java代码需要调用这些本地代码，在调用本地代码时，首先要保证本地代码被加载到Java执行环境中并与Java代码链接在一起，这样当Java代码在调用本地方法时能保证找到并调用到正确的本地代码，然后在Java中要显示声明本地方法为native方法。其实现步骤如下：
· 编写Java代码，在Java代码中加载本地代码库
· 在Java中声明本地native方法
· 调用本地native方法
例如：
public class HelloJNI{
static{
System.loadLibrary(“hellojni”); // 通过System.loadLibrary()来加载本地代码库
}
privatestatic native String getJNIHello(); // 由于该方法的实现在本地代码中，所以加上native关键字进行声明
publicstatic void main(String args[]){
System.out.println(HelloJNI.getJNIHello()); // 调用本地方法
}
}
上述代码的执行需要本地代码库hellojni，正常运行的话会在屏幕上打印：Helloworld字符串。由代码可知，在Java中调用本地代码不是很复杂，本地代码库的加载系统方法System.loadLibrary在static静态代码块中实现的，这是因为静态代码块只会在Java类加载时被调用，并且只会被调用一次。本地代码库的名字为hellojni，如果在Windows中则其对应的文件名为：hellojni.dll，如果在Linux中，其对应的文件名为libhellojni.so。
思考：
1. 可不可以将本地代码库的加载放到构造方法中？放在非静态代码块中呢？
2. native方法可以声明为abstract类型的吗？
Native关键字本身和abstract关键字冲突，他们都是方法的声明，只是一个是把方法实现移交给子类，另一个是移交给本地代码库。如果同时出现，就相当于即把实现移交给子类，又把实现移交给本地操作系统，那到底谁来实现具体方法呢？
4.5 JNI访问Java成员
在JNI调用中，不仅仅Java可以调用本地方法，本地代码也可以调用Java中的方法和成员变量。在Java1.0中规定：Java和C本地代码绑定后，程序员可以直接访问Java对象数据域。这就要求虚拟机暴露它们之间内部数据的绑定关系，基于这个原因，JNI要求程序员通过特殊的JNI函数来获取和设置数据以及调用java方法。
Java中的类封装了属性和方法，要想访问Java中的属性和方法，首先要获得Java类或Java对象，然后再访问属性、调用方法。
在Java中类成员指静态属性和静态方法，它们属于类而不属于对象。而对象成员是指非静态属性和非静态方法，它们属于具体一个对象，不同的对象其成员是不同的。正因为如此，在本地代码中，对类成员的访问和对对象成员的访问是不同的。
在JNI中通过下面的函数来获得Java运行环境中的类。
jclass FindClass(const char *name);
name：类全名，包含包名，其实包名间隔符用“/”代替“.”
例如：
jclass jActivity = env->FindClass(“java/lang/String”);
上述JNI代码获得Android中的Activity类保存在jActivity中。
在JNI中Java对象一般都是作为参数传递给本地方法的。
例如：
Java代码：
package com.test.exam1;
class MyClass{
privateint mNumber;
privatestatic String mName;
publicMyClass(){
}
publicvoid printNum(){
System.out.println(“Number:” + mNumber);
}
publicstatic void printNm(){
System.out.println(“Number:” + mNumber);
}
}
class PassJavaObj{
static{
System.loadLibrary(“native_method”);
}
privatenative static void passObj(String str);
publicstatic void main(String arg[]){
passObj(“HelloWorld”);
}
}
本地代码：
void Java_com_test_exam1_PassJavaObj_passObj
(JNIEnv * env, jclassthiz, jobject str)
{
…
}
在上述例子中，Java代码中将“Hello World”字符串对象传递给了本地代码，在本地代码对应的方法中，共有三个参数，其中前两个参数是由Java运行环境自动传递过来的，env表示当前Java代码的运行环境，thiz表示调用当前本地方法的对象，这两个参数在每个本地方法中都有。第三个参数str就是我们传递过来的字符串。
在本地方法中拿到了类或对象后，JNI要求程序员通过特殊的JNI函数来获取和设置Java属性以及调用java方法。
4.5.1取得Java属性ID和方法ID
为了在C/C++中表示Java的属性和方法，JNI在jni.h头文件中定义了jfieldID和jmethodID类型来分别代表Java对象的属性和方法。我们在访问或是设置Java属性的时候，首先就要先在本地代码取得代表该Java属性的jfieldID，然后才能对本地代码的Java属性进行操作。同样的，我们需要调用Java方法时，也需要取得代表该方法的jmethodID才能进行Java方法调用。
使用JNIEnv提供的JNI方法，我们就可以获得属性和方法相对应的jfieldID和jmethodID：
@jni.h
// 根据属性签名返回 clazz类中的该属性ID
jfieldID GetFieldID(jclass clazz, const char*name, const char *sig);
// 如果获得静态属性ID，则调用下面的函数
jfieldID GetStaticFieldID(jclass clazz, constchar *name, const char *sig);
// 根据方法签名返回clazz类中该方法ID
jmethodID GetMethodID(jclass clazz, const char*name, const char *sig);
// 如果是静态方法，则调用下面的函数实现
jmethodID GetStaticMethodID(jclass clazz, constchar *name, const char *sig);
可以看到这四个方法的参数列表都是一模一样的，下面来分析下每个参数的含义：
· jclass clazz：要取得成员对应的类
· const char *name：代表我们要取得的方法名或者属性名
· const char *sig：代表我们要取得的方法或属性的签名
我们将一个例子进行简单修改：
package com.test.exam2;
class MyClass{
privateint mNumber;
privatestatic String mName = “Michael”;
publicMyClass(){
mNumber= 1000;
}
publicvoid printNum(){
System.out.println(“Number:” + mNumber);
}
publicstatic void printNm(){
System.out.println(“Number:” + mNumber);
}
}
class NativeCallJava{
static{
System.loadLibrary(“native_callback”);
}
privatenative static void callNative(MyClass cls);
publicstatic void main(String arg[]){
callNative(newMyClass());
}
}
本地代码：
void Java_com_test_exam2_NativeCallJava_callNative(JNIEnv* env, jclassthiz, jobject obj)
{
jclass myCls = env->GetObjectClass(obj);
jfieldIDmNumFieldID = env->GetFieldID(myCls, “mNumber”, “I”);
jfieldIDmNameFieldID = env->GetStaticFieldID(myCls, “mName”, “java/lang/String”);
jmethodIDprintNumMethodID = env->GetMethodID(myCls, “printNum”, “(V)V”);
jmethodIDprintNmMethodID = env->GetStaticMethodID(myCls, “printNm” , “(V)V”);
}
在上述Java代码中，我们自己定义了一个类MyClass，里面定义了对应的静态和非静态成员，然后将MyClass对象传递给本地代码。在本地代码中通过GetObjectClass方法取得MyClass对象对应的类，然后依次取得MyClass类中的属性ID和方法ID。
其中GetObjectClass定义如下：
jclass GetObjectClass(jobject obj) ;
jobject obj：如果本地代码拿到一个对象，则通过该方法取得该对象的类类型，其功能如同Object.getClass()方法。
4.5.2 JNI类型签名
Java语言是面向对象的语言，它支持重载机制，即：允许多个具有相同的方法名不同的方法签名的方法存在。因此，只通过方法名不能明确的让JNI找到Java里对应的方法，还需要指定方法的签名，即：参数列表和返回值类型。
JNI中类型签名如下表所示：
类型签名 |
Java类型 |
类型签名 |
Java类型 |
Z |
boolean |
[ |
[] |
B |
byte |
[I |
int[] |
C |
char |
[F |
float[] |
S |
short |
[B |
byte[] |
I |
int |
[C |
char[] |
J |
long |
[S |
short[] |
F |
float |
[D |
double[] |
D |
double |
[J |
long[] |
L |
类 |
[Z |
boolean[] |
V |
void |
|
|
· 基本类型
以特定的单个大写字母表示
· Java类类型
Java类类型以L开头，以“/”分隔包名，在类名后加上“;”分隔符，例如String的签名为：Ljava/lang/String;
在Java中数组是引用类型，数组以“[”开头，后面跟数组元素类型签名，例如：int[]的签名是[I ，对于二维数组，如int[][]签名就是[[I，object数组签名就是[Ljava/lang/Object;
对于方法签名，在JNI中也有特定的表示方式。
(参数1类型签名参数2类型签名参数3类型签名.......)返回值类型签名
注意：
· 方法名在方法签名中没有体现出来
· 括号内表示参数列表，参数列表紧密相挨，中间没有逗号，没有空格
· 返回值出现在括号后面
· 如果函数没有返回值，也要加上V类型
例如：
Java方法 |
JNI方法签名 |
boolean isLedOn(void) ; |
(V)Z |
void setLedOn(int ledNo); |
(I)V |
String substr(String str, int idx, int count); |
(Ljava/lang/String;II)Ljava/lang/String |
char fun (int n, String s, int[] value); |
(ILjava/lang/String;[I)C |
boolean showMsg(android.View v, String msg); |
(Landroid/View;Ljava/lang/String;)Z |
4.5.3JNI操作Java属性和方法
1. 获得、设置属性和静态属性
取得了代表属性和静态属性的jfieldID，就可以使用JNIEnv中提供的方法来获取和设置属性/静态属性。
取得Java属性的JNI方法定义如下：
j<类型> Get<类型>Field(jobjectobj, jfieldID fieldID);
j<类型> Get Static<类型>Field(jobjectobj, jfieldID fieldID);
设置Java属性的JNI方法定义如下：
void Set<类型>Field(jobject obj, jfieldID fieldID, j<类型> val);
void Set Static<类型>Field(jobject obj, jfieldID fieldID, j<类型> val);
<类型>表示Java中的基本类型。例如：
// 获得obj对象中，整形属性ID为fieldID的值
jint GetIntField(jobject obj, jfieldID fieldID);
// 设置obj对象中，属性ID为fieldID，属性值为val
void SetObjectField(jobjectobj, jfieldID fielded,jobject val);
// 设置clazz类中，静态属性ID为fieldID的属性值为value
void SetStaticCharField(jclass clazz, jfieldIDfieldID, jchar value)
我们将上一节中的本地代码进行修改如下：
void Java_com_test_exam2_NativeCallJava_callNative(JNIEnv* env, jclassthiz, jobject obj)
{
jclass myCls = env->GetObjectClass(obj);
jfieldIDmNumFieldID = env->GetFieldID(myCls, “mNumber”, “I”);
jfieldIDmNameFieldID = env->GetStaticFieldID(myCls, “mName”, “java/lang/String”);
//获得、设置Java成员的属性值
jintmNum = env->GetIntField(obj, mNumFieldID);
env->SetIntField(obj,mNumFieldID, mNum+100);
//获得、设置静态属性的值
jstringmNm = (jstring)(env->GetStaticObjectField(myCls, mNameFieldID));
printf(“%s\n”,mNm);
jstringnewStr = env->NewStringUTF(“Hello from Native”);
env->SetStaticObjectField(myCls,mNumFieldID, newStr);
…
}
上述代码通过JNI提供的Get、Set方法取得和设置Java对象和类的属性，NewStringUTF表示创建一个Java的字符串对象，字符串值使用8位字符初始化。
2. 通过JNI调用Java中的方法
在4.5.1节我们通过JNI方法获得了jmethodID，在本地代码中我们就可以通过jmethodID来调用Java中的方法了。
JNI提供了下面的方法用来调用Java方法：
// 调用Java成员方法
Call<Type>Method(jobject obj,jmethodIDmethodID,...);
Call<Type>MethodV(jobject clazz, jmethodIDmethodID,va_listargs);
Call<Type>tMethodA(jobject clazz,jmethodID methodID,constjvalue *args);
// 调用Java静态方法
CallStatic<Type>Method(jclass clazz,jmethodID methodID,...);
CallStatic<Type>MethodV(jclass clazz,jmethodID methodID,va_listargs);
CallStatic<Type>tMethodA(jclass clazz,jmethodID methodID,constjvalue *args);
上面的Type这个方法的返回值类型，如void，int，char，byte等等。
第一个参数代表调用的这个方法所属于的对象，或者这个静态方法所属的类。
第二个参数代表jmethodID。
后面的表示调用方法的参数列表，…表示是变长参数，以“V”结束的方法名表示以向量表形式提供参数列表，以“A”结束的方法名表示以jvalue数组提供参数列表，这两种调用方式使用较少。
我们将前面的例子的本地代码继续进行修改：
void Java_com_test_exam2_NativeCallJava_callNative(JNIEnv* env, jclassthiz, jobject obj)
{
jclass myCls = env->GetObjectClass(obj);
jfieldIDmNumFieldID = env->GetFieldID(myCls, “mNumber”, “I”);
jfieldIDmNameFieldID = env->GetStaticFieldID(myCls, “mName”, “java/lang/String”);
//获得、设置Java成员的属性值
jintmNum = env->GetIntField(obj, mNumFieldID);
env->SetIntField(obj,mNumFieldID, mNum+100);
//获得、设置静态属性的值
jstringmNm = (jstring)(env->GetStaticObjectField(myCls, mNameFieldID));
printf(“%s\n”,mNm);
jstringnewStr = env->NewStringUTF(“Hello from Native”);
env->SetStaticObjectField(myCls,mNumFieldID, newStr);
//取得Java方法ID
jmethodIDprintNumMethodID = env->GetMethodID(myCls, “printNum”, “(V)V”);
jmethodIDprintNmMethodID = env->GetStaticMethodID(myCls, “printNm” , “(V)V”);
//调用MyClass对象中的printNum方法
CallVoidMethod(obj,printNumMethodID);
//调用MyClass类的静态pinrtNm方法
CallStaticVoidMethod(myCls,printNmMethodID);
}
在Java中构造方法是一种特殊的方法，主要用于对象创建时被回调，我们将在下一节分析。
4.5.4 在本地代码中创建Java对象
1. 在本地代码中创建Java对象
在JNIEnv的函数表中提供了下面几个方法来创建一个Java对象：
jobject NewObject(jclass clazz, jmethodIDmethodID,...);
jobject NewObjectV(jclass clazz,jmethodIDmethodID,va_list args);
jobjectNewObjectA(jclass clazz, jmethodIDmethodID,const jvalue *args) ;
它们和上一节中介绍的调用Java方法使用起来很相似，他们的参数意义如下：
clazz：要创建的对象的类。
jmethodID：创建对象对应的构造方法ID。
参数列表：…表示是变长参数，以“V”结束的方法名表示向量表表示参数列表，以“A”结束的方法名表示以jvalue数组提供参数列表。
由于Java的构造方法的特点是方法名与类名一样，并且没有返回值，所以对于获得构造方法的ID的方法env->GetMethodID(clazz,method_name,sig)中的第二个参数是固定为类名（也可以用“<init>”代替类名），第三个参数和要调用的构造方法有关，默认的Java构造方法没有返回值，没有参数。
我们将上一节的例子进行修改，在本地代码中创建一个新的MyClass对象：
void Java_com_test_exam2_NativeCallJava_callNative(JNIEnv* env, jclassthiz, jobject obj)
{
jclass myCls = env->GetObjectClass(obj);
//当然我们也可以像下面这样写：
//jclass myCls = env->FindClass("com/test/exam2/MyClass");
//取得MyClass的构造方法ID
jmethodIDmyClassMethodID = env->GetMethodID(myCls, “MyClass”, “(V)V”);
//创建MyClass新对象
jobjectnewObj = NewObject(myCls, myClassMethodID);
}
2．创建Java String对象
在Java中，字符串String对象是Unicoode（UTF-16）编码，每个字符不论是中文还是英文还是符号，一个字符总是占用两个字节。在C/C++中一个字符是一个字节， C/C++中的宽字符是两个字节的。
在本地C/C++代码中我们可以通过一个宽字符串，或是一个UTF-8编码的字符串创建一个Java端的String对象。这种情况通常用于返回Java环境一个String返回值等场合。
根据传入的宽字符串创建一个Java String对象
jstring NewString(const jchar *unicode, jsizelen)
根据传入的UTF-8字符串创建一个Java String对象
jstring NewStringUTF(const char *utf)
在Java中String类有很多对字符串进行操作的方法，在本地代码中可以通过JNI接口可以将Java的字符串转换到C/C++的宽字符串（wchar_t*），或是传回一个UTF-8的字符串（char*）到C/C++，在本地进行操作。
可以看下面的一个例子：
在Java端有一个字符串 String str="abcde";，在本地方法中取得它并且输出：
void native_string_operation (JNIEnv * env, jobject obj)
{
//取得该字符串的jfieldID
jfieldIDid_string=env->GetFieldID(env->GetObjectClass(obj),"str", "Ljava/lang/String;");
jstringstring=(jstring)(env->GetObjectField(obj, id_string)); //取得该字符串，强转为jstring类型。
printf("%s",string);
}
由上面的代码可知，从java端取得的String属性或者是方法返回值的String对象，对应在JNI中都是jstring类型，它并不是C/C++中的字符串。所以，我们需要对取得的 jstring类型的字符串进行一系列的转换，才能使用。
JNIEnv提供了一系列的方法来操作字符串：
将一个jstring对象，转换为（UTF-16）编码的宽字符串（jchar*）:
const jchar *GetStringChars(jstring str,jboolean*isCopy)
将一个jstring对象，转换为（UTF-8）编码的字符串（char*）:
const char *GetStringUTFChars(jstringstr,jboolean *isCopy)
这两个函数的参数中，第一个参数传入一个指向Java 中String对象的jstring引用。第二个参数传入的是一个jboolean的指针，其值可以为NULL、JNI_TRUE、JNI_FLASE。
如果为JNI_TRUE则表示在本地开辟内存，然后把Java中的String拷贝到这个内存中，然后返回指向这个内存地址的指针。如果为JNI_FALSE，则直接返回指向Java中String的内存指针。这时不要改变这个内存中的内容，这将破坏String在Java中始终是常量的规则。
如果是NULL，则表示不关心是否拷贝字符串。
使用这两个函数取得的字符，在不适用的时候（不管String的数据是否拷贝到本地内存），要分别对应的使用下面两个函数来释放内存。
RealeaseStringChars(jstring jstr,const jchar*str)
RealeaseStringUTFChars(jstringjstr, constchar* str)
第一个参数指定一个jstring变量，即要释放的本地字符串的资源
第二个参数就是要释放的本地字符串
4.5.5 Java数组在本地代码中的处理
我们可以使用GetFieldID获取一个Java数组变量的ID，然后用GetObjectFiled取得该数组变量到本地方法，返回值为jobject，然后我们可以强制转换为j<Type>Array类型。
@jni.h
typedef jarray jbooleanArray;
typedef jarray jbyteArray;
typedef jarray jcharArray;
typedef jarray jshortArray;
typedef jarray jintArray;
typedef jarray jlongArray;
typedef jarray jfloatArray;
typedef jarray jdoubleArray;
typedef jarray jobjectArray;
j<Type>Array类型是JNI定义的一个对象类型，它并不是C/C++的数组，如int[]数组，double[]数组等等。所以我们要把j<Type>Array类型转换为C/C++中的数组来操作。
JNIEnv定义了一系列的方法来把一个j<Type>Array类型转换为C/C++数组或把C/C++数组转换为j<Type>Array。
1. 获取数组的长度
jsize GetArrayLength(jarray array);
2. 对象类型数组的操作
jobjectArray NewObjectArray(jsize len, jclassclazz, jobject init) // 创建对象数组
jobject GetObjectArrayElement(jobjectArrayarray, jsize index) // 获得元素
void SetObjectArrayElement(jobjectArray array,jsize index, jobject val) // 设置元素
参数说明：
len：新创建对象数组长度
clazz：对象数组元素类型
init：对象数组元素的初始值
array：要操作的数组
index：要操作数组元素的下标索引
val：要设置的数组元素的值
JNI没有提供直接把Java的对象类型数组（Object[ ]）直接转到C++中的jobject[ ]数组的函数。而是直接通过Get/SetObjectArrayElement这样的函数来对Java的Object[ ]数组进行操作。
3. 对基本数据类型数组的操作
基本数据类型数组的操作方法比较多，大致可以分为如下几类：
获得指定类型的数组：
j<Type>*Get<Type>ArrayElements(j<Type>Array array, jboolean *isCopy);
释放数组：
voidRelease<Type>ArrayElements(j<Type>Array array, j<Type>*elems, jint mode);
这类函数可以把Java基本类型的数组转换到C/C++中的数组。有两种处理方式，一是拷贝一份传回本地代码，另一种是把指向Java数组的指针直接传回到本地代码，处理完本地化的数组后，通过Realease<Type>ArrayElements来释放数组。处理方式由Get方法的第二个参数isCopied来决定（取值为JNI_TRUE或JNI_FLASE）。
其第三个参数mode可以取下面的值：
l 0：对Java的数组进行更新并释放C/C++的数组
l JNI_COMMIT：对Java的数组进行更新但是不释放C/C++的数组
l JNI_ABORT：对Java的数组不进行更新，释放C/C++的数组
例如：
package com.test.exam4_5
class ArrayTest {
static{
System.loadLibrary("native_array");
}
privateint [] arrays=new int[]{1,2,3,4,5};
publicnative void show();
publicstatic void main(String[] args) {
new ArrayTest ().show();
}
}
本地代码：
void Java_com_test_exam4_5_ArrayTest_show(JNIEnv * env, jobject obj)
{
jfieldID id_arrsys = env->GetFieldID(env->GetObjectClass(obj),"arrays", "[I");
jintArrayarr = (jintArray)(env->GetObjectField(obj, id_arrsys));
jint*int_arr = env->GetIntArrayElements(arr, NULL);
jsizelen = env->GetArrayLength(arr);
for(int i = 0; I < len; i++)
{
cout << int_arr[i]<< endl;
}
env->ReleaseIntArrayElements(arr, int_arr, JNI_ABORT);
}
4.6 局部引用与全局引用
Java代码与本地代码里在进行参数传递与返回值复制的时候，要注意数据类型的匹配。对于int, char等基本类型直接进行拷贝即可，对于Java中的对象类型，通过传递引用实现。JVM保证所有的Java对象正确的传递给了本地代码，并且维持这些引用，因此这些对象不会被Java的gc（垃圾收集器）回收。因此，本地代码必须有一种方式来通知JVM本地代码不再使用这些Java对象，让gc来回收这些对象。
JNI将传递给本地代码的对象分为两种：局部引用和全局引用。
l 局部引用：只在上层Java调用本地代码的函数内有效，当本地方法返回时，局部引用自动回收。
l 全局引用：只有显示通知VM时，全局引用才会被回收，否则一直有效，Java的gc不会释放该引用的对象。
JNI中对于局部引用和全局引用相关的函数如下：
创建指向某个对象的局部引用，创建失败返回NULL
jobject NewLocalRef(jobject ref);
删除局部引用
void DeleteLocalRef(jobject obj);
创建指向某个对象的全局引用，创建失败返回NULL
jobject NewGlobalRef(jobject lobj);
删除全局引用
void DeleteGlobalRef(jobject gref);
4.6.1局部引用
默认的话，传递给本地代码的引用是局部引用。所有的JNI函数的返回值都是局部引用。
jstring MyNewString(JNIEnv *env, jchar *chars,jint len)
{
staticjclassstringClass = NULL; //static 不能保存一个局部引用
jmethodIDcid;
jcharArrayelemArr;
jstringresult;
if(stringClass== NULL) {
stringClass =env->FindClass("java/lang/String"); // 局部引用
if(stringClass == NULL) {
return NULL; /* exception thrown */
}
}
/* 本地代码中创建的字符串为局部引用，当函数返回后字符串有可能被gc回收 */
cid =env->GetMethodID(stringClass,"<init>","([C)V");
result=env->NewStringUTF(stringClass, cid, “Hello World”);
returnresult;
}
虽然局部引用会在本地代码执行之后自动释放，但是有下列情况时，要手动释放：
l 本地代码访问一个很大的Java对象时，在使用完该对象后，本地代码要去执行比较复杂耗时的运算时，由于本地代码还没有返回，Java收集器无法释放该本地引用的对象，这时，应该手动释放掉该引用对象。
l 本地代码创建了大量局部引用，这可能会导致JNI局部引用表溢出，此时有必要及时地删除那些不再被使用的局部引用。比如：在本地代码里创建一个很大的对象数组。
jni.h头文件中定义了JNI本地方法与Java方法映射关系结构体JNINativeMethod。
l 创建的工具函数，它会被未知的代码调用，在工具函数里使用完的引用要及时释放。
l 不返回的本地函数。例如，一个可能进入无限事件分发的循环中的方法。此时在循环中释放局部引用，是至关重要的，这样才能不会无限期地累积，进而导致内存泄露。局部引用只在创建它们的线程里有效，本地代码不能将局部引用在多线程间传递。一个线程想要调用另一个线程创建的局部引用是不被允许的。将一个局部引用保存到全局变量中，然后在其它线程中使用它，这是一种错误的编程。
4.6.2 全局引用
在一个本地方法被多次调用时，可以使用一个全局引用跨越它们。一个全局引用可以跨越多个线程，并且在被程序员手动释放之前，一直有效。和局部引用一样，全局引用保证了所引用的对象不会被垃圾回收。
JNI允许程序员通过局部引用来创建全局引用, 全局引用只能由NewGlobalRef函数创建。下面是一个使用全局引用例子：
jstringMyNewString(JNIEnv *env, jchar *chars,jint len)
{
staticjclassstringClass = NULL;
...省略部分代码
if(stringClass == NULL) {
jclasslocalRefCls =env->FindClass("java/lang/String");
if(localRefCls == NULL) {
return NULL;
}
/*创建全局引用并指向局部引用 */
stringClass = env->NewGlobalRef(localRefCls);
/*删除局部引用 */
env->DeleteLocalRef(localRefCls);
/*判断全局引用是否创建成功 */
if(stringClass == NULL) {
return NULL; /* out of memory exception thrown */
}
}
}
在native代码不再需要访问一个全局引用的时候，应该调用DeleteGlobalRef来释放它。如果调用这个函数失败，Java VM将不会回收对应的对象。
4.6.3 在Java环境中保存JNI对象
本地代码在某次被调用时生成的对象，在其他函数调用时是不可见的。虽然可以设置全局变量但那不是好的解决方式，Android中通常是在Java域中定义一个int型的变量，在本地代码生成对象的地方，与这个Java域的变量关联，在别的使用到的地方，再从这个变量中取值。
以JNICameraContext为例来说明：
JNICameraContext是android_hardware_camera.cpp中定义的类型，并会在本地代码中生成对象并与Java中定义的android.hardware.Camera类的mNativeContext整形成员关联。
注：为了简化理解，代码已经做了简单修改
static voidandroid_hardware_Camera_native_setup(JNIEnv*env, jobject thiz,jobjectweak_this, jintcameraId)
{
// 创建JNICameraContext对象
JNICameraContext *context = new JNICameraContext(env, weak_this,clazz,camera);
…省略部分代码
// 查找到Camera类
jclassclazz =env->FindClass("android/hardware/Camera ");
// 保存Carmera类中mNativeContext成员ID
jfieldID field = env->GetFieldID(clazz,"mNativeContext","I");
// 保存context对象的地址到了Java中的mNativeContext属性里
env->SetIntField(thiz,fields, (int)context);
}
当要使用在本地代码中创建的JNICameraContext对象时，通过JNIEnv::GetIntField()获取Java对象的属性，并转化为JNICameraContext类型：
// 查找到Camera类
jclassclazz =env->FindClass("android/hardware/Camera ");
// 保存Carmera类中mNativeContext成员ID
jfieldID field = env->GetFieldID(clazz,"mNativeContext","I");
// 从Java环境中得到保存在mNativeContext中的对象引用地址
JNICameraContext*context=(JNICameraContext*)(env->GetIntField(thiz,field));
if(context!= NULL) {
//…省略部分代码
}
4.7本地方法的注册
前面我们介绍了Java方法和本地方法互相调用过程中用到的JNI接口函数。在Java代码调用本地方法时，JVM又是如何能正确的绑定到本地方法呢？
当JVM在调用带有native关键字的方法时，JVM在Java运行时环境中查找“一张方法映射表”，根据这张表寻找对应的本地方法，如果本地代码中没有找到对应的函数，则会抛出java.lang.UnsatisfiedLinkError错误，所以，当我们在使用JNI编程时，必须保证本地方法出现在“方法映射表”中。
4.7.1 JNI_OnLoad方法
本地代码最终编译成动态库，在Java代码中通过System.loadLibrary方法来加载本地代码库，当本地代码动态库被JVM加载时，JVM会自动调用本地代码中的JNI_OnLoad函数。
JNI_OnLoad函数的定义如下：
jint JNI_OnLoad(JavaVM *vm, void *reserved);
参数说明：
vm：代表了JVM实例，其实是和JVM相关的一些操作函数指针，详情请查看4.2.1章节。
reserved：保留
一般来说JNI_OnLoad函数里主要做以下工作：
l 调用GetEnv函数，获得JNIEnv，即Java执行环境
l 通过RegisterNatives函数注册本地方法
l 返回JNI版本号
JNI从Java1.0到现在其版本也在发生变化 ，变化主要体现在JNIEnv中支持的函数个数，当调用GetEnv函数时可以指定获得某个版本的JNIEnv函数表。
jint GetEnv(void **penv, jint version);
参数说明：
penv： JNIEnv指针的地址，GetEnv成功调用后，它指向JNIEnv指针。
version：请求的JNI版本号，如：JNI_VERSION_1_4，表示请求JNI1.4版本的JNIEnv执行环境。
返回值：当请求的JNI版本号不支持时，返回负值，成功返回JNI_OK。
RegisterNatives是JNIEnv所提供的功能函数，用于注册本地方法和Java方法的映射关系到JVM中，保证Java代码调用本地代码时能正确调用到本地代码。
JVM要求JNI_OnLoad函数必须返回一个合法的JNI版本号，表示该库将被JVM加载，因此本地代码的JNI_OnLoad的实现一般如下：
/*
* Thisiscalled by the VM when the shared library is first loaded.
*/
jintJNI_OnLoad(JavaVM* vm, void* reserved) {
JNIEnv* env= NULL;
jintresult= -1;
if(vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) { // 调用GetEnv请求获得指定版本的JNIEnv
gotofail;
}
if(env!= NULL)
gotofail;
if(registerMethods(env) != 0) { //调用子函数注册本地方法
gotofail;
}
/*success-- return valid version number */
result =JNI_VERSION_1_4; //指定返回值为合法的JNI版本号
fail:
return result;
}
4.7.2 RegisterNatives方法
RegisterNatives通常在本地代码被加载时被调用，用来将JNI映射关系“告诉”Java执行环境。映射关系其实是在jni.h中定义一个结构体：
@jni.h
typedef struct {
char *name; // Java方法名
char *signature; //方法签名表示字符串
void *fnPtr; // Java方法对应的本地函数指针
} JNINativeMethod;
该结构体记录了Java运行环境中Java方法名name，Java方法签名signature以及其对应的本地函数名fnPtr。
由于Java代码中可能定义多个本地方法，所以JNINativeMethod结构通常放到一个数组中，通过RegisterNatives注册到JVM中：
@jni.h
jint RegisterNatives(jclass clazz, constJNINativeMethod *methods, jint nMethods);
jint UnregisterNatives(jclass clazz);
clazz：成员方法属于某个类，clazz指定注册的映射关系所在的类
methods：JNINativeMethod指针，它通常是一个映射关系数组
nMethods：映射关系数组元素个数，即：映射关系数量
当这些映射关系不再需要时，或需要更新映射关系时，则调用UnregisterNatives函数，删除这些映射关系。
我们现在完整的来看下之前例子：
@ NativeTest.java
package com.test.exam2;
class NativeTest{
static{
System.loadLibrary(“native_call”);
}
privatenative static void callNativePrint(String str);
privatenative static intcallNativeAdd(int n1, int n2);
publicstatic void main(String arg[]){
callNativePrint(“HelloWorld”);
System.out.println(“n1+ n2 = ” + callNativeAdd(10, 20));
}
}
@com_test_exam2_NativeTest.cpp：
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <jni.h>
#include <jni_md.h>
void native_print(JNIEnv * env, jclassthiz, jobject obj)
{
printf(“Stringfrom java:%s\n”, env->GetStringUTFChars((jstring)obj, JNI_FALSE));
}
jint native_add(JNIEnv * env, jclassthiz, jintn1, jint n2)
{
returnn1 + n2;
}
/*
* 定义映射关系结构体数组
*/
static const JNINativeMethod gMethods[] = {
{"callNativePrint", "(Ljava/lang/String;)V",(void*)native_print},
{"callNativeAdd", "(II)I",(void*)native_add},
};
/*
* 将映射关系结构体数组注册到JVM中
*/
static int registerMethods(JNIEnv*env) {
static constchar* const className= " com/test/exam2/NativeTest";
jclass clazz;
/* look upthe class */
clazz =env->FindClass(className);
if (clazz ==NULL) {
return-1;
}
/* registerall the methods */
if(env->RegisterNatives(clazz,gMethods,
sizeof(gMethods) /sizeof(gMethods[0])) != JNI_OK)
{
return -1;
}
/* fill outthe rest of the IDcache */
return 0;
}
/*
* Thisiscalled by the VM when the shared library is first loaded.
*/
jintJNI_OnLoad(JavaVM* vm, void* reserved) {
JNIEnv* env= NULL;
jintresult= -1;
if(vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) { // 调用GetEnv请求获得指定版本的JNIEnv
gotofail;
}
if(env!= NULL)
gotofail;
if(registerMethods(env) != 0) { //调用子函数注册本地方法
gotofail;
}
/*success-- return valid version number */
result =JNI_VERSION_1_4; //指定返回值为合法的JNI版本号
fail:
return result;
}
4.8 JNI调用实验
【实验内容】
在Linux操作系统中硬件通常有：open，read，write，close等相关操作接口，每个设备硬件还有一些自己的属性，我们用Java编写一个Screen“屏幕”设备类，设备的初始化，设备打开，关闭，读/写都交给本地代码去实现。当写屏幕设备时，将写入内容存放在本地代码缓冲区中，当读屏幕设备时，则将数据经过简单处理读取出来。例如：向Screen中写入a-z的小写字母，读出来变成A-Z的大写。
在Ubuntu系统中编写Java程序和本地C++代码，编写Makefile文件用来编译Java代码和本地代码库，最终正常运行Java与C++本地代码。
【实验目的】
通过实验，学员掌握在Linux系统中编写基于JNI的java程序和与Java对应的C++本地代码，熟悉Linux中编译动态库的过程和Makefile的编写，最终掌握JNI编程相关知识。
【实验平台】
安装有JDK的Ubuntu操作系统（可以在Windows系统中虚拟Ubuntu系统）。
【实验步骤】
1. 设计Screen类，并实现其代码
@Screen.java
package com.test.practice4_8;
class Screen{
// Load libscreen.so lib
static{
System.loadLibrary("screen");
}
private String mDevName;
private int mDevNo;
private boolean isInit = false;
private int mWidth;
private int mHeight;
publicScreen(){
mDevName = null;
mDevNo = 0;
}
// check is device inital
publicboolean isInit(){
return isInit;
}
// get the screen width
publicint getWidth(){
return mWidth;
}
// get the screen height
publicint getHeight(){
return mHeight;
}
// print screen informations
publicvoid printInfo(){
System.out.println("Screen Name: " + mDevName);
System.out.println("Device No: " + mDevNo);
System.out.println("Screen width: " + mWidth);
System.out.println("Screen height:" + mHeight);
}
// define all native methods
publicnative boolean open();
publicnative int read(byte[] data, int len);
publicnative int write(byte[] data, int len);
publicnative void close();
}
2. 设计并实现Screen测试类
package com.test.practice4_8;
class ScreenTest{
publicstatic void main(String arg[]){
Screen dev = new Screen(); //创建Screen对象
if(!dev.open()){ //打开Screen设备
System.out.println("Screen open error");
return;
}
dev.printInfo(); //打印设备信息
byte[] data = new byte[26]; //定义要写入的数据，不能用双字节的char类型
for(int i = 0; i < 26; i++){
data[i] = (byte)(97 + i);
}
System.out.println("Write a-z to Screen device:");
dev.write(data, data.length); // 写入设备中
byte[] buf = new byte[64];
int size = dev.read(buf, buf.length); //从设备中读取出来
if(size < 0){
System.out.println("read data from screen device error");
return ;
}
System.out.println("Read data from Screen device:");
for(int i = 0; i < 26; i++){
System.out.print((char)buf[i] + ","); // 打印出读取出的数据
}
System.out.println();
dev.close(); //关闭设备
}
}
3. 设计并实现本地代码
@com_test_practice4_8_ScreenTest.cpp
#include <unistd.h>
#include <stdlib.h>
#include <malloc.h>
#include <jni.h>
#include <jni_md.h>
// 定义一个全局结构体，用来保存所有的Screen类的相关ID信息
struct screen{
jclassclazz;
jfieldID id_dev_name;
jfieldID id_dev_no;
jfieldID id_is_init;
jfieldIDid_width;
jfieldID id_height;
} *gfieldID;
// 定义读写数据的缓冲区
char _data[64];
//初始化Screen类的相关ID信息，起到缓存的作用
static int native_id_init(JNIEnv *env){
gfieldID = (struct screen*)malloc(sizeof(struct screen));
if(gfieldID == NULL)
return -1;
gfieldID->clazz =env->FindClass("com/test/practice4_8/Screen");
gfieldID->id_dev_name = env->GetFieldID(gfieldID->clazz,"mDevName", "Ljava/lang/String;");
gfieldID->id_dev_no = env->GetFieldID(gfieldID->clazz,"mDevNo", "I");
gfieldID->id_is_init= env->GetFieldID(gfieldID->clazz, "isInit", "Z");
gfieldID->id_width = env->GetFieldID(gfieldID->clazz,"mWidth", "I");
gfieldID->id_height = env->GetFieldID(gfieldID->clazz,"mHeight", "I");
return 0;
}
// Java代码中open方法的本地实现
static jboolean native_open(JNIEnv * env,jobject thiz) {
//init the jfieldID in Java env
if(native_id_init(env) != 0){
return JNI_FALSE;
}
// 创建设备名字符串
jstring dev_nm = env->NewStringUTF("Farsight HD LCDScreen");
if(dev_nm == NULL)
return JNI_FALSE;
// 写回Screen对象的mDevName属性里
env->SetObjectField(thiz, gfieldID->id_dev_name, dev_nm);
// 设备设备号
env->SetIntField(thiz, gfieldID->id_dev_no, 0x1234);
// 设置初始化标识
env->SetBooleanField(thiz, gfieldID->id_is_init, JNI_TRUE);
// 设置Screen宽度
env->SetIntField(thiz, gfieldID->id_width, 1023);
// 设置Screen高度
env->SetIntField(thiz, gfieldID->id_height, 768);
returnJNI_TRUE;
}
// Screen类 read方法的本地实现
static jint native_read(JNIEnv * env, jobjectthiz, jbyteArray arr, jint len)
{
if(len<= 0){
return len;
}
// 获得Java层定义的byte数组
jbyte*byte_arr = env->GetByteArrayElements(arr, NULL);
int i= 0;
for(;i < len; i++){
byte_arr[i]= _data[i] - 32; // 将处理过的数据写回Java byte数组里
}
env->ReleaseByteArrayElements(arr, byte_arr, 0); // update array data andrelease array
returni;
}
// Screen类write方法的本地实现
static jint native_write(JNIEnv * env, jobjectthiz, jbyteArray arr, jint len)
{
if(len> sizeof(_data) && len <= 0){
return -1;
}
// 获得Java层定义的byte数组
jbyte*byte_arr = env->GetByteArrayElements(arr, NULL);
int i= 0;
for(;i < len; i++){
_data[i] = byte_arr[i]; //将Java byte数组保存在本地缓存区中
printf("%c,", _data[i]);
}
printf("\n");
env->ReleaseByteArrayElements(arr, byte_arr, JNI_ABORT); // do not update array data release array
returni;
}
// Screen类close方法的本地实现
static void native_close(JNIEnv * env, jobjectthiz)
{
// 修改isInit的值为false
env->SetBooleanField(thiz, gfieldID->id_is_init, JNI_FALSE);
free(gfieldID); //释放空间
gfieldID = NULL;
}
/*
* 定义映射关系结构体数组
*/
static const JNINativeMethod gMethods[] = {
{"open", "()Z", (void*)native_open},
{"read", "([BI)I", (void*)native_read},
{"write", "([BI)I", (void*)native_write},
{"close", "()V", (void*)native_close},
};
/*
* 将映射关系结构体数组注册到JVM中
*/
static int registerMethods(JNIEnv* env) {
staticconst char* const className = "com/test/practice4_8/Screen";
jclassclazz;
/*look up the class */
clazz= env->FindClass(className);
if(clazz == NULL) {
printf("FindClass error\n");
return-1;
}
/*registerall the methods */
if(env->RegisterNatives(clazz, gMethods, sizeof(gMethods) /sizeof(gMethods[0])) != JNI_OK)
{
return -1;
}
/*fill outthe rest of the ID cache */
return0;
}
/*
* This iscalled by the VM when the sharedlibrary is first loaded.
*/
jint JNI_OnLoad(JavaVM* vm, void* reserved) {
JNIEnv* env= NULL;
jintresult= -1;
if(vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) { // 调用GetEnv请求获得指定版本的JNIEnv
printf("GetEnv error\n");
goto fail;
}
if(env== NULL)
goto fail;
if(registerMethods(env) != 0) { // 调用子函数注册本地方法
printf("registerMethods error\n");
goto fail;
}
/*success-- return valid version number */
result= JNI_VERSION_1_4; // 指定返回值为合法的JNI版本号
fail:
returnresult;
}
我们在本地代码中声明了一个全局结构体指针gfieldID，该结构体里面存放的是Screen类成员ID，因为这些ID要在后面的方法中频繁的使用，如果不缓存起来，意味着每次使用都要Findclass，GetFieldID，这对性能有很大影响。
4. 为了方便编译，编写Makefile
libscreen.so:com_test_practice4_8_ScreenTest.cpp ScreenTest.class
g++-I/home/linux/jdk1.5.0_21/include/ -I/home/linux/jdk1.5.0_21/include/linux/$< -fPIC -shared -o $@
ScreenTest.class: ScreenTest.java
javac-d ./ $<
clean:
$(RM)ScreenTest.class libscreen.so
由于本地代码要编译成so动态库，所以g++的参数要指定-fPIC –shared等选项，另外，在编译本地代码时要用到jni.h和jni_md.h头文件，所以还要加上-I选项，用来指定这两个头文件的位置，它们在我们安装的JDK的目录下。
细心的同学可能已经注意到，本地C++文件名为Java的包名+类名.cpp，包名不是以“.”作为间隔符，而是以目录间隔符“/”分隔，这也是因为Java中的包名本身就是使用目录名以区分命名空间。这样做还有另外一个好处，即：我们看到本地代码文件时基本上就可以通过文件找到其对应的Java代码，反之亦然。
5. 执行make命令，并且运行查看实验结果
$ make
$ java -Djava.library.path='.'com/test/practice4_8/ScreenTest
Java命令的“-Djava.library.path”选项表示指定在运行Java代码时，加载本地库时的寻找路径。为了避免每次都输入上述运行命令，我们可以写到一个脚本中
@run.sh
#!/bin/bash
java -Djava.library.path='.'com/test/practice4_8/ScreenTest
运行结果如下：
linux@ubuntu:~/jni/practice$ ./run.sh
Screen Name: Farsight HD LCD Screen
Device No: 4660
Screen width: 1023
Screen height:768
Write a-z to Screen device:
a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,
Read data from Screen device:
A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z,
6. 常见问题
l Exception in thread"main" java.lang.NoClassDefFoundError: xxx
一般是由于FindClass方法查找不到Java类造成的，检查FindClass的参数是否正确。
l Exception in thread"main" java.lang.NoSuchMethodError: xxx
Java与本地方法的链接映射时出现错误，先确认下Java中有没有对应xxx方法声明，如果有，确认RegisterNatives注册映射关系的签名是否匹配。
l Exception in thread"main" java.lang.NoSuchFieldError：xxx
这表示在本地代码中访问xxx属性时，在java代码中没有该属性，先确认该属性是否定义，如果有定义，看下属性是静态属性还是非静态属性，如果是静态属性，本地方法只能通过Get/SetStatic<Type>Field来访问，如果是非静态属性，本地方法只能通过Get/Set<Type>Field来访问。
l Exception in thread"main" java.lang.UnsatisfiedLinkError: no xxx in java.library.path
这表示本地代码库找不到，确认java在执行时，“-Djava.library.path”参数是否正确。