Tutoriel GroupDocs Viewer Java : Convertir Word en HTML et rendre les documents avec commentaires

Introduction

Si vous devez convertir Word en HTML tout en conservant chaque note, commentaire ou annotation du réviseur, vous êtes au bon endroit. De nombreux développeurs Java se heurtent à un mur lorsque la conversion de documents supprime les retours précieux intégrés dans le fichier original. Ce tutoriel vous guide dans l’utilisation de GroupDocs Viewer pour Java afin de convertir Word en HTML et de rendre une large gamme de types de documents — Word, Excel, PowerPoint, PDF, et plus — sans perdre aucune donnée de commentaire.

Vous découvrirez pourquoi GroupDocs Viewer est un choix prêt pour la production, comment configurer l’environnement, le code exact dont vous avez besoin, et des astuces éprouvées pour garder des performances réactives même avec de gros fichiers.

Render Documents with Comments with GroupDocs.Viewer for Java

Render Documents with Comments with GroupDocs.Viewer for Java

Ce que vous maîtriserez dans ce tutoriel :

  • Configuration complète de GroupDocs Viewer
  • convertir Word en HTML étape par étape avec les commentaires préservés
  • Solutions courantes de dépannage et pièges à éviter
  • Modèles d’implémentation réels et meilleures pratiques
  • Techniques d’optimisation des performances pour la production

Réponses rapides

  • GroupDocs Viewer peut‑il convertir Word en HTML ? Oui — activez le rendu HTML et la prise en charge des commentaires en une seule ligne de code.
  • Les commentaires restent‑ils dans la sortie HTML ? Absolument — setRenderComments(true) préserve chaque commentaire et annotation.
  • Quelle version de Java est requise ? JDK 8 ou supérieur.
  • Une licence est‑elle nécessaire pour la production ? Une licence complète supprime les filigranes et débloque toutes les fonctionnalités.
  • Comment améliorer la vitesse de rendu ? Rendre des pages spécifiques, utiliser des ressources externes et augmenter la taille du tas JVM.

Qu’est‑ce que « convertir word en html » avec commentaires ?

« Convertir Word en HTML » signifie transformer un fichier Microsoft Word .docx en un document HTML prêt pour le web tout en conservant la mise en page originale, le style et tous les commentaires intégrés. Ce processus permet aux navigateurs d’afficher le document exactement comme les auteurs l’ont prévu, avec les retours des réviseurs.

Pourquoi choisir GroupDocs Viewer pour Java ?

Avant de plonger dans le code, explorons pourquoi GroupDocs Viewer est la bibliothèque de référence pour le rendu de documents basé sur Java :

  • Plus de 170 formats pris en charge – la bibliothèque gère tout, des DOCX aux fichiers CAD, vous offrant une dépendance unique pour tous vos besoins de conversion.
  • Pas d’installation d’Office tierce – elle fonctionne sur n’importe quel OS sans nécessiter Microsoft Office, LibreOffice ou d’autres environnements lourds.
  • Conserve la mise en forme et les annotations – les commentaires, notes de bas de page et le suivi des modifications survivent à la conversion intacts.
  • Moteur rapide et léger – les documents typiques de 100 pages se rendent en moins de 2 secondes sur un serveur standard à 4 cœurs.
  • Documentation robuste et communauté active – vous trouverez des exemples, des forums et un support rapide chaque fois que vous rencontrez un problème.

Quand utiliser cette approche

  • Construire des visionneuses de documents web qui doivent afficher les notes des réviseurs
  • Créer des plateformes de révision collaborative où les retours doivent rester visibles
  • Convertir des contrats anciens pour affichage en ligne dans des portails juridiques
  • Développer des solutions e‑learning qui intègrent les commentaires des instructeurs dans le matériel d’étude

Prérequis et configuration de l’environnement

