javafx
WebView y WebEngine

Observaciones

Cargando una pagina

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

WebView es el shell de la interfaz de usuario alrededor del WebEngine . Casi todos los controles para la interacción sin interfaz de usuario con una página se realizan a través de la clase WebEngine .

Obtener el historial de la página de un WebView

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

El historial es básicamente una lista de entradas. Cada entrada representa una página visitada y proporciona acceso a información relevante de la página, como la URL, el título y la fecha en que se visitó la página por última vez.

La lista se puede obtener utilizando el método getEntries() . El historial y la lista correspondiente de entradas cambian a medida que WebEngine navega por la web. La lista puede expandirse o reducirse dependiendo de las acciones del navegador. Estos cambios pueden ser escuchados por la API ObservableList que la lista expone.

El índice de la entrada del historial asociado con la página visitada actualmente se representa mediante currentIndexProperty() . El índice actual se puede usar para navegar a cualquier entrada en el historial usando el método go(int) . maxSizeProperty() establece el tamaño máximo del historial, que es el tamaño de la lista del historial

A continuación se muestra un ejemplo de cómo obtener y procesar la Lista de elementos del historial web .

Se utiliza un ComboBox (comboBox) para almacenar los elementos del historial. Al usar un ListChangeListener en el WebHistory el ComboBox se actualiza al WebHistory actual. En el ComboBox hay un EventHandler que redirige a la página seleccionada.

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();
    }
});

envíe alertas de Javascript desde la página web mostrada al registro de aplicaciones 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())); 

Comunicación entre la aplicación Java y Javascript en la página web.

Cuando use un WebView para mostrar su propia página web personalizada y esta página contiene Javascript, puede ser necesario establecer una comunicación bidireccional entre el programa Java y el Javascript en la página web.

Este ejemplo muestra cómo configurar dicha comunicación.

La página web mostrará un campo de entrada y un botón. Al hacer clic en el botón, el valor del campo de entrada se envía a la aplicación Java, que lo procesa. Después de procesar un resultado, se envía a Javascript, que a su vez muestra el resultado en la página web.

El principio básico es que para la comunicación de Javascript a Java se crea un objeto en Java que se configura en la página web. Y para la otra dirección, un objeto se crea en Javascript y se extrae de la página web.

El siguiente código muestra la parte de Java, lo guardé todo en un archivo:

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());
            }
        }
    }
}

Cuando la página se ha cargado, un objeto JavaConnector (definido por la clase interna y creado como un campo) se establece en la página web mediante estas llamadas:

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

El objeto javascriptConnector se recupera de la página web con

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

Cuando se toLowerCase(String) método toLowerCase(String) del JavaConnector , el valor pasado se convierte y luego se devuelve a través del objeto javascriptConnector .

Y este es el código html y 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 función sendToJava llama al método del JavaConnector que fue establecido por el código Java:

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

y la función llamada por el código Java para recuperar el javascriptConnector simplemente devuelve el objeto jsConnector :

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

El tipo de argumento de las llamadas entre Java y Javascript no se limita a cadenas. Más información sobre los posibles tipos y conversión se encuentra en el documento de API JSObject .