技术转载：Jni学习四：如何编写jni方法

转载：http://blog.chinaunix.net/u1/38994/showart_1099528.html

 

 

一、概述：

在这篇文章中将会简单介绍如何编制一些简单的JNI 方法。我们都知道JNI方法可以帮助我们调用用C/c++编写的函数，这样如果一项工作已经用C/c++语言实现的话，我们就可以不用花很大的力气再用JAVA语言对这一工作进行再实现，只要编制相应的JNI函数，就可以轻松实现JAVA语言对C/c＋＋函数的调用，从而大大减轻程序开发人员的工作量。

在这个项目中，我们编制了很多小实例，通过阅读，运行这些小实例，你可以轻松的学会如何编制JNI方法。这篇文档可以帮助你更好的理解及实现这些实例。

现在让我们进入主题。首先，我们看一下这个项目的体系构架。该项目分为两部分，一部分用c语言是c语言的例子，另一部分是c++语言的例子。每部分都包含java，src源文件目录，以及一个Makefile文件。java目录中是需要调用JNI函数的JAVA源程序，含有后缀名.java。src 目录中含有JNI函数的实现代码，包括.c或.cpp文件和.h文件。Makefile文件是对 java 、src 目录下的文件进行编译组织进而生成可执行文件的文件。当Makefile文件执行以后还会生成以下子目录：lib , class ,bin目录 。lib 目录中包含项目中生成的静态函数库文件libJNIExamples.so，java程序所调用的JNI方法都是通过这个库来调用的。class 目录中包含由java目录下的.java 文件生成的.class文件。bin目录中是一个可执行的shell脚本文件。在执行该脚本的时候，项目所有程序实例的运行结果都将一并显示在屏幕上。


具体执行步骤为：

make

cd bin

./run.sh


下面来介绍一下在这个项目中所实现的实例：

   1. 如何调用标准C/c++中的函数－－例如：printf(...)
   2. 如何调用C/c++中自定义的函数
   3. 如何在jni函数中访问java类中的对象实例域
   4. 如何在jni函数中访问java类中的静态实例域
   5. 如何在jni函数中调用java对象的方法
   6. 如何在jni函数中调用java类的静态方法
   7. 如何在jni函数中传递基本数据类型参数
   8. 如何在jni函数中传递对象类型参数
   9. 如何在jni函数中处理字符串
  10. 如何在jni函数中处理数组
  11. 处理jni函数中的返回值情况
  12. 在jni中实现创建java类对象


二、基本步骤：

在介绍这些例子之前，让我们先来看看编写jni方法所需要的基本步骤，这些实例都是用c来实例来讲解，至于c++的实例和c的实例区别不大，只要作稍微的修改即可，在文档的末尾我们将介绍这些内容：

1、要想定义jni方法，首先得要在java语言中对这一方法进行声明(自然这一声明过程要在类中进行)

声明格式如下：

publicnativevoid print();   System.loadLibrary(“JNIExamples”);   }  

jni 函数用关键字native方法声明。

2、对该类的源文件进行编译使用javac命令，生成相应的.class文件。
3、用javah -jni为函数生成一个在java调用和实际的c函数之间的转换存根，该存根通过从虚拟机栈中取出参数信息，并将其传递给已编译的C函数来实现转换。
4、建立一个特殊的共享库，并从该共享库到处这个存根，在上面的例子中使用了System.loadLibrary，来加载libJNIExamples共享库。


三、配置运行环境：

在编写一个简单的jni函数之前我们必须配置相应的运行环境。jdk的配置在这里就不作介绍，这里主要说的是库的路径。当调用System.loadLibrary(..)时，编译器会到我们系统设置的库路径中寻找该库。修改路径的方法和修改任何环境变量的方法基本相同，只要在/etc/bash.bashrc目录下增加一行LD_LIBRARY_PATH=.:./lib:$(LD_LIBRARY_PATH)即可。也可以通过命令行export LD_LIBRARY_PATH=.:./lib:$(LD_LIBRARY_PATH)


四、运行实例分析：

1、实例一：在jni中调用标准c中自带的函数printf():

