用Delphi开发JNI应用

JNI(Java Native Interface，Java本地接口)技术大家都不陌生，它可以帮助解决Java访问底层硬件的局限和执行效率的提高。关于JNI的开发，大多数资料讨论的都是如何用C/C++语言开发JNI，甚至于JDK也提供了一个javah工具来自动生成C语言程序框架。但是，对于广大的Delphi程序员来说，难道就不能用自己喜爱的Delphi与Java互通消息了吗？

通过对javah生成的C程序框架和JDK中的jni.h文件的分析，我们发现，Java利用JNI访问本地代码的关键在于jni.h中定义的JNINativeInterface_这个结构(Struct)，如果用Delhpi语言改写它的定义，应该也可以开发JNI的本地代码。幸运的是，在网上有现成的代码可以帮助你完成这个繁杂的工作，在http://delphi-jedi.org上提供了一个jni.pas文件(已添加到附件)，就是用Delphi语言重写的jni.h。我们只需在自己的Delphi工程中加入jni.pas就可以方便地开发出基于Delphi语言的JNI本地代码。

本文将利用jni.pas，讨论用Delphi语言开发JNI本地代码的基本方法。

先来看一个经典的HelloWorld例子。编写以下Java代码：

1. class HelloWorld
2. {
3. 　　public native void displayHelloWorld();
4. 　　static
5. 　　{
6. 　　　 System.loadLibrary("HelloWorldImpl");
7. 　　}
8. }

 

这段代码声明了一个本地方法displayHelloWorld，它没有参数，也没有返回值，但是希望它能在屏幕上打印出“您好！中国。”字样。这个任务我们打算交给了本地的Delphi来实现。同时，在这个类的静态域中，用System.loadLibrary()方法装载HelloWorldImpl.dll。注意，这里只需要给出文件名而不需要给出扩展名dll。

这时候，如果在我们的Java程序中使用HelloWorld类的displayHelloWorld方法，系统将抛出一个java.lang.UnsatisfiedLinkError的错误，因为我们还没有为它实现本地代码。

下面再看一下在Delphi中的本地代码的实现。新建一个DLL工程，工程名为HelloWorldImpl，输入以下代码：

1. Uses
2. JNI;
3. procedure Java_HelloWorld_displayHelloWorld(PEnv: PJNIEnv; Obj: JObject);stdcall; 
4. begin
5. Writeln('您好！中国。');
6. end;
7. exports
8. Java_HelloWorld_DisplayHelloWorld;
9. end.

 

这段代码首先导入jni.pas单元。然后实现了一个叫Java_HelloWorld_displayHelloWorld的过程，这个过程的命名很有讲究，它以Java开头，用下划线将Java类的包名、类名和方法名连起来。这个命名方法不能有误，否则，Java类将无法将nativ方法与它对应起来。同时，在Win32平台上，此过程的调用方式只能声明为stdcall。虽然在HelloWorld类中声明的本地方法没有参数，但在Delphi中实现的具体过程则带有两个参数：PEnv : PJNIEnv和Obj : JObject。（这两种类型都是在jni.pas中定义的）。其中，PEnv参数代表了Jvm环境，而Obj参数则代表调用此过程的Java对象。当然，这两个参数，在我们这个简单的例子中是不会用到的。因为我们编译的是dll文件，所以在exports需要输出这个方法。

编译Delphi工程，生成HelloWorldImp.dll文件，放在运行时系统能够找到的目录，一般是当前目录下，并编写调用HelloWorld类的Java类如下：

1. class MainTest
2. {
3. 　 public static void main(String[] args)
4. 　 {
5. 　　 new HelloWorld().displayHelloWorld();
6. 　 }
7. }

 

运行它，如果控制台输出了“您好！中国。”，恭喜你，你已经成功地用Delphi开发出第一个JNI应用了。

接下来，我们稍稍提高一点，来研究一下参数的传递。还是HelloWorld，修改刚才写的displayHelloWorld方法，让显示的字符串由Java类动态确定。新的displayHelloWorld方法的Java代码如下：

1. public native void displayHelloWorld(String str); 

修改Delphi的代码，这回用到了过程的第一个固有参数PEnv，如下：

1. procedure Java_HelloWorld_displayHelloWorld(PEnv: PJNIEnv; Obj: JObject; str: JString); stdcall; 
2. var
3. JVM: TJNIEnv;
4. begin
5. JVM := TJNIEnv.Create(PEnv);
6. Writeln(JVM.UnicodeJStringToString(str));
7. JVM.Free;
8. end;

 

