JNI学习积累之三 ---- 操作JNI函数以及复杂对象传递

原创 2012年05月27日 21:19:13

 

                                                                                       本文原创,转载请注明出处http://blog.csdn.net/qinjuning




         在掌握了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层原型方法:

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

       Native层该方法实现为 :

/*
 * 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层原型方法:

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

      Native层该方法实现为 :

/*
 * 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层原型方法:

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

    Native层该方法实现为 :

/*
 * 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层原型方法:

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层该方法实现为 :

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

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层的方法对应为:

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

     Native层该方法实现为 :       

/*
 * 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层的方法对应为:

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

     Native层该方法实现为 :       

/*
 * 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层的对应方法为:

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

     Native层该方法实现为 :       

/*
 * 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的使用了。哎,怎么学的东西又那么多呢? - -




JNI学习积累之一 ---- 常用函数大全

本文原创,转载请注明出处:http://blog.csdn.net/qinjuning                最近一段时间,在工作方面比较闲,分配的Bug不是很多,于是好好利用这段时间...
  • qinjuning
  • qinjuning
  • 2012年05月23日 17:40
  • 45166

JNI头文件详解(三)对象操作

JNI 中Java对象操作:   对象操作相关函数: (AllocObject,NewObject,NewObjectA,NewObjectV,GetObjectRefType,IsInstanceO...
  • shaohuazuo
  • shaohuazuo
  • 2015年02月04日 20:52
  • 2263

jni object的使用

jbyte * arrayBody = env->GetByteArrayElements(data,0);    jsize theArrayLengthJ = env->GetArra...
  • hetangbian
  • hetangbian
  • 2016年07月05日 09:13
  • 1065

Java中JNI的使用详解第二篇:JNIEnv类型和jobject类型的解释

上一篇说的是一个简单的应用,说明JNI是怎么工作的,这一篇主要来说一下,那个本地方法sayHello的参数的说明,以及其中方法的使用 首先来看一下C++中的sayHello方法的实现: JNIEXPO...
  • jiangwei0910410003
  • jiangwei0910410003
  • 2013年12月21日 14:33
  • 34360

JNI官方规范中文版——如何访问Java中的字段和方法

现在,你知道了如何通过JNI来访问JVM中的基本类型数据和字符串、数组这样的引用类型数据,下一步就是学习怎么样和JVM中任意对象的字段和方法进行交互。比如从本地代码中调用JAVA中的方法,也就是通常说...
  • a345017062
  • a345017062
  • 2012年10月14日 09:26
  • 16277

JNI学习笔记——局部和全局引用

JNI将实例、数组类型暴露为不透明的引用。native代码从不会直接检查一个不透明的引用指针的上下文,而是通过使用JNI函数来访问由不透明的引用所指向的数据结构。因为只处理不透明的引用,这样就不需要担...
  • huguohu2006
  • huguohu2006
  • 2012年03月26日 22:51
  • 13558

深入JNI

JNI连接着java和c++/c层。Android有大量驱动必须在native层实现,还有一些注重性能、功耗的功能在c++/c实现比较好。 从java到native建立的是函数关系。但是从natvi...
  • kc58236582
  • kc58236582
  • 2015年09月17日 18:54
  • 932

JNI 资源释放

JNI 编程实现了 native code 和 Java 程序的交互,因此 JNI 代码编程既遵循 native code 编程语言的编程规则,同时也遵守 JNI 编程的文档规范。在内存管理方面,na...
  • zhangguixian5
  • zhangguixian5
  • 2013年01月10日 15:19
  • 10081

JNI:从C/C++(本地代码)中返回一个对象数组

Java: public class TestJNI { static { System.loadLibrary("TestJNI"); } public native DiskIn...
  • duyiwuer2009
  • duyiwuer2009
  • 2012年07月12日 22:07
  • 7049

JNI返回复杂对象之一

JNI返回复杂对象,对象里面的变量是Hashmap里面装ArrayList
  • cjj198561
  • cjj198561
  • 2014年08月18日 23:03
  • 7948
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:JNI学习积累之三 ---- 操作JNI函数以及复杂对象传递
举报原因:
原因补充:

(最多只允许输入30个字)