jni java_JNI 常见用法

一、Java 代码 和JNI代码通信

Java代码通过JNI接口 调用 C/C++方法

1、首先我们需要在Java代码中声明Natvie方法原型

public native void helloJNI(String msg);

2、其次我们需要在C/C++代码里声明JNI方法的原型

如：

extern "C"

JNIEXPORT void JNICALL

Java_com_kgdwbb_jnistudy_MainActivity_helloJNI(JNIEnv* env, jobject thiz,jstring msg) {

//do something

}

extern "C"。JNI函数声明声明代码是用C++语言写的，所以需要添加extern "C"声明；如果源代码是C语言声明，则不需要添加这个声明

JNIEXPORT。这个关键字表明这个函数是一个可导出函数。每一个C/C++库都有一个导出函数列表，只有在这个列表里面的函数才可以被外部直接调用，类似Java的public函数和private函数的区别。

JNICALL。说明这个函数是一个JNI函数，用来和普通的C/C++函数进行区别。

Void 返回值类型

JNI函数名原型：Java_ + JNI方法所在的完整的类名，把类名里面的”.”替换成”_” + 真实的JNI方法名，这个方法名要和Java代码里面声明的JNI方法名一样。

env 参数 是一个执行JNIENV函数表的指针。

thiz 参数 代表的是声明这个JNI方法的Java类的引用。

msg 参数就是和Java声明的JNI函数的msg参数对于的JNI函数参数

静态JNI方法 和实例JNI方法的区别

Java代码:

public native void showHello();

public native static void showHello2();

C++代码：

extern "C"

JNIEXPORT void JNICALL

Java_com_kgdwbb_jnistudy_MainActivity_showHello(JNIEnv* env, jobject thiz) {

//do something

}

extern "C"

JNIEXPORT void JNICALL

Java_com_kgdwbb_jnistudy_MainActivity_showHello2(JNIEnv* env, jclass thiz) {

//do something

}

二、java 和JNI类型对照表

Java 和JNI基本类型对照表

java的基本类型可以直接与C/C++的基本类型映射。

image

Java与JNI引用类型对照表

与Java基本类型不同，引用类型对开发人员是不透明的。Java内部数据结构并不直接向原生代码开放。也就是说 C/C++代码并不能直接访问Java代码的字段和方法

image

三、JNI 基本操作举例

1、JNI操作 字符串

java 类 TestNatvie.java

/**

* 字符串相关测试代码

* @param str

*/

public native void testJstring(String str);

C++文件 natvie-lib.cpp

extern "C"

JNIEXPORT void JNICALL

Java_com_example_feifei_testjni_TestNatvie_testJstring(JNIEnv *env, jobject instance,

jstring str_) {

//(1)生成JNI String

char const * str = "hello world!";

jstring jstring = env->NewStringUTF(str);

// (2) jstring 转换成 const char * charstr

const char *charstr = env->GetStringUTFChars(str_, 0);

// (3) 释放 const char *

env->ReleaseStringUTFChars(str_, charstr);

//(4) 获取字符串子集

char * subStr = new char;

env->GetStringUTFRegion(str_,0,3,subStr);//截取字符串char*;

env->ReleaseStringUTFChars(str_, subStr);

}

2、JNI操作数组

java 类 TestNatvie.java

/**

* 整形数组相关代码

* @param array

*/

public native void testIntArray(int []array);

/**

*

* Object Array 相关测试 代码

* @param strArr

*/

public native void testObjectArray(String[]strArr);

C++文件 natvie-lib.cpp

extern "C"

JNIEXPORT void JNICALL

Java_com_example_feifei_testjni_TestNatvie_testIntArray(JNIEnv *env, jobject instance,

jintArray array_) {

//----获取数组元素

//(1)获取数组中元素

jint * intArray = env->GetIntArrayElements(array_,NULL);

int len = env->GetArrayLength(array_);//(2)获取数组长度

LOGD("feifei len:%d",len);

for(int i = 0; i < len;i++){

jint item = intArray[i];

LOGD("feifei item[%d]:%d",i,item);

}

env->ReleaseIntArrayElements(array_, intArray, 0);

//----- 获取子数组

jint *subArray = new jint;

env->GetIntArrayRegion(array_,0,3,subArray);

for(int i = 0;i<3;i++){

subArray[i]= subArray[i]+5;

LOGD("feifei subArray:[%d]:",subArray[i]);

}

//用子数组修改原数组元素

env->SetIntArrayRegion(array_,0,3,subArray);

env->ReleaseIntArrayElements(array_,subArray,0);//释放子数组元素

}

extern "C"

JNIEXPORT void JNICALL

