aardio 与 Java 混合编程指南

导入 java 扩展库

默认只要在 aardio 中调用

import java;

就会自动搜索系统可用的 JRE，如果没有找到 JRE，aardio 会自动导入 java.jre.v8 扩展库，并自动安装 OpenJDK JRE v8 。

我们通过在 aardio 中导入其他版本 JRE 扩展库以显式指定 JRE 版本，例如通过以下代码

import java.jre.v8ora

就可以自动绑定 Oracle Java 8 运行时，aardio 在运行时会自动查找用户电脑上符合要求的 JRE，如果没有找到就会全自动地安装和部署 Oracle Java 8 运行时，开发者要做的仅仅就是在 aardio 里写调用代码，然后发布并生成为 EXE 程序，最后简单地分发给用户就可以了。

我们还可以使用下面的代码嵌入更小的 JRE 6 运行时：

import java.jre.v6

java.jre.v6 携带一个仅 6MB 多一点的 JRE 6 运行时，并且在发布时会嵌入在独立 EXE 文件内部，发布时不需要携带额外的文件。

aardio 标准库提供的 JRE 如下：

java.jre.v8ora 调用 Oracle JRE v8，找不到会自动安装。
java.jre.v8 调用 OpenJDK JRE v8，找不到会自动安装。
java.jre.v6 自带的精简版 JRE v6，发布时嵌入到 EXE，体积很小只有 6.x MB。

在每个进程第一次创建JAVA 虚拟机或初始化 JVM 路径之前可调用 java.path.setJreHome("自定义 JRE 路径") 自行指定任意 JRE 路径。

aardio 会尝试各种可能找到系统已安装的 JDK或JRE（JVM），
这个搜索过程略有些复杂，请参考 java.path 库源码或文档里的说明。因为 aardio 可以自动下载并部署 JRE,JDK，所以 aardio + Java 混合编程可以生成体积更小的 EXE 文件，发布时可以不用自带 JRE 或 JDK 。

注意低版本 JDK 编译的 Java 程序可以在高版本 Java 虚拟机运行，反之则不行。如果一个 Java 的 class 文件在 aardio 中无法加载，注意检查一下是否使用了低版本 JRE 去加载高版本 JDK 编译的 class 文件。

更多关于在 aardio 中当前获取或设置 JVM/JRE/JDK 路径的内容以及相关规则请参考范例：JVM/JRE/JDK

创建 Java 虚拟机

🅰 示例：

import java; 

/*
创建 Java 虚拟机。
可指定不定个数的 Java 启动参数（字符串），
也可以将多个参数放到一个字符串或者字符串数组里。
*/
var jvm = java(); 

//导入 Java 类，首字母最好大写以避免与普通变量混淆
String = jvm.import( "java.lang.String"); 

//创建 Java 对象实例
var jstr = String("测试一下")

print( jstr );

在一个进程中只会创建一个 Java 虚拟机实例，一般应当在主线程中创建，子线程创建虚拟机时会自动绑定已创建的 Java 虚拟机实例。

在一个进程中首次创建 Java 虚拟机时可以使用 java("-D<propertyName>=propertyValue") 格式指定 Java 启动参数(可以指定多个字符串参数，也可以在一个字符串中指定多个参数，也可以指定包含多个字符串的数组参数 )，在 Java 代码中可用 System.getProperty("propertyName") 得到 propertyValue 的值。

aardio 调用 Java 对象 #

首先请看下面 aardio 调用 Java 如此简单，我们可以在 aardio 中直接导入 Java 的类，创建 Java 实例对象，就像在 Java 代码中那样使用它们。

//导入 Java 扩展库
import java;

//创建 Java 虚拟机，自动查找 32 位 Java 运行时，找不到会自动下载 
var jvm = java();

//导入 Java 类
HelloworldApp = jvm.import( "aardio.sample.HelloworldApp");

//修改 Java 类的静态成员变量
HelloworldApp.static_num = 996;

//获取 Java 类的静态成员变量
print( HelloworldApp.static_num );

//在 aardio 中实例化一个 Java 类
var javaObject = HelloworldApp(); //不需要 new 关键字

//获取 Java 对象的属性
print( javaObject.name );

//调用 Java 对象的方法
print( javaObject.test(1) );

//调用 main 函数，参数是字符串数组
var ret = HelloworldApp.main( ["aaa字符串数组1","bbb字符串数组2"] );

