windows下java JNI编程技巧——JAVA调用c/c++

一、使用情况

    当无法用Java语言编写整个应用程序时,JNI允许您使用本机代码。

    在下列典型情况下,您可能决定使用本机代码:

    1、希望用更低级、更快的编程语言去实现对时间有严格要求的代码。

    2、希望从 Java 程序访问旧代码或代码库。

    3、需要标准 Java 类库中不支持的依赖于平台的特性。

二、所需软件

    eclipse3.4.1、JDK6、VC6.0

三、步骤分析

从 Java 程序调用 C 或 C ++ 代码的过程由六个步骤组成:

我们将在下面几页中深入讨论每个步骤,但还是先让我们迅速地浏览一下它们:

1、编写 Java 代码。

    我们将从编写 Java 类开始,这些类执行三个任务:

    1)声明将要调用的本机方法;

    2)装入包含本机代码的共享库;

    3)然后调用该本机方法。

2、编译 Java 代码。

    在使用 Java 类之前,必须成功地将它们编译成字节码。

3、创建C/C++头文件。
    C/C++头文件将声明想要调用的本机函数说明。

    然后,这个头文件与 C/C++ 函数实现(请参阅步骤 4)一起来创建共享库(请参阅步骤 5)。

4、编写 C/C++ 代码。
   这一步实现 C 或 C++ 源代码文件中的函数。

   C/C++ 源文件必须包含步骤 3 中创建的头文件。

5、创建共享库文件。

   从步骤 4 中创建的C源代码文件来创建共享库文件。

6、运行 Java 程序。

   运行该代码,并查看它是否有用。我们还将讨论一些用于解决常见错误的技巧。


步骤 1:编写 Java 代码
我们从编写 Java 源代码文件开始,它将声明本机方法(或方法),装入包含本机代码的共享库,然后实际调用本机方法。

这里是名为JNI_javaCallc_test:

直接使用文本编辑器或在ecilpos中建立工程敲入以下代码:

[cpp]  view plain copy
  1. package test;  
  2.   
  3. public class JNI_javaCallc_test {  
  4.       
  5.     //c/c++本地方法  
  6.     public native int intMethod(int n);  
  7.       
  8.     public native boolean booleanMethod(boolean bool);  
  9.       
  10.     public native String stringMethod(String text);  
  11.       
  12.     public native int intArrayMethod(int[] intArray);  
  13.       
  14.     //java main方法  
  15.     public static void main(String[] args){  
  16.         //包含c语言动态库  
  17.         System.loadLibrary("test_JNI_javaCallc_test");  
  18.           
  19.         JNI_javaCallc_test sample = new JNI_javaCallc_test();  
  20.           
  21.         int square = sample.intMethod(5);  
  22.           
  23.         boolean bool = sample.booleanMethod(true);  
  24.           
  25.         String text =sample.stringMethod("JAVA");  
  26.             
  27.         int sum = sample.intArrayMethod(new int[] { 1, 1, 2, 3, 5, 8, 13 });  
  28.           
  29.         System.out.println("intMethod: " + square);  
  30.           
  31.         System.out.println("booleanMethod: " + bool);  
  32.           
  33.         System.out.println("stringMethod: " + text);  
  34.           
  35.         System.out.println("intArrayMethod: " + sum);  
  36.     }  
  37. }  

这段代码做了些什么?
    首先,请注意对 native 关键字的使用,它只能随方法一起使用。
    native 关键字告诉 Java 编译器:方法是用 Java 类之外的本机代码实现的,但其声明却在 Java 中。只能在 Java 类中声明本机方法,而不能实现它(但是不能声明为抽象的方法,使用native关键字即可),所以本机方法不能拥有方法主体。

现在,让我们逐行研究一下代码:

从第 6 行到第 12 行,我们声明了四个 native 方法。
在第 17 行,我们装入了包含这些本机方法的实现的共享库文件。(到步骤 5 时,我们将创建该共享库文件。)
最终,从第 21 行到第 27 行,我们调用了本机方法。
注:这个操作和调用非本机 Java 方法的操作没有差异。

步骤 2:编译 Java 代码

接下来,我们需要将 Java 代码编译成字节码。

