【转】深入解析JNA—模拟C语言结构体

转载自http://blog.csdn.net/shendl/article/details/3599849

深入解析JNA—模拟C语言结构体

 

 

 

前言

前几天写《JNA--JNI终结者》一文介绍JNA框架。写完之后才发现，忘了写比较有难度的C语言Struct的模拟了。

今天就补上这篇文章，介绍Struct。

不写怎样模拟C语言结构体，就不能算是真正解决了调用动态链接库的问题。

C语言的结构体用得实在是太广泛了。

 

 

首先说明一点，本文中大量把模拟Struct的类写作为接口的内部类。

这不是JNA规定的，而是一个编程习惯。

因为这些结构体（Structure类的子类），一般没有重用的价值，因此写成内部类比较方便。自然，你也可以把结构体写成一般的类。

 

 

 

 

例3   使用JNA调用使用Struct的C函数

C语言开发

继续使用例2中的那个VSC++的dll项目。

增加一个结构和使用该结构的函数。

头文件增加如下：

 

#define MYLIBAPI  extern   "C"     __declspec( dllexport ) 

struct UserStruct{

   long id;

   wchar_t*  name;

   int age;

 

};

 

MYLIBAPI void sayUser(UserStruct* pUserStruct);

 

JNA程序

对应的Java程序中，在例2的  接口

 

/*

        * 定义一个类，模拟C语言的结构

        * */

       public static class UserStruct extends Structure{

          

          

 

           public NativeLong id;

           public WString name;

           public int age;

       }

      

       public void sayUser(UserStruct.ByReference struct);

 

 

Java中的调用代码：

UserStruct userStruct=new UserStruct ();

       userStruct.id=new NativeLong(100);

       userStruct.age=30;

       userStruct.name=new WString("沈东良");

       TestDll1.INSTANCE.sayUser(userStruct);

 

Struct说明

    现在，我们就在Java中实现了对C语言的结构的模拟。

这里，我们继承了Structure类，用这个类来模拟C语言的结构。

 

必须注意，Structure子类中的公共字段的顺序，必须与C语言中的结构的顺序一致。否则会报错！

 

因为，Java调用dll中的C函数，实际上就是一段内存作为函数的参数传递给dll。

Dll以为这个参数就是C语言传过来的参数。

同时，C语言的结构是一个严格的规范，它定义了内存的次序。因此，JNA中模拟的结构的变量顺序绝对不能错。

如，一个Struct有2个int变量。  Int a, int b 

如果JNA中的次序和C中的次序相反，那么不会报错，但是得到的结果是相反的！

 

 

 

例4   使用JNA调用使用嵌套Struct数组的C函数

如果C语言中的结构体是复杂的嵌套的结构体，该怎么办呢？

继续在上面例3的基础上扩充。

 

C语言开发

头文件增加如下：

struct CompanyStruct{

    long id;

   wchar_t*  name;

   UserStruct   users[100];

   int count;

 

};

 

MYLIBAPI void sayCompany(CompanyStruct* pCompanyStruct);

 

源文件：

   

void sayCompany(CompanyStruct* pCompanyStruct){

 

 std::wcout.imbue(std::locale("chs"));

 

   std::wcout<<L"ID:"<<pCompanyStruct->id<<std::endl;

   std::wcout<<L"公司名称："<<pCompanyStruct->name<<std::endl;

    std::wcout<<L"员工总数："<<pCompanyStruct->count<<std::endl;

      

     for(int i=0;i<pCompanyStruct->count;i++){

        sayUser(&pCompanyStruct->users[i]);

    

     }

  

 

 

}

 

JNA程序

Java程序中，在原来的接口上加上如下代码：

 

    public static class CompanyStruct extends Structure{

                     public NativeLong id;

           public WString  name;

                    

           public UserStruct.ByValue[] users=new UserStruct.ByValue[100];

           public int count;

          

          

       }

      

      public   void sayCompany(CompanyStruct pCompanyStruct);

 

对原来的UserStruct类进行改写：

/*

        * 定义一个类，模拟C语言的结构

        * */

       public static class UserStruct extends Structure{

          

            public static class ByReference extends UserStruct implements Structure.ByReference { }

            public static class ByValue extends UserStruct implements Structure.ByValue

 { }

 

           public NativeLong id;

           public WString name;

           public int age;

       }

 

