基本JNI调用技术(c/c 与java互调

最新推荐文章于 2022-04-12 23:17:38 发布
最新推荐文章于 2022-04-12 23:17:38 发布
阅读量991 收藏
点赞数
分类专栏： ANDROID

注意我就是错在这个些包的名字上，导致调用失败

1,在项目根目录下建立文件夹libs/armeabi文件夹

2,将so库放入libs/armeabi文件夹注意事项：

1,如果采用静态注册的方式请注意C文件中严格按照命名规则Java_packageName_className_method()的方式命名

2,在Android项目中建立同上述命名规则中packageName中相同的包名,在此包名下建立同上述命名规则中className相同的类名

3,在className声明native方法

4,程序中加载so库System.loadLibrary(data/data/xxx.xxx.xxx/lib/xx.so)或者System.loadLibrary(xx),

      例如：System.loadLibrary(data/data/com.dtBank.app.service/lib/libjnixcld.so);

 

一、jni简介：

JNI一直以来都很少去关注，但却是我心中的一个结，最近这几天刚好手头有点时间，因此抽空看了一下这方面的东西，整理了一份文档，JNI技术的出现主要是基于三个方面的应用需求：

 

1. 解决性能问题
Java具有平台无关性，这使人们在开发企业级应用的时候总是把它作为主要候选方案之一，但是性能方面的因素又大大削弱了它的竞争力。为此，提高Java的性能就显得十分重要。Sun公司及Java的支持者们为提高Java的运行速度已经做出了许多努力，其中大多数集中在程序设计的方法和模式选择方面。由于算法和设计模式的优化是通用的，对Java有效的优化算法和设计模式，对其他编译语言也基本同样适用，因此不能从根本上改变Java程序与编译型语言在执行效率方面的差异。由此，于是人们开始引入JIT(Just In Time，及时编译)的概念。它的基本原理是：首先通过Java编译器把Java源代码编译成平台无关的二进制字节码。然后在Java程序真正执行之前，系统通过JIT编译器把Java的字节码编译为本地化机器码。最后，系统执行本地化机器码，节省了对字节码进行解释的时间。这样做的优点是大大提高了Java程序的性能，缩短了加载程序的时间；同时，由于编译的结果并不在程序运行间保存，因此也节约了存储空间。缺点是由于JIT编译器对所有的代码都想优化，因此同样也占用了很多时间。

 

动态优化技术是提高Java性能的另一个尝试。该技术试图通过把Java源程序直接编译成机器码，以充分利用Java动态编译和静态编译技术来提高Java的性能。该方法把输入的Java源码或字节码转换为经过高度优化的可执行代码和动态库 (Windows中的. dll文件或Unix中的. so文件)。该技术能大大提高程序的性能，但却破坏了Java的可移植性。

JNI(Java Native Interface, Java本地化方法)技术由此闪亮登场。因为采用JNI技术只是针对一些严重影响Java性能的代码段，该部分可能只占源程序的极少部分，所以几乎可以不考虑该部分代码在主流平台之间移植的工作量。同时，也不必过分担心类型匹配问题，我们完全可以控制代码不出现这种错误。此外，也不必担心安全控制问题，因为Java安全模型已扩展为允许非系统类加载和调用本地方法。根据Java规范，从JDK 1. 2开始，FindClass将设法找到与当前的本地方法关联的类加载器。如果平台相关代码属于一个系统类，则无需涉及任何类加载器; 否则，将调用适当的类加载器来加载和链接已命名的类。换句话说，如果在Java程序中直接调用C/C++语言产生的机器码，该部分代码的安全性就由Java虚拟机控制。

 

2. 解决本机平台接口调用问题
JAVA以其跨平台的特性深受人们喜爱，而又正由于它的跨平台的目的，使得它和本地机器的各种内部联系变得很少，约束了它的功能。解决JAVA对本地操作的一种方法就是JNI。JAVA通过JNI调用本地方法，而本地方法是以库文件的形式存放的（在WINDOWS平台上是DLL文件形式，在UNIX机器上是SO文件形式）。通过调用本地的库文件的内部方法，使JAVA可以实现和本地机器的紧密联系，调用系统级的各接口方法。

 

3. 嵌入式开发应用
“一次编程，到处使用”的Java软件概念原本就是针对网上嵌入式小设备提出的，几经周折，目前SUN公司已推出了J2ME(Java 2 P1atform Micro Edition)针对信息家电的Java版本，其技术日趋成熟，开始投入使用。SUN公司Java虚拟机(JVM)技术的有序开放，使得Java软件真正实现跨平台运行，即Java应用小程序能够在带有JVM的任何硬软件系统上执行。加上Java语言本身所具有的安全性、可靠性和可移植性等特点，对实现瘦身上网的信息家电等网络设备十分有利，同时对嵌入式设备特别是上网设备软件编程技术产生了很大的影响。也正是由于JNI解决了本机平台接口调用问题，于是JNI在嵌入式开发领域也是如火如荼。

 

不失直观性，我们首先写一个JNI小例子：

 

Java代码   收藏代码
  1. public class HelloJni {  
  2.     public native void displayHelloJni();  
  3.   
  4.     static {  
  5.         System.loadLibrary("helloJni");  
  6.     }  
  7.   
  8.     public static void main(String[] args) {  
  9.         //System.out.println(System.getProperty("java.library.path"));  
  10.         new HelloJni().displayHelloJni();  
  11.     }  
  12. }  

 

在class文件生成的相应目录执行命令如下：
----------------------------------------------------
E:\projects\jni\target\classes>javah HelloJni
----------------------------------------------------

 

得到C++文件HelloJni.h

Cpp代码   收藏代码
  1. /* DO NOT EDIT THIS FILE - it is machine generated */  
  2. #include <jni.h>  
  3. /* Header for class HelloJni */  
  4.   
  5. #ifndef _Included_HelloJni  
  6. #define _Included_HelloJni  
  7. #ifdef __cplusplus  
  8. extern "C" {  
  9. #endif  
  10. /* 
  11.  * Class:     HelloJni 
  12.  * Method:    displayHelloJni 
  13.  * Signature: ()V 
  14.  */  
  15. JNIEXPORT void JNICALL Java_HelloJni_displayHelloJni  
  16.   (JNIEnv *, jobject);  
  17.   
  18. #ifdef __cplusplus  
  19. }  
  20. #endif  
  21. #endif  

 

JNI函数名称分为三部分：首先是Java关键字，供Java虚拟机识别；然后是调用者类名称(全限定的类名，其中用下划线代替名称分隔符)；最后是对应的方法名称，各段名称之间用下划线分割。


JNI函数的参数也由三部分组成：首先是JNIEnv *,是一个指向JNI运行环境的指针；第二个参数随本地方法是静态还是非静态而有所不同一一非静态本地方法的第二个参数是对对象的引用，而静态本地方法的第二个参数是对其Java类的引用；其余的参数对应通常Java方法的参数，参数类型需要根据一定规则进行映射。

 

 

编写C++文件HelloJni.h的实现类，我是比较常用VC6.0来生成dll文件（helloJni.dll）的

Cpp代码   收藏代码
  1. #include <jni.h>  
  2. #include "HelloJni.h"  
  3. #include <stdio.h>  
  4.   
  5. JNIEXPORT void JNICALL   
  6. Java_HelloJni_displayHelloJni(JNIEnv *env, jobject obj)   
  7. {  
  8.     printf("Hello Dynamic Link Library has been calling!\n");  
  9.     printf("Java_HelloJni_displayHelloJni method has been executed!\n");  
  10.     return;  
  11. }  

 

其实此时，我们的工程目前还暂时不能生成我们想要的 helloJni.dll 文件，问题就出在了“#include <jni.h>”。由于VC6.0里没有我们需要的“jni.h”文件，因此就需要手动加入到VC6.0的环境中去。在JAVA_HOME路径下我们可以找到include文件夹，其中就可以找到我们需要的“jni.h”文件。为了避免以后麻烦起见，将所有的C++文件全部拿出来，放在“%CPP_HOME%\VC98\Include”路径下。然后将工程进行打包就可以得到我们需要的“helloJni.dll”文件了。

 

 将helloJni.dll文件放置于工程classes目录，执行命令如下：
-----------------------------------------------
E:\projects\jni\target\classes>java HelloJni
-----------------------------------------------

运行结果如下：
-----------------------------------------------------------------
Hello Dynamic Link Library has been calling!
Java_HelloJni_displayHelloJni method has been executed!
-----------------------------------------------------------------


但是要想在eclipse中运行helloJni.dll文件，就需要将文件拷贝到工程的根目录，或者将其放在诸如C:\WINDOWS\system32;C:\WINDOWS;等目录下。因为，eclipse在运行helloJni.dll文件时首先会去在当前根目录找，如果找不到则在path上去找，因此你还可以为了方便管理生成的dll文件，将所有工程中的dll文件都放到一个特定的目录，然后将该目录加入到你的本地path环境变量中去，这样每次只需要将生成的dll文件放入path目录下就可以访问了。注，如果需要加环境变量最好在加好以后重新启动一下eclipse，确保eclipse能够加载到最新的path环境。

 

接下来，对小例子进行重构：
1. 新增一个基础类

 

Java代码   收藏代码
  1. package org.danlley.jni.test;  
  2.   
  3. public class BaseClass {  
  4.   
  5.     public BaseClass(String arg) {  
  6.         loadLibrary(arg);  
  7.     }  
  8.   
  9.     private static void loadLibrary(String arg) {  
  10.         System.loadLibrary(arg);  
  11.     }  
  12. }  

 

 2. 定义新类继承基础类

 

Java代码   收藏代码
  1. package org.danlley.jni.test;  
  2.   
  3. public class HelloJniTest extends BaseClass {  
  4.     public HelloJniTest(String arg){  
  5.         super(arg);  
  6.     }  
  7.     public native void displayHelloJni();  
  8. }  

 

3. 编写调用类

Java代码   收藏代码
  1. package org.danlley.jni.test;  
  2.   
  3. public class RunMain {  
  4.     public static void main(String[] args) {  
  5.         new HelloJniTest("helloJniTest").displayHelloJni();  
  6.     }  
  7. }  

 此次，将dll文件定义为：helloJniTest.dll。

 

执行结果：
------------------------------------------------------------------------------------
Java_org_danlley_jni_test_HelloJniTest_displayHelloJni has been called!
------------------------------------------------------------------------------------

 

例子相当简单，没有传入参数，也没有返回值，那么是不是可以让本地方法返回一些参数，同时又可以传入数据进行处理，并把处理结果返回给方法的调用者呢，先拿基本类型开刀。接下来对 HelloJniTest 继续进行改造：新增两个本地方法，如下：

Java代码   收藏代码
  1. package org.danlley.jni.test;  
  2.   
  3. public class HelloJniTest extends BaseClass {  
  4.     public HelloJniTest(String arg){  
  5.         super(arg);  
  6.     }  
  7.     public native void displayHelloJni();  
  8.       
  9.     public native int getDynamicIntDataNoParam();  
  10.       
  11.     public native int getDynamicIntData(int i);  
  12. }  

 

重新生成org_danlley_jni_test_HelloJniTest.h文件，并改写其实现类org_danlley_jni_test_HelloJniTest.cpp如下：

Cpp代码   收藏代码
  1. // org_danlley_jni_test_HelloJniTest.cpp: implementation of the org_danlley_jni_test_HelloJniTest class.  
  2. //  
  3. //  
  4.   
  5. #include "org_danlley_jni_test_HelloJniTest.h"  
  6. #include <jni.h>  
  7. #include <stdio.h>  
  8.   
  9. JNIEXPORT void JNICALL   
  10. Java_org_danlley_jni_test_HelloJniTest_displayHelloJni(JNIEnv *env, jobject obj)   
  11. {  
  12.     printf("Java_org_danlley_jni_test_HelloJniTest_displayHelloJni has been called!\n");  
  13.     return;  
  14. }  
  15.   
  16. JNIEXPORT jint JNICALL   
  17. Java_org_danlley_jni_test_HelloJniTest_getDynamicIntDataNoParam(JNIEnv *env, jobject obj)   
  18. {  
  19.     return 65535;  
  20. }  
  21.   
  22. JNIEXPORT jint JNICALL   
  23. Java_org_danlley_jni_test_HelloJniTest_getDynamicIntData(JNIEnv *env, jobject obj, jint i)  
  24. {  
  25.     i*=i;  
  26.     return i;  
  27. }  

 

修改 RunMain 类：

Java代码   收藏代码
  1. package org.danlley.jni.test;  
  2.   
  3. public class RunMain {  
  4.     public static void main(String[] args) {  
  5.         HelloJniTest tester=new HelloJniTest("helloJniTest");  
  6.         tester.displayHelloJni();  
  7.         int i=tester.getDynamicIntDataNoParam();  
  8.         System.out.println("tester.getDynamicIntDataNoParam()="+i);  
  9.         int j=tester.getDynamicIntData(100);  
  10.         System.out.println("tester.getDynamicIntData(100)="+j);  
  11.     }  
  12. }  

 

运行RunMain：

-----------------------------------------------------------------------
tester.getDynamicIntDataNoParam()=65535
tester.getDynamicIntData(100)=10000
Java_org_danlley_jni_test_HelloJniTest_displayHelloJni has been called!
-----------------------------------------------------------------------

OK，一切正常。

 

还是不过瘾，简单对象可以处理了，如果是一个java对象，还可以处理吗，答案是当然可以，接下来我们来继续对 helloJniTest 类进行改造。新增一个方法如下：

Java代码   收藏代码
  1. package org.danlley.jni.test;  
  2.   
  3. public class HelloJniTest extends BaseClass {  
  4.     public HelloJniTest(String arg){  
  5.         super(arg);  
  6.     }  
  7.     public native void displayHelloJni();  
  8.       
  9.     public native int getDynamicIntDataNoParam();  
  10.       
  11.     public native int getDynamicIntData(int i);  
  12.       
  13.     public native String getDynamicStringData(String arg);  
  14. }  

 

重新生成org_danlley_jni_test_HelloJniTest.h文件：

Cpp代码   收藏代码
  1. /* DO NOT EDIT THIS FILE - it is machine generated */  
  2. #include <jni.h>  
  3. /* Header for class org_danlley_jni_test_HelloJniTest */  
  4.   
  5. #ifndef _Included_org_danlley_jni_test_HelloJniTest  
  6. #define _Included_org_danlley_jni_test_HelloJniTest  
  7. #ifdef __cplusplus  
  8. extern "C" {  
  9. #endif  
  10. /* 
  11.  * Class:     org_danlley_jni_test_HelloJniTest 
  12.  * Method:    displayHelloJni 
  13.  * Signature: ()V 
  14.  */  
  15. JNIEXPORT void JNICALL Java_org_danlley_jni_test_HelloJniTest_displayHelloJni  
  16.   (JNIEnv *, jobject);  
  17.   
  18. /* 
  19.  * Class:     org_danlley_jni_test_HelloJniTest 
  20.  * Method:    getDynamicIntDataNoParam 
  21.  * Signature: ()I 
  22.  */  
  23. JNIEXPORT jint JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicIntDataNoParam  
  24.   (JNIEnv *, jobject);  
  25.   
  26. /* 
  27.  * Class:     org_danlley_jni_test_HelloJniTest 
  28.  * Method:    getDynamicIntData 
  29.  * Signature: (I)I 
  30.  */  
  31. JNIEXPORT jint JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicIntData  
  32.   (JNIEnv *, jobject, jint);  
  33.   
  34. /* 
  35.  * Class:     org_danlley_jni_test_HelloJniTest 
  36.  * Method:    getDynamicStringData 
  37.  * Signature: (Ljava/lang/String;)Ljava/lang/String; 
  38.  */  
  39. JNIEXPORT jstring JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicStringData  
  40.   (JNIEnv *, jobject, jstring);  
  41.   
  42. #ifdef __cplusplus  
  43. }  
  44. #endif  
  45. #endif  

 

改写org_danlley_jni_test_HelloJniTest.cpp文件：

Cpp代码   收藏代码
  1. // org_danlley_jni_test_HelloJniTest.cpp: implementation of the org_danlley_jni_test_HelloJniTest class.  
  2. //  
  3. //  
  4.   
  5. #include "org_danlley_jni_test_HelloJniTest.h"  
  6. #include <jni.h>  
  7. #include <stdio.h>  
  8.   
  9. JNIEXPORT void JNICALL   
  10. Java_org_danlley_jni_test_HelloJniTest_displayHelloJni(JNIEnv *env, jobject obj)   
  11. {  
  12.     printf("Java_org_danlley_jni_test_HelloJniTest_displayHelloJni has been called!\n");  
  13.     return;  
  14. }  
  15.   
  16. JNIEXPORT jint JNICALL   
  17. Java_org_danlley_jni_test_HelloJniTest_getDynamicIntDataNoParam(JNIEnv *env, jobject obj)   
  18. {  
  19.     return 65535;  
  20. }  
  21.   
  22. JNIEXPORT jint JNICALL   
  23. Java_org_danlley_jni_test_HelloJniTest_getDynamicIntData(JNIEnv *env, jobject obj, jint i)  
  24. {  
  25.     i*=i;  
  26.     return i;  
  27. }  
  28.   
  29. JNIEXPORT jstring JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicStringData  
  30. (JNIEnv *env, jobject obj, jstring arg){  
  31.     //Get the native string from javaString  
  32.     const char *nativeString = env->GetStringUTFChars(arg, 0);  
  33.     printf("%s", nativeString);  
  34.     //DON'T FORGET THIS LINE!!!  
  35.     env->ReleaseStringUTFChars(arg, nativeString);  
  36.     return arg;  
  37. }  

  

 重新对C++工程打包成dll文件，运行结果：
---------------------------------------------------------------------------
tester.getDynamicIntDataNoParam()=65535
tester.getDynamicIntData(100)=10000
tester.getDynamicStringData=My first String test
Java_org_danlley_jni_test_HelloJniTest_displayHelloJni has been called!
My first String test
---------------------------------------------------------------------------

我们不仅把Java的一个String对象成功的传给了dll，而且还将处理后的结果返回了出来。

 

但是总觉得还是不够，那我们就再来个比较复杂的对象把，我们这次将一个整形数组通过java传给dll，看看是不是也可以处理，继续还是对 helloJniTest 类进行改造，新增一个方法：

Java代码   收藏代码
  1. package org.danlley.jni.test;  
  2.   
  3. public class HelloJniTest extends BaseClass {  
  4.     public HelloJniTest(String arg){  
  5.         super(arg);  
  6.     }  
  7.     public native void displayHelloJni();  
  8.       
  9.     public native int getDynamicIntDataNoParam();  
  10.       
  11.     public native int getDynamicIntData(int i);  
  12.       
  13.     public native String getDynamicStringData(String arg);  
  14.       
  15.     public native int[] getDynamicArrayData(int[] args);  
  16. }  

 

重新生成org_danlley_jni_test_HelloJniTest.h文件

Cpp代码   收藏代码
  1. /* DO NOT EDIT THIS FILE - it is machine generated */  
  2. #include <jni.h>  
  3. /* Header for class org_danlley_jni_test_HelloJniTest */  
  4.   
  5. #ifndef _Included_org_danlley_jni_test_HelloJniTest  
  6. #define _Included_org_danlley_jni_test_HelloJniTest  
  7. #ifdef __cplusplus  
  8. extern "C" {  
  9. #endif  
  10. /* 
  11.  * Class:     org_danlley_jni_test_HelloJniTest 
  12.  * Method:    displayHelloJni 
  13.  * Signature: ()V 
  14.  */  
  15. JNIEXPORT void JNICALL Java_org_danlley_jni_test_HelloJniTest_displayHelloJni  
  16.   (JNIEnv *, jobject);  
  17.   
  18. /* 
  19.  * Class:     org_danlley_jni_test_HelloJniTest 
  20.  * Method:    getDynamicIntDataNoParam 
  21.  * Signature: ()I 
  22.  */  
  23. JNIEXPORT jint JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicIntDataNoParam  
  24.   (JNIEnv *, jobject);  
  25.   
  26. /* 
  27.  * Class:     org_danlley_jni_test_HelloJniTest 
  28.  * Method:    getDynamicIntData 
  29.  * Signature: (I)I 
  30.  */  
  31. JNIEXPORT jint JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicIntData  
  32.   (JNIEnv *, jobject, jint);  
  33.   
  34. /* 
  35.  * Class:     org_danlley_jni_test_HelloJniTest 
  36.  * Method:    getDynamicStringData 
  37.  * Signature: (Ljava/lang/String;)Ljava/lang/String; 
  38.  */  
  39. JNIEXPORT jstring JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicStringData  
  40.   (JNIEnv *, jobject, jstring);  
  41.   
  42. /* 
  43.  * Class:     org_danlley_jni_test_HelloJniTest 
  44.  * Method:    getDynamicArrayData 
  45.  * Signature: ([I)[I 
  46.  */  
  47. JNIEXPORT jintArray JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicArrayData  
  48.   (JNIEnv *, jobject, jintArray);  
  49.   
  50. #ifdef __cplusplus  
  51. }  
  52. #endif  
  53. #endif  

 

改写org_danlley_jni_test_HelloJniTest.cpp文件：

Cpp代码   收藏代码
  1. // org_danlley_jni_test_HelloJniTest.cpp: implementation of the org_danlley_jni_test_HelloJniTest class.  
  2. //  
  3. //  
  4.   
  5. #include "org_danlley_jni_test_HelloJniTest.h"  
  6. #include <jni.h>  
  7. #include <stdio.h>  
  8.   
  9. JNIEXPORT void JNICALL   
  10. Java_org_danlley_jni_test_HelloJniTest_displayHelloJni(JNIEnv *env, jobject obj)   
  11. {  
  12.     printf("Java_org_danlley_jni_test_HelloJniTest_displayHelloJni has been called!\n");  
  13.     return;  
  14. }  
  15.   
  16. JNIEXPORT jint JNICALL   
  17. Java_org_danlley_jni_test_HelloJniTest_getDynamicIntDataNoParam(JNIEnv *env, jobject obj)   
  18. {  
  19.     return 65535;  
  20. }  
  21.   
  22. JNIEXPORT jint JNICALL   
  23. Java_org_danlley_jni_test_HelloJniTest_getDynamicIntData(JNIEnv *env, jobject obj, jint i)  
  24. {  
  25.     i*=i;  
  26.     return i;  
  27. }  
  28.   
  29. JNIEXPORT jstring JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicStringData  
  30. (JNIEnv *env, jobject obj, jstring arg){  
  31.     //Get the native string from javaString  
  32.     const char *nativeString = env->GetStringUTFChars(arg, 0);  
  33.     printf("%s", nativeString);  
  34.     //DON'T FORGET THIS LINE!!!  
  35.     env->ReleaseStringUTFChars(arg, nativeString);  
  36.     return arg;  
  37. }  
  38.   
  39.   
  40. JNIEXPORT jintArray JNICALL Java_org_danlley_jni_test_HelloJniTest_getDynamicArrayData  
  41. (JNIEnv *env, jobject  obj, jintArray args){  
  42.     jint buf[10];  
  43.     jint i;  
  44.     env->GetIntArrayRegion(args, 0, 10, buf);  
  45.     jint j=0;  
  46.     for (i = 0; i < 10; i++) {  
  47.         j=buf[i];  
  48.         j*=j;  
  49.         buf[i]=j;  
  50.     }  
  51.     env->SetIntArrayRegion(args, 0, 10, buf);  
  52.     return args;  
  53. }  

 

改写RunMain：

Java代码   收藏代码
  1. package org.danlley.jni.test;  
  2.   
  3. public class RunMain {  
  4.     public static void main(String[] args) {  
  5.         HelloJniTest tester = new HelloJniTest("helloJniTest");  
  6.         tester.displayHelloJni();  
  7.         int i = tester.getDynamicIntDataNoParam();  
  8.         System.out.println("tester.getDynamicIntDataNoParam()=" + i);  
  9.         int j = tester.getDynamicIntData(100);  
  10.         System.out.println("tester.getDynamicIntData(100)=" + j);  
  11.         String str = tester.getDynamicStringData("My first String test");  
  12.         System.out.println("tester.getDynamicStringData=" + str);  
  13.         int[] args_int = new int[10];  
  14.         for (int ii = 0; ii < 10; ii++) {  
  15.             args_int[ii] = ii;  
  16.         }  
  17.         int[] args_arr = tester.getDynamicArrayData(args_int);  
  18.         for (int ii = 0; ii < 10; ii++) {  
  19.             System.out.println(args_arr[ii]);  
  20.         }  
  21.     }  
  22. }  

 

运行结果：
--------------------------------------------------------------------------------
tester.getDynamicIntDataNoParam()=65535
tester.getDynamicIntData(100)=10000
tester.getDynamicStringData=My first String test
0
1
4
9
16
25
36
49
64
81
Java_org_danlley_jni_test_HelloJniTest_displayHelloJni has been called!
My first String test
--------------------------------------------------------------------------------

 

 

 

  

参考资料：

http://en.wikipedia.org/wiki/Java_Native_Interface
http://www.yesky.com/20011004/199789.shtml
http://www.21ic.com/news/html/63/show13260.htm
http://java.ccidnet.com/art/297/20060228/439729_1.html
http://www.blogjava.net/soft/archive/2006/11/13/posoft.html
http://www.blogjava.net/soft/archive/2006/11/13/80788.html
http://www.blogjava.net/soft/archive/2006/11/13/80789.html 


原文链接：http://www.iteye.com/topic/295776


二、java c/cpp互相调用实例（姊妹篇之一）      ----------java调用c/cpp 

（之二c/cpp调用java） 

此文章纯粹实例操作，关于jni已经有不少人不少文章讲的很清楚了，所以就不罗列理论了。 

看了kimmking的 JNI技术实践小结，又读了danlley的 Java JNI 编程进阶，这些文章中都是自己调用自己，方法很java化，而对于真正的调用dll还是不理解，心中一直存在问题：现在系统中已经有的dll我该如何去调用？如果一个大工程里需要cpp和java一起开发，cpp给出接口、SDK，我该如何处理？ 
带着这些疑问我决定从cpp到java的jni调用这个全过程亲自动手操作一下。 

完成此示例需要下列工具/环境： 
1、java环境（废话谁都知道） 
2、编译c/cpp的工具。推荐用vs/vc++，我用的是vs2008 


一 先制作一个系统中有的DLL文件（cpp给出的sdk接口） 

  既然是测试我们就把我们这个dll叫做testDll吧，为了简单其间，我只写一个add方法，就是简单的2个数字相加，对于真正的开发中我们肯定会遇到其他类型，java到c/cpp中类型需要转换，具体类型转换对应关系g一下就能得到，我也不在列举。c/cpp中一个class一般包含2个文件，一个头文件定义（*.h），一个文件主体（*.c/*.cpp）。啰嗦了这么多还是直接动手吧，先在vs2008中建立一个工程（当然你也可以直接编写不用这些IDE工具，gcc g++的命令自己g。下同，不在注释不在废话），选取win32工程 
 
键入工程名字testDll，点击next选取DLL，然后点击完成 
 
打开我们的testdll.cpp，添加进我们的add方法 
C++代码   收藏代码
  1. int add(int a,int b){   
  2.     return a+b;   
  3. }  

注意到文件列表里并没有testDll.h，因为我们要给出调用者一个接口，如果不给头文件，人家就没办法调用，所以我们就必须添加一个头文件testDll.h。 
C++代码   收藏代码
  1. #ifdef TEST_DLL  
  2. #define TEST_API __declspec(dllexport)  
  3. #else  
  4. #define TEST_API __declspec(dllimport)  
  5. #endif  
  6.   
  7. /* Set up for C function definitions, even when using C++ */  
  8. #ifdef __cplusplus  
  9. extern "C" {  
  10. #endif  
  11.   
  12. TEST_API int add(int,int);  
  13.   
  14. /* Ends C function definitions when using C++ */  
  15. #ifdef __cplusplus  
  16. }  
  17. #endif  
在这个头文件中我们把我们的add方法给定义了进去。注意到testdll.cpp中#include "stdafx.h"，所以我们就把这个testDll.h include进stdafx.h里面。 

按道理说我们的这个dll已经完成了，但是一般c/cpp给接口SDK的时候大都给.h和.lib，为了一步生成dll和lib，我们添加进一个testDll.def，有了这个文件就可以一步生成dll和lib。在source file里右键add new item ，选择Module-Definition File 
 
键入testDll，OK了，我们可以直接build了。生成testDll.dll和testDll.lib。 

把testDll.dll扔到system32目录里等待我们高大威猛的java jni调用。 

二 JNI 

2.1 编写java文件 

为了显示我们的与众相同，我们就把我们的这个java文件命名为Demo.java顺便直接带上包名 
，因为我们知道人家给我们的接口里有个add方法，所以我们就直接来个调用吧。
Java代码   收藏代码
  1. package com.testJni.testDemo;  
  2.   
  3. public class Demo {  
  4.     static  
  5.     {  
  6.         //System.out.println(System.getProperty("java.library.path"));  
  7.         System.loadLibrary("testDll");  
  8.         System.loadLibrary("jniDll");  
  9.     }  
  10.     public native static int add(int a,int b);   
  11.       
  12. }  
demo.java代码暂时如此，我们把将要生成的jni的dll叫做jniDll，有童鞋讲，我不想用你这个烂名字jniDll多俗啊，没关系，你可以换，随你换，生成文件后你再换也可以，现在换也可以。 

2.2 生成.h头文件 

javah命令，不多讲。生成的文件com_testJni_testDemo_Demo.h这个文件的命名规则我就不多讲了，一目了然。 
C++代码   收藏代码
  1. /* DO NOT EDIT THIS FILE - it is machine generated */  
  2. #include <jni.h>  
  3. /* Header for class com_testJni_testDemo_Demo */  
  4.   
  5. #ifndef _Included_com_testJni_testDemo_Demo  
  6. #define _Included_com_testJni_testDemo_Demo  
  7. #ifdef __cplusplus  
  8. extern "C" {  
  9. #endif  
  10. /* 
  11.  * Class:     com_testJni_testDemo_Demo 
  12.  * Method:    add 
  13.  * Signature: (II)I 
  14.  */  
  15. JNIEXPORT jint JNICALL Java_com_testJni_testDemo_Demo_add  
  16.   (JNIEnv *, jclass, jint, jint);  
  17.   
  18. #ifdef __cplusplus  
  19. }  
  20. #endif  
  21. #endif  


2.3 用c/cpp实现这个头文件 

c/cpp中已经实现了这个add方法，我们只需要调用就可以啦。所以直接vs2008中建立一个dll工程，工程名我们就叫jniDll，具体过程不再多讲，方法同上面testDll的建立一样。在这个工程里kimmking把需要引用的包、文件等已经讲的很清楚了。打开jniDll.cpp，添加下面代码 
C++代码   收藏代码
  1. JNIEXPORT jint JNICALL Java_com_testJni_testDemo_Demo_add  
  2. (JNIEnv *env,jclass jobject,jint a,jint b){  
  3.   
  4.     return add(a,b);  
  5. }  
因为int对应的类型就刚好是jint，所以就不需要转换，其他需要转换的类型自己g对应关系转换，注意释放。 

这个工程里我们还需要打开 stdafx.h添加
C++代码   收藏代码
  1. #include <jni.h>  
  2.   
  3. #include "testDll.h"  
  4. #include "com_testJni_testDemo_Demo.h"  


在编译这个jniDll工程的时候需要引入testDll.h，com_testJni_testDemo_Demo.h，另外添加testDll.lib这个依赖。 
 

好了做好这些后，build下，生成了我们期待已久的jniDll.dll，把这个dll同样扔到system32下。 

三 测试 


本人特懒，不想写多余的class，所以直接修改Demo.java 这也是刚才为什么讲暂时如此的原因
Java代码   收藏代码
  1. package com.testJni.testDemo;  
  2.   
  3. public class Demo {  
  4.     static  
  5.     {  
  6.         //System.out.println(System.getProperty("java.library.path"));  
  7.         System.loadLibrary("testDll");  
  8.         System.loadLibrary("jniDll");  
  9.     }  
  10.     public native static int add(int a,int b);   
  11.     public static void main(String[] args) {  
  12.         System.out.println(add(7,2));  
  13.     }  
  14. }  


四 最后补充 

如果系统已经加载过c/cpp的dll，我们就不用再System.loadLibrary("testDll")了，加载一遍就可以了，因为我们刚才写的testDll系统没有加载，所以我就加载了一下。对于多个dll可以写多个System.loadLibrary去加载，修改static{}里面的内容不需要重新生成dll，除非你多加了一个调用方法，如果你看清楚规则，就不用javah命令就可以直接编写头文件，用javah太麻烦了。 

【参考文章】 
http://www.iteye.com/topic/304594 JNI技术实践小结--原理分析和详细步骤截图说明 
http://www.iteye.com/topic/295776?page=1 Java JNI 编程进阶

原文链接：http://www.iteye.com/topic/459005


三、java c/cpp互相调用实例（姊妹篇之二） 

                             ----------c/cpp调用java 

本文是 javaJNI调用c/cpp实例（姊妹篇之一）的续集c/cpp调用java。 

计划第三篇写一个java安装程序实例（客户端无jre环境的安装包），以解决java程序（软件）安装不方便的问题，使java程序安装也傻瓜化。 

直接进入正题： 

完成本实例需要下列工具/环境： 
1、java环境 
2、c/cpp编辑器。windows下推荐用vs/vc++，我用的是vs2008。linux下gcc/g++ 

从 C/CPP 程序调用 Java 代码需要四个步骤 ： 
一 编写 Java 代码。 
二 编译 Java 代码。 
三 编写 C/C++ 代码。 
四 运行本机 C/C++ 应用程序。 

1、编写java代码 

为了达到示范作用，java方法我用两个，一个是静态方法，一个是普通方法。 

C2java.java 
Java代码   收藏代码
  1. package com.testJni.testDemo;  
  2.   
  3. public class C2java {  
  4.     public C2java(){  
  5.         super();  
  6.     }  
  7.     public static int add(int a,int b) {  
  8.         return a+b;  
  9.     }  
  10.     public boolean judge(boolean bool) {  
  11.         return !bool;  
  12.     }  
  13.   
  14. }  

静态方法的好处是我不用实例化，直接可以调用方法。调用起来比较简单，不容易出错。 

2、编译java代码 

javac 命令。（略） 

3、编写 C/C++ 代码 

我想在c/cpp中直接生成一个exe然后窗口输出结果，所以我就建立一个exe工程。编辑器jni环境是上篇已经搭建好的，所以这里只需要少量配置就可以了。好了，我们先建立一个工程： 

打开vs2008，新建一 win32 console App 工程 
 
键入工程名字c2java，点击OK，出来窗口点击next，选取console app 
 
点击完成。到这里先不忙编码实现，我们先把环境搭建好，右键工程属性，选取 linker -->input，在右边窗口添加依赖jvm.lib，这个lib的位置在你%JAVA_HOME%/lib 下。如果你的路径中同我一样包含空格（例如Program Files）记得用引号括起来。 
 
打开stdafx.h文件添加 
C++代码   收藏代码
  1. #include <iostream>  
  2. #include <jni.h>  
  3.   
  4. #ifdef _WIN32  
  5. #define PATH_SEPARATOR ';'  
  6. #else  
  7. #define PATH_SEPARATOR ':'  
  8. #endif  

打开c2java.cpp，键入下面的代码 
C++代码   收藏代码
  1. using namespace std;  
  2.   
  3. int main()  
  4. {  
  5.       
  6.   JavaVMOption options[1];  
  7.   JNIEnv *env;  
  8.   JavaVM *jvm;  
  9.   JavaVMInitArgs vm_args;  
  10.   long status;  
  11.   jclass cls;  
  12.   jmethodID mid;  
  13.   jint square;  
  14.   jboolean not;  
  15.     jobject jobj;  
  16.   
  17.   options[0].optionString = "-Djava.class.path=.";  
  18.   vm_args.version = JNI_VERSION_1_2;  
  19.   vm_args.nOptions = 1;  
  20.   vm_args.options = options;  
  21.   status = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);  
  22.   if (status != JNI_ERR)  
  23.   {  
  24.         cls = env->FindClass("com/testJni/testDemo/C2java");  
  25.     if(cls !=0)  
  26.     {   
  27.                 mid = env->GetStaticMethodID( cls, "add", "(II)I");  
  28.         if(mid !=0)  
  29.         {    
  30.                     square = env->CallStaticIntMethod( cls, mid, 5,5);  
  31.                     std::cout << square << std::endl;  
  32.           }  
  33.                 mid = env->GetMethodID(cls,"<init>","()V");  
  34.                 if(mid !=0)  
  35.         {    
  36.                     jobj=env->NewObject(cls,mid);  
  37.                     std::cout << "init ok" << std::endl;  
  38.           }  
  39.                 mid = env->GetMethodID( cls, "judge","(Z)Z");  
  40.                 if(mid !=0)  
  41.         {    
  42.                     not = env->CallBooleanMethod(jobj, mid, 1);  
  43.                     if(!not){  
  44.                         std::cout << "Boolean ok" << std::endl;  
  45.                     }  
  46.         }  
  47.                   
  48.     }  
  49.   
  50.     jvm->DestroyJavaVM();  
  51.    return 0;  
  52.   }  
  53.   else  
  54.     return -1;  
  55.   
  56. }  

