4

java高级用法之:JNA类型映射应该注意的问题_Java_程序那些事_InfoQ写作平台

 2 years ago
source link: https://xie.infoq.cn/article/8bffe248b8f933dcff528143d
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
neoserver,ios ssh client

JNA 提供 JAVA 类型和 native 类型的映射关系，但是这一种映射关系只是一个大概的映射，我们在实际的应用中还有很多需要注意的事项，本文将会为大家详细讲解在使用类型映射中可能会出现的问题。一起来看看吧。

String

首先是 String 的映射，JAVA 中的 String 实际上对应的是两种 native 类型：const char* 和 const wchar_t*。默认情况下 String 会被转换成为 char* 。

char 是 ANSI 类型的数据类型，而 wchar_t 是 Unicode 字符的数据类型,也叫做宽字符。

如果 JAVA 的 unicode characters 要转换成为 char 数组，那么需要进行一些编码操作，如果设置了 jna.encoding，那么就会使用设置好的编码方式来进行编码。默认情况下编码方式是 "UTF8".

如果是 WString,那么 Unicode values 可以直接拷贝到 WString 中，而不需要进行任何编码。

先看一个简单的例子:

 char* returnStringArgument(char *arg) {  return arg;}wchar_t* returnWStringArgument(wchar_t *arg) {  return arg;}

上面的 native 代码可以映射为：

String returnStringArgument(String s);WString returnWStringArgument(WString s);

再来看一个不同的例子，假如 native 方法的定义是这样的：

int getString(char* buffer, int bufsize);int getUnicodeString(wchar_t* buffer, int bufsize);

我们定义了两个方法，方法的参数分别是 char* 和 wchar_t*。

接下来看一下怎么在 JAVA 中定义方法的映射：

// Mapping A:int getString(byte[] buf, int bufsize);// Mapping B:int getUnicodeString(char[] buf, int bufsize);

下面是具体的使用：

byte[] buf = new byte[256];int len = getString(buf, buf.length);String normalCString = Native.toString(buf);String embeddedNULs = new String(buf, 0, len);

可能有同学会问了，既然 JAVA 中的 String 可以转换成为 char*，为什么这里需要使用 byte 数组呢？

这是因为 getString 方法需要对传入的 char 数组中的内容进行修改，但是因为 String 是不可变的，所以这里是不能直接使用 String 的，我们需要使用 byte 数组。

接着我们使用 Native.toString(byte[]) 将 byte 数组转换成为 JAVA 字符串。

再看一个返回值的情况：

// Example A: Returns a C string directlyconst char* getString();// Example B: Returns a wide character C string directlyconst wchar_t* getString();

一般情况下，如果是 native 方法直接返回 string,我们可以使用 String 进行映射：

// Mapping AString getString();// Mapping BWString getString();

如果 native code 为 String 分配了内存空间，那么我们最好使用 JNA 中的 Pointer 作为返回值，这样我们可以在未来某些时候，释放所占用的空间,如下所示：

Pointer getString();

Buffers，Memory,数组和 Pointer

什么时候需要用到 Buffers 和 Memory 呢?

一般情况下如果是基础数据的数组作为参数传到函数中的话，可以在 JAVA 中直接使用基础类的数组来替代。但是如果 native 方法在方法返回之后，还需要访问数组的话（保存了指向数组的指针），这种情况下使用基础类的数组就不太合适了，这种情况下，我们需要用到 ByteBuffers 或者 Memory。

我们知道 JAVA 中的数组是带有长度的，但是对于 native 方法来说，返回的数组实际上是一个指向数组的指针，我们并不能知道返回数组的长度，所以如果 native 方法返回的是数组指针的话，JAVA 代码中用数组来进行映射就是不合适的。这种情况下，需要用到 Pointer.

Pointer 表示的是一个指针，先看一下 Pointer 的例子，首先是 native 代码：

void* returnPointerArgument(void *arg) {  return arg;}void* returnPointerArrayElement(void* args[], int which) {  return args[which];}

接下来是 JAVA 的映射：

Pointer returnPointerArgument(Pointer p);Pointer returnPointerArrayElement(Pointer[] args, int which);

除了基本的 Pointer 之外，你还可以自定义带类型的 Pointer，也就是 PointerType. 只需要继承 PointerType 即可，如下所示：

public static class TestPointerType extends PointerType {            public TestPointerType() { }            public TestPointerType(Pointer p) { super(p); }        }TestPointerType returnPointerArrayElement(TestPointerType[] args, int which);

再看一下字符串数组：

char* returnStringArrayElement(char* args[], int which) {  return args[which];}wchar_t* returnWideStringArrayElement(wchar_t* args[], int which) {  return args[which];}

对应的 JAVA 映射如下：

String returnStringArrayElement(String[] args, int which);WString returnWideStringArrayElement(WString[] args, int which);

对应 Buffer 来说，JAVA NIO 中提供了很多类型的 buffer，比如 ByteBuffer,ShortBuffer,IntBuffer,LongBuffer,FloatBuffer 和 DoubleBuffer 等。这里以 ByteBuffer 为例，来看一下具体的使用.

首先看下 native 代码：

int32_t fillInt8Buffer(int8_t *buf, int len, char value) {  int i;  for (i=0;i < len;i++) {    buf[i] = value;  }  return len;}

这里将 buff 进行填充，很明显后续还需要使用到这个 buffer，所以这里使用数组是不合适的，我们可以选择使用 ByteBuffer：

int fillInt8Buffer(ByteBuffer buf, int len, byte value);

然后看下具体怎么使用：

TestLibrary lib = Native.load("testlib", TestLibrary.class);        ByteBuffer buf  = ByteBuffer.allocate(1024).order(ByteOrder.nativeOrder());        final byte MAGIC = (byte)0xED;        lib.fillInt8Buffer(buf, 1024, MAGIC);        for (int i=0;i < buf.capacity();i++) {            assertEquals("Bad value at index " + i, MAGIC, buf.get(i));        }

对于 native 和 JAVA 本身来说，都是支持可变参数的，我们举个例子，在 native 方法中：

int32_t addVarArgs(const char *fmt, ...) {  va_list ap;  int32_t sum = 0;  va_start(ap, fmt);  while (*fmt) {    switch (*fmt++) {    case 'd':      sum += va_arg(ap, int32_t);      break;    case 'l':      sum += (int) va_arg(ap, int64_t);      break;    case 's': // short (promoted to 'int' when passed through '...')     case 'c': // byte/char (promoted to 'int' when passed through '...')      sum += (int) va_arg(ap, int);      break;    case 'f': // float (promoted to ‘double’ when passed through ‘...’)    case 'g': // double      sum += (int) va_arg(ap, double);      break;    default:      break;    }  }  va_end(ap);  return sum;}

对应的 JAVA 方法映射如下：

public int addVarArgs(String fmt, Number... args);

相应的调用代码如下：

int arg1 = 1;int arg2 = 2;assertEquals("32-bit integer varargs not added correctly", arg1 + arg2,                     lib.addVarArgs("dd", arg1, arg2));

本文介绍了在使用 JNA 方法映射中应该注意的一些细节和具体的使用问题。

本文的代码：https://github.com/ddean2009/learn-java-base-9-to-20.git

本文已收录于 http://www.flydean.com/05-jna-type-mapping-details-md/

最通俗的解读，最深刻的干货，最简洁的教程，众多你不知道的小技巧等你来发现！

欢迎关注我的公众号:「程序那些事」,懂技术，更懂你！


report

Recommend

About Joyk


Aggregate valuable and interesting links.
Joyk means Joy of geeK