捕获纳肖恩的全局变量

我有一个Java 7程序，它加载数千个对象（组件），每个对象（组件）都有许多参数（存储在Map中），并在这些对象上执行各种Rhino脚本来计算其他派生参数，这些参数被存储回对象的Map中。 在运行每个脚本之前，会创建一个Scope对象，由对象的映射提供支持，该映射在脚本持续时间内用作 JavaScript 的作用域。

作为一个简单的示例，下面创建一个 a=10 和 b=20 的HashMap，并执行脚本c = a + b ，这导致c = 30.0存储回映射中。 虽然脚本看起来像是在创建一个全局变量c，但Scope对象会捕获它并将其存储在映射中;使用不同的 Scope 对象执行的另一个脚本不会看到此变量：

public class Rhino {
    public static void main(String[] args) throws ScriptException {
        Context cx = Context.enter();
        Scriptable root_scope = cx.initStandardObjects();
        Map<String, Object> map = new HashMap<>();
        map.put("a", 10);
        map.put("b", 20);
        Scope scope = new Scope(root_scope, map);
        cx.evaluateString(scope, "c = a + b", "<expr>", 0, null);
        System.out.println(map); // --> {b=20, c=30.0, a=10}
        Context.exit();
    }
    static class Scope extends ScriptableObject {
        private Map<String, Object> map;
        public Scope(Scriptable parent, Map<String, Object> map) {
            setParentScope(parent);
            this.map = map;
        }
        @Override
        public boolean has(String key, Scriptable start) {
            return true;
        }
        @Override
        public Object get(String key, Scriptable start) {
            if (map.containsKey(key))
                return map.get(key);
            return Scriptable.NOT_FOUND;
        }
        @Override
        public void put(String key, Scriptable start, Object value) {
            map.put(key, value);
        }
        @Override
        public String getClassName() {
            return "MapScope";
        }
    }
}

上面的脚本输出{b=20, c=30.0, a=10}，显示变量c已经存储在Map中。

现在，我需要将其迁移到Java 8，并使用Nashorn。 但是，我发现 Nashorn 总是将全局变量存储在一个特殊的"nashorn.global"对象中。 事实上，它似乎将所有绑定视为只读，并尝试更改现有变量会导致新的全局变量隐藏现有绑定。

public class Nashorn {
    private final static ScriptEngineManager MANAGER = new ScriptEngineManager();
    public static void main(String[] args) throws ScriptException {
        new Nashorn().testBindingsAsArgument();
        new Nashorn().testScopeBindings("ENGINE_SCOPE", ScriptContext.ENGINE_SCOPE);
        new Nashorn().testScopeBindings("GLOBAL_SCOPE", ScriptContext.GLOBAL_SCOPE);
    }
    private ScriptEngine engine = MANAGER.getEngineByName("nashorn");
    private Map<String, Object> map = new HashMap<>();
    private Bindings bindings = new SimpleBindings(map);
    private Nashorn() {
        map.put("a", 10);
        map.put("b", 20);
    }
    private void testBindingsAsArgument() throws ScriptException {
        System.out.println("Bindings as argument:");
        engine.eval("c = a + b; a += b", bindings);
        System.out.println("map = " + map);
        System.out.println("eval('c', bindings) = " + engine.eval("c", bindings));
        System.out.println("eval('a', bindings) = " + engine.eval("a", bindings));
    }
    private void testScopeBindings(String scope_name, int scope) throws ScriptException {
        System.out.println("'n" + scope_name + ":");
        engine.getContext().setBindings(bindings, scope);
        engine.eval("c = a + b; a += b");
        System.out.println("map = " + map);
        System.out.println("eval('c') = " + engine.eval("c"));
        System.out.println("eval('a') = " + engine.eval("a"));
    }
}

输出：

Bindings as argument:
map = {a=10, b=20, nashorn.global=[object global]}
eval('c', bindings) = 30.0
eval('a', bindings) = 30.0
ENGINE_SCOPE:
map = {a=10, b=20, nashorn.global=[object global]}
eval('c') = 30.0
eval('a') = 30.0
GLOBAL_SCOPE:
map = {a=10, b=20}
eval('c') = 30.0
eval('a') = 30.0

eval输出行显示结果已正确计算并正在存储，但map输出行显示结果未存储在我希望的位置。

出于各种原因，这是不可接受的。 各个对象不会将计算参数存储回其自己的本地存储中。 在其他对象上执行的其他脚本中的变量将从以前的脚本执行中继承，这可能会隐藏逻辑错误（脚本可能会意外使用未定义的变量名称，但如果该名称实际上被以前的脚本使用，则可以使用旧的垃圾值而不是正在生成的ReferenceError，从而隐藏错误）。

按照map.put("c", engine.get("c")) engine.eval()会将结果移动到我需要的位置，但是使用任意脚本，我不知道所有变量名称是什么，因此不是一种选择。

所以问题来了：是否有任何方法可以捕获全局变量的创建，并将它们存储在应用程序控制的 Java 对象中，例如原始 Binding 对象？