调用JNA程序：

 

CompanyStruct companyStruct=new CompanyStruct();

       companyStruct.id=new NativeLong(1);

       companyStruct.name=new WString("Google");

       companyStruct.count=9;

   

       UserStruct.ByValue userStructValue=new UserStruct.ByValue();

       userStructValue.id=new NativeLong(100);

       userStructValue.age=30;

       userStructValue.name=new WString("沈东良");

       for(int i=0;i<companyStruct.count;i++){

           companyStruct.users[i]=userStructValue;

              }

       TestDll1.INSTANCE.sayCompany(companyStruct);

说明

可以看到，程序正确输出了。

    读者也许会有一些疑问。

 

 

1，为什么我们要给UserStruct 这个结构添加2个内部类呢？

看Structure类的API说明，我们知道，这个类内部有2个接口：

static interface	Structure.ByReference           Tagging interface to indicate the address of an instance of the Structure type is to be used within a Structure definition rather than nesting the full Structure contents.
static interface	Structure.ByValue           Tagging interface to indicate the value of an instance of the Structure type is to be used in function invocations rather than its address.

这2个内部接口是标记，内部什么都没有。

在运行时，JNA的执行框架会使用反射查看你是否实现了这2个接口，然后进行特定的处理。

（这种技术在java标注Annotation之前很流行。现在可以使用运行时Annotation实现同样的效果。

JNA项目据说1999年就启动了，使用这样的老技术不足为奇。只是很奇怪，为什么国内都没怎么听说过。我也是最近偶然在国外的网站上发现它的。一试之下，爱不释手，令我又对Java的桌面应用信心百倍！

）

 

 

如果你的Struct实现Structure.ByReference接口，那么JNA认为你的Struct是一个指针。指向C语言的结构体。

如果你的Struct实现Structure.ByValue接口，那么JNA认为你的Struct是值类型，就是C语言的结构体。

如果你不实现这2个接口，那么就相当于你实现了Structure.ByReference接口。

因此，在例3中，我没有实现这2个接口。

 

 

2，C语言中，结构体内部必须进行数组定义。Java中最好也这样做。

C语言的结构体是一段连续的内存，内存的大小是编译时确定的。

因此，数组必须定义。否则编译不会成功。

 

对应的Java类中，我们也应该在类定义时为数组定义。尽管实际上在使用时再赋值也可以。

但是，强烈不建议你这样做。

如，上面

public UserStruct.ByValue[] users=new UserStruct.ByValue[100];

定义100个元素的数组，如果你不再类内部定义。

而在使用时定义，如果你没有正确赋值，没有定义为100个元素，就会出错。

 

从表面上看，CompanyStruct类占用的内存是：

NativeLong  id

WString  name;

                    

           public UserStruct.ByValue[] users=new UserStruct.ByValue[100];

           public int count;

这4个元素占用的内存的总和。

 

由于Java的数组是一个对象，users中实际保存的也应该是一个引用，也就是指针，32bit。

 

那么CompanyStruct类占用的内存就比对应的C结构体：

struct CompanyStruct{

    long id;

   wchar_t*  name;

   UserStruct   users[100];

   int count;

};

 

小很多。内存少用很多。

我在例3的说明中曾经说过：

“

Java调用dll中的C函数，实际上就是一段内存作为函数的参数传递给dll。

Dll以为这个参数就是C语言传过来的参数。

”

那么，JNA怎么还能正确调用C函数呢。

 

事实上，在调用C函数时，JNA会把UserStruct类的实例的所有数据全部*100倍。（我的例子里数组是100个，你的例子当然可以有不一样的数值）

这样，Java中的结构体的内存量就和C语言的CompanyStruct结构体占据相同大小和结构的内存，从而正确调用C函数。

 

例5   使用JNA调用使用嵌套Struct的指针的数组的C函数

现在给大家看看最复杂的Struct的例子。

Struct中嵌套的是一个结构体的指针的数组。

 

C语言代码

struct CompanyStruct2{

    long id;

   wchar_t*  name;

  UserStruct*  users[100];

  // UserStruct   users[100];

   int count;

 

};

MYLIBAPI void sayCompany2(CompanyStruct2* pCompanyStruct);

 

这里，把刚才使用的UserStruct数组换成UserStruct指针的数组。

 

 

