JNI: Echt(!) nativen Code in Java ausführen?

[astralarse]

Servus!

Ich hab ein Problem mit JNI. Ich finde im Netz zwar tausende Beispiele und Tutorials die mir erklären wie ich JNI-fähigen C-Code schreibe, den in DLLs deploye und das dann mittels System.getLibary(...) in Java-Programmen zugänglich mache, aber irgendwie vermisse ich da eine ganz entscheidende Sache.

Ist bzw. sollte nicht Kern des Gedankens sein, dass ich mit JNI echt(!) nativen Code in Java ausführen kann? Sämtliche Tutorials laufen nach dem Schema ab:

1. Java-Code schreiben
2. kompilieren (javac)
3. Header-Datei erzeugen (javah)
4. dann erst den C-Code schreiben (der da dann natürlich schon den JNI-Konventionen entspricht)
5. diesen kompilieren (.so bei UNIX, .dll auf MS-Plattformen)
6. Java-Programm ausführen und fertig.

Wie gehe ich jetzt aber vor, wenn ich von Anfang an schon C-Sourcen habe und die nicht umschreiben kann oder will? Ich hab zwar gesehen, dass es dafür wohl Generators und/oder Wrapper-Tools gibt, aber das muss doch auch von Hand gehen, z.B. mithilfe einer Interface-DLL oder whatsoever.

Kann mir das jemand anhand eines HelloWorld-Beispiels erläutern? Also mit ganz normalem C-Code, z.B. so:

#include <stdio.h>

// simple method with "Hello World!" output
void sayHello(void)
{
	printf("Hello World!\n");
}

// main method of program
int main (void)
{
	sayHello();
	return 0;
}

 

[Wildcard]

Du brauchst einen Wrapper der mit dem vorhandenen C Code kommuniziert.
Schau dir vielleicht mal JNA an, das ist einfacher als JNI.

 

[thE_29]

Eine DLL/SO Datei braucht IMMER Einstiegspunkte die nunmal anders sind als wenn du dir ne exe draus erstellen lässt.

Dh, ohne diese Einstiegspunkte (diese elendlangen JNI ... Headers) kann Java in der dll/so diese Funktion nicht finden!

Dh, wenn du sayHello aufrufen willst, brauchst du eine Funktion mit dem JNI Header und diese ruft halt dann einfach dein sayHello auf!

 

[astralarse]

Du brauchst einen Wrapper der mit dem vorhandenen C Code kommuniziert.
Schau dir vielleicht mal JNA an, das ist einfacher als JNI.

das problem ist, dass ich die vorgabe habe das mit JNI zu machen. mein chef meinte zu mir, dass ich mich da einarbeiten soll mit dem szenario, dass der vorhandene native c-code nicht den JNI-konventionen entspricht (also ganz normaler c-code ist ohne irgendwelchen schnick-schnack). er meinte auch, dass ich dazu keinen wrapper o.ä. brauche und das auch von hand gehe... nun sind das aussagen, die mich schlussfolgern lassen, dass das ganze ja kein so riesen act sein kann, oder doch?

[...] Dh, wenn du sayHello aufrufen willst, brauchst du eine Funktion mit dem JNI Header und diese ruft halt dann einfach dein sayHello auf!

gibt es also die möglichkeit mir eine art interface-dll zu erstellen, die dann die methodenaufrufe von java/JNI "abfängt" bzw. an die richtige (echt native) dll "weiterleitet" - also dort dann die methoden aufruft/holt/grabt/whatever? oder hab ich doch ne total falsche info bekommen bzw. vorstellung von der ganzen sache?

klar ist es schön mit einer plattformunabhängigen ebene (java-programm) plattform-spezifische (c-dll) sachen auszuführen, aber es muss doch möglich sein das auch mit bereits bestehenden c-sources bzw. -dlls zu tun.

 

[thE_29]

Für das musste JNA nehmen!

JNA ist so ein Wrapper der dir schon dlls aufrufen lässt (zB kernel.dll oder sonstige) und dort halt Funktionen aufruft!

Sag deinem Chef, das ist genau das was er will!

 

[astralarse]

Für das musste JNA nehmen!

JNA ist so ein Wrapper der dir schon dlls aufrufen lässt (zB kernel.dll oder sonstige) und dort halt Funktionen aufruft!

Sag deinem Chef, das ist genau das was er will!

okay, ich schau mir das mal an. dankeschön derweil! :toll:

 

[astralarse]

Hallo nochmal!

Also ich hab mir das mit JNA jetzt mal angesehen. Das läuft im Prinzip schon in die richtige Richtung, allerdings bleibt es beim Thema JNI...

[OFFTOPIC] Cheffe meinte, das geht und dem muss ich mich als Werkstudent dann nunmal doch stellen. Wie das geht will er mir natürlich nicht verraten - das soll ich eben selber rausfinden. Ist im Endeffekt alles im Rahmen der Einarbeitung in ein Java-Projekt in das ich demnächst einsteigen soll - und dort wird eben die Verwendung nativer DLLs via JNI getätigt: [/OFFTOPIC]

System.loadLibrary(getDingensBumens());

Jetzt hab ich folgende Idee:
Wie u.a. oben schon gesagt wurde, müssen native Methoden gewissen Namenskonventionen entsprechen um via JNI in Java-Code ausgeführt werden zu können. Soweit so gut. HelloWorld.java, HelloWorld.class und HelloWorld.h stehen bzw. wurden erzeugt. Gemäß der Header-Datei bau ich mir nun ein C-File welches die entsprechende(n) Methode(n) enthält:

// HelloWorld.c

#include <jni.h>
#include <stdio.h>
#include <windows.h>
#include "HelloWorld.h"

JNIEXPORT void JNICALL
Java_HelloWorld_hello(JNIEnv *env, jobject obj)
{
	// call sayHello() from NativeHelloWorld.dll which is in same directory
	extern "C" __declspec(dllimport) void sayHello();
}

Hier versuch ich nun einen DLL-Import zu tätigen. Hab nur eben noch nicht richtig ausgetüftelt wie ich das denn jetzt genau anstelle - aber so in die Richtung müsste es doch auch funktionieren. Dann hätt ich doch so ne Art "Wrapper"- oder "Interface"-DLL. Warnt mich bitte jemand, wenn ich im Begriff bin nen riesen Müll zu bauen? ;-)