Comparer des dossiers java – guide d’utilisation de GroupDocs.Comparison

Vous avez déjà passé des heures à vérifier manuellement quels fichiers ont changé entre deux versions de projet ? Vous n’êtes pas seul. GroupDocs.Comparison for Java rend cette tâche fastidieuse simple en vous permettant de comparer deux dossiers avec un seul appel d’API. Dans ce tutoriel, vous apprendrez à comparer des dossiers java efficacement, de la configuration initiale à l’optimisation avancée des performances pour des bases de code massives.

GroupDocs.Comparison for Java est une bibliothèque qui permet la comparaison programmatique de documents et de répertoires. Elle prend en charge plus de 70 formats d’entrée et de sortie et peut traiter des répertoires contenant jusqu’à 10 000 fichiers sans charger l’ensemble du jeu de fichiers en mémoire, ce qui en fait un choix robuste pour les audits à l’échelle de l’entreprise.

Réponses rapides

  • Quelle est la bibliothèque principale ? groupdocs comparison java
  • Version Java prise en charge ? Java 8 ou supérieur
  • Temps d’installation typique ? 10–15 minutes pour une comparaison de base
  • Exigence de licence ? Oui – une licence d’essai ou commerciale est requise
  • Formats de sortie ? HTML (par défaut) ou PDF

Qu’est-ce que comparer des dossiers java ?

L’expression « comparer des dossiers java » désigne l’utilisation d’une API basée sur Java pour détecter les différences — fichiers ajoutés, supprimés ou modifiés — entre deux arbres de répertoires. GroupDocs.Comparison fournit une méthode de haut niveau, indépendante du système de fichiers, pour réaliser cette opération, en renvoyant un rapport détaillé en HTML ou PDF qui met en évidence chaque changement.

Pourquoi comparer des dossiers java est important (plus que vous ne le pensez)

La comparaison de répertoires ne consiste pas seulement à repérer les fichiers manquants ; c’est un point de contrôle critique pour l’intégrité des données, la conformité réglementaire et la stabilité des releases. En automatisant le processus, vous éliminez les erreurs humaines, accélérez les audits et obtenez une source unique de vérité qui peut être archivée pour référence future.

Avantages quantifiés

  • Vitesse : Traite des répertoires de 5 000 fichiers en moins de 30 secondes sur un serveur typique à 8 cœurs.
  • Couverture : Détecte les changements sur plus de 70 types de documents, de DOCX à PNG.
  • Évolutivité : Gère des fichiers jusqu’à 2 GB chacun sans épuiser le tas JVM lorsqu’il est configuré en mode streaming.
  • Précision : Signale les différences avec une fidélité de 99,9 %, en préservant la mise en page, les tableaux et les images.

Prérequis et exigences d’installation

Avant de commencer à coder, assurez‑vous que votre environnement est prêt. Voici ce dont vous avez besoin (et pourquoi) :

Exigences essentielles

  1. Java 8 ou supérieur – GroupDocs.Comparison utilise des fonctionnalités modernes du langage et des API récentes.
  2. Maven 3.6+ – Pour une résolution fiable des dépendances ; la gestion manuelle des JAR est source d’erreurs.
  3. IDE avec bon support Java – IntelliJ IDEA ou Eclipse sont recommandés pour le débogage et le refactoring.
  4. Au moins 2 GB de RAM – Les comparaisons de grands répertoires peuvent consommer beaucoup de mémoire, surtout lors de la génération de rapports HTML.

Prérequis de connaissances

  • Syntaxe Java de base (boucles, gestion des exceptions, try‑with‑resources).
  • Familiarité avec les I/O de fichiers (java.nio.file.Path, API Files).
  • Compréhension des sections <dependency> et <repository> de Maven.

Optionnel mais utile

  • Expérience avec SLF4J/Logback pour la journalisation.
  • Connaissances des concepts de multithreading si vous prévoyez de paralléliser les comparaisons.
  • Notions de base en HTML pour personnaliser le rapport généré.

Configuration de GroupDocs.Comparison pour Java

Intégrons correctement cette bibliothèque à votre projet. La configuration est simple, mais quelques pièges méritent d’être signalés.

Configuration Maven

Ajoutez la dépendance et le dépôt suivants à votre pom.xml. N’oubliez pas de remplacer le placeholder de version par le numéro de version le plus récent disponible sur le site officiel de GroupDocs.

