JNI学习积累之三 - 操作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层原型方法：

[java] view plain copy print ?

1. public class HelloJni {  
2.     ...  
3.     public native void getAJNIString();  
4.     ...  
5. }     

public class HelloJni { ... public native void getAJNIString(); ... }

 

       Native层该方法实现为 :

[java] view plain copy print ?

1.    
2. //返回字符串   
3. JNIEXPORT jstring JNICALL Java_com_feixun_jni_HelloJni_getAJNIString(JNIEnv * env, jobject obj)  
4. {  
5.     jstring str = env->newStringUTF("HelloJNI");  //直接使用该JNI构造一个jstring对象返回   
6.     return str ;  
7. }  

 //返回字符串 JNIEXPORT jstring JNICALL Java_com_feixun_jni_HelloJni_getAJNIString(JNIEnv * env, jobject obj) { jstring str = env->newStringUTF("HelloJNI"); //直接使用该JNI构造一个jstring对象返回 return str ; }

 

 

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

    Java层原型方法：

[java] view plain copy print ?

1. public class HelloJni {  
2.     ...  
3.     //参数代表几行几列数组 ，形式如：int a[dimon][dimon]   
4.     private native int[][] getTwoArray(int dimon) ;   
5.     ...  
6. }     

public class HelloJni { ... //参数代表几行几列数组 ，形式如：int a[dimon][dimon] private native int[][] getTwoArray(int dimon) ; ... }

      Native层该方法实现为 :

[java] view plain copy print ?

1.   
2. //通过构造一个数组的数组， 返回 一个二维数组的形式   
3. JNIEXPORT jobjectArray JNICALL Java_com_feixun_jni_HelloJni_getTwoArray  
4.   (JNIEnv * env, jobject object, jint dimion)  
5. {  
6.       
7.     jclass intArrayClass = env->FindClass("[I"); //获得一维数组 的类引用，即jintArray类型   
8.     //构造一个指向jintArray类一维数组的对象数组，该对象数组初始大小为dimion   
9.     jobjectArray obejctIntArray  =  env->NewObjectArray(dimion ,intArrayClass , NULL);  
10.   
11.     //构建dimion个一维数组，并且将其引用赋值给obejctIntArray对象数组   
12.     for( int i = 0 ; i< dimion  ; i++ )  
13.     {  
14.         //构建jint型一维数组   
15.         jintArray intArray = env->NewIntArray(dimion);  
16.   
17.         jint temp[10]  ;  //初始化一个容器，假设 dimion  < 10 ;   
18.         for( int j = 0 ; j < dimion ; j++)  
19.         {  
20.             temp[j] = i + j  ; //赋值   
21.         }  
22.           
23.         //设置jit型一维数组的值   
24.         env->SetIntArrayRegion(intArray, 0 , dimion ,temp);  
25.         //给object对象数组赋值，即保持对jint一维数组的引用   
26.         env->SetObjectArrayElement(obejctIntArray , i ,intArray);  
27.   
28.         env->DeleteLocalRef(intArray);  //删除局部引用   
29.     }  
30.   
31.     return   obejctIntArray; //返回该对象数组   
32. }  

//通过构造一个数组的数组， 返回 一个二维数组的形式 JNIEXPORT jobjectArray JNICALL Java_com_feixun_jni_HelloJni_getTwoArray (JNIEnv * env, jobject object, jint dimion) { jclass intArrayClass = env->FindClass("[I"); //获得一维数组 的类引用，即jintArray类型 //构造一个指向jintArray类一维数组的对象数组，该对象数组初始大小为dimion jobjectArray obejctIntArray = env->NewObjectArray(dimion ,intArrayClass , NULL); //构建dimion个一维数组，并且将其引用赋值给obejctIntArray对象数组 for( int i = 0 ; i< dimion ; i++ ) { //构建jint型一维数组 jintArray intArray = env->NewIntArray(dimion); jint temp[10] ; //初始化一个容器，假设 dimion < 10 ; for( int j = 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); //删除局部引用 } return obejctIntArray; //返回该对象数组 }

 

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

