JAVA嵌入运行Groovy脚本

    最近设计一个数据统计系统,系统中上百种数据统计维度,而且这些数据统计的指标可能随时会调整.如果基于java编码的方式逐个实现数据统计的API设计,工作量大而且维护起来成本较高;最终确定为将"数据统计"的计算部分单独分离成脚本文件(javascript,或者Groovy),非常便捷了实现了"数据统计Task" 与 "数据统计规则(计算)"解耦,且可以动态的加载和运行的能力.顺便对JAVA嵌入运行Groovy脚本做个备忘.

    Java中运行Groovy,有三种比较常用的类支持:GroovyShell,GroovyClassLoader以及Java-Script引擎(JSR-223).

    1) GroovyShell: 通常用来运行"script片段"或者一些零散的表达式(Expression)

    2) GroovyClassLoader: 如果脚本是一个完整的文件,特别是有API类型的时候,比如有类似于JAVA的接口,面向对象设计时,通常使用GroovyClassLoader.

    3) ScriptEngine: JSR-223应该是推荐的一种使用策略.规范化,而且简便.

    官方参考文档：http://docs.groovy-lang.org/latest/html/documentation/guide-integrating.html

 

一.GroovyShell代码样例

    1) 简单的表达式执行,方法调用

/**
 * 简答脚本执行
 * @throws Exception
 */
public static void evalScriptText() throws Exception{
	//groovy.lang.Binding
	Binding binding = new Binding();
	GroovyShell shell = new GroovyShell(binding);
	
	binding.setVariable("name", "zhangsan");
	shell.evaluate("println 'Hello World! I am ' + name;");
	//在script中,声明变量,不能使用def,否则scrope不一致.
	shell.evaluate("date = new Date();");
	Date date = (Date)binding.getVariable("date");
	System.out.println("Date:" + date.getTime());
	//以返回值的方式,获取script内部变量值,或者执行结果
	//一个shell实例中,所有变量值,将会在此"session"中传递下去."date"可以在此后的script中获取
	Long time = (Long)shell.evaluate("def time = date.getTime(); return time;");
	System.out.println("Time:" + time);
	binding.setVariable("list", new String[]{"A","B","C"});
	//invoke method
	String joinString = (String)shell.evaluate("def call(){return list.join(' - ')};call();");
	System.out.println("Array join:" + joinString);
	shell = null;
	binding = null;
}

    GroovyShell是一种性能较低的方式，因为每次都需要创建shell和script，这也意味着每次都需要对expression进行“编译”（JAVA Class）。

    2)  伪main方法执行.

/**
 * 当groovy脚本,为完整类结构时,可以通过执行main方法并传递参数的方式,启动脚本.
 */
public static void evalScriptAsMainMethod(){
	String[] args = new String[]{"Zhangsan","10"};//main(String[] args)
	Binding binding = new Binding(args);
	GroovyShell shell = new GroovyShell(binding);
	shell.evaluate("static void main(String[] args){ if(args.length != 2) return;println('Hello,I am ' + args[0] + ',age ' + args[1])}");
	shell = null;
	binding = null;
}

    3)  通过Shell运行具有类结构的Groovy脚本

/**
 * 运行完整脚本
 * @throws Exception
 */
public static void evalScriptTextFull() throws Exception{
	StringBuffer buffer = new StringBuffer();
	//define API
	buffer.append("class User{")
			.append("String name;Integer age;")
			//.append("User(String name,Integer age){this.name = name;this.age = age};")
			.append("String sayHello(){return 'Hello,I am ' + name + ',age ' + age;}}\n");
	//Usage
	buffer.append("def user = new User(name:'zhangsan',age:1);")
			.append("user.sayHello();");
	//groovy.lang.Binding
	Binding binding = new Binding();
	GroovyShell shell = new GroovyShell(binding);
	String message = (String)shell.evaluate(buffer.toString());
	System.out.println(message);
	//重写main方法,默认执行
	String mainMethod = "static void main(String[] args){def user = new User(name:'lisi',age:12);print(user.sayHello());}";
	shell.evaluate(mainMethod);
	shell = null;
}

    4)  方法执行和分部调用

/**
 * 以面向"过程"的方式运行脚本
 * @throws Exception
 */
public static void evalScript() throws Exception{
	Binding binding = new Binding();
	GroovyShell shell = new GroovyShell(binding);
	//直接方法调用
	//shell.parse(new File(//))
	Script script = shell.parse("def join(String[] list) {return list.join('--');}");
	String joinString = (String)script.invokeMethod("join", new String[]{"A1","B2","C3"});
	System.out.println(joinString);
	////脚本可以为任何格式,可以为main方法,也可以为普通方法
	//1) def call(){...};call();
	//2) call(){...};
	script = shell.parse("static void main(String[] args){i = i * 2;}");
	script.setProperty("i", new Integer(10));
	script.run();//运行,
	System.out.println(script.getProperty("i"));
	//the same as
	System.out.println(script.getBinding().getVariable("i"));
	script = null;
	shell = null;
}

