[The_S]

Das Java Native Interface - Ein Einstieg

Java ist eine plattformunabhängige Programmiersprache, weshalb du in ihr nicht system- und/oder hardwarenah programmieren kannst. Dennoch ist es manchmal hilfreich, einen Zugriff auf die Systemressourcen zu erhalten. Z. B. wenn du ein plattformabhängiges Programm in Kauf nehmen kannst, aber Java dir mehr als alle anderen (nativen) Sprachen liegt. Oder wenn das Programm prinzipiell plattformunabhängig gestaltet werden soll, aber nur kleine, native Funktionen benötigt werden. In diesem Fall ist es einfacher das komplette Programm in Java zu schreiben und lediglich den plattformabhängigen Code in native Programmbibliotheken auszulagern.

Um so etwas zu realisieren, benötigst du eine entsprechende native Schnittstelle zu deinem Java-Programm. Diese kannst du z. B. über JNI (Java Native Interface) oder JNA (Java Native Access) realisieren. Der Unterschied zwischen den beiden Bibliotheken liegt darin, dass du mit JNA auf bestehende Bibliotheken zugreifen kannst. Mit JNI programmierst du bspw. in C oder C++ eine eigene Bibliothek, und greifst dann von deinem Java-Programm auf diese zu. Umgekehrt kannst du natürlich auch aus deiner nativen Bibliothek auf Java-Methoden zugreifen oder sogar eine komplette JVM ausführen (Invocation-API).

Da JNI deutlich umfangreicher, unbeschränkter und flexibler als JNA ist, beschäftigt sich dieses Tutorial größtenteils mit JNI. Für dieses Tutorial und um mit JNI arbeiten zu können, benötigst du zusätzlich eine entsprechende Entwicklungsumgebung für native Programme (hier eine C/C++-Umgebung wie z. B. gcc) und das Programm javah aus dem bin-Verzeichnis deines JDKs. Da JNI mit dem JDK 1.1 eingeführt wurde, musst du dir keine Gedanken machen, dass du eine zu alte Java-Version verwendest. Vorher gab es das NMI (Native Methode Interface).

Nachdem du nun weißt, was JNI ist und für was du es alles einsetzen kannst, programmierst du heute ein erstes HelloWorld-Programm mit JNI. Dabei rufst dein Java-Programm eine selbst geschriebene C-Bibliothek auf, welche ein einfaches Hello World auf der Konsole ausgibt.

Installation einer C/C++ Umgebung
Damit du aus deinem C/C++-Code eine Programmbibliothek (z. B. unter Windows *.dll oder bei Solaris *.so) erstellen kannst, benötigst du zuerst eine entsprechende Umgebung (ähnlich dem JDK). Hierfür bietet sich gcc an. Für die Windows-Plattform kannst du auf Cygwin oder MinGW zurückgreifen. Bei der Installation musst du lediglich darauf achten, dass du gcc-core, gcc-g++, gdb und make mit installierst.
Nachdem die Installation erfolgreich abgeschlossen wurde, solltest du noch das bin-Verzeichnis, welches den gcc enthält, in die Umgebungsvariable PATH mit aufnehmen.

Natürlich kannst du auch eine andere Umgebung zur Entwicklung Ihrer nativen Schnittstellen verwenden. Dieses Tutorial bezieht sich allerdings auf den gcc.

Wenn du alles richtig gemacht hast, kannst du jetzt über deine Konsole folgendes Kommando ohne Fehlermeldung ausführen:

gcc --version

Das Java-Programm
Erstelle eine neue Klasse mit dem Namen HelloJNIWorld und dem Inhalt

package de.jbb.jni;
 
public class HelloJNIWorld {
 
  static {
    System.loadLibrary("helloworld");
  }
 
  public static void main(String[] args) {
    printHelloWorld();
  }
 
  public static native void printHelloWorld();
}
 

im Package de.jbb.jni. Wie du auch in dem Kapitel über weitere Modifizierer lesen kannst, verweist die Methode printHelloWorld dank des native-Modifizierers auf eine native Implementierung dieser Methode. Der statische Initialisierer sorgt dafür, dass die native Bibliothek beim Start geladen wird. Hierzu wird die Methode loadLibrary der Klasse System verwendet. Wir gehen davon aus, dass sich die Library im selben Verzeichnis wie das Programm befindet (oder zumindest im library.path), weshalb es genügt, den Namen der Bibliothek ohne Dateiendung zu nennen (die Dateiendung wird - je nach Plattform - automatisch hinzugefügt).

Der library.path ist der Ort, an dem Java nach Bibliotheken sucht. Du kannst dir diesen Pfad über System.out.println(System.getPropertie("java.libra ry.path")); anzeigen lassen.

Es ist ebenfalls möglich zum Laden der Bibliothek einen absoluten Pfad, wie z.B. C:\java\dlls\helloworld.dll zu verwenden. Diesen lädst du dann aber nicht über System.loadLibrary sondern über System.load.

Die Klasse kann nun ganz normal kompiliert werden.

Die Header-Datei
So wie Java-Programme imports von Klassen zur Funktionserweiterung benötigen, benötigen C-Programme includes von Header-Dateien.

Eine Header-Datei enthält unter aanderem Deklarationen für den eigentlichen Quellcode und bilden in einer gewissen Form die Schnittstellen zwischen den unterschiedlichen Programmelementen.

