java调用动态库dll/so（二）jna结构体Structure介绍和使用

我不是女神ヾ 2022-01-29 08:11 1652阅读 0赞

目录

前言

JNA数据类型与java数据类型映射关系

JNA指针介绍

怎样构建java结构体

更简单的构造结构体

  • 前言

C/C++里有结构体struct,甚至C#中也具有，然而java中却不具有结构体，当调用动态库.so和.dll时，函数接口上很多数据都是结构体，这该怎么办呢，放心jna为我们提供了Structure这个类，只要继承该类，就可实现java结构体。我们从以下几点来进行介绍。

  • JNA数据类型与java数据类型映射关系

在jna中数据类型的对应关系使用的是TypeMapper这个接口来定义jna自定义数据类型与java类型的转换。官方jna数据类型与java数据类型映射关系如下：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ZhbnBlaV9tb3Vrb3k_size_16_color_FFFFFF_t_70

  • JNA指针介绍

以下为Structure的部分源码，其中包含两个接口，ByValue和ByReference。

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0ZhbnBlaV9tb3Vrb3k_size_16_color_FFFFFF_t_70 1

ByReference具有很多实现，例如：

  1. ByteByReference
  2. DoubleByReference
  3. FloatByReference
  4. IntByReference
  5. LongByReference
  6. NativeLongByReference
  7. PointerByReference
  8. ShortByReference
  9. W32API.HANDLEByReference
  10. X11.AtomByReference
  11. X11.WindowByReference

ByValue : 结构体自身实例对象

ByReference ：指针
PointerByReference ：指向指针的指针

在JNA中模拟指针，最常用到的就是Pointer类和PointerByReference类。Pointer类代表指向任何东西的指针，PointerByReference类表示指向指针的指针。Pointer类更加通用，事实上PointerByReference类内部也持有Pointer类的实例。

  • 怎样构建java结构体

  1. 继承Structure，并在结构体上使用FieldOrder注解；
  2. 继承Structure，重载getFieldOrder函数。

第一种为官方使用方法，第二个方法为我自定义，二者比较，第一种使用复杂，需要在类上使用注解并设置value；第二种方法则简单，接下来我们详细描述这两种方法。

  1. package maoko.dllSolibLoad;
  3. import com.sun.jna.Structure;
  4. import com.sun.jna.Structure.FieldOrder;
  6. @FieldOrder("a,b")
  7. public class TestStructure_WithFieldOrder extends Structure {
  8.     public int a;
  9.     public int b;
  10. }

FieldOrder里的顺序为自己定义结构体顺序。

以下为第二种，重载：

  1. package maoko.dllSolibLoad;
  3. import java.util.Arrays;
  4. import java.util.List;
  6. import com.sun.jna.Structure;
  8. public class TestStructure_WithOverride extends Structure {
  10.     public int a;
  11.     public int b;
  13.     @Override
  14.     protected List<String> getFieldOrder() {
  15.         return Arrays.asList("a", "b");
  16.     }
  17. }

  • 更简单的构造结构体

由第二种方式进行衍生，使用java反射技术将此方式变的更加的简单，具体方式为：使用一个自定义基本类即可，子类只需要定义自己的属性字段，基类定义如下：

  1. package maoko.dllSolibLoad.lib.model.struct;
  3. import java.lang.reflect.Field;
  4. import java.util.LinkedList;
  5. import java.util.List;
  7. import com.sun.jna.Pointer;
  8. import com.sun.jna.Structure;
  10. /**
  11.  * java struct base
  12.  * 
  13.  * @author fanpei
  14.  *
  15.  */
  16. public abstract class JavaStructBase extends Structure {
  18.     /**
  19.      * 默认构造函数
  20.      */
  21.     public JavaStructBase() {
  22.     }
  24.     /**
  25.      * 构造函数
  26.      * 
  27.      * @param _pointer
  28.      */
  29.     public JavaStructBase(Pointer _pointer) {
  30.         super(_pointer);
  31.     }
  33.     /**
  34.      * 结构体的引用
  35.      * 
  36.      * @author maoko
  37.      *
  38.      */
  39.     public static class ByReference extends JavaStructBase implements Structure.ByReference {
  40.     }
  42.     /**
  43.      * 结构体对象
  44.      * 
  45.      * @author fanpei
  46.      *
  47.      */
  48.     public static class ByValue extends JavaStructBase implements Structure.ByValue {
  49.     }
  51.     @Override
  52.     protected List<String> getFieldOrder() {
  53.         return getStructFields();
  54.     }
  56.     /**
  57.      * 自定义反射获取字段顺序
  58.      * 
  59.      * @return
  60.      */
  61.     private List<String> getStructFields() {
  62.         List<String> feilds = new LinkedList<>();
  63.         Field[] declearedFeilds = this.getClass().getDeclaredFields();
  64.         if (declearedFeilds != null && declearedFeilds.length > 0) {
  65.             for (Field f : declearedFeilds) {
  66.                 feilds.add(f.getName());
  67.             }
  68.         }
  69.         return feilds;
  70.     }
  72.     /**
  73.      * 打印字段-测试用
  74.      */
  75.     @Deprecated
  76.     public void printStructFeilds() {
  77.         List<String> feilds = getStructFields();
  78.         if (feilds == null || feilds.size() == 0)
  79.             System.out.println("feilds:none");
  80.         else {
  81.             StringBuilder feidlSb = new StringBuilder("feilds:");
  82.             for (String f : feilds) {
  83.                 feidlSb.append(f);
  84.                 feidlSb.append(",");
  85.             }
  86.             System.out.println(feidlSb.toString());
  87.         }
  88.     }
  90. }

继承类举例：

  1. package maoko.dllSolibLoad.lib.model.struct.meta;
  3. import com.sun.jna.NativeLong;
  5. import maoko.dllSolibLoad.lib.model.struct.JavaStructBase;
  7. /**
  8.  * 时间信息
  9.  * 
  10.  * @author fanpei
  11.  *
  12.  */
  13. public class StruFileTime extends JavaStructBase {
  14.     public NativeLong dwLowDateTime;// 开始时间
  15.     public NativeLong dwHighDateTime;// 结束时间
  16. }

从以上代码中可以看出JavaStructBase的getStructFields()方法实现了重载，利用反射获取子类申明的属性字段返回字段顺序list，子类则只需定义属性字段即可，且子类具有ByValue和ByReference两个静态类。

代码完整地址：https://download.csdn.net/download/fanpei_moukoy/11195072

  1.                      [https://github.com/maokofan/maoko.dllSoLibLoad][https_github.com_maokofan_maoko.dllSoLibLoad]

发表评论

表情：
评论列表 （有 0 条评论，1652人围观）

还没有评论，来说两句吧...

相关阅读