完成这一步的方法之一是使用随SDK一起提供的Java编译器javac。

用来将 Java 代码编译成字节码的命令是:

cd test
javac JNI_javaCallc_test.java

    如果是在eclipse环境下编写的以上代码,文件保存时会自动在工程目录的bin下生成以上java文件

步骤 3:创建 C/C++ 头文件

第三步是创建 C/C++ 头文件,它定义本机函数说明。

完成这一步的方法之一是使用 javah.exe,它是随 SDK 一起提供的本机方法 C 存根生成器工具。

这个工具被设计成用来创建头文件,该头文件为在 Java 源代码文件中所找到的每个 native 方法定义 C 风格的函数。

这里使用的命令是: 
cd test
javah -classpath . test.JNI_javaCallc_test

注意.和test之间有空格

会生成以下文件:

[cpp]  view plain copy
  1. <span style="font-family:SimSun;font-size:16px;">/* DO NOT EDIT THIS FILE - it is machine generated */  
  2. #include <jni.h>  
  3. /* Header for class test_JNI_javaCallc_test */  
  4.   
  5. #ifndef _Included_test_JNI_javaCallc_test  
  6. #define _Included_test_JNI_javaCallc_test  
  7. #ifdef __cplusplus  
  8. extern "C" {  
  9. #endif  
  10. /* 
  11.  * Class:     test_JNI_javaCallc_test 
  12.  * Method:    intMethod 
  13.  * Signature: (I)I 
  14.  */  
  15. JNIEXPORT jint JNICALL Java_test_JNI_1javaCallc_1test_intMethod  
  16.   (JNIEnv *, jobject, jint);  
  17.   
  18. /* 
  19.  * Class:     test_JNI_javaCallc_test 
  20.  * Method:    booleanMethod 
  21.  * Signature: (Z)Z 
  22.  */  
  23. JNIEXPORT jboolean JNICALL Java_test_JNI_1javaCallc_1test_booleanMethod  
  24.   (JNIEnv *, jobject, jboolean);  
  25.   
  26. /* 
  27.  * Class:     test_JNI_javaCallc_test 
  28.  * Method:    stringMethod 
  29.  * Signature: (Ljava/lang/String;)Ljava/lang/String; 
  30.  */  
  31. JNIEXPORT jstring JNICALL Java_test_JNI_1javaCallc_1test_stringMethod  
  32.   (JNIEnv *, jobject, jstring);  
  33.   
  34. /* 
  35.  * Class:     test_JNI_javaCallc_test 
  36.  * Method:    intArrayMethod 
  37.  * Signature: ([I)I 
  38.  */  
  39. JNIEXPORT jint JNICALL Java_test_JNI_1javaCallc_1test_intArrayMethod  
  40.   (JNIEnv *, jobject, jintArray);  
  41.   
  42. #ifdef __cplusplus  
  43. }  
  44. #endif  
  45. #endif<strong>  
  46. </strong></span>  

关于 C/C++ 头文件

    如您可能已经注意到的那样,JNI_javaCallc_test.h 中的 C/C++ 函数说明和 JNI_javaCallc_test.java 中的 Java native 方法声明有很大差异。

1、JNIEXPORT 和 JNICALL 是用于导出函数的、依赖于编译器的指示符。 

2、返回类型、参数类型是映射到 Java 类型的 C/C++ 类型,比如:jstring,jint

现在来介绍下JNI里的数据类型:

在C++里,编译器会很据所处的平台来为一些基本的数据类型来分配长度,因此也就造成了平台不一致性,而这个问题在Java中则不存在,因为有JVM的缘故,所以Java中的基本数据类型在所有平台下得到的都是相同的长度,比如int的宽度永远都是32位。基于这方面的原因,java和c++的基本数据类型就需要实现一些mapping,保持一致性。

下面的表可以概括:下标列举了常见的c/c++到到java的类型映射表。

    Java类型                      本地类型                 JNI中定义的别名         
intlongjint
long_int64jlong
bytesigned charjbyte
booleanunsigned charjboolean
charunsigned shortjchar
shortshortjshort
floatfloatjfloat
doubledoublejdouble
Object_jobject*jobject

