深入浅出 - Android系统移植与平台开发（十二）- Android JNI机制

谁借莪１个温暖的怀抱￠ 2022-08-23 13:44 199阅读 0赞

# 第五章、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代码实现一次，直接复用该本地代码，即提高了编程效率，又确保了程序的安全性和健壮性。

![Center][]

## 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);

![Center 1][]

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代码。

![Center 2][]

@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

<table> 
 <tbody> 
 <tr> 
 <td style="background:#D9D9D9;">Java Language Type</td> 
 <td style="background:#D9D9D9;">JNI Type</td> 
 </tr> 
 <tr> 
 <td>boolean </td> 
 <td>jboolean</td> 
 </tr> 
 <tr> 
 <td>byte</td> 
 <td>jbyte</td> 
 </tr> 
 <tr> 
 <td>char</td> 
 <td>jchar</td> 
 </tr> 
 <tr> 
 <td>short</td> 
 <td>jshort</td> 
 </tr> 
 <tr> 
 <td>int</td> 
 <td>jint</td> 
 </tr> 
 <tr> 
 <td>long</td> 
 <td>jlong</td> 
 </tr> 
 <tr> 
 <td>float</td> 
 <td>jfloat</td> 
 </tr> 
 <tr> 
 <td>double</td> 
 <td>jdouble</td> 
 </tr> 
 <tr> 
 <td>All Reference type</td> 
 <td>jobject</td> 
 </tr> 
 </tbody> 
</table>

由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中也定义了一套对应的引用类型，它们的对应关系如下：

<table> 
 <tbody> 
 <tr> 
 <td style="background:#D9D9D9;">JNI引用类型</td> 
 <td style="background:#D9D9D9;">Java引用类型</td> 
 </tr> 
 <tr> 
 <td>jobject</td> 
 <td>所有引用类型父类Object</td> 
 </tr> 
 <tr> 
 <td>jclass</td> 
 <td>java.lang.Class类型</td> 
 </tr> 
 <tr> 
 <td>jstring</td> 
 <td>java.lang.String类型</td> 
 </tr> 
 <tr> 
 <td>jarray</td> 
 <td>数组类型</td> 
 </tr> 
 <tr> 
 <td>jobjectArray</td> 
 <td>对象数组类型</td> 
 </tr> 
 <tr> 
 <td>jbooleanArray</td> 
 <td>布尔数组类型</td> 
 </tr> 
 <tr> 
 <td>jbyteArray</td> 
 <td>字节数组类型</td> 
 </tr> 
 <tr> 
 <td>jcharArray</td> 
 <td>字符数组类型</td> 
 </tr> 
 <tr> 
 <td>jshortArray</td> 
 <td>短整形数组类型</td> 
 </tr> 
 <tr> 
 <td>jintArray</td> 
 <td>整形数组类型</td> 
 </tr> 
 <tr> 
 <td>jlongArray</td> 
 <td>长整形数组类型</td> 
 </tr> 
 <tr> 
 <td>jfloatArray</td> 
 <td>浮点数组类型</td> 
 </tr> 
 <tr> 
 <td>jdoubleArray</td> 
 <td>双精度数组类型</td> 
 </tr> 
 <tr> 
 <td>jthrowable</td> 
 <td>java.lang.Throwadble类型</td> 
 </tr> 
 </tbody> 
</table>

由上表内容可知，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中类型签名如下表所示：

<table> 
 <tbody> 
 <tr> 
 <td style="background:#D9D9D9;">类型签名</td> 
 <td style="background:#D9D9D9;">Java类型</td> 
 <td style="background:#D9D9D9;">类型签名</td> 
 <td style="background:#D9D9D9;">Java类型</td> 
 </tr> 
 <tr> 
 <td>Z</td> 
 <td>boolean</td> 
 <td>[</td> 
 <td>[]</td> 
 </tr> 
 <tr> 
 <td>B</td> 
 <td>byte</td> 
 <td>[I</td> 
 <td>int[]</td> 
 </tr> 
 <tr> 
 <td>C</td> 
 <td>char</td> 
 <td>[F</td> 
 <td>float[]</td> 
 </tr> 
 <tr> 
 <td>S</td> 
 <td>short</td> 
 <td>[B</td> 
 <td>byte[]</td> 
 </tr> 
 <tr> 
 <td>I</td> 
 <td>int</td> 
 <td>[C</td> 
 <td>char[]</td> 
 </tr> 
 <tr> 
 <td>J</td> 
 <td>long</td> 
 <td>[S</td> 
 <td>short[]</td> 
 </tr> 
 <tr> 
 <td>F</td> 
 <td>float</td> 
 <td>[D</td> 
 <td>double[]</td> 
 </tr> 
 <tr> 
 <td>D</td> 
 <td>double</td> 
 <td>[J</td> 
 <td>long[]</td> 
 </tr> 
 <tr> 
 <td>L</td> 
 <td>类</td> 
 <td>[Z</td> 
 <td>boolean[]</td> 
 </tr> 
 <tr> 
 <td>V</td> 
 <td>void</td> 
 <td>&nbsp;</td> 
 <td>&nbsp;</td> 
 </tr> 
 </tbody> 
</table>

·        基本类型

以特定的单个大写字母表示

·        Java类类型

Java类类型以L开头，以“/”分隔包名，在类名后加上“;”分隔符，例如String的签名为：Ljava/lang/String;

在Java中数组是引用类型，数组以“\[”开头，后面跟数组元素类型签名，例如：int\[\]的签名是\[I ，对于二维数组，如int\[\]\[\]签名就是\[\[I，object数组签名就是\[Ljava/lang/Object;

对于方法签名，在JNI中也有特定的表示方式。

(参数1类型签名参数2类型签名参数3类型签名.......)返回值类型签名

注意：

·        方法名在方法签名中没有体现出来

·        括号内表示参数列表，参数列表紧密相挨，中间没有逗号，没有空格

·        返回值出现在括号后面

·        如果函数没有返回值，也要加上V类型

例如：

<table> 
 <tbody> 
 <tr> 
 <td style="background:#D9D9D9;">Java方法</td> 
 <td style="background:#D9D9D9;">JNI方法签名</td> 
 </tr> 
 <tr> 
 <td>boolean isLedOn(void) ;</td> 
 <td>(V)Z</td> 
 </tr> 
 <tr> 
 <td>void setLedOn(int ledNo);</td> 
 <td>(I)V</td> 
 </tr> 
 <tr> 
 <td>String substr(String str, int idx, int count);</td> 
 <td>(Ljava/lang/String;II)Ljava/lang/String</td> 
 </tr> 
 <tr> 
 <td>char fun (int n, String s, int[] value);</td> 
 <td>(ILjava/lang/String;[I)C</td> 
 </tr> 
 <tr> 
 <td>boolean showMsg(android.View v, String msg);</td> 
 <td>(Landroid/View;Ljava/lang/String;)Z</td> 
 </tr> 
 </tbody> 
</table>

### 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”参数是否正确。

[Center]: /images/20220823/4fe56bdba9eb48f6ae23f1d70d338d76.png
[Center 1]: /images/20220823/c4fd7c7ffee9482aa781375c3fdc910c.png
[Center 2]: /images/20220823/def4a37a427e4ceab026851d055b314f.png