     Java层原型方法：

[java] view plain copy print ?

1. public class HelloJni {  
2.     ...  
3.     //在Native层读取/设置属性值   
4.     public native void native_set_name() ;  
5.     ...  
6.       
7.     private String name = "I am at Java" ; //类属性   
8. }     

public class HelloJni { ... //在Native层读取/设置属性值 public native void native_set_name() ; ... private String name = "I am at Java" ; //类属性 }

    Native层该方法实现为 :

[java] view plain copy print ?

1.   
2. //在Native层操作Java对象，读取/设置属性等   
3. JNIEXPORT void JNICALL Java_com_feixun_jni_HelloJni_native_1set_1name  
4.   (JNIEnv *env , jobject  obj )  //obj代表执行此JNI操作的类实例引用   
5. {  
6.    //获得jfieldID 以及 该字段的初始值   
7.    jfieldID  nameFieldId ;  
8.   
9.    jclass cls = env->GetObjectClass(obj);  //获得Java层该对象实例的类引用，即HelloJNI类引用   
10.   
11.    nameFieldId = env->GetFieldID(cls , "name" , "Ljava/lang/String;"); //获得属性句柄   
12.   
13.    if(nameFieldId == NULL)  
14.    {  
15.        cout << " 没有得到name 的句柄Id \n;" ;  
16.    }  
17.    jstring javaNameStr = (jstring)env->GetObjectField(obj ,nameFieldId);  // 获得该属性的值   
18.    const char * c_javaName = env->GetStringUTFChars(javaNameStr , NULL);  //转换为 char *类型   
19.    string str_name = c_javaName ;    
20.    cout << "the name from java is " << str_name << endl ; //输出显示   
21.    env->ReleaseStringUTFChars(javaNameStr , c_javaName);  //释放局部引用   
22.   
23.    //构造一个jString对象   
24.    char * c_ptr_name = "I come from Native" ;  
25.      
26.    jstring cName = env->NewStringUTF(c_ptr_name); //构造一个jstring对象   
27.   
28.    env->SetObjectField(obj , nameFieldId , cName); // 设置该字段的值   
29. }  

//在Native层操作Java对象，读取/设置属性等 JNIEXPORT void JNICALL Java_com_feixun_jni_HelloJni_native_1set_1name (JNIEnv *env , jobject obj ) //obj代表执行此JNI操作的类实例引用 { //获得jfieldID 以及 该字段的初始值 jfieldID nameFieldId ; jclass cls = env->GetObjectClass(obj); //获得Java层该对象实例的类引用，即HelloJNI类引用 nameFieldId = env->GetFieldID(cls , "name" , "Ljava/lang/String;"); //获得属性句柄 if(nameFieldId == NULL) { cout << " 没有得到name 的句柄Id \n;" ; } jstring javaNameStr = (jstring)env->GetObjectField(obj ,nameFieldId); // 获得该属性的值 const char * c_javaName = env->GetStringUTFChars(javaNameStr , NULL); //转换为 char *类型 string str_name = c_javaName ; cout << "the name from java is " << str_name << endl ; //输出显示 env->ReleaseStringUTFChars(javaNameStr , c_javaName); //释放局部引用 //构造一个jString对象 char * c_ptr_name = "I come from Native" ; jstring cName = env->NewStringUTF(c_ptr_name); //构造一个jstring对象 env->SetObjectField(obj , nameFieldId , cName); // 设置该字段的值 }

 

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

    Java层原型方法：

[java] view plain copy print ?

1. public class HelloJni {  
2.     ...  
3.     //Native层回调的方法实现   
4.     public void callback(String fromNative){       
5.         System.out.println(" I was invoked by native method  ############# " + fromNative);  
6.     };  
7.     public native void doCallBack(); //Native层会调用callback()方法   
8.     ...   
9.       
10.     // main函数   
11.     public static void main(String[] args)   
12.     {  
13.         new HelloJni().ddoCallBack();  
14.     }     
15. }     

public class HelloJni { ... //Native层回调的方法实现 public void callback(String fromNative){ System.out.println(" I was invoked by native method ############# " + fromNative); }; public native void doCallBack(); //Native层会调用callback()方法 ... // main函数 public static void main(String[] args) { new HelloJni().ddoCallBack(); } }

 

