GroupDocs Viewer Java Návod: Převod Wordu do HTML a vykreslení dokumentů s komentáři

Úvod

Pokud potřebujete převést Word do HTML a zároveň zachovat každou poznámku, komentář nebo anotaci recenzenta, jste na správném místě. Mnoho vývojářů v Javě narazí na problém, když konverze dokumentů odstraní cennou zpětnou vazbu vloženou v původním souboru. Tento návod vás provede používáním GroupDocs Viewer pro Java k převodu Wordu do HTML a vykreslení široké škály typů dokumentů – Word, Excel, PowerPoint, PDF a další – aniž by se ztratila jakákoli data o komentářích.

Zjistíte, proč je GroupDocs Viewer připravenou volbou pro produkci, jak nastavit prostředí, jaký kód potřebujete, a osvědčené triky, jak udržet výkon rychlý i u velkých souborů.

Vykreslení dokumentů s komentáři pomocí GroupDocs.Viewer pro Java

Render Documents with Comments with GroupDocs.Viewer for Java

Co se v tomto návodu naučíte:

  • Kompletní nastavení a konfigurace GroupDocs Viewer
  • Krok za krokem převést Word do HTML se zachovanými komentáři
  • Běžná řešení problémů a tipy, kterým se vyhnout
  • Reálné implementační vzory a osvědčené postupy
  • Techniky optimalizace výkonu pro produkční použití

Rychlé odpovědi

  • Umí GroupDocs Viewer převést Word do HTML? Ano—povolte vykreslování HTML a podporu komentářů jedním řádkem kódu.
  • Zůstávají komentáře ve výstupu HTML? Naprosto—setRenderComments(true) zachovává každý komentář a anotaci.
  • Jaká verze Javy je požadována? JDK 8 nebo vyšší.
  • Je pro produkci potřeba licence? Plná licence odstraňuje vodoznaky a odemyká všechny funkce.
  • Jak zlepšit rychlost vykreslování? Vykreslete konkrétní stránky, použijte externí zdroje a zvětšete velikost haldy JVM.

Co je „převod word do html“ s komentáři?

„Convert Word to HTML“ znamená převod souboru Microsoft Word .docx na web‑připravený HTML dokument při zachování původního rozvržení, stylování a všech vložených komentářů. Tento proces umožňuje prohlížečům zobrazit dokument přesně tak, jak jej autoři zamýšleli, včetně zpětné vazby recenzentů.

Proč zvolit GroupDocs Viewer pro Java?

Než se ponoříme do kódu, podívejme se, proč je GroupDocs Viewer knihovnou číslo jedna pro vykreslování dokumentů v Javě:

  • 170+ podporovaných formátů – knihovna zvládne vše od DOCX po CAD soubory, poskytuje vám jedinou závislost pro všechny vaše potřeby konverze.
  • Žádná instalace třetí strany Office – funguje na jakémkoli OS bez potřeby Microsoft Office, LibreOffice nebo jiných těžkých runtime.
  • Zachovává formátování a anotace – komentáře, poznámky pod čarou a sledování změn přežijí konverzi nedotčeny.
  • Rychlý, lehký engine – typické 100‑stránkové dokumenty se vykreslí za méně než 2 sekundy na standardním 4‑jádrovém serveru.
  • Robustní dokumentace a aktivní komunita – najdete příklady, fóra a rychlou podporu, kdykoli narazíte na problém.

Kdy použít tento přístup

  • Vytváření webových prohlížečů dokumentů, které potřebují zobrazovat poznámky recenzentů
  • Vytváření kolaborativních recenzních platforem, kde musí být zpětná vazba viditelná
  • Převod starých smluv pro online zobrazení v právních portálech
  • Vývoj e‑learning řešení, která vkládají komentáře instruktorů do studijního materiálu

Předpoklady a nastavení prostředí

Co budete potřebovat

  • Java Development Kit (JDK) 8+ – runtime, který napájí vaši aplikaci.
  • Maven 3.6+ – pro správu závislostí a sestavení projektu.
  • IDE dle vašeho výběru – IntelliJ IDEA, Eclipse nebo VS Code.
  • Ukázkové dokumenty s komentáři – soubory DOCX, XLSX, PPTX, které obsahují poznámky recenzentů.