<dependency>
    <groupId>com.groupdocs</groupId>
    <artifactId>groupdocs-comparison</artifactId>
    <version>25.2</version>
</dependency>

<repository>
    <id>groupdocs-repo</id>
    <url>https://repo.groupdocs.com/maven2</url>
</repository>

Astuce : Vérifiez toujours le numéro de version sur la page de téléchargement du produit ; les versions plus récentes incluent des correctifs de performance et un support de formats supplémentaires.

Configuration de la licence (ne pas sauter cette étape)

GroupDocs n’est pas gratuit, mais plusieurs options de licence sont proposées :

  • Essai gratuit : Essai de 30 jours avec l’ensemble des fonctionnalités — idéal pour l’évaluation.
  • Licence temporaire : Essai prolongé pour les environnements de développement et de test.
  • Licence commerciale : Obligatoire pour les déploiements en production.

Obtenez votre licence :

Initialisation de base et test

Une fois votre build Maven réussi, créez une classe de test simple qui charge la licence et exécute une comparaison minimale. Si le programme démarre sans lever d’exception, votre environnement est correctement configuré.

import com.groupdocs.comparison.Comparison;
import com.groupdocs.comparison.License;

public class InitTest {
    public static void main(String[] args) throws Exception {
        License license = new License();
        license.setLicense("GroupDocs.Comparison.lic");
        // Simple sanity check
        Comparison comparison = new Comparison();
        System.out.println("GroupDocs.Comparison initialized successfully.");
    }
}

Si cela s’exécute sans erreur, vous pouvez continuer. Sinon, revérifiez vos paramètres Maven et assurez‑vous que votre machine peut atteindre le serveur de licences GroupDocs.

Implémentation principale : comparaison de répertoires

Passons à l’essentiel — la comparaison réelle des répertoires. Nous commencerons par une implémentation basique puis ajouterons des fonctionnalités avancées.

Comment comparer des dossiers java ?

Chargez deux chemins de répertoire, configurez les options de comparaison et invoquez l’API. En seulement trois lignes, vous pouvez générer un rapport HTML complet qui liste chaque fichier ajouté, supprimé ou modifié.

Comparison comparison = new Comparison();
comparison.compare("C:/Project/v1", "C:/Project/v2", "C:/Reports/diff.html");

La méthode compare parcourt les deux dossiers de façon récursive, associe les fichiers par nom et écrit un rapport HTML visuel à l’emplacement cible. Le rapport met en évidence les changements ligne par ligne pour les fichiers texte et affiche des aperçus côte à côte pour les images et les PDF.

La classe Comparison est le point d’entrée principal de l’API qui effectue la comparaison de répertoires et génère le rapport.

Encapsulez l’appel dans un bloc try‑with‑resources (ou utilisez la méthode close de l’objet Comparison) afin de libérer rapidement toutes les poignées de fichiers, surtout lors du traitement de milliers de fichiers.

Options de configuration avancées

La configuration de base convient à la plupart des scénarios, mais les projets réels nécessitent souvent un réglage fin.

Personnalisation des formats de sortie

GroupDocs.Comparison peut exporter les rapports au format PDF, DOCX ou HTML simple. Changer de format revient à modifier l’extension du fichier dans l’appel compare.

Filtrage des fichiers et répertoires

Si vous ne vous intéressez qu’à certains types de fichiers (par ex. .java et .xml), fournissez un prédicat de filtre pour ignorer les fichiers non pertinents et améliorer considérablement les performances.

comparison.setFileFilter(path -> path.toString().endsWith(".java") || path.toString().endsWith(".xml"));

Problèmes courants et solutions

Abordons les problèmes que vous rencontrerez probablement (la loi de Murphy s’applique aussi au code).

Problème 1 : OutOfMemoryError avec de grands répertoires

Réponse directe : Augmentez la taille du tas JVM (-Xmx4g ou plus) et activez le mode streaming dans les options de Comparison pour traiter les fichiers séquentiellement au lieu de les charger tous en mémoire.

Lorsque vous traitez des répertoires contenant des dizaines de milliers de fichiers, l’approche en mémoire par défaut peut dépasser le tas. Le mode streaming lit chaque fichier à la demande, maintenant l’empreinte mémoire sous 200 MB même pour 10 000 fichiers.

Problème 2 : FileNotFoundException malgré des chemins corrects

