如何通过JNA为带多返回值的Go函数编写Java接口？

这个问题的核心在于C语言（JNA基于C调用约定）不支持多返回值，而Go的//export指令本质是生成兼容C的函数接口，所以直接导出多返回值的Go函数没法被JNA正确识别。下面提供两种最常用的解决方案，附带完整的代码示例和注意事项：

方案1：用结构体封装多个返回值 #

把两个返回值打包成一个C兼容的结构体，让Go函数返回这个结构体，然后Java用JNA的Structure类映射该结构体，就能一次性获取所有返回值。

步骤1：修改Go代码，导出返回结构体的函数 #

首先定义一个和C兼容的结构体（注意字段类型要匹配C的类型），然后在导出函数中生成密钥并封装到结构体里：

// #include <stdint.h>
import "C"
import "unsafe"

// 定义C兼容的密钥对结构体
type KeyPair struct {
    PrivateKey   *C.uchar // 对应C的unsigned char*
    PrivateKeyLen C.int    // 密钥长度
    PublicKey    *C.uchar
    PublicKeyLen C.int
}

// 实际生成密钥的内部函数
func actualGenerateKeys() ([]byte, []byte) {
    // 这里替换成你的密钥生成逻辑
    priv := []byte("test-private-key")
    pub := []byte("test-public-key")
    return priv, pub
}

//export generateKeys
func generateKeys() C.struct_KeyPair {
    privBytes, pubBytes := actualGenerateKeys()

    // 把Go字节数组转成C可访问的指针和长度
    // 注意：这里用C.malloc分配内存，后续需要手动释放，避免Go GC误回收
    cPriv := (*C.uchar)(C.malloc(C.size_t(len(privBytes))))
    C.memcpy(unsafe.Pointer(cPriv), unsafe.Pointer(&privBytes[0]), C.size_t(len(privBytes)))
    cPrivLen := C.int(len(privBytes))

    cPub := (*C.uchar)(C.malloc(C.size_t(len(pubBytes))))
    C.memcpy(unsafe.Pointer(cPub), unsafe.Pointer(&pubBytes[0]), C.size_t(len(pubBytes)))
    cPubLen := C.int(len(pubBytes))

    return C.struct_KeyPair{
        PrivateKey:   cPriv,
        PrivateKeyLen: cPrivLen,
        PublicKey:    cPub,
        PublicKeyLen: cPubLen,
    }
}

//export freeKeyPair
func freeKeyPair(pair *C.struct_KeyPair) {
    // 释放C.malloc分配的内存
    C.free(unsafe.Pointer(pair.PrivateKey))
    C.free(unsafe.Pointer(pair.PublicKey))
}

步骤2：Java中映射结构体和调用接口 #

用JNA的Structure类映射Go的结构体，然后定义调用接口：

import com.sun.jna.Library;
import com.sun.jna.Native;
import com.sun.jna.Pointer;
import com.sun.jna.Structure;
import java.util.Arrays;
import java.util.List;

// 映射Go的KeyPair结构体
public class KeyPair extends Structure {
    public Pointer privateKey;
    public int privateKeyLen;
    public Pointer publicKey;
    public int publicKeyLen;

    @Override
    protected List<String> getFieldOrder() {
        // 必须和Go结构体的字段顺序完全一致
        return Arrays.asList("privateKey", "privateKeyLen", "publicKey", "publicKeyLen");
    }
}

// JNA调用接口
public interface GoKeyLibrary extends Library {
    GoKeyLibrary INSTANCE = Native.load("keys", GoKeyLibrary.class); // 替换成你的库文件名（不带后缀）

    KeyPair generateKeys();
    void freeKeyPair(KeyPair pair); // 释放Go分配的内存
}

// 调用示例
public class Main {
    public static void main(String[] args) {
        KeyPair pair = null;
        try {
            pair = GoKeyLibrary.INSTANCE.generateKeys();
            // 把Pointer转成Java字节数组
            byte[] privateKey = pair.privateKey.getByteArray(0, pair.privateKeyLen);
            byte[] publicKey = pair.publicKey.getByteArray(0, pair.publicKeyLen);

            System.out.println("Private Key: " + new String(privateKey));
            System.out.println("Public Key: " + new String(publicKey));
        } finally {
            // 必须释放内存，避免泄漏
            if (pair != null) {
                GoKeyLibrary.INSTANCE.freeKeyPair(pair);
            }
        }
    }
}