Damit du eine Schnittstelle zwischen Java und C/C++ aufbauen kannst, wird zwingend eine solche Header-Datei benötigt. Um diese Datei zu erstellen, bietet Java das Tool javah an. Hiermit lassen sich automatisiert solche Header-Dateien für eine Klasse mit einem nativen Aufruf erzeugen. Dieses Programm findest du im bin-Verzeichnis deiner JDK-Installation. Da sich dieses Verzeichnis ohnehin in der PATH-Variable befinden sollte, kannst du das Tool ohne Probleme von überall aus auf der Konsole starten. Der Aufruf schaut genauso wie ein normaler java-Aufruf aus - nur eben mit javah anstelle von java:

javah de.jbb.jni.HelloJNIWorld

Auf der selben Ebene wie dein de-Ordner befindet sich nun die Header-Datei mit dem Namen de_jbb_jni_HelloJNIWorld.h. Es ist wichtig, dass du diese Datei niemals veränderst oder anpasst, sie sollte dann in etwa so aussehen:

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class de_jbb_jni_HelloJNIWorld */
 
#ifndef _Included_de_jbb_jni_HelloJNIWorld
#define _Included_de_jbb_jni_HelloJNIWorld
#ifdef __cplusplus
extern "C" {
#endif
/*
* Class:     de_jbb_jni_HelloJNIWorld
* Method:    printHelloWorld
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_de_jbb_jni_HelloJNIWorld_printHelloWorld
(JNIEnv *, jclass);
 
#ifdef __cplusplus
}
#endif
#endif
 

Das C-Programm
Nun ist es an der Zeit die dazugehörige Library zu erstellen. Entweder verwendest du ein C/C++ Plugin für Ihre IDE (z. B. CDT für Eclipse), oder du legst von Hand eine neue Textdatei an, und benennen diese in helloworld.c um. Diese Datei öffnest du dann mit einem beliebigen Texteditor und fügst folgenden Code ein:

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

JNIEXPORT void JNICALL Java_de_jbb_jni_HelloJNIWorld_printHelloWorld(JNIEnv *env, jclass cls)   {
  printf("Hello World\n");
  return;
}

Beachte, dass eine Leerzeile am Ende der Datei stehen muss!

Wie du bereits weißt, entsprechen die include-Zeilen in etwa den import-Anweisungen aus Java. Es werden also folgende Header-Dateien importiert:

• jni.h - für die Standard-JNI-Funktionen
• stdio.h - für die Funktionen zur Ausgabe von Text auf der Konsole
• de_jbb_jni_HelloJNIWorld.h - der eben generierte Header als Schnittstelle zu unserem Java-Programm

Jetzt folgt auch schon die Implementation Ihrer nativen Methode. Solche Methoden beginnen immer mit JNIEXPORT gefolgt vom Rückgabetyp (in unserem Fall void) und dem Macro JNICALL. Anschließend folgt der Name der Methode. Er beginnt immer mit Java, gefolgt vom Package der Klasse mit den nativen Methoden und letztendlich der Klasse selbst und dem Namen der nativen Methode. Die einzelnen Elemente sind dabei jeweils durch Unterstriche getrennt Java_de_jbb_jni_HelloJNIWorld_pintHelloWorld. Als Parameter werden der Methode standardmäßig die JNI-Umgebung (JNIEnv *env) und die aufrufende Klasse (jclass cls) bei statischen Methoden, bzw. das aufrufende Objekt (jobject obj) bei Objektmethoden übergeben. Sollte die Methode an sich noch Parameter erwarten, folgen diese im Anschluss.
Die Zeile printf("Hello World\n"); gibt erwartungsgemäß den Text “Hello World” aus und das abschließende return; beendet die Methode.

Kompilierung des C-Codes
Nun musst du deinen C-Quellcode noch in eine Bibliothek umwandeln. Wenn du - wie oben empfohlen - gcc verwendest, sieht der dazugehörige Aufruf im Verzeichnis deiner C-Datei auf der Konsole wie folgt aus:

gcc -mno-cygwin -I"pfad\zum\jdk\include\os" -I"pfad\zum\jdk\include" -I"pfad\zum\verzeichnis\von\de_jbb_jni_HelloJNIWorld" -Wl,--add-stdcall-alias -shared -o helloworld.sfx helloworld.c

Du musst jetzt noch die Pfade der -I-Aufrufe anpassen. Dabei werden folgende Verzeichnisse übergeben (relativ oder absolut):

1. Den Pfad zum include-Ordner im Installationsverzeichnis deines JDKs
2. Den Ordner im include-Ordner mit dem Namen deines Betriebssystems (z. B. win32 für Windows oder solaris für Solaris)
3. Den Pfad zum Verzeichnis, wo sich deine erzeugte Header-Datei (de_jbb_jni_HelloJNIWorld.h) befindet

Die letzten beiden Parameter spezifizieren den Namen der Programmbibliothek (ändere hier bitte die Dateiendung .sfx in die Dateiendung der Programmbibliotheken Ihres Betriebssystems - z. B. .dll für Windows oder .so für Solaris ab) und der Source-Datei.

Nach Absenden dieses Befehls wird eine native Bibliothek im aktuellen Verzeichnis erstellt. Kopiere die erstellte Datei nun auf die selbe Ebene, in der sich auch der de-Ordner deines Java-Programms befindet (bzw. falls du load anstelle von loadLibrary verwendet hast, an die Stelle, die du angegeben hast).

Jetzt kannst du dein Java-Programm ganz normal ausführen und solltest die Konsolenausgabe Hello World erhalten.

Dieses Tutorial wird uns mit freundlicher Genehmigung von java-blog-buch.de zur Verfügung gestellt.
Solltest du Fragen zu diesem Tutorial haben, so schreibe bitte einen Beitrag im Java-Forum mit einem Verweis auf dieses Tutorial.