java6内置JS引擎初接触

test01.js:

if(age>=18){  
    print('Old enough to vote!');  
}else{  
    print('Back to school!');  
}

test02.js:

if(age<25){  
    riskFactor = 1.5;  
}else if(noClaims){  
    ristFactor = 0.75;  
}else{  
    ristFactor = 1.0;  
}

test03.js:

function Hello(){}   
Hello.prototype.sayHello = function(value) {
    println('hello!'+value);
}
Hello.prototype.increment = function(value) {
    return i+1;
}

var hello = new Hello();
hello.sayHello('World1');

Hello.java:

package com.hjr.demo.util.js;

public interface Hello {
    public int increment(int value);
    public void sayHello(String name);
}

ScriptEngineDemo.java:

package com.hjr.demo.util.js;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.PipedReader;
import java.io.PipedWriter;
import java.io.PrintWriter;

import javax.script.*;

public class ScriptEngineDemo {
	public static void main(String[] args) throws Exception {
		test10();
	}
	
	// 使用脚本引擎运行脚本程序
	public static void test01() throws ScriptException {
		// 若是调用者可访问线程上下文 ClassLoader，则调用此构造方法的效果与调用 ScriptEngineManager(Thread.currentThread().getContextClassLoader()) 相同  
	    // ScriptEngineManager检索感兴趣的脚本编写的语言的ScriptEngine对象 
		ScriptEngineManager manager = new ScriptEngineManager();
		ScriptEngine engine = manager.getEngineByName("js");
		engine.put("age", 26);
		engine.eval("if(age>=18){println('Old enough to vote!');}else{println('Back to school!');}");
	}
	
	// 使用脚本引擎执行外部资源中的脚本
	public static void test02() throws FileNotFoundException, ScriptException {
		ScriptEngineManager manager = new ScriptEngineManager();
		ScriptEngine engine = manager.getEngineByName("js");
		engine.put("age", 26);
		engine.eval(new FileReader("E:/ScriptEngine/test01.js"));// 对文件或其它外部资源中得脚本表达式进行求值  
	}
	
	// 使用脚本引擎检索结果
	public static void test03() throws FileNotFoundException, ScriptException {
		ScriptEngineManager manager = new ScriptEngineManager();
		ScriptEngine engine = manager.getEngineByName("js");
		engine.put("age", 26);
		engine.put("noClaims", Boolean.TRUE);
		Object result = engine.eval(new FileReader("E:/ScriptEngine/test02.js"));// eval()函数返回执行脚本后所返回的值，默认状况下，将返回上次执行的表达式的值  
		System.out.println(result.toString());
	}
	
	// 上下文属性的做用域
	public static void test04() throws ScriptException {
		ScriptEngineManager manager = new ScriptEngineManager();
		Bindings globalBindings = manager.getBindings(); // 属于ScriptEngineManager的全局上下文,每一个ScriptEngineManager拥有一个Bindings
		globalBindings.put("name", "yangYong");
		ScriptEngine engine = manager.getEngineByName("js");
		Bindings globalBindings02 = engine.getBindings(ScriptContext.GLOBAL_SCOPE); // 每一个引擎都共有一个ScriptEngineManager的Bindings
		System.out.println("name=" + globalBindings02.get("name"));
		System.out.println(globalBindings == globalBindings02);
		ScriptContext context = engine.getContext(); // 每一个引擎都有本身独立的scriptContext上下文
		
		Bindings engineDefaultBindings = engine.getBindings(ScriptContext.ENGINE_SCOPE); // 每一个引擎的scriptContext中都有个默认属于本身的Bindings
		engineDefaultBindings.put("gender", "男");
		engine.eval("name2 = name;println(name2);", engineDefaultBindings);
		engineDefaultBindings.put("name", "zhangSan");
		engine.eval("name2 = name;println(name2)", engineDefaultBindings);
		Bindings engineCreateBindings = engine.createBindings(); // 每一个引擎的scriptContext中也能够新建多个属于本身的Bindings
		engineCreateBindings.put("gender", "女");
		System.out.println(engineDefaultBindings == engineCreateBindings);
		System.out.println(engine.getBindings(ScriptContext.ENGINE_SCOPE));
		System.out.println(engineCreateBindings.get("gender"));
		engine.eval("name2 = name;println(name2)", engineCreateBindings);
	}
	