在该过程的参数表中我们增加了一个参数 str : JString，这个str就负责接收来自HelloWorld传入的str实参。注意实现代码的不同，因为使用了参数，就涉及到参数的数据类型之间的转换。从Java程序传过来的Java的String对象现在成了特殊的JString类型，而JString在Delphi中是不可以直接使用的。需要借助TJNIEnv提供的UnicodeJStringToString()方法来转换成Delphi能识别的string类型。所以，需要构造出TJNIEnv的实例对象，使用它的方法（TJNIEnv提供了众多的方法，这里只使用了它最基本最常用的一个方法），最后，记得要释放它。对于基本数据类型的参数，从Java传到Delphi中并在Delphi中使用的步骤就是这么简单。

我们再提高一点点难度，构建一个自定义类Book，并把它的实例对象作为参数传入Delphi，研究一下在本地代码中如何访问对象参数的公共字段。

首先，定义一个简单的Java类Book，为了把问题弄得稍微复杂一点，我们在Book中增加了一个java.util.Date类型的字段，代码如下：

1. public class Book
2. {
3. public String title; //标题
4. public double price; //价格
5. public Date pdate; //购买日期
6. }
7.  

同样，在HelloWorld类中增加一个本地方法displayBookInfo，代码如下：

1. public native void displayBookInfo(Book b); 
2. Delphi的代码相对于上面几个例子来说，显得复杂了一点，先看一下代码：
3. procedure Java_HelloWorld_displayBookInfo(PEnv: PJNIEnv; Obj: JObject; b:JObject); stdcall;
4. var
5. JVM: TJNIEnv;
6. c,c2: JClass;
7. fid:JFieldID;
8. mid:JMethodID;
9. title,datestr:string;
10. price:double;
11. pdate:JObject;
12. begin
13. JVM := TJNIEnv.Create(PEnv);
14. c:=JVM.GetObjectClass(b);
15. fid:=JVM.GetFieldID(c,'title','LjavalangString;');
16. title:=JVM.UnicodeJStringToString(JVM.GetObjectField(b,fid));
17. fid:=JVM.GetFieldID(c,'price','D');
18. price:=JVM.GetDoubleField(b,fid);
19. fid:=JVM.GetFieldID(c,'pdate','LjavautilDate;');
20. pdate:=JVM.GetObjectField(b,fid);
21. c2:=JVM.GetObjectClass(pdate);
22. mid:=JVM.GetMethodID(c2,'toString','()LjavalangString;');
23. datestr:=JVM.JStringToString(JVM.CallObjectMethodA(pdate,mid,nil));
24. WriteLn(Format('%s %f %s',[title,price,datestr]));
25. JVM.Free;
26. end;

 

参数b:JObject就是传入的Book对象。先调用GetObjectClass方法，根据b对象获得它所属的类c，然后调用GetFieldID方法从?中获取一个叫做title的属性的字段ID，一定要传入正确的类型签名。然后通过GetObjectField方法就可以根据得到的字段ID从对象中得到字段的值。注意这里的次序：我们得到传入的对象参数(Object)，就要先得到它的类(Class)，这样既有了对象实例，又有了类，以后就从类中得到字段ID，根据字段ID从对象中得到字段值。对于类的静态字段，则可以直接从类中获取它的值而不需要通过对象。如果要调用对象的方法，操作步骤也基本类似，也需要从类中获取方法ID，再执行对象的相应方法。在本例中，因为我们增加了一个java.util.Date类型的字段，要访问这样的字段，也只能先把它做为JObject读入，再以同样的方法进一步去访问它的成员（属性或方法）。本例中演示了如何访问Date对象的成员方法toString。

要正确地访问类对象的成员属性（字段）及成员方法，最重要的一点是一定要给出正确的签名，在Java中对于数据类型和方法的签名有如下的约定：




通过上面的例子，我们了解了访问对象参数的成员属性或方法的基本步骤和多个Get方法的使用。TJNIEnv同时提供了多个Set方法，可以修改传入的对象参数的字段值，因为Java对象参数都是以传址的方式进行传递的，所以修改的结果可以在Java程序中得到反映。TJNIEnv提供的Get/Set方法，都需要两个基本参数：对象实例（JObject类型）和字段ID（JField类型），就可以根据提供的对象和字段ID来获取或设置这个对象的这个字段的值。

