Chinaunix首页 | 论坛 | 博客

牛蹄印章_VX_iibull

首页　| 　博文目录　| 　关于我

iibull

  • 博客访问： 9393072
  • 博文数量： 1747
  • 博客积分： 12961
  • 博客等级： 上将
  • 技术积分： 20060
  • 用 户 组： 普通用户
  • 注册时间： 2009-01-09 11:25
个人简介

偷得浮生半桶水(半日闲), 好记性不如抄下来(烂笔头). 信息爆炸的时代, 学习是一项持续的工作.

文章分类

全部博文（1747）

文章存档

2024年（23）

2023年（26）

2022年（112）

2021年（217）

2020年（157）

2019年（192）

2018年（81）

2017年（78）

2016年（70）

2015年（52）

2014年（40）

2013年（51）

2012年（85）

2011年（45）

2010年（231）

2009年（287）

我的朋友
最近访客
推荐博文
相关博文
JNI编程 —— 让C++和Java相互调用

分类： LINUX

2009-09-28 15:26:34

JNI其实是Java Native Interface的简称,也就是java本地接口。它提供了若干的API实现了和Java和其他语言的通信（主要是C&C++）。也许不少人觉 得Java已经足够强大，为什么要需要JNI这种东西呢？我们知道Java是一种平台无关性的语言，平台对于上层的java代码来说是透明的，所以在多数 时间我们是不需要JNI的，但是假如你遇到了如下的三种情况之一呢？

 

  1. 你的Java代码，需要得到一个文件的属性。但是你找遍了JDK帮助文档也找不到相关的API。
  2. 在本地还有一个别的系统，不过他不是Java语言实现的，这个时候你的老板要求你把两套系统整合到一起。
  3. 你的Java代码中需要用到某种算法，不过算法是用C实现并封装在动态链接库文件（DLL）当中的。

对于上述的三种情况，如果没有JNI的话，那就会变得异常棘手了。就算找到解决方案了，也是费时费力。其实说到底还是会增加开发和维护的成本。

 

说了那么多一通废话，现在进入正题。看过JDK源代码的人肯定会注意到在源码里有很多标记成native的方法。这些个方法只有方法签名但是没有方 法体。其实这些naive方法就是我们说的 java native interface。他提供了一个调用（invoke）的接口，然后用C或者C++去实现。我们首先来编写这个“桥梁”.我自己的开发环境是 j2sdk1.4.2_15 + eclipse 3.2 + VC++ 6.0，先在eclipse里建立一个HelloFore的Java工程，然后编写下面的代码。

Java代码
  1. package com.chnic.jni;  
  2.   
  3. public class SayHellotoCPP {  
  4.       
  5.     public SayHellotoCPP(){  
  6.     }  
  7.     public native void sayHello(String name);  
  8. }  

 

 一般的第一个程序总是HelloWorld。今天换换口味，把world换成一个名字。我的native本地方法有一个String的参数。会传 递一个name到后台去。本地方法已经完成，现在来介绍下javah这个方法，接下来就要用javah方法来生成一个相对应的.h头文件。

 

javah是一个专门为JNI生成头文件的一个命令。CMD打开控制台之后输入javah回车就能看到javah的一些参数。在这里就不多介绍 我们要用的是 -jni这个参数，这个参数也是默认的参数，他会生成一个JNI式的.h头文件。在控制台进入到工程的根目录，也就是HelloFore这个目录，然后输 入命令。

Java代码
  1. javah -jni com.chnic.jni.SayHellotoCPP  

 

命令执行完之后在工程的根目录就会发现com_chnic_jni_SayHellotoCPP.h 这个头文件。在这里有必要多句嘴，在执行javah的时候，要输入完整的包名+类名。否则在以后的测试调用过程中会发生java.lang.UnsatisfiedLinkError这个异常。

 

到这里java部分算是基本完成了，接下来我们来编写后端的C++代码。（用C也可以，只不过cout比printf用起来更快些，所以这里俺偷下 懒用C++）打开VC++首先新建一个Win32 Dynamic-Link library工程，之后选择An empty DLL project空工程。在这里我C++的工程是HelloEnd，把刚刚生成的那个头文件拷贝到这个工程的根目录里。随便用什么文本编辑器打开这个头文 件，发现有一个如下的方法签名。

Cpp代码
  1. /* 
  2.  * Class:     com_chnic_jni_SayHellotoCPP 
  3.  * Method:    sayHello 
  4.  * Signature: (Ljava/lang/String;)V 
  5.  */  
  6. JNIEXPORT void JNICALL Java_com_chnic_jni_SayHellotoCPP_sayHello  
  7.   (JNIEnv *, jobject, jstring);  

 