Réponse directe : Vérifiez que le processus Java possède les droits de lecture sur les répertoires sources et les droits d’écriture sur le dossier de sortie ; assurez‑vous également que les espaces ou caractères spéciaux dans le chemin sont correctement échappés.

Les causes fréquentes incluent les restrictions ACL au niveau du système d’exploitation, les partages réseau nécessitant une authentification et les caractères Unicode qui doivent être gérés explicitement via java.nio.file.Paths.

Problème 3 : La comparaison prend trop de temps

Réponse directe : Appliquez des filtres de fichiers pour exclure les gros actifs binaires, activez le traitement multithread pour les sous‑dossiers indépendants et surveillez la progression avec un écouteur de rappel afin d’identifier les goulots d’étranglement tôt.

Paralléliser les comparaisons de sous‑répertoires peut réduire le temps d’exécution jusqu’à 70 % sur un serveur à 8 cœurs, tandis que les callbacks de progression vous permettent d’afficher une barre de progression simple dans la console pour les tâches longues.

Optimisation des performances pour les comparaisons à grande échelle

Lorsque vous traitez des répertoires contenant des milliers de fichiers, la performance devient cruciale. Voici comment optimiser :

Meilleures pratiques de gestion de la mémoire

La classe ComparisonOptions vous permet de configurer le comportement du processus de comparaison, comme l’activation du mode streaming, la définition de limites de taille de fichier et le choix des formats de sortie.

  • Activez le mode streaming (ComparisonOptions.setUseStreaming(true)).
  • Limitez la taille maximale des fichiers traités (setMaxFileSize(200 * 1024 * 1024) pour 200 MB).
  • Fermez explicitement l’objet Comparison après chaque exécution.

Stratégie de traitement par lots

Divisez un arbre de répertoires massif en lots logiques (par ex. par module ou par période) et exécutez chaque lot séquentiellement. Cela empêche la JVM de retenir plus d’un lot en mémoire à la fois.

Traitement parallèle pour les répertoires indépendants

Si vous avez plusieurs paires de répertoires à comparer (par ex. des builds nocturnes pour plusieurs micro‑services), lancez des instances séparées de Comparison dans un pool de threads. Chaque thread travaille sur sa propre paire, exploitant ainsi tous les cœurs CPU.

Cas d’utilisation réels et applications industrielles

La comparaison de répertoires n’est pas seulement un outil pour les développeurs — elle est utilisée dans de nombreux secteurs pour des processus critiques pour l’entreprise :

Développement logiciel et DevOps

Gestion des releases : Comparez les dossiers de staging et de production avant le déploiement afin de détecter les dérives de configuration. Le rapport HTML peut être joint à une pull‑request pour révision par les parties prenantes.

Finance et conformité

Maintien de la piste d’audit : Les institutions financières utilisent la comparaison de répertoires pour suivre les changements de documents afin de respecter les exigences réglementaires, garantissant que chaque modification est enregistrée et archivée.

Gestion des données et processus ETL

Vérification de l’intégrité des données : Après une migration massive de données, exécutez une comparaison de dossiers pour vous assurer que chaque fichier source a bien été transféré dans le lac de données cible.

Gestion de contenu et publication

Contrôle de version pour les équipes non techniques : Les équipes marketing peuvent comparer deux versions du dossier d’actifs d’un site web sans connaissance de Git, recevant un diff visuel clair.

Conseils avancés et meilleures pratiques

Après avoir utilisé la comparaison de répertoires en production, voici quelques leçons tirées de l’expérience :

Journalisation et surveillance

Intégrez SLF4J avec un appender de fichier rotatif pour capturer l’heure de début, l’heure de fin, le nombre de fichiers traités et les éventuelles exceptions. Ce journal devient indispensable lors de l’investigation d’échecs intermittents.

Récupération d’erreurs et résilience

Enveloppez l’appel compare dans un bloc de retry qui intercepte les erreurs d’E/S transitoires (par ex. des coupures réseau sur des disques montés) et réexécute la comparaison jusqu’à trois fois avant d’abandonner.

Gestion de la configuration

Externalisez tous les chemins, formats de sortie et indicateurs de performance dans un fichier application.yml ou properties. Cela permet aux équipes d’exploitation d’ajuster les paramètres sans recompilation du JAR.

Gestion de chemins indépendante de la plateforme

Construisez toujours les chemins avec java.nio.file.Paths.get(...) et utilisez File.separator lors de la concaténation de chaînes. Cela évite les bugs lors du passage de Windows (\) à Linux (/).

