GroupDocs Viewer Java Handleiding: Word naar HTML converteren en documenten met opmerkingen weergeven

Inleiding

Als je convert Word to HTML moet converteren terwijl je elke reviewer‑note, commentaar of annotatie behoudt, ben je op de juiste plek. Veel Java‑ontwikkelaars lopen tegen een muur aan wanneer documentconversie de waardevolle feedback die in het originele bestand is ingebed, verwijdert. Deze handleiding leidt je door het gebruik van GroupDocs Viewer voor Java om convert Word to HTML te converteren en een breed scala aan documenttypen—Word, Excel, PowerPoint, PDF en meer—weer te geven zonder commentaargegevens te verliezen.

Je ontdekt waarom GroupDocs Viewer een productie‑ready keuze is, hoe je de omgeving instelt, de exacte code die je nodig hebt, en bewezen trucs om de prestaties snel te houden, zelfs bij grote bestanden.

Documenten met opmerkingen weergeven met GroupDocs.Viewer voor Java

Wat je in deze handleiding onder de knie krijgt:

• Volledige GroupDocs Viewer installatie en configuratie
• Stapsgewijs convert Word to HTML met behoud van opmerkingen
• Veelvoorkomende oplossingen voor probleemoplossing en valkuilen om te vermijden
• Praktijkvoorbeelden en best practices
• Prestaties optimalisatietechnieken voor productiegebruik

Snelle antwoorden

• Kan GroupDocs Viewer Word naar HTML converteren? Ja—schakel HTML‑rendering en commentaarondersteuning in met één regel code.
• Blijven opmerkingen behouden in de HTML‑uitvoer? Absoluut—setRenderComments(true) behoudt elke opmerking en annotatie.
• Welke Java‑versie is vereist? JDK 8 of hoger.
• Is een licentie nodig voor productie? Een volledige licentie verwijdert watermerken en ontgrendelt alle functies.
• Hoe de renderingssnelheid te verbeteren? Render specifieke pagina’s, gebruik externe bronnen, en vergroot de JVM‑heap‑grootte.

Wat is “convert word to html” met opmerkingen?

“Convert Word to HTML” betekent het omzetten van een Microsoft Word .docx‑bestand naar een web‑klaar HTML‑document, waarbij de oorspronkelijke lay-out, opmaak en eventuele ingebedde opmerkingen behouden blijven. Dit proces maakt het mogelijk dat browsers het document precies weergeven zoals de auteurs bedoeld hebben, inclusief feedback van reviewers.

Waarom kiezen voor GroupDocs Viewer voor Java?

Voordat we in de code duiken, laten we onderzoeken waarom GroupDocs Viewer de bibliotheek bij uitstek is voor Java‑gebaseerde documentweergave:

• 170+ ondersteunde formaten – de bibliotheek verwerkt alles van DOCX tot CAD‑bestanden, waardoor je één afhankelijkheid hebt voor al je conversiebehoeften.
• Geen installatie van derde‑partij Office – werkt op elk OS zonder Microsoft Office, LibreOffice of andere zware runtimes.
• Behoudt opmaak en annotaties – opmerkingen, voetnoten en track changes blijven intact na conversie.
• Snelle, lichte engine – typische 100‑pagina documenten renderen in minder dan 2 seconden op een standaard 4‑core server.
• Robuuste documentatie en actieve community – je vindt voorbeelden, forums en snelle ondersteuning wanneer je een probleem tegenkomt.

Wanneer deze aanpak te gebruiken

• Web‑gebaseerde documentviewers bouwen die reviewer‑notities moeten tonen
• Samenwerkende beoordelingsplatformen creëren waarbij feedback zichtbaar moet blijven
• Legacy‑contracten converteren voor online weergave in juridische portals
• E‑learning oplossingen ontwikkelen die instructeurs‑opmerkingen in studiemateriaal opnemen

Vereisten en omgeving configuratie

Wat je nodig hebt

• Java Development Kit (JDK) 8+ – de runtime die je applicatie aandrijft.
• Maven 3.6+ – voor afhankelijkheidsbeheer en het bouwen van het project.
• IDE naar keuze – IntelliJ IDEA, Eclipse of VS Code.
• Voorbeelddocumenten met opmerkingen – DOCX-, XLSX- en PPTX‑bestanden die reviewer‑notities bevatten.

Instellen van je ontwikkelomgeving

Stap 1: Java‑installatie verifiëren

