GroupDocs Viewer Java oktató: Word konvertálása HTML-re és dokumentumok megjelenítése megjegyzésekkel

Bevezetés

Ha Word konvertálásra HTML-re van szükséged, miközben minden lektor megjegyzését, kommentjét vagy annotációját meg akarod tartani, a megfelelő helyen jársz. Sok Java fejlesztő akadályba ütközik, amikor a dokumentumkonverzió eltávolítja az eredeti fájlba ágyazott értékes visszajelzéseket. Ez az oktató végigvezet a GroupDocs Viewer for Java használatán, hogy Word‑t HTML‑re konvertálj, és számos dokumentumtípust – Word, Excel, PowerPoint, PDF és egyebek – jeleníts meg anélkül, hogy a komment adatokat elveszítenéd.

Dokumentumok megjelenítése megjegyzésekkel a GroupDocs.Viewer for Java segítségével

Dokumentumok megjelenítése megjegyzésekkel a GroupDocs.Viewer for Java segítségével

Amit ebben az oktatóban elsajátítasz:

  • Teljes GroupDocs Viewer beállítás és konfiguráció
  • Lépésről‑lépésre Word konvertálása HTML-re a kommentek megőrzésével
  • Gyakori hibakeresési megoldások és elkerülendő csapdák
  • Valós példák implementációs minták és legjobb gyakorlatok
  • Teljesítményoptimalizálási technikák termelési környezethez

Gyors válaszok

  • Tud a GroupDocs Viewer Word‑t HTML‑re konvertálni? Igen—egyetlen kódsorral engedélyezheted a HTML renderelést és a komment támogatást.
  • Megmaradnak a kommentek a HTML kimenetben? Teljesen—setRenderComments(true) megőrzi minden kommentet és annotációt.
  • Milyen Java verzió szükséges? JDK 8 vagy újabb.
  • Szükséges licenc a termeléshez? A teljes licenc eltávolítja a vízjeleket és feloldja az összes funkciót.
  • Hogyan javítható a renderelés sebessége? Renderelj konkrét oldalakat, használj külső erőforrásokat, és növeld a JVM heap méretét.

Mi az a “Word konvertálása HTML-re” kommentekkel?

„Word konvertálása HTML-re” azt jelenti, hogy egy Microsoft Word .docx fájlt web‑kész HTML dokumentummá alakítunk, miközben megőrzük az eredeti elrendezést, a stílusokat és a beágyazott kommenteket. Ez a folyamat lehetővé teszi, hogy a böngészők pontosan úgy jelenítsék meg a dokumentumot, ahogy a szerzők szánták, a lektori visszajelzésekkel együtt.

Miért válasszuk a GroupDocs Viewer for Java‑t?

Mielőtt a kódba merülnénk, nézzük meg, miért a GroupDocs Viewer a legjobb könyvtár a Java‑alapú dokumentumrendereléshez:

  • 170+ támogatott formátum – a könyvtár mindent kezel a DOCX‑től a CAD fájlokig, egyetlen függőséget biztosítva minden konverziós igényhez.
  • Nincs szükség harmadik fél Office telepítésére – bármilyen operációs rendszeren működik Microsoft Office, LibreOffice vagy más nehéz futtatókörnyezet nélkül.
  • Megőrzi a formázást és az annotációkat – a kommentek, lábjegyzetek és a változtatások nyomon követése érintetlenül maradnak a konverzió során.
  • Gyors, könnyű motor – egy tipikus 100 oldalas dokumentum kevesebb, mint 2 másodperc alatt renderelődik egy szabványos 4‑magos szerveren.
  • Robusztus dokumentáció és aktív közösség – példákat, fórumokat és gyors támogatást találsz, ha elakadsz.

Mikor használjuk ezt a megközelítést

  • Web‑alapú dokumentumnézők építése, amelyeknek lektori megjegyzéseket kell megjeleníteniük
  • Együttműködő felülvizsgálati platformok létrehozása, ahol a visszajelzésnek láthatónak kell maradnia
  • Örökölt szerződések konvertálása online megjelenítésre jogi portálokban
  • E‑learning megoldások fejlesztése, amelyek az oktató kommentjeit ágyazzák be a tananyagra

Előfeltételek és környezet beállítása

Amire szükséged lesz

  • Java Development Kit (JDK) 8+ – a futtatókörnyezet, amely az alkalmazásodat hajtja.
  • Maven 3.6+ – a függőségek kezeléséhez és a projekt építéséhez.
  • A választott IDE – IntelliJ IDEA, Eclipse vagy VS Code.
  • Minta dokumentumok kommentekkel – DOCX, XLSX, PPTX fájlok, amelyek lektori megjegyzéseket tartalmaznak.

