JNI erm?glicht es dem Java -Code, mit dem in C/C und anderen Sprachen geschriebenen lokalen Code zu interagieren und ihn als freigegebene Bibliothek zu implementieren, indem native Methoden deklariert, Header -Dateien generiert, C als freigegebene Bibliothek geschrieben und zusammengestellt werden, die Bibliothek geladen und das Programm ausgeführt werden, um Anrufe zu erzielen. 2. Die Daten werden zwischen Java und lokalen Typen durch JNI -Funktionen wie JString und char*konvertiert. 3. Lokaler Code kann Java -Methoden zurückrufen, und Sie müssen Klassenreferenzen, Methoden -IDs erhalten und Funktionen wie CallvoidMethod verwenden. 4. Achten Sie bei der Verwendung von Spezifikationen, Ausnahmegem??ungen, Speicherverwaltung, Thread -Sicherheit und Leistungsaufwand bei der Verwendung; 5. Es ist geeignet, um auf Systemressourcen zuzugreifen, native Bibliotheken wiederzuverwenden oder die Leistung zu verbessern. Es sollte jedoch vermieden werden, wenn reine Java die Portabilit?t l?sen oder betonen kann. JNI ist ein leistungsstarkes, aber vorsichtiges Werkzeug, und die korrekte Anwendung kann die Java -Funktionen erheblich erweitern.

Mit der Java Native Interface (JNI) k?nnen Java -Code, die in der Java Virtual Machine (JVM) ausgeführt werden, mit nativen Anwendungen und Bibliotheken in anderen Sprachen wie C, C oder Montage interagieren. Dies ist nützlich, wenn Sie auf Ressourcen auf Systemebene zugreifen, vorhandenen nativen Code nutzen oder die Leistung für rechnerische intensive Aufgaben verbessern müssen.

W?hrend Java als plattformunabh?ngig ausgelegt ist, führt JNI plattformspezifische Abh?ngigkeiten ein-aber Sie erhalten bei Bedarf eine leistungsstarke Kontrolle auf niedriger Ebene.

Lassen Sie uns die Funktionsweise von JNI Schritt für Schritt mit einem praktischen Beispiel aufschlüsseln.

? Wie JNI funktioniert: Das gro?e Bild

JNI fungiert als Brücke zwischen Java und dem nativen Code:

1. Java ruft native Methoden auf, die mit dem native Schlüsselwort deklariert wurden.
2. Das JVM l?dt eine gemeinsame Bibliothek ( .dll unter Windows, .so unter Linux, .dylib auf macOS).
3. Der native Code implementiert diese Methoden , typischerweise in c/c.
4. Die Daten werden zwischen Java und nativen Typen mit JNI -Funktionen konvertiert .
5. Optional kann der native Code in Java -Methoden zurückrufen .

?? Verwenden Sie JNI sorgf?ltig - es umgeht JVM -Sicherheitsfunktionen wie Müllsammlung und Sicherheitskontrollen.

Schritt-für-Schritt

Wir erstellen ein einfaches Programm, bei dem Java eine C -Funktion aufruft, die eine Zeichenfolge zurückgibt.

1. Schreiben Sie die Java -Klasse

 // HelloWorld.java
?ffentliche Klasse Helloworld {
    // native Methode deklarieren
    ?ffentliche native String Sayshello ();

    // Native Bibliothek laden
    statisch {
        System.loadlibrary ("Hallo"); // l?dt libhello.so (linux), hello.dll (Windows) oder libhello.dylib (macOS)
    }

    public static void main (String [] args) {
        HelloWorld hw = new HelloWorld ();
        System.out.println (hw.sayhello ());
    }
}

Kompilieren Sie es:

 Javac HelloWorld.java

Dies erzeugt HelloWorld.class .

2. Generieren Sie die Header -Datei mit javah (veraltet) oder javac -h

Seit JDK 8 ist javah veraltet. Verwenden:

 Javac -h. HelloWorld.java

Dies generiert eine Header -Datei: HelloWorld.h , die aussieht:

 / * Bearbeiten Sie diese Datei nicht - sie ist maschinell generiert */
#include <Jni.h>
/ * Header für die Klasse HelloWorld */

#ifndef _included_helloworld
#define _included_helloworld
#ifdef __cplusplus
extern "c" {
#endif

/*
 * Klasse: HelloWorld
 * Methode: Sayhello
 * Signatur: () ljava/lang/String;
 */
Jniexport jstring jnicall java_helloworld_sayhello
  (Jnienv *, Job);

#ifdef __cplusplus
}
#endif
#endif

Notiz:

• Java_HelloWorld_sayHello ist die erforderliche Namenskonvention.
• JNIEnv* ist der Schnittstellenzeiger für den Zugriff auf JNI -Funktionen.
• jobject beziehen sich auf die Instanz des HelloWorld -Objekts.

3. Implementieren Sie die native Methode in C.

Erstellen Sie HelloWorld.c :

 #include <Jni.h>
#include "helloWorld.h"
#include <string.h>

Jniexport jstring jnicall java_helloworld_sayhello
  (Jnienv *env, Job obj) {
    return (*env)-> newStingutf (env, "Hallo von c via jni!");
}

Hier:

• Wir verwenden (*env)->NewStringUTF() um eine C-String ( char* ) in einen jstring umzuwandeln.
• Alle JNI -Funktionen werden über den JNIEnv -Zeiger zugegriffen.

4. Kompilieren Sie den C -Code in eine gemeinsam genutzte Bibliothek

