Java Native Interface (JNI)

The Java Native Interface (JNI) is a framework that allows Java code running in the Java Virtual Machine (JVM) to call and be called by native applications and libraries written in other languages such as C, C++, and assembly. This enables Java applications to leverage platform-specific features and libraries, enhancing performance and functionality.

2.1 JNI Basics

• JNI provides a way to interact with native libraries.
• It enables Java applications to utilize platform-specific features.
• JNI is primarily used for performance-critical operations.

2.2 JNI Functions

JNI provides various functions categorized into:

1. Functions to load and manage native libraries.
2. Functions to call native methods.
3. Functions to manipulate Java objects and types.

The JNI architecture consists of two main sides:

• Java Side: Where Java code is compiled into bytecode and executed by the JVM.
• Native Side: Where native code (C/C++) is compiled into a native library.

The two sides communicate through JNI calls.

graph TD;
    A[Java Application] -->|Calls| B[JNI]
    B -->|Calls| C[Native Library]
    C -->|Returns| B
    B -->|Returns| A
            

4.1 Creating a Simple JNI Example

1. Create a Java Class with a Native Method:

public class HelloWorld {
    static {
        System.loadLibrary("helloworld");
    }

    public native void sayHello();

    public static void main(String[] args) {
        new HelloWorld().sayHello();
    }
}
            

2. Create the Native Method Implementation in C:

#include 
#include 
#include "HelloWorld.h"

JNIEXPORT void JNICALL Java_HelloWorld_sayHello(JNIEnv *env, jobject obj) {
    printf("Hello from C!\n");
}
            

3. Compile and Run the Example:

1. Compile the Java code: javac HelloWorld.java
2. Generate header file: javah HelloWorld
3. Compile the C code: gcc -shared -o libhelloworld.so -I${JAVA_HOME}/include -I${JAVA_HOME}/include/linux HelloWorld.c
4. Run the Java application: java HelloWorld

• Minimize JNI calls: Each call has overhead; batch operations where possible.
• Use JNI for performance-critical code: Avoid using JNI for general application logic.
• Handle exceptions: Ensure that exceptions in native code are properly handled.
• Keep native code separate: Maintain clear boundaries between Java and native code.