Ce dont vous avez besoin

  • Java Development Kit (JDK) 8+ – le runtime qui alimente votre application.
  • Maven 3.6+ – pour la gestion des dépendances et la construction du projet.
  • IDE de votre choix – IntelliJ IDEA, Eclipse ou VS Code.
  • Documents d’exemple avec commentaires – fichiers DOCX, XLSX, PPTX contenant des notes de réviseur.

Configuration de votre environnement de développement

Étape 1 : Vérifier l’installation de Java

Ouvrez un terminal et exécutez :

java -version

Vous devriez voir une chaîne de version commençant par 1.8 ou supérieure. Sinon, téléchargez le dernier JDK depuis le site officiel d’Oracle ou d’OpenJDK.

Étape 2 : Vérifier l’installation de Maven

mvn -v

Maven devrait afficher sa version ainsi que la version de Java qu’il utilise. Installez Maven depuis le site Apache si la commande n’est pas reconnue.

Étape 3 : Créer un nouveau projet Maven

Générez un projet squelette avec :

mvn archetype:generate -DgroupId=com.example.viewer -DartifactId=viewer-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Naviguez dans le dossier viewer-demo nouvellement créé et vous êtes prêt à ajouter GroupDocs Viewer.

Configuration de GroupDocs.Viewer pour Java

Ajout de la dépendance

La première étape de tout tutoriel GroupDocs Viewer Java consiste à intégrer la bibliothèque dans votre projet. Ajoutez cette configuration à votre fichier pom.xml :

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

Astuce  : Vérifiez toujours la page des versions GroupDocs pour la dernière version. La bibliothèque est activement maintenue avec des mises à jour régulières et des corrections de bugs.

Comprendre les options de licence

GroupDocs propose des licences flexibles qui s’adaptent à différents besoins de projet :

  • Essai gratuit (Parfait pour l’apprentissage) : évaluation de 30 jours avec accès complet aux fonctionnalités et filigranes d’évaluation.
  • Licence temporaire (Pour le développement) : évaluation prolongée sans filigranes ; idéale pour les projets de preuve de concept. Demandez-la sur la page de licence temporaire GroupDocs.
  • Licence complète (Prête pour la production) : aucune limitation ni filigrane, utilisation commerciale autorisée. Disponible sur la page d’achat GroupDocs.

Modèle d’initialisation de base

Voici le modèle fondamental que vous utiliserez tout au long de ce tutoriel :

try (Viewer viewer = new Viewer("input.docx")) {
    // Rendering options will be set later
}

Pourquoi ce modèle fonctionne  :

  • Gestion automatique des ressources empêche les fuites de mémoire.
  • Gestion des exceptions capture les problèmes courants d’accès aux fichiers.
  • Code propre et lisible facile à maintenir dans de grands projets.

Implémentation principale : rendu de documents avec commentaires

Comprendre le processus

Lorsque vous rendez un document avec GroupDocs Viewer, la bibliothèque effectue quatre étapes clés :

  1. Analyse du document – analyse le fichier d’entrée et construit une représentation interne.
  2. Extraction des commentaires – identifie chaque commentaire, note de bas de page et annotation.
  3. Génération HTML – crée un HTML propre et conforme aux standards qui reflète la mise en page originale.
  4. Gestion des ressources – regroupe images, CSS et polices soit en ligne, soit comme fichiers externes.

Implémentation étape par étape

Étape 1 : Configurer vos chemins de fichiers

Organisez vos emplacements d’entrée et de sortie dès le départ pour éviter les erreurs liées aux chemins :

Path inputPath = Paths.get("documents/sample-with-comments.docx");
Path outputDir = Paths.get("output/html");
Files.createDirectories(outputDir);

Pourquoi cette approche  :

  • Utilise l’API moderne Java NIO.2 Path, plus fiable que java.io.File.
  • Des noms de variables descriptifs facilitent le débogage.
  • Le placeholder {0} dans le modèle de sortie est automatiquement remplacé par les numéros de page.

Étape 2 : Configurer les options de rendu HTML

C’est ici que la magie opère. Nous indiquons à GroupDocs exactement comment nous voulons que le document soit rendu :