Fejlesztői környezet beállítása

1. lépés: Java telepítés ellenőrzése

Nyiss egy terminált és futtasd:

java -version

A verziószámnak 1.8 vagy annál magasabb értékkel kell kezdődnie. Ha nem, töltsd le a legújabb JDK‑t a hivatalos Oracle vagy OpenJDK weboldalról.

2. lépés: Maven telepítés ellenőrzése

Futtasd:

mvn -v

A Maven‑nek jelentenie kell a verzióját és a használt Java verziót. Telepíts Maven‑t az Apache weboldaláról, ha a parancs nem ismerhető.

3. lépés: Új Maven projekt létrehozása

Generálj egy váz projektet a következővel:

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

Lépj be az újonnan létrehozott viewer-demo mappába, és készen állsz a GroupDocs Viewer hozzáadására.

GroupDocs.Viewer beállítása Java‑hoz

Függőség hozzáadása

Az első lépés minden GroupDocs Viewer Java oktatóban a könyvtár projektbe való beillesztése. Add hozzá ezt a konfigurációt a pom.xml fájlodhoz:

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

Pro tipp: Mindig ellenőrizd a GroupDocs kiadási oldalt a legújabb verzióért. A könyvtár aktívan karbantartott, rendszeres frissítésekkel és hibajavításokkal.

Licencelési lehetőségek megértése

GroupDocs rugalmas licencelést kínál, amely különböző projektigényekhez illeszkedik:

  • Ingyenes próba (Tökéletes a tanuláshoz): 30 napos értékelés teljes funkcióhozzáféréssel és értékelési vízjelekkel.
  • Ideiglenes licenc (Fejlesztéshez): Kiterjesztett értékelés vízjelek nélkül; ideális proof‑of‑concept projektekhez. Kérvényezhető a GroupDocs Ideiglenes Licenc oldalán.
  • Teljes licenc (Termelésre kész): Nincs korlátozás vagy vízjel, kereskedelmi használat engedélyezett. Elérhető a GroupDocs vásárlási oldalon.

Alap inicializációs minta

Itt van az alapvető minta, amelyet az egész oktató során használni fogsz:

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

Miért működik ez a minta:

  • Automatikus erőforrás-kezelés megakadályozza a memória szivárgásokat.
  • Kivételkezelés elkapja a gyakori fájlhozzáférési problémákat.
  • Tiszta, olvasható kód, amely nagy projektekben is könnyen karbantartható.

Alap implementáció: Dokumentumok renderelése kommentekkel

A folyamat megértése

Amikor egy dokumentumot renderelsz a GroupDocs Viewer‑rel, a könyvtár négy kulcsfontosságú lépést hajt végre:

  1. Dokumentumelemzés – beolvassa a bemeneti fájlt és belső reprezentációt épít.
  2. Komment kivonás – azonosít minden kommentet, lábjegyzetet és annotációt.
  3. HTML generálás – tiszta, szabványos HTML‑t hoz létre, amely tükrözi az eredeti elrendezést.
  4. Erőforráskezelés – képeket, CSS‑t és betűtípusokat csomagol be, akár beágyazottan, akár külső fájlként.

Lépésről‑lépésre implementáció

1. lépés: Fájl útvonalak beállítása

Rendezd el a bemeneti és kimeneti helyeket már a kezdetekkor, hogy elkerüld az útvonalakkal kapcsolatos hibákat:

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

Miért ez a megközelítés:

  • Modern Java NIO.2 Path API-t használ, amely megbízhatóbb, mint a java.io.File.
  • Leíró változónevek segítik a hibakeresést.
  • Az output mintában lévő {0} helyőrző automatikusan a lap számával lesz helyettesítve.

2. lépés: HTML renderelési beállítások konfigurálása

Itt történik a varázslat. Megmondjuk a GroupDocs‑nek, pontosan hogyan szeretnénk a dokumentumot renderelni:

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

Kulcsfontosságú konfigurációs részletek:

  • forEmbeddedResources() beágyazza a CSS‑t, képeket és betűtípusokat közvetlenül a HTML‑be, így a kimenet hordozható.
  • setRenderComments(true) az egyetlen sor, amely biztosítja, hogy a Word konvertálása HTML-re megtartja az összes lektori megjegyzést.
  • Az alternatív forExternalResources() lehetővé teszi az eszközök külön tárolását, ha egy könnyebb HTML fájlt szeretnél.

3. lépés: Renderelés végrehajtása

Most mindent összehozzuk:

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

A view hívás beolvassa a Word fájlt, kinyeri a kommenteket, HTML oldalakat generál, és a output/html könyvtárba írja őket. Minden oldal page_1.html, page_2.html stb. néven kerül mentésre.

