Es ist schwierig, Apache POI so zu verwenden, wie es ist. Als ich nach einem guten suchte, war Jxls gut. Was gut ist, ist, dass Sie Daten mit einer Baumstruktur einfach ausgeben können. Als ich jedoch danach suchte, schien es, dass es nur wenige japanische Dokumente gab, also übersetzte ich es. Ich würde es begrüßen, wenn Sie auf merkwürdige Punkte hinweisen könnten.

Dieser Artikel ist ein übersetzter Artikel von hier. Wir übersetzen die Version 2020/3/30 des Dokuments.

Einführung

JXLS ist eine kleine Java-Bibliothek zum einfachen Generieren von Excel-Formularen. Das Format des von JXLS ausgegebenen Formulars und das Layout der Daten werden durch Schreiben einer eindeutigen Syntax in die Excel-Vorlage definiert. Die Excel-Generierung ist für Java-Anwendungen wie die sogenannte Formularfunktion unverzichtbar geworden.

Java hat eine sehr gute Bibliothek für die Ausgabe von Excel-Dateien, sowohl Open Source als auch kommerziell. Unter den Open Source sind Apache POI und Java Excel API erwähnenswert.

Diese Bibliotheken sind jedoch sehr niedrig (primitiv), und selbst wenn Sie Excel mit einer einfachen Struktur ausgeben möchten, müssen Sie viel Quellcode schreiben.

Normalerweise müssen Sie bei diesen Bibliotheken jede Zelle manuell formatieren und datieren. Und wenn das Layout von Formularen und die Formatierung von Daten komplexer werden, wird auch der Quellcode komplexer, was das Debuggen und Verwalten erschwert. Darüber hinaus werden nicht alle Excel-Funktionen unterstützt, sodass nicht alle über die API verarbeitet werden können. (Beispielsweise können Makros und Diagramme nicht verwendet werden.) Für solche nicht unterstützten Funktionen können Sie ein Objekt selbst in eine Excel-Vorlage einbetten und dann Daten über die API schreiben.

Jxls hingegen ermöglicht die Generierung von Excel-Formularen auf einer höheren Ebene. Alles, was Sie tun müssen, um ein Excel-Formular mit JXLS zu generieren, ist, das Formularformat und die Datenformatierung in die Vorlage einzubetten und die Daten dann mit der JXLS-Engine in die Vorlage zu fließen. In den meisten Fällen ist beim Generieren von Excel-Formularen kein Schreiben von Quellcode erforderlich, außer das Deklarieren der JXLS-Engine und das Schreiben der entsprechenden Einstellungen.

Charakteristisch

XML- und Binärformat-Excel-Formularausgabe (abhängig von der JAVA-Excel-Konvertierungs-API auf niedriger Ebene)
Konvertieren Sie die Java-Auflistungsklasse in eine Zeile oder Spalte und geben Sie sie aus
Bedingte Ergebnisausgabe
Markierungssprache zum Definieren von Formularen
Mehrfachblattausgabe
Einbetten von Excel-Formeln
Parametrisierte Formel
Unterstützt die Gruppierung (* Datenausgabe für jede Gruppe. Getrennt von der Gruppierung von Excel-Funktionen)
Unterstützt das Zusammenführen von Zellen
Ein Listener, der die Excel-Generierung unterstützt --Markup-Syntax zum Schreiben in Excel-Kommentaren zur Befehlsdefinition
XML-Syntax für die Befehlsdefinition
Benutzerdefinierte Befehlsdefinition
Unterstützt Streaming, wodurch der Speicherverbrauch reduziert und eine schnellere Ausgabeverarbeitung ermöglicht wird
Es kann angegeben werden, dass nur das ausgewählte Blatt von Streaming verarbeitet wird.
Unterstützt die Tabellenverbindung

Erste Schritte

Betrachten wir zunächst den Fall, in dem Sie das Employee-Objekt in einem Excel-Formular ausgeben möchten. Die Employee-Klasse sieht so aus.

public class Employee {
    private String name;
    private Date birthDate;
    private BigDecimal payment;
    private BigDecimal bonus;
    // ... constructors
    // ... getters/setters
}

Um dieses Objekt mit JXLS in Excel auszugeben, müssen die folgenden Schritte ausgeführt werden.

Fügen Sie Ihrem Projekt die erforderlichen Bibliotheken für JXLS hinzu
Erstellen Sie eine Excel-Vorlage mit einer speziellen Syntax
Führen Sie den Prozess des Einbettens von Mitarbeiterdaten in die Vorlage aus, die mit der JXLS-API erstellt wurde.

Schauen wir uns jeden dieser Schritte im nächsten Kapitel genauer an.

Fügen Sie Ihrem Projekt die erforderlichen Bibliotheken für JXLS hinzu

Am einfachsten ist es, Maven zu verwenden, um die erforderlichen Bibliotheken in der Konfigurationsdatei anzugeben. Das Jxls-Glas ist im Central Repository von Maven verfügbar. Das Kernmodul von Jxls hängt von den folgenden Bibliotheken ab.

<dependency>
    <groupId>org.jxls</groupId>
    <artifactId>jxls</artifactId>
    <version>2.8.0</version>
</dependency>

Eine andere Möglichkeit besteht darin, es von der Sourceforge-Site herunterzuladen und das Glas zu verwenden.

Zusätzlich zu den Jxls-Kernmodulen müssen wir eine Abhängigkeit von der Jxls-Transformator-Engine hinzufügen, die die Grundlage für alle Funktionen zur Durchführung von Konvertierungsvorgängen von Java in Excel bildet.

