세부 사항 및 사용법에 주의를 기울이는 Java의 JNA 유형

String

첫 번째는 문자열 매핑입니다. JAVA의 문자열은 실제로 두 가지 기본 유형인 const char* 및 const wchar_t*에 해당합니다. 기본적으로 String은 char*로 변환됩니다.

char는 ANSI 데이터 유형이고 wchar_t는 와이드 문자라고도 하는 유니코드 문자 데이터 유형입니다.

JAVA의 유니코드 문자를 char 배열로 변환하려면 일부 인코딩 작업을 수행해야 합니다. jna.encoding이 설정된 경우 설정된 인코딩 방법이 인코딩에 사용됩니다. 기본적으로 인코딩 방법은 "UTF8"입니다.

WString이라면 인코딩 없이 유니코드 값을 WString에 직접 복사할 수 있습니다.

먼저 간단한 예를 살펴보겠습니다.

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

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

위의 네이티브 코드는 다음과 같이 매핑될 수 있습니다.

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

다른 예를 다시 살펴보겠습니다. 네이티브 메서드의 정의가 다음과 같다면:

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의 문자열을 char*로 변환할 수 있는데 왜 필요한지 묻습니다. 여기서 바이트를 사용하려면 배열은 어떻습니까?

getString 메소드는 들어오는 char 배열의 내용을 수정해야 하지만 String은 불변이기 때문에 여기서는 String을 직접 사용할 수 없기 때문입니다.

그런 다음 Native.toString(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();

일반적으로 네이티브 메서드가 문자열을 직접 반환하는 경우 매핑에 문자열을 사용할 수 있습니다.

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

네이티브 코드가 문자열에 메모리 공간을 할당하는 경우 포인터를 사용하는 것이 좋습니다. JNA는 반환 값으로 사용되므로 아래와 같이 향후 어느 시점에 점유된 공간을 해제할 수 있습니다.

Pointer getString();

Buffers, Memory, Arrays and Pointer

언제 버퍼와 메모리를 사용해야 합니까?

일반적으로 기본 데이터의 배열이 함수에 매개변수로 전달되면 대신 JAVA의 기본 클래스 배열을 직접 사용할 수 있습니다. 그러나 메서드가 반환된 후에도 네이티브 메서드가 배열에 액세스해야 하는 경우(배열에 대한 포인터 저장) 이 경우 기본 클래스의 배열을 사용하는 것은 적절하지 않습니다. 메모리 .

JAVA의 배열에는 길이가 있다는 것을 알고 있지만 네이티브 메서드의 경우 반환된 배열은 실제로 배열에 대한 포인터입니다. 반환된 배열의 길이를 모르므로 네이티브 메서드가 배열을 반환하는 경우 포인터의 경우 JAVA 코드에서 매핑을 위해 배열을 사용하는 것은 부적절합니다. 이 경우 포인터를 사용해야 합니다.

포인터의 예를 먼저 살펴보겠습니다. 첫 번째는 네이티브 코드입니다.

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를 사용하면 형식화된 포인터, 즉 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);

버퍼에 해당 일반적으로 JAVA NIO는 ByteBuffer, ShortBuffer, IntBuffer, LongBuffer, FloatBuffer 및 DoubleBuffer 등과 같은 다양한 유형의 버퍼를 제공합니다. 여기서는 구체적인 사용법을 보기 위해 ByteBuffer를 예로 듭니다.

먼저 네이티브 코드를 살펴보세요.

int32_t fillInt8Buffer(int8_t *buf, int len, char value) {
  int i;

  for (i=0;i < len;i++) {
    buf[i] = value;
  }
  return len;
}

여기에 버퍼가 채워져 있습니다. 이 버퍼는 나중에 사용될 것이 분명하므로 배열을 사용하는 것은 부적절합니다. 여기에서 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));
        }

가변 매개변수

네이티브와 JAVA 자체의 경우 둘 다 네이티브 메서드에서 예를 들어 보겠습니다. :

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));

위 내용은 세부 사항 및 사용법에 주의를 기울이는 Java의 JNA 유형의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!