前言

由于一些需求，现在需要在Java中解析字符串，做一些简单的算数运算和逻辑运算，那么最先想的是模板引擎这个东西，但是Java中的模板引擎是针对View层的，也就是JSP的，在Service层中使用不是太方便，因此选用了原生的JavaScript脚本解析引擎。实际上Java原生支持解析大部分脚本语言，像JavaScript，PHP，Python等。

那么，先贴一下核心实现类的代码：

import java.io.FileNotFoundException;
import java.util.Map;

import javax.script.ScriptException;

public interface TempletEngineService {
	
	public Object eval(String script) throws ScriptException, FileNotFoundException;
	
	public Object eval(String script, Map<String, Object> vars) throws ScriptException, FileNotFoundException;
	
}

然后是实现类：

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

@Service
public class TempletEngineServiceImpl implements TempletEngineService {

	private ScriptEngine jsEngine;
	
	public TempletEngineServiceImpl() {
		ScriptEngineManager manager = new ScriptEngineManager();
		jsEngine = manager.getEngineByName("JavaScript");
	}
	
	@Override
	public Object eval(String script) throws ScriptException, FileNotFoundException {
		if (script == null || script.equals("")) {
			return null;
		}
		String jsfile = "/home/phw/Workspaces/MyEclipseProjects/gomoo-fu/src/com/gomoo/util/script/template.js";
		jsEngine.eval(new FileReader(new File(jsfile)));
		return jsEngine.eval(script);
	}
	
	@Override
	public Object eval(String script, Map<String, Object> vars) throws ScriptException, FileNotFoundException {
		if (script == null || script.equals("")) {
			return null;
		}
		if (vars == null || vars.isEmpty()) {
			for (Map.Entry<String, Object> entry: vars.entrySet()) {
				jsEngine.put(entry.getKey(), entry.getValue());
			}
		} 
		return eval(script);
	}

}

主要的核心类就是这两个文件，可以看到，用到的解析引擎是javax.script包下的引擎。

脚本是自定义的一串符合JavaScript规则的字符串，像简单点的字符串“5 + 6”、"9 - (6 + 5) * 5"等等，可以直接执行eval函数；若需要计算一些复杂的逻辑，那可以写到你自定义的一个js文件里，然后在脚本中运行那个函数；那再复杂一点，在函数中或者脚本中带自定义参数，这时就用到了eval(String script, Map vars)函数了。

下面是一些例子：

/**
	 * 简单字符串的测试
	 * @throws ScriptException 
	 * @throws FileNotFoundException 
	 */
	@Test
	public void testEval() throws FileNotFoundException, ScriptException {

		String script = "(65 - 5) / (3 * 6)";
		String script2 = "15 > 10 ? 15 : 10";
		String script3 = "15 > 10";
		
		Object val1 = templetEngineService.eval(script);
		System.out.println("脚本1的结果为：" + val1);
		Object val2 = templetEngineService.eval(script2);
		System.out.println("脚本2的结果为：" + val2);
		Object val3 = templetEngineService.eval(script3);
		System.out.println("脚本3的结果为：" + val3);
		
	}

	/**
	 * 脚本1的结果为：3.3333333333333335
	 * 脚本2的结果为：15
	 * 脚本3的结果为：true
	 */

	/**
	 * 带函数的脚本测试
	 * @throws ScriptException 
	 * @throws FileNotFoundException 
	 */
	@Test
	public void testEval2() throws FileNotFoundException, ScriptException {
		String script = "random()";
		String script2 = "random() + random()";
		Object val1 = templetEngineService.eval(script);
		System.out.println("脚本1的结果为：" + val1);
		Object val2 = templetEngineService.eval(script2);
		System.out.println("脚本2的结果为：" + val2);
	}
	
	/**
	 * 脚本1的结果为：63.0
	 * 脚本2的结果为：163.0
	 */

	/**
	 * 带参数的脚本测试
	 * @throws FileNotFoundException
	 * @throws ScriptException
	 */

	@Test
	public void testEval3() throws FileNotFoundException, ScriptException {
		
		String script = "random(min, max)";
		String script2 = "random(min, max) + min - max";
		
		Map<String, Object> vars = new HashMap<>();
		vars.put("min", 10);
		vars.put("max", 100);
		Object val1 = templetEngineService.eval(script, vars);
		System.out.println("脚本1的结果为：" + val1);
		
		Map<String, Object> vars2 = new HashMap<>();
		vars.put("min", 100);
		vars.put("max", 1000);
		Object val2 = templetEngineService.eval(script2, vars2);
		System.out.println("脚本2的结果为：" + val2);
	}

	/**
	 * 脚本1的结果为：69.0
	 * 脚本2的结果为：-65.0
	 */

