一、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函数参数
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代码的字段和方法
文章图片
三、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!";
jstringjstring = 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) {//获取类名
jclassclazz = env->GetObjectClass(instance);
if(clazz == NULL) return;
jmethodIDjavaMethod = env->GetMethodID(clazz,"helloworld","(Ljava/lang/String;
)V");
if(javaMethod == NULL)return;
const char * msg = "nancy";
jstringjmsg = 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) {jclassclazz = env->GetObjectClass(student);
if(clazz == NULL )return;
// 获取Object 实例属性
jfieldIDnameId = env->GetFieldID(clazz,"name","Ljava/lang/String;
");
jstring jname = (jstring)env->GetObjectField(student,nameId);
jfieldIDageId = env->GetFieldID(clazz,"age","I");
jint jage = env->GetIntField(student,ageId);
const char * name = env->GetStringUTFChars(jname,false);
env->ReleaseStringUTFChars(jname,name);
//获取java 类属性:jfieldIDgradeId = env->GetStaticFieldID(clazz,"grade","I");
jintjgrade = env->GetStaticIntField(clazz,gradeId);
jfieldIDnickeNameID = env->GetStaticFieldID(clazz,"nickname","Ljava/lang/String;
");
jstringjnickname = (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对象
- NewWeakGlobalRef用来创建弱全局引用的JNI对象
- DeleteWeakGlobalRef用来删除弱全局引用的JNI对象
- IsSameObject用来判断两个JNI对象是否相同
/**
* 测试 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对象是否相同
*/jobjectgThiz;
//全局JNI对象引用
jobjectgWeakThiz;
//全局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对象锁
/**
* 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) {jclassclazz = 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");
jclassexpetionClazz = 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");
jclassexpetionClazz = 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++对象地址
jlongp = 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
jobjectgThiz;
//全局JNI对象引用 - 用于持有特定的java对象。
jobjectgWeakThiz;
//全局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对象应用时，可以将其删除。}【你所需要知道的jni知识】本篇为转载,原文地址：https://www.jianshu.com/p/6cbdda111570
推荐阅读
- Android进阶|Android官方文档之Services
- android|【Android进阶】如何写一个很屌的动画（1）---先实现一个简易的自定义动画框架
- Android:仿“某音”APP 多头像跳动动画+轮播动画+心跳动画+输入框抖动动画
- Android RxJava第一弹之原理详解、使用详解、常用场景（基于Rxjava2.0）
- Android应用层|Android事件总线（一）EventBus3.0用法全解析
- EventBus3.0的使用详解
- Android进阶之事件拦截处理机制
- Android进阶|手撸一个简单的网络框架
- Android框架层|腾讯面试官（了解Java Binder中的系统服务吗（））
- Android进阶|Android Binder原理（四）ServiceManager的启动过程