java平台脚本+java编译器API

最新推荐文章于 2023-07-06 18:13:08 发布

PacosonSWJTU

最新推荐文章于 2023-07-06 18:13:08 发布

阅读量1.3k

点赞数

分类专栏： (3)core_java_advanced

(3)core_java_advanced 专栏收录该内容

71 篇文章 1 订阅

订阅专栏

【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.0
		System.out.println(result);
		
		// 获取由脚本语句绑定的变量 
		engine.put("k", 100);
		result = engine.eval("k+1"); // 101
		System.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函数产生的输出都会发送到 writer
		StringWriter 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函数产生的输出都会发送到 writer
		StringWriter 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 visit http://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 类；

PacosonSWJTU

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java平台脚本+java编译器API

【0】README0.1）本文文字描述转自 core java volume 2，旨在学习 java平台脚本+java编译器API 的基础知识；------------------------------------------------------------------------------【1】java平台的脚本 1）脚本语言定义：脚本语言是一种通过在运行时解
复制链接

扫一扫