JNI學習積累之三 ---- 操做JNI函數以及複雜對象傳遞

時間 2019-11-09

標籤 jni 學習積累之三函數以及複雜對象傳遞简体版

原文原文鏈接

在掌握了JNI函數的使用和相關類型的映射後，以及知曉何利用javah工具生成對應的jni函數以及如何生成動態java

連接庫 (windos下就是.dll庫，Linux就是.so庫了，不懂在Window下生成dll動態庫的，具體流程可看個人這篇博客：數組

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

總的來講，JNI是不難的。經過前面的學習相信你應該有所瞭解。今天，咱們從幾個簡單的小例子，來對JNI進行下實戰訓練。工具

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

主要操做內容，包括以下幾個部分：this

一、在Native層返回一個字符串對象

二、從Native層返回一個int型二維數組(int a[ ][ ]) 字符串

三、從Native層操做Java層的類：讀取/設置類屬性get

四、在Native層操做Java層的類：讀取/設置類屬性、回調Java方法原型

五、從Native層返回一個複雜對象(即一個類咯)

六、在Java層傳遞複雜對象至Native層

七、從Native層返回Arraylist集合對象

廣而告知，這些操做就是簡單的利用一些JNI函數即實現了。so easy 。

1、在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 ;
}

2、在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; //返回該對象數組
}

3、在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); // 設置該字段的值
}

4、在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 ;
}
}

5、在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 ;
}

6、從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 ;
}

7、最後加個難度，即在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 ;
}