JNI的设计者其实已经帮我们取好了相应的别名以方便记忆。如果想了解一些更加细致的信息,可以去看一些jni.h这个头文件,各种数据类型的定义以及别名就被定义在这个文件中。

除了 Java 声明中的一般参数以外,所有这些函数的参数表中都有一个指向 JNIEnv 和 jobject 的指针。

指向 JNIEnv 的指针实际上是一个指向函数指针表的指针。

正如将要在步骤4 中看到的,这些函数提供各种用来在C和C++中操作Java数据的能力。

jobject 参数引用当前对象

因此,如果C或C++代码需要引用Java函数,则这个jobject 充当引用或指针,返回调用的 Java 对象。

函数名本身是由前缀“Java_”加全限定类名,再加下划线和方法名构成的。


步骤 4:编写 C/C++ 代码

    当谈到编写 C/C++ 函数实现时,有一点需要牢记:说明必须和 JNI_javaCallc_test.h 的函数声明完全一样。

    我们将研究用于 C 实现和 C++ 实现的完整代码,然后讨论两者之间的差异。

C函数实现

以下是 JNI_javaCallc_test.c,它是用 C 编写的实现:

[cpp]  view plain copy
  1. #include <jni.h>  
  2. /* Header for class test_JNI_javaCallc_test */  
  3.   
  4.   
  5. /* 
  6.  * Class:     test_JNI_javaCallc_test 
  7.  * Method:    intMethod 
  8.  * Signature: (I)I 
  9.  */  
  10. JNIEXPORT jint JNICALL Java_test_JNI_1javaCallc_1test_intMethod(JNIEnv *env, jobject obj, jint num)  
  11.  {  
  12.     return num * num;  
  13.  }  
  14.     
  15. /* 
  16.  * Class:     test_JNI_javaCallc_test 
  17.  * Method:    booleanMethod 
  18.  * Signature: (Z)Z 
  19.  */  
  20. JNIEXPORT jboolean JNICALL Java_test_JNI_1javaCallc_1test_booleanMethod  
  21.   (JNIEnv *env, jobject obj, jboolean boolean) {  
  22.    return!boolean;  
  23. }  
  24. /* 
  25.  * Class:     test_JNI_javaCallc_test 
  26.  * Method:    stringMethod 
  27.  * Signature: (Ljava/lang/String;)Ljava/lang/String; 
  28.  */  
  29. JNIEXPORT jstring JNICALL Java_test_JNI_1javaCallc_1test_stringMethod  
  30.   (JNIEnv *env, jobject obj, jstring string)   
  31.   {  
  32.     const char *str = (*env)->GetStringUTFChars(env, string, 0);  
  33.     char cap[128];  
  34.     strcpy(cap, str);  
  35.     (*env)->ReleaseStringUTFChars(env, string, str);  
  36.     return (*env)->NewStringUTF(env, strupr(cap));  
  37. }  
  38.   
  39. /* 
  40.  * Class:     test_JNI_javaCallc_test 
  41.  * Method:    intArrayMethod 
  42.  * Signature: ([I)I 
  43.  */  
  44. JNIEXPORT jint JNICALL Java_test_JNI_1javaCallc_1test_intArrayMethod  
  45.   (JNIEnv *env, jobject obj, jintArray array)   
  46.   {  
  47.     int i, sum = 0;  
  48.     jsize len = (*env)->GetArrayLength(env, array);  
  49.     jint*body = (*env)->GetIntArrayElements(env, array, 0);  
  50.     for(i=0; i<len; i++)  
  51.     {   sum += body[i];  
  52.     }  
  53.     (*env)->ReleaseIntArrayElements(env, array, body, 0);  
  54.     return sum;  
  55. }  


C++ 函数实现