HtmlViewOptions configure la façon dont le document est rendu en HTML, y compris la gestion des ressources et le rendu des commentaires.

HtmlViewOptions viewOptions = HtmlViewOptions.forEmbeddedResources(outputDir);
viewOptions.setRenderComments(true);   // Preserve every comment
viewOptions.setPageNumberPrefix("page_");

Détails clés de la configuration  :

  • forEmbeddedResources() intègre le CSS, les images et les polices directement dans le HTML, rendant la sortie portable.
  • setRenderComments(true) est la ligne unique qui garantit que convertir word en html conserve toutes les notes des réviseurs.
  • L’alternative forExternalResources() vous permet de stocker les ressources séparément si vous préférez un fichier HTML plus léger.

Étape 3 : Exécuter le rendu

Nous rassemblons maintenant tous les éléments :

Viewer est la classe principale utilisée pour charger un document et effectuer les opérations de rendu.

try (Viewer viewer = new Viewer(inputPath.toFile())) {
    viewer.view(viewOptions);
}

L’appel view lit le fichier Word, extrait les commentaires, génère les pages HTML et les écrit dans output/html. Chaque page est enregistrée sous page_1.html, page_2.html, etc.

Exemple complet fonctionnel

Assembler toutes les pièces vous donne une classe unique et exécutable qui convertit un document Word en HTML tout en conservant les commentaires intacts. (Le code source complet est disponible dans le référentiel officiel GitHub.)

Configuration avancée et options

Configuration de répertoires de sortie dynamiques

Pour les applications plus importantes, vous pouvez vouloir générer des répertoires de sortie basés sur les ID d’utilisateur ou les horodatages :

String userId = "12345";
Path dynamicOutput = Paths.get("output", userId, LocalDate.now().toString());
Files.createDirectories(dynamicOutput);
HtmlViewOptions dynamicOptions = HtmlViewOptions.forEmbeddedResources(dynamicOutput);

Problèmes courants et dépannage

Problème 1 : Erreurs « File Not Found »

Assurez‑vous que le chemin d’entrée est absolu ou relatif au répertoire de travail, et vérifiez les permissions du fichier. Utiliser des objets Path aide à éviter les erreurs courantes de concaténation de chaînes.

Problème 2 : Les commentaires n’apparaissent pas dans la sortie

Vérifiez que setRenderComments(true) est appelé avant viewer.view(). Assurez‑vous également que le document source contient réellement des commentaires ; vous pouvez les inspecter via viewer.getDocumentInfo().getComments().

Problème 3 : Erreurs de mémoire insuffisante avec de gros documents

GroupDocs Viewer diffuse les données, mais les fichiers extrêmement volumineux (> 500 pages) peuvent encore solliciter le tas JVM. Augmentez la taille du tas avec -Xmx4g ou ne rendez que les pages nécessaires.

Problème 4 : Performance de rendu lente

Rendez des plages de pages spécifiques en utilisant viewer.view(pageRange, viewOptions). Les ressources externes (forExternalResources()) réduisent également la taille du payload HTML, accélérant le rendu du navigateur.

Modèles d’implémentation réels

Modèle 1 : Intégration dans une application Web

Intégrez la logique de rendu dans un contrôleur Spring Boot pour servir le HTML à la demande :

@RestController
@RequestMapping("/api/view")
public class DocumentController {

    @GetMapping("/{id}")
    public ResponseEntity<Resource> renderDocument(@PathVariable String id) throws IOException {
        Path docPath = Paths.get("documents", id + ".docx");
        Path outDir = Files.createTempDirectory("viewer");
        HtmlViewOptions options = HtmlViewOptions.forEmbeddedResources(outDir);
        options.setRenderComments(true);
        try (Viewer viewer = new Viewer(docPath.toFile())) {
            viewer.view(options);
        }
        // Return the first HTML page as a Resource
        Path firstPage = outDir.resolve("page_1.html");
        Resource resource = new UrlResource(firstPage.toUri());
        return ResponseEntity.ok()
                .contentType(MediaType.TEXT_HTML)
                .body(resource);
    }
}

