从Ballerina调用Java的问题

下面的ballerina Java interop代码无法生成数据签名。 你能指出它为什么在下面这行失败吗

该代码与Ballerina slalpha5一起运行。 Java版本：openjdk版本“15.0.1”2020-10-20

我已经检查了java类和方法的签名，在我看来都是正确的

`var signedDataHandle = check generateSignature(signature);`

导入ballerina/jballerina.java；
导入ballerina/jballerina.java.array；
进口芭蕾舞演员/io；
公共函数main（）返回错误？{
var data=“测试数据！”.toBytes（）；
var{encodedPublicKey，encodedPrivateKey}=check generateKeyTestPair（）；
var signedData=检查signData（数据，encodedPrivateKey）；
io:println（signedData.length（））；
}
函数signData（字节[]数据，字节[]encodedPrivateKey）返回字节[]错误{
var pkcs8EncodedKeySpec=newPKCS8EncodedKeySpec（检查数组：toHandle（encodedPrivateKey，“byte”）；
var-keyFactory=check-getKeyFactoryInstance（java:fromString（“RSA”））；
var privateKey=检查generatePrivateKey（keyFactory，pkcs8EncodedKeySpec）；
var signature=check-getSignatureInstance（java:fromString（“SHA256withRSA”）；
检查初始化数据签名（签名、私钥）；
检查updateSignatureData（签名，检查数组：toHandle（数据，“字节”）；
//下面这行不行
var signedDataHandle=检查生成签名（签名）；
var signedData=检查数组：fromHandle（signedDataHandle，“byte”）；
返回签名数据；
}
函数generateKeyTestPair（）返回记录{byte[]'encodedPublicKey；byte[]'encodedPrivateKey；}错误{
var keyPairGenerator=检查getKeyPairGeneratorInstance（java:fromString（“RSA”））；
初始化keyPairGenerator（keyPairGenerator，1024）；
var密钥对=发电机密钥对（密钥对发电机）；
var privateKey=getPrivateKeyFromKeyPair（密钥对）；
var publicKey=getPublicKeyFromKeyPair（密钥对）；
返回{
encodedPublicKey：检查数组：fromHandle（getEncodedPublicKey（publicKey），“byte”），
encodedPrivateKey：检查数组：fromHandle（getEncodedPrivateKey（privateKey），“字节”）
};
}
独立函数getKeyFactoryInstance（句柄算法）返回句柄| error=@java:Method{
'类：“java.security.KeyFactory”，
名称：“getInstance”
}外部的；
独立函数newPKCS8EncodedKeySpec（handle encodedKey）返回handle=@java:Constructor{
'class:'java.security.spec.PKCS8EncodedKeySpec'
}外部的；
独立函数generatePrivateKey（handle receiver，handle keySpec）返回handle | error=@java:Method{
'类：“java.security.KeyFactory”，
名称：“generatePrivate”
}外部的；
独立函数getSignatureInstance（句柄算法）返回句柄| error=@java:Method{
'类：“java.security.Signature”，
名称：“getInstance”，
paramTypes:[“java.lang.String”]
}外部的；
独立函数initDataSigning（句柄接收器，句柄私钥）返回错误？=@java：方法{
'类：“java.security.Signature”，
名称：“initSign”，
paramTypes:[“java.security.PrivateKey”]
}外部的；
独立函数updateSignatureData（句柄接收器，句柄数据）返回错误？=@java：方法{
'类：“java.security.Signature”，
名称：“更新”，
paramTypes:[{'类：“字节”，维度：1}]
}外部的；
独立函数generateSignature（句柄接收器）返回句柄| error=@java:Method{
'类：“java.security.Signature”，
姓名：“签名”
}外部的；
独立函数getKeyPairGeneratorInstance（handle算法）返回handle | error=@java:Method{
'类：“java.security.KeyPairGenerator”，
名称：“getInstance”
}外部的；
独立函数initializeKeyPairGenerator（句柄接收器，int-keySize）=@java:Method{
'类：“java.security.KeyPairGenerator”，
名称：“初始化”，
参数类型：[“int”]
}外部的；
独立函数generateKeyPair（句柄接收器）返回句柄=@java:Method{
'类：“java.security.KeyPairGenerator”，
名称：“generateKeyPair”
}外部的；
独立函数getPrivateKeyFromKeyPair（句柄接收器）返回句柄=@java:Method{
'类：“java.security.KeyPair”，
名称：“getPrivate”
}外部的；
独立函数getPublicKeyFromKeyPair（句柄接收器）返回句柄=@java:Method{
'类：“java.security.KeyPair”，
名称：“getPublic”
}外部的；
独立函数getEncodedPrivateKey（句柄接收器）返回句柄=@java:Method{
'类：“java.security.Key”，
名称：“getEncoded”
}外部的；
独立函数getEncodedPublicKey（句柄接收器）返回句柄=@java:Method{
'类：“java.security.PublicKey”，
名称：“getEncoded”
}外部的；

这看起来像芭蕾舞演员中的一只虫子。

---

为解决此问题而创建的问题：

感谢@Dhananjaya的快速回复。这是一个令人头痛的问题。

    import ballerina/jballerina.java;
    import ballerina/jballerina.java.arrays;
    import ballerina/io;
    
    public function main() returns error? {
    
        var data = "Test data!".toBytes();
        var { encodedPublicKey, encodedPrivateKey } = check generateKeyTestPair();
        var signedData = check signData(data, encodedPrivateKey);
    
        io:println(signedData.length());
    }
    
    function signData(byte[] data, byte[] encodedPrivateKey) returns byte[]|error {
    
        var pkcs8EncodedKeySpec = newPKCS8EncodedKeySpec(check arrays:toHandle(encodedPrivateKey, "byte"));
        var keyFactory = check getKeyFactoryInstance(java:fromString("RSA"));
        var privateKey = check generatePrivateKey(keyFactory, pkcs8EncodedKeySpec);
        var signature = check getSignatureInstance(java:fromString("SHA256withRSA"));
    
        check initDataSigning(signature, privateKey);
        check updateSignatureData(signature, check arrays:toHandle(data, "byte"));
    
        // The line below is failing
        var signedDataHandle = check generateSignature(signature);
        var signedData = <byte[]> check arrays:fromHandle(signedDataHandle, "byte");
    
        return signedData;
    }
    
    function generateKeyTestPair() returns record { byte[] 'encodedPublicKey; byte[] 'encodedPrivateKey; }|error {
    
        var keyPairGenerator = check getKeyPairGeneratorInstance(java:fromString("RSA"));
    
        initializeKeyPairGenerator(keyPairGenerator, 1024);
        
        var keyPair = generateKeyPair(keyPairGenerator);
        var privateKey = getPrivateKeyFromKeyPair(keyPair);
        var publicKey = getPublicKeyFromKeyPair(keyPair);
    
        return {
            encodedPublicKey: <byte[]> check arrays:fromHandle(getEncodedPublicKey(publicKey), "byte"),
            encodedPrivateKey: <byte[]> check arrays:fromHandle(getEncodedPrivateKey(privateKey), "byte")
        };
    }
    
    isolated function getKeyFactoryInstance(handle algorithm) returns handle|error = @java:Method {
        'class: "java.security.KeyFactory",
        name: "getInstance"
    } external;
    
    isolated function newPKCS8EncodedKeySpec(handle encodedKey) returns handle = @java:Constructor {
        'class: "java.security.spec.PKCS8EncodedKeySpec"
    } external;
    
    isolated function generatePrivateKey(handle receiver, handle keySpec) returns handle|error = @java:Method {
        'class: "java.security.KeyFactory",
        name: "generatePrivate"
    } external;
    
    isolated function getSignatureInstance(handle algorithm) returns handle|error = @java:Method {
        'class: "java.security.Signature",
        name: "getInstance",
        paramTypes: ["java.lang.String"]
    } external;
    
    isolated function initDataSigning(handle receiver, handle privateKey) returns error? = @java:Method {
        'class: "java.security.Signature",
        name: "initSign",
        paramTypes: ["java.security.PrivateKey"]
    } external;
    
    isolated function updateSignatureData(handle receiver, handle data) returns error? = @java:Method {
        'class: "java.security.Signature",
        name: "update",
        paramTypes: [{ 'class: "byte", dimensions: 1 }]
    } external;
    
    isolated function generateSignature(handle receiver) returns handle|error = @java:Method {
        'class: "java.security.Signature",
        name: "sign"
    } external;
    
    isolated function getKeyPairGeneratorInstance(handle algorithm) returns handle|error = @java:Method {
        'class: "java.security.KeyPairGenerator",
        name: "getInstance"
    } external;
    
    isolated function initializeKeyPairGenerator(handle receiver, int keySize) = @java:Method {
        'class: "java.security.KeyPairGenerator",
        name: "initialize",
        paramTypes: ["int"]
    } external;
    
    isolated function generateKeyPair(handle receiver) returns handle = @java:Method {
        'class: "java.security.KeyPairGenerator",
        name: "generateKeyPair"
    } external;
    
    isolated function getPrivateKeyFromKeyPair(handle receiver) returns handle = @java:Method {
        'class: "java.security.KeyPair",
        name: "getPrivate"
    } external;
    
    isolated function getPublicKeyFromKeyPair(handle receiver) returns handle = @java:Method {
        'class: "java.security.KeyPair",
        name: "getPublic"
    } external;
    
    
    isolated function getEncodedPrivateKey(handle receiver) returns handle = @java:Method {
        'class: "java.security.Key",
        name: "getEncoded"
    } external;
    
    isolated function getEncodedPublicKey(handle receiver) returns handle = @java:Method {
        'class: "java.security.PublicKey",
        name: "getEncoded"
    } external;