Kotlin/Native与JVM混合部署：性能优化与跨平台兼容性实现指南

plugins {
    kotlin("multiplatform") version "1.9.22" // 使用你的Kotlin版本
}

kotlin {
    // 定义JVM目标，用于纯JVM回退或JNI接口的Java部分
    jvm()

    // 定义Kotlin/Native目标
    // Linux x64
    linuxX64("nativeLinux") {
        binaries {
            sharedLib() // 编译为动态库 (.so)
        }
    }
    // macOS x64
    macosX64("nativeMac") {
        binaries {
            sharedLib() // 编译为动态库 (.dylib)
        }
    }
    // Windows x64
    mingwX64("nativeWin") {
        binaries {
            sharedLib() // 编译为动态库 (.dll)
        }
    }
    // ... 可以添加更多平台，如arm64

    sourceSets {
        val commonMain by getting {
            // 共享的Kotlin/Native代码
        }
        val nativeLinuxMain by getting {
            dependencies {
                // Linux特有的依赖
            }
        }
        val nativeMacMain by getting {
            dependencies {
                // macOS特有的依赖
            }
        }
        val nativeWinMain by getting {
            dependencies {
                // Windows特有的依赖
            }
        }
        // ... 为每个原生目标配置源集
    }
}

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;

public class NativeLibraryLoader {

    private static boolean nativeLibraryLoaded = false;

    // 声明一个或多个原生方法
    public static native String processDataNative(String input);

    static {
        try {
            loadNativeLibrary();
            nativeLibraryLoaded = true;
        } catch (UnsatisfiedLinkError | IOException e) {
            System.err.println("Failed to load native library: " + e.getMessage());
            // 如果原生库加载失败，则使用JVM回退逻辑
            nativeLibraryLoaded = false;
        }
    }

    private static void loadNativeLibrary() throws IOException {
        String osName = System.getProperty("os.name").toLowerCase();
        String osArch = System.getProperty("os.arch").toLowerCase();
        String libraryName = "my_native_lib"; // Kotlin/Native模块名，对应生成的库文件前缀

        String resourcePath;
        String fileName;

        if (osName.contains("win")) {
            resourcePath = "natives/windows/" + osArch + "/";
            fileName = libraryName + ".dll";
        } else if (osName.contains("mac")) {
            resourcePath = "natives/macos/" + osArch + "/";
            fileName = "lib" + libraryName + ".dylib";
        } else if (osName.contains("nix") || osName.contains("linux")) {
            resourcePath = "natives/linux/" + osArch + "/";
            fileName = "lib" + libraryName + ".so";
        } else {
            throw new UnsatisfiedLinkError("Unsupported operating system: " + osName);
        }

        InputStream in = NativeLibraryLoader.class.getClassLoader().getResourceAsStream(resourcePath + fileName);
        if (in == null) {
            throw new UnsatisfiedLinkError("Native library resource not found: " + resourcePath + fileName);
        }

        // 将原生库从JAR包中提取到临时文件，然后加载
        Path tempDir = Files.createTempDirectory("native_libs");
        File tempFile = tempDir.resolve(fileName).toFile();
        Files.copy(in, tempFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
        in.close();

        System.load(tempFile.getAbsolutePath()); // 使用System.load加载绝对路径
        // 或者如果库已经位于系统路径或java.library.path中，可以使用 System.loadLibrary(libraryName);

        // 确保临时文件在JVM退出时被删除
        tempFile.deleteOnExit();
        tempDir.toFile().deleteOnExit();
    }

    public static boolean isNativeLibraryLoaded() {
        return nativeLibraryLoaded;
    }

    // JVM 回退实现
    public static String processDataJvm(String input) {
        System.out.println("Using JVM fallback implementation.");
        // 这里是纯Java的逻辑
        return "JVM processed: " + input.toUpperCase();
    }

    public static String processData(String input) {
        if (isNativeLibraryLoaded()) {
            try {
                return processDataNative(input);
            } catch (UnsatisfiedLinkError e) {
                System.err.println("Error calling native method, falling back to JVM: " + e.getMessage());
                return processDataJvm(input);
            }
        } else {
            return processDataJvm(input);
        }
    }
}