Many implementations of scripting and dynamically typed languages generate Java bytecodes so that programs can be run on the Java Platform, just as are actual Java programs. Implementing a language in this
way (or as a Java interpreter class for the scripting language) provides all the advantages of the Java platform: scripting implementations can take advantage of the Java platform‘s binary portability, security, and high performance bytecode execution.
上面这段话可以很好的回答为什么会有这么多基于Java平台的脚本语言。anyway，今天我们只是来看看怎么在我们的Java代码中执行脚本语言。下面使用两种语言来演示，Groovy 2.4.0和Scala 2.11.5。
有两种方式可以在Java中执行脚本，
Java SE includes JSR 223: Scripting for the Java Platform API. This is a framework by which Java applications can "host" script engines. The scripting framework supports third-party script engines using the JAR service discovery mechanism. It is possible to drop any JSR-223
compliant script engine in the CLASSPATH and access the same from your Java applications (much like JDBC drivers, JNDI implementations are accessed).
所以我们既可以使用JSR223的API来执行脚本，当然也可以直接使用脚本语言提供的API来执行了。下面分别来看看。
JSR-223
通过ScriptEngineManager#getEngineByName这个API我们可以拿到实现了JSR-223的脚本引擎，那么我们怎么知道传什么参数才能拿到Groovy跟Scala的引擎呢？冲进去看看代码就知道了，
public ScriptEngine getEngineByName(String shortName) {
if (shortName == null) throw new NullPointerException();
//look for registered name first
Object obj;
if (null != (obj = nameAssociations.get(shortName))) {
ScriptEngineFactory spi = (ScriptEngineFactory)obj;
try {
ScriptEngine engine = spi.getScriptEngine();
engine.setBindings(getBindings(), ScriptContext.GLOBAL_SCOPE);
return engine;
} catch (Exception exp) {
if (DEBUG) exp.printStackTrace();
}
}
for (ScriptEngineFactory spi : engineSpis) {
List<String> names = null;
try {
names = spi.getNames();
} catch (Exception exp) {
if (DEBUG) exp.printStackTrace();
}
if (names != null) {
for (String name : names) {
if (shortName.equals(name)) {
try {
ScriptEngine engine = spi.getScriptEngine();
engine.setBindings(getBindings(), ScriptContext.GLOBAL_SCOPE);
return engine;
} catch (Exception exp) {
if (DEBUG) exp.printStackTrace();
}
}
}
}
}
return null;
}
/**
* Registers a <code>ScriptEngineFactory</code> to handle a language
* name. Overrides any such association found using the Discovery mechanism.
* @param name The name to be associated with the <code>ScriptEngineFactory</code>.
* @param factory The class to associate with the given name.
* @throws NullPointerException if any of the parameters is null.
*/
public void registerEngineName(String name, ScriptEngineFactory factory) {
if (name == null || factory == null) throw new NullPointerException();
nameAssociations.put(name, factory);
}
所以可以看到有两种方式可以找到ScriptEngine，
- 如果已经通过调用ScriptEngineManager#registerEngineName注册了名字，那么需要知道注册的是啥名字；
- 如果没有，那就需要知道具体的ScriptEngineFactory实现的getNames方法返回了啥；
ScriptEngineFactory是通过ServiceLoader机制来进行加载的，看下Groovy跟Scala各自的实现都是啥，
javax.script.ScriptEngineFactory文件内容分别是，
org.codehaus.groovy.jsr223.GroovyScriptEngineFactory
scala.tools.nsc.interpreter.IMain$Factory
没有找到有调用registerEngineName方法，那就看下各自的getNames方法吧，GroovyScriptEngineFactory的，
private static final String SHORT_NAME = "groovy";
private static final String LANGUAGE_NAME = "Groovy";
static {
List<String> n = new ArrayList<String>(2);
n.add(SHORT_NAME);
n.add(LANGUAGE_NAME);
NAMES = Collections.unmodifiableList(n);
n = new ArrayList<String>(1);
n.add("groovy");
EXTENSIONS = Collections.unmodifiableList(n);
n = new ArrayList<String>(1);
n.add("application/x-groovy");
MIME_TYPES = Collections.unmodifiableList(n);
}
所以可以通过"groovy"或者"Groovy"来拿到Groovy的ScriptEngine。看下IMain，
@BeanProperty
val names: JList[String] = asJavaList("scala")
alright，那就是通过"scala"来拿到了。代码在后面，两种方式一起上。
Shell
通过groovy.lang.GroovyShell和IMain都可以直接执行脚本，这两个就是上面我们说的脚本语言提供的API。
我们可以在脚本语言提供的shell环境执行试试，
$ sudo groovy/bin/groovysh
[sudo] password for blues:
Feb 3, 2015 12:36:43 AM org.codehaus.groovy.runtime.m12n.MetaInfExtensionModule newModule
WARNING: Module [groovy-nio] - Unable to load extension class [org.codehaus.groovy.runtime.NioGroovyMethods]
Groovy Shell (2.4.0, JVM: 1.6.0_33)
Type ':help' or ':h' for help.
-----------------------------------------------------------------------------
groovy:000> import groovy.lang.GroovyShell
===> groovy.lang.GroovyShell
groovy:000> groovySh = new GroovyShell()
===> [email protected]
groovy:000> groovySh.evaluate("import java.util.Random; random = new Random(); random.nextInt();")
===> -1378717507
$ scala
Welcome to Scala version 2.11.5 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_51).
Type in expressions to have them evaluated.
Type :help for more information.
scala> import scala.tools.nsc.interpreter._
import scala.tools.nsc.interpreter._
scala> val iMain = new IMain()
iMain: scala.tools.nsc.interpreter.IMain = [email protected]
scala> iMain.eval("import java.util.Random; val random = new Random(); random.nextInt();")
res0: Object = 1320282527
都没有问题。
最后，回到最开始的问题，怎么在Java代码中执行脚本？下面就把两种方式的代码一起贴上，
import groovy.lang.GroovyShell;
import scala.tools.nsc.interpreter.IMain;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
public class Main {
public static void main(String[] args) throws Exception {
ScriptEngineManager sem = new ScriptEngineManager();
String script_groovy =
"import java.util.Random; random = new Random(); random.nextInt();";
ScriptEngine se_groovy = sem.getEngineByName("groovy");
System.out.println(se_groovy.eval(script_groovy));
GroovyShell groovyShell = new GroovyShell();
System.out.println(groovyShell.evaluate(script_groovy));
String script_scala =
"import java.util.Random; val random = new Random(); random.nextInt();";
ScriptEngine se_scala = sem.getEngineByName("scala");
System.out.println(se_scala.eval(script_scala));
IMain iMain = new IMain();
System.out.println(iMain.eval(script_scala));
}
}
1424725324 1691255297 459327395 1109624277
本来想玩下JDK自带的JSR223实现，也就是Nashorn，which is an implementation of the ECMAScript Edition 5.1 Language Specification，但是要到JDK8才有得玩，改天吧^_^
轻拍。