下面解释下上面的代码: 
JavaVMOption options[] 具有用于 JVM 的各种选项设置。声明的 JavaVMOption options[] 数组足够大，就能容纳我们希望使用的所有选项。在本实例中，我们使用的选项就是类路径选项。 
JNIEnv *env 表示 JNI 执行环境。 
JavaVM *jvm 是指向 JVM 的指针。我们主要使用这个指针来创建、初始化和销毁 JVM。JavaVMInitArgs vm_args 表示可以用来初始化 JVM 的各种 JVM 参数。 
设置参数后，创建我们的jvm ： 
  status = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args); 
成功返回0，不成功返回JNI_ERR。 
创建完成后，我们就可以查找我们的class了，因为我们的java类一般都有包，所以我们也要加上包路径com/testJni/testDemo/C2java 

在这里我们会使用到java的一个命令javap ，这个命令有什么用那，我们用javap -s -p C2java看看 
 
打开jni.h我们会发现，Signature就是sig，也就是GetStaticMethodID( cls, "add", "(II)I")方法的第三个参数。GetStaticMethodID表示调用static方法，GetMethodID调用普通方法。下面就是传入参数，打出结果。 
在看jni.h的时候我们注意到有 CallStaticXXXMethod() 和 CallXXXMethod() 之类的方法。这些方法分别代表调用静态方法和成员方法，用方法的返回类型（例如，Object、Boolean、Byte、Char、Int、Long 等等）代替变量 XXX。 
静态方法和普通方法不同之处就是普通方法必须要先实例化一个java对象，调用构造器的时候方法的名称为“<init>”。 

