JNI中System.loadLibrary()与RegisterNatives()的区别及相关技术疑问

Great question! Let's break this down clearly to cover the differences, your core question about .exe/.cpp files, and possible workarounds.

These two serve entirely distinct roles in JNI, so it's key to separate their purposes:

• System.loadLibrary(): This is Java's way to load a compiled native library (like .dll on Windows, .so on Linux, .dylib on macOS) into the JVM's process memory. Its job is to make the native binary code available to the JVM. Without loading the library first, the JVM has no way to find the implementation of your native Java methods—by default, it relies on the standard JNI naming convention (e.g., Java_com_example_MyClass_myNativeMethod) to locate functions in the loaded library. In short, it's the entry point to get native code into the JVM.

• RegisterNatives(): This is a JNI function (called from native code) that lets you manually map Java native methods to specific C/C++ functions, bypassing the JVM's automatic name-based lookup. You typically call this inside the JNI_OnLoad function of your native library to bind methods explicitly. This is useful if you want custom function names, or need to dynamically adjust method bindings at runtime. Critically, though, it only works after the native library is loaded—both RegisterNatives() itself and the functions you're binding must exist in the JVM's process memory already.

Short answer: No, not directly. Here's why:

1. .cpp files are source code: The JVM can only execute compiled machine code, not human-readable source files. .cpp code must first be compiled into a binary library or executable before it can interact with JVM.
2. .exe files are separate processes: An .exe runs in its own independent process space, which is isolated from the JVM's process. RegisterNatives() can only bind functions that are already loaded into the JVM's process memory—you can't reach across process boundaries to call functions directly via JNI.

If you want to avoid shipping a standalone .dll, here are practical alternatives:

• Runtime JIT compilation of C/C++ code: Use a just-in-time compilation library (like GCC's libgccjit or Clang's JIT) to compile .cpp source code directly into machine memory at runtime. Once the code is in memory, you can use JNI's raw function pointer support to register it with RegisterNatives(). This is more complex, but eliminates the need for pre-compiled libraries.
• Embed native code as a resource: Compile your native code into a library, then package it as a resource inside your Java JAR. At runtime, extract the library to a temporary file and load it with System.load(), then use RegisterNatives() as usual. This hides the separate .dll from end-users, even though it's still loaded temporarily.
• Inter-process communication (IPC) with .exe: If you need to call an existing .exe, use IPC mechanisms like pipes, sockets, or shared memory to send requests from the JVM to the .exe process and receive results. This isn't direct function calling, but it lets you interact with the executable's functionality.

内容的提问来源于stack exchange，提问作者Sri vishnu Bharat