Modèle 2 : Traitement par lots de plusieurs documents

Lorsque vous devez convertir un dossier complet de fichiers Word, parcourez le répertoire et réutilisez la même instance HtmlViewOptions afin de minimiser le sur‑coût de création d’objets.

Optimisation des performances et meilleures pratiques

Conseils de gestion de la mémoire

  • Utilisez toujours try‑with‑resources pour les instances Viewer.
  • Traitez les gros documents par lots plutôt que de tout charger en mémoire d’un coup.
  • Surveillez l’utilisation du tas JVM avec des outils comme VisualVM et ajustez -Xmx selon les besoins.
  • Mettez en œuvre un cache approprié pour les documents fréquemment accédés afin d’éviter les rendus répétés.

Directives d’utilisation des ressources

Pour les petites applications (< 100 documents/jour) :

HtmlViewOptions options = HtmlViewOptions.forEmbeddedResources(Paths.get("output"));
options.setRenderComments(true);

Pour les applications à haut volume (1000+ documents/jour) :

HtmlViewOptions options = HtmlViewOptions.forExternalResources(Paths.get("output"));
options.setRenderComments(true);
options.setCacheEnabled(true);

Stratégies de mise en cache

Stockez le HTML rendu dans un cache distribué (par ex., Redis) indexé par le hachage du document. Lorsqu’une requête arrive, vérifiez d’abord le cache ; si un hit, servez le HTML mis en cache instantanément, contournant le moteur de rendu.

Quand utiliser GroupDocs Viewer vs les alternatives

GroupDocs Viewer est parfait pour

  • Systèmes de gestion de documents – besoin d’afficher de nombreux types de fichiers avec annotations.
  • Plateformes de révision collaborative – les commentaires doivent rester visibles pour tous les participants.
  • Outils éducatifs – les notes des instructeurs apparaissent à côté des diapositives de cours.
  • Applications juridiques – les contrats avec commentaires d’avocat nécessitent un rendu fidèle.

Envisagez des alternatives lorsque

  • Affichage PDF simple – les visionneuses PDF natives du navigateur peuvent suffire.
  • Conversion d’image basique – ImageIO ou des bibliothèques similaires sont plus légères.
  • Extraction de texte pure – Apache POI ou iText pourraient être plus appropriés.

FAQ – Questions fréquentes

Q : Puis‑je rendre des documents sans commentaires ?
R : Oui — il suffit d’omettre l’appel setRenderComments(true) ou de le définir sur false.

Q : Quels formats de fichiers prennent en charge le rendu des commentaires ?
R : La plupart des formats majeurs — y compris DOC/DOCX, XLS/XLSX, PPT/PPTX, PDF, et bien d’autres. Consultez la documentation officielle pour la liste complète.

Q : Puis‑je personnaliser le style du rendu HTML ?
R : Absolument. Utilisez HtmlViewOptions.setEmbedResources(false) pour générer des fichiers CSS externes, puis ajoutez votre propre feuille de style après le rendu.

Q : Comment gérer les documents protégés par mot de passe ?
R : Fournissez une instance LoadOptions avec le mot de passe :

LoadOptions vous permet de spécifier les paramètres de chargement du document tels que les mots de passe.

LoadOptions loadOptions = new LoadOptions("myPassword");
try (Viewer viewer = new Viewer(inputPath.toFile(), loadOptions)) {
    viewer.view(viewOptions);
}

Q : Est‑il possible de rendre uniquement des pages spécifiques ?
R : Oui — utilisez la méthode surchargée view qui accepte une collection PageNumber :

PageNumber représente un indice de page spécifique utilisé lors du rendu d’un sous‑ensemble de pages.

viewer.view(new int[]{1, 3, 5}, viewOptions);

Q : Pourquoi le rendu est‑il lent pour les gros documents ?
R : Les gros fichiers nécessitent plus de temps de traitement. Améliorez la vitesse en ne rendant que les pages nécessaires, en utilisant des ressources externes, en augmentant le tas JVM et en activant le traitement asynchrone.