下面以实例1为例来详细说明编写jni方法的详细过程。

(1)、定义包含jni函数的类Print.java：

{   /*********************************************************************** * the print() function will call the printf() funcion which is a ANSI c funciton * *************************************************************************/publicnativevoid print();       System.loadLibrary("JNIExamples");     }   }  

在上面的实例中，使用public native void print();语句来定义了一个Print类的jni方法。并用Sysgem.loadLibrary(“JNIExamples”)语句来加载libJNIExamples.so库。注意：加载的语句一定要用static关键字声明在静态块中，以保证引用该类时该库始终被加载。

(2)、对该类进行编译：javac Print.java。生成Print.class类，然后用javah 产生一个Print.h的头文件：javah Print。长生的Print.h文件格式如下：

/* DO NOT EDIT THIS FILE - it is machine generated *//* Header for class Print */  JNIEXPORT void JNICALL Java_Print_print     (JNIEnv *, jobject);   }   

其中的加粗字体为要实现的JNI函数生命部分。

(3)、编写JNI函数的实现部分Print.c

JNIEXPORT void JNICALL Java_Print_print (JNIEnv *env, jobject obj)   {     printf("example1:in this example a printf() function in ANSI C is called\n");     printf("Hello,the output is generated by printf() function in ANSI C\n");   }  

在这个文件中实现了一个简单的Jni方法。该方法调用ANSI C 中的printf()函数，输出了两个句子。

(4)、将本地函数编译到libJNIExamples.so的库中：
使用语句：gcc -fPIC -I/usr/jdk1.5/include -I/usr/jdk1.5/include/linux -shared -o libJNIExamples.so Print.c。

(5)、至此Jni函数已全部实现，可以在java代码中调用拉。
在此我们使用一个简单的类来对实现的jni方法进行测试，下面是PrintTest.java的源代码部分：

publicstaticvoid main(String[] args) {       Print p = new Print();       p.print();     }   }  

(6)、对PrintTest.java进行编译执行得到如下结果：
example1:in this example a printf() function in ANSI C is called
Hello,the output is generated by printf() function in ANSI C .

下面介绍的每个实例实现的步骤也都是按着上述步骤执行的。所以介绍时只介绍实现的关键部分。

2、实例二、调用c 语言用户定义的函数（源程序为：java/Cfunction.java java/C_functionTest.java src/Cfunction.c src/Cfunction.h ）
当需要在java程序中调用用c所实现的函数是，需要在需要调用该c函数的类中定义一个jni方法，在该jni方法中去调用该c函数，相当于用java方法把c函数封装起来，以供java程序调用。
在实例二中我们简单定义了一个printHello()函数，该函数的功能只是输出一句话，如果要在java程序中调用该函数，只需在jni函数中调用即可，和调用ANSI C中自带的prinf()函数没有任何区别。

3、实例三、在jni函数中访问java类中的对象实例域（源程序为：java/CommonField.java java/CommonFieldTest.java src/CommonField.c src/CommonField.h ）
jni函数的实现部分是在c 语言中实现的，如果它想访问java中定义的类对象的实例域需要作三步工作，
（1）调用GetObjectClass()函数得到该对像的类，该函数返回一个jclass类型值。
（2）调用GetFieldID()函数得到要访问的实例域在该类中的id。
（3）调用GetXXXField()来得到要访问的实例域的值。其中XXX和要访问的实例域的类型相对应。
在jni中java 编程语言和c 语言数据类型的对应关系为java原始数据类型前加 'j' 表示对应c语言的数据类型例如boolean 为jboolean ,int 为 jint，double 为jdouble等。对象类型的对应类型为jobject。
在本实例中，您可以看到我们在java/CommonField.java 中定义了类CommonField类，其中包含int a , int b 两个实例域，我们要在jni函数getCommonField()中对这两个域进行访问和修改。你可以在 src/CommonField.c中找到该函数的实现部分。
以下语句是对该域的访问(以下代码摘自：src/CommonField.c)：