Open een terminal en voer uit:

java -version

Je zou een versiestring moeten zien die begint met 1.8 of hoger. Zo niet, download dan de nieuwste JDK van de officiële Oracle‑ of OpenJDK‑website.

Stap 2: Maven‑installatie controleren

Voer uit:

mvn -v

Maven zou zijn versie en de Java‑versie die het gebruikt moeten weergeven. Installeer Maven vanaf de Apache‑website als het commando niet wordt herkend.

Stap 3: Een nieuw Maven‑project maken

Genereer een skeleton‑project met:

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

Navigeer naar de nieuw aangemaakte viewer-demo‑map en je bent klaar om GroupDocs Viewer toe te voegen.

Instellen van GroupDocs.Viewer voor Java

Toevoegen van de afhankelijkheid

De eerste stap in elke GroupDocs Viewer Java‑handleiding is het krijgen van de bibliotheek in je project. Voeg deze configuratie toe aan je pom.xml‑bestand:

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

Pro Tip: Controleer altijd de GroupDocs releases-pagina voor de nieuwste versie. De bibliotheek wordt actief onderhouden met regelmatige updates en bugfixes.

Licentieopties begrijpen

GroupDocs biedt flexibele licenties die passen bij verschillende projectbehoeften:

• Free Trial (Perfect for Learning): 30‑daagse evaluatie met volledige functietoegang en evaluatiewatermerken.
• Temporary License (For Development): Uitgebreide evaluatie zonder watermerken; ideaal voor proof‑of‑concept projecten. Vraag aan op GroupDocs tijdelijke licentiepagina.
• Full License (Production Ready): Geen beperkingen of watermerken, commercieel gebruik toegestaan. Beschikbaar op GroupDocs aankooppagina.

Basisinitialisatiepatroon

Hier is het fundamentele patroon dat je gedurende deze handleiding zult gebruiken:

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

Waarom dit patroon werkt:

• Automatisch resource‑beheer voorkomt geheugenlekken.
• Exception handling vangt veelvoorkomende bestands‑toegangsproblemen.
• Schone, leesbare code die gemakkelijk te onderhouden is in grote projecten.

Kernimplementatie: Documenten renderen met opmerkingen

Het proces begrijpen

Wanneer je een document rendert met GroupDocs Viewer, voert de bibliotheek vier belangrijke stappen uit:

1. Documentanalyse – parseert het invoerbestand en bouwt een interne representatie.
2. Opmerkingsextractie – identificeert elke opmerking, voetnoot en annotatie.
3. HTML‑generatie – maakt schone, aan standaarden conforme HTML die de oorspronkelijke lay-out weerspiegelt.
4. Resource‑afhandeling – bundelt afbeeldingen, CSS en lettertypen inline of als externe bestanden.

Stapsgewijze implementatie

Stap 1: Stel je bestands‑paden in

Organiseer je invoer‑ en uitvoerlocaties vroeg om pad‑gerelateerde fouten te voorkomen:

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

Waarom deze aanpak:

• Maakt gebruik van de moderne Java NIO.2 Path‑API, die betrouwbaarder is dan java.io.File.
• Beschrijvende variabelenamen maken debugging eenvoudiger.
• De {0}‑placeholder in het uitvoerpatroon wordt automatisch vervangen door paginanummers.

Stap 2: HTML‑renderopties configureren

Dit is waar de magie gebeurt. We vertellen GroupDocs precies hoe we het document willen renderen:

HtmlViewOptions configureert hoe het document naar HTML wordt gerenderd, inclusief resource‑afhandeling en commentaar‑rendering.

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

Belangrijke configuratiedetails:

• forEmbeddedResources() embedt CSS, afbeeldingen en lettertypen direct in de HTML, waardoor de output draagbaar is.
• setRenderComments(true) is de enkele regel die ervoor zorgt dat convert word to html alle reviewer‑notities behoudt.
• Alternatief forExternalResources() laat je assets apart opslaan als je een slankere HTML‑file wilt.

Stap 3: De rendering uitvoeren

Nu brengen we alles samen:

Viewer is de primaire klasse die wordt gebruikt om een document te laden en render‑operaties uit te voeren.

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

De view‑aanroep leest het Word‑bestand, extraheert opmerkingen, genereert HTML‑pagina’s en schrijft ze naar output/html. Elke pagina wordt opgeslagen als page_1.html, page_2.html, enz.