Nastavení vývojového prostředí

Krok 1: Ověření instalace Javy

Otevřete terminál a spusťte:

java -version

Krok 2: Kontrola instalace Maven

Spusťte:

mvn -v

Krok 3: Vytvoření nového Maven projektu

Vygenerujte kostru projektu pomocí:

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

Přejděte do nově vytvořené složky viewer-demo a jste připraveni přidat GroupDocs Viewer.

Nastavení GroupDocs.Viewer pro Java

Přidání závislosti

Prvním krokem v jakémkoli návodu GroupDocs Viewer pro Java je získání knihovny do vašeho projektu. Přidejte tuto konfiguraci do souboru pom.xml:

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

Tip: Vždy zkontrolujte stránku vydání GroupDocs pro nejnovější verzi. Knihovna je aktivně udržována s pravidelnými aktualizacemi a opravami chyb.

Porozumění licenčním možnostem

GroupDocs nabízí flexibilní licencování, které vyhovuje různým potřebám projektů:

  • Free Trial (Perfektní pro učení): 30‑denní hodnocení s plným přístupem ke všem funkcím a evaluačními vodoznaky.
  • Temporary License (Pro vývoj): Rozšířené hodnocení bez vodoznaků; ideální pro proof‑of‑concept projekty. Požádejte na GroupDocs Temporary License Page.
  • Full License (Produkčně připravená): Žádná omezení ani vodoznaky, komerční použití povoleno. Dostupná na GroupDocs Purchase Page.

Základní inicializační vzor

Zde je základní vzor, který budete během tohoto návodu používat:

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

Proč tento vzor funguje:

  • Automatická správa zdrojů zabraňuje únikům paměti.
  • Zpracování výjimek zachytává běžné problémy s přístupem k souborům.
  • Čistý, čitelný kód, který je snadno udržovatelný v rozsáhlých projektech.

Hlavní implementace: Vykreslování dokumentů s komentáři

Porozumění procesu

Když vykreslíte dokument pomocí GroupDocs Viewer, knihovna provede čtyři klíčové kroky:

  1. Analýza dokumentu – parsuje vstupní soubor a vytváří interní reprezentaci.
  2. Extrahování komentářů – identifikuje každý komentář, poznámku pod čarou a anotaci.
  3. Generování HTML – vytváří čisté, standardy dodržující HTML, které odráží původní rozvržení.
  4. Zpracování zdrojů – balí obrázky, CSS a fonty buď inline, nebo jako externí soubory.

Implementace krok za krokem

Krok 1: Nastavení cest k souborům

Uspořádejte vstupní a výstupní umístění již na začátku, abyste se vyhnuli chybám souvisejícím s cestami:

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

Proč tento přístup:

  • Používá moderní Java NIO.2 Path API, které je spolehlivější než java.io.File.
  • Popisné názvy proměnných usnadňují ladění.
  • Zástupný znak {0} ve výstupním vzoru je automaticky nahrazen čísly stránek.

Krok 2: Konfigurace možností vykreslování HTML

Zde se děje kouzlo. Řekneme GroupDocs přesně, jak chceme dokument vykreslit:

HtmlViewOptions konfiguruje, jak je dokument vykreslen do HTML, včetně zpracování zdrojů a vykreslování komentářů.

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

Klíčové detaily konfigurace:

  • forEmbeddedResources() vkládá CSS, obrázky a fonty přímo do HTML, což činí výstup přenosným.
  • setRenderComments(true) je jediný řádek, který zajišťuje, že převod word do html zachová všechny poznámky recenzentů.
  • Alternativa forExternalResources() vám umožní uložit zdroje odděleně, pokud preferujete štíhlejší HTML soubor.

Krok 3: Spuštění vykreslování

Nyní spojíme vše dohromady:

Viewer je hlavní třída používaná k načtení dokumentu a provádění operací vykreslování.

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

Volání view načte soubor Word, extrahuje komentáře, vygeneruje HTML stránky a zapíše je do output/html. Každá stránka je uložena jako page_1.html, page_2.html atd.

