Java Native Interface

Java Native Interface (JNI) es un framework de programación que permite que un programa escrito en Java ejecutado en la máquina virtual java (JVM) pueda interactuar con programas escritos en otros lenguajes como C, C++ y ensamblador.

Propósito y características

El JNI se usa para escribir métodos nativos que permitan solventar situaciones en las que una aplicación no puede ser enteramente escrita en Java, como por ejemplo en el caso de que la biblioteca estándar de clases no proporcione soporte para funcionalidades dependientes de la plataforma.

También se usa para modificar programas existentes escritos en algún otro lenguaje, permitiéndoles ser accesibles desde aplicaciones Java. Muchas de las clases de la API estándar de Java dependen del JNI para proporcionar funcionalidad al desarrollador y al usuario, por ejemplo las funcionalidades de sonido o lectura/escritura de ficheros. El desarrollador debe asegurarse que la API estándar de Java no proporciona una determinada funcionalidad antes de recurrir al JNI, ya que la primera ofrece una implementación segura e independiente de la plataforma.

El framework JNI permite a un método nativo utilizar los objetos Java de la misma forma en que el propio código de Java lo hace. Un método nativo puede crear objetos Java; y examinarlos y utilizarlos para que lleven a cabo su función. Un método nativo puede asimismo examinar y utilizar objetos que han sido creados por código de aplicación escrito en Java.

A menudo se denomina a JNI como la "válvula de escape" para desarrolladores dado que les permite añadir funcionalidades a sus aplicaciones que el API de Java no puede proporcionar.

Dado que -como se ha dicho antes- puede ser usado para interactuar con código escrito en otros lenguajes como C++, también se usa para operaciones y cálculos de alta complejidad temporal, porque el código nativo es por lo general más rápido que el que se ejecuta en una máquina virtual.

Advertencias

JNI no es en absoluto trivial, Se recomienda que sea usado por programadores experimentados. En cualquier caso, la posibilidad de comunicar Java con C, C++ o ensamblador, desestima toda limitación en lo que los programas Java pueden hacer.

Es aconsejable tener en cuenta los siguientes puntos cuando se considera usar JNI:

JNI no es un API fácil de aprender.
Pequeños errores en el uso de JNI pueden desestabilizar completamente la máquina virtual Java, de formas muy difíciles de reproducir y subsanar.
Solo las aplicaciones y applets firmados pueden invocar el JNI.
Una aplicación que recurre a JNI pierde una de las características más importantes que Java le confiere, su portabilidad. (Una forma de solventar esto, es escribir una implementación separada del código JNI por cada plataforma, y hacer a Java detectar el sistema operativo para ejecutar una u otra implementación llegado el momento).
No hay recolección de basura en el lado JNI, (el código JNI debe deslocalizar explícitamente sus punteros).

El colector automático de basura de Java es algo distinto a malloc/free en C, dado que puede mover objetos después de que se les haya sido asignada la memoria necesaria. Es por lo tanto de vital importancia que los punteros a objetos Java sean obtenidos y bloqueados correctamente. Los programadores habituados a C a menudo no entienden esto, lo que puede llevarles a provocar errores bastante esotéricos e irreproducibles.

Por todo lo anterior, JNI debe ser utilizado con cautela y suele ser evitado por los desarrolladores Java. Por ejemplo, la mayoría de las bases de datos JDBC se comunican directamente con un socket en lugar de utilizar las API existentes en C.

Cómo funciona el JNI

En JNI, las funciones nativas se implementan en archivos .c o .cpp por separado (C++ ofrece una interfaz con JNI ligeramente más clara). Cuando la máquina virtual invoca a la función, le pasa un puntero a JNIEnv, un puntero a jobject, y cualquier número de argumentos declarados por el método Java. Una función de JNI debería parecerse a esto:

 JNIEXPORT void JNICALL Java_ClassName_MethodName
   (JNIEnv *env, jobject obj)
 {
     //El método nativo se implementa aquí
 }

El puntero JNIEnv *env es una estructura que contiene la interfaz hacia la máquina virtual. Incluye todas las funciones necesarias para interactuar con la JVM (Java Virtual Machine) y para trabajar con los objetos Java.

Como ejemplos de uso de esta interfaz, se pueden mencionar la conversión de vectores (estilo C) de/a vectores Java o cadenas nativas (punteros a carácter) de/a cadenas Java (objetos String); instanciación de objetos, lanzamiento y captura de excepciones, etc.

En esencia, usando JNIEnv puede hacerse cualquier cosa que el código Java pueda hacer; eso sí, con una dificultad considerablemente incrementada.

Por ejemplo, el siguiente fragmento de código convierte una cadena de Java en una nativa.

 //Código C++
 JNIEXPORT void JNICALL Java_ClassName_MethodName
   (JNIEnv *env, jobject obj, jstring javaString)
 {
     //Tomar la cadena nativa de la cadena de java
     const char *nativeString = env->GetStringUTFChars(javaString, 0);

     //Hacer algo con ella

     /* NO OLVIDE ESTA LÍNEA, libera el espacio ocupado por la cadena usada
      * esto tiene que ver con la forma en que Java maneja las cadenas */
     env->ReleaseStringUTFChars(javaString, nativeString);
 }

 //C code
 JNIEXPORT void JNICALL Java_ClassName_MethodName
   (JNIEnv *env, jobject obj, jstring javaString)
 {
     //Tomar la cadena nativa de la cadena de java
     const char *nativeString = (*env)->GetStringUTFChars(env, javaString, 0);

     //Hacer algo con ella

     /* NO OLVIDE ESTA LÍNEA, libera el espacio ocupado por la cadena usada
      * esto tiene que ver con la forma en que Java maneja las cadenas */
     (*env)->ReleaseStringUTFChars(env, javaString, nativeString);
 }

Nótese que el código JNI de C++ es sintácticamente más claro que el código en C, porque al igual que Java, C++ usa una semántica de invocación de métodos orientada a objetos,

Esto implica que en C, el parámetro env debe ser desreferenciado usando (*env) y debe ser pasado explícitamente (aparece como parámetro) a los métodos de JNIEnv.

En C++, el parámetro env se desreferencia usando env-> y se pasa implícitamente como parte de la semántica de invocación de métodos orientada a objetos (no aparece como parámetro porque el método forma parte de env cuando se trata como un objeto).

Los tipos de datos nativos pueden sufrir conversiones desde/hacia tipos de datos Java. Para tipos complejos, tales como los objetos, arrays y cadenas, el método nativo debe convertir los datos explícitamente llamando a métodos en el JNIEnv (Java Native Interface Environment).

Bibliografía

Sheng Liang (1999). Java Native Interface: Programmer's Guide and Specification (en inglés). Versión en pdf. Addison-Wesley. ISBN 0-201-32577-2.

Datos: Q168492