JNA代码

   

  public static class CompanyStruct2 extends Structure{

         public static class ByReference extends CompanyStruct2 implements Structure.ByReference { }

           public NativeLong id;

           public WString  name;

      

           public UserStruct.ByReference[] users=new UserStruct.ByReference[100];

           public int count;

          

          

       }

      public void sayCompany2(CompanyStruct2.ByReference  pCompanyStruct);

 

   

测试代码：

 

CompanyStruct2.ByReference companyStruct2=new CompanyStruct2.ByReference();

       companyStruct2.id=new NativeLong(2);

       companyStruct2.name=new WString("Yahoo");

       companyStruct2.count=10;

      

       UserStruct.ByReference pUserStruct=new UserStruct.ByReference();

       pUserStruct.id=new NativeLong(90);

       pUserStruct.age=99;

       pUserStruct.name=new WString("良少");

        pUserStruct.write();

    //  TestDll1.INSTANCE.sayUser(pUserStruct);

       for(int i=0;i<companyStruct2.count;i++){

           companyStruct2.users[i]=pUserStruct;

              }

      

       TestDll1.INSTANCE.sayCompany2(companyStruct2);

 

 

程序说明----Pin锁住Java对象：

因为是结构体的指针的数组，所以，我们使用了

public UserStruct.ByReference[] users=new UserStruct.ByReference[100];

来对应C语言中的

UserStruct*  users[100];

 

但是，有问题，如果去除

pUserStruct.write();

这一行代码，就会报错。

如果去除pUserStruct.write();

但是使用    TestDll1.INSTANCE.sayUser(pUserStruct);

也不会有问题。

 

这是怎么回事？

 

    原来，错误的原因就是内存锁定！

 

java内存锁定机制和JNI，JNA调用

我们知道，java的内存是GC管理的。它会自动管理JVM使用的堆内存。删除不再使用的内存，并把Java对象使用的内存自动移动，以防止内存碎片增多。

因此，虽然Java的引用实际上就是指针，但还是和指针不同。Java中不能直接使用指针。因为对象在内存中的地址都不是固定的。说不准什么时候GC就把它给移位了。

 

如果使用JNI，JNA等技术调用C函数。那么就会有问题。因此，C语言使用的是指针。如果想要获取C函数的返回值。那么我们必须提供一块内存给C语言访问。而C语言是不知道你Java的引用的。它只能访问固定的内存地址。

如果GC把Java对象移来移去，那么C函数就没办法和Java交互了。

 

因此，在使用JNI和JNA时，都会把Java对象锁住。GC不再管理。不删除，也不移动位置。由此出现的内存碎片，也不管了！

这种技术的术语是PIN。  .NET也有同样的概念。

 

 

上面TestDll1.INSTANCE.sayUser(pUserStruct);这个调用是JNA调用。这个操作就把pUserStruct这个Java对象锁住了。

 

例4中，嵌套的是结构体，因此也会直接把CompanyStruct类的实例锁住。

 

但是例5中，嵌套的是结构体的指针的数组。  CompanyStruct2类的实例companyStruct2在执行

TestDll1.INSTANCE.sayCompany2(companyStruct2);

时是被锁住了，可以companyStruct2 的users 指针数组 的成员：

pUserStruct  都没有被锁住。

 

怎么办呢？ 

难道每一个UserStruct.ByReference 的实例都先调用一遍不需要的

TestDll1.INSTANCE.sayUser(pUserStruct);  方法？

 

没事！JNA开发人员早已想到了：

Structure  类中有方法：

write

public void write()

Writes the fields of the struct to native memory

---

writeField

public void writeField(String name)

Write the given field to native memory. The current value in the Java field will be translated into native memory.

Throws:

IllegalArgumentException - if no field exists with the given name

 

    这些write方法，会把Java的内存Pin住。   就是C语言可以使用。GC不再管理它们。

 

现在只要调用

pUserStruct.write();

把java模拟结构体实例给Pin住就可以了。

 

 

题外话，C#定义了语法，可以使用关键字 pin 锁住.NET对象。

 

 

 

结论：

结构体是C语言模拟OOP开发中经常使用的一种数据组织形式。搞定了结构体Struct，我们就可以放心大胆、轻轻松松地把C程序随便拿来用了！