L'éditeur de Downcodes va vous montrer les différentes méthodes de Java appelant JavaScript ! L'interopérabilité entre Java et JavaScript est de plus en plus importante, et cet article examinera en profondeur quatre méthodes courantes : l'utilisation de ScriptEngineManager, du moteur JavaScript Nashorn, de Duktape et GraalVM. Chacune de ces méthodes présente ses propres avantages et inconvénients et convient à différents scénarios, aidant les développeurs à utiliser de manière flexible les puissantes fonctions de JavaScript dans les applications Java pour améliorer l'efficacité du développement et les performances des applications. L'article vous aidera à maîtriser rapidement ces technologies grâce à des exemples de code clairs et des explications détaillées, et est accompagné d'une FAQ pour vous aider à mieux comprendre l'interaction entre Java et JavaScript.
Le code Java peut appeler des scripts JavaScript de différentes manières, notamment en utilisant ScriptEngineManager, le moteur JavaScript Nashorn, Duktape et GraalVM. Ces technologies permettent d'exécuter du code JavaScript dans la machine virtuelle Java, augmentant ainsi la flexibilité et les fonctionnalités de JavaScript dans les applications Java.
Par exemple, l'utilisation de ScriptEngineManager est un moyen courant pour Java d'appeler des scripts JavaScript, car il s'agit d'une méthode standard intégrée à Java. De plus, avec le lancement du nouveau GraalVM hautes performances d'Oracle, l'exécution de scripts JavaScript via GraalVM est devenue plus efficace.
La plate-forme Java fournit la classe ScriptEngineManager, qui fait partie du package javax.script dans Java SE 6 et versions ultérieures, spécialement conçue pour assurer l'intégration avec les langages de script. ScriptEngineManager permet au code Java d'interagir avec les langages de script, profitant ainsi des avantages des langages de script, tels que le développement rapide et le typage dynamique.
Pour utiliser ScriptEngineManager, il vous suffit d'en créer une instance et d'obtenir l'environnement d'exécution JavaScript via celle-ci. Voici un exemple simple d'utilisation de ScriptEngineManager :
importer javax.script.ScriptEngineManager ;
importer javax.script.ScriptEngine ;
importer javax.script.ScriptException ;
classe publique JavaScriptFromJava {
public static void mAIn(String[] args) {
// Créer un objet ScriptEngineManager
Gestionnaire ScriptEngineManager = new ScriptEngineManager();
// Récupère le ScriptEngine de JavaScript
Moteur ScriptEngine = manager.getEngineByName(JavaScript);
essayer {
//Exécuter le code JavaScript
moteur.eval(print('Bonjour le monde !'));
} catch (ScriptException e) {
e.printStackTrace();
}
}
}
Nashorn, introduit depuis Java SE 8, est un moteur JavaScript hautes performances qui permet d'exécuter JavaScript sur la JVM, offrant de meilleures performances et compatibilité avec la spécification ECMAScript 5.1.
Semblable à ScriptEngineManager, vous devez utiliser cette classe pour obtenir une instance du moteur Nashorn et exécuter du code JavaScript.
importer javax.script.ScriptEngineManager ;
importer javax.script.ScriptEngine ;
importer javax.script.ScriptException ;
classe publique NashornExample {
public static void main (String[] arguments) {
// Créer un ScriptEngineManager
Gestionnaire ScriptEngineManager = new ScriptEngineManager();
// Récupère le ScriptEngine de Nashorn
Moteur ScriptEngine = manager.getEngineByName(nashorn);
essayer {
//Exécuter le script JavaScript
moteur.eval(print('Bonjour Nashorn !'));
} catch (ScriptException e) {
e.printStackTrace();
}
}
}
Duktape est un moteur JavaScript intégré léger, facile à intégrer et peut fournir un environnement d'exécution JavaScript dans divers systèmes. Duktape convient aux situations où vous devez exécuter JavaScript dans des environnements aux ressources limitées.
Étant donné que Duktape est un moteur JavaScript écrit en C, il doit généralement être intégré aux applications Java via JNI (Java Native Interface). Le code JNI correspondant doit être écrit pour relier le code Java et le moteur Duktape.
// Supposons qu'il existe déjà une interface JNI
classe publique DuktapeExample {
//Déclaration de la méthode JNI
String natif public executeScript (script String);
statique {
//Charger la bibliothèque contenant l'implémentation de la méthode Native
System.loadLibrary(duktape);
}
public static void main (String[] arguments) {
Exemple DuktapeExample = new DuktapeExample();
// Appelez Duktape pour exécuter JavaScript via JNI
Résultat de chaîne = exemple.executeScript(var msg = 'Bonjour, Duktape !'; msg;);
System.out.println(résultat);
}
}
GraalVM est une toute nouvelle machine virtuelle capable d'exécuter plusieurs langages, dont Java et JavaScript. L'objectif de GraalVM est de fournir un environnement d'exécution unique pour exécuter tous les langages de programmation, caractérisé par des performances élevées et une coexistence multilingue.
Dans GraalVM, vous pouvez utiliser la classe Context pour créer un environnement d'exécution pour exécuter JavaScript.
importer org.graalvm.polyglot.* ;
classe publique GraalVMExample {
public static void main (String[] arguments) {
// Utiliser le contexte de GraalVM pour exécuter du code JavaScript
essayez (contexte contextuel = Context.create()) {
// Exécuter le code JavaScript
Résultat de la valeur = context.eval(js, print('Bonjour, GraalVM !'););
}
}
}
Grâce aux méthodes ci-dessus, Java peut appeler des scripts JavaScript et utiliser les caractéristiques de programmation dynamique de JavaScript dans différents scénarios. Que ce soit via ScriptEngineManager, Nashorn, Duktape ou GraalVM, l'interopérabilité Java et JavaScript offre aux développeurs des outils puissants pour créer des applications flexibles et riches en fonctionnalités.
1. Comment appeler un script JavaScript dans du code Java ?
L'appel de scripts JavaScript en Java peut être réalisé en utilisant l'interface ScriptEngine de Java. Tout d’abord, vous devez créer une instance ScriptEngine, puis charger le script JavaScript dans l’instance. Ensuite, vous pouvez utiliser la méthode eval() de l'instance ScriptEngine pour exécuter du code JavaScript. Par exemple:
//Créer une instance ScriptEngine ScriptEngineManager manager = new ScriptEngineManager();ScriptEngine engine = manager.getEngineByName(JavaScript);try { //Charger le script JavaScript engine.eval(function sayHello() { return 'Hello, World!'; }); // Appel de la fonction JavaScript Résultat de l'objet = engine.eval(sayHello()); // Résultat de sortie System.out.println(result.toString());} catch (ScriptException e) { e.printStackTrace();}2. Comment passer des objets Java aux scripts JavaScript ?
Si vous souhaitez accéder à un objet Java dans un script JavaScript, vous pouvez lier l'objet Java à une variable globale dans l'instance ScriptEngine. De cette façon, vous pouvez utiliser la variable dans un script JavaScript pour appeler les méthodes de l'objet Java et accéder à ses propriétés. Par exemple:
//Créer une instance ScriptEngine ScriptEngineManager manager = new ScriptEngineManager();ScriptEngine engine = manager.getEngineByName(JavaScript);try { //Lier l'objet Java à la variable globale dans ScriptEngine engine.put(myObject, new MyObject()); // Utilisez cette variable dans le script JavaScript engine.eval(myObject.sayHello(););} catch (ScriptException e) { e.printStackTrace();}// Définir un objet Java public class MyObject { public void sayHello() { System.out.println(Bonjour de Java ! }});3. Comment obtenir la valeur de retour du script JavaScript en Java ?
Pour obtenir la valeur de retour d'un script JavaScript, vous pouvez utiliser la méthode eval() de l'instance ScriptEngine pour exécuter le script et stocker la valeur de retour dans une variable. Par exemple:
//Créer une instance ScriptEngine ScriptEngineManager manager = new ScriptEngineManager();ScriptEngine engine = manager.getEngineByName(JavaScript);try { //Exécuter le script JavaScript et obtenir la valeur de retour Object result = engine.eval(function sayHello() { return 'Bonjour tout le monde !'; } sayHello();); // Résultat de sortie System.out.println(result.toString());} catch (ScriptException e) { e.printStackTrace();}Dans le code ci-dessus, la valeur de retour du script JavaScript est la chaîne Hello, World !. En stockant le résultat de l'exécution du script dans la variable result, nous pouvons imprimer cette valeur de retour.
J'espère que cet article pourra vous aider à mieux comprendre comment Java appelle JavaScript. Pour plus de connaissances sur Java, continuez à suivre l'éditeur de Downcodes !