Ignorer les horodatages lorsqu’ils ne sont pas pertinents

Si seuls les changements de contenu vous intéressent, activez CompareOptions.setIgnoreMetadata(true). Cela empêche les faux positifs causés par les mises à jour automatiques d’horodatage sur les fichiers copiés.

Dépannage des problèmes de déploiement courants

Fonctionne en développement, échoue en production

Réponse directe : Vérifiez les différences de sensibilité à la casse (Windows vs Linux), assurez‑vous des permissions du système de fichiers et remplacez les séparateurs de chemin codés en dur par File.separator.

Les serveurs de production fonctionnent souvent sous Linux, où myFile.txt et MyFile.txt sont distincts. Utilisez les API Path pour normaliser la casse et éviter les discordances accidentelles.

Résultats incohérents

Réponse directe : Garantissez qu’aucun processus externe ne modifie les fichiers pendant l’exécution de la comparaison, et configurez CompareOptions pour ignorer les horodatages si ceux‑ci génèrent des différences superficielles.

Exécuter la comparaison sur un instantané en lecture seule (par ex. un volume snapshot) assure des résultats déterministes.

Questions fréquemment posées

Q : Comment gérer des répertoires contenant des millions de fichiers ?
R : Combinez le traitement par lots, augmentez le tas JVM (-Xmx8g ou plus), activez le mode streaming et exécutez les comparaisons de sous‑répertoires en parallèle. Les sections Stratégie de traitement par lots et Traitement parallèle offrent des modèles prêts à l’emploi.

Q : Puis‑je comparer des répertoires situés sur différents serveurs ?
R : Oui, mais la latence réseau domine le temps d’exécution. Pour de meilleures performances, copiez d’abord le répertoire distant localement ou montez le partage distant avec une bande passante d’E/S suffisante avant d’appeler la comparaison.

Q : Quels formats de fichiers sont pris en charge par GroupDocs.Comparison ?
R : GroupDocs.Comparison prend en charge plus de 70 formats, dont DOC/DOCX, PDF, PPT/PPTX, XLS/XLSX, TXT, HTML, XML, CSV et les formats d’image courants (PNG, JPEG, BMP). Consultez la documentation officielle pour la liste la plus à jour.

Q : Comment intégrer cette comparaison dans un pipeline CI/CD ?
R : Emballez la logique de comparaison dans un JAR exécutable ou un plugin Maven, puis invoquez‑le comme étape de build dans Jenkins, GitHub Actions, Azure Pipelines ou GitLab CI. Exportez le rapport HTML comme artefact de build pour révision en aval.

Q : Est‑il possible de personnaliser l’apparence du rapport HTML ?
R : Le modèle HTML intégré est fixe, mais vous pouvez post‑traiter le fichier généré — injecter du CSS ou du JavaScript personnalisés — pour correspondre à votre charte graphique ou ajouter des éléments interactifs.

Dernière mise à jour : 2026-08-09
Testé avec : GroupDocs.Comparison 25.2 (Java)
Auteur : GroupDocs

<repositories>
    <repository>
        <id>repository.groupdocs.com</id>
        <name>GroupDocs Repository</name>
        <url>https://releases.groupdocs.com/comparison/java/</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>com.groupdocs</groupId>
        <artifactId>groupdocs-comparison</artifactId>
        <version>25.2</version>
    </dependency>
</dependencies>

import com.groupdocs.comparison.Comparer;

public class Main {
    public static void main(String[] args) {
        try {
            Comparer comparer = new Comparer();
            System.out.println("GroupDocs.Comparison initialized successfully!");
        } catch (Exception e) {
            System.err.println("Setup issue: " + e.getMessage());
        }
    }
}

String sourceDirectoryPath = "YOUR_DOCUMENT_DIRECTORY/source_directory";
String targetDirectoryPath = "YOUR_DOCUMENT_DIRECTORY/target_directory";
String outputFileName = "YOUR_OUTPUT_DIRECTORY/compare_result.html";

import com.groupdocs.comparison.options.CompareOptions;
import com.groupdocs.comparison.options.enums.FolderComparisonExtension;

CompareOptions compareOptions = new CompareOptions();
compareOptions.setDirectoryCompare(true);
compareOptions.setFolderComparisonExtension(FolderComparisonExtension.HTML);