Q : Comment puis‑je surveiller la progression du rendu ?
R : Bien que GroupDocs Viewer ne dispose pas de callbacks intégrés, vous pouvez chronométrer l’opération avec System.nanoTime() avant et après viewer.view() pour enregistrer la durée.

Q : Que se passe‑t‑il si le document source est corrompu ?
R : La bibliothèque lève une ViewerException. Enveloppez l’appel dans un bloc try‑catch et consignez l’erreur pour une dégradation en douceur.

Q : Puis‑je utiliser GroupDocs Viewer dans une application commerciale ?
R : Oui, mais une licence commerciale est requise. L’essai gratuit inclut des filigranes qui doivent être supprimés pour une utilisation en production.

Q : Existe‑t‑il des limites d’utilisation ?
R : La bibliothèque elle‑même n’impose aucune limite, bien que votre contrat de licence puisse définir des plafonds d’utilisation. Consultez votre contrat pour les détails.

Q : Puis‑je redistribuer des applications incluant GroupDocs Viewer ?
R : Vous pouvez distribuer votre propre application, mais vous ne pouvez pas redistribuer les binaires de la bibliothèque GroupDocs eux‑mêmes. Vérifiez les termes de la licence pour conformité.

Prochaines étapes et sujets avancés

Vous avez maintenant une base solide pour convertir word en html tout en préservant les commentaires. Voici quelques pistes pour approfondir votre expertise :

  1. Filigrane — ajouter des filigranes personnalisés aux pages rendues pour le branding ou la confidentialité.
  2. Extraction de métadonnées — récupérer l’auteur, la date de création et le nombre de pages via viewer.getDocumentInfo().
  3. Visionneuses personnalisées — créer des visionneuses spécialisées pour les PDF, les feuilles de calcul ou les présentations qui masquent ou mettent en évidence les commentaires différemment.
  4. Intégration du stockage cloud — rendre les fichiers directement depuis AWS S3, Azure Blob ou Google Drive sans les télécharger localement.

Parcours d’apprentissage recommandé

  1. Expérimenter avec différents types de fichiers — essayez Excel, PowerPoint et PDF pour voir comment les commentaires sont gérés selon les formats.
  2. Construire un simple visionneur Web — créez une page HTML minimale qui charge le HTML généré via une balise <iframe> ou AJAX.
  3. Explorer l’écosystème GroupDocs — consultez GroupDocs Annotation, Comparison et Signature pour des flux de travail documentaires de bout en bout.
  4. Rejoindre la communauté — participez au Forum GroupDocs pour des astuces, projets d’exemple et support.

Obtenir de l’aide et du support

Ressources officielles

Ressources communautaires

  • Stack Overflow (tag : groupdocs-viewer)
  • Communautés Reddit de programmation
  • Serveurs Discord pour développeurs Java

Dernière mise à jour : 2026-05-21
Testé avec : GroupDocs.Viewer 25.2 for Java
Auteur : GroupDocs

java -version
javac -version

mvn -version

mvn archetype:generate -DgroupId=com.example.documentviewer -DartifactId=groupdocs-viewer-demo -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

<repositories>
   <repository>
      <id>repository.groupdocs.com</id>
      <name>GroupDocs Repository</name>
      <url>https://releases.groupdocs.com/viewer/java/</url>
   </repository>
</repositories>
<dependencies>
   <dependency>
      <groupId>com.groupdocs</groupId>
      <artifactId>groupdocs-viewer</artifactId>
      <version>25.2</version>
   </dependency>
</dependencies>

import com.groupdocs.viewer.Viewer;

// The try-with-resources pattern ensures proper cleanup
try (Viewer viewer = new Viewer("path/to/your/document.docx")) {
    // All rendering operations happen here
    // Resources are automatically closed when done
} catch (Exception e) {
    System.err.println("Error rendering document: " + e.getMessage());
    e.printStackTrace();
}

