Android操作JNI函数以及复杂对象传递

在掌握了JNI函数的使用和相关类型的映射后，以及知晓何利用javah工具生成对应的jni函数以及如何生成动态

链接库(windos下就是.dll库，Linux就是.so库了，不懂在Window下生成dll动态库的，具体流程可看我的这篇博客：

《Android中JNI的使用之一：Java原生JNI的使用、javah指令的使用以及图解教材》)。即可掌握JNI的使用了了。

总的来说，JNI是不难的。通过前面的学习相信你应该有所了解。今天，我们从几个简单的小例子，来对JNI进行下实战训练。

可都是些小例子，耐心看咯。

主要操作内容，包括如下几个部分：

1、在Native层返回一个字符串

2、从Native层返回一个int型二维数组(int a[ ][ ])

3、从Native层操作Java层的类： 读取/设置类属性

4、在Native层操作Java层的类：读取/设置类属性、回调Java方法

5、从Native层返回一个复杂对象(即一个类咯)

6、在Java层传递复杂对象至Native层

7、从Native层返回Arraylist集合对象

广而告知，这些操作就是简单的利用一些JNI函数即实现了。so easy 。

一、在Native层返回一个字符串

Java层原型方法：

 publicclassHelloJni{
 ...
 publicnativevoidgetAJNIString();
 ...
 }

Native层该方法实现为 :

 /*
 *Class:com_feixun_jni_HelloJni
 *Method:getAJNIString
 *Signature:()Ljava/lang/String;
 */
 //返回字符串
 JNIEXPORTjstringJNICALLJava_com_feixun_jni_HelloJni_getAJNIString(JNIEnv*env,jobjectobj)
 {
 jstringstr=env->newStringUTF("HelloJNI");//直接使用该JNI构造一个jstring对象返回
 returnstr;
 }

二、在Native层返回一个int型二维数组(inta[ ][ ])

Java层原型方法：

 publicclassHelloJni{
 ...
 //参数代表几行几列数组，形式如：inta[dimon][dimon]
 privatenativeint[][]getTwoArray(intdimon);
 ...
 }

Native层该方法实现为 :

 /*
 *Class:com_feixun_jni_HelloJni
 *Method:getTwoArray
 *Signature:(I)[[I
 */
 //通过构造一个数组的数组，返回一个二维数组的形式
 JNIEXPORTjobjectArrayJNICALLJava_com_feixun_jni_HelloJni_getTwoArray
 (JNIEnv*env,jobjectobject,jintdimion)
 {

 jclassintArrayClass=env->FindClass("[I");//获得一维数组的类引用，即jintArray类型
 //构造一个指向jintArray类一维数组的对象数组，该对象数组初始大小为dimion
 jobjectArrayobejctIntArray=env->NewObjectArray(dimion,intArrayClass,NULL);

 //构建dimion个一维数组，并且将其引用赋值给obejctIntArray对象数组
 for(inti=0;i<dimion;i++)
 {
 //构建jint型一维数组
 jintArrayintArray=env->NewIntArray(dimion);

 jinttemp[10];//初始化一个容器，假设dimion<10;
 for(intj=0;j<dimion;j++)
 {
 temp[j]=i+j;//赋值
 }

 //设置jit型一维数组的值
 env->SetIntArrayRegion(intArray,0,dimion,temp);
 //给object对象数组赋值，即保持对jint一维数组的引用
 env->SetObjectArrayElement(obejctIntArray,i,intArray);

 env->DeleteLocalRef(intArray);//删除局部引用
 }

 returnobejctIntArray;//返回该对象数组
 }

三、在Native层操作Java层的类 ：读取/设置类属性

Java层原型方法：

 publicclassHelloJni{
 ...
 //在Native层读取/设置属性值
 publicnativevoidnative_set_name();
 ...

 privateStringname="IamatJava";//类属性
 }

