javafx
WebView et WebEngine

Remarques

Chargement d'une page

WebView wv = new WebView();
WebEngine we = wv.getEngine();
we.load("https://stackoverflow.com");

WebView est le shell d'interface utilisateur autour du WebEngine . Presque tous les contrôles pour l'interaction sans interface utilisateur avec une page sont effectués via la classe WebEngine .

Obtenir l'historique des pages d'une WebView

WebHistory history = webView.getEngine().getHistory();

L'historique est essentiellement une liste d'entrées. Chaque entrée représente une page visitée et permet d'accéder aux informations de page pertinentes, telles que l'URL, le titre et la date de la dernière visite de la page.

La liste peut être obtenue en utilisant la méthode getEntries() . L'historique et la liste correspondante des entrées changent lorsque WebEngine navigue sur le Web. La liste peut être étendue ou réduite en fonction des actions du navigateur. Ces modifications peuvent être écoutées par l’API ObservableList que la liste expose.

L'index de l'entrée d'historique associée à la page actuellement visitée est représenté par currentIndexProperty() . L'index actuel peut être utilisé pour accéder à n'importe quelle entrée de l'historique en utilisant la méthode go(int) . Le maxSizeProperty() définit la taille maximale de l'historique, qui correspond à la taille de la liste d'historique.

Vous trouverez ci-dessous un exemple sur la façon d' obtenir et de traiter la liste des éléments de l'historique Web .

Un ComboBox (comboBox) est utilisé pour stocker les éléments de l'historique. En utilisant ListChangeListener sur le WebHistory le ComboBox est mis à jour vers WebHistory actuel. Sur le ComboBox y a un EventHandler qui redirige vers la page sélectionnée.

final WebHistory history = webEngine.getHistory();

comboBox.setItems(history.getEntries());
comboBox.setPrefWidth(60);
comboBox.setOnAction(new EventHandler<ActionEvent>() {
    @Override
    public void handle(ActionEvent ev) {
        int offset =
                comboBox.getSelectionModel().getSelectedIndex()
                - history.getCurrentIndex();
        history.go(offset);
    }
});

history.currentIndexProperty().addListener(new ChangeListener<Number>() {

    @Override
    public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) {
        // update currently selected combobox item
        comboBox.getSelectionModel().select(newValue.intValue());
    }
});

// set converter for value shown in the combobox:
//   display the urls
comboBox.setConverter(new StringConverter<WebHistory.Entry>() {

    @Override
    public String toString(WebHistory.Entry object) {
        return object == null ? null : object.getUrl();
    }

    @Override
    public WebHistory.Entry fromString(String string) {
        throw new UnsupportedOperationException();
    }
});

envoyer des alertes Javascript de la page Web affichée au journal des applications Java.

private final Logger logger = Logger.getLogger(getClass().getCanonicalName());

WebView webView = new WebView();
webEngine = webView.getEngine();

webEngine.setOnAlert(event -> logger.warning(() -> "JS alert: " + event.getData())); 

Communication entre l'application Java et Javascript dans la page Web

Lorsque vous utilisez une WebView pour afficher votre propre page Web personnalisée et que celle-ci contient du Javascript, il peut être nécessaire d'établir une communication bidirectionnelle entre le programme Java et le Javascript de la page Web.

Cet exemple montre comment configurer une telle communication.

La page Web doit afficher un champ de saisie et un bouton. En cliquant sur le bouton, la valeur du champ de saisie est envoyée à l'application Java, qui la traite. Après traitement, un résultat est envoyé à Javascript qui affiche à son tour le résultat sur la page Web.

Le principe de base est que pour la communication de Javascript vers Java, un objet est créé en Java et défini dans la page Web. Et pour l'autre sens, un objet est créé en Javascript et extrait de la page Web.

Le code suivant montre la partie Java, je l'ai gardé dans un seul fichier:

package com.sothawo.test;

import javafx.application.Application;
import javafx.concurrent.Worker;
import javafx.scene.Scene;
import javafx.scene.web.WebEngine;
import javafx.scene.web.WebView;
import javafx.stage.Stage;
import netscape.javascript.JSObject;

import java.io.File;
import java.net.URL;

/**
 * @author P.J. Meisch ([email protected]).
 */
public class WebViewApplication extends Application {

    /** for communication to the Javascript engine. */
    private JSObject javascriptConnector;

    /** for communication from the Javascript engine. */
    private JavaConnector javaConnector = new JavaConnector();;

    @Override
    public void start(Stage primaryStage) throws Exception {
        URL url = new File("./js-sample.html").toURI().toURL();

        WebView webView = new WebView();
        final WebEngine webEngine = webView.getEngine();

        // set up the listener
        webEngine.getLoadWorker().stateProperty().addListener((observable, oldValue, newValue) -> {
            if (Worker.State.SUCCEEDED == newValue) {
                // set an interface object named 'javaConnector' in the web engine's page
                JSObject window = (JSObject) webEngine.executeScript("window");
                window.setMember("javaConnector", javaConnector);

                // get the Javascript connector object. 
                javascriptConnector = (JSObject) webEngine.executeScript("getJsConnector()");
            }
        });

        Scene scene = new Scene(webView, 300, 150);
        primaryStage.setScene(scene);
        primaryStage.show();

        // now load the page
        webEngine.load(url.toString());
    }

    public class JavaConnector {
        /**
         * called when the JS side wants a String to be converted.
         *
         * @param value
         *         the String to convert
         */
        public void toLowerCase(String value) {
            if (null != value) {
                javascriptConnector.call("showResult", value.toLowerCase());
            }
        }
    }
}

Lorsque la page a été chargée, un objet JavaConnector (défini par la classe interne et créé en tant que champ) est défini dans la page Web par ces appels:

JSObject window = (JSObject) webEngine.executeScript("window");
window.setMember("javaConnector", javaConnector);

L’objet javascriptConnector est extrait de la page Web avec

javascriptConnector = (JSObject) webEngine.executeScript("getJsConnector()");

Lorsque la méthode toLowerCase(String) de JavaConnector est appelée, la valeur transmise est convertie, puis renvoyée via l'objet javascriptConnector .

Et ceci est le code HTML et JavaScript:

<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Sample</title>
    </head>
    <body>
        <main>
    
            <div><input id="input" type="text"></div>
            <button onclick="sendToJava();">to lower case</button>
            <div id="result"></div>
    
        </main>
    
        <script type="text/javascript">
            function sendToJava () {
                var s = document.getElementById('input').value;
                javaConnector.toLowerCase(s);
            };
    
            var jsConnector = {
                showResult: function (result) {
                    document.getElementById('result').innerHTML = result;
                }
            };
    
            function getJsConnector() {
                return jsConnector;
            };
        </script>
    </body>
</html>

La fonction sendToJava appelle la méthode de JavaConnector définie par le code Java:

function sendToJava () {
    var s = document.getElementById('input').value;
    javaConnector.toLowerCase(s);
};

et la fonction appelée par le code Java pour récupérer le javascriptConnector renvoie simplement l'objet jsConnector :

var jsConnector = {
    showResult: function (result) {
        document.getElementById('result').innerHTML = result;
    }
};
    
function getJsConnector() {
    return jsConnector;
};

Le type d'argument des appels entre Java et Javascript n'est pas limité aux chaînes. Plus d'informations sur les types possibles et la conversion sont disponibles dans le doc de l'API JSObject .