能否结合jaotc与jlink构建优化的Java运行时镜像？

Absolutely! You can absolutely combine jlink and jaotc to build a minimal runtime image that includes pre-compiled native code—solving both your goals of size optimization and faster, obfuscation-resistant execution. Let me break down the step-by-step workflow, and address the conflicting documentation pain points you’ve run into.

Step 1: Compile Your Java Code to Class Files #

First, make sure your application code is compiled into class files (or packaged as a modular JAR if you’re using modules). For a simple modular app:

javac -d build/classes --module-source-path src src/com/example/myapp/module-info.java src/com/example/myapp/MyApp.java

Step 2: Use jaotc to Generate Native Code Library #

jaotc compiles your Java code into a platform-specific shared library (.so on Linux, .dll on Windows, .dylib on macOS). You’ll need to point it to your compiled classes/modules and specify the output library:

jaotc \
  --module-path build/classes \
  --output libmyapp.so \
  --compile-for-tiered \
  --module com.example.myapp

• --compile-for-tiered: Ensures the native code works with the JVM’s tiered compilation (critical for ensuring the AOT code is actually used at runtime).
• If you’re working with a non-modular JAR, replace --module with --jar path/to/your-app.jar.

Step 3: Build the Minimal Runtime with jlink #

Now use jlink to package a trimmed JRE, and include the jaotc-generated native library using the --include-native-libs flag. You’ll also define a launcher for easy execution:

jlink \
  --module-path $JAVA_HOME/jmods:build/classes \
  --add-modules com.example.myapp \
  --output myapp-runtime \
  --include-native-libs libmyapp.so \
  --launcher run-app=com.example.myapp/com.example.MyApp

• --include-native-libs: This is the key flag that links your AOT library into the runtime image—most conflicting docs miss this step!
• Use jdeps first if you’re unsure which modules to include (to avoid over-trimming):

  jdeps --module-path build/classes --list-deps com.example.myapp
  

  Add the listed modules to --add-modules to ensure all dependencies are included.

Step 4: Test the Runtime Image #

Navigate to your generated image and run the launcher:

./myapp-runtime/bin/run-app

The JVM will automatically detect and use the pre-compiled native code, resulting in faster startup and class loading. You can verify AOT is working with:

./myapp-runtime/bin/java -XX:+PrintAOT -m com.example.myapp/com.example.MyApp

You’ll see logs confirming the AOT library is loaded.

Common Pitfalls to Avoid #

• Platform Lock-In: jaotc generates platform-specific libraries—you must build the library and runtime image on your target OS (cross-compilation support is limited).
• Module Path Mismatches: Ensure jaotc and jlink use the exact same module path, otherwise you’ll get class not found errors when loading the AOT library.
• Over-Trimming with jlink: If you exclude modules required by the AOT runtime (like java.base sub-components), the JVM won’t load your native code. Use jdeps to validate dependencies first.

内容的提问来源于stack exchange，提问作者Sooth