仔细观察一下这个方法，在注释上标注类名、方法名、签名（Signature），至于这个签名是做什么用的，我们以后再说。在这里最重要的是 Java_com_chnic_jni_SayHellotoCPP_sayHello这个方法签名。在Java端我们执行 sayHello(String name)这个方法之后，JVM就会帮我们唤醒在DLL里的Java_com_chnic_jni_SayHellotoCPP_sayHello这个方 法。因此我们新建一个C++ source file来实现这个方法。

Cpp代码
  1. #include   
  2. #include "com_chnic_jni_SayHellotoCPP.h"  
  3.   
  4.   
  5. JNIEXPORT void JNICALL Java_com_chnic_jni_SayHellotoCPP_sayHello   
  6.   (JNIEnv* env, jobject obj, jstring name)  
  7. {  
  8.     const char* pname = env->GetStringUTFChars(name, NULL);  
  9.     cout << "Hello, " << pname << endl;  
  10. }  

 

因为我们生成的那个头文件是在C++工程的根目录不是在环境目录，所以我们要把尖括号改成单引号，至于VC++的环境目录可以在 Tools->Options->Directories里设置。F7编译工程发现缺少jni.h这个头文件。这个头文件可以 在%JAVA_HOME%\include目录下找到。把这个文件拷贝到C++工程目录，继续编译发现还是找不到。原来是因为在我们刚刚生成的那个头文件 里，jni.h这个文件是被 #include 引用进来的，因此我们把尖括号改成双引号#include "jni.h"，继续编译发现少了jni_md.h文件，接着在%JAVA_HOME%\include\win32下面找到那个头文件，放入到工程根目 录，F7编译成功。在Debug目录里会发现生成了HelloEnd.dll这个文件。

 

这个时候后端的C++代码也已经完成，接下来的任务就是怎么把他们连接在一起了，要让前端的java程序“认识并找到”这个动态链接库，就必须把这个DLL放在windows path环境变量下面。有两种方法可以做到：

 

  1. 把这个DLL放到windows下面的sysytem32文件夹下面，这个是windows默认的path
  2. 复制你工程的Debug目录，我这里是C:\Program Files\Microsoft Visual Studio\MyProjects\HelloEnd\Debug这个目录，把这个目录配置到User variable的Path下面。重启eclipse，让eclipse在启动的时候重新读取这个path变量。

 

比较起来，第二种方法比较灵活，在开发的时候不用来回copy dll文件了，节省了很多工作量，所以在开发的时候推荐用第二种方法。在这里我们使用的也是第二种，eclipse重启之后打开 SayHellotoCPP这个类。其实我们上面做的那些是不是是让JVM能找到那些DLL文件，接下来我们要让我们自己的java代码“认识”这个动态 链接库。加入System.loadLibrary("HelloEnd");这句到静态初始化块里。

 

Java代码
  1. package com.chnic.jni;  
  2.   
  3. public class SayHellotoCPP {  
  4.       
  5.     static{  
  6.         System.loadLibrary("HelloEnd");  
  7.     }  
  8.     public SayHellotoCPP(){  
  9.     }  
  10.     public native void sayHello(String name);  
  11.       
  12. }  

 

这样我们的代码就能认识并加载这个动态链接库文件了。万事俱备，只欠测试代码了，接下来编写测试代码。

Java代码
  1. SayHellotoCPP shp = new SayHellotoCPP();  
  2. shp.sayHello("World");  

 

我们不让他直接Hello，World。我们把World传进去，执行代码。发现控制台打印出来Hello, World这句话。就此一个最简单的JNI程序已经开发完成。也许有朋友会对CPP代码里的

Cpp代码
  1. const char* pname = env->GetStringUTFChars(name, NULL);  

 

 这句有疑问，这个GetStringUTFChars就是JNI给developer提供的API，我们以后再讲。在这里不得不多句嘴。

  1. 因为JNI有一个Native这个特点，一点有项目用了JNI，也就说明这个项目基本不能跨平台了。
  2. JNI调用是相当慢的，在实际使用的之前一定要先想明白是否有这个必要。
  3. 因为C++和C这样的语言非常灵活，一不小心就容易出错，比如我刚刚的代码就没有写析构字符串释放内存，对于java developer来说因为有了GC 垃圾回收机制，所以大多数人没有写析构函数这样的概念。所以JNI也会增加程序中的风险，增大程序的不稳定性。
 

