java平台脚本+java编译器API

【0】README

0.1）本文文字描述转自 core java volume 2， 旨在学习  java平台脚本+java编译器API 的 基础知识；

------------------------------------------------------------------------------

【1】java平台的脚本 

1）脚本语言定义： 脚本语言是一种通过在运行时解释程序文本，从而避免使用通常的编辑/编译/链接/运行循环的语言。（干货——脚本语言定义，如JavaScript）

2）脚本语言有很多优势（merit）：

m1）便于快速变更，鼓励不断试验；

m2）可以修改运行着的程序的行为；

m3）支持程序用户的定制化；

3）problem+solution：

3.1）problem：大多数脚本语言都缺乏可以使编写复杂应用受益的特性，如，强类型，封装和模块化；

3.2）solution：因此人们在尝试将脚本语言和传统语言的优势相结合。。脚本API 使你可以在 java 平台上实现这个目的， 他支持在java程序中使用 JavaScript， Groovy， Ruby， 甚至更奇异的注入 Scheme 和 Haskell 等语言编写的脚本进行调用；（干货——java脚本API的作用）

---

【1.1】获取脚本引擎

1）脚本引擎： 脚本引擎是一个可以执行用某种特定语言编写的脚本的类库。当虚拟机启动时， 他会发现这些引擎；（干货——脚本引擎定义）

2）为了枚举这些引擎：需要构造一个 ScriptEngineManager ， 并调用 getEngineFactories 方法。 可以向每个引擎工厂去询问他们所支持的引擎名， MIME类型和文件扩展名；如下表所示：

3）获取引擎：可以直接通过名字， MIME 类型 或文件扩展名来请求它：

<span style="font-family:Microsoft YaHei;font-size:14px;">ScriptEngine engine = manager.getEngineByName("JavaScript");</span>

---

【1.2】 脚本赋值与绑定

1）利用引擎调用脚本： Object result = engine.eval(script);

2）如果脚本存储在文件中， 那么需要打开一个 Reader， 然后调用： Object result = engine.eval(reader);

3）可以在同一个引擎上调用多个脚本： 

<span style="font-family:Microsoft YaHei;font-size:14px;">engine.eval("n=1728");Object result = engine.eval("n+1")返回 1729；</span>

Attention） 要想知道在多个线程中并发执行脚本是否安全， 可以调用：

Object param = factory.getParameter("THREADING"); 返回值有： 

A1）null：（不安全）；

A2）MULTITHREADED： 并发执行安全； 

A3）THREAD-ISOLATED：除了MULTITHREADED外，会为每个线程维护不同的变量绑定；

A4）STATELESS： 除了THREAD-ISOLATED外， 脚本不会改变变量绑定；

4） 向引擎中添加变量绑定：

<span style="font-family:Microsoft YaHei;font-size:14px;">engine.put(k, 100);Object result = engine.eval("k+1");</span>

5）获取由脚本语句绑定的变量：

<span style="font-family:Microsoft YaHei;font-size:14px;">engine.eval("n=100");Object result = engine.get("n");</span>

6）除了向引擎或全局作用域添加绑定外，还可以将绑定收集到一个类型为 Bindings 的对象中， 然后将其传递给 eval 方法：

<span style="font-family:Microsoft YaHei;font-size:14px;">Bindings scope = engine.createBindings();scope.put(b, new Butten());engine.eval(script, scope);</span>

