Java JNI nutzen mit Hilfe von Eclipse CDT und MinGW

Da ich mich jüngst mit diesem Thema beschäftigt habe und ich auch ein paar Stunden Zeit investieren musste, bis alles einwandfrei funktionierte, hier nun eine kleine Anleitung nach dem Schema “Hello World”, wie man Java und C++ mit Hilfe von JNI verbindet und das Ganze in Kombination mit Eclipse.
Einige Dinge, die ich nun versuche kurz und knapp zu beschreiben, kann man sicherlich auch anders machen, eventuell auch besser, aber so funktioniert es, jedenfalls bei mir . Vorweg sei auch gesagt, dass ich hier nicht groß und breit erklären werde, was JNI bedeutet, was es macht, warum, wieso, weshalb und so weiter. Hier geht es einfach nur darum ein HelloWorld mit Hilfe von Eclipse auf den Bildschirm/TFT zu zaubern und darauf werde ich mich hier beschränken. Anleitungen zu JNI gibt es haufenweise im Netz, deshalb muss ich hier nicht auch noch ein Buch schreiben, wo das Selbe enthalten ist. Detaillierte Beiträge zu JNI, was es macht und wie es funktioniert, gibt es zum Beispiel hier. Die Anleitung basiert auf Windows XP, müsste aber ähnlich auch bei Linuxsystemen funktionieren.

Voraussetzungen für JNI mit Eclipse

Ein paar Erfahrungen sollte man mit Eclipse, CDT, MinGW und so weiter schon gemacht haben, also für wen das Neuland ist, dem sei erst einmal ein Eclipse Tutorial ans Herz gelegt.

Folgendes muss installiert sein und funktionieren:

• Eclipse 3.2 mit CDT
• JDK (1.6.0)
• MinGW
• MSYS

Der grobe Ablauf

1. Erstellen einer Javaklasse, die das JNI in Anspruch nimmt
2. Erstellen einer Headerdatei
3. Schreiben der C++ Funktionen
4. DLL erstellen
5. Das Ergebnis bewundern

Arbeiten wir nun die Punkte nach und nach ab…

Erstellen der Projekte

Zuerst ein neues Standard Java Projekt mit dem Namen “HelloWorld” in Eclipse anlegen und eine einfache Klasse erstellen im Package “helloworld”, die eine native Funktion erhält. Zum Beispiel so:

package helloworld;

public class HelloWorld {

  public native void callNative(); // Funktion die später in der DLL implementiert wird

  static {
    System.loadLibrary("HelloWorld"); // Name der externen DLL Datei (ohne .dll)
  }

  public static void main(String[] args) {

    System.out.println("Servus, ich bin die Javaklasse. Wie geht es dir CallNative.DLL?");
    HelloWorld hello = new HelloWorld();
    hello.callNative();
    System.exit(0);

  }
}

Anschließend kompilieren, wenn nicht schon automatisch von Eclipse erledigt. Im bin-Verzeichnis müsste sich nun ein Unterverzeichnis “helloworld” befinden, welches die Klasse “HelloWorld.class” enthält. Wir haben nun ein fertiges Javaprojekt. Um die spätere DLL erstellen zu können brauchen wir noch ein C++ Projekt. Das erstellen wir nun.

Als neues Projekt wählen wir also dieses mal aus dem Unterordner “C++” ein “Managed Make C++ Project” aus. Ein passender Name wäre, im Gegensatz zu dem Java Projekt “HelloWorld”, hier dieses Mal passend zur DLL “HelloWorldDLL”. Im nächsten Fenster wählen wir dann bei Project Type “Shared Library (Gnu on Windows)” aus und entferne noch das Häkchen bei “Debug”. Das wir hier nicht zwingend gebraucht. Mit “Finish” wird das Projekt erstellt. Gleich danach erstellen wir ein Verzeichnis “/src” direkt im C++ Projekt. So haben wir nun am Ende 2 Projekte: ein Java und ein C++ Projekt.

Erstellen der Headerdatei mit Eclipse

Nun kommt Schritt 2, erstellen der Headerdatei. Wir wechseln nun in das bin-Verzeichnis und geben dort folgendes Kommando ein:

javah -jni helloworld.HelloWorld

Nun müsste eine Headerdatei erzeugt worden sein, mit dem Namen “helloworld_HelloWorld.h” oder so ähnlich. Diese sollte später unverändert bleiben, als nicht darin rumschreiben! Dies ist jetzt aber der normale Weg, wir wollen das ganze einfach und automatisch in Eclipse machen und die Headerdatei soll auch gleich im richtigen Verzeichnis des “HelloWorldDLL” Projektes landen. Die eben erstellte Headerdatei kann dann erstmal wieder gelöscht werden.