Teljes működő példa

Az összes részlet összeállításával egyetlen, futtatható osztályt kapsz, amely Word dokumentumot konvertál HTML‑re, miközben a kommenteket érintetlenül hagyja. (A teljes forráskód elérhető a hivatalos GitHub tárolóban.)

Haladó konfiguráció és beállítások

Dinamikus kimeneti könyvtárak beállítása

Nagyobb alkalmazásoknál érdemes lehet a kimeneti könyvtárakat felhasználói azonosítók vagy időbélyegek alapján generálni:

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

Gyakori problémák és hibakeresés

1. probléma: „File Not Found” hibák

Győződj meg arról, hogy a bemeneti útvonal abszolút vagy a munkakönyvtárhoz relatív, és ellenőrizd a fájl jogosultságait. A Path objektumok használata segít elkerülni a gyakori karakterlánc‑összefűzési hibákat.

2. probléma: A kommentek nem jelennek meg a kimenetben

Ellenőrizd, hogy a setRenderComments(true) a viewer.view() előtt van meghívva. Továbbá győződj meg arról, hogy a forrásdokumentum valóban tartalmaz kommenteket; ezeket a viewer.getDocumentInfo().getComments() segítségével ellenőrizheted.

3. probléma: Memóriahiány hibák nagy dokumentumoknál

A GroupDocs Viewer adatfolyamot használ, de a rendkívül nagy fájlok (> 500 oldal) még mindig megterhelhetik a JVM heap‑et. Növeld a heap méretét -Xmx4g‑val, vagy csak a szükséges oldalakat rendereld.

4. probléma: Lassú renderelési teljesítmény

Renderelj konkrét oldaltartományokat a viewer.view(pageRange, viewOptions) használatával. A külső erőforrások (forExternalResources()) szintén csökkentik a HTML terhelés méretét, felgyorsítva a böngésző renderelését.

Valós példák implementációs minták

Minta 1: Webalkalmazás integráció

Integráld a renderelési logikát egy Spring Boot controllerbe, hogy igény szerint szolgálj ki HTML‑t:

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

Minta 2: Tömeges feldolgozás több dokumentummal

Ha egy egész mappát kell konvertálni Word fájlokból, iterálj a könyvtáron, és használd újra ugyanazt a HtmlViewOptions példányt, hogy minimalizáld az objektum létrehozás költségét.

Teljesítményoptimalizálás és legjobb gyakorlatok

Memóriakezelési tippek

  • Mindig használj try‑with‑resources‑t a Viewer példányokhoz.
  • Nagy dokumentumokat batch‑ekben dolgozz fel ahelyett, hogy egyszerre mindent a memóriába töltenél.
  • Figyeld a JVM heap használatát olyan eszközökkel, mint a VisualVM, és szükség szerint állítsd be a -Xmx‑et.
  • Alkalmazz megfelelő gyorsítótárazást a gyakran elérhető dokumentumoknál, hogy elkerüld az ismételt renderelést.

Erőforrás használati irányelvek

Kis alkalmazásokhoz (< 100 dokumentum/nap):

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

Nagy forgalmú alkalmazásokhoz (1000+ dokumentum/nap):

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

Gyorsítótárazási stratégiák

Tárold a renderelt HTML‑t egy elosztott gyorsítótárban (pl. Redis), a dokumentum hash‑e alapján kulcsként. Amikor egy kérés érkezik, először ellenőrizd a gyorsítótárat; ha találat van, azonnal szolgáld ki a gyorsítótárból származó HTML‑t, megkerülve a renderelő motort.

Mikor használjuk a GroupDocs Viewer‑t alternatívákkal szemben

A GroupDocs Viewer ideális a következőkre

  • Dokumentumkezelő rendszerek – sok fájltípus megjelenítése annotációkkal.
  • Együttműködő felülvizsgálati platformok – a kommenteknek minden résztvevő számára láthatónak kell maradniuk.
  • Oktatási eszközök – az oktatók megjegyzései a diák mellett jelennek meg.
  • Jogi alkalmazások – a jogi megjegyzésekkel ellátott szerződések hiteles renderelése szükséges.

Alternatívákat érdemes fontolóra venni, ha

  • Egyszerű PDF megjelenítés – a natív böngésző PDF megjelenítők elegendőek lehetnek.
  • Alapvető kép konvertálás – az ImageIO vagy hasonló könyvtárak könnyebbek.
  • Tiszta szövegkinyerés – az Apache POI vagy iText lehet megfelelőbb.

Gyakran ismételt kérdések

K: Renderelhetek dokumentumokat kommentek nélkül?
Igen—egyszerűen hagyd ki a setRenderComments(true) hívást, vagy állítsd false‑ra.