Kompletní funkční příklad

Spojením všech částí získáte jedinou spustitelnou třídu, která převádí dokument Word do HTML a zachovává komentáře nedotčeny. (Plný zdrojový kód je k dispozici v oficiálním repozitáři na GitHubu.)

Pokročilá konfigurace a možnosti

Nastavení dynamických výstupních adresářů

Pro větší aplikace můžete chtít generovat výstupní adresáře na základě ID uživatelů nebo časových razítek:

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

Běžné problémy a řešení

Problém 1: Chyby „Soubor nenalezen“

Ujistěte se, že vstupní cesta je absolutní nebo relativní k pracovnímu adresáři, a ověřte oprávnění k souborům. Použití objektů Path pomáhá vyhnout se běžným chybám při spojování řetězců.

Problém 2: Komentáře se neobjevují ve výstupu

Dvojitě zkontrolujte, že setRenderComments(true) je voláno před viewer.view(). Také se ujistěte, že zdrojový dokument skutečně obsahuje komentáře; můžete je prohlédnout pomocí viewer.getDocumentInfo().getComments().

Problém 3: Chyby nedostatku paměti u velkých dokumentů

GroupDocs Viewer streamuje data, ale extrémně velké soubory (> 500 stránek) mohou stále zatížit haldu JVM. Zvětšete velikost haldy pomocí -Xmx4g nebo vykreslujte jen potřebné stránky.

Problém 4: Pomalejší výkon vykreslování

Vykreslete konkrétní stránky pomocí viewer.view(pageRange, viewOptions). Externí zdroje (forExternalResources()) také snižují velikost HTML, což urychluje vykreslování v prohlížeči.

Reálné implementační vzory

Vzor 1: Integrace webové aplikace

Integrujte logiku vykreslování do Spring Boot kontroleru, který bude poskytovat HTML na požádání:

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

Vzor 2: Dávkové zpracování více dokumentů

Když potřebujete převést celou složku Word souborů, projděte adresář a znovu použijte stejnou instanci HtmlViewOptions, abyste minimalizovali režii vytváření objektů.

Optimalizace výkonu a osvědčené postupy

Tipy pro správu paměti

  • Vždy používejte try‑with‑resources pro instance Viewer.
  • Zpracovávejte velké dokumenty po dávkách místo načítání všeho najednou do paměti.
  • Monitorujte využití haldy JVM pomocí nástrojů jako VisualVM a upravujte -Xmx podle potřeby.
  • Implementujte správné cachování pro často přistupované dokumenty, aby se předešlo opakovanému vykreslování.

Pokyny pro využití zdrojů

Pro malé aplikace (< 100 dokumentů/den):

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

Pro aplikace s vysokým objemem (1000+ dokumentů/den):

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

Strategie cachování

Ukládejte vykreslené HTML do distribuované cache (např. Redis) s klíčem založeným na hash dokumentu. Když přijde požadavek, nejprve zkontrolujte cache; pokud je zásah, okamžitě servírujte cachované HTML a obejděte vykreslovací engine.

Kdy použít GroupDocs Viewer vs alternativy

GroupDocs Viewer je ideální pro

  • Systémy pro správu dokumentů – potřebují zobrazovat mnoho typů souborů s anotacemi.
  • Kolaborativní recenzní platformy – komentáře musí být viditelné pro všechny účastníky.
  • Vzdělávací nástroje – poznámky instruktorů se zobrazují vedle prezentačních slidů.
  • Právní aplikace – smlouvy s komentáři právníků vyžadují věrné vykreslení.

Zvažte alternativy, když

  • Jednoduché zobrazení PDF – nativní prohlížečové PDF prohlížeče mohou stačit.
  • Základní konverze obrázků – ImageIO nebo podobné knihovny jsou lehčí.
  • Čisté získávání textu – Apache POI nebo iText mohou být vhodnější.

Často kladené otázky

Q: Mohu vykreslovat dokumenty bez komentářů?
Ano—jednoduše vynechejte volání setRenderComments(true) nebo jej nastavte na false.