import java.nio.file.Path;
import java.nio.file.Paths;

// Create a descriptive output directory
Path outputDirectory = Paths.get("rendered-documents");
Path pageFilePathFormat = outputDirectory.resolve("page_{0}.html");

import com.groupdocs.viewer.options.HtmlViewOptions;

// Create HTML options with embedded resources
HtmlViewOptions viewOptions = HtmlViewOptions.forEmbeddedResources(pageFilePathFormat);

// The crucial setting – enable comment rendering!
viewOptions.setRenderComments(true);

import com.groupdocs.viewer.Viewer;

try (Viewer viewer = new Viewer("path/to/your/document.docx")) {
    // Create output directory if it doesn't exist
    if (!outputDirectory.toFile().exists()) {
        outputDirectory.toFile().mkdirs();
    }
    
    // Perform the actual rendering
    viewer.view(viewOptions);
    
    System.out.println("Document rendered successfully!");
    System.out.println("Output location: " + outputDirectory.toAbsolutePath());
    
} catch (Exception e) {
    System.err.println("Rendering failed: " + e.getMessage());
    e.printStackTrace();
}

package com.example.documentviewer;

import com.groupdocs.viewer.Viewer;
import com.groupdocs.viewer.options.HtmlViewOptions;
import java.nio.file.Path;
import java.nio.file.Paths;

public class DocumentRenderer {
    
    public static void main(String[] args) {
        renderDocumentWithComments("sample-document.docx", "output");
    }
    