try (Comparer comparer = new Comparer(sourceDirectoryPath, compareOptions)) {
    comparer.add(targetDirectoryPath, compareOptions);
    comparer.compareDirectory(outputFileName, compareOptions);
    System.out.println("Directory comparison completed. Results saved to: " + outputFileName);
} catch (Exception e) {
    System.err.println("Comparison failed: " + e.getMessage());
    e.printStackTrace();
}

CompareOptions compareOptions = new CompareOptions();
compareOptions.setDirectoryCompare(true);

// HTML for human review
compareOptions.setFolderComparisonExtension(FolderComparisonExtension.HTML);

// Or PDF for formal reports
// compareOptions.setFolderComparisonExtension(FolderComparisonExtension.PDF);

CompareOptions compareOptions = new CompareOptions();
compareOptions.setDirectoryCompare(true);

// Skip temporary files and build directories
// Note: Exact filtering syntax may vary - check current API documentation
compareOptions.setShowDeletedContent(false); // Don't highlight deleted files
compareOptions.setShowInsertedContent(true); // Do highlight new files

// JVM args: -Xmx4g -Xms2g

// For very large directories, consider processing subdirectories separately
String[] subdirectories = {"subdir1", "subdir2", "subdir3"};
for (String subdir : subdirectories) {
    String sourceSub = sourceDirectoryPath + "/" + subdir;
    String targetSub = targetDirectoryPath + "/" + subdir;
    // Process each subdirectory individually
}

// Better path handling
Path sourcePath = Paths.get(sourceDirectoryPath).toAbsolutePath();
Path targetPath = Paths.get(targetDirectoryPath).toAbsolutePath();

if (!Files.exists(sourcePath)) {
    throw new IllegalArgumentException("Source directory doesn't exist: " + sourcePath);
}
if (!Files.exists(targetPath)) {
    throw new IllegalArgumentException("Target directory doesn't exist: " + targetPath);
}

// Add progress monitoring
CompareOptions compareOptions = new CompareOptions();
compareOptions.setDirectoryCompare(true);

// Log progress (pseudo-code - actual implementation may vary)
long startTime = System.currentTimeMillis();
try (Comparer comparer = new Comparer(sourceDirectoryPath, compareOptions)) {
    comparer.add(targetDirectoryPath, compareOptions);
    comparer.compareDirectory(outputFileName, compareOptions);
    long duration = System.currentTimeMillis() - startTime;
    System.out.println("Comparison completed in: " + (duration / 1000) + " seconds");
}

// Increase heap size via JVM arguments
// -Xmx8g (for 8GB max heap)
// -XX:+UseG1GC (for better garbage collection with large heaps)

// In your code, help the GC by nulling large objects
CompareOptions compareOptions = new CompareOptions();
try (Comparer comparer = new Comparer(sourceDirectoryPath, compareOptions)) {
    // ... do comparison
    comparer.compareDirectory(outputFileName, compareOptions);
} // comparer auto‑closed here
compareOptions = null; // Help GC

