¡El editor de Downcodes le mostrará los diversos métodos de Java para llamar a JavaScript! La interoperabilidad entre Java y JavaScript es cada vez más importante, y este artículo analizará en profundidad cuatro métodos principales: usar ScriptEngineManager, el motor Nashorn JavaScript, Duktape y GraalVM. Cada uno de estos métodos tiene sus propias ventajas y desventajas y es adecuado para diferentes escenarios, lo que ayuda a los desarrolladores a utilizar de manera flexible las potentes funciones de JavaScript en aplicaciones Java para mejorar la eficiencia del desarrollo y el rendimiento de las aplicaciones. El artículo lo ayudará a dominar rápidamente estas tecnologías a través de ejemplos de código claros y explicaciones detalladas, y viene con preguntas frecuentes para ayudarlo a obtener una comprensión más profunda de la interacción entre Java y JavaScript.
El código Java puede llamar scripts JavaScript de diversas formas, incluido el uso de ScriptEngineManager, el motor JavaScript Nashorn, Duktape y GraalVM. Estas tecnologías hacen posible ejecutar código JavaScript en la máquina virtual Java, aumentando así la flexibilidad y funcionalidad de JavaScript en las aplicaciones Java.
Por ejemplo, usar ScriptEngineManager es una forma común para que Java llame a scripts JavaScript porque es un método estándar integrado en Java. Además, con el lanzamiento del nuevo GraalVM de alto rendimiento de Oracle, la ejecución de scripts JavaScript a través de GraalVM se ha vuelto más eficiente.
La plataforma Java proporciona la clase ScriptEngineManager, que forma parte del paquete javax.script en Java SE 6 y superior, que está diseñada específicamente para proporcionar integración con lenguajes de secuencias de comandos. ScriptEngineManager permite que el código Java interactúe con los lenguajes de secuencias de comandos, aprovechando así las ventajas de los lenguajes de secuencias de comandos, como el desarrollo rápido y la escritura dinámica.
Para utilizar ScriptEngineManager, sólo necesita crear una instancia del mismo y obtener el entorno de ejecución de JavaScript a través de ella. A continuación se muestra un ejemplo sencillo de cómo utilizar ScriptEngineManager:
importar javax.script.ScriptEngineManager;
importar javax.script.ScriptEngine;
importar javax.script.ScriptException;
clase pública JavaScriptFromJava {
público estático vacío principal (String [] argumentos) {
// Crear objeto ScriptEngineManager
Administrador de ScriptEngineManager = nuevo ScriptEngineManager();
// Obtener el ScriptEngine de JavaScript
Motor ScriptEngine = manager.getEngineByName(JavaScript);
intentar {
//Ejecutar código JavaScript
motor.eval(print('¡Hola, mundo!'));
} captura (ScriptException e) {
e.printStackTrace();
}
}
}
Nashorn, introducido desde Java SE 8, es un motor JavaScript de alto rendimiento que permite ejecutar JavaScript en la JVM, proporcionando un mejor rendimiento y compatibilidad con la especificación ECMAScript 5.1.
De manera similar a ScriptEngineManager, debe usar esta clase para obtener una instancia del motor Nashorn y ejecutar código JavaScript.
importar javax.script.ScriptEngineManager;
importar javax.script.ScriptEngine;
importar javax.script.ScriptException;
clase pública Ejemplo de Nashorn {
público estático vacío principal (String [] argumentos) {
// Crear ScriptEngineManager
Administrador de ScriptEngineManager = nuevo ScriptEngineManager();
// Obtenga el ScriptEngine de Nashorn
Motor ScriptEngine = manager.getEngineByName(nashorn);
intentar {
//Ejecutar script JavaScript
motor.eval(print('¡Hola, Nashorn!'));
} captura (ScriptException e) {
e.printStackTrace();
}
}
}
Duktape es un motor de JavaScript integrado que es liviano, fácil de integrar y puede proporcionar un entorno de ejecución de JavaScript en varios sistemas. Duktape es adecuado para situaciones en las que necesita ejecutar JavaScript en entornos con recursos limitados.
Debido a que Duktape es un motor JavaScript escrito en C, generalmente debe integrarse con aplicaciones Java a través de JNI (Java Native Interface). Es necesario escribir el código JNI correspondiente para unir el código Java y el motor Duktape.
// Supongamos que ya existe una interfaz JNI
clase pública DuktapeExample {
//declaración del método JNI
ejecución de cadena nativa pública (script de cadena);
estático {
//Carga la biblioteca que contiene la implementación del método nativo
System.loadLibrary(cinta adhesiva);
}
público estático vacío principal (String [] argumentos) {
Ejemplo de DuktapeExample = nuevo DuktapeExample();
// Llama a Duktape para ejecutar JavaScript a través de JNI
Resultado de cadena = ejemplo.executeScript(var msg = '¡Hola, Duktape!'; msg;);
System.out.println(resultado);
}
}
GraalVM es una nueva máquina virtual que puede ejecutar varios lenguajes, incluidos Java y JavaScript. El propósito de GraalVM es proporcionar un tiempo de ejecución único para ejecutar todos los lenguajes de programación, que se caracteriza por un alto rendimiento y coexistencia en varios lenguajes.
En GraalVM, puede utilizar la clase Context para crear un entorno de ejecución para ejecutar JavaScript.
importar org.graalvm.polyglot.*;
clase pública GraalVMExample {
público estático vacío principal (String [] argumentos) {
// Usa el contexto de GraalVM para ejecutar código JavaScript
intentar (Contexto contexto = Contexto.create()) {
// Ejecutar código JavaScript
Resultado del valor = context.eval(js, print('¡Hola, GraalVM!'););
}
}
}
A través de los métodos anteriores, Java puede llamar scripts de JavaScript y utilizar las características de programación dinámica de JavaScript en diferentes escenarios. Ya sea a través de ScriptEngineManager, Nashorn, Duktape o GraalVM, la interoperabilidad de Java y JavaScript proporciona a los desarrolladores herramientas potentes para crear aplicaciones flexibles y ricas en funciones.
1. ¿Cómo llamar al script JavaScript en código Java?
Se puede llamar a scripts JavaScript en Java utilizando la interfaz ScriptEngine de Java. Primero, debe crear una instancia de ScriptEngine y luego cargar el script JavaScript en la instancia. A continuación, puede utilizar el método eval() de la instancia de ScriptEngine para ejecutar código JavaScript. Por ejemplo:
//Crear instancia de ScriptEngine ScriptEngineManager manager = new ScriptEngineManager();ScriptEngine motor = manager.getEngineByName(JavaScript);try { //Cargar script de JavaScript motor.eval(function sayHello() { return '¡Hola, mundo!'; }); // Llamar a la función JavaScript Resultado del objeto = motor.eval(sayHello()); Resultado de salida System.out.println(result.toString());} catch (ScriptException e) { e.printStackTrace();}2. ¿Cómo pasar objetos Java a scripts JavaScript?
Si desea acceder a un objeto Java en un script JavaScript, puede vincular el objeto Java a una variable global en la instancia de ScriptEngine. De esta manera, puede utilizar la variable en un script JavaScript para llamar a los métodos del objeto Java y acceder a sus propiedades. Por ejemplo:
//Crear una instancia de ScriptEngine ScriptEngineManager manager = new ScriptEngineManager();ScriptEngine Engine = manager.getEngineByName(JavaScript);try { //Vincular el objeto Java a la variable global en ScriptEngine Engine.put(myObject, new MyObject()); // Utilice esta variable en el script JavaScript motor.eval(myObject.sayHello(););} catch (ScriptException e) { e.printStackTrace();}// Definir un objeto Java public class MyObject { public void sayHello() { System.out.println(¡Hola desde Java! }});3. ¿Cómo obtener el valor de retorno del script JavaScript en Java?
Para obtener el valor de retorno de un script JavaScript, puede utilizar el método eval() de la instancia de ScriptEngine para ejecutar el script y almacenar el valor de retorno en una variable. Por ejemplo:
//Crear una instancia de ScriptEngine ScriptEngineManager manager = new ScriptEngineManager();ScriptEngine motor = manager.getEngineByName(JavaScript);try { //Ejecutar el script JavaScript y obtener el valor de retorno Resultado del objeto = motor.eval(function sayHello() { return '¡Hola mundo!'; } sayHello(); // Resultado de salida System.out.println(result.toString());} catch (ScriptException) mi) { e.printStackTrace();}En el código anterior, el valor de retorno del script JavaScript es la cadena ¡Hola, mundo! Al almacenar el resultado de la ejecución del script en la variable de resultado, podemos imprimir este valor de retorno.
Espero que este artículo pueda ayudarle a comprender mejor cómo Java llama a JavaScript. Para obtener más conocimientos relacionados con Java, continúe siguiendo al editor de Downcodes.