Native层该方法实现为 :

 /*
 *Class:com_feixun_jni_HelloJni
 *Method:native_set_name
 *Signature:()V
 */
 //在Native层操作Java对象，读取/设置属性等
 JNIEXPORTvoidJNICALLJava_com_feixun_jni_HelloJni_native_1set_1name
 (JNIEnv*env,jobjectobj)//obj代表执行此JNI操作的类实例引用
 {
 //获得jfieldID以及该字段的初始值
 jfieldIDnameFieldId;

 jclasscls=env->GetObjectClass(obj);//获得Java层该对象实例的类引用，即HelloJNI类引用

 nameFieldId=env->GetFieldID(cls,"name","Ljava/lang/String;");//获得属性句柄

 if(nameFieldId==NULL)
 {
 cout<<"没有得到name的句柄Id\n;";
 }
 jstringjavaNameStr=(jstring)env->GetObjectField(obj,nameFieldId);//获得该属性的值
 constchar*c_javaName=env->GetStringUTFChars(javaNameStr,NULL);//转换为char*类型
 stringstr_name=c_javaName;
 cout<<"thenamefromjavais"<<str_name<<endl;//输出显示
 env->ReleaseStringUTFChars(javaNameStr,c_javaName);//释放局部引用

 //构造一个jString对象
 char*c_ptr_name="IcomefromNative";

 jstringcName=env->NewStringUTF(c_ptr_name);//构造一个jstring对象

 env->SetObjectField(obj,nameFieldId,cName);//设置该字段的值
 }

四、在Native层操作Java层的类：回调Java方法

Java层原型方法：

 publicclassHelloJni{
 ...
 //Native层回调的方法实现
 publicvoidcallback(StringfromNative){
 System.out.println("Iwasinvokedbynativemethod#############"+fromNative);
 };
 publicnativevoiddoCallBack();//Native层会调用callback()方法
 ...

 //main函数
 publicstaticvoidmain(String[]args)
 {
 newHelloJni().ddoCallBack();
 }
 }

Native层该方法实现为 :

 /*
 *Class:com_feixun_jni_HelloJni
 *Method:doCallBack
 *Signature:()V
 */
 //Native层回调Java类方法
 JNIEXPORTvoidJNICALLJava_com_feixun_jni_HelloJni_doCallBack
 (JNIEnv*env,jobjectobj)
 {
 //回调Java中的方法

 jclasscls=env->GetObjectClass(obj);//获得Java类实例
 jmethodIDcallbackID=env->GetMethodID(cls,"callback","(Ljava/lang/String;)V");//或得该回调方法句柄

 if(callbackID==NULL)
 {
 cout<<"getMethodIdisfailed\n"<<endl;
 }

 jstringnative_desc=env->NewStringUTF("IamNative");

 env->CallVoidMethod(obj,callbackID,native_desc);//回调该方法，并且传递参数值
 }

接下来，我们会操作复杂对象，也就是Java层的类，包括从Native层返回一个类以及传递一个类到Native层去， 这儿我们

使用的类非常简单，如下：

Student.java类

 packagecom.feixun.jni;

 publicclassStudent
 {
 privateintage;
 privateStringname;
 //构造函数，什么都不做
 publicStudent(){}

 publicStudent(intage,Stringname){
 this.age=age;
 this.name=name;
 }

 publicintgetAge(){
 returnage;
 }
 publicvoidsetAge(intage){
 this.age=age;
 }
 publicStringgetName(){
 returnname;
 }
 publicvoidsetName(Stringname){
 this.name=name;
 }

 publicStringtoString(){
 return"name--->"+name+"age--->"+age;
 }
 }

五、在Native层返回一个复杂对象(即一个类咯)

Java层的方法对应为：

 publicclassHelloJni{
 ...
 //在Native层返回一个Student对象
 publicnativeStudentnativeGetStudentInfo();
 ...
 }

Native层该方法实现为 :

 /*
 *Class:com_feixun_jni_HelloJni
 *Method:nativeGetStudentInfo
 *Signature:()Lcom/feixun/jni/Student;
 */
 //返回一个复杂对象
 JNIEXPORTjobjectJNICALLJava_com_feixun_jni_HelloJni_nativeGetStudentInfo
 (JNIEnv*env,jobjectobl)
 {
 //关于包描述符，这儿可以是com/feixun/jni/Student或者是Lcom/feixun/jni/Student;
 //这两种类型都可以获得class引用
 jclassstucls=env->FindClass("com/feixun/jni/Student");//或得Student类引用

 //获得得该类型的构造函数函数名为<init>返回类型必须为void即V
 jmethodIDconstrocMID=env->GetMethodID(stucls,"<init>","(ILjava/lang/String;)V");

 jstringstr=env->NewStringUTF("comefromNative");

 jobjectstu_ojb=env->NewObject(stucls,constrocMID,11,str);//构造一个对象，调用该类的构造函数，并且传递参数


 returnstu_ojb;
 }

