JNI使用小结

梦里梦外; 2022-05-27 05:39 235阅读 0赞

以下内容主要参考深入理解Android卷1.

**JNI函数动态注册：**

使用这个数据结构存储一个JNI函数的注册信息：

typedef struct {
    
       //Java中native函数的名字，不用携带包的路径。例如“native_init“。
    
    constchar* name;    
    
    //Java函数的签名信息，用字符串表示，是参数类型和返回值类型的组合。
    
        const char* signature;
    
       void*       fnPtr;  //JNI层对应函数的函数指针，注意它是void*类型。
    
    } JNINativeMethod;

从以上成员看出java中声明的native函数好像可以对应上该jni文件中的函数，但是实际上jni函数的在这个结构上是唯一的，但是java声明的不是，因为不带包路径，只是一个函数名，怎么知道这个函数是哪个类的呢，如果其他java文件也有这样一个同名的native声明呢？其实在注册时，会去获取对应的java类对象（Class类型的对象）。

为JNI动态库中的所有JNI函数建立一个JNINativeMethod数组，注册就用这个数组作为参数。示例：

static JNINativeMethod g_methods[] = {
        {"nativeSetBlueLightFilterStrength", "(I)Z", (void*)nativeSetBlueLightFilterStrength},
        {"nativeGetBlueLightFilterStrength", "()I", (void*)nativeGetBlueLightFilterStrength},
        {"nativeEnableBlueLightFilter", "(Z)Z", (void*)nativeEnableBlueLightFilter},
        {"nativeIsBlueLightFilterEnabled", "()Z", (void*)nativeIsBlueLightFilterEnabled},
        {"nativeGetBlueLightFilterStrengthRange", "()I", (void*)nativeGetBlueLightFilterStrengthRange},
        {"nativeBlueLightFilterInit", "()Z", (void*)nativeBlueLightFilterInit},
    };

JNI函数签名：

JNI规范定义的函数签名信息格式：

(参数1类型标示参数2类型标示...参数n类型标示)返回值类型标示

比较繁琐，具体编码时，读者可以定义字符串宏