Wir wollen nun den Befehl “javah” in ein “External Tool” von Eclipse transferieren. Dazu klicken wir auf “Run -> External Tools -> External Tools…”. In dem nun sich geöffneten Fenster wählen wir “Program” aus und füllen alle wichtigen Felder aus. Im Reiter “Main” muss zuerst die Location der “javah”-Datei eingegeben werden. Bei mir ist das beispielsweise:

C:/Programme/Java/jdk1.6.0/bin/javah.exe

Im “Working Directory” geben wir ein:

${workspace_loc:/HelloWorld/bin}

Hinter der Variable “workspace_loc:” kommt das Verzeichnis, in dem das Projekt zuhause ist, also “/HelloWorld” und anschließend “/bin”, da hier die fertig kompilierten Klassen liegen. Unter “Arguments kommt” kommt folgender Eintrag:

-jni -d ${workspace_loc:/HelloWorldDLL/src} helloworld.HelloWorld

“/HelloWorldDLL/src” ist unser Zielverzeichnis. Somit wird die Headerdatei gleich in das passende Verzeichnis des C++ Projektes verschoben. Abschließend geben wir dem Ganzen noch einen Namen, ganz oben in “Name:”. Unter dem Reiter “Refresh” machen wir noch ein Häkchen und wählen “The entire workspace” aus. Nun können wir das Ganze laufen lassen. In dem C++ Projekt müsste jetzt im Verzeichnis “/src” eine Headerdatei mit dem Namen “helloworld_HelloWorld.h” zu finden sein. Wenn alles funktioniert hat, haben wir nun für die Zukunft immer die Möglichkeit mit einem Klick eine neue Headerdatei zu erzeugen, sollte sich in der Javaklasse mal was ändern. Nun geht es an die Implementierung der DLL Datei.

Implementierung der C++ Funktionen

Im C++ Projekt erstellen wir nun eine “.cpp” Datei. Der genaue Inhalt der cpp-Datei richtet sich nach dem nun folgenden Inhalt der eben erstellten Headerdatei:

/* DO NOT EDIT THIS FILE - it is machine generated */

#include <jni.h>

/* Header for class helloworld_HelloWorld */
#ifndef _Included_helloworld_HelloWorld
#define _Included_helloworld_HelloWorld
#ifdef __cplusplusextern "C" {
#endif

/*
* Class:     helloworld_HelloWorld
* Method:    callNative
* Signature: ()V
*/

JNIEXPORT void JNICALL Java_helloworld_HelloWorld_callNative (JNIEnv *, jobject);

#ifdef __cplusplus

}

#endif
#endif

Wir sehen hier die Funktion

JNIEXPORT void JNICALL Java_helloworld_HelloWorld_callNative (JNIEnv *, jobject);

Diese müssen wir nun in der C++ Datei implementieren. Der Inhalt der C++ Datei sieht dann so aus:

#include <jni.h>
#include "helloworld_HelloWorld.h"
#include <iostream>

using namespace std;

JNIEXPORT void JNICALL Java_helloworld_HelloWorld_callNative (JNIEnv *env, jobject obj) {

   cout << "Mir geht es gut: Hello World!" << endl;

}

Am Besten man kopiert die Funktion einfach per copy-and-pase von der Headerdatei in die C++ Datei und fügt bei den Parametern nur noch “*env” und “obj” hinzu. So kann man Tippfehler vermeiden.

Damit das Kompilieren später funktioniert und die Funktionen der DLL auch von Java genutzt werden können muss nun noch eine 3. Datei erstellt werden, am besten mit dem Namen “HelloWorld.def”. Die Endung “def” ist dabei zwingend erforderlich. Diese hat den Inhalt:

EXPORTS

Java_helloworld_HelloWorld_callNative

Wie wohl jedem auffällt, ist das der Name der Funktion. Jetzt ist es an der Zeit den C++ Compiler zu konfigurieren.

Kompilieren der DLL

Wie klicken dazu auf “Project -> Properties”. In dem jetzigen Fenster nehmen wir nun alle nötigen Einstellungen vor:

Zuerst wählen wir links “C/C++ Build” aus. Dann geht es in den Reiter “Tool Settings”. Dort wählen wir unter “GCC C++ Compiler” -> “Directories” aus. Rechts können wir nun die “Include Paths” angeben. Hier fügen wir nun 2 (!) Verzeichnisse hinzu:

C:/Programme/Java/jdk1.6.0/include/win32
C:/Programme/Java/jdk1.6.0/include