<span style="font-family:Microsoft YaHei;font-size:14px;">package com.corejava.chapter10;import java.io.File;import java.io.FileNotFoundException;import java.io.PrintWriter;import java.io.StringWriter;import java.util.List;import javax.script.Bindings;import javax.script.ScriptEngine;import javax.script.ScriptEngineFactory;import javax.script.ScriptEngineManager;import javax.script.ScriptException;public class ScriptTest{public static void main(String[] args) throws ScriptException, FileNotFoundException{// 脚本引擎管理器//ScriptEngineManager manager = new ScriptEngineManager();/*List<ScriptEngineFactory> list = manager.getEngineFactories();for(ScriptEngineFactory engine : list){System.out.println(engine.getEngineName());}*/// 脚本引擎管理器ScriptEngineManager manager = new ScriptEngineManager();ScriptEngine engine = manager.getEngineByName("JavaScript");// 向引擎中添加变量绑定engine.eval("n=1728");Object result = engine.eval("n+1"); // 1729.0System.out.println(result);// 获取由脚本语句绑定的变量 engine.put("k", 100);result = engine.eval("k+1"); // 101System.out.println(result);// 除了向引擎或全局作用域添加绑定外，还可以将绑定收集到一个类型为 Bindings 的对象中， // 然后将其传递给 eval 方法：Bindings scope = engine.createBindings();scope.put("a", "hello, ");result = engine.eval("a+ 'world!'", scope); // hello, world!System.out.println(result);// 重定向输入和输出// 任何用 js 的 print 和 println函数产生的输出都会发送到 writerStringWriter writer = new StringWriter();engine.getContext().setWriter(new PrintWriter(new File("com/corejava/chapter10/output.txt")));engine.eval("print('hello world, this msg is from java app')");}}</span>

Attention）你可能希望除了引擎作用域和全局作用域外还有其他的作用域。但这需要你自己去解决。你需要实现一个类， 他实现了 ScriptContext 接口， 并管理着一个作用域集合。每个作用域都是由一个整数标识的， 而且越小的数字应该越先被搜索；

---

【1.3】重定向输入和输出

1）重定向输入和输出的实现：通过调用脚本上下文的　setReader 和 setWriter 方法来实现；

<span style="font-family:Microsoft YaHei;font-size:14px;">StringWriter writer = new StringWriter（）；engine.getContext().setWriter(new PrintWriter(writer, true));</span>

对以上代码的分析（Analysis）：  在上例中， 任何用 js 的 print 和 println函数产生的输出都会发送到 writer；

Warning）可以向setWriter 方法传递任何Writer， 但是如果传递的不是 PrintWriter， Rhino 引擎就会抛出异常；

<span style="font-family:Microsoft YaHei;font-size:14px;">// 重定向输入和输出（同上）// 任何用 js 的 print 和 println函数产生的输出都会发送到 writerStringWriter writer = new StringWriter();engine.getContext().setWriter(new PrintWriter(new File("com/corejava/chapter10/output.txt")));engine.eval("print('hello world, this msg is from java app')");</span>

---

【1.4】调用脚本的函数和方法

1）提供调用脚本的函数和方法的 脚本引擎实现了 Invocable 接口；

2）如何调用一个函数？ 需要用函数名来调用 invokeFunction 方法，函数名后面是函数的参数：

<span style="font-family:Microsoft YaHei;font-size:14px;">if(engine implemens Invocable)    (Invocable)engine.invockFunction("aFunction", param1, param2);</span>

3） 如果脚本是面向对象的， 像下面这样调用方法：

<span style="font-family:Microsoft YaHei;font-size:14px;">    (Invocable)engine.invockMethod(implicitParam, "aMethod", explicitParam1, explicitParam2);</span>

3.1）这里， implicitParam对象是用脚本语言编写的对象的一个代理， 他必须是前一个脚本引擎调用的结果；

4）让脚本引擎去实现一个 java 接口， 然后就就可以用 java 方法调用的语法来调用该脚本函数；

4.1）看个荔枝：

step1）java接口：

<span style="font-family:Microsoft YaHei;font-size:14px;">public interface Greeter{    String greet(String whom);}</span>

step2）在脚本引擎如Rhino中， 可以提供下面的函数：

<span style="font-family:Microsoft YaHei;font-size:14px;">function greet(x){    return "hello" + x + "!";}</span>

step3）以上代码必须先计算，然后调用：

<span style="font-family:Microsoft YaHei;font-size:14px;">Greeter g = （（Invocable）engine）.getInterface(Greeter.class)；</span>

step4） 产生一个普通的java 方法调用：

<span style="font-family:Microsoft YaHei;font-size:14px;">String result = g.greet("world");</span>

<span style="font-family:Microsoft YaHei;font-size:14px;">public class InvocableTest{public static void main(String[] args) throws FileNotFoundException, ScriptException{// 脚本引擎管理器ScriptEngineManager manager = new ScriptEngineManager();ScriptEngine engine = manager.getEngineByName("JavaScript");engine.eval(new FileReader("com/corejava/chapter10/test.js"));Greeter g = ((Invocable)engine).getInterface(Greeter.class);String result = g.greet("World");System.out.println(result);// hello, World}}</span>

5）在面向对象的脚本语言中， 可以通过相匹配的 java 接口来访问一个脚本类。

5.1）看个荔枝： 

step1）下面的代码定义了一个 SimpleGreeter类，

<span style="font-family:Microsoft YaHei;font-size:14px;">function SimpleGreeter(salutation) {this.salutation = salutation};SimpleGreeter.prototype.greet = function(whom){return this.salutation + ", " + whom + "!" ;}</span>

step2） 在对 JavaScript的类定义计算后， 可以调用：

<span style="font-family:Microsoft YaHei;font-size:14px;">Object greeter = engine.eval("new SimpleGreenter('goodbye')");Greeter g = （（Invocable）engine）.getInterface(greeter , Greeter.class)；</span>

step3） 当调用 g.greet("world")时， greet 方法会在 js 对象 greenter 上被调用。 其结果是 “goodbye”；

<span style="font-family:Microsoft YaHei;font-size:14px;">public class SimpleGreeter{public static void main(String[] args) throws FileNotFoundException, ScriptException{// 脚本引擎管理器ScriptEngineManager manager = new ScriptEngineManager();ScriptEngine engine = manager.getEngineByName("JavaScript");engine.eval(new FileReader("com/corejava/chapter10/test.js"));Object goodbyeGreeter = engine.eval("new SimpleGreeter('goodbye')");Greeter g = ((Invocable)engine).getInterface(goodbyeGreeter, Greeter.class);String result = g.greet("World");System.out.println(result);// goodbye, World}}</span>

<span style="font-family:Microsoft YaHei;font-size:14px;">function greet(x){return "hello, " + x + "!";}function SimpleGreeter(salutation){this.salutation = salutation;}SimpleGreeter.prototype.greet = function(whom){return this.salutation + ", " + whom + "!" ;}</span>

Conclusion） 如果你希望从 java 中调用脚本代码， 同时又不想因这种脚本语言的语法而受到困扰， 那么Invocable 接口就很有用；

---

【1.5】 编译脚本

Attention） 将脚本进行编译后，再执行；

1）应用背景：某些脚本引擎处于对执行效率的考虑，可以将脚本代码编译为某种中间格式。这些引擎实现了　Compilable 接口；

2）看个荔枝：

<span style="font-family:Microsoft YaHei;font-size:14px;">Reader reader = new FileReader("script.js");CompiledScript script = null;if(engine implements Compilable)    script = ((Compilable )engine).compile(reader);</span>

3）一旦脚本被编译，就可以执行它，如果引擎不支持编译， 则执行原始脚本， 如：

<span style="font-family:Microsoft YaHei;font-size:14px;">if(script != null)    script.eval();else    engine.eval(reader);</span>

Attention） 当然，只有需要重复执行代码时， 我们才希望编译脚本；（干货——为什么编译脚本？——只有需要重复执行代码时， 我们才希望编译脚本）

<span style="font-family:Microsoft YaHei;font-size:14px;">public class CompileTest{public static void main(String[] args) throws FileNotFoundException, ScriptException{// 脚本引擎管理器ScriptEngineManager manager = new ScriptEngineManager();ScriptEngine engine = manager.getEngineByName("JavaScript");// 读取器Reader reader = new FileReader("com/corejava/chapter10/test.js");CompiledScript script = null;if(engine instanceof Compilable){    script = ((Compilable)engine).compile(reader); // 编译脚本}if(script != null){    script.eval();    System.out.println("执行编译后的脚本");}else{    engine.eval(reader);    System.out.println("执行脚本源码");}Object goodbyeGreeter = engine.eval("new SimpleGreeter('goodbye')");Greeter g = ((Invocable)engine).getInterface(goodbyeGreeter, Greeter.class);String result = g.greet("World");System.out.println(result);// goodbye, World}}</span>

Attention） for complete source code about instances  above, please visit https://github.com/pacosonTang/core-java-volume/tree/master/coreJavaAdvanced/chapter10/10_1  

---

【2】编译器API

1）有许多工具都需要调用java 编译器，如（tools）：

t1） 开发环境；

t2） java 教学和辅导程序；

t3）自动化的构建和测试工具；

t4）处理java 代码段的模板工具， 如 java server page（JSP）；

2） 在过去， 应用程序是通过在 jdk/lib/tools.jar类库中未归档的类调用 java 编译器的。

3）从java SE6 开始， 用于编译的一个公共API 成为 java 平台的一部分，并且它再也不需要使用 tools.jar 了；

---

【2.1】编译便捷之法

1）调用编译器的荔枝：

<span style="font-family:Microsoft YaHei;font-size:14px;">JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();OutputStream out = ...OutputStream err = ...int result = compiler.run(null, out, err, "-sourcepath", "src", "Test.java"); // 返回值为0 表示编译成功；</span>

package com.corejava.chapter10_2;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.OutputStream;import javax.tools.JavaCompiler;import javax.tools.ToolProvider;public class JavaCompilerTest{public static void main(String[] args) throws FileNotFoundException{JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();OutputStream out = new FileOutputStream("out.txt");OutputStream err = new FileOutputStream("err.txt");System.out.println(compiler);System.out.println(System.getProperty("java.home"));int result = compiler.run(null, out, err, "com/corejava/chapter10_2/Hello.java");if(result == 0){System.out.println("bingo");}else{System.out.println("oops");}}}

对以上代码的分析（Analysis）：

A1） 编译器会向 提供给他 的流发送输出和错误消息；

A2）如果将这些参数设置为null， 就会使用 System.out 和 System.err；

A3） run 方法的第一个参数是输入流， 由于编译器不会接受任何控制台输入， 因此总是应该让其保持为null；

A4） 如果在命令行调用 javac， 那么run 方法其余的参数就会作为 变量传递给 javac；

---

【2.2】使用编译工具（for detailed info, please visithttp://blog.csdn.net/pacosonswjtu/article/details/50718602）

1）可以通过使用 CompilationTask 对象来对编译过程进行更多的控制， 如（controls）：

c1）控制程序代码的来源；

c2）控制类文件的位置；

c3）监听在编译过程中产生的错误和警告消息；

c4）在后台运行编译器；

2）源代码和类文件的位置：由　JavaFileManager 控制的， 它负责确定源代码和类文件的 JavaFileObject 实例；

3） 为了监听错误消息， 需要安装一个 DiagnosticListener： 这个监听器在编译器报告警告或错误消息时会收到一个 Diagnostic 对象。 DiagnosticCollector类实现了这个接口， 他将收集所有的 诊断信息， 使得你可以在编译完成之后遍历这些信息；

4）通过调用JavaCompiler 类的 getTaksk 方法 来获得 CompilationTask 对象， 这时需要指定（sepecification）：

s1）一个用于所有编译器输出的Writer： 如果是null， 则使用 System.err；

s2）一个 JavaFileManager：  如果是null， 则使用编译器的标准文件管理器；

s3）一个 DiagnosticListener；

s4）选项字符串：  如果没有选项， 则为null；

s5）用于注解处理的类名字： 如果没有指定类名字， 则为null；

s6）用于源文件的 JavaFileObject 实例；

5）需要为最后3个参数提供 Iterable 对象， 如：

Iterable<String> options = Arrays.asList("-g", "-d", "classes");

6）如果希望编译器从磁盘读取源文件， 可以让 StandardJavaFileManager 将文件 名字符串或 File 对象转译成 JavaObject 实例， 如：

<span style="font-family:Microsoft YaHei;font-size:14px;">StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null) ;Iterable<JavaFileObject> fileObjects = fileManager.getJavaFileObjectsFromStrings(filename);</span>

7） 如果希望 编译器从磁盘之外的地方读取 源代码： 可以提供自己的 JavaFileObject 的子类；

8）CompilationTask接口： 扩展了Callable<Boolean>接口，可以将其传递给一个 Executor， 使其可以在另一个线程中执行， 或者可以直接调用call 方法。返回值如果是 false， 则调用失败；

<span style="font-family:Microsoft YaHei;font-size:14px;">Callable<Boolean> task = new JavaCompiler.compilationTasks(null, fileManager, diagnostics,  options, null, fileObjects);if(!task.call())    println("compilation failed");</span>

9）problem+solution：

9.1）problem：事实证明，要告知编译器的文件管理器去使用这些文件对象还是比较棘手的，因为类库没有提供实现了 StandardJavaFileManager 接口的类；

9.2）solution：我们需要子类化 ForwardingJavaFileManager 类， 该类将所有的调用都代理给了给定的文件管理器。

Conclusion）

C1） 总之，如果只是想以常规的方式调用编译器， 那就只需要调用 JavaCompiler 任务的run方法， 去读写磁盘文件；

C2）如果想对文件处理和错误报告进行更多 的控制， 可以使用 CompilationTask 类；

---