现在我们了解了在Delphi代码中使用以及修改Java对象的操作步骤。进一步，如果需要在Delphi中从无到有地创建一个新的Java对象，可以吗？再来看一个例子，在Delphi中创建Java类的实例，操作方法其实也非常简单。

先在Java代码中增加一个本地方法，如下：

1. public native Book findBook(String t); 

然后，修改Delphi代码，增加一个函数（因为有返回值，所以不再是过程而是函数了）：

1. function Java_HelloWorld_findBook(PEnv: PJNIEnv; Obj: JObject; t:JString):JObject; stdcall;
2. var
3. JVM: TJNIEnv;
4. c: JClass;
5. fid:JFieldID;
6. b:JObject;
7. mid:JMethodID;
8. begin
9. JVM := TJNIEnv.Create(PEnv);
10. c:=JVM.FindClass('Book');
11. mid:=JVM.GetMethodID(c,'<init>','()V');
12. b:=JVM.NewObjectV(c,mid,nil);
13. fid:=JVM.GetFieldID(c,'title','LjavalangString;');
14. JVM.SetObjectField(b,fid,t);
15. fid:=JVM.GetFieldID(c,'price','D');
16. JVM.SetDoubleField(b,fid,99.8);
17. Result:=b;
18. JVM.Free;
19. end;

 

这里先用FindClass方法根据类名查找到类，然后获取构造函数的方法ID，构造函数名称固定为“<init>”，注意签名为“()V”说明使用了Book类的一个空的构造函数。然后就是使用方法NewObjectV根据类和构造函数的方法ID来创建类的实例。创建了类实例，再对它进行操作就与前面的例子没有什么两样了。对于非空的构造函数，则略为复杂一点。需要设置它的参数表。还是上面的例子，在Book类中增加一个非空构造函数：

1. public Book(Strint t,double p){
2. this.title=t;
3. this.price=p;
4. }

在Delphi代码中，findBook函数修改获取方法ID的代码如下：

1. mid:=JVM.GetMethodID(c,'<init>','(LjavalangString;D)V'); 

构造函数名称仍是“<init>”，方法签名表示它有两个参数，分别是String和double。然后就是参数的传入了，在Delphi调用Java对象的方法如果需要传入参数，都需要构造出一个参数数组。在变量声明中加上：

1. args : array[0..1] of JValue; 

注意！参数都是JValue类型，不管它是基本数据类型还是对象，都作为JValue的数组来处理。在代码实现中为参数设置值，并将数组的地址作为参数传给NewObjectA方法：

1. args[0].l:=t; // t是传入的JString参数
2. args[1].d:=9.8;
3. b:=JVM.NewObjectA(c,mid,@args);

为JValue类型的数据设置值的语句有点特殊，是吧？我们打开jni.pas，查看一下JValue的定义，原来它是一个packed record，已经包括了多种数据类型，JValue的定义如下：

1. JValue = packed record
2. case Integer of
3. 0: (z: JBoolean);
4. 1: (b: JByte );
5. 2: (c: JChar );
6. 3: (s: JShort );
7. 4: (i: JInt );
8. 5: (j: JLong );
9. 6: (f: JFloat );
10. 7: (d: JDouble );
11. 8: (l: JObject );
12. end;

下面再来看一下错误处理，在调试前面的例子中，大家也许看到了一旦在Delphi的执行过程中发生了错误，控制台就会输出一大堆错误信息，如果想要屏蔽这些信息，也就是说希望在Delphi中捕获错误并直接处理它，应该怎么做？也很简单，在TJNIEnv中提供了两个方法可以方便地处理在访问Java对象时发生的错误。

1. var
2. … …
3. ae:JThrowable;
4. begin
5. … …
6. ae:=JVM.ExceptionOccurred;
7. if ( ae<>nil ) then
8. begin
9. Writeln(Format('Exception handled in Main.cpp: %d', [longword(ae)]));
10. JVM.ExceptionDescribe;
11. JVM.ExceptionClear;
12. end;
13. … …

 

用方法ExceptionOccurred可以捕获Java抛出的错误，并存入JThrowable类型的变量中。用ExceptionDescribe可以显示出Java的错误信息，而ExceptionClear显然就是清除错误，让它不再被抛出。

至此，我们已经把从Java代码通过JNI技术访问Delphi本地代码的步骤做了初步的探讨。在jni.pas中也提供了从Delphi中打开Java虚拟机执行Java代码的方法，有兴趣的读者不妨自己研究一下。