Wie im Kapitel Transformer (siehe Hauptkonzept) erläutert, hängen die Kernmodule von Jxls nicht von einer anderen spezifischen Java-Excel-Bibliothek ab. Heutzutage bietet Jxls jedoch unabhängige Schnittstellen für jede der Apache POI- und Java Excel-API-Bibliotheken. ..

Fügen Sie pom.xml die folgende Abhängigkeit hinzu, um den Apache POI-basierten Konverter zu verwenden.

<dependency>
    <groupId>org.jxls</groupId>
    <artifactId>jxls-poi</artifactId>
    <version>2.8.0</version>
</dependency>

Fügen Sie die folgenden Abhängigkeiten hinzu, um einen Konverter zu verwenden, der auf der Java Excel-API basiert.

<dependency>
    <groupId>org.jxls</groupId>
    <artifactId>jxls-jexcel</artifactId>
    <version>${jxlsJexcelVersion}</version>
</dependency>

Erstellen Sie eine Excel-Vorlage

Eine Vorlage ist eine Excel-Datei, die mithilfe einer proprietären Syntax angibt, wie Daten ausgegeben werden.

Jxls verfügt über einen integrierten Markup-Verarbeitungsmechanismus, der aus einer Excel-Vorlage interpretiert werden kann, um Steuerbefehle zu extrahieren.

Benutzerdefinierte Markup-Verarbeitungsmechanismen können nach Bedarf erstellt werden. Sie können Ihre eigene Syntax definieren und in eine Excel-Vorlage einbetten, um eine Jxls-Befehlsstruktur zu erstellen.

Im Folgenden wird der integrierte Syntaxverarbeitungsmechanismus beschrieben.

Standardmäßig unterstützt Jxls Apache JEXL. Apache JEXL ist die Sprache, die in Excel-Vorlagen verwendet wird und zum Verweisen auf die Methoden und Eigenschaften von Java-Objekten verwendet wird. Unter einem Schlüssel ist das Objekt im Jxls-Kontext verfügbar. Um den Namen des Mitarbeiters in eine Zelle zu drucken, schreiben Sie einfach "$ {employee.name}" in die Zelle. Grundsätzlich ist Jxls auch voll von Jexl-ähnlichen Ausdrücken $ { und }. Anhand der Syntax können Sie schließen, dass sich das Employee-Objekt hinter dem Schlüssel "employee" befindet.

