ScriptEngine

在Java中，实现了ScriptEngine接口的类包括以下几种：

• NashornScriptEngine：用于执行JavaScript代码的引擎，由Oracle Nashorn提供。
• GraalJSScriptEngine：也是用于执行JavaScript代码的引擎，由GraalVM提供。
• BSFEngine：用于与Bean Scripting Framework (BSF) 集成的引擎。
• JythonScriptEngine：用于执行Python代码的引擎，由Jython提供。
• GroovyScriptEngine：用于执行Groovy代码的引擎，由Groovy提供。

这些类允许在Java应用程序中嵌入和执行脚本代码，支持多种不同的脚本语言。

以下是一些示例代码，展示了如何在Java中使用这些实现了ScriptEngine接口的类：

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

public class ScriptEngineExamples {

    public static void main(String[] args) {
        ScriptEngineManager manager = new ScriptEngineManager();

        // NashornScriptEngine 示例
        ScriptEngine nashornEngine = manager.getEngineByName("nashorn");
        try {
            nashornEngine.eval("print('Hello from Nashorn');");
        } catch (ScriptException e) {
            e.printStackTrace();
        }

        // GraalJSScriptEngine 示例
        ScriptEngine graalEngine = manager.getEngineByName("graal.js");
        try {
            graalEngine.eval("print('Hello from GraalVM');");
        } catch (ScriptException e) {
            e.printStackTrace();
        }

        // BSFEngine 示例
        ScriptEngine bsfEngine = manager.getEngineByName("beanshell");
        try {
            bsfEngine.eval("System.out.println(\\"Hello from BeanShell\\");");
        } catch (ScriptException e) {
            e.printStackTrace();
        }

        // JythonScriptEngine 示例
        ScriptEngine jythonEngine = manager.getEngineByName("python");
        try {
            jythonEngine.eval("print('Hello from Jython')");
        } catch (ScriptException e) {
            e.printStackTrace();
        }

        // GroovyScriptEngine 示例
        ScriptEngine groovyEngine = manager.getEngineByName("groovy");
        try {
            groovyEngine.eval("println 'Hello from Groovy'");
        } catch (ScriptException e) {
            e.printStackTrace();
        }
    }
}

这些示例代码展示了如何使用各种ScriptEngine来执行不同的脚本语言。在每个示例中，我们首先从ScriptEngineManager获取特定语言的引擎实例，然后使用eval方法执行脚本代码。

如果不使用 ScriptEngineManager，可以直接实例化具体的 ScriptEngine 实现类来创建 ScriptEngine 示例。以下是一些示例代码：

import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.HostAccess;
import org.graalvm.polyglot.Value;
import org.graalvm.polyglot.proxy.ProxyExecutable;

// GraalJSScriptEngine 示例
public class GraalExample {
    public static void main(String[] args) {
        try (Context context = Context.newBuilder("js")
                .allowHostAccess(HostAccess.ALL)
                .build()) {
            Value value = context.eval("js", "print('Hello from GraalVM without ScriptEngineManager');");
        }
    }
}

import jdk.nashorn.api.scripting.NashornScriptEngineFactory;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

// NashornScriptEngine 示例
public class NashornExample {
    public static void main(String[] args) {
        NashornScriptEngineFactory factory = new NashornScriptEngineFactory();
        ScriptEngine nashornEngine = factory.getScriptEngine();
        try {
            nashornEngine.eval("print('Hello from Nashorn without ScriptEngineManager');");
        } catch (ScriptException e) {
            e.printStackTrace();
        }
    }
}

import org.python.util.PythonInterpreter;

// JythonScriptEngine 示例
public class JythonExample {
    public static void main(String[] args) {
        PythonInterpreter interpreter = new PythonInterpreter();
        interpreter.exec("print('Hello from Jython without ScriptEngineManager')");
    }
}

import groovy.lang.GroovyShell;

// GroovyScriptEngine 示例
public class GroovyExample {
    public static void main(String[] args) {
        GroovyShell shell = new GroovyShell();
        shell.evaluate("println 'Hello from Groovy without ScriptEngineManager'");
    }
}