下面的代码就不用我再解释了，先是new一个实例出来，然后调用实例的方法。 

最后记得销毁jvm。 

代码解释完了，我们build下这个工程，生成c2java.exe。 

4、运行exe 

因为我们生成的exe需要调用jvm.dll初始化，为了使运行的exe不报错误，我们把%JAVA_HOME%/jre/bin/server也加进path目录。方便系统自动搜索jvm.dll。 
运行结果： 
 

最后补充：本实例并没有涉及到java的异常、java c/cpp的编码转换问题，对于异常问题，C里没有异常，请使用jni的异常处理函数。编码转换问题上篇已有介绍，此处略去。

 

五 、Linux 下C通过jni调用java

Java  C  JNI

编译环境:

fedora16

gcc (GCC) 4.6.3 20120306 (Red Hat 4.6.3-2)

java version "1.6.0_31"
Java(TM) SE Runtime Environment (build 1.6.0_31-b04)
Java HotSpot(TM) Server VM (build 20.6-b01, mixed mode)

 

准备工作:

    首先需要安装jdk和gcc(或者其他c编译器也可以)并配置相应的环境变量(可自行在网上搜索,这个资料很多的),配好之后在命令行运行gcc --version和java -version出现版本号就代表安装配置成功了:

Java代码   收藏代码
  1. [roysong@roysong c]$ gcc --version  
  2. gcc (GCC) 4.6.3 20120306 (Red Hat 4.6.3-2)  
  3. Copyright © 2011 Free Software Foundation, Inc.  
  4. 本程序是自由软件；请参看源代码的版权声明。本软件没有任何担保；  
  5. 包括没有适销性和某一专用目的下的适用性担保。  
  6. [roysong@roysong c]$ java -version  
  7. java version "1.6.0_31"  
  8. Java(TM) SE Runtime Environment (build 1.6.0_31-b04)  
  9. Java HotSpot(TM) Server VM (build 20.6-b01, mixed mode)  

 

     然后需要将jdk中的虚拟机库配置到环境路径中,我是在/etc/ld.so.conf.d/下面新建了一个jni-i386.conf文件,内容如下:

 