其实在Java代码中，除了对本地方法标注native关键字和加上要加载动态链接库之外，JNI基本上是对上层coder透明的，上层coder调用那些本地方法的时候并不知道这个方法的方法体究竟是在哪里，这个道理就像我们用JDK所提供的API一样。所以在Java中使用JNI还是很简单的，相比之下在C++中调用java，就比前者要复杂的多了。

 

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

 

    Java类型                 本地类型                  JNI中定义的别名    
int long jint
long _int64 jlong
byte signed char jbyte
boolean unsigned char jboolean
char unsigned short jchar
short short jshort
float float jfloat
double double jdouble
Object _jobject* jobject

 

上面的表格是我在网上搜的，放上来给大家对比一下。对于每一种映射的数据类型，JNI的设计者其实已经帮我们取好了相应的别名以方便记忆。如果想了解一些更加细致的信息，可以去看一些jni.h这个头文件，各种数据类型的定义以及别名就被定义在这个文件中。

 

了解了JNI中的数据类型，下面就来看这次的例子。这次我们用Java来实现一个前端的market（以下就用Foreground代替）用CPP来实现一个后端factory（以下用backend代替）。我们首先还是来编写包含本地方法的java类。

 

Java代码
  1. package com.chnic.service;  
  2.   
  3. import com.chnic.bean.Order;  
  4.   
  5. public class Business {  
  6.     static{  
  7.         System.loadLibrary("FruitFactory");  
  8.     }  
  9.       
  10.     public Business(){  
  11.           
  12.     }  
  13.       
  14.     public native double getPrice(String name);  
  15.     public native Order getOrder(String name, int amount);  
  16.     public native Order getRamdomOrder();  
  17.     public native void analyzeOrder(Order order);  
  18.       
  19.     public void notification(){  
  20.         System.out.println("Got a notification.");  
  21.     }  
  22.       
  23.     public static void notificationByStatic(){  
  24.         System.out.println("Got a notification in a static method.");  
  25.     }  
  26. }  
 

这个类里面包含4个本地方法，一个静态初始化块加载将要生成的dll文件。剩下的方法都是很普通的java方法，等会在backend中回调这些方法。这个类需要一个名为Order的JavaBean。

 

Java代码
  1. package com.chnic.bean;  
  2.   
  3. public class Order {  
  4.       
  5.     private String name = "Fruit";  
  6.     private double price;  
  7.     private int amount = 30;  
  8.       
  9.     public Order(){  
  10.           
  11.     }  
  12.   
  13.     public int getAmount() {  
  14.         return amount;  
  15.     }  
  16.    
  17.     public void setAmount(int amount) {  
  18.         this.amount = amount;  
  19.     }  
  20.   
  21.     public String getName() {  
  22.         return name;  
  23.     }  
  24.   
  25.     public void setName(String name) {  
  26.         this.name = name;  
  27.     }  
  28.   
  29.     public double getPrice() {  
  30.         return price;  
  31.     }  
  32.   
  33.     public void setPrice(double price) {  
  34.         this.price = price;  
  35.     }  
  36. }  

 

JavaBean中，我们为两个私有属性赋值，方便后面的例子演示。到此为止除了测试代码之外的Java端的代码就全部高调了，接下来进行生成.h 头文件、建立C++工程的工作，在这里就一笔带过，不熟悉的朋友请回头看第一篇。在工程里我们新建一个名为Foctory的C++ source file 文件，去实现那些native方法。具体的代码如下。

 