    Native层该方法实现为 :

[java] view plain copy print ?

1.   
2. //Native层回调Java类方法   
3. JNIEXPORT void JNICALL Java_com_feixun_jni_HelloJni_doCallBack  
4.   (JNIEnv * env , jobject obj)  
5. {  
6.      //回调Java中的方法   
7.   
8.     jclass cls = env->GetObjectClass(obj);//获得Java类实例   
9.     jmethodID callbackID = env->GetMethodID(cls , "callback" , "(Ljava/lang/String;)V") ;//或得该回调方法句柄   
10.   
11.     if(callbackID == NULL)  
12.     {  
13.          cout << "getMethodId is failed \n" << endl ;  
14.     }  
15.     
16.     jstring native_desc = env->NewStringUTF(" I am Native");  
17.   
18.     env->CallVoidMethod(obj , callbackID , native_desc); //回调该方法，并且传递参数值   
19. }  

//Native层回调Java类方法 JNIEXPORT void JNICALL Java_com_feixun_jni_HelloJni_doCallBack (JNIEnv * env , jobject obj) { //回调Java中的方法 jclass cls = env->GetObjectClass(obj);//获得Java类实例 jmethodID callbackID = env->GetMethodID(cls , "callback" , "(Ljava/lang/String;)V") ;//或得该回调方法句柄 if(callbackID == NULL) { cout << "getMethodId is failed \n" << endl ; } jstring native_desc = env->NewStringUTF(" I am Native"); env->CallVoidMethod(obj , callbackID , native_desc); //回调该方法，并且传递参数值 }

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

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