Java_com_example_feifei_testjni_TestNatvie_testObjectArray(JNIEnv *env, jobject instance,

jobjectArray strArr) {

//获取数组长度

int len = env->GetArrayLength(strArr);

for(int i = 0;i< len;i++){

//获取Object数组元素

jstring item = (jstring)env->GetObjectArrayElement(strArr,i);

const char * charStr = env->GetStringUTFChars(item, false);

LOGD("feifei strArray item:%s",charStr);

jstring jresult = env->NewStringUTF("HaHa");

//设置Object数组元素

env->SetObjectArrayElement(strArr,i,jresult);

env->ReleaseStringUTFChars(item,charStr);

}

}

3、JNI 访问Java类的方法和字段

JNI 中访问java类的方法和字段都是 通过反射来实现的。

JNI获取Java类的方法ID和字段ID,都需要一个很重要的参数，就是Java类的方法和字段的签名

image

JNI 中访问Java对象的属性 和方法:

java 类 TestNatvie.java

public class TestNatvie {

static {

System.loadLibrary("native-lib");

}

/**

* Jni调用 java 对象方法

*/

public native void testCallJavaMethod();

/**

* Jni 调用 java static 方法

*/

public native void testCallStaticJavaMethod();

/**

* JNI 访问 java 的对象属性和类属性

* @param student

*/

public native void getJavaObjectField(Student student);

public void helloworld(String msg){

Log.d("feifei","hello world:"+msg);

}

public static void helloworldStatic(String msg){

Log.d("feifei","hello world:"+msg);

}

}

C++ 类 natvie-lib.cpp

extern "C"

JNIEXPORT void JNICALL

Java_com_example_feifei_testjni_TestNatvie_testCallJavaMethod(JNIEnv *env, jobject instance) {

//获取类名

jclass clazz = env->GetObjectClass(instance);

if(clazz == NULL) return;

jmethodID javaMethod = env->GetMethodID(clazz,"helloworld","(Ljava/lang/String;)V");

if(javaMethod == NULL)return;

const char * msg = "nancy";

jstring jmsg = env->NewStringUTF(msg);

env->CallVoidMethod(instance,javaMethod,jmsg);

}

extern "C"

JNIEXPORT void JNICALL

Java_com_example_feifei_testjni_TestNatvie_testCallStaticJavaMethod(JNIEnv *env, jobject instance) {

//获取java类型

jclass clazz = env->GetObjectClass(instance);

if(clazz == NULL) return;

jmethodID staticMethod = env->GetStaticMethodID(clazz,"helloworldStatic","(Ljava/lang/String;)V");

if(staticMethod == NULL) return;

jstring jmsg = env->NewStringUTF("wangfeng");

env->CallStaticVoidMethod(clazz,staticMethod,jmsg);

}

extern "C"

JNIEXPORT void JNICALL

Java_com_example_feifei_testjni_TestNatvie_getJavaObjectField(JNIEnv *env, jobject instance,

jobject student) {

jclass clazz = env->GetObjectClass(student);

if(clazz == NULL )return;

// 获取Object 实例属性

jfieldID nameId = env->GetFieldID(clazz,"name","Ljava/lang/String;");

jstring jname = (jstring)env->GetObjectField(student,nameId);

jfieldID ageId = env->GetFieldID(clazz,"age","I");

jint jage = env->GetIntField(student,ageId);

const char * name = env->GetStringUTFChars(jname,false);

env->ReleaseStringUTFChars(jname,name);

//获取java 类属性:

jfieldID gradeId = env->GetStaticFieldID(clazz,"grade","I");

jint jgrade = env->GetStaticIntField(clazz,gradeId);

jfieldID nickeNameID = env->GetStaticFieldID(clazz,"nickname","Ljava/lang/String;");

jstring jnickname = (jstring)env->GetStaticObjectField(clazz,nickeNameID);

const char * nickeName = env->GetStringUTFChars(jnickname, false);

env->ReleaseStringUTFChars(jnickname,nickeName);

LOGD("feifei name:%s,age:%d,grade:%d,nickname:%s",name,jage,jgrade,nickeName);

//JNI 设置 java对象属性

env->SetObjectField(student,nameId,env->NewStringUTF("张三"));

//JNI 设置 java 类属性

env->SetStaticObjectField(clazz,nickeNameID,env->NewStringUTF("小白"));

jstring jnameNew = (jstring)env->GetObjectField(student,nameId);

jstring jnickNameNew = (jstring)env->GetStaticObjectField(clazz,nickeNameID);

const char * newName = env->GetStringUTFChars(jnameNew, false);

const char *newNickName = env->GetStringUTFChars(jnickNameNew, false);

env->ReleaseStringUTFChars(jnameNew,newName);

env->ReleaseStringUTFChars(jnickNameNew,newName);

LOGD("feifei after update name:%s,age:%d,grade:%d,nickname:%s",newName,jage,jgrade,newNickName);

}

4、JNI对象的全局引用和局部引用