print(ret);

📄 HelloworldApp 类的 Java 源代码

使用 java 构造函数创建 jvm 虚拟机是在 aardio 进程内调用 Java 接口，必须使用 32 位 JRE。

改用 java.popenProcess() 或 java.openProcess() 则可以在进程外调用或创建 Java 进程，兼容 64/32 位 Java 运行时。

在 aardio 中加载与搜索 Java 类

Java 会在 CLASSPATH 指定的搜索目录下使用 Java 类(替换类名中的.为\)" 去查找类，这很像 aardio 导入库的方式（区别是 aardio 导入库的目录是明确指定的位置，而 Java 则可以添加导入类的目录）。

aardio 的 java 扩展库已默认在 CLASSPATH 内添加 /java/以及/java/*.jar 目录，在 Java 中 jre 文件也相当于一个虚拟的包目录。

在 aardio 中文件路径的首字符为单斜杆（或单个反斜杆）时表示应用程序根目录。 应用程序根目录在发布后指启动程序的 EXE 文件所在目录，在开发环境中指的是 aardio 工程根目录（如果没有创建工程，单独运行 aardio 文件则是指启动程序的 aardio 文件所有目录）。

例如上面示例程序的目录结构如下：

│  main.aardio
└─ java  
    └─aardio 
        └─sample
                HelloworldApp.class
                HelloworldApp.java

📄 HelloworldApp.class 的源代码

aardio 代码中的 jvm.import( "aardio.sample.HelloworldApp") 载入的就是上面的 /java/aardio/sample/HelloworldApp.class 类，Java 类的路径与 class 文件的实际路径是一致的。

在首次创建 Java 虚拟机以前，可以用下面的代码添加目录到 JAVA CLASSPATH:

java.addClassPath("/java/"); //在创建 Java 虚拟机或运行 Java 程序以前调用才会生效

以上参数指定目录下的 *.jar 也会自动添加到 JAVA CLASSPATH, 不会再递归搜索子目录下的 jar 。

也可以如下自指定文件（或者内存数据）直接加载类：

HelloworldApp = jvm.import("aardio.sample.HelloworldApp"
  ,$"\java\aardio\sample\HelloworldApp.class");

上面文件路径前添加 $ 操作符就表示内存加载 HelloworldApp.class 文件， $ 操作符的作用是将文件编译为二进制字符串（发布后不再需要原文件）。

Java 接口的错误与异常处理

默认 Java 虚拟机的所有异常会输出到控制台窗口，前提是在执行 import java 前打开控制台。

一个简单的方法是将 import console 替换为 import console.init 并放在 import java 前面。import console.init 会在打导 console.init 库时就自动打开控制台窗口，并且会在退出线程前暂停控制台窗口以等待用户按键（不需要手动添加 console.pause()）。

🅰 示例：

import console.init;
import java;

var jvm = java()

//演示导入一个错误的，不存在的 Java 类
JavaClass = jvm.import("nonexistent.Class");

执行上面的代码，控制台输出了错误信息：

java.lang.NoClassDefFoundError: nonexistent/Class
Caused by: java.lang.ClassNotFoundException: nonexistent.Class
        at ......

在 aardio 中导入类失败不会抛出异常，只会返回 null 与固定的错误信息。这个基本都是写错了路径，抛出异常的作用不大，而且导入类为 null 想不知道都不行。

在调用其他 Java 函数时如果出错则会抛出异常。

读写类或对象的字段即使失败也不会抛出异常，读字段失败则返回 null 值。

注意: aardio 中较少使用 try 语句，如果代码抛出异常大多应当在开发时就进行处理。大多数 aardio 函数会在失败时返回 null 值，并使用第 2 个返回值返回可选的错误信息。在调用 Java 函数时如果抛出异常，这类问题通常是需要在开发时就修正的严重错误，没有必要在代码中使用过多的 try 语句。

控制台输出 / 打印 Java 对象

print,console.log 等输出到控制台的函数会自动调用 tostring 转换参数为字符串，而 Java 类（在aardio 中存为 java.class 类包含的对象）或Java 对象（在 aardio 中存为 java.object 类包含的对象）都支持 tostring 函数。

🅰 示例：

import java;

var jvm = java();
ArrayList = jvm.import("java.util.ArrayList");

//创建 ArrayList 对象
var arrayList = ArrayList();

//调用 Java 对象的方法
arrayList.add(jvm.int(123));
arrayList.add(2.2);

//在控制台输出 [123, 2.2]
print( arrayList );

使用 console.dump( arrayList ) 则会输出更详细的信息如下：

java.object(class java.util.ArrayList):
[123, 2.2]

需要注意 Java 在 Windows 上默认使用 ANSI 编码，这可能会导致控制台输出输出乱码。#

aardio 内核的文本编码是 UTF-8(通过 UTF 自动标记功能实现自动兼容 UTF-16 编码)，如果用 ANSI 编码与 Java 交互这就很麻烦，所以在 aardio 中 Java 虚拟机已经被默认设置为了 UTF-8 编码。

可如下修改 Java 虚拟机的默认文本编码，必须在在运行进程范围首次创建 Java 虚拟机前设置才会生效。

java.encoding = "utf-8" //修改 Java 默认编码, 默认已设为 "utf-8"

如果 aardio 与 Java 双方都使用 UTF-8 编码，一般就没有什么问题。唯一需要注意的是：即使 Java 的编码设为 UTF-8 了，如果在 Java 代码里往控制台输出，他仍然是使用 ANSI编码输出，这样中文输出到控制台就会出现乱码。

aardio 在 Windows 10 以及之后的系统，控制台会将默认编码设为 UTF-8，如果必须用 Java 向控制台输出中文（更好的选择是改为调用 aardio 函数输出），可以用下面的代码让 aardio 控制台切换到 ANSI 编码：

console.utf8 = false;//一定要在打开控制台以前执行

无论控制台是不是启用 UTF-8，aardio 代码都可以自动兼容转换，不会出现乱码，但关闭 UTF-8 可能无法在控制台显示部分 Unicode 字符。

Java 函数签名 #

示例

aardio 调用 Java 函数的时候，允许不写 Java 函数签名直接调用。但我们也可以显式地指定 Java 函数签名，这是一个略显繁琐且容易出错的操作。

🅰 示例：

import java; 

var jvm = java();

//导入 Java 类
HelloworldApp = jvm.import( "aardio.sample.HelloworldApp");

//getMethod用于获取一个函数，参数@2指定函数签名
var main = HelloworldApp.getMethod("main","string(string[])");

//通过声明导入的函数，如果参数是一个字符串数组，也可以把参数展开写
var result = main("test1","test2")

Java 函数签名语法格式

函数签名里可以使用的数据类型如下：

object,string,byte,short,int,long,float,double,char,boolean
pointer(object),bool(boolean),word(short),long64(long),float32(float),float64(double),int8(byte),int16(short),int32(int),int64(long)
void 类型表示无返回值

上面签名类型后面括号里写的是等价的类型。

要点：

Java 函数签名中的所有类型名要小写。
在 aardio 里 Java 签名里的返回值的类型必须写在函数签名的前面，多个参数必须用逗号分开。例如 string(int,double)。
在 Java 签名里只要写类型，不要写参数名字，例如不能写为 string(int paramName1,double paramName2)。aardio 的原生函数签名里是可以写参数名称的，请注意区别。
所有类型都可以在后面加一个 [] 表示数组，例如 string [] 表示字符串数组。这种数组签名仅用于匹配 Java 函数签名，实际使用的类型会被 aardio 在内部自动替换为 pointer 指针类型，在向 Java 注册本地函数时，数组类型的回调参数实际接收到的也是指针。

注意在 aardio 里原生 API 函数的参数类型里只能使用 struct 类型的结构体指针（在函数参数中 struct 总是作为指针处理）表示数组指针，仅在 Java 函数签名里才能这样写参数类型。另外原生结构体的字段类型里也可以用 [] 表示数组，例如 {int array[32]=[]}。
Java 接口里 pointer 对应的都是特指继承自 Java Object 对象的引用类型指针，在 Java 接口里的指针参数都会被识别为 Java Object 对象指针，不能传入其他类型的原生指针。而且这些 Java 对象指针都是由 aardio 自动处理的，所以调用 Java 接口时不要使用任何指针就可以了（在 Java 中注册本地 aardio 函数是例外）。
Java 没有无符号数值类型，所以 aardio 里加 u 或 U 前缀的类型不要使用，并且所有类型名都要小写（ aardio 里大写数值类型表示无符号数）。
object,short,char,boolean 是仅在 Java 接口里使用的类型，object 对象 aardio 的 pointer 类型，short 等价于 aardio 的 word 或 int16 类型，char 等价于 aardio 的 uint16 类型，boolean 等价于 aardio 的 bool 类型。
函数签名也可以使用任何 Java 自定义的类型，例如 jobject.getMethod("iterator","java.util.Iterator()") 或者 jobject.getMethod("iterator","java/util/Iterator()") 这两种写法都可以。

省略函数签名直接调用 Java 函数

在 aardio 里调用 Java 函数，可以省略签名，例如：

🅰 示例：

import java; 
var jvm = java();
HelloworldApp = jvm.import( "aardio.sample.HelloworldApp");

//调用 Java 函数
HelloworldApp.main( ["aaa字符串数组1","bbb字符串数组2"] )

显式指定减少了搜索匹配的过程，但大多时候这种影响可以忽略不计。

Java 构造函数签名

我们在使用 Java 类构造函数时也可以显式指定签名，区别是我们需要使用 Java 类的 new2 方法，并且返回值只能指定为 void ，示例：

import java;

var jvm = java()

var HashMap = jvm.import("java.util.HashMap")

//指定签名并构造对象，可自参数 2 开始指定其他构造参数（所以它叫 new2 ）
var jMap = HashMap.new2("void()") //签名里的返回值必须是 void，但返回值是 Java 实例对象

//使用 new 方法构造对象则不必指定签名
var jMap = HashMap.new()

// new 是 Java 类的默认方法，可以省略并直接用 Java 类构造对象
var jMap =  HashMap();

//aardio 提供了预置的 jvm.hashMap 可以直接创建 java.util.HashMap
var jMap = jvm.hashMap({ //参数可指定要转换为 HashMap 的 aardio 表对象
    key1 = "value1";
    key2 = "value2";
})

print(jMap)

可变参数

Java 函数里最后一个可变参数只要声明为数组类型就可以，在aardio 里传数组，或者展开写都可以。

🅰 示例：

var javaMethod = javaObject.getMethod("javaMethod","void(int,string[])");

//可以传数组
javaMethod(123,["str1","str2"])

//也可以展开写
javaMethod(123,"str1","str2")

Java 泛型

Java 的泛型是伪泛型，编译时会执行泛型擦除。 aardio 调用的是 Java 运行时代码，Java 泛型参数作为 object 类型或泛型的边界类型处理即可。这与 .NET 泛型在 aardio 中需要显式声明是不同的。

Java 与 aardio 之间的数据类型转换

1. 传值类型

在 aardio 中调用 Java 函数时，字符串、数值、布尔值、buffer、time 对象可以自动双向转换，也就是说 Java 里的字符串传入 aardio 就是 aardio 字符串，反过来也一样，不需要手动转换。

包含字符串与数值的数组也会自动转换，Java 数值数组传入 aardio 会转换为纯 aardio 数组（不会保持对 Java 数组的引用），反过来也一样。

aardio 中的 buffer 是由 raw.buffer 函数构造的二进制字节数组，在 Java 中等价的对象是 byte 数组，在与 Java 交互时可自动做双向转换。

aardio 中的 time 对象以及继承自 time 的 time.ole 对象等在传入 Java 时会自动转换为 java.util.Date 对象，反过来 java.util.Date 传入 aardio 也会自动转换为 aardio 对象。

以上这些类型都是传值而不传址，不会保持引用。

2. 传址类型

除了上述的基础传值类型以外，其他 Java 对象在 aardio 中将存为 java.object 对象，并保持对 Java 原对象的引用。在 aardio 操作这引起对象也会改变 Java 中的实际对象。

如果显式调用 Java 类的构造函数也不会会做任何自动类型转换，总是直接返回 Java 对象引用（存储为 aardio 里的 java.object 对象）。即使是字符串、数值这些基础的 Java 类型直接构造对象也会返回 java.object 对象，例如：

import java;
var jvm = java()

//返回 java.lang.String 类
var JavaString = jvm.import("java.lang.String");

//创建 java.lang.String 对象实例，不会自动转换为 aardio 字符串
var jString = JavaString();

3. java.util.Map,java.util.HashMap

所有 java.util.Map 对象（包含 java.util.HashMap 等）默认在 aardio 中也会存为 java.object 对象，并保持对原 Java 对象的引用（传址）。

调用 aardio 函数时，aardio 参数如果是一个纯表对象，并且不是 java 对象、数组、类数组、时间对象，则会自动转换为 java.util.HashMap ，这会复制所有的值并且解除对原 aardio 对象的引用（传值）。

aardio 提供了预置的 jvm.hashMap 可以直接创建 java.util.HashMap，示例：

import java;
var jvm = java()

//参数可指定要转换为 HashMap 的 aardio 表对
var jMap = jvm.hashMap({  
    key1 = "value1";
    key2 = "value2";
})

//写入新的键值
jMap.put("key1","value1")
jMap.put("key2","value2")

//转换为纯 aardio 值（表对象）
var tab = jMap.parseValue()

所有实现 java.util.Map 接口的 Java 对象都可以调用 parseValue() 方法转换为仅包含纯 aardio 值的表对象（仅复制值，并解除对原 Java 对象的引用）。

4. java.util.Collection,java.util.List,java.util.ArrayList

所有 java.util.Collection 对象（包含 java.util.ArrayList 等）默认在 aardio 中也会存为 java.object 对象，并保持对原 Java 对象的引用（传址）。这些集合对象（Collection）在 aardio 都可以调用 parseValue() 方法转换为仅包含纯 aardio 值的表对象（仅复制值，并解除对原 Java 对象的引用）。

下标

所有 java.util.List 对象（包含继承自 java.util.List 类的对象）在 aardio 中都支持用数值下标读写值。只要在下标中指定数值索引，aardio 就会将其视为 List 对象进行操作，不会事先检查类型。

Java 对象并不支持非数值的下标，例如 java.util.HashMap 对象需要调用 parseValue 方法转换为 aardio 表对象才能使用下标操作。

import java;

var jvm = java();
ArrayList = jvm.import("java.util.ArrayList");

//创建 ArrayList 对象
var arrayList = ArrayList();

//调用 Java 对象的方法
arrayList.add(1);
arrayList.add(2);

//使用下标操作符读写值
arrayList[0] = 3;
print( arrayList[1] );

迭代器

在 aardio 中所有可创建 Java 迭代器的 Java 对象都可以使用 each 函数创建 aardio 迭代器，可用于 for in 语句。

java.util.Map,java.util.HashMap,java.util.Collection,java.util.List,java.util.ArrayList 在 aardio 中都支持调用 each 方法创建迭代器。

🅰 示例：

import java;
var jvm = java()

var jMap = jvm.hashMap({  
    key1 = "value1";
    key2 = "value2";
})

//创建 Java 对象迭代器
for k,v in jMap.each() {
    print(k,v)
}

类型转换函数

在与 aardio 交互时，大多时候类型可以自动转换，但 aardio 也提供了部分显式转换类型的函数。

1. aardio 对象转换为 Java 对象

jvm.double(number) 将参数指定的数值转换为 java.lang.Double 对象
jvm.float(number) 将参数指定的数值转换为 java.lang.Float 对象
jvm.long(number) 将参数指定的数值转换为 java.lang.Long 对象
jvm.int(number) 将参数指定的数值转换为 java.lang.Integer 对象
jvm.short(number) 将参数指定的数值转换为 java.lang.Short 对象
jvm.char(number) 将参数指定的数值转换为 java.lang.Character 对象
jvm.byte(number) 将参数指定的数值转换为 java.lang.Byte 对象
jvm.boolean(number) 将参数指定的数值转换为 java.lang.Boolean 对象
jvm.hashMap(number) 将参数指定的数值转换为 java.util.HashMap 对象
jvm.date(number) 将参数指定的数值转换为 java.util.Date 对象
array(elementType,...) 将参数 @2 指定的数组转换为 Java 数组，如果参数 @2 不是数组，则将参数 @2 开始的参数合并为数组然后转换为 Java 数组。参数 @elementType 指定类型，可用的类型与请参数 Java 函数签名。
stringArray(...) 将参数 @1 指定的数组转换为 Java 数组，如果参数 @1 不是数组，则将能数 @1 开始的参数合并为数组然后转换为 Java 数组。
object(value) 将参数 @1 指定的值转换为 java.lang.Object 对象，参数可指定所有可自动转换为 Java 对象的值。

🅰 示例：

import java;
var jvm = java();

//创建 java.util.date 对象
var jdate = jvm.date();
print(jdate);

2. Java 对象转换为 aardio 对象

在 aardio 中调用 Java 函数时，返回的 Java 对象如果支持自动转换则会自动转换为适合的类型。不支持自动转换的 Java 对象，或者显式创建的 Java 对象在 aardio 中会存为 java.object 对象，支持显式转换为 aardio 值的 Java 对象（包含可自动转换为 aardio 对象的Java 对象）可以调用 java.object 对象的 parseValue 方法将其转换为纯 aardio 值。

💡 aardio 提供以下对象用于将原生 Java 对象指针转换为可操作的对象，**下面这些函数仅用于解析 Java 回调 aardio 函数时回调参数里的指针参数**：

jvm.parseBuffer(jBufferPtr) 将 Java 的 byte[] 指针转换为 aardio 中的 buffer 字节数组。
jvm.parseString(jStringPtr) 将 Java 字符串指针转换为 aardio 字符串。
jvm.parseArray(elementType,jArrayPtr) 将参数 @jStringPtr 指定的 Java 数组指针转换为 aardio 数组，参数 @elementType 指定数组元素类型，可用类型请参考 Java 函数签名。
jvm.parseStringArray(jStringArrayPtr) 将参数 @jStrinjStringArrayPtr 指定的 Java 字符串数组指针转换为 aardio 字符串数组
jvm.parseObject(jObjectPtr) = 将参数指定的 java.lang.Object 对象指针转换为 aardio 中的 java.object 对象。

上述这些以 Java 指针作为参数的函数全部都会首先调用 JNI 接口的 DeleteLocalRef 事先解除引用，因此这些函数应当谨慎地使用，不能对已经执行 DeleteLocalRef 的指针进行操作。

如果不是在 Java 中注册本地 aardio 函数不需要用到这些操作指针的函数，其他未提供转换函数的基础类型不需要转换（例如数值、布尔值这些不需要转换）。

Java 回调 aardio 函数 #

我们先看一下本文档使用的 Java 类 📄 HelloworldApp 的 Java 源代码：

package aardio.sample; 
import java.io.*; 

public class HelloworldApp{   
    static native String aardio(String code); 

    public static String main(String[] args) {   
        System.out.println("Hello this is a simply test"); /
        System.out.println( args[0]  );  
        System.out.println( args[1]  ); 
        return "aardio,你好,这是给你的返回值"; 
    }  
    public String name = "HelloworldApp2";
    public static int static_num = 123;
    public int test(int a) {   
        return a + 123;
    } 
    public String test_aardio() {  
        return aardio("import win;win.msgbox('我是Java,我正在执行aardio代码');return true;") ; 
    }      
}

Java 中的包相当于 aardio 中的库,
Java 中的 package 语句类似在 aardio 代码中用 namespace 语句定义名字空间。 Java 与 aardio 都要求包或库的名字空间与文件的相对路径保持一致。

我们需要将上面的源码放置在路径 /java/aardio/sample/HelloworldApp.java：

│  main.aardio
└─ java  
    └─aardio 
        └─sample
                HelloworldApp.class
                HelloworldApp.java

然后编译为 HelloworldApp.class 文件。

上面 Java 代码中的 static native String aardio(String code); 声明了一个 aardio 回调函数，并在在后面的 Java 代码中继续回调了 aardio 函数。

aardio 代码示例：

import java;  
var jvm = java(); 
HelloworldApp = jvm.import( "aardio.sample.HelloworldApp");

//为 Java 提供 Native API
HelloworldApp.registerNative(
    function(env,jobject,jstring){
        /*
        转换 java 类型 为 aardio 类型，
        也可以用 owner.parseString(jstring)
        */
        var code = jvm.parseString(jstring) 

        var func = loadcode(code) 
        var str = func();

        //将 aardio 对象加转换为 Java 对象。
        return jvm.string(str)
    },"aardio","string(string)"
)