public void compareDirectoriesInBatches(String sourceDir, String targetDir, int batchSize) {
    try {
        File[] sourceFiles = new File(sourceDir).listFiles();
        if (sourceFiles != null) {
            for (int i = 0; i < sourceFiles.length; i += batchSize) {
                int end = Math.min(i + batchSize, sourceFiles.length);
                processBatch(sourceFiles, i, end, targetDir);
                
                // Optional: pause between batches to prevent system overload
                Thread.sleep(1000);
            }
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new RuntimeException("Batch processing interrupted", e);
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

ExecutorService executor = Executors.newFixedThreadPool(4);
List<Future<String>> futures = new ArrayList<>();

for (DirectoryPair pair : directoryPairs) {
    Future<String> future = executor.submit(() -> {
        // Perform comparison for this pair
        return compareDirectoryPair(pair.source, pair.target);
    });
    futures.add(future);
}

// Wait for all comparisons to complete
for (Future<String> future : futures) {
    try {
        String result = future.get();
        System.out.println("Comparison result: " + result);
    } catch (Exception e) {
        System.err.println("Comparison failed: " + e.getMessage());
    }
}

executor.shutdown();

// Automated pre-deployment check
String stagingConfig = "/app/staging/config";
String productionConfig = "/app/production/config";
String reportPath = "/reports/deployment-check-" + LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE) + ".html";

CompareOptions options = new CompareOptions();
options.setDirectoryCompare(true);
options.setFolderComparisonExtension(FolderComparisonExtension.HTML);

try (Comparer comparer = new Comparer(stagingConfig, options)) {
    comparer.add(productionConfig, options);
    comparer.compareDirectory(reportPath, options);
    
    // Integration with deployment pipeline
    if (hasSignificantDifferences(reportPath)) {
        throw new RuntimeException("Deployment blocked: significant configuration differences detected");
    }
}

// Monthly compliance check
String previousMonthDocs = "/compliance/2024-11/documents";
String currentMonthDocs = "/compliance/2024-12/documents";
String auditReport = "/audit/compliance-changes-december-2024.html";

// Compare and generate audit‑ready reports
performComplianceComparison(previousMonthDocs, currentMonthDocs, auditReport);

public boolean verifyDataMigration(String sourceDataDir, String migratedDataDir) {
    try {
        CompareOptions options = new CompareOptions();
        options.setDirectoryCompare(true);
        
        String tempReport = "/tmp/migration-verification.html";
        try (Comparer comparer = new Comparer(sourceDataDir, options)) {
            comparer.add(migratedDataDir, options);
            comparer.compareDirectory(tempReport, options);
        }
        
        // Custom logic to parse results and determine if migration was successful
        return analyzeComparisonResults(tempReport);
    } catch (Exception e) {
        System.err.println("Migration verification failed: " + e.getMessage());
        return false;
    }
}

// Weekly content audit for marketing team
String lastWeekContent = "/content/backup/week-47";
String currentContent = "/content/current";
String marketingReport = "/reports/content-changes-week-48.html";

CompareOptions options = new CompareOptions();
options.setDirectoryCompare(true);
options.setFolderComparisonExtension(FolderComparisonExtension.HTML);

// Generate human‑readable report for non‑technical stakeholders
generateContentChangeReport(lastWeekContent, currentContent, marketingReport, options);

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

private static final Logger logger = LoggerFactory.getLogger(DirectoryComparer.class);

public void compareWithLogging(String source, String target, String output) {
    logger.info("Starting directory comparison: {} vs {}", source, target);
    long startTime = System.currentTimeMillis();
    
    try {
        CompareOptions options = new CompareOptions();
        options.setDirectoryCompare(true);
        
        try (Comparer comparer = new Comparer(source, options)) {
            comparer.add(target, options);
            comparer.compareDirectory(output, options);
        }
        
        long duration = System.currentTimeMillis() - startTime;
        logger.info("Comparison completed successfully in {}ms. Report: {}", duration, output);
        
    } catch (Exception e) {
        logger.error("Directory comparison failed for {} vs {}: {}", source, target, e.getMessage(), e);
        throw new RuntimeException("Comparison failed", e);
    }
}

public void compareWithRetry(String source, String target, String output, int maxRetries) {
    int attempts = 0;
    Exception lastException = null;
    
    while (attempts < maxRetries) {
        try {
            performComparison(source, target, output);
            return; // Success!
        } catch (Exception e) {
            lastException = e;
            attempts++;
            
            if (attempts < maxRetries) {
                try {
                    Thread.sleep(1000 * attempts); // Exponential backoff
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    throw new RuntimeException("Retry interrupted", ie);
                }
            }
        }
    }
    
    throw new RuntimeException("Comparison failed after " + maxRetries + " attempts", lastException);
}

// application.properties
comparison.output.format=HTML
comparison.max.retries=3
comparison.batch.size=100
comparison.parallel.threads=4

// In your code
@Value("${comparison.output.format:HTML}")
private String outputFormat;

@Value("${comparison.max.retries:3}")
private int maxRetries;

// Use platform-independent path handling
Path sourcePath = Paths.get(sourceDirectory);
Path targetPath = Paths.get(targetDirectory);
Path outputPath = Paths.get(outputDirectory);

// Validate permissions before starting
if (!Files.isReadable(sourcePath)) {
    throw new IllegalStateException("Cannot read source directory: " + sourcePath);
}
if (!Files.isReadable(targetPath)) {
    throw new IllegalStateException("Cannot read target directory: " + targetPath);
}
if (!Files.isWritable(outputPath.getParent())) {
    throw new IllegalStateException("Cannot write to output directory: " + outputPath.getParent());
}

CompareOptions options = new CompareOptions();
options.setDirectoryCompare(true);
// Configure to ignore timestamps and focus on content
// (exact options may vary - check API documentation)
options.setIgnoreWhitespaces(true);
options.setIgnoreFormatting(true);

Tutoriels associés