二. GroovyClassLoader代码示例

    1) 解析groovy文件

/**
 * from source file of *.groovy
 */
public static void parse() throws Exception{
	GroovyClassLoader classLoader = new GroovyClassLoader(Thread.currentThread().getContextClassLoader());
	File sourceFile = new File("D:\\TestGroovy.groovy");//文本内容的源代码
	Class testGroovyClass = classLoader.parseClass(new GroovyCodeSource(sourceFile));
	GroovyObject instance = (GroovyObject)testGroovyClass.newInstance();//proxy
	Long time = (Long)instance.invokeMethod("getTime", new Date());
	System.out.println(time);
	Date date = (Date)instance.invokeMethod("getDate", time);
	System.out.println(date.getTime());
	//here
	instance = null;
	testGroovyClass = null;
}

    2) 如何加载已经编译的groovy文件(.class)

public static void load() throws Exception {
	GroovyClassLoader classLoader = new GroovyClassLoader(Thread.currentThread().getContextClassLoader());
	BufferedInputStream bis = new BufferedInputStream(new FileInputStream("D:\\TestGroovy.class"));
	ByteArrayOutputStream bos = new ByteArrayOutputStream();
	for(;;){
		int i = bis.read();
		if( i == -1){
			break;
		}
		bos.write(i);
	}
	Class testGroovyClass = classLoader.defineClass(null, bos.toByteArray());
	//instance of proxy-class
	//if interface API is in the classpath,you can do such as:
	//MyObject instance = (MyObject)testGroovyClass.newInstance()
	GroovyObject instance = (GroovyObject)testGroovyClass.newInstance();
	Long time = (Long)instance.invokeMethod("getTime", new Date());
	System.out.println(time);
	Date date = (Date)instance.invokeMethod("getDate", time);
	System.out.println(date.getTime());
	
	//here
bis.close();
	bos.close();
	instance = null;
	testGroovyClass = null;
}

三. ScriptEngine

    1) pom.xml依赖

<dependency>
	<groupId>org.codehaus.groovy</groupId>
	<artifactId>groovy</artifactId>
	<version>2.1.6</version>
</dependency>
<dependency>
	<groupId>org.codehaus.groovy</groupId>
	<artifactId>groovy-jsr223</artifactId>
	<version>2.1.6</version>
</dependency>

    2) 代码样例

public static void evalScript() throws Exception{
	ScriptEngineManager factory = new ScriptEngineManager();
	//每次生成一个engine实例
	ScriptEngine engine = factory.getEngineByName("groovy");
	System.out.println(engine.toString());
	assert engine != null;
	//javax.script.Bindings
	Bindings binding = engine.createBindings();
	binding.put("date", new Date());
	//如果script文本来自文件,请首先获取文件内容
	engine.eval("def getTime(){return date.getTime();}",binding);
	engine.eval("def sayHello(name,age){return 'Hello,I am ' + name + ',age' + age;}");
	Long time = (Long)((Invocable)engine).invokeFunction("getTime", null);
	System.out.println(time);
	String message = (String)((Invocable)engine).invokeFunction("sayHello", "zhangsan",new Integer(12));
	System.out.println(message);
}

    需要提醒的是,在groovy中,${expression} 将会被认为一个变量,如果需要输出"$"符号,需要转义为"\$".   

    这是一种性能较高的方式，engine我们可以声明为全局实例，是线程安全的。每次调用时只需要创建新的Binndings即可，此外如果脚本已经编译过（首次执行之后）其Class将会被缓存，则此后不需要再次编译。

 

    关于ScriptEngine更多介绍,请参考.

 

---END---  

评论

3 楼 feidian1028 2014-04-25  

QING____ 写道

feidian1028 写道

兄弟，你的数据统计系统设计方案能否介绍下

这个可能说来话长..我简单描述一下:用户在系统中产生的操作,将会以日志的方式发送到采集系统(例如kafka,flume),然后再由统计系统负责分拣日志,将日志归类之后,分别存储在不同文件中,我们使用mongodb存储它们;在统计系统中,使用mongodb聚合框架--mapreduce来统计数据;因为统计系统是分布式部署,我们还有一个"单点worker"支撑系统,用来控制集群中.同一个统计任务(worker)只会在一个机器上运行;最终需要交付的是统计数据报表,比如: 2014.04.15日"PV"为120W.