     Student.java类

[java] view plain copy print ?

1. package com.feixun.jni;  
2.   
3. public class Student  
4. {  
5.     private int age ;  
6.     private String name ;  
7.     //构造函数，什么都不做   
8.     public Student(){ }  
9.       
10.     public Student(int age ,String name){  
11.         this.age = age ;  
12.         this.name = name ;  
13.     }  
14.       
15.     public int getAge() {  
16.         return age;  
17.     }  
18.     public void setAge(int age) {  
19.         this.age = age;  
20.     }  
21.     public String getName() {  
22.         return name;  
23.     }  
24.     public void setName(String name){  
25.         this.name = name;  
26.     }  
27.       
28.     public String toString(){  
29.         return "name --- >" + name + "  age --->" + age ;  
30.     }  
31. }  

package com.feixun.jni; public class Student { private int age ; private String name ; //构造函数，什么都不做 public Student(){ } public Student(int age ,String name){ this.age = age ; this.name = name ; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name){ this.name = name; } public String toString(){ return "name --- >" + name + " age --->" + age ; } }

 

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

     Java层的方法对应为：

[java] view plain copy print ?

1. public class HelloJni {  
2.     ...  
3.     //在Native层返回一个Student对象   
4.     public native Student nativeGetStudentInfo() ;  
5.     ...   
6. }     

public class HelloJni { ... //在Native层返回一个Student对象 public native Student nativeGetStudentInfo() ; ... }

     Native层该方法实现为 :       

[java] view plain copy print ?

1.   
2. //返回一个复杂对象   
3. JNIEXPORT jobject JNICALL Java_com_feixun_jni_HelloJni_nativeGetStudentInfo  
4.   (JNIEnv * env, jobject obl)  
5. {  
6.     //关于包描述符，这儿可以是 com/feixun/jni/Student 或者是 Lcom/feixun/jni/Student;    
7.     //   这两种类型 都可以获得class引用   
8.     jclass stucls = env->FindClass("com/feixun/jni/Student"); //或得Student类引用   
9.   
10.     //获得得该类型的构造函数  函数名为  返回类型必须为 void 即 V   
11.     jmethodID constrocMID = env->GetMethodID(stucls,"","(ILjava/lang/String;)V");  
12.   
13.     jstring str = env->NewStringUTF(" come from Native ");  
14.   
15.     jobject stu_ojb = env->NewObject(stucls,constrocMID,11,str);  //构造一个对象，调用该类的构造函数，并且传递参数   
16.   
17.   
18.     return stu_ojb ;  
19. }  

//返回一个复杂对象 JNIEXPORT jobject JNICALL Java_com_feixun_jni_HelloJni_nativeGetStudentInfo (JNIEnv * env, jobject obl) { //关于包描述符，这儿可以是 com/feixun/jni/Student 或者是 Lcom/feixun/jni/Student; // 这两种类型 都可以获得class引用 jclass stucls = env->FindClass("com/feixun/jni/Student"); //或得Student类引用 //获得得该类型的构造函数 函数名为 返回类型必须为 void 即 V jmethodID constrocMID = env->GetMethodID(stucls,"","(ILjava/lang/String;)V"); jstring str = env->NewStringUTF(" come from Native "); jobject stu_ojb = env->NewObject(stucls,constrocMID,11,str); //构造一个对象，调用该类的构造函数，并且传递参数 return stu_ojb ; }

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

     Java层的方法对应为：

[java] view plain copy print ?

1. public class HelloJni {  
2.     ...  
3.     //在Native层打印Student的信息   
4.     public native void  printStuInfoAtNative(Student stu);  
5.     ...   
6. }  

public class HelloJni { ... //在Native层打印Student的信息 public native void printStuInfoAtNative(Student stu); ... }

 

     Native层该方法实现为 :       

[java] view plain copy print ?

1.   
2. //在Native层输出Student的信息   
3. JNIEXPORT void JNICALL Java_com_feixun_jni_HelloJni_printStuInfoAtNative  
4.   (JNIEnv * env, jobject obj,  jobject obj_stu) //第二个类实例引用代表Student类，即我们传递下来的对象   
5. {  
6.       
7.     jclass stu_cls = env->GetObjectClass(obj_stu); //或得Student类引用   
8.   
9.     if(stu_cls == NULL)  
10.     {  
11.         cout << "GetObjectClass failed \n" ;  
12.     }  
13.     //下面这些函数操作，我们都见过的。O(∩_∩)O~   
14.     jfieldID ageFieldID = env->GetFieldID(stucls,"age","I"); //获得得Student类的属性id    
15.     jfieldID nameFieldID = env->GetFieldID(stucls,"name","Ljava/lang/String;"); // 获得属性ID   
16.   
17.     jint age = env->GetIntField(objstu , ageFieldID);  //获得属性值   
18.     jstring name = (jstring)env->GetObjectField(objstu , nameFieldID);//获得属性值   
19.   
20.     const char * c_name = env->GetStringUTFChars(name ,NULL);//转换成 char *   
21.    
22.     string str_name = c_name ;   
23.     env->ReleaseStringUTFChars(name,c_name); //释放引用   
24.       
25.     cout << " at Native age is :" << age << " # name is " << str_name << endl ;   
26. }  

//在Native层输出Student的信息 JNIEXPORT void JNICALL Java_com_feixun_jni_HelloJni_printStuInfoAtNative (JNIEnv * env, jobject obj, jobject obj_stu) //第二个类实例引用代表Student类，即我们传递下来的对象 { jclass stu_cls = env->GetObjectClass(obj_stu); //或得Student类引用 if(stu_cls == NULL) { cout << "GetObjectClass failed \n" ; } //下面这些函数操作，我们都见过的。O(∩_∩)O~ jfieldID ageFieldID = env->GetFieldID(stucls,"age","I"); //获得得Student类的属性id jfieldID nameFieldID = env->GetFieldID(stucls,"name","Ljava/lang/String;"); // 获得属性ID jint age = env->GetIntField(objstu , ageFieldID); //获得属性值 jstring name = (jstring)env->GetObjectField(objstu , nameFieldID);//获得属性值 const char * c_name = env->GetStringUTFChars(name ,NULL);//转换成 char * string str_name = c_name ; env->ReleaseStringUTFChars(name,c_name); //释放引用 cout << " at Native age is :" << age << " # name is " << str_name << endl ; }

 

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

     Java层的对应方法为：

[java] view plain copy print ?

1. public class HelloJni {  
2.     ...  
3.     //在Native层返回ArrayList集合    
4.     public native ArrayList native_getListStudents();  
5.     ...   
6. }     

public class HelloJni { ... //在Native层返回ArrayList集合 public native ArrayList native_getListStudents(); ... }

     Native层该方法实现为 :       

[java] view plain copy print ?

1.  //获得集合类型的数组   
2. JNIEXPORT jobject JNICALL Java_com_feixun_jni_HelloJni_native_getListStudents  
3.   (JNIEnv * env, jobject obj)  
4. {  
5.     jclass list_cls = env->FindClass("Ljava/util/ArrayList;");//获得ArrayList类引用   
6.   
7.     if(listcls == NULL)  
8.     {  
9.         cout << "listcls is null \n" ;  
10.     }  
11.     jmethodID list_costruct = env->GetMethodID(list_cls , "","()V"); //获得得构造函数Id   
12.   
13.     jobject list_obj = env->NewObject(list_cls , list_costruct); //创建一个Arraylist集合对象   
14.     //或得Arraylist类中的 add()方法ID，其方法原型为： boolean add(Object object) ;   
15.     jmethodID list_add  = env->GetMethodID(list_cls,"add","(Ljava/lang/Object;)Z");   
16.     
17.     jclass stu_cls = env->FindClass("Lcom/feixun/jni/Student;");//获得Student类引用   
18.     //获得该类型的构造函数  函数名为  返回类型必须为 void 即 V   
19.     jmethodID stu_costruct = env->GetMethodID(stu_cls , "", "(ILjava/lang/String;)V");  
20.   
21.     for(int i = 0 ; i < 3 ; i++)  
22.     {  
23.         jstring str = env->NewStringUTF("Native");  
24.         //通过调用该对象的构造函数来new 一个 Student实例   
25.         jobject stu_obj = env->NewObject(stucls , stu_costruct , 10,str);  //构造一个对象   
26.           
27.         env->CallBooleanMethod(list_obj , list_add , stu_obj); //执行Arraylist类实例的add方法，添加一个stu对象   
28.     }  
29.   
30.     return list_obj ;  
31. }  

 //获得集合类型的数组 JNIEXPORT jobject JNICALL Java_com_feixun_jni_HelloJni_native_getListStudents (JNIEnv * env, jobject obj) { jclass list_cls = env->FindClass("Ljava/util/ArrayList;");//获得ArrayList类引用 if(listcls == NULL) { cout << "listcls is null \n" ; } jmethodID list_costruct = env->GetMethodID(list_cls , "","()V"); //获得得构造函数Id jobject list_obj = env->NewObject(list_cls , list_costruct); //创建一个Arraylist集合对象 //或得Arraylist类中的 add()方法ID，其方法原型为： boolean add(Object object) ; jmethodID list_add = env->GetMethodID(list_cls,"add","(Ljava/lang/Object;)Z"); jclass stu_cls = env->FindClass("Lcom/feixun/jni/Student;");//获得Student类引用 //获得该类型的构造函数 函数名为 返回类型必须为 void 即 V jmethodID stu_costruct = env->GetMethodID(stu_cls , "", "(ILjava/lang/String;)V"); for(int i = 0 ; i < 3 ; i++) { jstring str = env->NewStringUTF("Native"); //通过调用该对象的构造函数来new 一个 Student实例 jobject stu_obj = env->NewObject(stucls , stu_costruct , 10,str); //构造一个对象 env->CallBooleanMethod(list_obj , list_add , stu_obj); //执行Arraylist类实例的add方法，添加一个stu对象 } return list_obj ; }

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

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