Die Eigenschaftsnotationsmethode kann festgelegt werden. Sie können es beispielsweise festlegen, indem Sie "[[employee.name]]" als Eigenschaftsnotation verwenden. Weitere Informationen finden Sie unter Ausdruckssprache (http://jxls.sourceforge.net/reference/expression_language.html).

Die Beispielvorlage zur Ausgabe des Employee-Objekts sieht möglicherweise folgendermaßen aus:

In der vierten Zeile dieser Vorlage wird die zuvor beschriebene JEXL-Syntax verwendet, um auf die Eigenschaften des Mitarbeiterobjekts zu verweisen.

Zelle A1 enthält einen Excel-Kommentar wie "jx: area (lastCell =" D4 ")". Dieser Kommentar definiert, dass der Vorlagenbereich der obersten Ebene von Jxls im Bereich A1: D4 liegt.

Im Kommentar von Zelle A4 ist Jxls Eaxh-Command definiert als "jx: each (items = "employee" var = "employee" lastCell = "D4")". Dieser Befehl "Jeder" ruft jeden Satz von Objekten mit "Mitarbeiter" als Schlüssel ab und platziert einzelne Daten im Schlüssel "Mitarbeiter" (definiert durch das var-Attribut). Der Umfang jedes Befehls ist A4: D4 und wird jedes Mal dupliziert, wenn ein neues Mitarbeiterobjekt im Kontext angezeigt wird.

In diesem Beispiel wird die XlsCommentAreaBuilder-Klasse zum Erstellen des Jxls-Bereichs verwendet. Diese Klasse kann definiert werden, indem der Befehl Jxls in einen Excel-Zellenkommentar geschrieben wird. Wenn es vorzuziehen ist, es im Java-Quellcode zu definieren, ist es in Ordnung, die Zelle ohne Kommentare als Vorlage zu verwenden.

Verwenden Sie die Jxls-API, um Vorlagen zu verarbeiten

Hier ist ein Beispiel für die Verwendung der Jxls-API zum Verarbeiten von Excel-Vorlagen.

...
    logger.info("Running Object Collection demo");
    List<Employee> employees = generateSampleEmployeeData();
    try(InputStream is = ObjectCollectionDemo.class.getResourceAsStream("object_collection_template.xls")) {
        try (OutputStream os = new FileOutputStream("target/object_collection_output.xls")) {
            Context context = new Context();
            context.putVar("employees", employees);
            JxlsHelper.getInstance().processTemplate(is, os, context);
        }
    }
...

In diesem Beispiel wird die Vorlage (object_collection_template.xls) angegeben und aus dem Klassenpfad gelesen. Die generierte Excel-Datei wird in target / object_collection_output.xls geschrieben.

Der Hauptprozess wird durch die folgende Zeile dargestellt.

JxlsHelper.getInstance().processTemplate(is, os, context);

Standardmäßig erwartet JxlsHelper, dass Daten auf dem Vorlagenblatt überschrieben werden.

Mit der folgenden Methode können Sie jedoch auch neue Daten auf ein anderes Blatt schreiben.

JxlsHelper.getInstance().processTemplateAtCell(is, os, context, "Result!A1");

In diesem Beispiel wird der Bereich in die Zelle "A1" des Blattes "Ergebnis" geschrieben.

Das in diesem Beispiel generierte endgültige Formular kann von [hier] heruntergeladen werden (http://jxls.sourceforge.net/xls/object_collection_output.xls). Es sieht aus wie das:

Referenz

Konzeptübersicht

Jxls basiert auf dem folgenden Konzept.

XlsArea
Command
Transformer

Schauen wir uns die einzelnen Funktionen genauer an.

Xls Bereich

Der Xls-Bereich bezieht sich auf den in der Excel-Datei gezeichneten rechteckigen Bereich. Insbesondere wird er durch Angabe des Zellbereichs sowie der Startzelle und -größe (Anzahl der Zeilen und Spalten) angegeben. Kann gemacht werden. Das heißt, der Xls-Bereich enthält alle Zellen im angegebenen Bereich.

Jeder XlsA-Bereich kann eine Reihe von Befehlen enthalten, die die Jxls-Engine während der Verarbeitung des Bereichs ausführt. Und Sie können untergeordnete Bereiche im Xls-Bereich verschachteln lassen. Und jeder untergeordnete Bereich kann wie sein übergeordneter Bereich Befehle und Enkelbereiche haben.

Der Xls-Bereich kann auf drei Arten definiert werden:

So schreiben Sie in die Excel-Vorlage mit einer dedizierten Syntax: Jxls stellt standardmäßig die Syntax bereit, die XlsCommandAreaBuilder entspricht. Auf Wunsch können Sie auch eine benutzerdefinierte Syntax bereitstellen.
Verwendung der XML-Definitionsdatei: Jxls bietet die XmlAreaBuilder-Klasse für die Interpretation der XML-Syntax.
Verwendung der Jxls Java API

Hier ist ein Beispiel für die Definition des Xls-Bereichs.

Command

Ein Befehl bezieht sich auf eine Konvertierungsaktion für einen oder mehrere XLS-Bereiche. Die entsprechende Java-Schnittstelle lautet wie folgt.

public interface Command {
    String getName();
    List<Area> getAreaList();
    Command addArea(Area area);
    Size applyAt(CellRef cellRef, Context context);
    void reset();
}

Die Hauptmethode des Befehls ist "Size applyAt (CellRef cellRef, Kontextkontext)". Diese Methode übergibt die Befehlsaktion an die in der Variablen "cellRef" übergebene Zelle und die in der Variablen "context" übergebenen Daten. Kontexte können wie Karten behandelt werden und werden verwendet, um Daten an Befehle zu übergeben.

Jxls bietet die folgenden integrierten Befehle. --Jeder-Befehl: Befehl, der ausgeführt wird, während Daten im Listenformat durchlaufen werden --If-Command: Ein Befehl, der die Verarbeitung unter bestimmten Bedingungen ausführt --Image-Command: Befehl zum Rendern des Bildes --MergeCells-Command - Zellen zusammenführen

Sie können auch einfach Ihre eigenen benutzerdefinierten Befehle definieren. Der Prozess der Datenübergabe an den Befehl wird vom Context-Objekt realisiert. Der Kontext funktioniert wie eine Karte. In der XLS-Vorlage wird anhand der Schlüsselinformationen auf sie verwiesen, und der zugehörige Wert wird als Daten festgelegt.

Tramsformer Über die Transformer-Oberfläche kann der Xls-Bereich unabhängig von einem bestimmten Framework mit Excel arbeiten. Das heißt, Sie können eine Konvertierungsschnittstelle mit einem anderen Java-zu-Excel-Framework verwenden. Die Schnittstelle wird in der folgenden Form verwendet.

public interface Transformer {
    void transform(CellRef srcCellRef, CellRef targetCellRef, Context context, boolean updateRowHeight);

    void setFormula(CellRef cellRef, String formulaString);

    Set<CellData> getFormulaCells();

    CellData getCellData(CellRef cellRef);

    List<CellRef> getTargetCellRef(CellRef cellRef);

    void resetTargetCellRefs();

    void resetArea(AreaRef areaRef);

    void clearCell(CellRef cellRef);

    List<CellData> getCommentedCells();

    void addImage(AreaRef areaRef, byte[] imageBytes, ImageType imageType);

    void write() throws IOException;

    TransformationConfig getTransformationConfig();

    void setTransformationConfig(TransformationConfig transformationConfig);

    boolean deleteSheet(String sheetName);

    void setHidden(String sheetName, boolean hidden);

    void updateRowHeight(String srcSheetName, int srcRowNum, String targetSheetName, int targetRowNum);

Auf den ersten Blick sieht es so aus, als wären viele Methoden erschienen, aber die meisten davon sind bereits in der zugrunde liegenden abstrakten Klasse "AbstractTransformer" implementiert. Dann erben Sie bei Bedarf davon und implementieren Sie ein neues Java-to-Excel.

Derzeit bietet Jxls die folgenden zwei Transformatoren an.

PoiTransformer
JexcelTransformer

PoiTransformer befasst sich mit der berühmten Excel-Datei-Ausgabebibliothek Apache POI. Beachten Sie, dass JexcelTransformer auf der alten Java Excel-API-Bibliothek basiert.

POI Transformer PoiTransformer ist eine Implementierung der Transformer-Schnittstelle, die auf Apache POI basiert.

Dies ist ein integrierter Excel-Transformator aus dem Modul jxls-poi.

Es unterstützt sowohl POI-HSSF- als auch POI-XSSF / SXSSF-Arbeitsmappen und verfügt über mehrere Konstruktoren, mit denen Sie Streaming- oder Nicht-Streaming-Transformationsinstanzen aus POI-Arbeitsmappen oder aus Vorlageneingabestreams erstellen können.

Außerdem können Sie die Zeilenhöhe und Spaltenbreite der Quellzelle während der Zellenkonvertierung ignorieren. Dies wird mit den Methoden setIgnoreRowProps (boolean) und setIgnoreColumnProps (boolean) erreicht.

XLS Area Introduction Der XLS-Bereich ist das Hauptkonzept von Jxls Plus. Es stellt im Grunde einen rechteckigen Bereich in einer Excel-Datei dar, der konvertiert werden muss. Jeder XLS-Region kann eine Liste von Konvertierungsbefehlen und eine Reihe verschachtelter untergeordneter Regionen zugeordnet sein. Jede untergeordnete Region ist auch eine XLS-Region mit einem eigenen Befehl und einer Reihe verschachtelter Regionen. Eine XLS-Region der obersten Ebene hat keine übergeordnete Region (sie ist in keiner anderen XLS-Region verschachtelt).

Erstellen Sie einen XLS-Bereich

Es gibt drei Möglichkeiten, einen XLS-Bereich zu definieren:

--Markup to Excel

Definiert durch XML --Verwenden Sie die Java-API

Lassen Sie uns jede Methode im Detail erklären.

Excel-Markup zum Erstellen von XLS-Bereichen

Sie können spezielle Markups in der Excel-Vorlage verwenden, um den XLS-Bereich zu erstellen. Das Markup sollte im Excel-Kommentar in der ersten Zelle des Bereichs platziert werden. Das Markup sieht folgendermaßen aus:

jx:area(lastCell = "<AREA_LAST_CELL>")

Wobei "<AREA_LAST_CELL>" die letzte Zelle im definierten Bereich ist.

Dieses Markup definiert einen Bereich der obersten Ebene, der mit der Zelle mit dem Markup-Kommentar beginnt und mit "<AREA_LAST_CELL>" endet.

Schauen wir uns die Beispielvorlage für die Ausgabeobjektsammlung an, um ein Beispiel zu sehen.

In dem Kommentar in Zelle A1 ist der Bereich wie folgt definiert:

jx:area(lastCell="D4")

Hier haben wir also einen Bereich, der den A1: D4-Zellbereich abdeckt.

Um das Markup zu analysieren und ein XlsArea-Objekt zu erstellen, müssen Sie die XlsCommentAreaBuilder-Klasse wie folgt verwenden:

// getting input stream for our report template file from classpath
InputStream is = ObjectCollectionDemo.class.getResourceAsStream("object_collection_template.xls");
// creating POI Workbook
Workbook workbook = WorkbookFactory.create(is);
// creating JxlsPlus transformer for the workbook
PoiTransformer transformer = PoiTransformer.createTransformer(workbook);
// creating XlsCommentAreaBuilder instance
AreaBuilder areaBuilder = new XlsCommentAreaBuilder(transformer);
// using area builder to construct a list of processing areas
List<Area> xlsAreaList = areaBuilder.build();
// getting the main area from the list
Area xlsArea = xlsAreaList.get(0);

Die folgenden zwei Codezeilen führen den Hauptprozess zum Erstellen einer JxlsArea aus.

AreaBuilder areaBuilder = new XlsCommentAreaBuilder(transformer);
List<Area> xlsAreaList = areaBuilder.build();

Instanziieren Sie zunächst XlsCommentAreaBuilder, um eine Instanz von AreaBuilder zu erstellen. Rufen Sie dann die Methode areaBuilder.build () auf, um eine Liste der Area-Objekte aus der Vorlage zu erstellen.

Sobald Sie eine Liste der Bereiche der obersten Ebene haben, können Sie diese für Excel-Konvertierungen verwenden.

XML-Einstellungen zum Erstellen des XLS-Bereichs

Wenn Sie eine XLS-Region mit XML-Markup definieren möchten, haben Sie folgende Möglichkeiten:

Zunächst müssen Sie eine XML-Einstellung erstellen, die die Region definiert.

Betrachten Sie als Beispiel eine einfache XML-Konfiguration aus der Ausgabe einer Objektsammlung mit XML Builder.

<xls>
    <area ref="Template!A1:D4">。
        <each items="employees" var="employees" ref="Template!
            <area ref="Template!A4:D4"/>
        </each>
    </area>
</xls>

Das Wurzelelement ist xls. Listen Sie als Nächstes einige der Bereichselemente auf, die jeden Bereich der obersten Ebene definieren.

Hier hat das Vorlagenblatt einen Bereich der obersten Ebene mit der Bezeichnung A1: D4.

<area ref="Template!A1:D4"> In diesem Bereich verwenden Sie spezielle Elemente für einen bestimmten Befehl, um den zugehörigen Befehl zu definieren. In diesem Fall wird jeder Befehl in jedem XML-Element definiert. Der jedem Befehl zugeordnete Bereich wird durch das ref-Attribut angegeben.

<each items =" employee "var =" employee "ref =" template! A4: D4 ">. In jedem Befehl befindet sich ein verschachtelter Regionsparameter.

<area ref="template!

Erstellen Sie einen XLS-Bereich mit der Java-API

Um einen XLS-Bereich mithilfe der Java-API zu erstellen, können Sie einen der Konstruktoren der XlsArea-Klasse verwenden. Die folgenden Konstruktoren sind verfügbar.


 public XlsArea(AreaRef areaRef, Transformer transformer);

 public XlsArea(String areaRef, Transformer transformer);

 public XlsArea(CellRef startCell, CellRef endCell, Transformer transformer);

 public XlsArea(CellRef startCellRef, Size size, List<CommandData> commandDataList, Transformer transformer);

 public XlsArea(CellRef startCellRef, Size size);

 public XlsArea(CellRef startCellRef, Size size, Transformer transformer);

Um einen Realm der obersten Ebene zu erstellen, müssen Sie eine Transformer-Instanz bereitstellen, damit der Realm transformiert werden kann.

Anschließend müssen Sie die Zellen in dem Bereich definieren, indem Sie den Zellbereich als Zeichenfolge verwenden oder ein CellRef-Zellreferenzobjekt erstellen und die Größe des Bereichs festlegen.

Unten finden Sie einen Teil des Codes, der eine Reihe verschachtelter XLS-Vorlagenbereiche mit Befehlen erstellt.


// create Transformer instance
// ...
// Create a top level area
XlsArea xlsArea = new XlsArea("Template!A1:G15", transformer);
// Create 'department' are
XlsArea departmentArea = new XlsArea("Template!A2:G13", transformer);
// create 'EachCommand' to iterate through departments
EachCommand departmentEachCommand = new EachCommand("department", "departments", departmentArea);
// create an area for employee 'each' command
XlsArea employeeArea = new XlsArea("Template!A9:F9", transformer);
// create an area for 'if' command
XlsArea ifArea = new XlsArea("Template!A18:F18", transformer);
// create 'if' command with the specified areas
IfCommand ifCommand = new IfCommand("employee.payment <= 2000",
        ifArea,
        new XlsArea("Template!A9:F9", transformer));
// adding 'if' command instance to employee area
employeeArea.addCommand(new AreaRef("Template!A9:F9"), ifCommand);
// create employee 'each' command and add it to department area
Command employeeEachCommand = new EachCommand( "employee", "department.staff", employeeArea);
departmentArea.addCommand(new AreaRef("Template!A9:F9"), employeeEachCommand);
// add department 'each' command to top-level area
xlsArea.addCommand(new AreaRef("Template!A2:F12"), departmentEachCommand);

SimpleExporter Introduction Mit der SimpleExporter-Klasse können Sie eine Liste von Objekten mit einer einzigen Codezeile nach Excel exportieren.

Dies wird durch die Verwendung einer speziellen integrierten Vorlage erreicht, die einen GridCommand enthält.

wie benutzt man

Erstellen Sie einfach eine SimpleExporter-Instanz und führen Sie die gridExport-Methode aus.


new SimpleExporter().gridExport(headers, dataObjects, propertyNames, outputStream);

--headers --Sammlung von Headern --dataObjects - Sammlung von Datenobjekten --propertyNames - Eine durch Kommas getrennte Liste von Objekteigenschaften. --outputStream --Ausgabestream zum Schreiben des endgültigen Excel.

Siehe das Beispiel in SimpleExporter.

Custom Template Verwenden Sie die registerGridTemplate-Methode, um die von SimpleExporter verwendete Vorlage zu registrieren.


public void registerGridTemplate(InputStream templateInputStream)

In der Vorlage muss [Grid Command] definiert sein (http://jxls.sourceforge.net/reference/grid_command.html).

Informationen hierzu finden Sie im Beispiel in SimpleExporter.

Hinweise zur Unterstützung von Transformatoren

GridCommand wird derzeit nur von POI-Transformatoren unterstützt. Daher sollten Sie POI verwenden, wenn Sie mit SimpleExporter arbeiten.

Excel mark-up

In Jxls gibt es drei Arten von Markup-Syntax, die für Excel verwendet werden können.

--Bean Property Markup --Area Definition Markup

Befehlsdefinitions-Markup

Jxls bietet die XlsCommentAreaBuilder-Klasse, mit der Sie Markups aus Excel-Zellkommentaren lesen können. XlsCommentAreaBuilder implementiert die allgemeine AreaBuilder-Schnittstelle.

public interface AreaBuilder {
    List<Area> build();
}

Dies ist eine einfache Schnittstelle mit einer einzelnen Methode, die eine Liste von Bereichsobjekten zurückgibt.

Wenn Sie Ihr eigenes Markup definieren möchten, können Sie daher eine eigene Implementierung von AreaBuilder erstellen und die eingegebene Excel-Vorlage (oder eine andere Eingabe) nach Ihren Wünschen interpretieren.

Bean-Eigenschafts-Markup

jxls verarbeitet die Apache JEXL-Ausdruckssprache.

In einer zukünftigen Version wird die Formelsprachen-Engine konfigurierbar sein, sodass JEXL bei Bedarf durch andere Formel-Engines ersetzt werden kann.

Die Syntax der JEXL-Ausdruckssprache wird hier beschrieben.

Jxls erwartet, dass der JEXL-Ausdruck im $ {} der XLS-Vorlagendatei platziert wird.

Der folgende Zelleninhalt "$ {department.chief.age} Jahre" weist JEXL beispielsweise an, department.chief.age auszuwerten, sofern sich ein Kontextobjekt im Kontext befindet. Wenn beispielsweise der Ausdruck "department.getChief (). GetAge ()" 35 ergibt, fügt Jxls während der Verarbeitung von XlsArea "35 Jahre" in die Zelle ein.

XLS-Bereichsdefinitions-Markup

Das Jxls-Bereichsmarkup wird verwendet, um die Root-XlsArea zu definieren, die von der Jxls-Engine verarbeitet wird. XlsCommentAreaBuilder unterstützt die folgende Syntax zum Definieren von Bereichen als Excel-Zellenbefehle.

jx:area(lastCell="<LAST_CELL>")

Wobei <last_cell> die untere rechte Zelle des rechteckigen Bereichs definiert. Die erste Zelle wird durch die Zelle definiert, in der der Excel-Kommentar platziert wird.

Angenommen, Zelle A1 hat den folgenden Kommentar jx: area (lastCell = "G12"), wird der Stammbereich als A1: G12 gelesen.

Sie müssen XlsCommentAreaBuilder verwenden, um den gesamten Speicherplatz aus der Vorlagendatei zu laden. Das folgende Codefragment lädt beispielsweise alle Bereiche in die xlsAreaList und speichert den ersten Bereich in der Variablen xlsArea.

    AreaBuilder areaBuilder = new XlsCommentAreaBuilder(transformer);
    List<Area> xlsAreaList = areaBuilder.build();
    Area xlsArea = xlsAreaList.get(0);

In den meisten Fällen reicht es aus, eine einzelne Root-XlsArea zu definieren.

Befehlsmarkup

Der Befehl muss in XlsArea definiert sein. XlsCommentAreaBuilder akzeptiert die folgende Befehlsnotation, die als Kommentar in einer Excel-Zelle erstellt wurde.

jx:<command_name>(attr1='val1' attr2='val2' ... attrN='valN' lastCell=<last_cell> areas=["<command_area1>", "<command_area2", ... "<command_areaN>"])

ist ein Befehlsname, der bei XlsCommentAreaBuilder vorregistriert oder manuell registriert wurde. Derzeit sind die folgenden Befehlsnamen vorregistriert.

each
if
image

Benutzerdefinierte Befehle können manuell mit der Methode "static void addCommandMapping (String commandName, Class clazz)" der XlsCommentAreaBuilder-Klasse registriert werden.

attr1, attr2, ..., attrN sind befehlsspezifische Attribute.

Beispielsweise verfügt If-Command über ein bedingtes Attribut zum Festlegen eines bedingten Ausdrucks.

<last_cell> definiert die untere rechte Zelle des Befehlskörperbereichs. Die obere linke Zelle wird von der Zelle mit der Befehlsnotation bestimmt.

<Befehlsbereich1>, <Befehlsbereich2>, ... <BefehlsbereichN> --XLS-Bereich, der als Parameter an den Befehl übergeben werden soll.

If-Command erwartet beispielsweise, die folgenden Bereiche zu definieren:

ifArea ist eine Referenz auf den Bereich, der ausgegeben werden soll, wenn die Bedingung If-command als wahr ausgewertet wird. elseArea ist eine optionale Referenz auf den Bereich, der ausgegeben werden soll, wenn die Bedingung If-command als false ausgewertet wird. Das heißt, um einen Bereich für den If-Befehl zu definieren, lauten seine Bereichsattribute:

areas=["A8:F8","A13:F13"]

Sie können mehrere Befehle mit einem Zellenkommentar definieren. Beispielsweise lauten die Definitionen der Befehle "each" und "what if" wie folgt:

jx:each(items="department.staff", var="employee", lastCell="F8")
jx:if(condition="employee.payment <= 2000", lastCell="F8", areas=["A8:F8","A13:F13"])

Expression Language

Überblick

Standardmäßig verwendet Jxls die Apache JEXL-Ausdruckssprache, um in Excel-Vorlagendateien angegebene Eigenschaftsausdrücke auszuwerten.

In der JEXL-Syntaxreferenz finden Sie Informationen dazu, welche Ausdrücke verwendet werden können.

Passen Sie die Verarbeitung von Jexl an

Wenn Sie den Jexl-Prozess anpassen müssen, können Sie eine Referenz von Transformer zu JexlEngine abrufen und die erforderlichen Einstellungen anwenden.

Der folgende Code registriert beispielsweise eine benutzerdefinierte Jexl-Funktion im Demo-Namespace.

     Transformer transformer = TransformerFactory.createTransformer(is, os);
     ...
     JexlExpressionEvaluator evaluator = (JexlExpressionEvaluator) transformer.getTransformationConfig().getExpressionEvaluator();
     Map<String, Object> functionMap = new HashMap<>();
     functionMap.put("demo", new JexlCustomFunctionDemo());
     evaluator.getJexlEngine().setFunctions(functionMap);

Angenommen, es gibt eine solche Methode in JexlCustomFunctionDemo.

public Integer mySum(Integer x, Integer y){
    return x + y;
}

Anschließend können die folgenden Funktionen für die Vorlage verwendet werden.

 ${demo:mySum(x,y)}

Übrigens sind x und y hier die vom Kontext übergebenen Parameter.

Eine Beispielimplementierung finden Sie unter JexlCustomFunctionDemo.java.

Die Expression-Engine ändert sich

Möglicherweise möchten Sie anstelle von Apache JEXL eine andere Ausdrucksverarbeitungs-Engine verwenden (z. B. Spring Expression Language (SpEL). Verwenden Sie die Referenz / html / expression.html) usw.).

Mit Jxls können Sie die Standard-Rating-Engine durch eine beliebige ersetzen.

Implementieren Sie dazu einfach eine Methode der ExpressionEvaluator-Schnittstelle und delegieren Sie den Ausdrucksbewertungsprozess an Ihre bevorzugte Engine.

public interface ExpressionEvaluator {
    Object evaluate(String expression, Map<String,Object> context);
}

Anschließend müssen Sie die ExpressionEvaluator-Implementierung an TransformationConfig übergeben, wie im folgenden Code gezeigt.

 ExpressionEvaluator evaluator = new MyCustomEvaluator(); // your own implementation based for example on SpEL
  transformer.getTransformationConfig().setExpressionEvaluator(evaluator);

Each-Command

Einführung

Jeder Befehl wird verwendet, um die Sammlung zu durchlaufen und den XLS-Bereich des Befehls zu klonen. Dies ist ein Java-Analogon des Operators.

Befehlsattribute

Jeder Befehl hat die folgenden Attribute:

--var ist der Name der Variablen im Jxls-Kontext, mit der jedes neue Sammlungselement in den iterativen Prozess einbezogen wird. --items ist der Name der Kontextvariablen, die die iterative Auflistung (Iterable <?>) oder das Array enthält. --area ist ein Verweis auf den XLS-Bereich, der als Hauptteil jedes Befehls verwendet wird. --direction ist der Wert der Direction-Aufzählung, die den Wert DOWN oder RIGHT haben kann, und gibt an, wie der Befehlstext (Zeile oder Spalte) wiederholt werden soll. Der Standardwert ist DOWN. --select ist eine Ausdrucksauswahl zum Filtern von Sammlungselementen während der Iteration. --groupBy ist eine Eigenschaft zum Gruppieren. --groupOrder gibt die Reihenfolge der Gruppen an ('desc' oder'asc '). --orderBy enthält durch Kommas getrennte Namen und ein optionales Präfix "ASC" (Standard) oder "DESC" für die Sortierreihenfolge. --cellRefGenerator ist eine benutzerdefinierte Strategie zum Erstellen von Zielzellenreferenzen. --multisheet ist der Name der Kontextvariablen, die die Liste der Blattnamen zur Ausgabe der Sammlung enthält. --lastCell ist ein allgemeines Attribut von Befehlen, das auf die letzte Zelle im Befehlsbereich verweist.

Das var-Attribut und das item-Attribut sind erforderlich, andere Attribute können jedoch weggelassen werden.

Weitere Informationen zur Verwendung von cellRefGenerator- und Multi-Sheet-Attributen finden Sie im Abschnitt Mehrere Blätter.

Befehlskonstruktion

Wie bei jedem Jxls-Befehl können Sie jeden Befehl mithilfe der Java-API-, Excel-Markup- und XML-Einstellungen definieren.

Verwendung der Java-API

Unten finden Sie ein Beispiel für die Erstellung jedes Befehls im Paket org.jxls.examples.

// creating a transformer and departments collection
    ...
// creating department XlsArea
    XlsArea departmentArea = new XlsArea("Template!A2:G13", transformer);
// creating Each Command to iterate departments collection and attach to it "departmentArea"
    EachCommand departmentEachCommand = new EachCommand("department", "departments", departmentArea);

Verwendung von Excel-Markups

Um jeden Befehl im Excel-Markup zu erstellen, müssen Sie eine spezielle Syntax zum Kommentieren der Startzelle im Befehlshauptteilbereich verwenden.

jx:each(items="employees" var="employee" lastCell="D4")

Das Attribut lastCell definiert die letzte Zelle im Hauptteil des Befehls XlsArea.

XML markup usage Verwenden Sie die folgenden Markups, um jeden Befehl in den XML-Einstellungen zu erstellen.

<each items="employees" var="employee" ref="Template!A4:D4">
    <area ref="Template!A4:D4"/>
</each>

Hier definiert das ref-Attribut den Bereich, der jedem Befehl zugeordnet ist. Und der innere Bereich definiert den Hauptteil jedes Befehls. Normalerweise das gleiche.

Schleifenrichtung

Standardmäßig ist das Orientierungsattribut für jeden Befehl auf DOWN festgelegt. Dies bedeutet, dass der Befehlstext in der Excel-Zeile dupliziert wird.

Wenn Sie den Bereich für jede Spalte duplizieren müssen, müssen Sie das Orientierungsattribut auf den Wert RECHTS setzen.

In der Java-API:

//... creating EachCommand to iterate departments
// setting its direction to RIGHT
departmentEachCommand.setDirection(EachCommand.Direction.RIGHT);

Daten gruppieren

Jeder Befehl unterstützt die Gruppierung mithilfe der groupBy-Eigenschaft. Die Eigenschaft groupOrder legt die Reihenfolge fest und kann absteigend oder aufsteigend sein. Wenn Sie groupBy schreiben, ohne groupOrder anzugeben, erfolgt keine Sortierung.

Das Excel-Markup sieht folgendermaßen aus:

jx:each(items="employees" var="myGroup" groupBy="name" groupOrder="asc" lastCell="D6")

In diesem Beispiel kann auf jede Gruppe mit der Variablen myGroup verwiesen werden, auf die über den Kontext zugegriffen werden kann.

Auf das aktuelle Gruppenelement kann mit myGroup.item verwiesen werden. Das heißt, um den Namen des Mitarbeiters zu sehen

Für $ {myGroup.item.name} Auf alle Elemente in der Gruppe kann über die Elementeigenschaften der Gruppe zugegriffen werden.

jx:each(items="myGroup.items" var="employee" lastCell="D6") Sie können das var-Attribut auch ganz überspringen. In diesem Fall lautet der Standardname der Gruppenvariablen _group.

Weitere Beispiele finden Sie unter hier.

Sprachübersicht

Standardmäßig verwendet Jxls die Apache JEXL-Ausdruckssprache, um in Excel-Vorlagendateien angegebene Eigenschaftsausdrücke auszuwerten.

In der JEXL-Syntaxreferenz finden Sie Informationen dazu, welche Ausdrücke verwendet werden können.

Passen Sie die Verarbeitung von Jexl an

Wenn Sie den Jexl-Prozess anpassen müssen, können Sie eine Referenz von Transformer zu JexlEngine abrufen und die erforderlichen Einstellungen anwenden.

Der folgende Code registriert beispielsweise eine benutzerdefinierte Jexl-Funktion im Demo-Namespace.

     Transformer transformer = TransformerFactory.createTransformer(is, os).
     ...
     JexlExpressionEvaluator evaluator = (JexlExpressionEvaluator) transformer.getTransformationConfig().getExpressionEvaluator().
     Map<String, Object> functionMap = new HashMap<>().
     functionMap.put("demo", new JexlCustomFunctionDemo()).
     evaluator.getJexlEngine().setFunctions(functionMap)。

Nun zur JexlCustomFunctionDemo-Klasse

public Integer mySum(Integer x, Integer y){
    return x + y;
}

Daher können Sie die folgenden Funktionen in der Vorlage verwenden.

${demo:mySum(x,y)} Wobei x und y auf die Parameter aus dem Kontext zeigen.

Ein vollständiges Implementierungsbeispiel finden Sie unter JexlCustomFunctionDemo.java.

Die Expression-Engine ändert sich

Möglicherweise möchten Sie anstelle von Apache JEXL eine andere Ausdrucksverarbeitungs-Engine verwenden (z. B. Spring Expression Language (SpEL)).

Mit Jxls können Sie die Standard-Rating-Engine durch eine beliebige ersetzen.

Implementieren Sie dazu einfach eine Methode der ExpressionEvaluator-Schnittstelle und delegieren Sie den Ausdrucksbewertungsprozess an Ihre bevorzugte Engine.

public interface ExpressionEvaluator {
    Object evaluate(String expression, Map<String,Object> context);
}

Anschließend müssen Sie die ExpressionEvaluator-Implementierung an TransformationConfig übergeben, wie im folgenden Code gezeigt.

  ExpressionEvaluator evaluator = new MyCustomEvaluator(); // your own implementation based for example on SpEL
  transformer.getTransformationConfig().setExpressionEvaluator(evaluator);

Each-Command Jeder Befehl wird verwendet, um die Sammlung zu durchlaufen und den XLS-Bereich des Befehls zu klonen. Dies ist ein Java-Analogon des Operators.

Befehlsattribut

Jeder Befehl hat das folgende Attribut:

Die var- und item-Attribute sind erforderlich, andere Attribute können jedoch weggelassen werden.

Weitere Informationen zur Verwendung von cellRefGenerator- und Multi-Sheet-Attributen finden Sie im Abschnitt Mehrere Blätter.

Befehlskonstruktion

Wie bei jedem Jxls-Befehl können Sie jeden Befehl mithilfe der Java-API-, Excel-Markup- und XML-Einstellungen definieren. Unten finden Sie ein Beispiel für die Erstellung jedes Befehls im Paket org.jxls.examples.

// creating a transformer and departments collection
    ...
// creating department XlsArea
    XlsArea departmentArea = new XlsArea("Template!A2:G13", transformer);
// creating Each Command to iterate departments collection and attach to it "departmentArea"
    EachCommand departmentEachCommand = new EachCommand("department", "departments", departmentArea);

Verwendung von Excel Markup

Um jeden Befehl im Excel-Markup zu erstellen, müssen Sie eine spezielle Syntax zum Kommentieren der Startzelle im Befehlshauptteilbereich verwenden.

<each items="employees" var="employee" ref="Template!A4:D4">
    <area ref="Template!A4:D4"/>
</each>

Verwendung von XML-Markups

Verwenden Sie die folgenden Markups, um jeden Befehl in den XML-Einstellungen zu erstellen.

<each items = "employee" var = "employee" ref = "Vorlage! <area ref = "Vorlage! Hier definiert das ref-Attribut den Bereich, der jedem Befehl zugeordnet ist. Und der innere Bereich definiert den Hauptteil jedes Befehls. Normalerweise das gleiche.

Orientierte Wiederholung

Standardmäßig ist das Orientierungsattribut für jeden Befehl auf DOWN festgelegt. Dies bedeutet, dass der Befehlstext in Excel über einer Zeile dupliziert wird. Wenn Sie den Bereich für jede Spalte duplizieren müssen, müssen Sie das Orientierungsattribut auf den Wert RECHTS setzen. In der Java-API:

//... creating EachCommand to iterate departments
// setting its direction to RIGHT
departmentEachCommand.setDirection(EachCommand.Direction.RIGHT);

Daten gruppieren

Das Excel-Markup sieht folgendermaßen aus:

jx:each(items="employees" var="myGroup" groupBy="name" groupOrder="asc" lastCell="D6")

In diesem Beispiel kann auf jede Gruppe mit der Variablen myGroup verwiesen werden, auf die im Kontext zugegriffen werden kann.

Auf das aktuelle Gruppenelement kann mit myGroup.item verwiesen werden. Den Namen des Mitarbeiters anzeigen

Für $ {myGroup.item.name} Auf alle Elemente in der Gruppe kann über die Elementeigenschaften der Gruppe zugegriffen werden.

jx:each(items="myGroup.items" var="employee" lastCell="D6")

Sie können das var-Attribut auch ganz überspringen. In diesem Fall lautet der Standardname der Gruppenvariablen _group.

Ein Beispiel finden Sie unter Gruppierungsbeispiel (http://jxls.sourceforge.net/samples/grouping_example.html).

Dies ist die Excel-Ausgabe in Java! Offizielle Dokumentübersetzung "JXLS"

Einführung

Charakteristisch

Erste Schritte

Fügen Sie Ihrem Projekt die erforderlichen Bibliotheken für JXLS hinzu

Erstellen Sie eine Excel-Vorlage

Verwenden Sie die Jxls-API, um Vorlagen zu verarbeiten

Referenz

Konzeptübersicht

Xls Bereich

Erstellen Sie einen XLS-Bereich

Excel-Markup zum Erstellen von XLS-Bereichen

XML-Einstellungen zum Erstellen des XLS-Bereichs

Erstellen Sie einen XLS-Bereich mit der Java-API

wie benutzt man

Hinweise zur Unterstützung von Transformatoren

Bean-Eigenschafts-Markup

XLS-Bereichsdefinitions-Markup

Befehlsmarkup

Überblick

Passen Sie die Verarbeitung von Jexl an

Die Expression-Engine ändert sich

Einführung

Befehlsattribute

Befehlskonstruktion

Verwendung der Java-API

Verwendung von Excel-Markups

Schleifenrichtung

Daten gruppieren

Sprachübersicht

Passen Sie die Verarbeitung von Jexl an

Die Expression-Engine ändert sich

Befehlsattribut

Befehlskonstruktion

Verwendung von Excel Markup

Verwendung von XML-Markups

Orientierte Wiederholung

Daten gruppieren