Java Native Interface

JNI: Java Native Interface

Puede dar una miarada a Notas técnicas de Oracle

Introducción

Java Native Interface es una característica de Java que permite incorporar en aplicaciones Java código escrito en lenguaje C o C++ (también Java, cuando es llamado desde aplicaciones escritas en C).
JNI es parte de la máquina virtual Java y permite invocaciones en ambos sentidos: aplicaciones Java pueden invocar código nativo escrito en otro lenguaje y vice versa.

Figura 1: Usos de JNI, Aplicación Java más biblioteca puede correr sobre el host a través de la JVM, o una Aplicación Nativa más una biblioteca puede correr sobre el host.

Podemos usar JNI para escribir métodos nativos. Éstos tienen prototipo en Java pero su implementación es hecha en otro lenguaje. Estas implementaciones son pasadas a la máquina virtual a través de bibliotecas nativas (.dll en Windows o .so en Linux) Ver lado izquierdo de la Figura 1.

JNI también soporta una interfaz nativas permite incrustar una implementación de la máquina virtual dentro de aplicaciones nativas (lado derecho de la Figura 1). Aplicaciones nativas pueden enlazarse con una biblioteca nativa que implementa la máquina virtual Java y luego usar la interfaz de invocación para ejecutar componentes escritas en lenguaje Java. Así es cómo un browser escrito en C puede ejecutar applets en una máquina virtual embebida.

¿Cuándo usar JNI?

Hay dos efectos secundarios del uso de JNI: Las aplicaciones que dependen de métodos nativos dejan se correr en otros ambientes. Se hace necesario re-hacer la biblioteca para cada ambiente. En segundo lugar se pierden algunas características del lenguaje, un mal comportamiento de un método nativo afecta toda la aplicación. ¿Qué pasa si el método nativo genera fuga de memoria?. Como regla general se debe limitar el uso de métodos nativo a un mínimo.

Se recomienda usar JNI cuando la aplicación requiere alguna característica del host no accesible a través de la máquina virtual, cuando se desea acceder a bibliotecas nativas, o cuando deseamos dar mayor velocidad a porciones críticas del código.

Existen alternativas a JNI que implican comunicación entre procesos. Por ejemplo cuando usamos la clase Runtime para ejecutar procesos nativos en forma concurrente. También podemos comunicar procesos vía TCP/IP o usar tecnologías para distribuir objetos como la API de Java IDL (Interface Description Language). En todos estos casos se sacrifica eficiencia por la necesaria comunicación entre procesos.

Usando JNI para invocar métodos nativos

En general el uso es simple, la mayor atención se debe poner en el paso de parámetros entre el método en Java y su implementación en C. Los pasos a seguir se resumen en la Figura 2.

Figura 2: Pasos para incluir métodos nativos en una aplicación Java

A través de un ejemplo simple veremos estos pasos uno a uno.
1.- Creación de una clase que declara un método nativo, usando ejemplo HelloWorld.java

class HelloWorld {
     private native void print();
     public static void main(String[] args) {
         new HelloWorld().print();
     }
     static {  // asegura la carga de la biblioteca dinámica al inicio del programa.
         System.loadLibrary("HelloWorld");
     }
 }

2.- Compilación usando javac.

$ javac HelloWorld.java

Se genera archivo HelloWorld.class

3.- Creación del encabezado del método nativo

$ javah -jni HelloWorld

Se genera archivo HelloWorld.h. En este caso su contenido esencial es:

JNIEXPORT void JNICALL Java_HelloWorld_print
  (JNIEnv *, jobject);

La implementación C del método tiene un nombre que alude al: código Java de origen, nombre de la clase y nombre del método. Aún cuando el método Java no tiene argumentos, su implementación considera dos. El primer argumento de toda implementación de método nativo es un puntero a JNIEnv, el segundo es una referencia al objeto HelloWorld mismo (como el puntero a this en C++).

4.- Implementar método nativo HelloWorld.c.

#include <jni.h>
#include <stdio.h>
#include "HelloWorld.h"
 
 JNIEXPORT void JNICALL  // JNIEXPORT y JNICALL corresponde a macros requeridas, en medio el tipo retornado.
 Java_HelloWorld_print(JNIEnv *env, jobject obj)
 {
     printf("Hello World!\n");
     return;
 }

Se debe incluir encabezados según la implementación que hagamos. El código es C convencional.

5.- Compilación del código C y creación de la biblioteca de ligado dinámico. Esto depende del sistema operativo nativo. En este caso será linux. Además debe incluirse los directorios donde se encuentras los archivos de encabezados requeridos por JNI. En este caso son /usr/lib/jvm/java-6-sun/include y /usr/lib/jvm/java-6-sun/include/linux.

$cc -shared -I/usr/lib/jvm/java-6-sun/include -I/usr/lib/jvm/java-6-sun/include/linux -o libHelloWorld.so HelloWorld.c

Como resultado se general la biblioteca libHelloWorld.so

6.- Ejecución de la aplicación
Se debe poner cuidado en que la máquina virtual sepa dónde ubicar la biblioteca dinámica HelloWorld.so. Para esto se debe configurar la variable de ambiente LD_LIBRARY_PATH. En linux esto es:

$ export LD_LIBRARY_PATH=.

Luego podemos ejecutar la aplicación:

$ java HelloWorld 
Hello World!
$

Java también admite especificar el path de la biblioteca con la opción, en este caso, -Djava.library.path=.

Paso de parámetros entre métodos nativos y sus implementaciones nativas

El tratamiento cambia según si los tipos de datos son primitivos u objetos. A continuación de los dos argumentos presentes en toda implementación nativa, se listan los parámetros declarados en el método nativo. Cuando son tipos básicos éstos son reflejados en C con tipos equivalentes definidos en jni.h. El listado de equivalencias se puede ver aquí.

Consideremos el ejemplo Prompt.java:

class Prompt {
    // native method that prints a prompt and reads a line
  private native String getLine(String prompt, int i);
 
  public static void main(String args[]) {
    int i = 20;  // sólo para agregar otro tipo de dato
    Prompt p = new Prompt();
    String input = p.getLine("Type a line: ", i);
    System.out.println("User typed: " + input);
  }
  static {
    System.loadLibrary("Prompt");
  }
}

Luego de compilar y correr javah, se genera el archivo Prompt.h, cuyo contenido fundamental es:

JNIEXPORT jstring JNICALL Java_Prompt_getLine
  (JNIEnv *, jobject, jstring, jint);

String son objetos en Java, en C corresponden a char *. La implementación del método nativo está en Prompt.c.Para hacer un acceso adecuado debemos hacer una conversión.

#include <jni.h>
#include <stdio.h>
#include "Prompt.h"

JNIEXPORT jstring JNICALL 
Java_Prompt_getLine(JNIEnv *env, jobject obj, jstring prompt, jint i)
{
  char buf[128];
  const jbyte *str;
  str = (*env)->GetStringUTFChars(env, prompt, NULL);
  if (str == NULL) {
    return NULL; /* OutOfMemoryError already thrown */
  }
  printf("Number:%d, %s", i, str);
  (*env)->ReleaseStringUTFChars(env, prompt, str);
    /* We assume here that the user does not type more than
     * 127 characters */
  gets(buf);
  return (*env)->NewStringUTF(env, buf);
}

A través del puntero env es posible acceder a funciones JNI para efectuar conversiones. En esta conversión GetStringUTFChars solicita memoria para str. Una vez finalizado el uso de str, debemos retornar el espacio de memoria por eso llamamos a ReleaseStringUTFChars.
La compilación y ejecución del código es similar al del ejemplo previo HelloWorld.java.