//创建 Java 类实例
var helloworld = HelloworldApp();

//调用 Java 对象的方法
helloworld.test_aardio()

在 aardio 中注册 Java 回调函数需要显式指定 Java 函数签名。需要注意的是，用这个方法注册 Java 函数实际上是调用 raw.tostdcall 创建了一个原生函数指针，Java 函数签名中的特殊 Java 类型也会被转换为 aardio 原生接口的兼容类型，例例如 Java 类型 char 会被替换为 WORD 类型再传入 raw.tostdcall 调用参数。

注册的 Java 回调函数基础的数值等类型不需要自己转换，但 Java 中的特殊类型需要转换。

可用的转换函数请参考解析 Java 指针参数。

aardio 调用 Java 执行 JavaScript #

🅰 示例：

import console.init;
import java;

var jvm = java();
ScriptEngineManager = jvm.import("javax.script.ScriptEngineManager")

var script = ScriptEngineManager();
var engine = script.getEngineByName("javascript");

var jsCode = /******

//在 JavaScript 里调用 Java 
var javaObject = new java.lang.Object(); 
print(javaObject.toString());

//创建 JS 对象
var jsObject = { 
    getGreeting : function(name) { return 'Hello, ' + name; } 
}; 
******/;  

//执行 JavaScript 代码
engine.eval(jsCode);