jclass class_Field = (*env)->GetObjectClass(env,obj);   jfieldID fdA = (*env)->GetFieldID(env,class_Field,"a","I");   jfieldID fdB = (*env)->GetFieldID(env,class_Field,"b","I");   jint valueA = (*env)->GetIntField(env,obj,fdA);   jint valueB = (*env)->GetIntField(env,obj,fdB);  

在jni中对所有jni函数的调用都要用到env指针，该指针也是每一个本地方法的第一个参数，他是函数指针表的指针，所以，必须在每一个jni调用前面加上(*env)->GetObjectClass(env,obj)函数调用返回obj对像的类型，其中obj 参数表示要你想要得到类型的类对象。
jfieldID GetFieldID(JNIEnv *env,jclass cl, const char name[], const char sig[]) 该函数返回一个域的标识符name 表示域名，sig表示编码的域签名。所谓编码的签名即编码类型的签名在上例中类中的a实例域为int 型，用"I”来表示，同理"B” 表示byte ，"C” 表示 char , “D”表示 double ,”F” 表示float,“J”表示long, “S” 表示short , “V” 表示void ,”Z”表示 boolean类型。
GetIntField(env,obj,fdA)，用来访问obj对象的fdA域，如果要访问的域为double类型，则要使用GetDoubleField(env,obj,fdA)来访问，即类型对应GetXXXField中的XXX。

以下函数用来修改域的值：

(*env)->SetIntField(env,obj,fdA,109);   (*env)->SetIntField(env,obj,fdB,145);  

这和获得域的值类似，只是该函数多了一个要设置给该域的值参数。
访问对象实例域的相关函数如下：
jfieldID GetFieldID(JNIEnv *env, jclass cl, const char name[], const char sig[])
该函数返回一个域的标识符。各参数含义如下：
env JNI 接口指针；cl 类对象 ； name 域名； sig 编码的域签名

XXX GetXXXField(JNIEnv *env, jobject obj, jfieldID id)
该函数返回域的值。域类型XXX是Object, Boolean, byte, char , short, int ,long ,float， double 中类型之一。
参数 env JNI借口指针；obj为域所在对象；id为域的标识符。
void SetXXXField(JNIEnv *env,jobject obj, jfieldID id, XXX value)

该函数用于设置域的值。XXX的含义同上，
参数中env, obj , id 的含义也同上，value 值为将要设置的值。

4、实例四：在jni函数中访问类的静态实例域 （java/Field.java java/FieldTest.java src/Field.c src/Field.h）

因为静态实例域并不属于某个对象，而是属于一个类，所以在要访问静态实例域时，和访问对象的实例域不同，它所调用的函数是（以实例四来说明,一下代码摘自src/Field.c）：

jclass class_Field = (*env)->FindClass(env,"Field");   jfieldID fdA = (*env)->GetStaticFieldID(env,class_Field,"a","I");   jint valueA = (*env)->GetStaticIntField(env,class_Field,fdA);   (*env)->SetStaticIntField(env,class_Field,fdA,111);  

由于没有对象，必须使用FindClass代替GetObjectClass来获得类引用。在FindClass()的第二个参数是类的编码签名，类的编码签名和基本类型的编码签名有所不同，如果类在当前包中，就直接是类的名称，如果类不在当前包中则要加入该类的详细路径：例如String类在java.lang包中，则String的签名要写成( Ljava/lang/String;),其中的（L和；）是不可少的，其中（；）是表达是的终止符。其他三个函数和访问对象数据域基本没什么区别。

5、实例五：在jni函数中调用java对象的方法(java/CommonMethod.java java/CommonMethodTest.java src/CommonMehod.c src/CommonMethod.h )

在jni函数中我们不仅要对java对象的数据域进行访问，而且有时也需要调用java中类对象已经实现的方法，实例五就是关于这方面的实现的。在src/CommonMethod.c中我们可以找到下面的代码：

JNIEXPORT void JNICALL Java_CommonMethod_callMethod   (JNIEnv *env, jobject obj, jint a, jstring s)   {     printf("example 5:in this example,a object's method will be called\n");     jclass class_CommonMethod = (*env)->GetObjectClass(env,obj);     jmethodID md = (*env)->GetMethodID(env,class_CommonMethod,"print","(ILjava/lang/String;)V");     (*env)->CallVoidMethod(env,obj,md,a,s);   }  