Q: Jaké formáty souborů podporují vykreslování komentářů?
Většina hlavních formátů—včetně DOC/DOCX, XLS/XLSX, PPT/PPTX, PDF a mnoha dalších. Viz oficiální dokumentace pro kompletní seznam.

Q: Mohu přizpůsobit stylování výstupního HTML?
Rozhodně. Použijte HtmlViewOptions.setEmbedResources(false) k vygenerování externích CSS souborů a poté po vykreslení přidejte vlastní stylový list.

Q: Jak zacházet s dokumenty chráněnými heslem?
Poskytněte instanci LoadOptions s heslem:

LoadOptions vám umožňuje specifikovat parametry načítání dokumentu, jako jsou hesla.

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

Q: Je možné vykreslit pouze konkrétní stránky?
Ano—použijte přetíženou metodu view, která přijímá kolekci PageNumber:

PageNumber představuje konkrétní index stránky používaný při vykreslování podmnožiny stránek.

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

Q: Proč je vykreslování pomalé u velkých dokumentů?
Velké soubory vyžadují více času na zpracování. Zrychlete tím, že budete vykreslovat jen potřebné stránky, použijete externí zdroje, zvětšíte haldu JVM a povolíte asynchronní zpracování.

Q: Jak mohu sledovat průběh vykreslování?
I když GroupDocs Viewer postrádá vestavěné zpětné volání, můžete měřit dobu operace pomocí System.nanoTime() před a po viewer.view() a zaznamenat dobu.

Q: Co se stane, pokud je zdrojový dokument poškozený?
Knihovna vyhodí ViewerException. Zabalte volání do try‑catch bloku a zaznamenejte chybu pro elegantní degradaci.

Q: Mohu použít GroupDocs Viewer v komerční aplikaci?
Ano, ale je vyžadována komerční licence. Bezplatná zkušební verze obsahuje vodoznaky, které je třeba odstranit pro produkční použití.

Q: Existují nějaká omezení používání?
Knihovna sama o sobě neklade žádná omezení, i když vaše licenční smlouva může definovat limity používání. Prohlédněte si smlouvu pro podrobnosti.

Q: Mohu redistribuovat aplikace, které zahrnují GroupDocs Viewer?
Můžete distribuovat svou vlastní aplikaci, ale nesmíte redistribuovat samotné binární soubory knihovny GroupDocs. Zkontrolujte licenční podmínky pro soulad.

Další kroky a pokročilá témata

Nyní máte solidní základ pro převod word do html při zachování komentářů. Zde je několik směrů, jak prohloubit své znalosti:

  • Watermarking – přidejte vlastní vodoznaky na vykreslené stránky pro branding nebo důvěrnost.
  • Extrahování metadat – získávejte autora, datum vytvoření a počet stránek pomocí viewer.getDocumentInfo().
  • Vlastní prohlížeče – vytvořte specializované prohlížeče pro PDF, tabulky nebo prezentace, které skryjí nebo zvýrazní komentáře jinak.
  • Integrace cloudového úložiště – vykreslujte soubory přímo z AWS S3, Azure Blob nebo Google Drive bez lokálního stahování.

Doporučená cesta učení

  1. Experimentujte s různými typy souborů – vyzkoušejte Excel, PowerPoint a PDF soubory, abyste viděli, jak jsou komentáře zpracovány napříč formáty.
  2. Vytvořte jednoduchý webový prohlížeč – vytvořte minimální HTML stránku, která načte vygenerované HTML pomocí <iframe> nebo AJAX.
  3. Prozkoumejte ekosystém GroupDocs – podívejte se na GroupDocs Annotation, Comparison a Signature pro kompletní workflow dokumentů.
  4. Připojte se ke komunitě – zapojte se do GroupDocs Forum pro tipy, ukázkové projekty a podporu.

Získání pomoci a podpory

Oficiální zdroje

Komunitní zdroje

  • Stack Overflow (tag: groupdocs-viewer)
  • Reddit programátorské komunity
  • Java vývojářské Discord servery

Poslední aktualizace: 2026-05-21
Testováno s: GroupDocs.Viewer 25.2 for Java
Autor: 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());
}

Související tutoriály