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 se debe incluir 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
Notar la diferencia entre el nombre de la biblioteca y el nombre usado
para cargarla en programa Java. Por convención como nombre de archivo
se usa lib{NombreDeBiblioteca}.so Usamos .so para indicar que se trata
de un Shared Object.
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 a través de ReleaseStringUTFChars.
La compilación y ejecución del código es similar al del ejemplo previo HelloWorld.java.