Le type JNA de Java mappe l'attention aux détails et à l'utilisation

String

Le premier est le mappage de String en JAVA correspond en fait à deux types natifs : const char* et const wchar_t*. Par défaut, String sera converti en char*.

char est un type de données ANSI et wchar_t est un type de données caractère Unicode, également appelé caractère large.

Si les caractères Unicode de JAVA doivent être convertis en tableaux de caractères, certaines opérations d'encodage doivent être effectuées si jna.encoding est défini, la méthode d'encodage définie sera utilisée pour l'encodage. Par défaut, la méthode d'encodage est "UTF8".

S'il s'agit de WString, alors les valeurs Unicode peuvent être copiées directement dans WString sans aucun encodage.

Regardons d'abord un exemple simple :

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

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

Le code natif ci-dessus peut être mappé à :

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

Regardons à nouveau un exemple différent Si la définition de la méthode native est comme ceci :

int getString(char* buffer, int bufsize);

int getUnicodeString(wchar_t* buffer, int bufsize);

Nous avons défini. deux méthodes, méthode Les paramètres sont respectivement char* et wchar_t*.

Voyons comment définir le mappage de méthode en JAVA :

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

Voici l'utilisation spécifique :

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

Certains étudiants peuvent se demander, puisque String en JAVA peut être converti en char*, pourquoi devons-nous utiliser octet ici ? Et les tableaux ?

C'est parce que la méthode getString doit modifier le contenu du tableau de caractères entrant, mais comme String est immuable, String ne peut pas être utilisé directement ici. Nous devons utiliser un tableau d'octets.

Ensuite, nous utilisons Native.toString(byte[]) pour convertir le tableau d'octets en une chaîne JAVA.

Regardons une autre valeur de retour :

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

Généralement, si la méthode native renvoie directement une chaîne, nous pouvons utiliser String pour le mappage :

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

Si le code natif alloue de l'espace mémoire pour String, alors nous ferions mieux d'utiliser Pointer dans JNA est utilisé comme valeur de retour, afin que nous puissions libérer l'espace occupé à un moment donné dans le futur, comme indiqué ci-dessous :

Pointer getString();

Tampons, mémoire, tableaux et pointeur

Quand devons-nous utiliser les tampons et la mémoire ?

Généralement, si un tableau de données de base est transmis à une fonction en tant que paramètre, vous pouvez utiliser directement un tableau de classes de base en JAVA. Mais si la méthode native a toujours besoin d'accéder au tableau après le retour de la méthode (enregistrer le pointeur sur le tableau), dans ce cas, il n'est pas approprié d'utiliser le tableau de la classe de base. Dans ce cas, nous devons utiliser ByteBuffers ou. Mémoire .

Nous savons que les tableaux en JAVA ont des longueurs, mais pour les méthodes natives, le tableau renvoyé est en fait un pointeur vers le tableau. Nous ne connaissons pas la longueur du tableau renvoyé, donc si la méthode native renvoie un tableau Comme pour les pointeurs, il est inapproprié d'utiliser des tableaux pour le mappage dans le code JAVA. Dans ce cas, Pointer doit être utilisé.

Pointer représente un pointeur. Regardons d'abord l'exemple de Pointer. Le premier est le code natif :

void* returnPointerArgument(void *arg) {
  return arg;
}

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

Le suivant est le mappage JAVA :

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

En plus du. Basic Pointer , vous pouvez également personnaliser un Pointer typé, c'est-à-dire PointerType. Il vous suffit d'hériter de PointerType, comme indiqué ci-dessous :

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

Regardez à nouveau le tableau de chaînes :

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

Le mappage JAVA correspondant est le suivant :

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

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

.

correspond à Buffer De manière générale, JAVA NIO fournit de nombreux types de tampons, tels que ByteBuffer, ShortBuffer, IntBuffer, LongBuffer, FloatBuffer et DoubleBuffer, etc. Ici, nous prenons ByteBuffer comme exemple pour voir l'utilisation spécifique.

Premier coup d'œil au code natif :

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

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

Le tampon est rempli ici. Il est évident que ce tampon sera utilisé plus tard, il est donc inapproprié d'utiliser un tableau. ici. Nous Vous pouvez choisir d'utiliser ByteBuffer :

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

Ensuite, regardez comment l'utiliser :

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

Paramètres variables

Pour le natif et JAVA lui-même, les deux prennent en charge les paramètres variables. :

Le mappage de la méthode JAVA correspondant de

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

est le suivant :

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

Le code d'appel correspondant est le suivant :

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!