Cpp代码
  1. #include   
  2. #include   
  3. #include "com_chnic_service_Business.h"  
  4.   
  5. jobject getInstance(JNIEnv* env, jclass obj_class);  
  6.   
  7. JNIEXPORT jdouble JNICALL Java_com_chnic_service_Business_getPrice(JNIEnv* env,   
  8.                                                                    jobject obj,   
  9.                                                                    jstring name)  
  10. {  
  11.     const char* pname = env->GetStringUTFChars(name, NULL);  
  12.     cout << "Before release: "  << pname << endl;  
  13.   
  14.     if (strcmp(pname, "Apple") == 0)  
  15.     {  
  16.         env->ReleaseStringUTFChars(name, pname);  
  17.         cout << "After release: " << pname << endl;  
  18.         return 1.2;  
  19.     }   
  20.     else  
  21.     {  
  22.         env->ReleaseStringUTFChars(name, pname);  
  23.         cout << "After release: " << pname << endl;  
  24.         return 2.1;  
  25.     }     
  26. }  
  27.   
  28.   
  29. JNIEXPORT jobject JNICALL Java_com_chnic_service_Business_getOrder(JNIEnv* env,   
  30.                                                                    jobject obj,   
  31.                                                                    jstring name,   
  32.                                                                    jint amount)  
  33. {  
  34.     jclass order_class = env->FindClass("com/chnic/bean/Order");  
  35.     jobject order = getInstance(env, order_class);  
  36.       
  37.     jmethodID setName_method = env->GetMethodID(order_class, "setName", "(Ljava/lang/String;)V");  
  38.     env->CallVoidMethod(order, setName_method, name);  
  39.   
  40.     jmethodID setAmount_method = env->GetMethodID(order_class, "setAmount", "(I)V");  
  41.     env->CallVoidMethod(order, setAmount_method, amount);  
  42.   
  43.     return order;  
  44. }  
  45.   
  46. JNIEXPORT jobject JNICALL Java_com_chnic_service_Business_getRamdomOrder(JNIEnv* env,   
  47.                                                                          jobject obj)  
  48. {  
  49.     jclass business_class = env->GetObjectClass(obj);  
  50.     jobject business_obj = getInstance(env, business_class);  
  51.   
  52.     jmethodID notification_method = env->GetMethodID(business_class, "notification", "()V");  
  53.     env->CallVoidMethod(obj, notification_method);  
  54.   
  55.     jclass order_class = env->FindClass("com/chnic/bean/Order");  
  56.     jobject order = getInstance(env, order_class);  
  57.     jfieldID amount_field = env->GetFieldID(order_class, "amount", "I");  
  58.     jint amount = env->GetIntField(order, amount_field);  
  59.     cout << "amount: " << amount << endl;  
  60.     return order;  
  61. }  
  62.   
  63.   
  64. JNIEXPORT void JNICALL Java_com_chnic_service_Business_analyzeOrder (JNIEnv* env,   
  65.                                                                      jclass cls,   
  66.                                                                      jobject obj)  
  67. {  
  68.     jclass order_class = env->GetObjectClass(obj);  
  69.     jmethodID getName_method = env->GetMethodID(order_class, "getName", "()Ljava/lang/String;");  
  70.     jstring name_str = static_cast(env->CallObjectMethod(obj, getName_method));  
  71.     const char* pname = env->GetStringUTFChars(name_str, NULL);  
  72.   
  73.     cout << "Name in Java_com_chnic_service_Business_analyzeOrder: " << pname << endl;  
  74.     jmethodID notification_method_static = env->GetStaticMethodID(cls, "notificationByStatic", "()V");  
  75.     env->CallStaticVoidMethod(cls, notification_method_static);  
  76.   
  77. }  
  78.   
  79. jobject getInstance(JNIEnv* env, jclass obj_class)  
  80. {  
  81.     jmethodID construction_id = env->GetMethodID(obj_class, "", "()V");  
  82.     jobject obj = env->NewObject(obj_class, construction_id);  
  83.     return obj;  
  84. }  
 

可以看到，在我Java中的四个本地方法在这里全部被实现，接下来针对这四个方法来解释下，一些JNI相关的API的使用方法。先从第一个方法讲起吧：

 

1.getPrice(String name)

 

这个方法是从foreground传递一个类型为string的参数到backend，然后backend判断返回相应的价格。在cpp的代码中， 我们用GetStringUTFChars这个方法来把传来的jstring变成一个UTF-8编码的char型字符串。因为jstring的实际类型是 jobject，所以无法直接比较。

GetStringUTFChars方法包含两个参数，第一参数是你要处理的jstring对象，第二个参数是否需要在内存中生成一个副本对象。将 jstring转换成为了一个const char*了之后，我们用string.h中带strcmp函数来比较这两个字符串，如果传来的字符串是“Apple”的话我们返回1.2。反之返回 2.1。在这里还要多说一下ReleaseStringUTFChars这个函数，这个函数从字面上不难理解，就是释放内存用的。有点像cpp里的析构函 数，只不过Sun帮我们已经封装好了。由于在JVM中有GC这个东东，所以多数java coder并没有写析构的习惯，不过在JNI里是必须的了，否则容易造成内存泄露。我们在这里在release之前和之后分别打出这个字符串来看一下效果。

 

粗略的解释完一些API之后，我们编写测试代码。

 

Java代码
  1. Business b = new Business();          
  2. System.out.println(b.getPrice("Apple"));  
 

运行这段测试代码，控制台上打出

 

Before release: Apple
After release:

阅读(11077) | 评论(0) | 转发(0) |
0

上一篇：基础库-libxplc

下一篇：ubuntu 下 PC机上的软件

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6