类型标示示意表

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;"> 类型标示 </td> 
 <td style="vertical-align:top;"> Java类型 </td> 
 <td style="vertical-align:top;"> 类型标示 </td> 
 <td style="vertical-align:top;"> Java类型 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> Z </td> 
 <td style="vertical-align:top;"> boolean </td> 
 <td style="vertical-align:top;"> F </td> 
 <td style="vertical-align:top;"> float </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> B </td> 
 <td style="vertical-align:top;"> byte </td> 
 <td style="vertical-align:top;"> D </td> 
 <td style="vertical-align:top;"> double </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> C </td> 
 <td style="vertical-align:top;"> char </td> 
 <td style="vertical-align:top;"> Ljava/lang/String; </td> 
 <td style="vertical-align:top;"> String </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> S </td> 
 <td style="vertical-align:top;"> short </td> 
 <td style="vertical-align:top;"> [I </td> 
 <td style="vertical-align:top;"> int[] </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> I </td> 
 <td style="vertical-align:top;"> int </td> 
 <td style="vertical-align:top;"> [Lava/lang/object; </td> 
 <td style="vertical-align:top;"> Object[] </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> J </td> 
 <td style="vertical-align:top;"> long </td> 
 <td style="vertical-align:top;"> &nbsp; </td> 
 <td style="vertical-align:top;"> &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

上面列出了一些常用的类型标示，如果Java类型是数组，则标示中会有一个“\[”，另外，引用类型（除基本类型的数组外）的标示最后都有一个“;”，**返回值签名时也是要加分号的**

函数签名小例子

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;"> 函数签名 </td> 
 <td style="vertical-align:top;"> Java函数 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> “()Ljava/lang/String;” </td> 
 <td style="vertical-align:top;"> String f() </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> “(ILjava/lang/Class;)J” </td> 
 <td style="vertical-align:top;"> long f(int i, Class c) </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> “([B)V” </td> 
 <td style="vertical-align:top;"> void f(byte[] bytes) </td> 
 </tr> 
 </tbody> 
</table>

当Java层通过System.loadLibrary加载完JNI动态库后，紧接着会查找该库中一个叫JNI\_OnLoad的函数，如果有，就调用它，而动态注册的工作就是在这里完成的。

在JNI\_OnLoad函数中注册会用到一下两行代码：

/*
    
    env指向一个JNIEnv结构体，classname为对应的Java类名（全路径名，包名+类名），由于
    
    JNINativeMethod中使用的函数名并非全路径名，所以要指明是哪个类。
    
    */
    
    jclass clazz =  (*env)->FindClass(env, className);
    
    //调用JNIEnv的RegisterNatives函数，注册关联关系。
    
    (*env)->RegisterNatives(env, clazz, gMethods,numMethods);

示例：

/*
 * Register several native methods for one class.
 */
 static int registerNativeMethods(JNIEnv* env, const char* className,
 JNINativeMethod* gMethods, int numMethods)
 {
 jclass clazz;
 
 clazz = env->FindClass(className);
 if (clazz == NULL) {
 ALOGE("Native registration unable to find class '%s'", className);
 return JNI_FALSE;
 }
 if (env->RegisterNatives(clazz, gMethods, numMethods) < 0) {
 ALOGE("RegisterNatives failed for '%s'", className);
 return JNI_FALSE;
 }
 
 return JNI_TRUE;
 }
 
 // ----------------------------------------------------------------------------
 
 /*
 * This is called by the VM when the shared library is first loaded.
 */
 
 jint JNI_OnLoad(JavaVM* vm, void* reserved)
 {
 //该函数的第一个参数类型为JavaVM,这可是虚拟机在JNI层的代表喔，每个Java进程只有一个
  JNIEnv* env = NULL;
 jint result = -1;
 
 UNUSED(reserved);
 
 ALOGI("JNI_OnLoad");
 
 if (JNI_OK != vm->GetEnv((void **)&env, JNI_VERSION_1_4)) {
 ALOGE("ERROR: GetEnv failed");
 goto bail;
 }
 
 if (!registerNativeMethods(env, classPathName, g_methods, sizeof(g_methods) / sizeof(g_methods[0]))) {
 ALOGE("ERROR: registerNatives failed");
 goto bail;
 }
 //必须返回这个值，否则会报错。
 result = JNI_VERSION_1_4;
 
 bail:
 return result;
 }

**静态注册：**

extern "C" JNIEXPORT jstring
    JNICALL
    Java_com_champion_ndkhelloword_MainActivity_stringFromJNI(
            JNIEnv *env,
            jobject /* this */) {
        std::string hello = "Hello from C++";
        return env->NewStringUTF(hello.c_str());
    }

必须带上extern "C"，但是JNIEXPORT和JNICALL是可以带也可以不带上。不影响程序执行，只是标记作用。动态注册则不用带上extern "C"。开始猜想可能是因为动态注册时带上了签名，包含了参数类型，这就符合了C++对重载函数的描述要求，而静态注册则只会根据名字查找。但是后面实践证明，无论是动态注册还是静态注册都不允许JNI函数重载。

在一个Java文件中，允许部分native函数是静态注册，而部分是动态注册的。

\-----------------------------------------------------------------------------------------------

JNI层代码中一般要包含jni.h这个头文件。Android源码中提供了一个帮助头文件JNIHelp.h，它内部其实就包含了jni.h，所以我们在自己的代码中直接包含这个JNIHelp.h即可。

头文件路径可以通过在Android.mk中指定：

LOCAL_C_INCLUDES := $(JNI_H_INCLUDE) \
            $(MTK_PATH_SOURCE)/hardware/pq/mt8163/inc

java调用native函数时，可以传递任意java类型的对象。在jni函数中，并不能识别具体的对象类型，jni函数通过类似java反射的技术调用java层传过来的对象的成员和方法。

2. 数据类型转换

通过前面的分析，解决了JNI函数的注册问题。下面来研究数据类型转换的问题。

在Java中调用native函数传递的参数是Java数据类型，那么这些参数类型到了JNI层会变成什么呢？

Java数据类型分为基本数据类型和引用数据类型两种，JNI层也是区别对待这二者的。先来看基本数据类型的转换。

（1）基本类型的转换

基本类型的转换很简单，可用表2-1表示：

表2-1 基本数据类型转换关系表

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;"> Java </td> 
 <td style="vertical-align:top;"> Native类型 </td> 
 <td style="vertical-align:top;"> 符号属性 </td> 
 <td style="vertical-align:top;"> 字长 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> boolean </td> 
 <td style="vertical-align:top;"> jboolean </td> 
 <td style="vertical-align:top;"> 无符号 </td> 
 <td style="vertical-align:top;"> 8位 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> byte </td> 
 <td style="vertical-align:top;"> jbyte </td> 
 <td style="vertical-align:top;"> 无符号 </td> 
 <td style="vertical-align:top;"> 8位 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> char </td> 
 <td style="vertical-align:top;"> jchar </td> 
 <td style="vertical-align:top;"> 无符号 </td> 
 <td style="vertical-align:top;"> 16位 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> short </td> 
 <td style="vertical-align:top;"> jshort </td> 
 <td style="vertical-align:top;"> 有符号 </td> 
 <td style="vertical-align:top;"> 16位 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> int </td> 
 <td style="vertical-align:top;"> jint </td> 
 <td style="vertical-align:top;"> 有符号 </td> 
 <td style="vertical-align:top;"> 32位 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> long </td> 
 <td style="vertical-align:top;"> jlong </td> 
 <td style="vertical-align:top;"> 有符号 </td> 
 <td style="vertical-align:top;"> 64位 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> float </td> 
 <td style="vertical-align:top;"> jfloat </td> 
 <td style="vertical-align:top;"> 有符号 </td> 
 <td style="vertical-align:top;"> 32位 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> double </td> 
 <td style="vertical-align:top;"> jdouble </td> 
 <td style="vertical-align:top;"> 有符号 </td> 
 <td style="vertical-align:top;"> 64位 </td> 
 </tr> 
 </tbody> 
</table>

上面列出了Java基本数据类型和JNI层数据类型对应的转换关系，非常简单。不过，应务必注意，转换成Native类型后对应数据类型的字长，例如jchar在Native语言中是16位，占两个字节，这和普通的char占一个字节的情况完全不一样。上面的基本类型除了注意类型所占字节长度外，在jni中可以混合使用，不会报错。如一个JNIEnv中的方法要求jint类型的，可以直接传一个int类型的，native方法返回类型是jint的，可以直接返回int。

接下来看Java引用数据类型的转换。

（2）引用数据类型的转换

引用数据类型的转换如表2-2所示：

表2-2 Java引用数据类型转换关系表

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;"> Java引用类型 </td> 
 <td style="vertical-align:top;"> Native类型 </td> 
 <td style="vertical-align:top;"> Java引用类型 </td> 
 <td style="vertical-align:top;"> Native类型 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> All objects </td> 
 <td style="vertical-align:top;"> jobject </td> 
 <td style="vertical-align:top;"> char[] </td> 
 <td style="vertical-align:top;"> jcharArray </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> java.lang.Class实例 </td> 
 <td style="vertical-align:top;"> jclass </td> 
 <td style="vertical-align:top;"> short[] </td> 
 <td style="vertical-align:top;"> jshortArray </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> java.lang.String实例 </td> 
 <td style="vertical-align:top;"> jstring </td> 
 <td style="vertical-align:top;"> int[] </td> 
 <td style="vertical-align:top;"> jintArray </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> Object[] </td> 
 <td style="vertical-align:top;"> jobjectArray </td> 
 <td style="vertical-align:top;"> long[] </td> 
 <td style="vertical-align:top;"> jlongArray </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> boolean[] </td> 
 <td style="vertical-align:top;"> jbooleanArray </td> 
 <td style="vertical-align:top;"> float[] </td> 
 <td style="vertical-align:top;"> floatArray </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> byte[] </td> 
 <td style="vertical-align:top;"> jbyteArray </td> 
 <td style="vertical-align:top;"> double[] </td> 
 <td style="vertical-align:top;"> jdoubleArray </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> java.lang.Throwable实例 </td> 
 <td style="vertical-align:top;"> jthrowable </td> 
 <td style="vertical-align:top;"> &nbsp; </td> 
 <td style="vertical-align:top;"> &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

由上表可知：

· 除了Java中基本数据类型的数组、Class、String和Throwable外，其余所有Java对象的数据类型在JNI中都用jobject表示。

JNIEnv是一个和线程相关的，代表JNI环境的结构体。

JNIEnv实际上就是提供了一些JNI系统函数。通过这些函数可以做到：

· 调用Java的函数。

· 操作jobject对象等很多事情。

JNIEnv，是一个和线程有关的变量。也就是说，线程A有一个JNIEnv，线程B有一个JNIEnv。由于线程相关，所以不能在线程B中使用线程A的JNIEnv结构体。读者可能会问，JNIEnv不都是native函数转换成JNI层函数后由虚拟机传进来的吗？使用传进来的这个JNIEnv总不会错吧？是的，在这种情况下使用当然不会出错。不过当后台线程收到一个网络消息，而又需要由Native层函数主动回调Java层函数时，JNIEnv是从何而来呢？根据前面的介绍可知，我们不能保存另外一个线程的JNIEnv结构体，然后把它放到后台线程中来用。这该如何是好？

还记得前面介绍的那个JNI\_OnLoad函数吗？它的第一个参数是JavaVM，它是虚拟机在JNI层的代表，代码如下所示：

//全进程只有一个JavaVM对象，所以可以保存，任何地方使用都没有问题。

jint JNI\_OnLoad(JavaVM\* vm, void\* reserved)

正如上面代码所说，不论进程中有多少个线程，JavaVM却是独此一份，所以在任何地方都可以使用它。那么，JavaVM和JNIEnv又有什么关系呢？答案如下：

· 调用JavaVM的AttachCurrentThread函数，就可得到这个线程的JNIEnv结构体。这样就可以在后台线程中回调Java函数了。

· 另外，后台线程退出前，需要调用JavaVM的DetachCurrentThread函数来释放对应的资源。

操作对象jobject

成员变量和成员函数是由类定义的，它是类的属性，所以在JNI规则中，用jfieldID 和jmethodID 来表示Java类的成员变量和成员函数，它们通过JNIEnv的下面两个函数可以得到：

jfieldID GetFieldID(jclass clazz,const char\*name, const char \*sig);

jmethodID GetMethodID(jclass clazz, const char\*name,const char \*sig);

其中，jclass代表Java类，name表示成员函数或成员变量的名字，sig为这个函数和变量的签名信息。如前所示，成员函数和成员变量都是类的信息，这两个函数的第一个参数都是jclass。

调用method：

NativeType Call<type>Method(JNIEnv \*env,jobject obj,jmethodID methodID, ...)。

示例：

/*
    
    调用JNIEnv的CallVoidMethod函数，注意CallVoidMethod的参数：
    
    第一个是代表MediaScannerClient的jobject对象，
    
    第二个参数是函数scanFile的jmethodID，后面是Java中scanFile的参数。
    
    */
    
           mEnv->CallVoidMethod(mClient, mScanFileMethodID, pathStr,
    
    lastModified, fileSize);

获取成员：

//获得fieldID后，可调用Get<type>Field系列函数获取jobject对应成员变量的值。

NativeType Get<type>Field(JNIEnv \*env,jobject obj,jfieldID fieldID)

//或者调用Set<type>Field系列函数来设置jobject对应成员变量的值。

void Set<type>Field(JNIEnv \*env,jobject obj,jfieldID fieldID,NativeType value)

//下面我们列出一些参加的Get/Set函数。

GetObjectField() SetObjectField()//jstring,jobject,jthrow等类型成员都可以使用该方法进行访问

GetBooleanField() SetBooleanField()

GetByteField() SetByteField()

GetCharField() SetCharField()

GetShortField() SetShortField()

GetIntField() SetIntField()

GetLongField() SetLongField()

GetFloatField() SetFloatField()

GetDoubleField() SetDoubleField()

jstring介绍

获取Java对象中的String成员：

jfieldID fid = env->GetFieldID(clazz,"mStr","Ljava/lang/String;"); 
    jstring js = (jstring)env->GetObjectField(instance,fid);

Java中的String也是引用类型，不过由于它的使用非常频繁，所以在JNI规范中单独创建了一个jstring类型来表示Java中的String类型。虽然jstring是一种独立的数据类型，但是它并没有提供成员函数供操作。相比而言，C++中的string类就有自己的成员函数了。那么该怎么操作jstring呢？还是得依靠JNIEnv提供的帮助。这里看几个有关jstring的函数：

· 调用JNIEnv的NewString(JNIEnv \*env, const jchar\*unicodeChars,jsize len)，可以从Native的字符串得到一个jstring对象。其实，可以把一个jstring对象看成是Java中String对象在JNI层的代表，也就是说，jstring就是一个Java String。但由于Java String存储的是Unicode字符串，所以NewString函数的参数也必须是Unicode字符串。

· 调用JNIEnv的NewStringUTF将根据Native的一个UTF-8字符串得到一个jstring对象。在实际工作中，这个函数用得最多。

· 上面两个函数将本地字符串转换成了Java的String对象，JNIEnv还提供了GetStringChars和GetStringUTFChars函数，它们可以将Java String对象转换成本地字符串。其中GetStringChars得到一个Unicode字符串，而GetStringUTFChars得到一个UTF-8字符串。

· 另外，如果在代码中调用了上面几个函数，在做完相关工作后，就都需要调用ReleaseStringChars或ReleaseStringUTFChars函数对应地释放资源，否则会导致JVM内存泄露。这一点和jstring的内部实现有关系，读者写代码时务必注意这个问题。

为了加深印象，来看processFile是怎么做的：

\[-->android\_media\_MediaScanner.cpp\]

static void

android\_media\_MediaScanner\_processFile(JNIEnv\*env, jobject thiz, jstring path, jstring mimeType, jobject client)

MediaScanner \*mp = (MediaScanner \*)env->GetIntField(thiz,fields.context);

......

//调用JNIEnv的GetStringUTFChars得到本地字符串pathStr

constchar \*pathStr = env->GetStringUTFChars(path, NULL);

......

//使用完后，必须调用ReleaseStringUTFChars释放资源

env->ReleaseStringUTFChars(path, pathStr);

......

垃圾回收

我们知道，Java中创建的对象最后是由垃圾回收器来回收和释放内存的，可它对JNI有什么影响呢？下面看一个例子：

\[-->垃圾回收例子\]

static jobject save\_thiz = NULL; //定义一个全局的jobject

static void

android\_media\_MediaScanner\_processFile(JNIEnv\*env, jobject thiz, jstring path,

jstringmimeType, jobject client)

//保存Java层传入的jobject对象，代表MediaScanner对象

save\_thiz = thiz;

return;

//假设在某个时间，有地方调用callMediaScanner函数

void callMediaScanner()

//在这个函数中操作save\_thiz，会有问题吗？

因为和save\_thiz对应的Java层中的MediaScanner很有可能已经被垃圾回收了，也就是说，save\_thiz保存的这个jobject可能是一个野指针，如使用它，后果会很严重。

将一个引用类型进行赋值操作，它的引用计数不会增加，而垃圾回收机制只会保证那些没有被引用的对象才会被清理。但如果在JNI层使用下面这样的语句，是不会增加引用计数的。

save\_thiz = thiz; //这种赋值不会增加jobject的引用计数。

JNI规范已很好地解决了这一问题，JNI技术一共提供了三种类型的引用，它们分别是：

· Local Reference：本地引用。在JNI层函数中使用的非全局引用对象都是Local Reference。它包括函数调用时传入的jobject、在JNI层函数中创建的jobject。LocalReference最大的特点就是，一旦JNI层函数返回，这些jobject就可能被垃圾回收。

· Global Reference：全局引用，这种对象如不主动释放，就永远不会被垃圾回收。

· Weak Global Reference：弱全局引用，一种特殊的GlobalReference，在运行过程中可能会被垃圾回收。所以在程序中使用它之前，需要调用JNIEnv的IsSameObject判断它是不是被回收了。

平时用得最多的是Local Reference和Global Reference，下面看一个实例，代码如下所示：

\[-->android\_media\_MediaScanner.cpp::MyMediaScannerClient构造函数\]

MyMediaScannerClient(JNIEnv \*env, jobjectclient)

: mEnv(env),

//调用NewGlobalRef创建一个GlobalReference,这样mClient就不用担心被回收了。

mClient(env->NewGlobalRef(client)),

mScanFileMethodID(0),

mHandleStringTagMethodID(0),

mSetMimeTypeMethodID(0)

......

//析构函数

virtual ~MyMediaScannerClient()

mEnv->DeleteGlobalRef(mClient);//调用DeleteGlobalRef释放这个全局引用。

每当JNI层想要保存Java层中的某个对象时，就可以使用Global Reference，使用完后记住释放它就可以了。

\-----------------------------------------------------------------------------------------------------------------------------------

**创建对象：注意构造函数名为<init>**

jclass jc = env->FindClass("com/smile/jnitest/JNITest$TestPoint");
 	//获取构造函数ID（构造函数函数名为<init>，第三个参数为签名，意指传参和返回的对应缩写）
 	jmethodID mid = env->GetMethodID(jc,"<init>","()V");
 	jobject testPoint = env->NewObject(jc,mid );

\----------------------------------------------------------------------------------------------------------------------------------------

## JNI 的 call<>method 与 callNonVirtual<>method ##

nonVirtual应该就是忽略了继承的多态性，即访问的方法，不是实例实际类型的方法，而是引用类型的方法。下面是一个类型：

public class Father {
    
    	@Override
    	public void fun() {
    		// TODO Auto-generated method stub
    		Log.d("333", "Father involked");
    	}
    
    }
    public class Child extends Father{
    	@Override
    	public void fun() {
    		// TODO Auto-generated method stub
    		Log.d("333", "Child involked");
    	}
    }

在如果定义

Father instance = new Child();

在C＋＋中如下调用

jobject fObj = env->GetObjectField(obj,fID);
    jclass fclass=env->FindClass("lc/test/jni/Father");
    jmethodID fm= env->GetMethodID(fclass,"fun","()V");
    env->CallNonvirtualVoidMethod(fObj,fclass,fm);

**Calling Instance Methods of a Superclass（调用实例超类的方法）**

You can call instance methods defined in a superclass that have been overridden in the class to which the object belongs. The JNI provides a set of `CallNonvirtual<type>Method` functions for this purpose. To call instance methods from the superclass that defined them, you do the following:

*  Obtain the method ID from the superclass using `GetMethodID`, as opposed to `GetStaticMethodID)`.
 *  Pass the object, superclass, method Id, and arguments to the family of nonvirtual invocation functions: `CallNonvirtualVoidMethod`, `CallNonvirtualBooleanMethod`, and so on.

It is rare that you will need to invoke the instance methods of a superclass. This facility is similar to calling a superclass method, say `f`, using:

>     super.f();

in Java.

**顺带说下 FindClass( ) 和 getObjectClass( )的区别，因为在写上面的测试代码的时候我出过这个错**

FindClass( ) 就是通过包名类名去找，这个相当于绝对路径吧

getObjectClass( ) 是通过一个obj的类型去找，这个地方需要注意的是，他是通过对象类型去找，不是通过引用类型去找

比如一开始在java 里面写了

Father p=new Child();

那么在C＋＋里面获得这个obj之后，如果用GetObjectClass( ) 获得的就是 Child 的 Class ， 不是 Father 的 Class

\-------------------------------------------------------------------------------------------------------------------------------------------------------------------

**GetStringUTFChars/ReleaseStringUTFChars和Get<Type>ArrayElements/Release<Type>ArrayElements**

其中GetStringUTFChars有一个isCopy的参数，代表是否复制一份在native堆，但是不知道有什么用，反正返回的都是一个const char\*,就是说无法改变其内容的指针。这个const char\*在被调用ReleaseStringUTFChars前有效。

Get<Type>ArrayElements也有个isCopy参数，返回的是jbyte\*，如果isCopy为JNI\_TRUE，那么这个copy而来的buf是可以修改的，而且修改后的数据可以通过Release<Type>ArrayElements覆盖java堆中的数据，是否覆盖决定于Release<Type>ArrayElements的mode参数：

<table> 
 <thead> 
 <tr> 
 <th>mode</th> 
 <th>actions</th> 
 </tr> 
 </thead> 
 <tbody> 
 <tr> 
 <td><code>0</code></td> 
 <td>copy back the content and free the <code>elems</code> buffer</td> 
 </tr> 
 <tr> 
 <td><code>JNI_COMMIT</code></td> 
 <td>copy back the content but do not free the <code>elems</code> buffer</td> 
 </tr> 
 <tr> 
 <td><code>JNI_ABORT</code></td> 
 <td>free the buffer without copying back the possible changes</td> 
 </tr> 
 </tbody> 
</table>

经过实践证明，无论**Get<Type>ArrayElements是否使用isCopy是JNI\_FALSE还是JNI\_TRUE还是NULL，对是否把修改覆盖JAVA堆中的对象都没有关系，只跟Release<Type>ArrayElements时使用的mode有关，而且必须使用Release<Type>ArrayElements才会把修改覆盖Java堆。COMMIT和0都将覆盖Java堆，而JNI\_ABORT则不会。**

\-----------------------------------------------------------------------------------------------------------------------------------------------------------------

[JNI参考指南][JNI]

本人另一篇可以用于学习jni的文章：[SQLite--SQLiteDatabase、SQLiteOpenHelper、sqlite3.c--（jni、头文件）--源码分析基于Android M][SQLite--SQLiteDatabase_SQLiteOpenHelper_sqlite3.c--_jni_--_Android M]

[JNI]: https://docs.oracle.com/javase/9/docs/specs/jni/invocation.html
[SQLite--SQLiteDatabase_SQLiteOpenHelper_sqlite3.c--_jni_--_Android M]: https://blog.csdn.net/b1480521874/article/details/80257931