Java代码的内存是由垃圾回收器来管理，而JNI代码则不受Java的垃圾回收器来管理。所以JNI代码提供了一组函数，来管理通过JNI代码生成的JNI对象，比如jobject，jclass，jstring，jarray等。

JNI对象的局部引用

在JNI接口函数中引用JNI对象的局部变量，都是对JNI对象的局部引用，一旦JNI接口函数返回，所有这些JNI对象都会被自动释放。

不过我们也可以采用JNI代码提供的DeleteLocalRef函数来删除一个局部JNI对象引用。

//声明局部变量clazz

jclass clazz = env->GetObjectClass(instance);

//手动释放 局部变量 clazz ;DeleteLocalRef 也可不用手动调用，JNI方法返回之后，会自动释放局部JNI变量

env->DeleteLocalRef(clazz);

JNI对象的全局引用

JNI对象的全局引用分为两种，一种是强全局引用，这种引用会阻止Java的垃圾回收器回收JNI代码引用的Java对象，另一种是弱全局引用，这种全局引用则不会阻止垃圾回收器回收JNI代码引用的Java对象。

1、强全局引用

NewGlobalRef用来创建强全局引用的JNI对象

DeleteGlobalRef用来删除强全局引用的JNI对象

2、弱全局引用

NewWeakGlobalRef用来创建弱全局引用的JNI对象

DeleteWeakGlobalRef用来删除弱全局引用的JNI对象

IsSameObject用来判断两个JNI对象是否相同

Java类 TestNatvie.java

/**

* 测试 JNI 强全局引用 和弱全局引用

*/

public native void testJNIReference(Object object);

C++ 代码 natvie-lib.cpp

/**

* (1)在JNI接口函数中引用JNI对象的局部变量，都是对JNI对象的局部引用，一旦JNI接口函数返回，所有这些JNI对象都会被自动释放。不过我们也可以采用JNI代码提供的DeleteLocalRef函数来删除一个局部JNI对象引用

* (2)对于JNI对象，绝对不能简单的声明一个全局变量，在JNI接口函数里面给这个全局变量赋值这么简单，一定要使用JNI代码提供的管理JNI对象的函数.

* JNI 全局引用分为两种: 一种全局引用,这种引用会阻止Java垃圾回收器回收JNI代码引用的对象；

* 另一种是弱全局引用，这种全局引用不会阻止垃圾回收器回收JNI 代码引用的Java对象

* - NewGlobalRef用来创建强全局引用的JNI对象

* - DeleteGlobalRef用来删除强全局引用的JNI对象

* - NewWeakGlobalRef用来创建弱全局引用的JNI对象

* - DeleteWeakGlobalRef用来删除弱全局引用的JNI对象

* - IsSameObject用来判断两个JNI对象是否相同

*/

jobject gThiz; //全局JNI对象引用

jobject gWeakThiz;//全局JNI对象弱应用

extern "C"

JNIEXPORT void JNICALL

Java_com_example_feifei_testjni_TestNatvie_testJNIReference(JNIEnv *env, jobject instance,jobject obj) {

//声明局部变量clazz

jclass clazz = env->GetObjectClass(instance);

//手动释放 局部变量 clazz ;DeleteLocalRef 也可不用手动调用，JNI方法返回之后，会自动释放局部JNI变量

env->DeleteLocalRef(clazz);

//---- 强全局变量

gThiz = env->NewGlobalRef(obj);//生成全局的JNI 对象引用,这样生成的全局的JNI对象 才可以在其他函数中使用

env->DeleteGlobalRef(gThiz);//在我们不需要gThis这个全局JNI对象应用时，可以将其删除。

//---- 全局弱引用

gWeakThiz = env->NewWeakGlobalRef(obj);//生成全局的JNI对象引用，这样生成的全局的JNI对象才可以在其它函数中使用

if(env->IsSameObject(gWeakThiz,NULL)){

LOGD("全局弱引用 已经被释放了");

}

//释放 全局弱应用对象

env->DeleteWeakGlobalRef(gWeakThiz);

}

5、JNI 进程间同步

JNI可以使用Java对象进行线程同步

MonitorEnter函数用来锁定Java对象

MonitorExit函数用来释放Java对象锁

Java类 TestNative.java

/**

* JNI 利用 java 对象进行线程同步

* @param lock

*/

public native void testJNILock(Object lock);

C++ 类 native-lib.cpp

extern "C"

JNIEXPORT void JNICALL

Java_com_example_feifei_testjni_TestNatvie_testJNILock(JNIEnv *env, jobject instance,

jobject lock) {

//加锁

env->MonitorEnter(lock);

//doSomething

LOGD("feifei, this is in lock");

//释放锁

env->MonitorExit(lock);

}

6、JNI异常相关的函数

JNI处理Java异常