Auf Linux/macOS:

 gcc -fpic -i "$ {java_home}/include" -i "$ {java_home}/include/linux" \
    -Shared -o libhello.so helloWorld.c

Ersetzen /linux durch /darwin auf MacOS.

Unter Windows (mit Mingw oder MSVC):

 GCC -i "%Java_Home%\ include" -i "%Java_Home%\ include \ win32" 
    -Shared -o hello.dll helloWorld.c

Stellen Sie sicher, dass die Ausgabe übereinstimmt, was System.loadLibrary() erwartet:

• Linux: libhello.so
• Windows: hello.dll
• macos: libhello.dylib

5. Führen Sie das Programm aus

Stellen Sie sicher, dass sich die gemeinsame Bibliothek im Bibliotheksweg befindet:

 Java -djava.library.Path =. HelloWorld

Ausgabe:

 Hallo von C über JNI!

? Erfolg! Java nannte Ihre C -Funktion.

? Datentypen übergeben und zurückgeben

JNI unterstützt verschiedene Datentypkonvertierungen.

Beispiel: Fügen Sie zwei Ganzzahlen in C hinzu

Java:

 ?ffentliche Klasse Mathhlib {
    ?ffentliche native int add (int a, int b);
    statisch {
        System.loadlibrary ("math");
    }
    public static void main (String [] args) {
        Mathlib ml = neuer mathhlib ();
        System.out.println ("5 7 =" ml.add (5, 7));
    }
}

C Implementierung ( MathLib.c ):

 #include <Jni.h>
#include "mathhlib.h"

Jniexport jint jnicall java_mathlib_add
  (Jnienv *env, Job obj, jint a, jint b) {
    Rückkehr AB;
}

Gleiche Kompilierungsschritte gelten.

? Zugriff auf Java -Felder und -Methoden aus dem nativen Code

Native Code kann auch in Java zurückrufen .

Beispiel: Rufen Sie eine Java -Methode von C. an C.

Java:

 ?ffentliche Klassen Callbackexample {
    privater Int -Wert = 42;

    public void printValue () {
        System.out.println ("Wert aus Java:" Wert);
    }

    ?ffentliche native void CallPrintValue ();

    statisch {
        System.loadLibrary ("Rückruf");
    }

    public static void main (String [] args) {
        new Callbackexample (). CallPrintValue ();
    }
}

C Implementierung:

 #include <Jni.h>
#Include "callbackexample.h"

Jniexport void jnicall java_callbackexample_callprintvalue
  (Jnienv *env, Job obj) {

    // die Klasse bekommen
    jclass cls = (*env)-> getObjectClass (env, obj);

    // Die Methoden -ID finden
    JMethodid Mid = (*env)-> getMethodid (env, cls, "printValue", "() v");
    if (Mid == null) return; // Methode nicht gefunden

    // rufen Sie die Java -Methode an
    (*env)-> callvoidMethod (env, obj, mid);
}

Signatur "()V" bedeutet: keine Argumente, Rückgabe void.

Kompilieren Sie neu und rennen Sie → Ausgabe:

 Wert aus Java: 42

Sie haben gerade eine Java -Methode anrufen!

?? H?ufige Fallstricke und Best Practices

• Namenskonvention : Native Method -Namen müssen Java_PackageName_ClassName_MethodName folgen.
• Ausnahmebehandlung : überprüfen Sie immer Ausnahmen nach kritischen JNI-Aufrufen unter Verwendung von (*env)->ExceptionCheck() oder ExceptionOccurred() .
• Speicherverwaltung : Lokale Referenzen, die im nativen Code erstellt wurden, werden automatisch aufger?umt, sofern nicht festgehalten. Vermeiden Sie Speicherlecks.
• Fadensicherheit : JNIEnv ist Thread-lokal. Teile es nicht über Threads.
• Leistung : Das überqueren der JNI -Grenze hat Overhead. Minimieren Sie h?ufig Aufrufe.
• Portabilit?t : Native Bibliotheken sind Betriebssystem-/Architekturspezifische. M?glicherweise ben?tigen Sie mehrere Builds.

? Wann sollten Sie JNI verwenden?

Verwenden Sie JNI, wenn:

• Schnittstelle mit Hardware- oder Betriebssystem -APIs (z. B. Ger?tetreiber).
• Wiederverwenden von Legacy C/C -Codebasen.
• Leistungskritische Abschnitte (z. B. Mathematik, Bildverarbeitung).
• Integration in native Bibliotheken (OpenCV, OpenSSL usw.).

Vermeiden Sie JNI, wenn:

• Es gibt reine Java -L?sungen.
• Portabilit?t ist der Schlüssel.
• Einfachheit und Hauptverwaltung sind wichtiger als Geschwindigkeit.

Zusammenfassung

JNI erm?glicht eine leistungsstarke Integration zwischen Java und nativem Code. Mit nur wenigen Schritten - deklarieren Sie native Methoden, generieren Sie Header, schreiben Sie C -Code, kompilieren Sie sie in die gemeinsame Bibliothek und laden Sie sie - Sie k?nnen die Funktionen von Java über die JVM hinaus erweitern.

Es ist nicht etwas, das Sie jeden Tag verwenden, aber wenn Sie es brauchen, ist es unverzichtbar.

Grunds?tzlich ?ffnet JNI die Tür - seien Sie einfach vorsichtig, was Sie durchbringen.

Das obige ist der detaillierte Inhalt vonJava Native Interface (JNI) mit Beispielen erkl?rt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!