¿Cómo puedo pasar una función javaScript a un Método Java para actuar como una devolución de llamada (Rhino)

Question

Básicamente estoy tratando de pasar una función javaScript a un método Java para actuar como una devolución de llamada al script.

Puedo hacerlo, más o menos, pero el objeto que recibo es sun.org.mozilla.javascript.internal.InterpretedFunction y no veo una forma de invocarlo.

¿Alguna idea?

Esto es lo que tengo hasta ahora:

var someNumber = 0; 

function start() { 
    // log is just an log4j instance added to the Bindings 
    log.info("started...."); 
    someNumber = 20; 

    // Test is a unit test object with this method on it (taking Object as a param). 
    test.callFromRhino(junk); 
} 

function junk() { 
    log.info("called back " + someNumber); 
} 

Answer 1

implementar una interfaz:

import javax.script.*; 

public class CallBack { 
    public void invoke(Runnable runnable) { 
    runnable.run(); 
    } 

    public static void main(String[] args) throws ScriptException { 
    ScriptEngine js = new ScriptEngineManager().getEngineByExtension("js"); 
    js.getContext().setAttribute("callBack", new CallBack(), 
     ScriptContext.ENGINE_SCOPE); 
    js.eval("var impl = { run: function() { print('Hello, World!'); } };\n" 
     + "var runnable = new java.lang.Runnable(impl);\n" 
     + "callBack.invoke(runnable);\n"); 
    } 
} 

Answer 2

sun.org.mozilla.javascript.internal.InterpretedFunction implementa la interfaz sun.org.mozilla.javascript.Function. Ese interfaz tiene un método en que llamó call que lleva:

• un Context
• un Scriptable de usar como el alcance
• un Scriptable para usar como el valor de this dentro de la función
• una matriz de Objects que son los argumentos para la función

Entonces, lo que sugiero es que en java usted cas t el objeto que recibió como sun.org.mozilla.javascript.Function y llame al call. Los primeros dos argumentos pueden ser lo que sea que haya usado desde Java para iniciar el script en primer lugar. La forma en que lo está utilizando allí, los dos últimos argumentos pueden ser null y new Object[0].

Answer 3

La solución es en realidad para invocar en otro guión. Este tipo de trabajos:

import javax.script.*; 

public class CallFunction { 

    /** 
    * @param args 
    * @throws Exception oops! 
    */ 
    public static void main(String[] args) throws Exception { 
     ScriptEngine js = new ScriptEngineManager().getEngineByExtension("js"); 
     js.getContext().setAttribute("out", System.out, ScriptContext.ENGINE_SCOPE); 
     Object a = js.eval(
       "out.println('Defining function a...');" + 
       "function a() {out.println('hello from JavaScript!'); }" + 
       "function foobar() {out.println('in foobar() definition');}" +  
       "out.println('Done!.');" 
     ); 

     System.out.println(js.get("a")); // InterpretedFunction 
     SimpleBindings bindings = new SimpleBindings(); 
     bindings.put("foobar",js.get("a")); 
     js.eval("foobar();", bindings); // hello from JavaScript 
     js.eval("foobar();"); // in foobar() definition 
    } 
} 

Al llegar de nuevo la referencia a una función, tiene que solicitar al motor para ejecutar esa función para usted. Y aunque no es bonito, pedir js a eval() para usted con un conjunto específico de enlaces realmente hará el trabajo por usted. Debe tener cuidado de que las variables que está manipulando pertenezcan al alcance correcto; Supongo que es fácil cometer errores aquí.

Answer 4

Este ejemplo cubre la implementación de la interfaz java con javascript. Eso también se puede usar para la invocación de devoluciones de llamada javascript desde Java.

package com.hal.research; 

import javax.script.*; 

public class CallFunction { 
    /** 
    * define contract for the callback 
    */ 
    static interface WhatEverYouWant { 
     public String testMe(String a, String b); 
    } 
    /** 
    * @param args 
    */ 
    public static void main(String[] args) throws Exception { 
     final ScriptEngineManager scriptManager = new ScriptEngineManager(); 
     final ScriptEngine js = scriptManager.getEngineByExtension("js"); 
     js.put("producer", new Object() { 
      /** 
      * @param call is a callback to be invoked 
      */ 
      public void doSomethingWithIt(WhatEverYouWant call) { 
       System.out.println("invoke callback javascript..."); 
       String result = call.testMe("a", "b"); 
       // do something with the result ... 
       System.out.println("invoke callback...done, result: "+result); 
      } 
     }); 
     js.eval( "var handler = {\"testMe\": function (a,b){return a + \" is concatenated to \"+ b;}};\n" 
       + "var callback = new Packages.com.hal.research.CallFunction.WhatEverYouWant(handler);\n" 
       + "producer.doSomethingWithIt(callback); "); 
    } 
}