[cpp]  view plain copy
  1. #include <jni.h>  
  2. /* Header for class test_JNI_javaCallc_test */  
  3.   
  4.   
  5. /* 
  6.  * Class:     test_JNI_javaCallc_test 
  7.  * Method:    intMethod 
  8.  * Signature: (I)I 
  9.  */  
  10. JNIEXPORT jint JNICALL Java_test_JNI_1javaCallc_1test_intMethod(JNIEnv *env, jobject obj, jint num)  
  11.  {  
  12.     return num * num;  
  13.  }  
  14.     
  15. /* 
  16.  * Class:     test_JNI_javaCallc_test 
  17.  * Method:    booleanMethod 
  18.  * Signature: (Z)Z 
  19.  */  
  20. JNIEXPORT jboolean JNICALL Java_test_JNI_1javaCallc_1test_booleanMethod  
  21.   (JNIEnv *env, jobject obj, jboolean boolean) {  
  22.    return!boolean;  
  23. }  
  24. /* 
  25.  * Class:     test_JNI_javaCallc_test 
  26.  * Method:    stringMethod 
  27.  * Signature: (Ljava/lang/String;)Ljava/lang/String; 
  28.  */  
  29. JNIEXPORT jstring JNICALL Java_test_JNI_1javaCallc_1test_stringMethod  
  30.   (JNIEnv *env, jobject obj, jstring string)   
  31.   {  
  32.     constchar *str = env->GetStringUTFChars(string, 0);  
  33.     char cap[128];  
  34.     strcpy(cap, str);  
  35.     env->ReleaseStringUTFChars(string, str);  
  36.     returnenv->NewStringUTF(strupr(cap));  
  37. }  
  38.   
  39. /* 
  40.  * Class:     test_JNI_javaCallc_test 
  41.  * Method:    intArrayMethod 
  42.  * Signature: ([I)I 
  43.  */  
  44. JNIEXPORT jint JNICALL Java_test_JNI_1javaCallc_1test_intArrayMethod  
  45.   (JNIEnv *env, jobject obj, jintArray array)   
  46.   {  
  47.      int i,sum = 0;  
  48.      jsizelen = env->GetArrayLength(array);  
  49.      jint*body = env->GetIntArrayElements(array, 0);  
  50.      for(i=0; i<len; i++)  
  51.      {     
  52.         sum += body[i];  
  53.      }  
  54.     env->ReleaseIntArrayElements(array, body, 0);  
  55.      returnsum;  
  56. }  


C 和 C++ 函数实现的比较
唯一的差异在于用来访问 JNI 函数的方法。

在C中,JNI 函数调用由“(*env)->”作前缀,目的是为了取出函数指针所引用的值。

在 C++ 中,JNIEnv 类拥有处理函数指针查找的内联成员函数。

下面将说明这个细微的差异,其中,这两行代码访问同一函数,但每种语言都有各自的语法

C语法:    jsize len = (*env)->GetArrayLength(env,array);

C++语法:  jsize len =env->GetArrayLength(array);


步骤 5:创建共享库文件

接下来,我们创建包含本机代码的共享库文件。

大多数 C 和 C++ 编译器除了可以创建机器代码可执行文件以外,也可以创建共享库文件。

用来创建共享库文件的命令取决于您使用的编译器。

下面是在 Windows执行的命令。

Windows:

使用visual studio commandprompt工具cl.exe

cl -I"C:\Program Files\Java\jdk1.6.0_10\include" -I"C:\Program Files\Java\jdk1.6.0_10\include\win32" -LD test_JNI_javaCallc_test.c -Fe test_JNI_javaCallc_test.dll

也可以使用vc6.0直接建立动态库





编译的时候需要jni相关的头文件和库文件,在vc6.0的的搜索路径加入与java有关的两个路径即可即可

Tools->sptions->Directories



Linux:使用gcc工具
gcc -c -fPIC -I/usr/java/jdk1.6.0_22/include/ -I/usr/java/jdk1.6.0_22/include/linux/ Sample1.c
gcc -shared -fPIC -o libSample1.so Sample1.o

步骤 6:运行 Java 程序
最后一步是运行 Java 程序,并确保代码正确工作。

因为必须在 Java 虚拟机中执行所有 Java 代码,所以需要使用 Java 运行时环境。

完成这一步的方法之一是使用 java,它是随 SDK 一起提供的 Java 解释器。

所使用的命令是:

java -cp . test.test_JNI_javaCallc_test

或者直接在eclipose中运行即可

输出:
intMethod: 25
booleanMethod: false
stringMethod: JAVA
intArrayMethod: 33


原文地址:http://blog.csdn.net/xdw1985829/article/details/6906989

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值