JNI 详解

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. public class SayHellotoCPP {
  3. public SayHellotoCPP(){
  4. }
  5. public native void sayHello(String name);
  6. }

[java] view
plaincopy

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

一般的第一个程序总是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

[java] view
plaincopy

  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);

[cpp] view
plaincopy

  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 <iostream.h>
  2. #include "com_chnic_jni_SayHellotoCPP.h"
  3. JNIEXPORT void JNICALL Java_com_chnic_jni_SayHellotoCPP_sayHello
  4. (JNIEnv* env, jobject obj, jstring name)
  5. {
  6. const char* pname = env->GetStringUTFChars(name, NULL);
  7. cout << "Hello, " << pname << endl;
  8. }

[cpp] view
plaincopy

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

因为我们生成的那个头文件是在C++工程的根目录不是在环境目录，所以我们要把尖括号改成单引号，至于VC++的环境目录可以在 Tools->Options->Directories里设置。F7编译工程发现缺少jni.h这个头文件。这个头文件可以在%JAVA_HOME%/include目录下找到。把这个文件拷贝到C++工程目录，继续编译发现还是找不到。原来是因为在我们刚刚生成的那个头文件里，jni.h这个文件是被 #include <jni.h>引用进来的，因此我们把尖括号改成双引号#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. public class SayHellotoCPP {
  3. static{
  4. System.loadLibrary("HelloEnd");
  5. }
  6. public SayHellotoCPP(){
  7. }
  8. public native void sayHello(String name);
  9. }

[java] view
plaincopy

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

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

Java代码

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

[java] view
plaincopy

  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);

[cpp] view
plaincopy

  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. import com.chnic.bean.Order;
  3. public class Business {
  4. static{
  5. System.loadLibrary("FruitFactory");
  6. }
  7. public Business(){
  8. }
  9. public native double getPrice(String name);
  10. public native Order getOrder(String name, int amount);
  11. public native Order getRamdomOrder();
  12. public native void analyzeOrder(Order order);
  13. public void notification(){
  14. System.out.println("Got a notification.");
  15. }
  16. public static void notificationByStatic(){
  17. System.out.println("Got a notification in a static method.");
  18. }
  19. }

[java] view
plaincopy

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

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

Java代码

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

[java] view
plaincopy

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

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

Cpp代码

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

[cpp] view
plaincopy

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

可以看到，在我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"));

[java] view
plaincopy

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

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

Before release: Apple

After release: ?&#18;?

1.2

在release之前打印出来的是我们“需要”的Apple，release之后就成了乱码了。由于传递的是Apple，所以得到1.2。测试成功。

2. getOrder(String name, int amount)

在foreground中可以通过这个方法让backend返回一个你“指定”的Order。所谓“指定”，其实也就是指方法里的两个参数：name和amout，在cpp的代码在中，会根据传递的两个参数来构造一个Order。回到cpp的代码里。

Java代码

  1. jclass order_class = env->FindClass("com/chnic/bean/Order");

[java] view
plaincopy

  1. jclass order_class = env->FindClass("com/chnic/bean/Order");

是不是觉得这句代码似曾相识？没错，这句代码很像我们java里写的Class.forName(className)反射的代码。其实在这里 FindClass的作用和上面的forName是类似的。只不过在forName中要用完整的类名，但是在这里必须用"/"来代替“.”。这个方法会返回一个jclass的对象，其实也就是我们在Java中说的类对象。

Java代码

  1. jmethodID construction_id = env->GetMethodID(obj_class, "<init>", "()V");
  2. jobject obj = env->NewObject(obj_class, construction_id);

[java] view
plaincopy

  1. jmethodID construction_id = env-><span class="hilite1">GetMethodID</span>(obj_class, "<init>", "()V");
  2. jobject obj = env->NewObject(obj_class, construction_id);

拿到"类对象"了之后，按照Java RTTI的逻辑我们接下来就要唤醒那个类对象的构造函数了。在JNI中，包括构造函数在内的所有方法都被看成Method。每个method都有一个特定的ID，我们通过GetMethodID这个方法就可以拿到我们想要的某一个java 方法的ID。GetMethodID需要传三个参数，第一个是很显然jclass，第二个参数是java方法名，也就是你想取的method
ID的那个方法的方法名（有些绕口 ），第三个参数是方法签名。