Volledig werkend voorbeeld

Alle onderdelen samenvoegen geeft je een enkele, uitvoerbare klasse die een Word‑document naar HTML converteert terwijl opmerkingen intact blijven. (De volledige broncode is beschikbaar in de officiële GitHub‑repository.)

Geavanceerde configuratie en opties

Dynamische uitvoermap instellen

Voor grotere applicaties wil je mogelijk uitvoermappen genereren op basis van gebruikers‑ID’s of tijdstempels:

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

Veelvoorkomende problemen en foutoplossing

Probleem 1: “File Not Found”‑fouten

Zorg ervoor dat het invoerpad absoluut of relatief ten opzichte van de werkmap is, en controleer bestandsrechten. Het gebruik van Path‑objecten helpt veelvoorkomende string‑concatenatiefouten te vermijden.

Probleem 2: Opmerkingen verschijnen niet in de output

Controleer dubbel dat setRenderComments(true) wordt aangeroepen voor viewer.view(). Zorg er ook voor dat het bronbestand daadwerkelijk opmerkingen bevat; je kunt ze inspecteren via viewer.getDocumentInfo().getComments().

Probleem 3: Out‑of‑Memory‑fouten bij grote documenten

GroupDocs Viewer streamt data, maar extreem grote bestanden (> 500 pagina’s) kunnen nog steeds de JVM‑heap belasten. Verhoog de heap‑grootte met -Xmx4g of render alleen de benodigde pagina’s.

Probleem 4: Trage renderprestaties

Render specifieke paginabereiken met viewer.view(pageRange, viewOptions). Externe resources (forExternalResources()) verminderen ook de HTML‑payload‑grootte, waardoor browser‑rendering sneller gaat.

Praktijkimplementatiepatronen

Patroon 1: Integratie in webapplicatie

Integreer de renderlogica in een Spring Boot‑controller om HTML op aanvraag te leveren:

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

Patroon 2: Batchverwerking van meerdere documenten

Wanneer je een hele map met Word‑bestanden moet converteren, loop je door de directory en hergebruik je dezelfde HtmlViewOptions‑instantie om de overhead van objectcreatie te minimaliseren.

Prestatie‑optimalisatie en best practices

Tips voor geheugenbeheer

• Gebruik altijd try‑with‑resources voor Viewer‑instanties.
• Verwerk grote documenten in batches in plaats van alles in één keer in het geheugen te laden.
• Monitor het JVM‑heap‑gebruik met tools zoals VisualVM en pas -Xmx aan indien nodig.
• Implementeer juiste caching voor vaak geraadpleegde documenten om herhaald renderen te vermijden.

Richtlijnen voor resource‑gebruik

Voor kleine applicaties (< 100 documenten/dag):

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

Voor high‑volume applicaties (1000+ documenten/dag):

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

Caching‑strategieën

Sla gerenderde HTML op in een gedistribueerde cache (bijv. Redis) met de document‑hash als sleutel. Wanneer een verzoek binnenkomt, controleer eerst de cache; bij een hit, serveer de gecachte HTML direct, waardoor de renderengine wordt omzeild.

Wanneer GroupDocs Viewer gebruiken versus alternatieven

GroupDocs Viewer is perfect voor

• Document Management Systems – moeten veel bestandstypen met annotaties weergeven.
• Collaboratieve beoordelingsplatformen – opmerkingen moeten zichtbaar blijven voor alle deelnemers.
• Educatieve tools – notities van instructeurs verschijnen naast presentatieslides.
• Juridische toepassingen – contracten met advocaat‑opmerkingen vereisen een getrouwe weergave.

Overweeg alternatieven wanneer

• Eenvoudige PDF-weergave – native browser‑PDF‑viewers kunnen voldoende zijn.
• Basis afbeelding conversie – ImageIO of soortgelijke bibliotheken zijn lichter.
• Zuivere tekstextractie – Apache POI of iText kunnen geschikter zijn.

Veelgestelde vragen

V: Kan ik documenten renderen zonder opmerkingen?
A: Ja—laat simpelweg de setRenderComments(true)‑aanroep weg of stel deze in op false.

V: Welke bestandsformaten ondersteunen het renderen van opmerkingen?
A: De meeste belangrijke formaten—waaronder DOC/DOCX, XLS/XLSX, PPT/PPTX, PDF en nog veel meer. Zie de officiële documentatie voor de volledige lijst.

