Ceci est la sortie Excel en Java! Traduction de documents officiels "JXLS"

Il est difficile d'utiliser Apache POI tel quel, alors quand je cherchais un bon, Jxls était bon. Ce qui est bien, c'est que vous pouvez facilement générer des données avec une structure arborescente. Cependant, quand je l'ai cherché, il semblait qu'il y avait peu de documents japonais, alors je l'ai traduit. Je vous serais reconnaissant de bien vouloir souligner des points étranges.

Cet article est un article traduit de ici. Nous traduisons la version 2020/3/30 du document.

introduction

JXLS est une petite bibliothèque Java permettant de générer facilement des formulaires Excel. Le format du formulaire généré par JXLS et la mise en page des données sont définis en écrivant une syntaxe unique dans le modèle Excel. La génération Excel est devenue indispensable pour les applications Java telles que la fonction dite de formulaire.

Java a une très bonne bibliothèque pour la sortie de fichiers Excel, à la fois open source et commerciale. Parmi les sources ouvertes, il convient de mentionner Apache POI et Java Excel API.

Cependant, ces bibliothèques sont de très bas niveau (primitives), et même si vous souhaitez générer Excel avec une structure simple, vous devez écrire beaucoup de code source.

Normalement, avec ces bibliothèques, vous devez formater et données manuellement chaque cellule. Et à mesure que la mise en page des formulaires et le formatage des données deviennent plus complexes, le code source en fait de même, ce qui rend plus difficile le débogage et la maintenance. En plus de cela, toutes les fonctionnalités d'Excel ne sont pas prises en charge, de sorte que toutes ne peuvent pas être gérées via l'API. (Par exemple, les macros et les graphiques ne peuvent pas être utilisés.) Pour ces fonctions non prises en charge, vous pouvez incorporer un objet dans un modèle Excel par vous-même, puis écrire des données à l'aide de l'API.

Jxls, en revanche, permet la génération de formulaires Excel à un niveau supérieur. Tout ce que vous avez à faire pour générer un formulaire Excel avec JXLS est d'incorporer le format du formulaire et le formatage des données dans un modèle, puis d'introduire les données dans le modèle avec le moteur JXLS. Dans la plupart des cas de génération de formulaires Excel, aucun code source n'est requis autre que la déclaration du moteur JXLS et l'écriture des paramètres appropriés.

Fonctionnalité