mongodb中使用mapreduce是非常简单的,而且是编程良好的,可嵌入式的.这一点就决定了,开发者可以在"单点worker"系统指派统计系统分析数据时,从DB中获取map + reducer的脚本内容,然后运行它.

如果你使用过map-reducer开发过程序,你或许知道,map和reducer只不过是两个纯计算性的代码段,所以它们可以脱离运行环境,而独立的编写和保存,这也意味着它们无需被"固定"在一个java类中,所以把它们保存成Groovy脚本最好不过了;前提是你最好不要在map-reducer中执行有关业务性的代码,否则无法被剥离成Groovy脚本.

最终,我们把那些原本应该写在java类中的map-reducer代码块,"迁移"到了Groovy中,在我们的系统中,map和reducer分别为2个Groovy脚本文件,比如:PvMapper.groovy,PvReducer.groovy.
因为我们可以在java中非常便捷的调用groovy脚本,而且还可以向脚本"输入"参数,通常这种运行起来比较良好.最终groovy脚本的文本文件将会被保存在DB或者文件系统系统中.

因为Groovy可以被动态加载/解析/运行,所以我们编辑groovy脚本之后,无需重新发布统计系统,只需要在某个worker触发运行时,从文件系统中加载脚本即可.


我们有一个后台系统,我们可以在这个系统中通过文本编辑器来编写groovy脚本,也可以向每个脚本指定"参数列表",比如,你在groovy脚本中使用了$date参数,那么你可以配置$date = new Date(),不过每个参数,也是通过groovy引擎在运行时计算,并把结果传递给map-reducer脚本的.

最终统计的结果,将会后台系统中指定的存储地址,存储在文件中,并由分拣程序,负责将这些数据存储为结构化的格式,一遍后续的查询和报表设计.

十分感谢，讲解得很详细。我现在手头上也有一个类似的项目，希望在应用日志中分析出一些个性化的业务数据，分析的类型也会比较多变，所以也考虑用到这种方式。受启发了，多谢哈哈！

2 楼 QING____ 2014-04-25  

feidian1028 写道

兄弟，你的数据统计系统设计方案能否介绍下

这个可能说来话长..我简单描述一下:用户在系统中产生的操作,将会以日志的方式发送到采集系统(例如kafka,flume),然后再由统计系统负责分拣日志,将日志归类之后,分别存储在不同文件中,我们使用mongodb存储它们;在统计系统中,使用mongodb聚合框架--mapreduce来统计数据;因为统计系统是分布式部署,我们还有一个"单点worker"支撑系统,用来控制集群中.同一个统计任务(worker)只会在一个机器上运行;最终需要交付的是统计数据报表,比如: 2014.04.15日"PV"为120W.

mongodb中使用mapreduce是非常简单的,而且是编程良好的,可嵌入式的.这一点就决定了,开发者可以在"单点worker"系统指派统计系统分析数据时,从DB中获取map + reducer的脚本内容,然后运行它.

如果你使用过map-reducer开发过程序,你或许知道,map和reducer只不过是两个纯计算性的代码段,所以它们可以脱离运行环境,而独立的编写和保存,这也意味着它们无需被"固定"在一个java类中,所以把它们保存成Groovy脚本最好不过了;前提是你最好不要在map-reducer中执行有关业务性的代码,否则无法被剥离成Groovy脚本.

最终,我们把那些原本应该写在java类中的map-reducer代码块,"迁移"到了Groovy中,在我们的系统中,map和reducer分别为2个Groovy脚本文件,比如:PvMapper.groovy,PvReducer.groovy.
因为我们可以在java中非常便捷的调用groovy脚本,而且还可以向脚本"输入"参数,通常这种运行起来比较良好.最终groovy脚本的文本文件将会被保存在DB或者文件系统系统中.

因为Groovy可以被动态加载/解析/运行,所以我们编辑groovy脚本之后,无需重新发布统计系统,只需要在某个worker触发运行时,从文件系统中加载脚本即可.


我们有一个后台系统,我们可以在这个系统中通过文本编辑器来编写groovy脚本,也可以向每个脚本指定"参数列表",比如,你在groovy脚本中使用了$date参数,那么你可以配置$date = new Date(),不过每个参数,也是通过groovy引擎在运行时计算,并把结果传递给map-reducer脚本的.

最终统计的结果,将会后台系统中指定的存储地址,存储在文件中,并由分拣程序,负责将这些数据存储为结构化的格式,一遍后续的查询和报表设计.

1 楼 feidian1028 2014-04-25  

兄弟，你的数据统计系统设计方案能否介绍下