Java代码   收藏代码
  1. /usr/java/jdk1.6.0_31/jre/lib/i386/client  

    然后运行一下ldconfig –v,让配置文件起作用,也可以直接编辑/etc/ld.so.conf文件,将这个路径加入进去.这个路径的含义就是$JAVA_HOME/jre/lib/i386/client,其中

$JAVA_HOME换成你自己的jdk安装路径就可以了.这是为了找到libjvm.so.因为我是32位的机器,所以路径中是i386,

我估计64位的机器这个目录是不一样的,根据libjvm.so文件的路径自行替换即可.

 

 程序编写和编译:

    程序就分成了c的部分和java的部分,首先我们先看看java的部分,我是把在同一目录下新建了两个文件夹分别叫c和java,

作为c程序的路径和java的classpath,然后在java文件夹下面新建包com.test.base64,java程序的目录结构即:

java/com/test/base64.接着,我们在base64目录下面新建一个Hello.java:

Java代码   收藏代码
  1. package com.test.base64;  
  2.   
  3. public class Hello{  
  4.     public String hello (String name){  
  5.         return "hello,"+name;     
  6.     }  
  7. }  

    结构非常简单,不过有参数有返回值就可以代表大部分情况了.然后我们使用javac对这个文件进行编译以产生一个class

