javafx
WebView och WebEngine

Anmärkningar

Laddar en sida

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

WebView är UI-skalet runt WebEngine . Nästan alla kontroller för icke-UI-interaktion med en sida görs via klassen WebEngine .

Hämta sidhistoriken för en WebView

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

Historiken är i princip en lista med poster. Varje post representerar en besökt sida och den ger tillgång till relevant sidinformation, till exempel URL, titel och datum då sidan besökades senast.

Listan kan erhållas med getEntries() . Historiken och motsvarande lista med poster ändras när WebEngine navigerar över webben. Listan kan expandera eller krympa beroende på webbläsarens åtgärder. Dessa ändringar kan lyssnas på av ObservableList API som listan visar.

Indexet för historikposten som är associerad med den för närvarande besökta sidan representeras av den currentIndexProperty() . Det aktuella indexet kan användas för att navigera till valfri post i historiken med hjälp av go(int) -metoden. maxSizeProperty() anger maximal historikstorlek, som är storleken på historiklistan

Nedan följer ett exempel på hur du får fram och bearbetar listan över webbhistorikobjekt .

En ComboBox (comboBox) används för att lagra historikobjekten. Genom att använda en ListChangeListener på WebHistory uppdateras ComboBox till den aktuella WebHistory . På ComboBox finns en EventHandler som omdirigerar till den valda sidan.

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

skicka Javascript-varningar från den visade webbsidan till Java-applikationsloggen.

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

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

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

Kommunikation mellan Java-appen och Javascript på webbsidan

När du använder en WebView för att visa din egen anpassade webbsida och denna webbsida innehåller Javascript, kan det vara nödvändigt att upprätta en tvåvägskommunikation mellan Java-programmet och Javascript på webbsidan.

Detta exempel visar hur du konfigurerar en sådan kommunikation.

Webbsidan ska visa ett inmatningsfält och en knapp. När du klickar på knappen skickas värdet från inmatningsfältet till Java-applikationen, som bearbetar det. Efter bearbetning skickas ett resultat till Javascript som i sin tur visar resultatet på webbsidan.

Grundprincipen är att för kommunikation från Javascript till Java skapas ett objekt i Java som är inställt på webbsidan. Och för den andra riktningen skapas ett objekt i Javascript och extraheras från webbsidan.

Följande kod visar Java-delen, jag lagrade allt i en fil:

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

När sidan laddats JavaConnector ett JavaConnector objekt (som definieras av den inre klassen och skapas som ett fält) in på webbsidan av dessa samtal:

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

javascriptConnector objektet hämtas från webbsidan med

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

När toLowerCase(String) -metoden från JavaConnector anropas konverteras det passerade värdet och skickas sedan tillbaka via javascriptConnector objektet.

Och detta är html- och javascript-koden:

<!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>

Funktionen sendToJava anropar metoden för JavaConnector som inställdes med Java-koden:

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

och den funktion som kallas av Java-koden för att hämta javascriptConnector returnerar bara jsConnector objektet:

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

Argumenttypen för samtal mellan Java och Javascript är inte begränsade till strängar. Mer information om möjliga typer och konvertering finns i JSObject API-dokumentet .