La bibliothèque EasyExcel simplifie grandement les opérations de lecture et d'écriture de fichiers Excel en Java. Elle propose une API conviviale pour gérer diverses tâches, notamment la lecture synchrone et asynchrone, l'exportation de données, le remplissage de modèles, la personnalisation des en-têtes et du contenu, ainsi que la gestion de plusieurs feuilles de calcul.

Gestion des Données avec EasyExcelUtils

La classe EasyExcelUtils centralise les méthodes courantes pour interagir avec les fichiers Excel.

Lecture Synchrone

Permet de lire des données depuis un fichier Excel de manière synchrone. Il est possible de lire sans modèle (chaque ligne est représentée par une Map) ou avec un modèle (les données sont directement converties en objets d'une classe spécifiée).

Lecture sans modèle

Les méthodes syncRead permettent de lire le contenu d'une feuille de calcul spécifique, en commençant potentiellement à une ligne donnée et en spécifiant le nombre de lignes d'en-tête.

// Lecture de la première feuille, à partir de la deuxième ligne (par défaut)
List<map string="">> data = EasyExcelUtils.syncRead("chemin/vers/fichier.xlsx");

// Lecture d'une feuille spécifique (index 1)
List<map string="">> sheetData = EasyExcelUtils.syncRead("chemin/vers/fichier.xlsx", 1);

// Lecture d'une feuille spécifique en spécifiant le nombre de lignes d'en-tête
List<map string="">> customHeadData = EasyExcelUtils.syncRead("chemin/vers/fichier.xlsx", 0, 2); // Feuille 0, 2 lignes d'en-tête
</map></map></map>

Lecture avec modèle

Les méthodes syncReadModel convertissent les données lues en instances d'une classe modèle fournie. Vous pouvez spécifier la feuille et le nombre de lignes d'en-tête.

// Lecture avec un modèle Java (ex: classe MonModele)
List<monmodele> modelData = EasyExcelUtils.syncReadModel("chemin/vers/fichier.xlsx", MonModele.class);

// Lecture d'une feuille spécifique avec un modèle
List<monmodele> specificSheetModelData = EasyExcelUtils.syncReadModel(inputStream, MonModele.class, 2); // Feuille 2
</monmodele></monmodele>

Lecture Asynchrone

Pour le traitement de gros volumes de données, la lecture asynchrone via des AnalysisEventListener est recommnadée. Les données sont traitées par lots, améliorant les performances.

Lecture sans modèle asynchrone

// Utilisation d'un écouteur personnalisé
EasyExcelUtils.asyncRead("chemin/vers/gros_fichier.xlsx", new MonEcouteur());

// Lecture asynchrone d'une feuille spécifique
EasyExcelUtils.asyncRead(file, new MonEcouteur(), 3); // Feuille 3

Lecture avec modèle asycnhrone

// Lecture asynchrone convertie en objets MonModele
EasyExcelUtils.asyncReadModel("chemin/vers/donnees.xlsx", new MonEcouteurModele<MonModele>(), MonModele.class);

// Lecture asynchrone d'une feuille spécifique avec modèle et en-têtes personnalisés
EasyExcelUtils.asyncReadModel(inputStream, new MonEcouteurModele<MonModele>(), MonModele.class, 1, 2); // Feuille 1, 2 lignes d'en-tête

Écriture de Fichiers

EasyExcel permet l'écriture de données dans des fichiers Excel, que ce soit sans modèle (en fournissant des listes de listes) ou avec un modèle Java.

Écriture sans modèle

List<List<String>> headers = Arrays.asList(Arrays.asList("Colonne A", "Colonne B"));
List<List<Object>> rows = Arrays.asList(Arrays.asList("Valeur 1", 100), Arrays.asList("Valeur 2", 200));

// Écriture dans un fichier
EasyExcelUtils.write("chemin/sortie/nouveau_fichier.xlsx", headers, rows);

// Écriture avec nom de feuille personnalisé
EasyExcelUtils.write(outputStream, headers, rows, 0, "Données Principales");

Écriture avec modèle

User utilisateur = new User(1, "Alice", "alice@example.com");
List<User> userData = Collections.singletonList(utilisateur);

// Écriture en utilisant une classe modèle
EasyExcelUtils.write("chemin/sortie/utilisateurs.xlsx", User.class, userData);

// Écriture sur une feuille spécifique avec nom
EasyExcelUtils.write(file, User.class, userData, 1, "Utilisateurs Actifs");

Écriture basée sur un modèle (Template Fill)

Permet de remplir un fichier Excel existant (template) avec des données.

// Remplissage d'un template
EasyExcelUtils.writeTemplate("chemin/sortie/rapport.xlsx", "template.xlsx", userData);

Écriture Multi-Sheet avec EasyExcelWriterFactory

La classe EasyExcelWriterFactory facilite la création de fichiers Excel contenant plusieurs feuilles de calcul, en utilisant une approche chaînée.

// Création d'un fichier avec plusieurs feuilles
EasyExcelWriterFactory writer = EasyExcelUtils.writeWithSheets(response.getOutputStream());
writer.writeModel(User.class, usersList, "Utilisateurs")
      .write(customHeaders, dataList, "Données Brutes")
      .finish(); // Important de terminer l'écriture et fermer le flux

Gestion des Gros Volumes avec ExcelListener

L'ExcelListener est conçu pour traiter efficacement de grandes quantités de données lors de la lecture. Il utilise un ExecutorService pour paralléliser le traitement par lots des lignes et gérer les exceptions spécifiques à la conversion des données Excel.

// Exemple d'utilisation dans un listener personnalisé
public class MonEcouteurModele<T> extends ExcelListener<T> {

    public MonEcouteurModele(Integer sheetNum, Executor exec) {
        super(sheetNum, exec);
    }

    @Override
    public void invoke(T data, AnalysisContext context) {
        super.invoke(data, context); // Appel au traitement par lots du parent
        // Logique métier spécifique à chaque ligne ici si nécessaire
    }

    @Override
    public void doAfterAllAnalysed(AnalysisContext context) {
        super.doAfterAllAnalysed(context); // Assure que les dernières données sont traitées
        // Logique métier après l'analyse complète de la feuille
    }

    // Méthode pour sauvegarder les lots de données (exemple)
    private void saveToDB(List<T> batchData) {
        // Implémentation de la sauvegarde en base de données
        System.out.println("Sauvegarde de " + batchData.size() + " enregistrements.");
    }
}

Cet ansemble d'outils offre une solution robuste et flexible pour toutes vos exigences de manipulation de fichiers Excel en Java.