/**
	 * 参数为类时的脚本测试
	 * @throws FileNotFoundException
	 * @throws ScriptException
	 */
	@Test
	public void testEval4() throws FileNotFoundException, ScriptException {
		
		User user = new User();
		user.setRealName("phw");
		String script = "out(user)";
		Map<String, Object> vars = new HashMap<>();
		vars.put("user", user);
		Object val = templetEngineService.eval(script, vars);
		System.out.println("脚本1的结果为：" + val);
	}
	
	/**
	 * 脚本1的期望结果：phw
	 */

下面贴一下template.js，也就是我们预定义的Js function的文件：

/**
 * 生成100内的随机数
 */
function random() {
	return Math.floor(Math.random() * 100);
}

/**
 * 生成区间内的随机整数[m, n]
 */
function random(minNum,maxNum){
  switch(arguments.length){ 
      case 1: 
          return parseInt(Math.random()*minNum+1,10); 
      break; 
      case 2: 
          return parseInt(Math.random()*(maxNum-minNum+1)+minNum,10); 
      break; 
          default: 
              return 0; 
          break; 
  } 
}

function out(obj) {
	return obj.realName;
}

以上就是测试里用到的js function函数，再说一下，脚本不支持es6的语法，所以老老实实用var，不要用let。

以上。

最近有一个小小的需求，就是在java中解析javascript脚本,JDK6就已经支持脚本语言了,针对JS有js引擎ScriptEngine。但是我在使用过程觉得用的不是很方便，比较别扭，经研究发现还有一个更强大的脚本引擎-mozilla提供的rhino

Java用ScriptEngine解析脚本

　　javax.script，始于JDK1.6，不过现在只有sun实现的javascript的解析器，难道是因为主要用来解析js语法所以归类到JEE的范畴？不过基本足够了，一般的用途主要是能解析通用的表达式就好，比如X >= 1（X作为参数传入）这样的表达式，也能利用js的函数语法，创造一个就像java的函数一样存在于内存中随时可以被调用的函数，更可以将js中的对象直接转换成java对象。

Script主要类及接口

ScriptEngineManager、ScriptEngine、CompiledScript和Bindings 4个类或接口

1. ScriptEngineManager是一个工厂的集合，可以通过name或tag的方式获取某个脚本的工厂并生成一个此脚本的ScriptEngine，目前只有javascript的工厂。通过工厂函数得到了ScriptEngine之后，就可以用这个对象来解析脚本字符串了，直接调用Object obj = ScriptEngine.eval(String script)即可，返回的obj为表达式的值，比如true、false或int值。
2. CompiledScript可以将ScriptEngine解析一段脚本的结果存起来，方便多次调用。只要将ScriptEngine用Compilable接口强制转换后，调用compile(String script)就返回了一个CompiledScript对象，要用的时候每次调用一下CompiledScript.eval()即可，一般适合用于js函数的使用。
3. Bindings的概念算稍微复杂点，我的理解Bindings是用来存放数据的容器。它有3个层级，为Global级、Engine级和Local级，前2者通过ScriptEngine.getBindings()获得，是唯一的对象，而Local Binding由ScriptEngine.createBindings()获得，很好理解，每次都产生一个新的。Global对应到工厂，Engine对应到ScriptEngine，向这2者里面加入任何数据或者编译后的脚本执行对象，在每一份新生成的Local Binding里面都会存在。

ScriptEngine代码示例

先来看一段JS

var arrclass = new Array();
arrclass.push(new Class(20000,"计算机-软件开发"));
arrclass.push(new Class(30000,"计算机-网络/通讯"));
arrclass.push(new Class(10000,"计算机-硬件开发"));
arrclass.push(new Class(40000,"计算机-管理"));
arrclass.push(new Class(50000,"计算机-品质管理/技术支持"));
arrclass.push(new Class(320000,"电子/电器/半导体/仪器仪表"));

java代码实现解析