在这里有必要单独来讲一讲这个方法签名，为什么要用这个东东呢？我们知道，在Java里方法是可以被重载的，比如我一个类里有public void a(int arg)和public void a(String arg)这两个方法，在这里用方法名来区分方法显然就是行不通的了。方法签名包括两部分：参数类型和返回值类型；具体的格式：(参数1类型签名参数2类型签名)返回值类型签名。下面是java类型和年名类型的对照的一个表

    Java类型      对应的签名
boolean Z
byte B
char C
shrot S
int I
long L
float F
double D
void V
Object L用/分割包的完整类名;  Ljava/lang/String;
Array [签名       [I       [Ljava/lang/String;

其实除了自己对照手写之外，JDK也提供了一个很好用的生成签名的工具javap,cmd进入控制台到你要生成签名的那个类的目录下。在这里用 Order类打比方，敲入： javap -s -private Order。所有方法签名都会被输出，关于javap的一些参数可以在控制台下面输入 javap -help查看。（做coder的 毕竟还是要认几个单词的）

啰嗦了一大堆，还是回到我们刚刚的getMethodID这个方法上。因为是调用构造函数，JNI规定调用构造函数的时候传递的方法名应该为<init> ,通过javap查看 我们要的那个无参的构造函数的方法签是()V。得到方法签名，最后我们调用NewObject方法来生成一个新的对象。

拿到了对象，之后我们开始为对象jobject填充数值，还是首先拿到setXXX方法的Method ID，之后调用Call<Type>Method来调用java方法。这里的<Type>所指的是方法的返回类型，我们刚刚调用的是set方法的返回值是void，因此这里的方法也就是CallVoidMethod，这个方法的参数除了前两个要传入jobject和 jmethodID之外还要传入要调用的那个方法的参数，而且要顺序必须一致，这点和Java的反射一模一样，在这里就不多解释。（看到这一步是不是对 java 反射又有了自己新的理解？）

终于介绍完了第二个方法，下来就是测试代码测试。

Java代码

  1. Order o = b.getOrder("Watermelom", 100);
  2. System.out.println("java: " + o.getName());
  3. System.out.println("java: " + o.getAmount());

[java] view
plaincopy

  1. Order o = b.getOrder("Watermelom", 100);
  2. System.out.println("java: " + o.getName());
  3. System.out.println("java: " + o.getAmount());

控制台打出

java: Watermelom

java: 100

就此，我们完成了第二个方法的测试。

3.getRamdomOrder()

这个方法会从backend得到一个随机的Order对象（抱歉这里“Random”拼错了），然后再调用java中相应的通知方法来通知 foreground。getRamdomOrder方法没有参数，但是所对应的C++方法里却有两个参数，一定有人会不解。其实细心的朋友一定会发现，JNI里所有对应Java方法的C++ 方法都会比Java方法多两个参数，第一个参数是我们很熟悉的JNIEnv*指针，第二个参数有时是jobject有时是个jclass。针对这第二个参数在这里有必要多废话两句。

其实第二个参数传递的是包含了native本地方法的对象或者类对象，我们知道非静态的方法是属于某一个对象的，而静态方法是属于类对象的，所以静态方法可以被所有对象共享。有这个对象/类对象，我们就可以很方便的操作包含了native方法的对象的一些函数了。（这句话有点绕口，没看明白的建议多读两遍）。

废话完了言归正传，因为getRamdomOrder不是静态的，所以C++相对应的参数中传递来的是一个jobject对象。

Cpp代码

  1. jclass business_class = env->GetObjectClass(obj);

[cpp] view
plaincopy

  1. jclass business_class = env->GetObjectClass(obj);

这一句不难理解，GetObjectClass方法可以得到一个对象的类对象，这句有点像Java中的Object.class。不熟悉的朋友建议再去看一下Java反射机制。接下来的几句C++代码应该在之前的方法1和方法2中都解释过。早backend端会发一个“消息”给 foreground，之后new一个新的Order类出来。接下来的三句有必要再废话一下。

Cpp代码

  1. jfieldID amount_field = env->GetFieldID(order_class, "amount", "I");
  2. jint amount = env->GetIntField(order, amount_field);
  3. cout << "amount: " << amount << endl;

[cpp] view
plaincopy

  1. jfieldID amount_field = env->GetFieldID(order_class, "amount", "I");
  2. jint amount = env->GetIntField(order, amount_field);
  3. cout << "amount: " << amount << endl;

之前我为Order这个Javabean的amount的属性设置了一个初始值为30，其实就是为了在这里演示如何在C++中拿一个Java对象的属性，拿的方法和我们之前说过的调用Java方法的程序差不多，也要先拿到一个jfieldID，之后调用Get<type>Field方法来取得某一个对象中的某一个属性的数值，最后cout把他打印出来。我们编写测试代码来看一下最终效果。

Java代码

  1. Business b = new Business();
  2. Order o2 = b.getRamdomOrder();
  3. System.out.println(o2.getName());

[java] view
plaincopy

  1. Business b = new Business();
  2. Order o2 = b.getRamdomOrder();
  3. System.out.println(o2.getName());

运行上述的测试代码之后，控制台上打出了

Got a notification.

amount: 30

Fruit

和我们想要的结果是一样的，测试成功。

4.analyzeOrder(Order order)

这是一个静态方法，foreground会通过这个方法传一个Order的对象到backend去，然后再由CPP端进行“analyze”。在这里我们取出来传递过来的Order对象的name属性，然后打印到控制台上。因为这个方法是静态static方法，所以相对应的C++方法中的第二个参数也变成了jclass对象，也就是Business.class这个类对象。第三个参数是一个jobject对象，很明显就是我们传递过来的order对象。

前5句代码应该不难理解，就是调用getName这个方法，然后打印出来。因为JNI的API中并没有提供CallStringMethod这个方法，所以我们用CallObjectMethod这个方法来取得name这个字符串（String很明显也是一个Object），然后再转型成为 jstring。也就是下面这句代码。

Cpp代码

  1. jstring name_str = static_cast<jstring>(env->CallObjectMethod(obj, getName_method));

[cpp] view
plaincopy

  1. jstring name_str = static_cast<jstring>(env->CallObjectMethod(obj, getName_method));

取到了name这个字符串之后cout打印出来，之后调用Business这个类对象中的静态方法notificationByStatic来通知 foreground。调用的流程以及方法和非静态都是一样的，只不过注意JNI中调用静态方法的API所传递的一个参数是一个jclass而非 jobject（这个也不难理解，因为静态方法是属于class类对象的）

还是编写测试代码测试这个方法

Java代码

  1. Business b = new Business();
  2. Order o = b.getOrder("Watermelom", 100);
  3. Business.analyzeOrder(o);

[java] view
plaincopy

  1. Business b = new Business();
  2. Order o = b.getOrder("Watermelom", 100);
  3. Business.analyzeOrder(o);

控制台上打印出

Name in Java_com_chnic_service_Business_analyzeOrder: Watermelom

Got a notification in a static method.

第一句是C++中cout打印出来的，第二句则是Java中的静态方法打印出来的，和我们想要的结果是一致的。

呼~好不容易介绍完了4个方法，最后总结一下吧。

  1. JNI中所提供的API远远不止这4个方法中所使用的API。上面介绍的都是比较常用的，本人也不可能罗列出所有的API。
  2. 了解了JNI编程更加有利于深入了解Java中的反射机制，反之亦然。

因此如果有对JNI编程有兴趣或者有更深入的需要，可以参考一下sun的相关文档。在这里上传sun提供的JNI的API手册，还有上面例子中所用的演示代码给大家参考。

JNI 详解,布布扣,bubuko.com

时间： 2024-10-15 22:45:02

JNI 详解的相关文章

Java本地接口JNI详解

对于java程序员来说,java语言的好处和优点,我想不用我说了,大家自然会说出很多一套套的.但虽然我们作为java程序员,但我们不得不承认java语言也有一些它本身的缺点.比如在性能.和底层打交道方面都有它的缺点.所以java就提供了一些本地接口,他主要的作用就是提供一个标准的方式让java程序通过虚拟机与原生代码进行交互,这也就是我们平常常说的java本地接口(JNI--java native Interface).它使得在 Java 虚拟机(VM) 内部运行的Java 代码能够与用其它编程

QtAndroid详解(5)：JNI调用Android系统功能(2)

在"QtAndroid详解(4):JNI调用Android系统功能(1)"中我们给出了一些简单的示例,演示了如何使用 Qt JNI 类库访问网络状态.系统资源目录.当前应用信息等等,这次呢,我们提供一些新的示例,这些示例可能更具实际意义.本文的示例包括: 震动 让屏幕常亮 动态改变应用的显示方向(横屏.竖屏) 调节屏幕亮度 设置铃声模式 示例介绍 图1 我们按照界面上的顺序,一个一个来看这些功能如何实现. 源码分析 构建界面的代码在 Widget 类的构造函数里,不说了.这次我们换个搞

jni.h头文件详解(二)

一:struct JNINativeInterface_{} 结构体的作用:它有点像我们char字符驱动的 file_ops结构体,它定义各种函数对在(jni.h头文件详解一)中定义的各种数据的操作函数集体． 二:它包含那些针对Java中类和对象的相关操作呢如下图． 三:下面我们讲详细介绍14个部分方法的用法和解析 3.1.版本信息操作函数. 一.GetVersion jint (JNICALL *GetVersion)(JNIEnv *env) --模块信息:该模块主要针对的JNI接口的版本信

jni.h头文件详解二

作者:左少华 博客:http://blog.csdn.net/shaohuazuo/article/details/42932813 转载请注明出处:http://blog.csdn.net/shaohuazuo 一:struct JNINativeInterface_{} 结构体的作用:它有点像我们char字符驱动的 file_ops结构体,它定义各种函数对在(jni.h头文件详解一)中定义的各种数据的操作函数集体． 二:它包含那些针对Java中类和对象的相关操作呢如下图． 三:下面我们讲详细

java 通过jni调用c++实现详解

Java通过JNI调用C++程序 JNI是Java Native Interface的缩写,中文为JAVA本地调用.使用JNI可以很方便的用我们的Java程序调用C/C++程序.很多时候,某些功能用Java无法实现,比如说涉及到底层驱动的一些功能,这时候我们就可以利用JNI来调用C或者C++程序来实现,这就是JNI的强大之处.但是JNI也有它的缺点,使用java与本地已编译的代码交互,通常会丧失平台可移植性. 下面是一个JNI例子,调用C++输出"hello world": 第一步:创

Java虚拟机工作原理详解

原文地址:http://blog.csdn.net/bingduanlbd/article/details/8363734 一.类加载器 首先来看一下java程序的执行过程. 从这个框图很容易大体上了解java程序工作原理.首先,你写好java代码,保存到硬盘当中.然后你在命令行中输入 [java] view plaincopy javac YourClassName.java 此时,你的java代码就被编译成字节码(.class).如果你是在Eclipse IDE或者其他开发工具中,你保存代码

Java虚拟机详解——JVM常见问题总结

[正文] 声明:本文只是做一个总结,有关jvm的详细知识可以参考之前的系列文章,尤其是那篇:Java虚拟机详解04--GC算法和种类.那篇文章和本文是面试时的重点. 面试必问关键词:JVM垃圾回收.类加载机制. 先把本文的目录画一个思维导图:(图的源文件在本文末尾) 一.Java引用的四种状态: 强引用:  用的最广.我们平时写代码时,new一个Object存放在堆内存,然后用一个引用指向它,这就是强引用. * 如果一个对象具有强引用,那垃圾回收器绝不会回收它*.当内存空间不足,Java虚拟机宁

Android严苛模式StrictMode使用详解

StrictMode类是Android 2.3 (API 9)引入的一个工具类,可以用来帮助开发者发现代码中的一些不规范的问题,以达到提升应用响应能力的目的.举个例子来说,如果开发者在UI线程中进行了网络操作或者文件系统的操作,而这些缓慢的操作会严重影响应用的响应能力,甚至出现ANR对话框.为了在开发中发现这些容易忽略的问题,我们使用StrictMode,系统检测出主线程违例的情况并做出相应的反应,最终帮助开发者优化和改善代码逻辑. 官网文档:http://developer.android.c

MTP in Android详解

MTP in Android详解 最近好长一段时间没有做笔记了,今天主要学习一下MTP相关的知识. MTP的全称是Media Transfer Protocol(媒体传输协议),它是微软公司提出的一套媒体文件传输协议.Android从3.0开始支持MTP. 一  背景知识介绍 笔者相信<程序员>杂志的绝大多数读者或多或少都使用过MTP.因为早在智能手机普及前,数码相机和MP3播放器等都使用了MTP的前身PTP(Picture Transfer Protocol)进行媒体文件传输.那时,只要通过