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

[java] view
plain copy

print?

public class HelloJni {

...

public native void getAJNIString();

...

}

Native层该方法实现为 :

[java] view
plain copy

print?

/*

* Class: com_feixun_jni_HelloJni

* Method: getAJNIString

* Signature: ()Ljava/lang/String;

*/

//返回字符串

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?

public class HelloJni {

...

//参数代表几行几列数组 ，形式如：int a[dimon][dimon]

private native int[][] getTwoArray(int dimon) ;

...

}

Native层该方法实现为 :

[java] view
plain copy

print?

/*

* Class: com_feixun_jni_HelloJni

* Method: getTwoArray

* Signature: (I)[[I

*/

//通过构造一个数组的数组， 返回 一个二维数组的形式

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?

public class HelloJni {

...

//在Native层读取/设置属性值

public native void native_set_name() ;

...

private String name = "I am at Java" ; //类属性

}

Native层该方法实现为 :

[java] view
plain copy

print?

/*

* Class: com_feixun_jni_HelloJni

* Method: native_set_name

* Signature: ()V

*/

//在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?

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?

/*

* Class: com_feixun_jni_HelloJni

* Method: doCallBack

* Signature: ()V

*/

//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?

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?

public class HelloJni {

...

//在Native层返回一个Student对象

public native Student nativeGetStudentInfo() ;

...

}

Native层该方法实现为 :

[java] view
plain copy

print?

/*

* Class: com_feixun_jni_HelloJni

* Method: nativeGetStudentInfo

* Signature: ()Lcom/feixun/jni/Student;

*/

//返回一个复杂对象

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类引用

//获得得该类型的构造函数 函数名为 <init> 返回类型必须为 void 即 V

jmethodID constrocMID = env->GetMethodID(stucls,"<init>","(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?

public class HelloJni {

...

//在Native层打印Student的信息

public native void printStuInfoAtNative(Student stu);

...

}

Native层该方法实现为 :

[java] view
plain copy

print?

/*

* Class: com_feixun_jni_HelloJni

* Method: printStuInfoAtNative

* Signature: (Lcom/feixun/jni/Student;)V

*/

//在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?

public class HelloJni {

...

//在Native层返回ArrayList集合

public native ArrayList<Student> native_getListStudents();

...

}

Native层该方法实现为 :

[java] view
plain copy

print?

/*

* Class: com_feixun_jni_HelloJni

* Method: native_getListStudents

* Signature: ()Ljava/util/ArrayList;

*/ //获得集合类型的数组

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 , "<init>","()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类引用

//获得该类型的构造函数 函数名为 <init> 返回类型必须为 void 即 V

jmethodID stu_costruct = env->GetMethodID(stu_cls , "<init>", "(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的使用了。哎，怎么学的东西又那么多呢？ - -