V: Kan ik de styling van de HTML‑output aanpassen?
A: Absoluut. Gebruik HtmlViewOptions.setEmbedResources(false) om externe CSS‑bestanden te genereren, en voeg daarna je eigen stylesheet toe.

V: Hoe ga ik om met wachtwoord‑beveiligde documenten?
A: Geef een LoadOptions‑instantie op met het wachtwoord:

LoadOptions stelt je in staat om document‑laadparameters zoals wachtwoorden te specificeren.

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

V: Is het mogelijk om alleen specifieke pagina’s te renderen?
A: Ja—gebruik de overladen view‑methode die een PageNumber‑collectie accepteert:

PageNumber vertegenwoordigt een specifieke paginanummerindex die wordt gebruikt bij het renderen van een subset van pagina’s.

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

V: Waarom is renderen traag voor grote documenten?
A: Grote bestanden vereisen meer verwerkingstijd. Verbeter de snelheid door alleen benodigde pagina’s te renderen, externe resources te gebruiken, de JVM‑heap te vergroten en asynchrone verwerking in te schakelen.

V: Hoe kan ik de voortgang van het renderen monitoren?
A: Hoewel GroupDocs Viewer geen ingebouwde callbacks heeft, kun je de bewerking timen met System.nanoTime() vóór en na viewer.view() om de duur te loggen.

V: Wat gebeurt er als het brondocument corrupt is?
A: De bibliotheek gooit een ViewerException. Plaats de aanroep in een try‑catch‑blok en log de fout voor een soepele degradatie.

V: Kan ik GroupDocs Viewer gebruiken in een commerciële applicatie?
A: Ja, maar een commerciële licentie is vereist. De gratis proefversie bevat watermerken die verwijderd moeten worden voor productiegebruik.

V: Zijn er gebruikslimieten?
A: De bibliotheek zelf legt geen limieten op, hoewel je licentieovereenkomst gebruikslimieten kan definiëren. Bekijk je contract voor details.

V: Kan ik applicaties die GroupDocs Viewer bevatten herdistribueren?
A: Je mag je eigen applicatie distribueren, maar je mag de GroupDocs‑bibliotheekbinaries zelf niet herdistribueren. Controleer de licentievoorwaarden voor naleving.

Volgende stappen en geavanceerde onderwerpen

Je hebt nu een solide basis voor convert word to html met behoud van opmerkingen. Hier zijn enkele richtingen om je expertise te verdiepen:

1. Watermarking – voeg aangepaste watermerken toe aan gerenderde pagina’s voor branding of vertrouwelijkheid.
2. Metadata‑extractie – haal auteur, aanmaakdatum en paginatelling op via viewer.getDocumentInfo().
3. Aangepaste viewers – bouw gespecialiseerde viewers voor PDF’s, spreadsheets of presentaties die opmerkingen anders verbergen of benadrukken.
4. Integratie met cloudopslag – render bestanden direct vanuit AWS S3, Azure Blob of Google Drive zonder ze lokaal te downloaden.

Aanbevolen leerpad

1. Experimenteer met verschillende bestandstypen – probeer Excel-, PowerPoint- en PDF‑bestanden om te zien hoe opmerkingen worden behandeld in verschillende formaten.
2. Bouw een eenvoudige webviewer – maak een minimale HTML‑pagina die de gegenereerde HTML laadt via een <iframe> of AJAX.
3. Verken het GroupDocs‑ecosysteem – bekijk GroupDocs Annotation, Comparison en Signature voor end‑to‑end document‑workflows.
4. Word lid van de community – neem deel aan het GroupDocs Forum voor tips, voorbeeldprojecten en ondersteuning.

Hulp en ondersteuning krijgen

Officiële bronnen

• GroupDocs.Viewer Documentatie
• API‑referentie
• Supportforum
• GitHub‑voorbeelden

Community‑bronnen

• Stack Overflow (tag: groupdocs-viewer)
• Reddit‑programmeergemeenschappen
• Java‑ontwikkelaar Discord‑servers

Laatst bijgewerkt: 2026-05-21
Getest met: 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());
}

Gerelateerde tutorials

• Word‑tracked changes weergeven in Word‑documenten met GroupDocs.Viewer voor Java
• Responsieve HTML-rendering met GroupDocs.Viewer voor Java: een uitgebreide gids
• Hoe documenten te laden en renderen als HTML met GroupDocs.Viewer voor Java