方案2：用输出参数（指针）传递结果 #

模拟C语言的"out参数"模式，让Java传入缓冲区，Go把密钥数据写入缓冲区，同时返回实际长度。这种方式不需要额外的内存释放（缓冲区由Java管理）。

步骤1：修改Go代码，使用输出参数 #

// #include <stdint.h>
#include <string.h>
import "C"
import "unsafe"

func actualGenerateKeys() ([]byte, []byte) {
    priv := []byte("test-private-key")
    pub := []byte("test-public-key")
    return priv, pub
}

//export generateKeys
// 返回值：0=成功，-1=缓冲区不足（此时会返回实际需要的长度）
func generateKeys(
    privateKeyBuf *C.uchar, privateKeyMaxLen C.int, privateKeyActualLen *C.int,
    publicKeyBuf *C.uchar, publicKeyMaxLen C.int, publicKeyActualLen *C.int,
) C.int {
    privBytes, pubBytes := actualGenerateKeys()
    privLen := C.int(len(privBytes))
    pubLen := C.int(len(pubBytes))

    // 先检查缓冲区是否足够，不足则返回需要的长度
    *privateKeyActualLen = privLen
    *publicKeyActualLen = pubLen
    if privLen > privateKeyMaxLen || pubLen > publicKeyMaxLen {
        return -1
    }

    // 复制数据到Java传入的缓冲区
    C.memcpy(unsafe.Pointer(privateKeyBuf), unsafe.Pointer(&privBytes[0]), C.size_t(privLen))
    C.memcpy(unsafe.Pointer(publicKeyBuf), unsafe.Pointer(&pubBytes[0]), C.size_t(pubLen))
    return 0
}

步骤2：Java中调用接口 #

import com.sun.jna.Library;
import com.sun.jna.Native;
import com.sun.jna.Memory;
import com.sun.jna.Pointer;
import com.sun.jna.ptr.IntByReference;

public interface GoKeyLibrary extends Library {
    GoKeyLibrary INSTANCE = Native.load("keys", GoKeyLibrary.class);

    int generateKeys(
        Pointer privateKeyBuf, int privateKeyMaxLen, IntByReference privateKeyActualLen,
        Pointer publicKeyBuf, int publicKeyMaxLen, IntByReference publicKeyActualLen
    );
}

// 调用示例
public class Main {
    public static void main(String[] args) {
        // 第一步：获取密钥需要的长度
        IntByReference privLenRef = new IntByReference();
        IntByReference pubLenRef = new IntByReference();
        int result = GoKeyLibrary.INSTANCE.generateKeys(null, 0, privLenRef, null, 0, pubLenRef);
        if (result != -1) {
            System.err.println("Unexpected result when getting key lengths");
            return;
        }
        int privLen = privLenRef.getValue();
        int pubLen = pubLenRef.getValue();

        // 第二步：分配足够的缓冲区，获取实际密钥数据
        Pointer privBuf = new Memory(privLen);
        Pointer pubBuf = new Memory(pubLen);
        result = GoKeyLibrary.INSTANCE.generateKeys(privBuf, privLen, privLenRef, pubBuf, pubLen, pubLenRef);
        if (result != 0) {
            System.err.println("Failed to generate keys");
            return;
        }

        byte[] privateKey = privBuf.getByteArray(0, privLen);
        byte[] publicKey = pubBuf.getByteArray(0, pubLen);

        System.out.println("Private Key: " + new String(privateKey));
        System.out.println("Public Key: " + new String(publicKey));
    }
}

关键注意事项 #

1. 编译Go共享库：编译时必须指定-buildmode=c-shared参数，比如：

   # Linux/macOS
   go build -buildmode=c-shared -o libkeys.so keys.go
   # Windows
   go build -buildmode=c-shared -o keys.dll keys.go
   

2. 内存管理：如果用方案1，必须调用freeKeyPair释放Go分配的内存；方案2的缓冲区由JNA的Memory管理，会自动回收。
3. 结构体字段顺序：Java的Structure的getFieldOrder必须和Go结构体的字段顺序完全一致，否则会出现数据错乱。
4. 类型匹配：Go和Java的类型要一一对应（比如C.int对应Java的int，*C.uchar对应Java的Pointer）。

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