该代码部分展示了如何实现对java类对象函数的调用过程。从以上代码部分我们可以看到，要实现该调用需要有三个步骤，调用三个函数

jclass class_CommonMethod = (*env)->GetObjectClass(env,obj);   jmethodID md = (*env)->GetMethodID(env,class_CommonMethod,"print","(ILjava/lang/String;)V");   (*env)->CallVoidMethod(env,obj,md,a,s);  

GetObjectClass(...)函数获得要调用对象的类；GetMethodID(...)获得要调用的方法相对于该类的ID号；CallXXXMethod(...)调用该方法。
在编写该调用过程的时候，需要注意的仍然是GetMethodID(...)函数中编码签名的问题，在该实例中，我们要做的是找到CommonMethod类的print(int a, String s)方法，该方法打印整数a,和字符串s 的直。在函数的编码签名部分（该部分以加粗、并加有下划线）GetMethodID(env,class_CommonMethod,"print","(ILjava/lang/String;)V"); 从左往右可以查看，括号中的内容为要调用方法的参数部分内容，I表示第一个参数为int类型，“Ljava/lang/String;”表示第二个参数为String类型，V表示返回值类型为空void，如果返回值类型不为空，则使用相应的类型签名。返回值类型是和下面将要使用的调用该方法的函数CallXXXMethod(...)相关联的，该函数的xxx要用相应的类型来替换,在此实例中为void，如果返回值类型为int类型则调用该方法的函数就为CallIntMethod(...)。


6、实例六：在jni函数中调用java类的静态方法（java/Method.java java/MethodTest.java src/Method.h src/Method.c)

实例五中介绍了如何调用类对象的方法，在此实例中我们将介绍如何调用java类的静态方法在此实例中我们在/java/Method.java中定义了静态方法：

public static void print() {
  System.out.println("this is a static method of class Method");
}

该函数的功能就是打印字符串“ this is a static method of class Method”；
我们在src/Method.c中实现了对该方法调用的jni函数：

JNIEXPORT void JNICALL Java_Method_callMethod   (JNIEnv *env, jobject obj)   {     printf("example 6:in this example, the class's static method will be called\n");     jclass class_Method = (*env)->FindClass(env,"Method");     jmethodID md = (*env)->GetStaticMethodID(env,class_Method,"print","()V");     (*env)->CallStaticVoidMethod(env,class_Method,md);   }  

和实例五不同的是，我们要调用的三个函数变为：
FindClass(...)、GetStaticMethodID(...)、CallStaticVoidMethod(...)。
其中的机制和实例五是一样的。再次就不做过多的介绍。

7、实例七：jni函数中传递基本数据类型参数（java/Basic.java java/BasicTest.java src/Basic.c src/Basic.h) 在java/Basic.java中，我们定义了一个public native void raiseValue(int a)函数，该函数将打印使value的值增加a,并打印原来的value和新的value值。
在src/Basic.c中给出了该jni函数的实现部分。

JNIEXPORT void JNICALL Java_Basic_raiseValue   (JNIEnv *env, jobject obj, jint a)   {     printf("example 7: in this example, a integer type parament will be passed to the jni method\n");     jclass class_Basic = (*env)->GetObjectClass(env,obj);     jfieldID fd = (*env)->GetFieldID(env,class_Basic,"value","I");     jint v = (*env)->GetIntField(env,obj,fd);     v = v+a;     (*env)->SetIntField(env,obj,fd,v);   }  

在此函数实现中，因为要访问Basic类中的value域，所以调用了GetObjectClass(...), GetFieldID(...), GetIntField(...)函数获取value值，下面一步的 “ = v+a; ”说明，传递基本类型参数的处理方式和在c语言中的基本数据类型的处理无异。


8、实例八：在jni函数中传递对象类型参数（java/Book.java java/BookTest.java src/BookTest.c src/BookTest.h)

  在该实例中演示了在jni函数中传递对象函数的过程。

  我们在该实例中定义了一个类Book

    total_page = t;     }   publicint getTotalPage() {     }   publicint getCurrentPage() {     }       current_page++;     }   }  