K: Mely fájlformátumok támogatják a komment renderelést?
A legtöbb fő formátum—beleértve a DOC/DOCX, XLS/XLSX, PPT/PPTX, PDF és sok más. Lásd a hivatalos dokumentációt a teljes listáért.

K: Testreszabhatom a HTML kimenet stílusát?
Természetesen. Használd a HtmlViewOptions.setEmbedResources(false)‑t külső CSS fájlok generálásához, majd a renderelés után add hozzá a saját stíluslapodat.

K: Hogyan kezelem a jelszóval védett dokumentumokat?
Adj meg egy LoadOptions példányt a jelszóval:

LoadOptions lehetővé teszi a dokumentum betöltési paramétereinek, például a jelszavak, megadását.

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

K: Lehetséges csak bizonyos oldalakat renderelni?
Igen—használd a túlterhelt view metódust, amely PageNumber gyűjteményt fogad:

PageNumber egy adott oldal indexet jelöl, amelyet az oldalak részhalmazának renderelésekor használsz.

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

K: Miért lassú a renderelés nagy dokumentumoknál?
A nagy fájlok több feldolgozási időt igényelnek. Növeld a sebességet úgy, hogy csak a szükséges oldalakat rendereled, külső erőforrásokat használsz, növeled a JVM heap‑et, és engedélyezed az aszinkron feldolgozást.

K: Hogyan követhetem a renderelés előrehaladását?
Bár a GroupDocs Viewer nem rendelkezik beépített visszahívásokkal, időzítheted a műveletet a System.nanoTime()‑val a viewer.view() előtt és után, hogy naplózd a időtartamot.

K: Mi történik, ha a forrásdokumentum sérült?
A könyvtár ViewerException‑t dob. Tedd a hívást try‑catch blokkba, és naplózd a hibát a graceful degradation érdekében.

K: Használhatom a GroupDocs Viewer‑t kereskedelmi alkalmazásban?
Igen, de kereskedelmi licenc szükséges. Az ingyenes próba vízjeleket tartalmaz, amelyeket a termelési használat előtt el kell távolítani.

K: Vannak használati korlátok?
Maga a könyvtár nem szab korlátot, bár a licencszerződés meghatározhat használati korlátokat. Tekintsd át a szerződésed részleteit.

K: Átadhatok olyan alkalmazásokat, amelyek tartalmazzák a GroupDocs Viewer‑t?
Saját alkalmazásodat terjesztheted, de a GroupDocs könyvtár binárisait magukat nem terjesztheted. Ellenőrizd a licencfeltételeket a megfelelőség érdekében.

Következő lépések és haladó témák

Most már szilárd alapjaid vannak a Word konvertálására HTML-re a kommentek megőrzésével. Íme néhány irány, hogy mélyítsd a tudásodat:

  • Vízjelezés – egyedi vízjelek hozzáadása a renderelt oldalakhoz márka vagy titoktartás céljából.
  • Metaadat kinyerés – szerző, létrehozás dátuma és oldalszám lekérése a viewer.getDocumentInfo() segítségével.
  • Egyedi nézők – speciális nézők építése PDF‑ekhez, táblázatokhoz vagy prezentációkhoz, amelyek másként rejtenek vagy emelik ki a kommenteket.
  • Felhő tároló integráció – fájlok renderelése közvetlenül az AWS S3‑ról, Azure Blob‑ról vagy Google Drive‑ról anélkül, hogy helyileg letöltenéd őket.

Ajánlott tanulási útvonal

  1. Kísérletezz különböző fájltípusokkal – próbálj ki Excel, PowerPoint és PDF fájlokat, hogy lásd, hogyan kezelik a kommenteket a különböző formátumok.
  2. Építs egy egyszerű webes nézőt – hozz létre egy minimális HTML oldalt, amely az <iframe> vagy AJAX segítségével tölti be a generált HTML‑t.
  3. Fedezd fel a GroupDocs ökoszisztémát – nézd meg a GroupDocs Annotation, Comparison és Signature termékeket a teljes dokumentumfolyamatokhoz.
  4. Csatlakozz a közösséghez – vegyél részt a GroupDocs Fórumon tippekért, mintaprojektekért és támogatásért.

Segítség és támogatás

Hivatalos erőforrások

Közösségi erőforrások

  • Stack Overflow (címke: groupdocs-viewer)
  • Reddit programozási közösségek
  • Java fejlesztői Discord szerverek

Utolsó frissítés: 2026-05-21
Tesztelve a következővel: GroupDocs.Viewer 25.2 for Java
Szerző: 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());
}

Kapcsolódó oktatóanyagok