文件:

Java代码   收藏代码
  1. [roysong@roysong java]$ cd com/test/base64/  
  2. [roysong@roysong base64]$ javac Hello.java  
  3. [roysong@roysong base64]$ ls  
  4.  Hello.class  Hello.java   

   编译成功后,在base64目录下会出现Hello.class这个文件.

   然后我们回到c文件夹,新建一个c源文件,我的是cfjIns.c,开始编写c的程序:

C代码   收藏代码
  1. #include <stdio.h>  
  2. #include <jni.h>  
  3.   
  4. /** 
  5. *初始化jvm 
  6. */  
  7. JNIEnv* create_vm() {  
  8.         JavaVM* jvm;  
  9.         JNIEnv* env;  
  10.         JavaVMInitArgs args;  
  11.         JavaVMOption options[1];  
  12.         args.version = JNI_VERSION_1_6;  
  13.         args.nOptions = 1;  
  14.         options[0].optionString = "-Djava.class.path=../java";  
  15.         args.options = options;  
  16.         args.ignoreUnrecognized = JNI_FALSE;  
  17.         JNI_CreateJavaVM(&jvm, (void **)&env, &args);  
  18.         return env;  
  19. }  
 

    这是cfjIns.c的第一部分,头文件声明

C代码   收藏代码
  1. #include <jni.h>  

    非常重要,这是引用的$JAVA_HOME/include/jni.h,一会儿我们在编译时会加上这个路径.

    其次就是