然后我们在java/BookTest.java中定义jni函数
public native void bookCurrentStatus(Book b);
该函数需要一个Book类型的参数，并返回该参数的当前状态，包括该书一共有多少页的total_page,以及当前页current_page。函数的实现部分为（src/BookTest.c)

JNIEXPORT void JNICALL Java_BookTest_bookCurrentStatus   (JNIEnv *env, jobject this_obj, jobject obj)   {     printf("example 8: in this example, a object parament will be passed to the jni method。\n");     jclass class_book = (*env)->GetObjectClass(env,obj);     jmethodID id_getTotal = (*env)->GetMethodID(env,class_book,"getTotalPage","()I");     jmethodID id_getCurrent = (*env)->GetMethodID(env,class_book,"getCurrentPage","()I");     jint total_page = (*env)->CallIntMethod(env,obj,id_getTotal);     jint current_page = (*env)->CallIntMethod(env,obj,id_getCurrent);     printf("the total page is:%d and the current page is :%d\n",total_page,current_page);   }  

该函数包含三个参数(JNIEnv *env, jobject this_obj, jobject obj) ，第二个jobject this_obj参数表示当前的jni 函数所属于的类对象，第三个jobject obj参数表示传递的参数Book类型的类对象。
对于实现部分，基本和实例五－－调用java类对象的方法中的操作相同，就不作详解。

9、实例九：在jni函数中处理字符串（java/Str.java java/StrTest.java src/Str.c src/Str.h）
在该实例中我们讲解如何传递、处理字符串参数。
在java/Str.java中我们定义了一个 printString(String s) 的方法，用来处理字符串参数。
在src/Str.c中我们可以看到该函数的实现部分：

JNIEXPORT void JNICALL Java_Str_printString   (JNIEnv *env, jobject obj, jstring s)   {     printf("example 9: in this example, a String object parament will be passed to the jni method.\n");     string = (char*)(*env)->GetStringUTFChars(env,s,NULL);     printf("%s is put out in native method\n",string);     (*env)->ReleaseStringUTFChars(env,s,(jbyte*)string);   }  

实现过程中调用了两个函数：GetStringUTFChars(...)、 ReleaseStringUTFChars(...)。
GetStringUTFChars(...)用来获取String对象的字符串，并将其抓那还为char*类型，这应该字符串就可以在c语言中进行处理拉。ReleaseStringUTFChars(...)用于当该字符串使用完成后，将其进行垃圾回收。记住，当使用完字符串时一定不要忘记调用该函数。

10、实例十：在jni函数中处理数组（java/Arr.java java/ArrTest.java src/Arr.c src/Arr.h)
java中所有的数组类型都有相对应的c语言类型，其中jarray类型表示一个泛型数组
boolean[] --jbooleanArray byte[]--jbyteArray char[]--jcharArary
int[]---jcharArray short[]---jshortArray long[]---jlongArray float[]--jfloatArray
double[]—-jdoubleArray Object[]--- jobjectArray。当访问数组时，可以通过GetObjectAraryElement和SetObjectArrayElement方法访问对象数组的元素。
而对于一般类型数组，你可以调用GetXXXAraryElements来获取一个只想数组起始元素的指针，而当你不在使用该数组时，要记得调用ReleaseXXXArrayElements，这样你所作的改变才能保证在原始数组里得到反映。当然如果你需要得到数组的长度，可以调用GetArrayLength函数。
在本实例中，我们在Arr.java中定义一个本地方法：print(int intArry[]),该函数的功能为对该数组进行输出，在src/Arr.c中我们可以看到该方法的实现过程如下：

