JNI allows Java code to interact with local code written in C/C and other languages, and implement it as a shared library by declaring native methods, generating header files, writing and compiling C as a shared library, loading the library and running the program to achieve calls; 2. Data is converted between Java and local types through JNI functions, such as jstring and char*; 3. Local code can call back Java methods, and you need to obtain class references, method IDs and use functions such as CallVoidMethod; 4. Pay attention to naming specifications, exception checking, memory management, thread safety and performance overhead when using them; 5. It is suitable for accessing system resources, reusing native libraries or improving performance, but it should be avoided when pure Java can solve or emphasize portability; JNI is a powerful but cautious tool, and correct application can significantly expand Java capabilities.

Java Native Interface (JNI) allows Java code running in the Java Virtual Machine (JVM) to interact with native applications and libraries written in other languages such as C, C , or assembly. This is useful when you need to access system-level resources, leverage existing native code, or improve performance for computationally intense tasks.

While Java is designed to be platform-independent, JNI introduces platform-specific dependencies — but it gives you powerful low-level control when needed.

Let's break down how JNI works, step by step, with a practical example.

? How JNI Works: The Big Picture

JNI acts as a bridge between Java and native code:

1. Java calls native methods declared with the native keyword.
2. The JVM loads a shared library ( .dll on Windows, .so on Linux, .dylib on macOS).
3. The native code implements those methods , typically in C/C .
4. Data is converted between Java and native types using JNI functions.
5. Optionally, native code can call back into Java methods .

?? Use JNI carefully — it bypasses JVM safety features like garbage collection and security checks.

?? Step-by-Step Example: Calling C from Java

We'll create a simple program where Java calls a C function that returns a string.

1. Write the Java Class

 // HelloWorld.java
public class HelloWorld {
    // Declare native method
    public native String saysHello();

    // Load native library
    static {
        System.loadLibrary("hello"); // Loads libhello.so (Linux), hello.dll (Windows), or libhello.dylib (macOS)
    }

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

Compile it:

 javac HelloWorld.java

This generates HelloWorld.class .

2. Generate Header File Using javah (Deprecated) or javac -h

Since JDK 8, javah is deprecated. Use:

 javac -h . HelloWorld.java

This generates a header file: HelloWorld.h , which looks like:

 /* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class HelloWorld */

#ifndef _Included_HelloWorld
#define _Included_HelloWorld
#ifdef __cplusplus
extern "C" {
#endif

/*
 * Class: HelloWorld
 * Method: sayHello
 * Signature: ()Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_HelloWorld_sayHello
  (JNIEnv *, job);

#ifdef __cplusplus
}
#endif
#endif

Note:

• Java_HelloWorld_sayHello is the required naming convention.
• JNIEnv* is the interface pointer to access JNI functions.
• jobject refer to the instance of the HelloWorld object.

3. Implement the Native Method in C

Create HelloWorld.c :

 #include <jni.h>
#include "HelloWorld.h"
#include <string.h>

JNIEXPORT jstring JNICALL Java_HelloWorld_sayHello
  (JNIEnv *env, job obj) {
    return (*env)->NewStringUTF(env, "Hello from C via JNI!");
}

Here:

• We use (*env)->NewStringUTF() to convert a C string ( char* ) to a jstring .
• All JNI functions are accessed through the JNIEnv pointer.

4. Compile the C Code into a Shared Library

On Linux/macOS:

 gcc -fPIC -I"${JAVA_HOME}/include" -I"${JAVA_HOME}/include/linux" \
    -shared -o libhello.so HelloWorld.c

Replace /linux with /darwin on macOS.

On Windows (using MinGW or MSVC):

 gcc -I"%JAVA_HOME%\include" -I"%JAVA_HOME%\include\win32" 
    -shared -o hello.dll HelloWorld.c

Make sure the output matches what System.loadLibrary() expects:

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

5. Run the Program

Ensure the shared library is in the library path:

 java -Djava.library.path=. HelloWorld

Output:

 Hello from C via JNI!

? Success! Java called your C function.

? Passing and Returning Data Types

JNI supports various data type conversions.

Example: Add Two Integers in C

Java:

 public class MathLib {
    public native int add(int a, int b);
    static {
        System.loadLibrary("math");
    }
    public static void main(String[] args) {
        MathLib ml = new MathLib();
        System.out.println("5 7 = " ml.add(5, 7));
    }
}

C implementation ( MathLib.c ):

 #include <jni.h>
#include "MathLib.h"

JNIEXPORT jint JNICALL Java_MathLib_add
  (JNIEnv *env, job obj, jint a, jint b) {
    return ab;
}

Same compilation steps apply.

? Accessing Java Fields and Methods from Native Code

Native code can also call back into Java .

Example: Call a Java method from C.

Java:

 public class CallbackExample {
    private int value = 42;

    public void printValue() {
        System.out.println("Value from Java: " value);
    }

    public native void callPrintValue();

    static {
        System.loadLibrary("callback");
    }

    public static void main(String[] args) {
        new CallbackExample().callPrintValue();
    }
}

C implementation:

 #include <jni.h>
#include "CallbackExample.h"

JNIEXPORT void JNICALL Java_CallbackExample_callPrintValue
  (JNIEnv *env, job obj) {

    // Get the class
    jclass cls = (*env)->GetObjectClass(env, obj);

    // Find the method ID
    jmethodID mid = (*env)->GetMethodID(env, cls, "printValue", "()V");
    if (mid == NULL) return; // method not found

    // Call the Java method
    (*env)->CallVoidMethod(env, obj, mid);
}

Signature "()V" means: no arguments, returns void.

Recompile and run → Output:

 Value from Java: 42

You've just made C call a Java method!

?? Common Pitfalls & Best Practices

• Naming Convention : Native method names must follow Java_PackageName_ClassName_MethodName .
• Exception Handling : Always check for exceptions after critical JNI calls using (*env)->ExceptionCheck() or ExceptionOccurred() .
• Memory Management : Local references created in native code are automatically cleaned up unless pinned. Avoid memory leaks.
• Thread Safety : JNIEnv is thread-local. Don't share it across threads.
• Performance : Crossing the JNI boundary has overhead. Minimize frequently calls.
• Portability : Native libraries are OS/architecture-specific. You may need multiple builds.

? When Should You Use JNI?

Use JNI when:

• Interfacing with hardware or OS APIs (eg, device drivers).
• Reusing legacy C/C codebases.
• Performance-critical sections (eg, math, image processing).
• Integrating with native libraries (OpenCV, OpenSSL, etc.).

Avoid JNI when:

• Pure Java solutions exist.
• Portability is key.
• Simplicity and maintenanceability matter more than speed.

Summary

JNI enables powerful integration between Java and native code. With just a few steps — declare native methods, generate headers, write C code, compile to shared library, and load it — you can extend Java's capabilities beyond the JVM.

It's not something you use every day, but when you need it, it's indispensable.

Basically, JNI opens the door — just be careful what you bring through.

The above is the detailed content of Java Native Interface (JNI) Explained with Examples. For more information, please follow other related articles on the PHP Chinese website!