	// java应用程序与脚本交互
	public static void test05() throws ScriptException {
		ScriptEngineManager manager = new ScriptEngineManager();
		ScriptEngine engine = manager.getEngineByName("js");
		Bindings bindings = engine.createBindings(); // Bindings:KV对映射，用来在Java应用程序和javascript脚本之间交换信息，即上下文
		bindings.put("age", 26);
		bindings.put("noClaims", Boolean.TRUE);
		bindings.put("riskFactor", 1.0);
		engine.eval("if(age<25){riskFactor = 1.5;}else if(noClaims){ristFactor = 0.75;}else{ristFactor = 1.0;}", bindings);//必须绑定bindings执行脚本，不然报变量未定义异常  
	    double risk = (Double) bindings.get("riskFactor");
	    System.out.println(risk);
	}
	
	// 脚本内部访问java资源
	public static void test06() throws ScriptException {
		ScriptEngineManager manager = new ScriptEngineManager();
		ScriptEngine engine = manager.getEngineByName("js");
		engine.eval("importPackage(java.util)");
		engine.eval("today = new Date();println(today)");
		engine.put("name", "ZhangSan");
		engine.eval("name2 = name.toUpperCase();println(name2);");
	}
	
	// 重定向脚本输出
	public static void test07() throws IOException, ScriptException {
		ScriptEngineManager manager = new ScriptEngineManager();
		ScriptEngine engine = manager.getEngineByName("js");
		
		PipedReader pr = new PipedReader();
		PipedWriter pw = new PipedWriter(pr);
		// 用户能够经过与这个 PrintWriter 连通的 PrintReader 读取实际的输出，使 Java 应用程序能获取脚本运行输出
		PrintWriter out = new PrintWriter(pw);
		engine.getContext().setWriter(out);
		
		engine.eval("println('hello from javascript!');");
		
		BufferedReader br = new BufferedReader(pr);
		System.out.println(br.readLine());
	}
	
	// 可编译且可调用的引擎
	public static void test08() throws ScriptException {
		ScriptEngineManager manager = new ScriptEngineManager();
		ScriptEngine engine = manager.getEngineByName("js");
		
		if (engine instanceof Compilable) { // 判断脚本引擎是否支持编译操做
			Compilable compilable = (Compilable)engine;
			CompiledScript script = compilable.compile("if(age<25){riskFactor = 1.5;}else if(noClaims){ristFactor = 0.75;}else{ristFactor = 1.0;}");
			
			Bindings bindings = engine.createBindings();
			bindings.put("age", 26);
            bindings.put("noClaims", Boolean.TRUE);
            bindings.put("riskFactor", 1.0);
			
            Object result = script.eval(bindings);
            System.out.println(result.toString());
		}
	}
	
	// 调用脚本中的函数和方法
	public static void test09() throws ScriptException, NoSuchMethodException, FileNotFoundException {
		ScriptEngineManager manager = new ScriptEngineManager();
		ScriptEngine engine = manager.getEngineByName("js");
		
		engine.eval("function increment(i){return i+1;}");
	    if (engine instanceof Invocable) { // 判断脚本引擎是否支持编译操做
	        Invocable invocable = (Invocable)engine; // Invocable容许从java代码调用定义在脚本中的单个函数  
	        Object result = invocable.invokeFunction("increment", new Object[]{10}); // 调用脚本中定义的顶层程序和函数
	        System.out.println("result = "+result);
	    }
	    
	    ScriptEngine engine2 = manager.getEngineByName("js");
	    engine2.eval(new FileReader("E:/ScriptEngine/test03.js"));
	    if (engine2 instanceof Invocable) {
	        Invocable invocable = (Invocable)engine2;
	        invocable.invokeMethod(engine2.get("hello"), "sayHello", "yangYong"); // 对之前的脚本执行中已经编译的脚本对象（以 ScriptEngine 的状态保持）调用某一方法
	    }  
	}
	
	// 调用脚本中的函数和方法并将他们做为java程序中的接口实现
	public static void test10() throws FileNotFoundException, ScriptException {
		/**
		 * TODO 这个用例存在问题，待处理
		 */
	    ScriptEngineManager manager = new ScriptEngineManager();
	    ScriptEngine engine = manager.getEngineByName("js");
	    engine.eval("function increment(i){return i+1;}");
	    
	    if (engine instanceof Invocable) {
	        Invocable invocable = (Invocable)engine;
	        Hello hello = invocable.getInterface(Hello.class); // 返回一个接口的实现，该接口使用解释器中编译的函数
	        Object result = hello.increment(2);
	        System.out.println("result = " + result);
	    }
	    
	    engine.eval(new FileReader("E:/ScriptEngine/test03.js"));
	    if (engine instanceof Invocable) {
	        Invocable invocable2 = (Invocable)engine;
	        Hello hello = invocable2.getInterface(engine.get("hello"), Hello.class); // 返回一个接口的实现，该接口使用解释器中已编译脚本对象的成员函数
	        hello.sayHello("zhangSan");
	    }  
	}  
}