public void parseJS() {
  //1、通过Http请求获取js的String数据，格式如上
  String jsData = getJsData("url");
  //2、观察js结构，自定义Class,push到数组中,java中需要定义跟js中的Class的声明
  String clazz = "function Class(classId, className){ this.classId=classId;this.className=className};";

  //3、初始化ScriptEngine
  ScriptEngine engine = new ScriptEngineManager().getEngineByName("javascript");
  //4、js中未定义返回对象,这里需要将Class数据转换成字符串的数组返回，个人觉得很别扭，不知道是理解错误还是确实如此？
  //如果不这样做则直接在js后加上arrclass，cScript.evel()则返回NativeObject对象的数组
  String fun = "var result = new Array() ;for(var i=0;i <arrclass.length;i++){result.push(new Array(arrclass[i].classId,arrclass[i].className))}; result;";
  Compilable compilable = (Compilable) engine;
  //4、使用NativeArray获取数据
  CompiledScript cScript;
  try {
     cScript = compilable.compile(clazz + jsData + fun);
     NativeArray na = (NativeArray) cScript.eval();
     for (int i = 0; i < na.getLength(); i++) {
         NativeArray nv = (NativeArray) na.get(i, null);
         System.out.println(nv.get(0, null).toString() + " " + nv.get(1, null).toString());
     }
 } catch (ScriptException ex) {
     ex.printStackTrace();
 }
}

java代码中执行js计算

public void js() {  
    // 创建脚本引擎管理器  
    ScriptEngineManager sem = new ScriptEngineManager();  
    // 创建一个处理JavaScript的脚本引擎  
    ScriptEngine engine = sem.getEngineByExtension("js");  
    try {  
        // 执行js公式  
        engine.eval("if(6>5){flag=true;}else{flag =false;}");  
    } catch (ScriptException ex) {
        ex.printStackTrace();  
    }  
    //看看我们预期的反馈结果 true  
    System.out.println(engine.get("flag"));  
}  

Java解析JS另一大引擎-Rhino

Rhino是完全用Java编写的JavaScript的开放源代码实现。它通常是嵌入到Java应用程序提供给最终用户的脚本。它被镶嵌在J2SE6作为默认的Java脚本引擎。

使用Rhino来解析，感觉一切都很清晰明朗.

public void parseJS() {
  //1、通过Http请求获取js的String数据，格式如上
  String jsData = getJsData("url");
  //2、定义跟js中的Class的声明
  String clazz = "function Class(classId, className){ this.classId=classId;this.className=className};";
  //3、初始化Context
  Context cx = Context.enter();
  Scriptable scope = cx.initStandardObjects();
  Object result = cx.evaluateString(scope, clazz + jsData + ";arrclass", "arrclass", 1, null);
  System.out.println(NativeJSON.stringify(cx, scope, result, null, null));
  Context.exit();
} 

第一次用java解析js文件，实现后台调用前台方法实现验证

1.js文件（放在src下）

function alert() {
}

//根据名字取标签的值

function getVal(name) {
    return document.getElementsByName(name)[0].value;
}

function checkRate(name) {
    var re =/^([a-zA-Z0-9_-])+@([a-zA-Z0-9_-])+(.[a-zA-Z0-9_-])+/;
    var nubmer =getVal(name);
    if (!re.test(nubmer)) {
        alert("请输入正确格式的邮件地址");
        // document.getElementById("email").value = "";
        return false;
    }
    return true;
}

<html>
<head>
    <title>Title</title>
    <script type="text/javascript">
        function validateForm() {
            alert(checkRate("email"));
        }



    </script>
</head>
<body>
邮箱：<input type="text" name="email" id="email" οnblur="checkRate('email')"><br>
<input type="button" value="validate" οnclick="validateForm()"/>

</body>
</html>

package com.test;

import java.io.FileReader;
import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;

/**
 * Created by gaoziang on 2017/8/28.
 */
public class FunctionTest {
    public static void main(String[] args) throws Exception{
 
        ScriptEngineManager manager = new ScriptEngineManager();
        ScriptEngine engine = manager.getEngineByName("javascript");
        String jsFileName = "src/JavaScript";
        // 读取js文件
        FileReader reader = new FileReader("src/validate.js");
        // 执行指定脚本
        engine.eval(reader);

//此处的email是定义在主函数里的，正常应从表单提交里接收到email文本框的值并赋值给email

        String email="907273324@qq.com";

/此处重新定义一个getVal方法，这样在js里的checkRate方法就会调用下面的新的getVal方法，实现了避开document对象，如果不重写就会提示document没定义，外部js没法单独用document。
        engine.eval("function getVal(name) {var json = {'name':"+"'"+email+"'"+"};return json[name];}");
        if(engine instanceof Invocable) {
            Invocable invoke = (Invocable)engine;
            Boolean boo=(boolean)invoke.invokeFunction("checkRate","name");
            System.out.println("boo="+boo);


        }
        reader.close();
    }
}