Calling Native Libraries From Java

  • 29/4/2020
  • 2-minute read

When you need to call native libraries from Java, there are several approaches available. Let’s explore each option with its pros and cons.

Java Native Interface (JNI)

The classic approach to calling native code. JNI allows Java code to call and be called by native applications and libraries written in other languages like C, C++, and Assembly.

public class NativeExample {
    static {
        System.loadLibrary("native_lib");
    }

    private native void nativeMethod();
}

Pros:

  • Direct integration with native code
  • High performance
  • Well-documented

Cons:

  • Complex implementation
  • Potential segmentation faults
  • Platform-dependent code

Project Panama

A promising OpenJDK project that aims to improve and simplify native code interoperability.

import jdk.incubator.foreign.*;

public class PanamaExample {
    public static void main(String[] args) {
        try (Arena arena = Arena.openConfined()) {
            MemorySegment cString = arena.allocateUtf8String("Hello");
            // Call native function
        }
    }
}

Pros:

  • Modern API design
  • Better memory safety
  • Simplified native access

Cons:

  • Early access/preview feature
  • API may change
  • Limited platform support

GraalVM

A universal virtual machine that supports multiple languages and native image compilation.

@CLibrary("mylib")
interface NativeLib {
    @CFunction
    int native_function(int value);
}

Pros:

  • Multiple language support
  • Native image compilation
  • Better performance

Cons:

  • Learning curve
  • Build complexity
  • Community still growing

zt-exec

A simple solution for executing external processes from Java.

new ProcessExecutor().command("native-program", "arg1", "arg2")
    .redirectOutput(System.out)
    .execute();

Pros:

  • Simple implementation
  • Process isolation
  • Cross-platform

Cons:

  • Higher overhead
  • Limited interaction
  • Process startup cost

RemoteTea RPC

Useful for legacy systems, especially when dealing with older C++ code.

OncRpcClient client = new OncRpcClient(host, program, version);
XdrAble result = client.call(procedureNumber, params);

Pros:

  • Works with legacy systems
  • Network transparency
  • Stable API

Cons:

  • Dated technology
  • Limited maintainance
  • Performance overhead

Conclusion

Choose your approach based on your specific needs:

  • Use JNI for performance-critical native integration
  • Consider Panama for modern native interop
  • Try GraalVM for polyglot applications
  • Pick zt-exec for simple process execution
  • Use RemoteTea for legacy RPC systems

Remember to consider factors like maintenance, performance, and platform compatibility when making your choice.

java