当JNI函数调用的Java方法出现异常的时候，并不会影响JNI方法的执行，但是我们并不推荐JNI函数忽略Java方法出现的异常继续执行，这样可能会带来更多的问题。我们推荐的方法是，当JNI函数调用的Java方法出现异常的时候，JNI函数应该合理的停止执行代码。

ExceptionOccurred函数用来判断JNI函数调用的Java方法是否出现异常

ExceptionClear函数用来清除JNI函数调用的Java方法出现的异常

/**

* 1、env->ExceptionOccurred() 判断JNI调用java方法 是否遇到了Exception

* 2、env->ThrowNew() JNI 可以主动抛出Java Exception异常

*/

public native void testJavaException();

C++ 类 native-lib.cpp

extern "C"

JNIEXPORT void JNICALL

Java_com_example_feifei_testjni_TestNatvie_testJavaException(JNIEnv *env, jobject instance) {

jclass clazz = env->GetObjectClass(instance);

if(clazz == NULL) return;

jmethodID helloException_method = env->GetMethodID(clazz,"helloException","()V");

if(helloException_method == NULL )return;

env->CallVoidMethod(instance,helloException_method);

if(env->ExceptionOccurred() != NULL){

// env->ExceptionDescribe();

env->ExceptionClear();

LOGD("feifei,调用java 方法时 遇到了Exception");

return;

}

LOGD("feifei,调用helloException 方法成功了!");

LOGD("feifei,now JNI throw java exception - beging");

jclass expetionClazz = env->FindClass("java/lang/Exception");

if(expetionClazz == NULL) return;

env->ThrowNew(expetionClazz,"this is a exception");

}

JNI抛出Java类型的异常

JNI通过ThrowNew函数抛出Java类型的异常

Java类 TestNative.java

LOGD("feifei,now JNI throw java exception - beging");

jclass expetionClazz = env->FindClass("java/lang/Exception");

if(expetionClazz == NULL) return;

env->ThrowNew(expetionClazz,"this is a exception");

四 JNI 和 Java对象的互相持有

Java对象持久化C/C++对象实例

通常的做法是 将C++对象指针 强转为jlong 类型，保存在调用者java对象的long型变量中，一直持有。

当需要使用该C++对象时,从Java对象中的long变量，强转化为C++对象,进而使用。

TestNative.java

public class TestNatvie {

static {

System.loadLibrary("native-lib");

}

/**

* 用户保存 C++对象的引用

*/

private long mNatvieId;

/**

* Java 对象持有 C++对象

*/

public native void initSDK();

/**

* Java 对象释放 C++对象

*/

public native void releasSDK();

}

native-lib.cpp

extern "C"

JNIEXPORT void JNICALL

Java_com_example_feifei_testjni_TestNatvie_initSDK(JNIEnv *env, jobject instance) {

Person * person = new Person();

person->setAge(18);

person->initSDK();

jclass classzz = env->GetObjectClass(instance);

jfieldID fid = env->GetFieldID(classzz,"mNatvieId","J");

//将C++对象的地址绑定到Java变量中

env->SetLongField(instance,fid,(jlong)person);

}

extern "C"

JNIEXPORT void JNICALL

Java_com_example_feifei_testjni_TestNatvie_releasSDK(JNIEnv *env, jobject instance) {

jclass objectClass = env->GetObjectClass(instance);

jfieldID fid = env->GetFieldID(objectClass,"mNatvieId","J");

//取出java对象中保存的C++对象地址

jlong p = env->GetLongField(instance,fid);

//转换成 C++对象

Person * person = (Person*)p;

person->releaseSDK();

//释放person C++对象

free(person);

env->SetLongField(instance,fid,-1);

}

C/C++ 持久化Java对象

一般做法是

在本地方式中，创建一个全局引用 保存java对象:

env->NewGlobalRef(obj);

这样在其他的JNI方法中就可以任意的使用该java对象了。

在不需要改java对象时，再将JNI全局引用删除即可。

env->DeleteGlobalRef(gThiz);

使用示例：

TestNative.cpp

/**

* 利用JNI全局引用持有java 对象

*/

public native void testJNIReference(Object object);

natvie-lib.cpp

jobject gThiz; //全局JNI对象引用 - 用于持有特定的java对象。

jobject gWeakThiz;//全局JNI对象弱应用

extern "C"

JNIEXPORT void JNICALL

Java_com_example_feifei_testjni_TestNatvie_testJNIReference(JNIEnv *env, jobject instance,jobject obj) {

//---- 强全局变量

gThiz = env->NewGlobalRef(obj);//生成全局的JNI 对象引用,这样生成的全局的JNI对象 才可以在其他函数中使用

env->DeleteGlobalRef(gThiz);//在我们不需要gThis这个全局JNI对象应用时，可以将其删除。

}

参考文章