本文原创,转载请注明出处: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的使用了。哎,怎么学的东西又那么多呢? - -
分享到:
相关推荐
Android studio JNI函数以及复杂对象传递
传递字符串数组 参数传递 JNI调用 代码清单15-10 在Linux平台上调用C函数的例程——Sample3 public class Sample3 { public native String[] stringMethod(String text); public static void main(String[] ...
3、实例三、在jni函数中访问java类中的对象实例域... 58 4、实例四:在jni函数中访问类的静态实例域... 60 5、实例五:在jni函数中调用java对象的方法... 60 6、实例六:在jni函数中调用java类的静态方法... 61 ...
jni编写的一个示例,示例中包含一带参数的有返回值的函数。
JNI编程常用函数,主要包括java普通数据类型,string类型,自定义对象的传递与返回。 内含java代码及c代码
cocos2d-x 通过JNI实现c/c++和Android的java层函数互调, 本文主要实现两个功能: (1)通过Android sdk的API得到应用程序的包名(PackageName),然后传递给c++层函数。 (2)通过c++函数调用Android的java层函数,显示一...
JNI 中有两种数组操作,基础数据类型数组和对象数组,JNI 对待基础数据类型数组和对象数组是不一样的。 基本数据类型数组 对于基本数据类型数组,JNI 都有和 Java 相对应的结构,在使用起来和基本数据类型的使用...
三、 嵌入式开发应用(JNI小例子) 20 1、 新增一个基础类 22 2、 定义新类继承基础类 23 3、 编写调用类 23 4、 新增两个本地方法 24 5、 修改 RunMain 类 25 6、 新增一个方法处理java对象 26 7、 新增一个方法处理...
支持 POP 、 IMAP 、 SMTP ,以及 AOL 和 GMAIL 电子邮件服务;支持 AIM 、 MSN 、雅虎通和 GTALK ;与谷歌日历同步;与 Android Market 联机;支持谷歌 “ 街景 ” 服务;包装盒内附 数据工具包。 更多信息 ...
Java与C语言混合开发是一种强大的编程技术,它结合了Java的跨平台性和...在C语言中编写本地方法时,需要注意函数名、参数类型和返回值类型的定义,以及内存分配和释放的问题。在Java代码中调用本地方法时,需要先加
A.1.2 访问JNI函数:JNIEnv自变量 A.1.3 传递和使用Java对象 A.1.4 JNI和Java违例 A.1.5 JNI和线程处理 A.1.6 使用现成代码 A.2 微软的解决方案 A.3 J/Direct A.3.1 @dll.import引导命令 A.3.2 com.ms.win32包 A.3.3...
A.1.2 访问JNI函数:JNIEnv自变量 A.1.3 传递和使用Java对象 A.1.4 JNI和Java违例 A.1.5 JNI和线程处理 A.1.6 使用现成代码 A.2 微软的解决方案 A.3 J/Direct A.3.1 @dll.import引导命令 A.3.2 com.ms.win32包 A.3.3...
NDK开发时,C/C++调用Java的函数的一些案例; 传递int类型参数: https://blog.csdn.net/niuba123456/article/details/80978500 传递String类型参数: https://blog.csdn.net/niuba123456/article/details/80978916 ...
但是mLua禁止lua直接操作java对象,如果想在lua中使用java对象,必须使用内置的全局函数实现。mLua区分byte数组和string。在mLua中,java的byte数组对lua端而言,只是一个普通的userdata。在跨语言数据交换的时候,...
Android 本目录下的代码都是来自于我的...JniCallback 演示了如何从Native线程回调Java的函数,相关博文:Android开发实践:JNI层线程回调Java函数示例 JniBuffer 演示了各种从Java端到Native层的Buffer传递方法,相
在这个例子中,我们使用...注意,我们在实现函数中使用了`JNIEnv *env`和`jobject obj`这两个参数,它们分别表示JNI的环境指针和当前对象的引用。这些参数可以让我们方便地在Java和C++之间传递数据和调用其他本地方法。
2014/12/24 星期三 jsp/EL表达式/EL函数 2014/12/25 星期四 2014/12/26 星期五 自定义标签/JSTL标签库/web国际化/java web之设计模式和案例 2014/12/27 星期六 编码实战演练(指导老师:) 2014/12/28 星期日 mysql...
A.1.2 访问JNI函数:JNIEnv自变量 A.1.3 传递和使用Java对象 A.1.4 JNI和Java违例 A.1.5 JNI和线程处理 A.1.6 使用现成代码 A.2 微软的解决方案 A.3 J/Direct A.3.1 @dll.import引导命令 A.3.2 com.ms.win32包 A.3.3...
A.1.2 访问JNI函数:JNIEnv自变量 A.1.3 传递和使用Java对象 A.1.4 JNI和Java违例 A.1.5 JNI和线程处理 A.1.6 使用现成代码 A.2 微软的解决方案 A.3 J/Direct A.3.1 @dll.import引导命令 A.3.2 com.ms.win32...
A.1.2 访问JNI函数:JNIEnv自变量 A.1.3 传递和使用Java对象 A.1.4 JNI和Java违例 A.1.5 JNI和线程处理 A.1.6 使用现成代码 A.2 微软的解决方案 A.3 J/Direct A.3.1 @dll.import引导命令 A.3.2 com.ms.win32包 A.3.3...