• Sortie de formulaire Excel au format XML et binaire (en fonction de l'API de conversion JAVA-Excel de bas niveau) --Convertir la classe de collection Java en ligne ou en colonne et en sortie
• Sortie de résultat conditionnelle
• Langage de marquage pour définir les formulaires
• Sortie de feuilles multiples
• Intégration de formules Excel
• Formule paramétrée
• Prend en charge le regroupement (* Sortie de données pour chaque groupe. Séparé du regroupement des fonctions Excel)
• Prend en charge la fusion de cellules
• Écouteur de zone prenant en charge la génération Excel
• Syntaxe de marquage pour écrire dans des commentaires Excel pour la définition de commande
• Syntaxe XML pour la définition de commande --Définition de commande personnalisée
• Prend en charge le streaming, ce qui réduit la consommation de mémoire et permet un traitement de sortie plus rapide --Il est possible de spécifier que seule la feuille sélectionnée est gérée par Streaming.
• Prend en charge la connexion de table

Guide de Démarrage

Tout d'abord, considérons le cas où vous souhaitez exporter l'objet Employé dans un formulaire Excel. La classe Employee ressemble à ceci.

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

Pour exporter cet objet vers Excel à l'aide de JXLS, il est nécessaire d'effectuer la série d'étapes suivante.

1. Ajoutez les bibliothèques requises pour JXLS à votre projet
2. Créez un modèle Excel en utilisant une syntaxe dédiée
3. Effectuez le processus d'intégration des données des employés dans le modèle préparé à l'aide de l'API JXLS.

Examinons de plus près chacune de ces étapes dans le chapitre suivant.

Ajoutez les bibliothèques requises pour JXLS à votre projet

Le moyen le plus simple consiste à utiliser Maven pour spécifier les bibliothèques requises dans le fichier de configuration. Le jar Jxls est disponible dans le référentiel central de Maven. Le module principal de Jxls dépend des bibliothèques suivantes.

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

Une autre option consiste à le télécharger depuis le site Sourceforge et à utiliser le fichier jar.

En plus des modules de base Jxls, nous devons ajouter une dépendance au moteur de transformation Jxls, qui est la base de toutes les fonctionnalités qui effectuent des opérations de conversion Java vers Excel.

Comme expliqué dans le chapitre Transformer (voir le concept principal), les modules de base de Jxls ne dépendent d'aucune autre bibliothèque Java --exel spécifique. Cependant, de nos jours, Jxls fournit des interfaces indépendantes pour chacune des bibliothèques Apache POI et Java Excel API. ..

Pour utiliser le convertisseur Apache POI, ajoutez la dépendance suivante à pom.xml.

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

Pour utiliser un convertisseur basé sur l'API Java Excel, ajoutez les dépendances suivantes.

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

Créer un modèle Excel

Un modèle est un fichier Excel qui utilise une syntaxe propriétaire pour spécifier le mode de sortie des données.

Jxls dispose d'un mécanisme de traitement de balisage intégré qui peut être interprété à partir d'un modèle Excel pour extraire les commandes de contrôle.

Des mécanismes de traitement de balisage personnalisés peuvent être créés selon les besoins. Vous pouvez définir votre propre syntaxe et l'intégrer dans un modèle Excel pour créer une structure de commande Jxls.

Ce qui suit décrit le mécanisme de traitement de la syntaxe intégré.

Par défaut, Jxls prend en charge Apache JEXL. Apache JEXL est le langage utilisé dans les modèles Excel et est utilisé pour référencer les méthodes et les propriétés des objets Java. Sous une clé, l'objet est disponible dans le contexte Jxls. Pour imprimer le nom de l'employé dans une cellule, écrivez simplement «$ {employee.name}» dans la cellule. Fondamentalement, Jxls est également plein d'expressions de type Jexl $ { et }. En regardant la syntaxe, nous pouvons déduire que l'objet Employee se trouve derrière la clé ʻemployee`.

La méthode de notation des propriétés peut être définie. Par exemple, vous pouvez le définir en utilisant «[[employee.name]]» comme notation de propriété. Pour plus d'informations, consultez Langage d'expression (http://jxls.sourceforge.net/reference/expression_language.html).

Le Sample Template pour la sortie de l'objet Employee ressemblera finalement à ceci:

La quatrième ligne de ce modèle utilise la syntaxe JEXL décrite précédemment pour faire référence aux propriétés de l'objet employé.

La cellule A1 contient un commentaire Excel tel que "jx: area (lastCell =" D4 ")". Ce commentaire définit que la zone de modèle de niveau supérieur de Jxls est dans la plage A1: D4.

Dans le commentaire de la cellule A4, Jxls Eaxh-Command est défini comme "jx: each (items = "Employees" var = "employee" lastCell = "D4")". Cette Each-Command récupère chaque ensemble d'objets en utilisant ʻemployees comme clé et place les données individuelles dans la clé ʻemployee (définie par l'attribut var). La portée de chaque commande est A4: D4, et elle sera dupliquée chaque fois qu'un nouvel objet Employé apparaîtra dans le contexte.

Cet exemple utilise la classe XlsCommentAreaBuilder pour créer la zone Jxls. Cette classe peut être définie en écrivant la commande Jxls dans un commentaire de cellule Excel. S'il est préférable de le définir dans le code source Java, vous pouvez utiliser la cellule sans commentaires comme modèle.

Utilisez l'API Jxls pour traiter les modèles

Voici un exemple d'utilisation de l'API Jxls pour traiter des modèles Excel.

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

Dans cet exemple, le modèle (object_collection_template.xls) est spécifié et lu à partir du chemin de classe. Et le fichier Excel généré est écrit dans target / object_collection_output.xls.

Le processus principal est représenté par la ligne suivante.

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

Par défaut, JxlsHelper s'attend à écraser les données sur la feuille de modèle.

Cependant, vous pouvez également écrire de nouvelles données dans une autre feuille avec la méthode suivante.

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

Dans cet exemple, la zone est écrite dans la cellule «A1» de la feuille «Résultat».

Le formulaire final généré dans cet exemple peut être téléchargé depuis ici. Cela ressemble à ceci:

référence

Aperçu du concept

Jxls est basé sur le concept suivant.

• XlsArea
• Command
• Transformer

Examinons de plus près chaque fonctionnalité.

Zone XLS

La zone Xls fait référence à la zone rectangulaire dessinée dans le fichier Excel. Plus précisément, elle est spécifiée en spécifiant la plage de cellules et la cellule de départ et sa taille (nombre de lignes et de colonnes). Peut être fait. Autrement dit, la zone Xls contient toutes les cellules de la plage spécifiée.

Chaque zone XlsA peut avoir un ensemble de commandes que le moteur Jxls exécutera pendant qu'il traite la zone. Et vous pouvez avoir des zones enfants imbriquées dans la zone Xls. Et chaque zone enfant, comme son parent, peut avoir des commandes et des zones petits-enfants.

La zone Xls peut être définie de trois manières: --Comment écrire dans le modèle Excel avec une syntaxe dédiée: Jxls fournit la syntaxe correspondant à XlsCommandAreaBuilder par défaut. Vous pouvez également fournir une syntaxe personnalisée si vous le souhaitez.

• Comment utiliser le fichier de définition XML: Jxls fournit la classe XmlAreaBuilder pour l'interprétation de la syntaxe XML.
• Comment utiliser l'API Java Jxls

Voici un exemple de la définition de la zone Xls.

Command

Une commande fait référence à une action de conversion pour une ou plusieurs zones Xls. L'interface Java correspondante est la suivante.

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

La méthode principale de la commande est Size applyAt (CellRef cellRef, Context context). Cette méthode transmet l'action de commande à la cellule passée dans la variable cellRef, et les données passées dans la variable context. Les contextes peuvent être traités comme des cartes et sont utilisés pour transmettre des données aux commandes.

Jxls fournit les commandes intégrées suivantes. --Each-Command: Commande exécutée lors de l'itération sur les données de format de liste --Si-Command: Une commande qui exécute le traitement dans des conditions spécifiques --Image-Command: commande pour rendre l'image --MergeCells-Command --Fusion de cellules

Vous pouvez également définir facilement vos propres commandes personnalisées. Le processus de transmission des données à la commande est réalisé par l'objet Context. Le contexte fonctionne comme une carte. À partir du modèle XLS, il est référencé en fonction des informations clés et la valeur associée est définie en tant que données.

Tramsformer L'interface Transformer permet à la zone Xls de fonctionner avec Excel indépendamment de tout cadre particulier. Autrement dit, vous pouvez utiliser une interface de conversion avec un autre framework Java vers Excel. L'interface est utilisée sous la forme suivante.

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

À première vue, il semble que beaucoup de méthodes sont apparues, mais la plupart sont déjà implémentées dans la classe abstraite sous-jacente ʻAbstractTransformer`. Puis, si nécessaire, héritez-en et implémentez un nouveau java-to-excel.

Actuellement, Jxls fournit les deux transformateurs suivants.

• PoiTransformer
• JexcelTransformer

PoiTransformer traite de la célèbre bibliothèque de sortie de fichier Excel Apache POI. Notez que JexcelTransformer est basé sur l'ancienne bibliothèque API Java Excel.

POI Transformer PoiTransformer est une implémentation de l'interface Transformer basée sur Apache POI.

Il s'agit d'un transformateur Excel intégré du module jxls-poi.

Il prend en charge à la fois les classeurs POI-HSSF et POI-XSSF / SXSSF et dispose de plusieurs constructeurs qui vous permettent de créer des instances de transformation en streaming ou non à partir de classeurs POI ou de flux d'entrée de modèle.

En outre, vous pouvez ignorer la hauteur de ligne et la largeur de colonne de la cellule source lors de la conversion de cellule. Ceci est réalisé avec les méthodes setIgnoreRowProps (boolean) et setIgnoreColumnProps (boolean).

XLS Area Introduction La zone XLS est le concept principal de Jxls Plus. Il représente essentiellement une zone rectangulaire dans un fichier Excel qui doit être converti. Chaque région XLS peut être associée à une liste de commandes de conversion et à un ensemble de régions enfants imbriquées. Chaque région enfant est également une région XLS avec sa propre commande et un ensemble de régions imbriquées. Une région XLS de niveau supérieur est une région qui n'a pas de région parente (elle n'est imbriquée dans aucune autre région XLS).

