这里主要总结Java中集成Groovy的应用。
Groovy可以与Java完美集成来扩展我们的应用，比如替代Java+jexl实现算式表达式计算或其它功能。在Ofbiz中也集成了Groovy来执行一些查询功能,并且是开始更多的使用Groovy而不是原有的bsh。这里仅仅初步总结我们在Java项目中如何来应用Groovy扩展我们的应用。
1.使用GroovyShell计算表达式
使用Binding对象将变量传入表达式，并通过GroovyShell返回表达式的计算结果。如下例：
public class GroovyShellExample {
public static void main(String args[]) {
Binding binding = new Binding();
binding.setVariable("x", 10);
binding.setVariable("language", "Groovy");
GroovyShell shell = new GroovyShell(binding);
Object value = shell.evaluate("println \"Welcome to $language\"; y = x * 2; z = x * 3; return x ");
System.err.println(value +", " + value.equals(10));
System.err.println(binding.getVariable("y") +", " + binding.getVariable("y").equals(20));
System.err.println(binding.getVariable("z") +", " + binding.getVariable("z").equals(30));
}
}
运行结果如下：
Welcome to Groovy
10, true
20, true
30, true
2．使用GroovyScriptEngine脚本引擎加载Groovy脚本
GroovyScriptEngine从指定的位置（文件系统，URL，数据库等等）加载Groovy脚本，并且随着脚本变化可重新加载它们。和GroovyShell一样，GroovyScriptEngine也可以传进变量值返回脚本的计算结果。这样我们可以把一些可用的计算公式或计算条件写入Groovy脚本中来执行应用计算。当这些公式或计算条件变更时，我们可更方便地进行更改计算。如：
public class GroovyScriptEngineExample {
public static void main(String args[]) {
try {
String[] roots = new String[]{".\\src\\sample\\"} ;//定义Groovy脚本引擎的根路径
GroovyScriptEngine engine = new GroovyScriptEngine(roots);
Binding binding = new Binding();
binding.setVariable("language", "Groovy");
Object value = engine.run("SimpleScript.groovy", binding);
assert value.equals("The End");
} catch (Exception e) {
e.printStackTrace();
}
}
}
SimpleScript.groovy脚本如下：
//SimpleScript.groovy
println "Welcome to $language"
return "The End"
运行结果如下：
Welcome to Groovy
3．使用GroovyClassLoader动态地载入Groovy的类
下例现示如何使用GroovyClassLoader加载Groovy类并且调用该类的一个方法
package sample;
public class GroovyClassLoaderExample {
public static void main(String args[]) {
try {
GroovyClassLoader loader = new GroovyClassLoader();
Class fileCreator = loader.parseClass(new File("GroovySimpleFileCreator.groovy"));
GroovyObject object = (GroovyObject) fileCreator.newInstance();
object.invokeMethod("createFile", "C:\\temp\\emptyFile.txt");
} catch (Exception e) {
e.printStackTrace();
}
}
}
GroovySimpleFileCreator.groovy文件如下：
package sample;
class GroovySimpleFileCreator {
public createFile(String fileName){
File file = new File(fileName);
file.createNewFile();
}
}
使用GroovyClassLoader另一种情景便是：存在一个Java接口和一个实现该Java接口的Groovy类。此时，可以通过GroovyClassLoader加载Groovy实现类到应用中，这样就可以直接调用该接口的方法。
接口定义如下：
package sample;
public interface IFoo {
Object run(Object foo);
}
package sample;
public class InvokeGroovy {
public static void main(String[] args) {
ClassLoader cl = new InvokeGroovy().getClass().getClassLoader();
GroovyClassLoader groovyCl = new GroovyClassLoader(cl);
try {
//从文件中读取，将实现IFoo接口的groovy类写在一个groovy文件中
//Class groovyClass = groovyCl.parseClass(new File("./src/sample/Foo.groovy"));
//直接使用Groovy字符串,也可以获得正确结果
Class groovyClass = groovyCl.parseClass("package sample; \r\n class Foo implements IFoo {public Object run(Object foo) {return 2+2>1}}");//这个返回true
IFoo foo = (IFoo) groovyClass.newInstance();
System.out.println(foo.run(new Integer(2)));
} catch (Exception e) {
e.printStackTrace();
}
}
}
4．使用JAVA脚本API （没有理解明白）
Java SE 6 引入了对 Java Specification Request（JSR）223 的支持，JSR 223 旨在定义一个统一的规范，使得 Java 应用程序可以通过一套固定的接口与各种脚本引擎交互，从而达到在 Java 平台上调用各种脚本语言的目的。每一个脚本引擎就是一个脚本解释器，负责运行脚本，获取运行结果。ScriptEngine 接口提供了许多 eval 函数的变体用来运行脚本，这个函数的功能就是获取脚本输入，运行脚本，最后返回输出。
下例显示了一个使用JAVA脚本API运行Groovy的例子：
public class GroovyJSR223Example {
public static void main(String args[]) {
try {
ScriptEngineManager factory = new ScriptEngineManager();
ScriptEngine engine = factory.getEngineByName("groovy");
String HelloLanguage = "def hello(language) {return \"Hello $language\"}";
engine.eval(HelloLanguage);
Invocable inv = (Invocable) engine;
Object[] params = {new String("Groovy")};
Object result = inv.invokeFunction("hello", params);
assert result.equals("Hello Groovy");
System.err.println(result);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
需要注意的是，通过看groovy的创建类的地方，就能发现，每次执行的时候，都会新生成一个class文件，这样就会导致JVM的perm区持续增长，进而导致FullGCc问题，解决办法很简单，就是脚本文件变化了之后才去创建文件，之前从缓存中获取即可，缓存的实现可以采用简单的Map或者使用之前文章提到的EhCache（同时可以设置缓存有效期，降低服务器压力）。
在使用时，最好每次重新new classloader，因为如果脚本重新加载了，这时候就会有新老两个class文件，如果通过一个classloader持有的话，这样在GC扫描的时候，会认为老的类还在存活，导致回收不掉，所以每次new一个就能解决这个问题了。
注意CodeCache的设置大小（来自：http://hellojava.info/）
对于大量使用Groovy的应用，尤其是Groovy脚本还会经常更新的应用，由于这些Groovy脚本在执行了很多次后都会被JVM编译为native进行优化，会占据一些CodeCache空间，而如果这样的脚本很多的话，可能会导致CodeCache被用满，而CodeCache一旦被用满，JVM的Compiler就会被禁用，那性能下降的就不是一点点了。
Code Cache用满一方面是因为空间可能不够用，另一方面是Code Cache是不会回收的，所以会累积的越来越多（其实在不采用groovy这种动态更新/装载class的情况下的话，是不会太多的），所以解法一可以是增大code cache的size，可通过在启动参数上增加-XX:ReservedCodeCacheSize=256m（Oracle JVM Team那边也是推荐把code cache调大的），二是启用code cache的回收机制（关于Code Cache flushing的具体策略请参见此文），可通过在启动参数上增加：-XX:+UseCodeCacheFlushing来启用。
转载引用：https://www.poorren.com/java-groovy-dynamic-algorithm