六、从Java层传递复杂对象至Native层

Java层的方法对应为：

 publicclassHelloJni{
 ...
 //在Native层打印Student的信息
 publicnativevoidprintStuInfoAtNative(Studentstu);
 ...
 }

Native层该方法实现为 :

 /*
 *Class:com_feixun_jni_HelloJni
 *Method:printStuInfoAtNative
 *Signature:(Lcom/feixun/jni/Student;)V
 */
 //在Native层输出Student的信息
 JNIEXPORTvoidJNICALLJava_com_feixun_jni_HelloJni_printStuInfoAtNative
 (JNIEnv*env,jobjectobj,jobjectobj_stu)//第二个类实例引用代表Student类，即我们传递下来的对象
 {

 jclassstu_cls=env->GetObjectClass(obj_stu);//或得Student类引用

 if(stu_cls==NULL)
 {
 cout<<"GetObjectClassfailed\n";
 }
 //下面这些函数操作，我们都见过的。O(∩_∩)O~
 jfieldIDageFieldID=env->GetFieldID(stucls,"age","I");//获得得Student类的属性id
 jfieldIDnameFieldID=env->GetFieldID(stucls,"name","Ljava/lang/String;");//获得属性ID

 jintage=env->GetIntField(objstu,ageFieldID);//获得属性值
 jstringname=(jstring)env->GetObjectField(objstu,nameFieldID);//获得属性值

 constchar*c_name=env->GetStringUTFChars(name,NULL);//转换成char*

 stringstr_name=c_name;
 env->ReleaseStringUTFChars(name,c_name);//释放引用

 cout<<"atNativeageis:"<<age<<"#nameis"<<str_name<<endl;
 }

七、最后加个难度，即在Native层返回集合对象(留这儿，以后也好找点)

Java层的对应方法为：

 publicclassHelloJni{
 ...
 //在Native层返回ArrayList集合
 publicnativeArrayList<Student>native_getListStudents();
 ...
 }

Native层该方法实现为 :

 /*
 *Class:com_feixun_jni_HelloJni
 *Method:native_getListStudents
 *Signature:()Ljava/util/ArrayList;
 *///获得集合类型的数组
 JNIEXPORTjobjectJNICALLJava_com_feixun_jni_HelloJni_native_getListStudents
 (JNIEnv*env,jobjectobj)
 {
 jclasslist_cls=env->FindClass("Ljava/util/ArrayList;");//获得ArrayList类引用

 if(listcls==NULL)
 {
 cout<<"listclsisnull\n";
 }
 jmethodIDlist_costruct=env->GetMethodID(list_cls,"<init>","()V");//获得得构造函数Id

 jobjectlist_obj=env->NewObject(list_cls,list_costruct);//创建一个Arraylist集合对象
 //或得Arraylist类中的add()方法ID，其方法原型为：booleanadd(Objectobject);
 jmethodIDlist_add=env->GetMethodID(list_cls,"add","(Ljava/lang/Object;)Z");

 jclassstu_cls=env->FindClass("Lcom/feixun/jni/Student;");//获得Student类引用
 //获得该类型的构造函数函数名为<init>返回类型必须为void即V
 jmethodIDstu_costruct=env->GetMethodID(stu_cls,"<init>","(ILjava/lang/String;)V");

 for(inti=0;i<3;i++)
 {
 jstringstr=env->NewStringUTF("Native");
 //通过调用该对象的构造函数来new一个Student实例
 jobjectstu_obj=env->NewObject(stucls,stu_costruct,10,str);//构造一个对象

 env->CallBooleanMethod(list_obj,list_add,stu_obj);//执行Arraylist类实例的add方法，添加一个stu对象
 }

 returnlist_obj;
 }

最后，如何调用这些JNI函数，大家都懂的，直接调用即可，我就不在贴代码了，免得罗嗦。

OK，本次JNI的学习就算告一段落了。下一步该认真仔细学习下Android中JNI的使用了。哎，怎么学的东西又那么多呢？ - -