JNIEXPORT void JNICALL Java_Arr_print   (JNIEnv *env, jobject obj, jintArray intArray)   {     printf("example 10:in this example, a array parament will be passed to the jni method.\n");     arr = (*env)->GetIntArrayElements(env,intArray,NULL);   //n = (*env)->GetArrayLength(env,intArray);   printf("the native method output the int array\n");   for( i = 0;i<(*env)->GetArrayLength(env,intArray);i++)     {       printf("%d ",arr[i]);     }     (*env)->ReleaseIntArrayElements(env,intArray,arr,0);   }  

我们在此调用了GetIntArrayElements(...)来获取一个指向intArray[]数组第一个元素的指针。
用getArrayLength(..)函数来得到数组的长度，以方便数组遍历时使用。最后应用ReleaseArrayElements(...)函数来释放该数组指针。

11、实例十一：在jni中的返回值问题（java/ReturnValue.java java/ReturnValueTest.java java/BookClass.java src/ReturnValue.c src/ReturnValue.h）
在java/ReturnValue类中定义了三个jni方法： returnInt()，returnString() ,returnObject()
三个方法，分别返回int , String , Object 类型的值。
其在src/ReturnValue.c中的实现分别为：

JNIEXPORT jint JNICALL Java_ReturnValue_returnInt   (JNIEnv *env, jobject obj)   {     jclass class_ReturnValue = (*env)->GetObjectClass(env,obj);     jfieldID fd = (*env)->GetFieldID(env,class_ReturnValue,"value","I");     jint v = (*env)->GetIntField(env,obj,fd);   }      * Signature: ()Ljava/lang/String; JNIEXPORT jstring JNICALL Java_ReturnValue_returnString   (JNIEnv *env, jobject obj)   {     printf("example 11: in this example, the int and object of return value will be proceeding\n");     jclass class_ReturnValue = (*env)->GetObjectClass(env,obj);     jfieldID fd = (*env)->GetFieldID(env,class_ReturnValue,"name","Ljava/lang/String;");     jstring jstr = (jstring)(*env)->GetObjectField(env,obj,fd);   }      * * Method: returnObject JNIEXPORT jobject JNICALL Java_ReturnValue_returnObject   (JNIEnv *env, jobject obj)   {     jclass class_ReturnValue = (*env)->GetObjectClass(env,obj);     jfieldID fd = (*env)->GetFieldID(env,class_ReturnValue,"myBook","LBookClass;");     jobject jbook = (jstring)(*env)->GetObjectField(env,obj,fd);   }  

在这里分别涉及到了对java类对象的一般参数，String参数，以及Object参数的访问。


12、实例十二：在jni中创建java类对象：（java/Test.java src/CreateObj.c src/CreateObj.h）

如果想要在jni函数创建java类对象则要引用java 类的构造器方法，通过调用NewObject函数来实现。
NewObject函数的调用方式为：
jobject obj_new = (*env)->NewObject(env,class, methodid, paraments);
在该实例中，我们在java/Test.java 中定义了Book1类，要在CreateObj类的modifyProperty() jni方法中创建该类对象。我们可以在src/CreateObj.c中看到该jni方法创建对象的过程：

jobject book;   jclass class_book;   jmethodID md_book;   class_book = (*env)->FindClass(env,"LBook1;");   md_book = (*env)->GetMethodID(env,class_book,"<init>","(IILjava/lang/String;)V");   book = (*env)->NewObject(env,class_book,md_book,100,1,"huanghe");  

在创建对象的过程中可以看到，要创建一个java类对象，首先需要得到得到使用FindClass函数得到该类，然后使用GetMethodID方法得到该类的构造器方法id,主义在此时构造器的函数名始终为："”,其后函数的签名要符合函数签名规则。在此我们的构造器有三个参数：int , int, String.
并且其返回值类型要永久为空，所以函数签名为："(IILjava/lang/String;)V"
然后我们调用NewObject()函数来创建该类的对象，在此之后就可以使用该对象拉。

以上内容介绍的是jni函数c语言的实现实例。如果想要使用c++的实例，我们只需要把其中的每一个函数调用过程作稍微的修改：
例如：(*env)->NewObject(env,class_book,md_book,100,1,”huanghe”);
修改为：(env)->NewObject(class_book,md_book,100,1,”huanghe”);
即修改(*env)为(env)再把参数中的env去掉。然后把所有c的函数改为c++的函数就OK拉。
具体情况可以去查看我们的c++实例代码.