这些示例代码展示了如何直接实例化并使用具体的 ScriptEngine 实现类，而不依赖于 ScriptEngineManager。每个示例都展示了如何执行特定脚本语言的代码。

在使用 ScriptEngine 执行脚本代码时，如果想要过滤某些类，可以通过设置安全管理器或自定义类过滤器来实现。以下是一些示例代码，展示了如何在不同的 ScriptEngine 中实现类过滤：

1. NashornScriptEngine

对于 NashornScriptEngine，可以使用 ClassFilter 接口来实现类过滤。

import jdk.nashorn.api.scripting.ClassFilter;
import jdk.nashorn.api.scripting.NashornScriptEngineFactory;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

public class NashornClassFilterExample {

    public static void main(String[] args) {
        ClassFilter filter = new ClassFilter() {
            @Override
            public boolean exposeToScripts(String className) {
                // 仅允许访问 java.util.Date 类
                return "java.util.Date".equals(className);
            }
        };

        NashornScriptEngineFactory factory = new NashornScriptEngineFactory();
        ScriptEngine engine = factory.getScriptEngine(filter);
        try {
            engine.eval("var Date = Java.type('java.util.Date'); print(new Date());");
            engine.eval("var System = Java.type('java.lang.System'); print(System.currentTimeMillis());"); // 这行代码将抛出异常
        } catch (ScriptException e) {
            e.printStackTrace();
        }
    }
}

2. GraalJSScriptEngine

对于 GraalJSScriptEngine，可以通过设置 HostAccess 来控制对主机类的访问。

import org.graalvm.polyglot.Context;
import org.graalvm.polyglot.HostAccess;
import org.graalvm.polyglot.Value;

public class GraalClassFilterExample {

    public static void main(String[] args) {
        HostAccess access = HostAccess.newBuilder()
                .allowPublicAccess(true)
                .allowAccess(java.util.Date.class)
                .build();

        try (Context context = Context.newBuilder("js")
                .allowHostAccess(access)
                .build()) {
            Value value = context.eval("js", "var Date = Java.type('java.util.Date'); print(new Date());");
            context.eval("js", "var System = Java.type('java.lang.System'); print(System.currentTimeMillis());"); // 这行代码将抛出异常
        }
    }
}

3. JythonScriptEngine

对于 JythonScriptEngine，可以通过自定义 Python 的 __import__ 函数来控制导入的模块。

import org.python.core.PyObject;
import org.python.util.PythonInterpreter;

public class JythonClassFilterExample {

    public static void main(String[] args) {
        PythonInterpreter interpreter = new PythonInterpreter();
        interpreter.exec("import __builtin__");
        interpreter.exec("__builtin__.__import__ = lambda name, *args: name if name == 'datetime' else None");

        interpreter.exec("import datetime; print(datetime.datetime.now())");
        interpreter.exec("import os; print(os.name)"); // 这行代码将抛出异常
    }
}

4. GroovyScriptEngine

对于 GroovyScriptEngine，可以通过设置自定义的 ClassLoader 来过滤类。

import groovy.lang.GroovyClassLoader;
import groovy.lang.GroovyShell;
import groovy.lang.Script;

public class GroovyClassFilterExample {

    public static void main(String[] args) {
        GroovyClassLoader parent = new GroovyClassLoader();
        GroovyClassLoader loader = new GroovyClassLoader(parent) {
            @Override
            protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
                if ("java.util.Date".equals(name)) {
                    return super.loadClass(name, resolve);
                }
                throw new ClassNotFoundException("Class " + name + " is not allowed.");
            }
        };

        GroovyShell shell = new GroovyShell(loader);
        Script script = shell.parse("println new Date()");
        script.run();

        try {
            Script script2 = shell.parse("println System.currentTimeMillis()");
            script2.run(); // 这行代码将抛出异常
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

这些示例代码展示了如何在不同的 ScriptEngine 中实现类过滤，以控制脚本代码对特定类的访问。