    public static void renderDocumentWithComments(String inputFile, String outputDir) {
        // Set up paths
        Path outputDirectory = Paths.get(outputDir);
        Path pageFilePathFormat = outputDirectory.resolve("page_{0}.html");
        
        // Configure rendering options
        HtmlViewOptions viewOptions = HtmlViewOptions.forEmbeddedResources(pageFilePathFormat);
        viewOptions.setRenderComments(true);
        
        // Render the document
        try (Viewer viewer = new Viewer(inputFile)) {
            // Ensure output directory exists
            outputDirectory.toFile().mkdirs();
            
            // Execute rendering
            viewer.view(viewOptions);
            
            System.out.println("✓ Document rendered with comments preserved");
            System.out.println("📂 Output directory: " + outputDirectory.toAbsolutePath());
            
        } catch (Exception e) {
            System.err.println("❌ Rendering failed: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

import java.nio.file.Path;
import java.nio.file.Paths;

public class PathManager {
    
    /**
     * Creates a structured output path based on document name and timestamp
     */
    public static Path getOutputDirectoryPath(String documentName) {
        String timestamp = String.valueOf(System.currentTimeMillis());
        String cleanDocName = documentName.replaceAll("[^a-zA-Z0-9]", "_");
        
        return Paths.get("rendered-docs")
                   .resolve(cleanDocName)
                   .resolve(timestamp);
    }
    
    /**
     * Simple output directory for basic use cases
     */
    public static Path getSimpleOutputPath(String folderName) {
        return Paths.get("output").resolve(folderName);
    }
}

// Always check if file exists before processing
Path inputPath = Paths.get("your-document.docx");
if (!inputPath.toFile().exists()) {
    throw new IllegalArgumentException("Input file not found: " + inputPath.toAbsolutePath());
}

// Check if file is readable
if (!inputPath.toFile().canRead()) {
    throw new IllegalArgumentException("Cannot read input file: " + inputPath.toAbsolutePath());
}

HtmlViewOptions viewOptions = HtmlViewOptions.forEmbeddedResources(pageFilePathFormat);
// This line is crucial – don't forget it!
viewOptions.setRenderComments(true);

// For debugging, you can verify the setting:
System.out.println("Comments enabled: " + viewOptions.isRenderComments());

// Increase JVM heap size when running
// java -Xmx2g -Xms1g YourApplication

// Or process documents page by page for very large files
HtmlViewOptions viewOptions = HtmlViewOptions.forEmbeddedResources(pageFilePathFormat);
viewOptions.setRenderComments(true);

// Render only specific pages if needed
viewer.view(viewOptions, 1, 2, 3); // Renders only pages 1, 2, and 3

// Use external resources for faster processing of multiple pages
HtmlViewOptions viewOptions = HtmlViewOptions.forExternalResources(
    pageFilePathFormat, 
    "resources/page_{0}/", 
    "resources/page_{0}/{0}"
);

// Enable caching if processing the same document multiple times
// (Note: Implement caching at application level)

@RestController
@RequestMapping("/api/documents")
public class DocumentController {
    
    @PostMapping("/render")
    public ResponseEntity<String> renderDocument(
            @RequestParam("file") MultipartFile file) {
        
        try {
            // Save uploaded file temporarily
            Path tempFile = Files.createTempFile("upload", ".tmp");
            file.transferTo(tempFile.toFile());
            
            // Render with comments
            String outputDir = renderDocumentWithComments(
                tempFile.toString(), 
                "web-output"
            );
            
            return ResponseEntity.ok("Document rendered: " + outputDir);
            
        } catch (Exception e) {
            return ResponseEntity.badRequest()
                .body("Rendering failed: " + e.getMessage());
        }
    }
}

public class BatchDocumentProcessor {
    
    public void processFolderWithComments(String inputFolder) {
        File folder = new File(inputFolder);
        File[] files = folder.listFiles((dir, name) -> 
            name.toLowerCase().endsWith(".docx") || 
            name.toLowerCase().endsWith(".xlsx") ||
            name.toLowerCase().endsWith(".pptx")
        );
        
        if (files == null) return;
        
        for (File file : files) {
            try {
                String outputDir = file.getName().replace(".", "_") + "_output";
                renderDocumentWithComments(file.getAbsolutePath(), outputDir);
                System.out.println("✓ Processed: " + file.getName());
                
            } catch (Exception e) {
                System.err.println("❌ Failed to process " + file.getName() + ": " + e.getMessage());
            }
        }
    }
}

// Simple approach works fine
try (Viewer viewer = new Viewer(documentPath)) {
    viewer.view(viewOptions);
}

public class DocumentRenderingService {
    private final ExecutorService executorService = 
        Executors.newFixedThreadPool(4); // Limit concurrent renderings
    
    public CompletableFuture<String> renderAsync(String documentPath) {
        return CompletableFuture.supplyAsync(() -> {
            try (Viewer viewer = new Viewer(documentPath)) {
                // Rendering logic here
                return "success";
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }, executorService);
    }
}

public class CachedDocumentRenderer {
    private final Map<String, String> renderCache = new ConcurrentHashMap<>();
    
    public String renderWithCaching(String documentPath) {
        String cacheKey = generateCacheKey(documentPath);
        
        return renderCache.computeIfAbsent(cacheKey, key -> {
            // Only render if not already cached
            return performActualRendering(documentPath);
        });
    }
    
    private String generateCacheKey(String documentPath) {
        // Include file modification time in cache key
        File file = new File(documentPath);
        return documentPath + "_" + file.lastModified();
    }
}

LoadOptions loadOptions = new LoadOptions();
loadOptions.setPassword("your-password");
try (Viewer viewer = new Viewer("protected-doc.docx", loadOptions)) {
    // Render as usual
}

viewer.view(viewOptions, 1, 3, 5); // Renders only pages 1, 3, and 5

System.out.println("Starting render for: " + documentName);
long startTime = System.currentTimeMillis();
viewer.view(viewOptions);
long endTime = System.currentTimeMillis();
System.out.println("Rendering completed in: " + (endTime - startTime) + "ms");

try (Viewer viewer = new Viewer(documentPath)) {
    viewer.view(viewOptions);
} catch (CorruptOrDamagedFileException e) {
    System.err.println("Document is corrupted: " + e.getMessage());
} catch (Exception e) {
    System.err.println("General error: " + e.getMessage());
}

Tutoriels associés