Créer une zone XLS

Il existe trois façons de définir une zone XLS:

--Markup vers Excel --Défini par XML --Utiliser l'API Java

Expliquons chaque méthode en détail.

Balisage Excel pour la création de zones XLS

Vous pouvez utiliser des annotations spéciales dans le modèle Excel pour créer la zone XLS. Le balisage doit être placé dans le commentaire Excel dans la première cellule de la zone. Le balisage ressemble à ceci:

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

Où «<AREA_LAST_CELL>» est la dernière cellule de la zone définie.

Ce balisage définit une zone de niveau supérieur qui commence par la cellule avec le commentaire de balisage et se termine par «<AREA_LAST_CELL>».

Pour voir un exemple, jetons un œil à l'exemple de modèle Output Object Collection.

Dans le commentaire de la cellule A1, la zone est définie comme:

jx:area(lastCell="D4")

Nous avons donc ici une zone qui couvre la plage de cellules A1: D4.

Pour analyser le balisage et créer un objet XlsArea, vous devez utiliser la classe XlsCommentAreaBuilder comme suit:

// 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);

Les deux lignes de code suivantes effectuent le travail principal de création d'un JxlsArea.

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

Tout d'abord, instanciez XlsCommentAreaBuilder pour créer une instance de AreaBuilder. Appelez ensuite la méthode ʻareaBuilder.build () `pour créer une liste d'objets Area à partir du modèle.