//将参数（可指定 JS 对象或者表达式）转换为可调用对象。
var jsObject = engine.invocable("jsObject");

//调用对象的方法 
var result = jsObject.getGreeting("Jacen");
print(result);

//不指定参数则返回当前作用域对象
var jsScope = engine.invocable();

//直接调用 JS 函数
jsScope.print("你好");

上面的 engine.invocable 返回的是 javax.script.Invocable 接口对象。

也可以用 engine 对象直接调用 javax.script.Invocable 接口的方法，但是要注意默认未声明函数签名时，可变参数只能传数组，示例：

engine.invokeFunction("print",["你好"])

我们可以先声明一下函数签名，就可以展开写可变参数了，示例：

//双层的直接下标 [[]] 可避免触发成员操作符的元方法
engine[["invokeFunction"]] = engine.getMethod("invokeFunction","object(string,object[])")

//可以仍旧传数组参数
engine.invokeFunction("print",["你好"])

//也可以将可变参数展开写
engine.invokeFunction("print","你好","你好2")

如果调用过 aardio 预置的 engine.invocable() 方法，会自动添加 javax.script.Invocable 接口的函数签名。

运行 Jar

在 aardio 进程内通过 Java 虚拟机调用 jar 的 main 函数示例：

import java;
java.addClassPath("~\lib\java\yuiCompressor\.res\yuicompressor.jar")