Je nachdem wo das JDK installiert wurde muss hier der Pfad zu dem “include”-Verzeichnis von Java angegeben werden. Jetzt wählt man “GCC C++ Linker” aus. Wieder auf der rechten Seite müsste nun ein Feld mit dem Namen “Command:” erscheinen mit dem Inhalt “g++”. Hier fügen wir nach einem Leerzeichen den Ausdruck “../src/HelloWorld.def” hinzu, so dass am Ende in dem Feld folgendes da stehen muss: “g++ ../src/HelloWorld.def”. Sicherlich geht das auch irgend wie eleganter, aber ich habe noch keine bessere Möglichkeit gefunden . Zuletzt müssen wir noch unter dem Reiter “Build Settings” den Namen der DLL-Datei ändern von “HelloWorldDLL” nach “HelloWorld”.

Normalerweise müsste das Kompilieren jetzt ohne Fehler funktionieren und in dem Verzeichnis “Release” müsste sich die Datei “HelloWorld.dll” befinden.

Der letzte Feinschliff

Wir wollen aber nun, dass die DLL-Datei gleich automatisch in das Java-Projekt kopiert wird. Dazu gehen wir noch mal zurück in die “Project -> Properties”. Dieses Mal wählen wir links “Builders” aus. Auf der rechten Seite werden jetzt die Builder aufgelistet: “Generated Makefile Builder”. Nun klicken wir ganz rechts auf “New” und dann auf “Program”. Es öffnet sich die gleiche Maske wie in den “External Tools”. Als Namen geben wir irgend was ein, zum Beispiel: “DLL kopieren” . Da wir ja MSYS installiert haben, machen wir uns das einfach und benutzen den “cp” Befehl, den wir aus der Linuxwelt kennen. Dies kann natürlich auch mit dem normalen “copy”-Befehl von Windows gemacht werden, aber das ist nicht so wichtig. Als Location wird hier also nur noch die “cp” Datei angegeben, die sich im “/MSYS/bin”-Verzeichnis befinden müsste. Als “Working Directory” geben wir an:

${workspace_loc:/HelloWorldDLL/Release}

und als Arguments:

*.dll ${workspace_loc:/HelloWorld/bin}

Unter “Build Options” machen wir ein Haken bei “Run the Builder” -> “During auto builds”.

Das Ergebnis bewundern

Die kompilierte DLL sollte sich nun immer automatisch in dem “/bin” Verzeichnis des Java Projektes befinden. Um das Ganze zum Laufen zu bringen, muss nun einmal auf “Run -> Run…” geklickt werden. Indem nun sich öffnenden Fenster muss man zu guter letzt noch auf den Reiter “Arguments” wechseln und in dem Feld “Working Directory -> Other:” ganz unten folgende Zeile einfügen:

${workspace_loc:HelloWorld/bin}

Sonst findet die Javaklasse die DLL nicht. Der Rest solle von Eclipse automatisch ausgefüllt worden sein. Wenn nun auf Run geklickt wird, sollte unten in der Konsole der Dialog zwischen Java und der DLL erscheinen.

Done

Wir haben nun die Möglichkeit parallel in 2 Projekten zu arbeiten. Die DLL wird immer automatisch kompiliert und an den richtigen Platz gebracht. Die obige Beschreibung habe ich selber noch einmal praktisch durchgespielt und es hat alles einwandfrei funktioniert. Wie es so häufig der Fall ist, kann es natürlich sein, dass auf einem anderen Rechner, mit einer anderer Konfiguration, die Sache irgend wie nicht funktioniert. Dann findet man aber schnell Hilfe in den vielen Javaforen. Zudem ist diese HowTo nur eine Möglichkeit die Sache in Eclipse umzusetzen. Hier und da kann man einige Dinge vielleicht geschickter lösen. So gibt es zum Beispiel auch die Möglichkeit beide Projekte zu vereinen. Der Übersicht halber finde ich diese Lösung aber sinnvoller. Zudem könnte man die Erzeugung der Headerdatei auch in die Buildkonfiguration des Javaprojektes aufnehmen und die Sache so noch weiter automatisieren. Ich hoffe aber, dass ich mit dieser HowTo einen guten Leitfaden zur Verfügung gestellt habe, womit man als Neuling erst einmal anfangen kann. Sollten irgend welche Fehler in dem Text enthalten sein, wäre ich dankbar, wenn diese in den anschließenden Commtsbereich gepostet werden. Für Fragen, Anregungen und Kritiken bin ich immer offen, sofern sie konstruktiv sind.