Une fois que vous avez une liste de zones de niveau supérieur, vous pouvez les utiliser pour les conversions Excel.

Paramètres XML pour la construction de la zone XLS

Si vous souhaitez définir une région XLS avec un balisage XML, voici quelques moyens de le faire:

Tout d'abord, vous devez créer un paramètre XML qui définit la région.

À titre d'exemple, considérons une configuration XML simple à partir de la sortie d'une collection d'objets à l'aide de XML Builder.

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

L'élément racine est xls. Ensuite, répertoriez certains des éléments de zone qui définissent chaque zone de niveau supérieur.

Ici, la feuille de modèle a une zone de niveau supérieur appelée A1: D4.

<area ref="Template!A1:D4"> Dans cette zone, vous utilisez des éléments spéciaux pour une commande particulière afin de définir la commande associée. Dans ce cas, chaque commande est définie dans chaque élément xml. La zone associée à chaque commande est indiquée par l'attribut ref.

<each items =" Employees "var =" Employees "ref =" template! A4: D4 ">. Dans chaque commande se trouvent des paramètres de région imbriqués.

<area ref="template!

Créer une zone XLS avec l'API Java

Pour créer une zone XLS à l'aide de l'API Java, vous pouvez utiliser l'un des constructeurs de la classe XlsArea. Les constructeurs suivants sont disponibles.

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

