PDF de programación - JNI: Java Native Interface

JNI:
Java
Native
Interface

JNI: Java Native Interface MacProgramadores


Acerca de este documento

Este documento es un tutorial de JNI (Java Native Interface), el mecanismo que
permite ejecutar funciones C y C++ desde Java. El tutorial supone que el lector
conoce tanto los lenguajes Java como C, no es necesario conocer C++, aunque el
saber siempre ayuda. También supone que el lector está familiarizado con el uso de
herramientas de programación como gcc, java o javac. Debido a
la
interoperatividad del lenguaje Java, hemos pretendido que las explicaciones sean
consistentes con cualquier sistema operativo, auque la mayoría de lo ejemplos se
desarollan en Mac OS X.

Al acabar este documento esperamos que el lector haya adquirido los
conocimientos necesarios para llamar desde Java a librerías C y C++, así como para
llamar desde C y C++ a librerías Java.


Nota Legal

Este tutorial ha sido escrito por Fernando López Hernández para MacProgramadores,
y de acuerdo a los derechos que le concede la legislación española e internacional el
autor prohíbe la publicación de este documento en cualquier otro servidor web, así
como su venta, o difusión en cualquier otro medio sin autorización previa.

Sin embargo el autor anima a todos los servidores web a colocar enlaces a este
documento. El autor también anima a cualquier persona interesada en aprender JNI
a bajarse o imprimirse este tutorial.

Madrid, Octubre del 2007
Para cualquier aclaración contacte con:
[email protected]

Pág 2

JNI: Java Native Interface MacProgramadores

5.5.

5.1.
5.2.
5.3.
5.4.

5.4.1
5.4.2
5.4.3

5.5.1
5.5.2


Tabla de Contenido


PARTE I: Programación con JNI

Introducción.................................................................................................6
1.
2. Evolución histórica de JNI .............................................................................7
3.
Las librerías de enlace estático y dinámico......................................................8
4. El ejemplo básico........................................................................................ 10
5. Tipos de datos fundamentales, arrays y objetos............................................ 13
Parámetros de un método nativo.......................................................... 13
Correspondencia de tipos..................................................................... 13
Acceso a tipos de datos fundamentales................................................. 14
Acceso a objetos String .................................................................... 15
Obtener el texto de un String..................................................... 15
Crear un nuevo String ............................................................... 17
Ejemplo....................................................................................... 17
Acceso a arrays................................................................................... 18
Acceso a arrays de tipos de datos fundamentales ........................... 18
Acceso a arrays de referencias ...................................................... 21
6. Acceso a objetos ........................................................................................ 24
La signatura de tipo............................................................................. 24
Acceso a los atributos de un objeto ...................................................... 25
Acceso a atributos de instancia ..................................................... 25
Acceso a atributos de clase ........................................................... 27
Acceso a los métodos de un objeto....................................................... 28
Ejecutar métodos de instancia....................................................... 29
Ejecutar métodos de clase ............................................................ 30
Ejecutar métodos de instancia de la superclase .............................. 31
Invocar a un constructor............................................................... 33
Rendimiento en le acceso a arrays, métodos y atributos......................... 34
Rendimiento en el acceso a arrays................................................. 35
Rendimiento en el acceso a los miembros de un objeto................... 36
Diferencias de coste entre métodos nativos y métodos Java............ 36
7. Referencias locales y globales...................................................................... 38
7.1. Qué son las referencias........................................................................ 38
Tipos de referencias ............................................................................ 39
7.2.
Referencias locales....................................................................... 39
Referencias globales..................................................................... 40
Referencias globales desligadas..................................................... 41
7.3.
Comparación de referencias ................................................................. 41
7.4. Gestión de referencias locales en JSDK 1.2............................................ 42
8. Excepciones ............................................................................................... 44
Capturar excepciones en un método nativo. .......................................... 44
Lanzar excepciones desde un método nativo ......................................... 46
Excepciones asíncronas........................................................................ 46
Ejemplo .............................................................................................. 46
Consideraciones de rendimiento ........................................................... 48

6.3.1
6.3.2
6.3.3
6.3.4

8.1.
8.2.
8.3.
8.4.
8.5.

6.1.
6.2.

6.3.

6.2.1
6.2.2

6.4.

6.4.1
6.4.2
6.4.3

7.2.1
7.2.2
7.2.3

Pág 3

JNI: Java Native Interface MacProgramadores

2.1.
2.2.

2.2.1
2.2.2


PARTE II: Programación avanzada con JNI

1. Programación multihilo con JNI ................................................................... 50
Restricciones para JNI ......................................................................... 50
1.1.
La interfaz JNIEnv ............................................................................. 51
1.2.
1.3. Monitores ........................................................................................... 52
wait() notify() y notifyAll()............................................... 53
1.4.
El modelo multihilo de la máquina virtual y del host environment............ 54
1.5.
2. El Invocation Interface................................................................................ 55
Creación de una máquina virtual .......................................................... 55
Enlazar una aplicación nativa con una máquina virtual Java.................... 58
Enlazar con una máquina virtual conocida...................................... 58
Enlazar con una máquina virtual desconocida................................. 59
2.3.
Ejemplo: Aplicación nativa que ejecuta un programa Java en una máquina
virtual incrustada ........................................................................................... 62
2.4. Obtener la máquina virtual del proceso ................................................. 63
La interface JavaVM............................................................................ 63
2.5.
2.6.
Asociar hilos nativos a la máquina virtual ............................................. 64
Ejecutar rutinas al cargar y descargar la máquina virtual ........................ 65
2.7.
3. Carga y enlace de librerías de enlace dinámico desde Java ............................ 67
Los class loader................................................................................... 67
Carga de librerías nativas por el class loader ......................................... 68
Enlace de los métodos nativos.............................................................. 69
Enlace manual de métodos nativos ....................................................... 70
4. Compatibilidad y acceso a librerías del host environment desde Java.............. 72
4.1. Mecanismos de paso de parámetros ..................................................... 72
Función de stub................................................................................... 72
4.2.
4.3.
Shared Stubs ...................................................................................... 73
4.4. Diferencias entre funciones de stub y shared stubs ................................ 74
4.5.
Implementación de los shared stubs ..................................................... 74
La clase PunteroC ...................................................................... 75
La clase MallocC ........................................................................ 76
La clase FuncionC ...................................................................... 77
4.6. Objetos peer ....................................................................................... 82
4.6.1
Objetos peer del JSDK .................................................................. 82
4.6.2
Liberación de objetos peer............................................................ 83
4.6.3
Punteros a Java desde el objeto peer ............................................ 84
5.
Información de introspección desde JNI ....................................................... 85
6. Programación en C++ con JNI .....