O editor de Downcodes mostrará os vários métodos de Java chamando JavaScript! A interoperabilidade entre Java e JavaScript é cada vez mais importante, e este artigo examinará detalhadamente quatro métodos principais: usando ScriptEngineManager, mecanismo Nashorn JavaScript, Duktape e GraalVM. Cada um desses métodos tem suas próprias vantagens e desvantagens e é adequado para diferentes cenários, ajudando os desenvolvedores a usar com flexibilidade as poderosas funções do JavaScript em aplicativos Java para melhorar a eficiência do desenvolvimento e o desempenho do aplicativo. O artigo ajudará você a dominar rapidamente essas tecnologias por meio de exemplos de código claros e explicações detalhadas, e vem com perguntas frequentes para ajudá-lo a obter uma compreensão mais profunda da interação entre Java e JavaScript.
O código Java pode chamar scripts JavaScript de várias maneiras, inclusive usando ScriptEngineManager, mecanismo Nashorn JavaScript, Duktape e GraalVM. Essas tecnologias possibilitam a execução de código JavaScript na máquina virtual Java, aumentando assim a flexibilidade e funcionalidade do JavaScript em aplicações Java.
Por exemplo, usar ScriptEngineManager é uma maneira comum de Java chamar scripts JavaScript porque é um método padrão integrado em Java. Além disso, com o lançamento do novo GraalVM de alto desempenho da Oracle, a execução de scripts JavaScript por meio do GraalVM tornou-se mais eficiente.
A plataforma Java fornece a classe ScriptEngineManager, que faz parte do pacote javax.script no Java SE 6 e superior, que é projetada especificamente para fornecer integração com linguagens de script. O ScriptEngineManager permite que o código Java interaja com linguagens de script, aproveitando assim as vantagens das linguagens de script, como desenvolvimento rápido e digitação dinâmica.
Para utilizar o ScriptEngineManager, basta criar uma instância dele e obter através dele o ambiente de execução do JavaScript. Aqui está um exemplo simples de como usar o ScriptEngineManager:
importar javax.script.ScriptEngineManager;
importar javax.script.ScriptEngine;
importar javax.script.ScriptException;
classe pública JavaScriptFromJava {
public static void principal(String[] args) {
// Cria o objeto ScriptEngineManager
Gerenciador ScriptEngineManager = novo ScriptEngineManager();
// Obtenha o ScriptEngine do JavaScript
Mecanismo ScriptEngine = manager.getEngineByName(JavaScript);
tentar {
//Executa código JavaScript
engine.eval(print('Olá, Mundo!'));
} catch (ScriptException e) {
e.printStackTrace();
}
}
}
Nashorn, introduzido desde Java SE 8, é um mecanismo JavaScript de alto desempenho que permite executar JavaScript na JVM, proporcionando melhor desempenho e compatibilidade com a especificação ECMAScript 5.1.
Semelhante ao ScriptEngineManager, você precisa usar esta classe para obter uma instância do mecanismo Nashorn e executar o código JavaScript.
importar javax.script.ScriptEngineManager;
importar javax.script.ScriptEngine;
importar javax.script.ScriptException;
classe pública NashornExample {
public static void main(String[] args) {
// Cria o ScriptEngineManager
Gerenciador ScriptEngineManager = novo ScriptEngineManager();
// Obtenha o ScriptEngine de Nashorn
Mecanismo ScriptEngine = manager.getEngineByName(nashorn);
tentar {
//Executa script JavaScript
motor.eval(print('Olá, Nashorn!'));
} catch (ScriptException e) {
e.printStackTrace();
}
}
}
Duktape é um mecanismo JavaScript incorporado leve, fácil de integrar e pode fornecer um ambiente de execução JavaScript em vários sistemas. Duktape é adequado para situações em que você precisa executar JavaScript em ambientes com recursos limitados.
Como Duktape é um mecanismo JavaScript escrito em C, geralmente ele precisa ser integrado a aplicativos Java por meio de JNI (Java Native Interface). O código JNI correspondente precisa ser escrito para fazer a ponte entre o código Java e o mecanismo Duktape.
// Suponha que já exista uma interface JNI
classe pública DuktapeExemplo {
//Declaração do método JNI
String nativa pública executeScript (String script);
estático {
//Carrega a biblioteca que contém a implementação do método Native
System.loadLibrary(duktape);
}
public static void main(String[] args) {
Exemplo de DuktapeExample = new DuktapeExample();
//Chama Duktape para executar JavaScript através de JNI
String resultado = exemplo.executeScript(var msg = 'Olá, Duktape!'; msg;);
System.out.println(resultado);
}
}
GraalVM é uma máquina virtual totalmente nova que pode executar várias linguagens, incluindo Java e JavaScript. O objetivo do GraalVM é fornecer um único tempo de execução para executar todas as linguagens de programação, que se caracteriza por alto desempenho e coexistência multilíngue.
No GraalVM, você pode usar a classe Context para criar um ambiente de execução para executar JavaScript.
importar org.graalvm.polyglot.*;
classe pública GraalVMExample {
public static void main(String[] args) {
// Use o Contexto do GraalVM para executar o código JavaScript
tentar (contexto contexto = Context.create()) {
//Executa o código JavaScript
Resultado do valor = context.eval(js, print('Olá, GraalVM!');););
}
}
}
Através dos métodos acima, Java pode chamar scripts JavaScript e utilizar as características de programação dinâmica do JavaScript em diferentes cenários. Seja através do ScriptEngineManager, Nashorn, Duktape ou GraalVM, a interoperabilidade Java e JavaScript fornece aos desenvolvedores ferramentas poderosas para criar aplicativos flexíveis e ricos em recursos.
1. Como chamar script JavaScript em código Java?
Chamar scripts JavaScript em Java pode ser feito usando a interface ScriptEngine do Java. Primeiro, você precisa criar uma instância do ScriptEngine e depois carregar o script JavaScript na instância. A seguir, você pode usar o método eval() da instância ScriptEngine para executar o código JavaScript. Por exemplo:
//Cria instância do ScriptEngine ScriptEngineManager manager = new ScriptEngineManager();ScriptEngine engine = manager.getEngineByName(JavaScript);try { //Carrega script JavaScript engine.eval(function sayHello() { return 'Hello, World!'; }); // Chama a função JavaScript Object result = engine.eval(sayHello()); Resultado de saída System.out.println(result.toString());} catch (ScriptException e) { e.printStackTrace();}2. Como passar objetos Java para scripts JavaScript?
Se desejar acessar um objeto Java em um script JavaScript, você poderá vincular o objeto Java a uma variável global na instância do ScriptEngine. Dessa forma, você pode usar a variável em um script JavaScript para chamar os métodos do objeto Java e acessar suas propriedades. Por exemplo:
//Cria uma instância do ScriptEngine ScriptEngineManager manager = new ScriptEngineManager();ScriptEngine engine = manager.getEngineByName(JavaScript);try { //Vincula o objeto Java à variável global no ScriptEngine engine.put(myObject, new MyObject()); // Use esta variável no script JavaScript engine.eval(myObject.sayHello(););} catch (ScriptException e) { e.printStackTrace();}// Defina um objeto Java public class MyObject { public void sayHello() { System.out.println(Hello from Java! }});3. Como obter o valor de retorno do script JavaScript em Java?
Para obter o valor de retorno de um script JavaScript, você pode usar o método eval() da instância ScriptEngine para executar o script e armazenar o valor de retorno em uma variável. Por exemplo:
//Cria uma instância do ScriptEngine ScriptEngineManager manager = new ScriptEngineManager();ScriptEngine engine = manager.getEngineByName(JavaScript);try { //Executa o script JavaScript e obtém o valor de retorno Object result = engine.eval(function sayHello() { return 'Olá, mundo!'; } sayHello();); // Resultado de saída System.out.println(result.toString());} catch (ScriptException e) { e.printStackTrace();}No código acima, o valor de retorno do script JavaScript é a string Hello, World!. Ao armazenar o resultado da execução do script na variável result, podemos imprimir esse valor de retorno.
Espero que este artigo possa ajudá-lo a entender melhor como Java chama JavaScript. Para mais conhecimento relacionado a Java, continue acompanhando o editor de Downcodes!