Pour construire un royaume de niveau supérieur, vous devez fournir une instance Transformer afin que le royaume puisse être transformé.

Vous devez ensuite définir les cellules de la zone en utilisant la plage de cellules comme chaîne ou en créant un objet de référence de cellule CellRef et en définissant la zone Size.

Vous trouverez ci-dessous une partie du code qui crée un ensemble imbriqué de régions de modèle XLS avec une commande.

// 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 Vous pouvez utiliser la classe SimpleExporter pour exporter une liste d'objets vers Excel avec une seule ligne de code.

Ceci est réalisé en utilisant un modèle intégré spécial qui inclut un GridCommand.

comment utiliser

Créez simplement une instance SimpleExporter et exécutez sa méthode gridExport.

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

--headers --Collection d'en-têtes --dataObjects --Collection d'objets de données --propertyNames --Une liste de propriétés d'objets séparées par des virgules --outputStream: flux de sortie pour l'écriture de l'Excel final.

Voir l'exemple dans SimpleExporter.

Custom Template Pour enregistrer le modèle utilisé par SimpleExporter, utilisez sa méthode registerGridTemplate.

public void registerGridTemplate(InputStream templateInputStream)

Le modèle doit avoir une commande de grille (http://jxls.sourceforge.net/reference/grid_command.html) définie.

Voir l'exemple dans SimpleExporter pour savoir comment procéder.

Notes de support du transformateur

GridCommand n'est actuellement pris en charge que par les transformateurs POI, vous devez donc utiliser POI lorsque vous travaillez avec SimpleExporter.

Excel mark-up

Dans Jxls, trois types de syntaxe de balisage peuvent être utilisés pour Excel.

--Balisage de la propriété Bean --Balisage de définition de zone --Balisage de définition de commande

Jxls fournit la classe XlsCommentAreaBuilder qui vous permet de lire les balises à partir des commentaires de cellule Excel. XlsCommentAreaBuilder implémente l'interface générale AreaBuilder.

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

Il s'agit d'une interface simple avec une seule méthode qui renvoie une liste d'objets de zone.

Par conséquent, si vous souhaitez définir votre propre balisage, vous pouvez créer votre propre implémentation d'AreaBuilder pour interpréter le modèle Excel saisi (ou toute autre entrée) comme vous le souhaitez.

Balisage de propriété Bean

jxls utilisant le langage d'expression Apache JEXL.

Dans une prochaine version, le moteur de langage de formule sera configurable afin que JEXL puisse être remplacé par d'autres moteurs de formule si nécessaire.

La syntaxe du langage d'expression JEXL est décrite ici.

Jxls s'attend à placer l'expression JEXL dans le $ {} du fichier modèle XLS.

Par exemple, le contenu de la cellule suivante $ {department.chief.age} years indique à JEXL d'évaluer department.chief.age, en supposant qu'il existe un objet department dans le contexte. Par exemple, si l'expression department.getChief (). GetAge () vaut 35, Jxls place 35 years dans la cellule lors du traitement de XlsArea.

Balisage de définition de zone XLS

Le balisage de zone Jxls est utilisé pour définir la racine XlsArea traitée par le moteur Jxls. XlsCommentAreaBuilder prend en charge la syntaxe suivante pour définir des zones en tant que commandes de cellule Excel.

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

Où <last_cell> définit la cellule inférieure droite de la zone rectangulaire. La première cellule est définie par la cellule dans laquelle le commentaire Excel est placé.

Autrement dit, en supposant que la cellule A1 a le commentaire suivant jx: area (lastCell = "G12"), la zone racine est lue comme A1: G12.

Vous devez utiliser XlsCommentAreaBuilder pour charger tout l'espace du fichier modèle. Par exemple, l'extrait de code suivant charge toutes les zones dans la xlsAreaList et enregistre la première zone dans la variable xlsArea.

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

Dans la plupart des cas, il suffit de définir une seule racine XlsArea.

Balisage de commande

La commande doit être définie dans XlsArea. XlsCommentAreaBuilder accepte la notation de commande suivante créée en tant que commentaire dans une cellule Excel.

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

<command_name> est un nom de commande pré-enregistré ou enregistré manuellement avec XlsCommentAreaBuilder. Actuellement, les noms de commande suivants sont pré-enregistrés.

• each
• if
• image

Les commandes personnalisées peuvent être enregistrées manuellement à l'aide de la méthode static void addCommandMapping (String commandName, Class clazz) de la classe XlsCommentAreaBuilder.

ʻAttr1, attr2, ..., attrN` sont des attributs spécifiques à la commande.

Par exemple, If-Command a un attribut conditionnel pour définir une expression conditionnelle.

<last_cell> définit la cellule inférieure droite de la zone du corps de commande. La cellule supérieure gauche est déterminée par la cellule avec la notation de commande.

<command_area1>, <command_area2>, ... <command_areaN> - Zone XLS à passer en paramètre à la commande.

Par exemple, If-Command s'attend à définir les zones suivantes:

ʻIfArea est une référence à la zone à afficher lorsque la condition ʻIf-command est évaluée à vrai. ʻElseArea est une référence facultative à la zone à afficher lorsque la condition ʻIf-command est évaluée à false. Autrement dit, pour définir une zone pour la commande If, ses attributs de zone sont:

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

Vous pouvez définir plusieurs commandes avec un seul commentaire de cellule. Par exemple, les définitions des commandes «each» et «what if» sont les suivantes:

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

Expression Language

Aperçu

Par défaut, Jxls utilise le langage d'expression Apache JEXL pour évaluer les expressions de propriété spécifiées dans les fichiers de modèle Excel.

Voir la référence de syntaxe JEXL pour les expressions qui peuvent être utilisées.

Personnalisez le traitement de Jexl

Si vous avez besoin de personnaliser le processus Jexl, vous pouvez obtenir une référence de Transformer vers JexlEngine et appliquer les paramètres requis.

Par exemple, le code suivant enregistre une fonction Jexl personnalisée dans l'espace de noms de démonstration.

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

Supposons qu'il existe une méthode dans JexlCustomFunctionDemo comme celle-ci.

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

Ensuite, les fonctions suivantes peuvent être utilisées sur le modèle.

 ${demo:mySum(x,y)}

Au fait, x et y sont les paramètres passés de Context.

Voir JexlCustomFunctionDemo.java pour un exemple d'implémentation.

Modifications du moteur d'expression

Vous souhaiterez peut-être utiliser un autre moteur de traitement d'expression au lieu d'Apache JEXL (par exemple, Spring Expression Language (SpEL). Utilisez reference / html / expressions.html), etc.).

Jxls vous permet de remplacer votre moteur d'évaluation préféré par le vôtre.

Pour ce faire, implémentez simplement une méthode de l'interface ExpressionEvaluator et déléguez le processus d'évaluation d'expression à votre moteur préféré.

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

Ensuite, vous devez transmettre l'implémentation ExpressionEvaluator à TransformationConfig, comme indiqué dans le code ci-dessous.

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

Each-Command

introduction

Chaque commande est utilisée pour parcourir la collection et cloner la zone XLS de la commande. Il s'agit d'un analogue Java de l'opérateur.

Attributs de commande

Chaque commande possède les attributs suivants:

--var est le nom de la variable dans le contexte Jxls pour placer chaque nouvel élément de collection dans le processus itératif. --items est le nom de la variable de contexte qui contient la collection itérative (Iterable <?>) Ou tableau. --area est une référence à la zone XLS utilisée comme corps de chaque commande. --direction est la valeur de l'énumération Direction, qui peut avoir la valeur DOWN ou RIGHT, et indique comment répéter le corps de la commande (ligne ou colonne). La valeur par défaut est DOWN. --select est un sélecteur d'expression pour filtrer les éléments de collection pendant l'itération. --groupBy est une propriété de regroupement. --groupOrder indique l'ordre des groupes ('desc' ou'asc '). --orderBy contient des noms séparés par des virgules et un préfixe facultatif "ASC" (par défaut) ou "DESC" pour l'ordre de tri. --cellRefGenerator est une stratégie personnalisée pour créer des références de cellule cible. --multisheet est le nom de la variable de contexte qui contient la liste des noms de feuille pour sortir la collection. --lastCell est un attribut commun des commandes qui pointe vers la dernière cellule de la zone de commande.

L'attribut var et l'attribut item sont obligatoires, mais d'autres attributs peuvent être omis.

Consultez la section Feuilles multiples pour plus d'informations sur l'utilisation de cellRefGenerator et des attributs multi-feuilles.

Construction de commande

Comme pour toute commande Jxls, vous pouvez définir chaque commande à l'aide de l'API Java, du balisage Excel et des paramètres XML.

Comment utiliser l'API Java

Voici un exemple de création de Each-Command dans le package 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);

Comment utiliser le balisage Excel

Pour créer chaque commande dans le balisage Excel, vous devez utiliser une syntaxe spéciale pour commenter la cellule de début dans la zone du corps de la commande.

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

L'attribut lastCell définit la dernière cellule du corps de la commande XlsArea.

XML markup usage Utilisez les balises suivantes pour créer chaque commande dans les paramètres XML.

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

Ici, l'attribut ref définit la zone associée à chaque commande. Et la zone intérieure définit le corps de chaque commande. Habituellement le même.

Direction de la boucle

Par défaut, l'attribut d'orientation de chaque commande est défini sur DOWN, ce qui signifie que le corps de la commande est dupliqué sur la ligne Excel.

Si vous devez dupliquer la zone pour chaque colonne, vous devez définir l'attribut d'orientation sur la valeur DROITE.

Dans l'API Java:

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

Regroupement des données

Chaque commande prend en charge le regroupement à l'aide de la propriété groupBy. La propriété groupOrder définit l'ordre et peut être desc ou asc. Si vous écrivez groupBy sans spécifier groupOrder, aucun tri n'est effectué.

Le balisage Excel ressemble à ceci:

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

Dans cet exemple, chaque groupe peut être référencé à l'aide de la variable myGroup accessible depuis le contexte.

L'élément de groupe actuel peut être référencé à l'aide de myGroup.item. Autrement dit, pour voir le nom de l'employé

Pour $ {myGroup.item.name} Tous les éléments du groupe sont accessibles à partir des propriétés des éléments du groupe.

jx:each(items="myGroup.items" var="employee" lastCell="D6") Vous pouvez également ignorer complètement l'attribut var, auquel cas le nom de la variable de groupe par défaut sera _group.

Voir ici pour d'autres exemples.

Aperçu de la langue

Par défaut, Jxls utilise le langage d'expression Apache JEXL pour évaluer les expressions de propriété spécifiées dans les fichiers de modèle Excel.

Voir la référence de syntaxe JEXL pour les expressions qui peuvent être utilisées.

Personnalisez le traitement de Jexl

Si vous avez besoin de personnaliser le processus Jexl, vous pouvez obtenir une référence de Transformer vers JexlEngine et appliquer les paramètres requis.

Par exemple, le code suivant enregistre une fonction Jexl personnalisée dans l'espace de noms de démonstration.

     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)。

Maintenant pour la classe JexlCustomFunctionDemo

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

Par conséquent, vous pouvez utiliser les fonctions suivantes dans le modèle.

${demo:mySum(x,y)} Où x et y pointent vers les paramètres du contexte.

Voir JexlCustomFunctionDemo.java pour un exemple d'implémentation complet.

Modifications du moteur d'expression

Vous souhaiterez peut-être utiliser un autre moteur de traitement d'expression au lieu d'Apache JEXL (par exemple, en utilisant Spring Expression Language (SpEL)).

Jxls vous permet de remplacer votre moteur d'évaluation préféré par le vôtre.

Pour ce faire, implémentez simplement une méthode de l'interface ExpressionEvaluator et déléguez le processus d'évaluation d'expression à votre moteur préféré.

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

Ensuite, vous devez transmettre l'implémentation ExpressionEvaluator à TransformationConfig, comme indiqué dans le code ci-dessous.

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

Each-Command Chaque commande est utilisée pour parcourir la collection et cloner la zone XLS de la commande. Il s'agit d'un analogue Java de l'opérateur.

Attribut de commande

Chaque commande a l'attribut suivant:

--var est le nom de la variable dans le contexte Jxls pour placer chaque nouvel élément de collection dans le processus itératif. --items est le nom de la variable de contexte qui contient la collection itérative (Iterable <?>) Ou tableau. --area est une référence à la zone XLS utilisée comme corps de chaque commande. --direction est la valeur de l'énumération Direction, qui peut avoir la valeur DOWN ou RIGHT, et indique comment répéter le corps de la commande (ligne ou colonne). La valeur par défaut est DOWN. --select est un sélecteur d'expression pour filtrer les éléments de collection pendant l'itération. --groupBy est une propriété de regroupement. --groupOrder indique l'ordre des groupes ('desc' ou'asc '). --orderBy contient des noms séparés par des virgules et un préfixe facultatif "ASC" (par défaut) ou "DESC" pour l'ordre de tri. --cellRefGenerator est une stratégie personnalisée pour créer des références de cellule cible. --multisheet est le nom de la variable de contexte qui contient la liste des noms de feuille pour sortir la collection. --lastCell est un attribut commun des commandes qui pointe vers la dernière cellule de la zone de commande.

Les attributs var et item sont obligatoires, mais d'autres attributs peuvent être omis.

Consultez la section Feuilles multiples pour plus d'informations sur l'utilisation de cellRefGenerator et des attributs multi-feuilles.

Construction de commande

Comme pour toute commande Jxls, vous pouvez définir chaque commande à l'aide de l'API Java, du balisage Excel et des paramètres XML. Voici un exemple de création de Each-Command dans le package 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);

Comment utiliser le balisage Excel

Pour créer chaque commande dans le balisage Excel, vous devez utiliser une syntaxe spéciale pour commenter la cellule de début dans la zone du corps de la commande.

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

Utilisation du balisage XML

Utilisez les balises suivantes pour créer chaque commande dans les paramètres XML.

<each items = "employee" var = "employee" ref = "Template! <area ref = "modèle! Ici, l'attribut ref définit la zone associée à chaque commande. Et la zone intérieure définit le corps de chaque commande. Habituellement le même.

Répétition orientée

Par défaut, l'attribut d'orientation de chaque commande est défini sur DOWN, ce qui signifie que le corps de la commande est dupliqué au-dessus d'une ligne dans Excel. Si vous devez dupliquer la zone pour chaque colonne, vous devez définir l'attribut d'orientation sur la valeur DROITE. Dans l'API Java:

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

Regroupement des données

Chaque commande prend en charge le regroupement à l'aide de la propriété groupBy. La propriété groupOrder définit l'ordre et peut être desc ou asc. Si vous écrivez groupBy sans spécifier groupOrder, aucun tri n'est effectué.

Le balisage Excel ressemble à ceci:

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

Dans cet exemple, chaque groupe peut être référencé à l'aide de la variable myGroup, qui est accessible en contexte.

L'élément de groupe actuel peut être référencé à l'aide de myGroup.item. Pour voir le nom de l'employé

Pour $ {myGroup.item.name} Tous les éléments du groupe sont accessibles à partir des propriétés des éléments du groupe.

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

Vous pouvez également ignorer complètement l'attribut var, auquel cas le nom de la variable de groupe par défaut sera _group.

À titre d'exemple, consultez Exemple de regroupement (http://jxls.sourceforge.net/samples/grouping_example.html).