What is Callable used for in java?

This interface is used in machines that interpret other programming languages ​​such as javascript, which is done with Nashorn, for example.

Imagine you have javascript like:

String javascript = "function multiplica(a, b) { return a * b; }\n"
     + "function divide(a, b) { return a / b; }"

With the script engine you implement the interface Invocableto call functions from Java with invokeFunction() :

ScriptEngineManager engineManager = new ScriptEngineManager();
ScriptEngine engine = engineManager.getEngineByName("nashorn");
// cargemos el código para que la maquina lo evalua
engine.eval(javascript);

// la maquina implementa la interfaz Invocable
Invocable js = (Invocable) engine;
// podemos llamar a funciones así:
System.out.println(js.invokeFunction("multiplica",3,5)
// eso imprime 15

We can also create interfaces in java with getInterface() to access the script:

interface Calculador{
    multiplica(int a, int b);
    divide(int a, int b);
}

// con eso podemos obtener una interfaz de Java del script
Calculador calc = js.getInterface(Calculador.class);
System.out.println(calc.multiplica(2,3));
// imprime 6
System.out.println(calc.divide(8,4));
// imprime 2

The last invokeMethod() method is similar to invokeFunctionbut allows you to call methods of an object:

// cargemos un objeto en javascript
Object jsObjeto = engine.eval(new FileReader("Printer.js"));
// llamamos a Printer.print( nombre )
js.invokeMethod(jsObjeto, "print", "foo" );

Nashorn documentation in English (Oracle)

When a script engine (which implements javax.script.ScriptEngine) also implements the interface javax.script.Invocable, it means that it can execute procedures, functions or methods that have previously been compiled .

That is, instead of using the method eval, javax.script.ScriptEngineyou can call the procedure or function or method directly from a Java program. Note that implementation of the interface Invocableby a script engine is optional. Before calling any procedure, function, or method, check if the script engine is an instance of this interface, cast a Invocable, and then execute the methods of this interface.

This interface contains four methods. Both versions of the method getInterface()allow obtaining an instance of a Java interface which is implemented in a scripting language (eg: factorial.js). The method invokeFunction()allows you to call a higher-level function (eg: parseInt()) written in a scripting language . The method invokeMethod()allows calling methods of objects (eg: obj.toString()) written in a scripting language .

If you want to make an invocation of this type, you can follow the following steps:

1. First check if the script engine is Invocable:

   ScriptEngineManager manager = new ScriptEngineManager();
   ScriptEngine engine = manager.getEngineByName("jruby");
   
   if (engine instanceof Invocable) {
       // Es invocable :-)
   } else {
       // No es invocable :'(
   }
   

2. Cast the reference toScriptEngine a Invocable:

   Invocable inv = (Invocable) engine;
   

3. Evaluate a script for the engine to compile and save the compiled for future invocations:

   String script = "def sumar(a, b)\n  return a + b\nend";
   engine.eval(script);
   

4. Invoke the procedure, function, or method:

   Object result = inv.invokeFunction("sumar", 1, 2);
   

addition

A script engine can also implement the interface javax.script.Compilablewhich allows scripts to be compiled for repeated execution.

References

• Klauer, N. (2008). InvokingFunctionsExample.java. Retrieved from https://github.com/klauern/callingruby/blob/master/src/klauer/callingruby/yokoharada/InvokingFunctionsExample.java
• McQueeney, T. (2007). Introducing the Java scripting API. Retrieved from https://www.ibm.com/developerworks/library/j-javascripting1/
• Sharan, K. (2014). Scripting in Java: Integrating with Groovy and JavaScript. Berkeley, CA: Press.