Integration einer Tabellenkalkulation (xlsx) in eine JavaFX- Abwendung

Table of Contents

Das Hauptanliegen unserer SCell-API besteht darin, xlsx-Tabellen in Ihrer Java oder Web Anwendung eingebettet nutzbar zu machen. In diesem Artikel zeigen wir Ihnen, wie Sie SCell mit seiner vollen Funktionalität in Ihrer Java Anwendung integrieren können, um darin xlsx-Tabellen anzuzeigen und zu bearbeiten. Mit der API gelingt die Integration von xlsx-Tabellen schnell und einfach.

Um dies zu demonstrieren, erstellen wir die Demo-App wie folgt:

Unsere Demo-Anwendung verwendet dabei grundlegende Funktionen der SCell-API:

  • Öffnen und Speichern einer xlsx-Datei, Bearbeiten, Suchen und das Rückgängigmachen und Wiederholen von Befehlen.

Der linke Bereich enthält lediglich Befehle zum Öffnen vordefinierter Dateien (xlsx-Templates). Die Symbolleiste oben enthält die Befehle für den Anwender, der Rest des Layouts, das Tabellenblatt, ist das SCell UI Control.

Die Architektur der Anwendung sieht wie folgt aus:

Schauen wir uns nun einige Details der Schritt für Schritt- Implementierung an (der vollständige Quellcode ist auf GitHub verfügbar).

 

Step 1. Integration eines xlsx-spreadsheets in die JavaFX Anwendung

Wie in den vorangegangenen Artikeln (Wie man Excel-Dateien mit dem IntelliJ IDEA plugin in Java liest and Bearbeiten und Erstellen von Exceldateien in Java mit SCell) beschrieben, können Sie nach dem Hinzufügen der SCell-API-Abhängigkeiten zum Projektzugriff auf den ScellApiEntryPoint erhalten. Dann lösen Sie IScellUiFxApiBuilder und IScellCoreApiFactory auf, die das UI-Steuerelement mit dem erforderlichen IWorkbook-Objekt erstellen können. Hier ist das Codebeispiel:

ScellApiEntryPoint.getApiResolverAsync().thenApplyAsync(resolver -> {
    IScellCoreApiFactory coreFactory = IScellCoreApiFactory.resolve(resolver);
    CompletableFuture<IWorkbook> workbookFuture = CompletableFuture.supplyAsync(coreFactory::createNew);
    IScellUiApi<Node> uiApi = IScellUiFxApiBuilder.resolve(resolver)
            .readOnly(false)
            .create(workbookFuture);
    return uiApi.getControl();
}, Platform::runLater)

Das IWorkbook hat die volle Kontrolle über das xlsx-Tabellenblattdokument. Die IWorkbook-Instanz ist erforderlich, um das UI-Steuerelement zu erstellen.

IScellUiApiBuilder erstellt die IScellUiApi mit den gewünschten Parametern. Die Beschreibungen der Parameter finden Sie in der JavaDoc. Die IScellUiApi liefert das Schlüsselobjekt (getControl() call) – ein JavaFX-Steuerelement mit eingebettetem xlsx-Spreadsheet, das zur Interaktion bereit ist. Dann kann der Knoten zum Anwendungslayout hinzugefügt werden.

Step 2. Interaktion mit einem in eine JavaFX-Anwendung eingebetteten
xlsx-Arbeitsplatt

Alle SCell-API-Aufrufe in der Anwendung sind in der ScellWrapper-Klasse gekapselt (siehe den vollständigen Code auf GitHub, da der Code in diesem Artikel, um ihn verständlicher zu machen, Unterschiede zum GitHub-Code aufweist). Wie oben erwähnt, werden wir die folgenden Funktionen implementieren:

  • Load an xlsx-file
  • Save an xlsx-file
  • Create a new xlsx-file
  • Undo/Redo
  • Search
  • Dialogfenster mit Informationen zur SCell API version

Um die gewünschten Funktionen zu implementieren, benötigen wir die folgenden SCell-API-Dienste (uiManager und selectionManager) und Versionsdaten (versionData):

    // private class members
    private IUiContentManager uiManager;
    private IUiSelectionManager selectionManager;
    private IProductInfo versionData;
    // ...
// Constructor or other init method content
ScellApiEntryPoint.getApiResolverAsync().thenApplyAsync(resolver -> {
    IScellCoreApiFactory coreFactory = IScellCoreApiFactory.resolve(resolver);
    CompletableFuture<IWorkbook> workbookFuture = CompletableFuture.supplyAsync(coreFactory::createNew);
    IScellUiApi<Node> uiApi = IScellUiFxApiBuilder.resolve(resolver)
            .readOnly(false)
            .create(workbookFuture);
    this.uiManager = uiApi.getContentManager();
    this.selectionManager = uiApi.getSelectionManager();
    this.versionData = coreFactory.getProductInfo();
    return uiApi.getControl();
}, Platform::runLater)

Jetzt wollen wir die SCell-API-Aufrufe in der ScellWrapper-Klasse zeigen:

Wie bereits erwähnt, benötigt die SCell-API zur Erstellung eines JavaFX-Knotens, der ein xlsx-Arbeitsblatt enthält, eine Instanz der IWorkbook-Schnittstelle, die die volle Kontrolle über ein xlsx-Arbeitsblattdokument hat. IWorkbook gehört zur Kern-API und kann auf verschiedene Arten bezogen werden:

  • Erstellen einer neuen Datei,
  • Laden aus einer vorhandenen Datei oder
  • programmgesteuertes Laden aus einem vom Benutzer erstellten Stream.

Alle diese Methoden werden von der Kern-API bereitgestellt (mit Hilfe des IScellCoreApiFactory-Dienstes). Um jedoch eine Datei in unserer Anwendung zu laden oder zu speichern, müssen wir das vorhandene Tabellenblatt aufrufen, das vom SCell JavaFX-Knoten angezeigt wird. Die entsprechenden Methoden werden vom IUiContentManager bereitgestellt, den wir im vorherigen Beispiel erhalten haben. Unter Berücksichtigung des oben Erwähnten sehen die Implementierungen der gewünschten Funktionen wie folgt aus (vollständiger Code ist hier):

Load a file
   // to load local file
   public CompletableFuture<Void> loadSpreadsheet(File file) {
        if (file == null) {
            return CompletableFuture.completedFuture(null);
        }
        return this.uiManager.load(file);
    }

    // to load predefined xlsx from app resources
    public CompletableFuture<Void> loadSpreadsheet(InputStream content, String name) {
        return this.uiManager.load(content, name);
    }
Save a file
    public CompletableFuture<Void> saveAs(File target) {
        if (target == null) {
            return CompletableFuture.completedFuture(null);
        }
        return this.uiManager.getWorkbook().thenAccept(workbook ->
                workbook.getWriter().fileName(target.getAbsolutePath()).save());
    }
Create a new file
    public void createNew() {
        this.uiManager.clear();
    }

In this example, we are simply clearing contents of a JavaFX UI control that displays an xlsx-spreadsheet. This action creates a new xlsx-file, independent of the previous one

Undo/Redo
    public void undo() {
        this.uiManager.undoLastAction();
    }

    public void redo() {
        this.uiManager.redoLastAction();
    }
About info
    public String getApiVersionsInfo() {
        return String.join("\n",
            "SCell API Core Interfaces: \t\t\t" + this.versionData.coreInterfaces(IProductInfo.ProductInfo.VERSION_WITH_BUILD_NUMBER),
            "SCell API Core Implementation: \t" + this.versionData.coreImpl(IProductInfo.ProductInfo.VERSION_WITH_BUILD_NUMBER),
            "SCell API UI Interfaces: \t\t\t" + this.versionData.uiInterfaces(IProductInfo.ProductInfo.VERSION_WITH_BUILD_NUMBER),
            "SCell API UI Implementation: \t\t" + this.versionData.uiImpl(IProductInfo.ProductInfo.VERSION_WITH_BUILD_NUMBER));
    }

    public String getPlatformVersionsInfo() {
        return "JavaFX: " + this.versionData.getJavaFxVersion() + "\n"
                + "Java Runtime Version: " + this.versionData.getJavaVersionInfo();
    }

Um zu beschreiben, wie die Suche funktioniert, sind detailliertere Erklärungen erforderlich, die einen eigenen Artikel wert sind, so dass Sie sich die Umsetzung auf GitHub ansehen können.

 

Step 3. Zusammenfassung

Der ScellWrapper wird mit Hilfe von einfachen Fabriken ( ButtonsFactory und ToolbarsFactory), die die Erstellung von Schaltflächen mit ihren Ereignissen kapseln, an die Ansicht gebunden.

Im Ergebnis sieht die Hauptanwendungsklasse wie folgt aus:

public class App extends Application {
    @Override
    public void start(Stage primaryStage) {
        BorderPane root = new BorderPane();
        root.setVisible(false);

        ScellWrapper scell = new ScellWrapper();

        scell.getScellControlFuture().thenAccept(scellControl -> {
            root.setCenter(scellControl);
            root.setStyle("-fx-background-color: #28a87d;");
            root.setVisible(true);
        });

        ButtonsFactory buttonsFactory = new ButtonsFactory(scell, primaryStage, App.class.getClassLoader());
        ToolbarsFactory toolbarsFactory = new ToolbarsFactory(buttonsFactory);

        root.setTop(toolbarsFactory.createTopToolbar());
        root.setLeft(toolbarsFactory.createLeftToolbar());

        primaryStage.setScene(new Scene(root, 800, 600));
        primaryStage.show();
    }

In den hervorgehobenen Zeilen wurde der JavaFX-Knoten, der ein xlsx-Arbeitsblatt und Symbolleisten enthält, der JavaFX-Scene hinzugefügt.

SCell kann viel mehr als nur xlsx-Tabellen integrieren, öffnen oder speichern. Es verfügt über eine breite Palette von Tools, die Ihnen bei der Verwaltung von xlsx-Arbeitsblättern helfen werden. Wir hoffen, dass dieser Artikel für Sie nützlich war.

Für weitere Informationen besuchen Sie unsere offizielle Website und JavaDoc. Sie können uns auch gerne über unsere Kontaktseite erreichen.

Share:

More Posts

Nach oben scrollen