Paso de variables de Java a JavaScript: de LiveConnect a GraalJS

«¿Cómo paso esta variable de Java a JavaScript?» fue una pregunta real de 2011, con applets por medio, y su respuesta ha cambiado de dirección cuatro veces en veinte años: LiveConnect, Rhino, Nashorn, GraalVM. Ninguna tecnología de esta lista murió por no funcionar; murieron por evolución de la plataforma. Repasar esa frontera es repasar la historia reciente de la JVM, y las lecciones siguen vigentes para cualquier integración entre lenguajes.

La era de los applets: JSObject y LiveConnect

Cuando el código Java vivía dentro del navegador, la comunicación era de doble sentido: JavaScript llamaba métodos públicos del applet y el applet manipulaba la página mediante JSObject:

// dentro de un applet, anno 2011
JSObject ventana = JSObject.getWindow(this);
ventana.setMember("totalCarrito", 240);     // variable hacia JS
Object r = ventana.eval("validarCarrito()");
ventana.call("mostrarAviso", new Object[]{"Pago procesado"});

Ese era el «paso de variables» literal del título original. Los applets fueron retirados del JDK en 11 (2018) y del navegador mucho antes, pero el patrón de esa API —getMember, setMember, call, eval— sobrevive casi intacto en GraalVM: las fronteras entre lenguajes envejecen mejor que las tecnologías que las unen.

Nashorn: JavaScript como ciudadano del JDK

Java 8 (2014) trajo Nashorn, un motor JavaScript completo dentro del JDK. Pasar variables se volvió trivial con ScriptEngine:

import javax.script.*;

ScriptEngine motor = new ScriptEngineManager()
        .getEngineByName("nashorn");

motor.put("unidades", 3);
motor.put("precio", 79.90);

Object total = motor.eval("unidades * precio * 1.21");
System.out.println(total);   // 290.27...

// bindings aislados para cada ejecucion
Bindings b = motor.createBindings();
b.put("nombre", "Ada");
Object saludo = motor.eval(
    "var s = 'Hola, ' + nombre; s.toUpperCase()", b);

put publica la variable en el motor y eval la consume; los Bindings aislados evitan que ejecuciones concurrentes pisen las variables unas a otras —el equivalente exacto de un ámbito local. Nashorn fue deprecado en 11 y retirado en 15: el ritmo de ECMAScript superaba al de un motor mantenido dentro del JDK. La lección institucional: los lenguajes invitados exigen ritmo de liberación propio, algo que la JVM aprendió y resolvió de otra manera.

El presente: GraalVM y el poliglotismo

import org.graalvm.polyglot.*;

try (Context ctx = Context.create()) {
    Value bindings = ctx.getBindings("js");
    bindings.putMember("unidades", 3);
    bindings.putMember("precio", 79.90);

    Value total = ctx.eval("js",
        "(unidades * precio * 1.21).toFixed(2)");

    System.out.println(total.asString());   // "290.28"
}

En GraalVM, el Context delimita una máquina virtual invitada completa: dentro puede vivir JavaScript, Python, Ruby o WebAssembly, y las fronteras se cruzan con putMember/getMember —nombres heredados casi literalmente de JSObject. Value es el tipo universal de la otra orilla: se pregunta (isNumber, hasMembers) antes de convertir (asDouble, asString), porque el sistema de tipos del otro lado nunca es el tuyo.

Reglas de la frontera, válidas en todas las eras

• Copia, no referencia: los valores cruzan como copias o como referencias opacas; asumir semántica compartida de objetos es la fuente número uno de bugs en cualquier puente.
• Tipos en la frontera: números, cadenas y booleanos cruzan bien; fechas, colecciones y objetos complejos necesitan conversión explícita o mappings declarados.
• Errores traducidos: una excepción del lado invitado llega como PolyglotException (o ScriptException en Nashorn): captura la envoltura y pregunta por la causa.
• Cuándo no hacerlo: si solo necesitas calcular un importe, escribe el double en Java. El puente se justifica cuando el otro lado tiene un ecosistema que el tuyo no —librerías npm, reglas de negocio ya escritas, fórmulas del usuario.

Los puentes entre lenguajes se construyen con la mejor tecnología del día y se jubilan por la siguiente. Diseña la frontera para poder cambiar el puente sin cambiar las orillas.

De la misma época tecnológica quedan otras dos piezas visitables: la reflexión, que todos estos motores usaban por debajo para tocar objetos Java, y el juego de la serpiente, que vio nacer y morir el mundo de los applets en primera fila.