C代码   收藏代码
  1. args.version = JNI_VERSION_1_6;  

     这是jni的版本信息,需要跟你自己的jdk中jni版本对应,jdk1.6和jdk1.7的jni版本都是上面这个.

C代码   收藏代码
  1. options[0].optionString = "-Djava.class.path=../java";  

     这个参数是指明你自己java程序的类路径(classpath),因为我的c文件夹和java文件夹在同一目录下,所以我用了一个

相对路径来指明classpath.

 

    cfjIns.c中获取类定义的函数:

C代码   收藏代码
  1. /** 
  2. * 根据全限定类名来获取类的定义 
  3. */  
  4. jclass create_class(JNIEnv* env,char *className){  
  5.         jclass cls = (*env)->FindClass(env,className);  
  6.         if(cls == 0){  
  7.                 printf("class-[%s] find error\n",className);  
  8.                 return;  
  9.         }  
  10.         return cls;  
  11. }  

    这个函数有两个参数,第一个就是我们上面通过create_vm函数创建的jvm环境,第二个是全限定的类名字符串,

比如:"com/test/base64/Hello",返回值即对应的类.

 

    cfjIns.c中获取类实例的函数:

C代码   收藏代码
  1. /** 
  2. *通过无参构造函数来获取对应类的实例 
  3. */  
  4. jobject getInstance(JNIEnv* env, jclass obj_class)  
  5. {   
  6.         jmethodID construction_id = (*env)->GetMethodID(env,obj_class, "<init>", "()V");  
  7.         jobject obj = (*env)->NewObject(env,obj_class, construction_id);  
  8.         if(obj == 0){  
  9.                 printf("java class instance failed\n");  
  10.                 return;  
  11.         }  
  12.         return obj;   
  13. }  

    这个函数的第一个参数是jvm环境,第二个是通过上面的create_class函数获取的类定义.

 

    cfjIns.c中获取方法定义的函数:

C代码   收藏代码
  1. /** 
  2. * 根据类\方法名\返回值\参数获取类中对应的方法定义 
  3. */  
  4. jmethodID get_method(JNIEnv* env,jclass cls,char *methodName,char *key){  
  5.         jmethodID mid = (*env)->GetMethodID(env,cls,methodName,key);  
  6.         if(mid == 0){  
  7.                 printf("method-%s is not found\n",methodName);  
  8.                 return;  
  9.         }  
  10.         return mid;  
  11. }  

    这儿我们需要注意的是最后一个参数字符串key,这个是方法签名,用于指明方法的参数和返回值类型,格式是

"(参数类型声明)返回值类型声明".类型声明的值参照下面的对应表:

Java类型     对应的签名
booleanZ
byteB
charC
shrotS
intI
longL
floatF
doubleD
voidV
ObjectL用/分割包的完整类名;  Ljava/lang/String;
Array[签名       [I       [Ljava/lang/String;

 

    举个例子,如果方法的参数是int,返回值是void,那么方法的签名就是"(I)V";如果方法的参数是String,返回值

也是String,则方法的签名就是"(Ljava/lang/String;)Ljava/lang/String;",注意,如果是引用类型,类名后面必须

带有一个分号.

    我们也可以通过javap来查看类中方法参数和返回值的签名:

Java代码   收藏代码
  1. [roysong@roysong c]$ cd ../java/com/test/base64/  
  2. [roysong@roysong base64]$ javap -s -private Hello  
  3. Compiled from "Hello.java"  
  4. public class com.test.base64.Hello extends java.lang.Object{  
  5. public com.test.base64.Hello();  
  6.   Signature: ()V    //构造函数的签名  
  7. public java.lang.String hello(java.lang.String);  
  8.   Signature: (Ljava/lang/String;)Ljava/lang/String; //hello方法的签名  
  9. }  
 

 

    然后是一个将c语言中的字符串转换为java中String的工具函数:

C代码   收藏代码
  1. /** 
  2. * 转换c中的字符串为java.lang.String,这个方法是从网上找到的,感谢原作者<a href="http://home.cnblogs.com/u/liangwind/">天末凉风</a> 
  3.  
  4. */  
  5. jstring stoJstring(JNIEnv* env, const char* pat)  
  6. {  
  7.         jclass strClass = (*env)->FindClass(env,"Ljava/lang/String;");  
  8.         jmethodID ctorID = (*env)->GetMethodID(env,strClass, "<init>", "([BLjava/lang/String;)V");  
  9.         jbyteArray bytes = (*env)->NewByteArray(env,strlen(pat));  
  10.         (*env)->SetByteArrayRegion(env,bytes, 0, strlen(pat), (jbyte*)pat);  
  11.         jstring encoding = (*env)->NewStringUTF(env,"utf-8");  
  12.         return (jstring)(*env)->NewObject(env,strClass, ctorID, bytes, encoding);  
  13. }  

    有了上面的例子,这个函数就很好理解了,首先获取到java.lang.String的类定义,然后获取构造函数,然后将c中的字符串

转化为字节流并设置编码格式,最后产生一个新的java.lang.String对象并返回.

 

   这下我们就准备齐全了,开始编写调用函数:

C代码   收藏代码
  1. void invoke(){  
  2.         JNIEnv* env = create_vm(); //初始化java虚拟机  
  3.         jclass cls = create_class(env,"com/test/base64/Hello");//根据类名找到对应的类  
  4.         jobject obj = getInstance(env,cls);//然后根据类获取对应的实例  
  5.         jmethodID hello = get_method(env,cls,"hello","(Ljava/lang/String;)Ljava/lang/String;");//根据类\方法名和签名获取到对应的方法  
  6.         jstring name_str =  (*env)->CallObjectMethod(env,obj,hello,stoJstring(env,"a"));//传入参数调用方法  
  7.         const char* pname = (*env)->GetStringUTFChars(env,name_str, NULL);//将返回的java字符串转换为c字符串  
  8.         printf("the result is:%s\n",pname);//打印出调用的结果  
  9. }  

    调用函数编写完成后,用一个main函数来运行一下查看结果:

C代码   收藏代码
  1. int main(int argc, char **argv) {  
  2.         invoke();  
  3. }  
 

     至此,c的源代码cfjIns.c就编写完成了,我们开始编译cfjIns.c:

Java代码   收藏代码
  1. [roysong@roysong c]$ gcc -o cfj cfj.c -I$JAVA_HOME/include -I$JAVA_HOME/include/linux -L$JAVA_HOME/jre/lib/i386/client -ljvm   
  2. [roysong@roysong c]$ ls  
  3. cfjIns  cfjIns.c  

     编译命令中我们使用-I选项加入了两个头文件路径,$JAVA_HOME/include这个是为了引用到jni.h,而

$JAVA_HOME/include/linux这个为了引用到jni_md.h,因为jni.h中有对jni_md.h的引用.我的操作系统是fedora,所以

jni_md.h在$JAVA_HOME/include的linux文件夹下面,其他操作系统可能路径不同,找到jni_md.h文件的路径进行替换

即可.使用-L选项是为了引用到java虚拟机的库文件libjvm.so,-l选项(注意,这是小写的L,而不是大写的i)是声明具体引用

的库jvm.如果libjvm.so文件的路径与我的不同,找到libjvm.so文件的路径进行替换即可.

    编译成功后,目录下面会出现一个可运行的cfj文件,如果一切顺利,我们运行它就可以得到预期的结果:

Java代码   收藏代码
  1. [roysong@roysong c]$ ./cfjIns  
  2. hello,a  

    显示正常,调用完成

 

 

 

最近在做的工作要用到本地方法，需要在Java中加载不少动态链接库（以下为方便延用Windows平台下的简写dll，但并不局限于Windows）。刚刚把程序跑通，赶紧把一些心得写出来，mark。也希望对大家的类似工作有所帮助.

首先，应当明确，dll有两类：（1）Java所依赖的dll和，（2）dll所依赖的dll。正是由于第（2）种dll的存在，才导致了java中加载dll的复杂性大大增加，许多说法都是这样的，但我实验的结果却表明似乎没有那么复杂，后面会予以详细阐述。

其次，Java中加载dll的方式也有两种：（1）通过调用System.loadLibrary(String filename)和，（2）通过调用System.load(String filename)方法。其底层都是通过使用ClassLoader中的loadLibrary(Class fromClass, String name, boolean isAbsolute)方法来实现的，区别仅在于（1）中的filename必须是绝对路径，（2）中的filename只能是dll名，不允许包含文件夹。

再者，Eclipse是一个相当强大的平台，其提供的BundleClassLoader的强大是一个很重要的原因，对于dll的加载也有自己一套很别致的做法，值得我们采纳。

 

根据上面的介绍，分两部分阐述Java中加载dll面临的主要问题和解决途径。

1. 在一般Java程序中加载dll

我所做的工作，需要加载的dll如下：

DigitDll.dll 
DsivsAcct.dll
DsivsComm.dll
DsivsTrans.dll
JBPack.dll
XCodeDll.dll
ImageDllCtrl.dll
yhfiche.dll
yhocr.dll
yhbill.dll
TSealSvrDll.dll
TImg.dll
TImage.dll   

直接调用的是TImage中的若干方法，列表中TImage之前的所有其直接或间接依赖的，不仅要把所有的dll load全，更要注意他们之间的依赖关系，被依赖dll一定要先加载，否则就会报错：UnsatisfiedLinkError。故而，首先应理清dll之间的依赖关系，上面的列表已经是处理过的了。

接下来是设置JVM的搜索路径，使其能够找到你的dll。JVM的搜索路径由java.library.path系统属性决定，其默认值为系统环境变量中的PATH内容。因此，可以通过修改PATH变量来达到设置java.library.path属性的目的（改变之后Eclipse需要重新启动），一般的方法是在PATH中加入dll所在文件夹的绝对路径。另一种方法是在Java命令的参数中加入“-Djava.library.path=dll所在文件夹的绝对路径”来设置（可以用；分开多个路径）。对于Eclipse开发环境上的应用程序，可以通过修改其启动参数，在VM arguments编辑框中加入前述参数。对于打包出来的Eclipse安装包，可编辑其启动目录下的application.ini（假设其启动文件为application.exe），在-vmargs后加入前述参数来设置java.library.path的值。需要注意的是，一旦JVM已经启动，则无法再修改java.library.path的内容了，也就是说，通过：

System.setProperty("java.library.path", "c:/mylib");

这样的方式是无法达到目的的，因为该属性是只读的。Sun公司的论坛上曾经讨论过如何在代码中修改java.library.path的问题，结论是：不能通过代码修改！如果嫌"java -Djava.library.path=c:/mylib"这样的方式写得太死，也只能是通过shell编程之类的方法对路径进行预处理，以改善其灵活性了。

如果你的dll是封装在jar包中的，则需要首先将之解压缩到一个临时路径上，然后再将该路径加入到Djava.library.path中，或者干脆将其解压缩到系统路径上。

2. 在Eclipse平台上加载dll

上面提到，Java中对本地库路径的设置方式做得太死，这也是我自己的切身体会，但令人感到欣慰的是我们的Eclipse平台的提供了一套比较灵活的做法，通过eclipse提供的BundleClassLoader，你可以将dll封在plugin中，既不需要在使用时解压缩，也不需要额外设置java.library.path属性，BundleClassLoader会自行到以相对plugin根目录的指定目录下去查找你的dll，这些目录是：ws/win32/, os/win32/x86/, os/win32/, nl/zh/CN/, nl/zh/，见org.eclipse.osgi.internal.baseadaptor.DefaultClassLoader和org.eclipse.core.runtime.internal.adaptor.EclipseClassLoadingHook。

我的目录设置是：
.classpath
.cvsignore
.project
build.properties
classes
CVS
lib
META-INF
os
plugin.xml
src

我把所有的dll都放到了os下面的win32目录内，同样可以建立ws/win32等目录用于放置本地库。如此处理之后，不用再修改任何系统变量就可以顺利加载本地库了。

另外，Eclipse还在MANIFEST文件中提供了Bundle-NativeCode的设置项，也是用于加载本地库的，有待进一步研究

使用JNI技术实现Java和C/C++互调（Java调C/C++）
wonghifong0223的博客
06-26 3210
Java作为一个技术生态平台在业界得到了广泛的应用，许许多多的大型项目都是搭载在其之上。Java语言本身功能也十分强大，能实现大量的业务逻辑算法。那么，我们为什么要让Java和C/C++互调呢，直接用Java写不就完了吗？这是初学者一个很常见的疑问，下面我们来看看为什么需要这样做。     用Java调用底层的代码（不一定指是C/C++写的，虽然大部分是）主要原因有三个：     1.运行效率
Qt for Android 用JNI来使C++和Java互调（目前最新版全网只有这个可用）
03-13
"Qt for Android 用JNI来使C++和Java互调"的主题揭示了如何利用JNI（Java Native Interface）技术在Qt与Android原生系统之间建立桥梁，实现两者的交互。以下将详细介绍这一过程。 首先，Qt for Android是Qt项目的一...
JNI技术介绍
07-31
JNI 简单介绍，了解JNI技术，适合想了解JNI的开发者
java与C/C++之间通过jni相互调用
wzb56的资料库
08-29 2795
一、jni简介： 企业应用 JNI一直以来都很少去关注，但却是我心中的一个结，最近这几天刚好手头有点时间，因此抽空看了一下这方面的东西，整理了一份文档，JNI技术的出现主要是基于三个方面的应用需求：   1. 解决性能问题 Java具有平台无关性，这使人们在开发企业级应用的时候总是把它作为主要候选方案之一，但是性能方面的因素又大大削弱了它的竞争力。为此，提高J
JNI技术-1
weixin_30332241的博客
12-01 117
什么是JNI呢 就是 java native interface 是 sun公司提供给我们的一个可以调用本地 非 java语言代码 的接口 . JNI技术 实现了java调用本地方法 ,但是有破坏了 java的 跨平台性,因为 java代码可以一次编译处处运行 但是 其他语言则不可以 还有java是强类型语言 在进...
JNI技术简介
空杯子的博客
04-12 1万+
JNI技术 目标:认识JNI(Java Native Interface)技术，了解Java调用本地C/C++库的简单原理以及一些基本的知识点 一、简介 JNI是Java Native Interface的缩写，通过使用Java本地接口书写程序，可以确保代码在不同的平台上方便移植。从Java1.1开始，JNI标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。 本地代码与 Java 虚拟机之间是通过 JNI 函数实现相互操作的。JNI函数通过接口指针来获得，本地方法将..
JNI技术详解
weixin_34277853的博客
05-10 147
前段时间探究了点关于JNI技术方面的东西，在网上找，发现关于这方面的东西很少 基本上也是找不到，所以就决定写下来，做个笔记： JNI: JNI是Java Native Interface的缩写，中文为JAVA本地调用。从Java1.1开始，Java Native Interface(JNI)标准成为java平台的一部分，它允许Java代码和其他语言写的代码进行交互。J...
C/C++与Java互调指南：深入JNI技术手册
JNI技术手册是开发者在进行Java与C/C++互操作编程时的重要参考资料，该手册详细介绍了如何在Java代码中调用C/C++库，以及如何从C/C++代码中访问Java对象和方法。 ### 标题知识点 ####JNI 概念 JNI技术允许Java...
JNI技术手册 c/c++调用java
09-11
### JNI技术手册：C/C++与Java互调详解 #### 一、JNI技术概览 **JNI（Java Native Interface）** 是Java平台的一部分，它允许Java代码与其他语言写的代码进行交互，尤其是C和C++。JNI是Java与本地代码之间沟通的...
掌握安卓JNI技术：Java与C/C++的互调指南
5. Java虚拟机通过JNI调用约定（JNI calling conventions）来调用这些本地函数，进行数据交换与执行操作。 6. 本地方法返回后，JNI负责将执行结果返回给Java代码。 JNI技术的使用场景主要包括性能优化、代码复用...
JNI技术
a2796749的专栏
05-15 681
一、JNI简介 JNI是Java Native Interface的简称,也就是java本地接口。它提供了java和其他语言通信（主要是C&C++）的若干API。由于项目中出现了以下两种情况： a.需要将一个java实现的系统与一个非java实现的系统整合起来。 b. Java代码中需要用到某种算法，不过该算法是封装在动态链接库文件（DLL）当中的。 对于上述的两种情况，如果不使用JNI的
JNI技术(Java Native Interface)
码农界的小学生
12-29 239
说白了，就是JAVA调用由C/C++编写的库文件DLL(WINDOWS)/SO(UNIX) public class testdll  {      static      {          System.loadLibrary("goodluck");      }      public native static int get();
JNI技术(一)
u011727893的博客
10-05 256
JNI技术(一)      JNI技术的出现主要是基于三个方面的应用需求： 1. 解决性能问题 Java具有平台无关性，这使人们在开发企业级应用的时候总是把它作为主要候选方案之一，但是性能方面的因素又大大削弱了它的竞争力。为此，提高Java的性能就显得十分重要。Sun公司及Java的支持者们为提高Java的运行速度已经做出了许多努力，其中大多数集中在程序设计的方法和模式选择方面。
jni c java互相调用_通过JNI实现Java和C++的相互调用
weixin_34418334的博客
02-17 170
评论#re: 通过JNI实现Java和C++的相互调用2008-07-29 14:14Always BaNg.不错，把字符转换也一并讲了吧，比如UTF-8的处理，USC-2与MBCS转换等。回复更多评论#re: 通过JNI实现Java和C++的相互调用[未登录]2008-07-29 14:17role0523你是指Java和C++之间的字符转换?目前还没有研究过字符转换。回复更多评...
JNI JAVA与C的互相调用
itheimach的专栏
12-03 423
Java调用C例子：java端调用c端的add，两个数相加1.java端void test() { int addr = add(100,200); test.setText("add ="+addr); } static { System.loadLibrary("javacallc"); } private native int a
jni c java互相调用_JNI JAVA与C的互相调用
weixin_39916379的博客
02-13 164
Java调用C例子：java端调用c端的add，两个数相加1.java端void test() {int addr = add(100,200);test.setText("add ="+addr);}static {System.loadLibrary("javacallc");}private native int add(int a,int b);2.建jni目录(main目录下面)，在ja...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值