关于java:java高级用法之JNA类型映射应该注意的问题

49次阅读

共计 4261 个字符，预计需要花费 11 分钟才能阅读完成。

JNA 提供 JAVA 类型和 native 类型的映射关系，然而这一种映射关系只是一个大略的映射，咱们在理论的利用中还有很多须要留神的事项，本文将会为大家具体解说在应用类型映射中可能会呈现的问题。一起来看看吧。

首先是 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 directly
const char* getString();
// Example B: Returns a wide character C string directly
const wchar_t* getString();

个别状况下，如果是 native 办法间接返回 string, 咱们能够应用 String 进行映射：

// Mapping A
String getString();
// Mapping B
WString getString();

如果 native code 为 String 调配了内存空间，那么咱们最好应用 JNA 中的 Pointer 作为返回值，这样咱们能够在将来某些时候，开释所占用的空间, 如下所示：

Pointer getString();

什么时候须要用到 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