var jvm = java(); 
YUICompressor = jvm.import( "com.yahoo.platform.yui.compressor.YUICompressor");  
var ret = YUICompressor.main({"d:\test.js", "-o","d:\testmin.js"})

但 jar中的 main 函数通常会假设自己是一个独立进程，出错可能会选择直接调用 System.exit() 退出进程。

为了避免出现这样的问题, 我们可以调用 java.popenProces 在进程外运行 Java 程序。

🅰 示例：

import java;

var javaProcess = java.popenProcess( 
    "-verbose:class",//记录类载入信息
    "-jar",//运行jar
    io.fullpath( "~\lib\java\yuiCompressor\.res\yuicompressor.jar" ),
    "d:\test.js"
);

这会创建独立的 Java 进程，并且可以兼容 32 位或 64 位 Java 运行时。 Java 进程退出也不会影响调用 Java 的 aardio 进程。

java.popenProcess 返回的是一个 process.popen 进程管道对象，我们可以对进程管道进行操作，示例：

var tOutBuffer = {}; 
for( all,out,err in javaProcess.each() ){
    console.log( out,err );
    table.push( tOutBuffer,all);
}

在 aardio 中编译 Java 代码 #

🅰 示例：

aardio 默认会自动搜索系统安装的 JDK 。

可以使用 java.path.setJdkHome 函数显式指定 JDK 的位置，也可以导入标准库中自动设置 JDK 的库：

import java.jdk.v8 自动引入 OpenJDK v8 ，找不到会自动下载安装，发布不需要携带 JDK。
import java.jdk.v8ora 自动引入 Oracle JDK v8 ，找不到会自动下载安装，发布不需要携带 JDK。

import java.jdk.v6ora 自动引入 Oracle JDK v6 ，找不到会自动下载安装，发布不需要携带 JDK。

import java; 
import java.jdk.v6ora

var javaCode = /****
package aardio.sample;  

public class HelloworldApp{    
public int Add(int a,int b) {   
    return a + b;
}     
}  
****/

//保存 Java 源码
string.save("\java\aardio\sample\HelloworldApp.java",javaCode )  

//编译 Java 代码
var prcs = java.compile("\java\aardio\sample\HelloworldApp.java")

//这是一个管道进程（ process.popen 对象 ）
prcs.logResponse(); //回显所有输出
prcs.close();

Markdown 格式