能否将多平台Kotlin Native可执行文件打包进JAR并集成JVM实现作为备用方案？

核心思路是通过Kotlin Multiplatform拆分核心逻辑，同时提供Native高性能实现和JVM兼容实现，再通过Gradle将所有资源打包进主JAR，最后在运行时自动适配平台，失败则 fallback 到JVM版本。

1. 项目结构拆分 #

将项目拆分为3个模块，职责明确：

• app-jvm：Java主应用模块，负责业务流程和运行时的Native/JVM适配
• audio-core：Kotlin Multiplatform模块，包含音频编解码/网络通信的核心逻辑，同时实现Native高性能版本和JVM fallback版本

目录结构示例：

your-project/
├── app-jvm/
│   ├── build.gradle
│   └── src/main/java/
├── audio-core/
│   ├── build.gradle
│   └── src/
│       ├── commonMain/       # 定义通用业务接口
│       ├── jvmMain/          # JVM平台兼容实现
│       └── nativeMain/       # Kotlin Native高性能实现
│           ├── linuxX64Main/
│           ├── macosX64Main/
│           └── mingwX64Main/
└── settings.gradle

2. 配置Kotlin Multiplatform模块（audio-core/build.gradle） #

定义通用接口，分别实现JVM和Native版本：

plugins {
    id 'org.jetbrains.kotlin.multiplatform' version '1.9.20'
}

kotlin {
    // JVM目标
    jvm()
    
    // 按需添加支持的Native平台
    linuxX64('nativeLinux')
    macosX64('nativeMacX64')
    macosArm64('nativeMacArm64')
    mingwX64('nativeWindows')

    sourceSets {
        commonMain.dependencies {
            implementation kotlin('stdlib-common')
        }
        
        jvmMain.dependencies {
            implementation kotlin('stdlib-jdk8')
        }
        
        // 通用Native逻辑
        nativeMain {
            dependsOn commonMain
        }
        // 各平台Native源集继承通用逻辑
        nativeLinuxMain.dependsOn nativeMain
        nativeMacX64Main.dependsOn nativeMain
        nativeMacArm64Main.dependsOn nativeMain
        nativeWindowsMain.dependsOn nativeMain
    }
    
    // 编译Native为共享库，统一输出目录
    targets.withType(org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget) {
        binaries.sharedLib {
            baseName = 'audio-core'
            outputDirectory = file("$projectDir/build/native-libs/${target.name}")
        }
    }
}

核心代码实现 #

在commonMain/kotlin/com/example/AudioCodec.kt定义通用接口：

interface AudioCodec {
    fun encode(rawAudio: ByteArray): ByteArray
    fun decode(encodedAudio: ByteArray): ByteArray
    fun init(config: CodecConfig)
}

data class CodecConfig(val sampleRate: Int, val bitRate: Int)

在jvmMain/kotlin/com/example/JvmAudioCodec.kt实现JVM fallback：

class JvmAudioCodec : AudioCodec {
    override fun encode(rawAudio: ByteArray): ByteArray {
        // JVM平台兼容实现（如调用Java音频API）
        return rawAudio
    }

    override fun decode(encodedAudio: ByteArray): ByteArray {
        return encodedAudio
    }

    override fun init(config: CodecConfig) {
        // 初始化逻辑
    }
}

在nativeMain/kotlin/com/example/NativeAudioCodec.kt实现Native高性能版本：

class NativeAudioCodec : AudioCodec {
    override fun encode(rawAudio: ByteArray): ByteArray {
        // Kotlin Native高性能实现（直接调用系统原生API或依赖库）
        return rawAudio
    }

    override fun decode(encodedAudio: ByteArray): ByteArray {
        return encodedAudio
    }

    override fun init(config: CodecConfig) {
        // 初始化逻辑
    }
}

// 暴露给JVM的工厂类
object NativeAudioCodecFactory {
    @JvmStatic
    fun create(config: CodecConfig): AudioCodec {
        return NativeAudioCodec().apply { init(config) }
    }
}

3. 配置主JVM应用模块（app-jvm/build.gradle） #

依赖Multiplatform模块，并将Native库打包进主JAR：

plugins {
    id 'java'
    id 'application'
}

repositories {
    mavenCentral()
}

dependencies {
    implementation project(':audio-core')
    implementation kotlin('stdlib-jdk8')
}

application {
    mainClass = 'com.example.MainApp'
}

// 复制Native库到资源目录，打包时自动进JAR
task copyNativeLibs(type: Copy) {
    from project(':audio-core').fileTree('build/native-libs')
    into 'src/main/resources/native-libs'
}

processResources.dependsOn copyNativeLibs

4. 运行时适配逻辑（Java代码） #

在Java主应用中自动加载对应平台的Native库，失败则切换到JVM实现：

package com.example;

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

public class AudioCodecLoader {
    private static final String NATIVE_LIB_BASE = "/native-libs/";

    public static AudioCodec loadCodec(CodecConfig config) {
        String os = System.getProperty("os.name").toLowerCase();
        String arch = System.getProperty("os.arch").toLowerCase();
        String libPath = getNativeLibPath(os, arch);

        if (libPath != null) {
            try {
                // 提取JAR中的Native库到临时目录（JVM无法直接加载JAR内的原生库）
                File tempLib = extractNativeLib(libPath);
                System.load(tempLib.getAbsolutePath());
                return NativeAudioCodecFactory.create(config);
            } catch (Exception e) {
                System.err.println("加载Native编解码器失败，切换到JVM实现：" + e.getMessage());
            }
        }

        return new JvmAudioCodec();
    }

    private static String getNativeLibPath(String os, String arch) {
        if (os.contains("linux")) {
            return arch.contains("64") ? NATIVE_LIB_BASE + "nativeLinux/libaudio-core.so" : null;
        } else if (os.contains("mac")) {
            return arch.contains("aarch64") 
                ? NATIVE_LIB_BASE + "nativeMacArm64/libaudio-core.dylib" 
                : NATIVE_LIB_BASE + "nativeMacX64/libaudio-core.dylib";
        } else if (os.contains("windows")) {
            return arch.contains("64") ? NATIVE_LIB_BASE + "nativeWindows/audio-core.dll" : null;
        }
        return null;
    }

    private static File extractNativeLib(String resourcePath) throws IOException {
        File tempFile = File.createTempFile("audio-core", getLibExtension());
        tempFile.deleteOnExit();
        Files.copy(AudioCodecLoader.class.getResourceAsStream(resourcePath), tempFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
        return tempFile;
    }

    private static String getLibExtension() {
        String os = System.getProperty("os.name").toLowerCase();
        if (os.contains("linux")) return ".so";
        else if (os.contains("mac")) return ".dylib";
        else if (os.contains("windows")) return ".dll";
        return "";
    }
}

5. 打包主JAR #

执行命令./gradlew app-jvm:jar，生成的主JAR会包含：

• Java主应用代码
• audio-core的JVM类文件
• 所有平台的Native共享库（存放在native-libs/目录下）

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