GroupDocs Viewer Java Tutorial: Word in HTML konvertieren und Dokumente mit Kommentaren rendern

Einführung

Wenn Sie Word in HTML konvertieren müssen, während Sie jede Anmerkung, jeden Kommentar oder jede Annotation des Prüfers beibehalten, sind Sie hier genau richtig. Viele Java‑Entwickler stoßen auf Probleme, wenn die Dokumentkonvertierung das wertvolle Feedback aus der Originaldatei entfernt. Dieses Tutorial führt Sie durch die Verwendung von GroupDocs Viewer für Java, um Word in HTML zu konvertieren und eine breite Palette von Dokumenttypen – Word, Excel, PowerPoint, PDF und mehr – zu rendern, ohne Kommentar‑Daten zu verlieren.

Sie erfahren, warum GroupDocs Viewer eine produktionsreife Wahl ist, wie Sie die Umgebung einrichten, welchen Code Sie benötigen, und bewährte Tricks, um die Leistung selbst bei großen Dateien flott zu halten.

Dokumente mit Kommentaren rendern mit GroupDocs.Viewer für Java

Dokumente mit Kommentaren rendern mit GroupDocs.Viewer für Java

Was Sie in diesem Tutorial lernen werden:

  • Vollständige Einrichtung und Konfiguration von GroupDocs Viewer
  • Schritt‑für‑Schritt Word in HTML konvertieren mit erhaltenen Kommentaren
  • Gemeinsame Fehlersuchlösungen und Stolperfallen, die zu vermeiden sind
  • Praxisnahe Implementierungsmuster und bewährte Verfahren
  • Leistungsoptimierungstechniken für den Produktionseinsatz

Schnelle Antworten

  • Kann GroupDocs Viewer Word in HTML konvertieren? Ja – aktivieren Sie das HTML‑Rendering und die Kommentarunterstützung in einer einzigen Codezeile.
  • Bleiben Kommentare im HTML‑Ausgabe erhalten? Absolut – setRenderComments(true) bewahrt jeden Kommentar und jede Annotation.
  • Welche Java‑Version wird benötigt? JDK 8 oder höher.
  • Wird für die Produktion eine Lizenz benötigt? Eine Voll‑Lizenz entfernt Wasserzeichen und schaltet alle Funktionen frei.
  • Wie lässt sich die Rendering‑Geschwindigkeit verbessern? Rendern Sie bestimmte Seiten, verwenden Sie externe Ressourcen und erhöhen Sie die JVM‑Heap‑Größe.

Was bedeutet „Word in HTML konvertieren“ mit Kommentaren?

„Word in HTML konvertieren“ bedeutet, eine Microsoft Word .docx‑Datei in ein web‑fertiges HTML‑Dokument zu verwandeln, wobei das ursprüngliche Layout, die Formatierung und alle eingebetteten Kommentare erhalten bleiben. Dieser Prozess ermöglicht es Browsern, das Dokument genau so darzustellen, wie die Autoren es beabsichtigt haben, inklusive des Feedbacks der Prüfer.

Warum GroupDocs Viewer für Java wählen?

Bevor wir in den Code eintauchen, schauen wir uns an, warum GroupDocs Viewer die bevorzugte Bibliothek für Java‑basiertes Dokument‑Rendering ist:

  • 170+ unterstützte Formate – die Bibliothek verarbeitet alles von DOCX bis CAD‑Dateien und bietet Ihnen eine einzige Abhängigkeit für alle Ihre Konvertierungsanforderungen.
  • Keine Drittanbieter‑Office‑Installation – sie funktioniert auf jedem Betriebssystem, ohne dass Microsoft Office, LibreOffice oder andere schwere Laufzeitumgebungen benötigt werden.
  • Erhält Formatierung und Anmerkungen – Kommentare, Fußnoten und Änderungen bleiben bei der Konvertierung unverändert erhalten.
  • Schnelle, leichte Engine – typische 100‑Seiten‑Dokumente werden in weniger als 2 Sekunden auf einem Standard‑4‑Kern‑Server gerendert.
  • Umfangreiche Dokumentation und aktive Community – Sie finden Beispiele, Foren und schnellen Support, wann immer Sie auf ein Problem stoßen.

Wann Sie diesen Ansatz verwenden sollten

  • Erstellung webbasierter Dokument‑Viewer, die Prüfer‑Notizen anzeigen müssen
  • Erstellung kollaborativer Review‑Plattformen, bei denen Feedback sichtbar bleiben muss
  • Konvertierung von Altverträgen für die Online‑Anzeige in Rechtsportalen
  • Entwicklung von E‑Learning‑Lösungen, die Kommentare von Dozenten im Lernmaterial einbetten

Voraussetzungen und Umgebungseinrichtung

Was Sie benötigen

  • Java Development Kit (JDK) 8+ – die Laufzeit, die Ihre Anwendung antreibt.
  • Maven 3.6+ – für das Abhängigkeitsmanagement und den Build des Projekts.
  • IDE Ihrer Wahl – IntelliJ IDEA, Eclipse oder VS Code.
  • Beispieldokumente mit Kommentaren – DOCX-, XLSX‑, PPTX‑Dateien, die Prüfer‑Notizen enthalten.

Einrichtung Ihrer Entwicklungsumgebung

Schritt 1: Java‑Installation überprüfen

Öffnen Sie ein Terminal und führen Sie aus:

java -version

Sie sollten eine Versionszeichenkette sehen, die mit 1.8 oder höher beginnt. Falls nicht, laden Sie das neueste JDK von der offiziellen Oracle‑ oder OpenJDK‑Website herunter.

Schritt 2: Maven‑Installation überprüfen

Führen Sie aus:

mvn -v

Maven sollte seine Version und die verwendete Java‑Version ausgeben. Installieren Sie Maven von der Apache‑Website, falls der Befehl nicht erkannt wird.

Schritt 3: Neues Maven‑Projekt erstellen

Generieren Sie ein Skelettprojekt mit:

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

Wechseln Sie in den neu erstellten Ordner viewer-demo und Sie sind bereit, GroupDocs Viewer hinzuzufügen.

Einrichtung von GroupDocs.Viewer für Java

Hinzufügen der Abhängigkeit

Der erste Schritt in jedem GroupDocs Viewer Java Tutorial ist, die Bibliothek in Ihr Projekt zu bekommen. Fügen Sie diese Konfiguration zu Ihrer pom.xml‑Datei hinzu:

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

Pro Tipp: Überprüfen Sie stets die GroupDocs releases page für die neueste Version. Die Bibliothek wird aktiv gepflegt mit regelmäßigen Updates und Fehlerbehebungen.

Verständnis der Lizenzoptionen

GroupDocs bietet flexible Lizenzierung, die zu unterschiedlichen Projektanforderungen passt:

  • Kostenlose Testversion (Perfekt zum Lernen): 30‑tägige Evaluation mit vollem Funktionszugriff und Evaluations‑Wasserzeichen.
  • Temporäre Lizenz (Für Entwicklung): Erweiterte Evaluation ohne Wasserzeichen; ideal für Proof‑of‑Concept‑Projekte. Anfordern unter GroupDocs Temporary License Page.
  • Vollständige Lizenz (Produktionsbereit): Keine Einschränkungen oder Wasserzeichen, kommerzielle Nutzung erlaubt. Erhältlich unter GroupDocs Purchase Page.

Grundlegendes Initialisierungsmuster

Hier ist das grundlegende Muster, das Sie während dieses Tutorials verwenden werden:

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

Warum dieses Muster funktioniert:

  • Automatisches Ressourcen‑Management verhindert Speicherlecks.
  • Ausnahmebehandlung fängt häufige Datei‑Zugriffsprobleme ab.
  • Sauberer, lesbarer Code, der in großen Projekten leicht zu warten ist.

Kernimplementierung: Dokumente mit Kommentaren rendern

Verständnis des Prozesses

Wenn Sie ein Dokument mit GroupDocs Viewer rendern, führt die Bibliothek vier zentrale Schritte aus:

  1. Dokumentanalyse – analysiert die Eingabedatei und erstellt eine interne Darstellung.
  2. Kommentarextraktion – identifiziert jeden Kommentar, jede Fußnote und Annotation.
  3. HTML‑Generierung – erzeugt sauberes, standardkonformes HTML, das das ursprüngliche Layout widerspiegelt.
  4. Ressourcenverwaltung – bündelt Bilder, CSS und Schriftarten entweder inline oder als externe Dateien.

Schritt‑für‑Schritt‑Implementierung

Schritt 1: Dateipfade einrichten

Organisieren Sie Ihre Eingabe‑ und Ausgabepfade frühzeitig, um pfadbezogene Fehler zu vermeiden:

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

Warum dieser Ansatz:

  • Verwendet die moderne Java NIO.2 Path‑API, die zuverlässiger ist als java.io.File.
  • Aussagekräftige Variablennamen erleichtern das Debugging.
  • Der {0}‑Platzhalter im Ausgabemuster wird automatisch durch Seitenzahlen ersetzt.

Schritt 2: HTML‑Rendering‑Optionen konfigurieren

Hier passiert die Magie. Wir teilen GroupDocs exakt mit, wie das Dokument gerendert werden soll:

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

Wichtige Konfigurationsdetails:

  • forEmbeddedResources() bettet CSS, Bilder und Schriftarten direkt in das HTML ein, wodurch die Ausgabe portabel wird.
  • setRenderComments(true) ist die einzige Zeile, die sicherstellt, dass Word in HTML konvertieren alle Prüfer‑Notizen beibehält.
  • Alternativ ermöglicht forExternalResources() das separate Speichern von Assets, falls Sie eine schlankere HTML‑Datei bevorzugen.

Schritt 3: Rendering ausführen

Jetzt fügen wir alles zusammen:

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

Viewer ist die primäre Klasse, die zum Laden eines Dokuments und zum Ausführen von Rendering‑Operationen verwendet wird.

Vollständiges funktionierendes Beispiel

Alle Bausteine zusammen ergeben eine einzelne, ausführbare Klasse, die ein Word‑Dokument in HTML konvertiert und dabei Kommentare intakt hält. (Der vollständige Quellcode ist im offiziellen GitHub‑Repository verfügbar.)

Erweiterte Konfiguration und Optionen

Dynamische Ausgabeverzeichnisse einrichten

Für größere Anwendungen möchten Sie möglicherweise Ausgabeverzeichnisse basierend auf Benutzer‑IDs oder Zeitstempeln erzeugen:

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

Häufige Probleme und Fehlersuche

Problem 1: „Datei nicht gefunden“-Fehler

Stellen Sie sicher, dass der Eingabepfad absolut oder relativ zum Arbeitsverzeichnis ist und prüfen Sie die Dateiberechtigungen. Die Verwendung von Path‑Objekten hilft, typische String‑Verkettungsfehler zu vermeiden.

Problem 2: Kommentare erscheinen nicht in der Ausgabe

Überprüfen Sie, dass setRenderComments(true) vor viewer.view() aufgerufen wird. Stellen Sie außerdem sicher, dass das Quell‑Dokument tatsächlich Kommentare enthält; Sie können sie über viewer.getDocumentInfo().getComments() inspizieren.

Problem 3: Out‑of‑Memory‑Fehler bei großen Dokumenten

GroupDocs Viewer streamt Daten, aber extrem große Dateien (> 500 Seiten) können den JVM‑Heap dennoch belasten. Erhöhen Sie den Heap mit -Xmx4g oder rendern Sie nur die benötigten Seiten.

Problem 4: Langsame Rendering‑Leistung

Rendern Sie bestimmte Seitenbereiche mit viewer.view(pageRange, viewOptions). Externe Ressourcen (forExternalResources()) reduzieren zudem die HTML‑Payload‑Größe und beschleunigen das Browser‑Rendering.

Praxisnahe Implementierungsmuster

Muster 1: Integration in Web‑Anwendung

Integrieren Sie die Rendering‑Logik in einen Spring‑Boot‑Controller, um HTML bei Bedarf bereitzustellen:

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

Muster 2: Stapelverarbeitung mehrerer Dokumente

Wenn Sie einen ganzen Ordner mit Word‑Dateien konvertieren müssen, durchlaufen Sie das Verzeichnis und verwenden Sie dieselbe HtmlViewOptions‑Instanz, um den Objekt‑Erstellungs‑Overhead zu minimieren.

Leistungsoptimierung und bewährte Verfahren

Tipps zum Speicher‑Management

  • Immer try‑with‑resources für Viewer‑Instanzen verwenden.
  • Große Dokumente in Batches verarbeiten, anstatt alles auf einmal in den Speicher zu laden.
  • JVM‑Heap‑Nutzung überwachen mit Tools wie VisualVM und -Xmx bei Bedarf anpassen.
  • Richtige Caching‑Strategien für häufig aufgerufene Dokumente implementieren, um wiederholtes Rendering zu vermeiden.

Richtlinien zur Ressourcennutzung

Für kleine Anwendungen (< 100 Dokumente/Tag):

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

Für hochvolumige Anwendungen (1000+ Dokumente/Tag):

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

Caching‑Strategien

Speichern Sie gerendertes HTML in einem verteilten Cache (z. B. Redis) mit dem Dokument‑Hash als Schlüssel. Bei einer Anfrage prüfen Sie zuerst den Cache; bei einem Treffer wird das gecachte HTML sofort ausgeliefert, wodurch das Rendering‑Engine umgangen wird.

Wann GroupDocs Viewer vs. Alternativen verwenden

GroupDocs Viewer ist ideal für

  • Dokumenten‑Management‑Systeme – müssen viele Dateitypen mit Anmerkungen anzeigen.
  • Kollaborative Review‑Plattformen – Kommentare müssen für alle Teilnehmer sichtbar bleiben.
  • E‑Learning‑Tools – Dozenten‑Notizen erscheinen neben den Vortragsfolien.
  • Rechtsanwendungen – Verträge mit Anmerkungen von Anwälten erfordern eine getreue Darstellung.

Alternativen in Betracht ziehen, wenn

  • Einfache PDF‑Anzeige – native Browser‑PDF‑Viewer könnten ausreichen.
  • Einfache Bildkonvertierung – ImageIO oder ähnliche Bibliotheken sind leichter.
  • Reine Textextraktion – Apache POI oder iText könnten geeigneter sein.

Häufig gestellte Fragen

F: Kann ich Dokumente ohne Kommentare rendern?
Ja – lassen Sie einfach den Aufruf setRenderComments(true) weg oder setzen Sie ihn auf false.

F: Welche Dateiformate unterstützen das Rendern von Kommentaren?
Die meisten gängigen Formate – einschließlich DOC/DOCX, XLS/XLSX, PPT/PPTX, PDF und viele weitere. Siehe die offizielle Dokumentation für die vollständige Liste.

F: Kann ich das Styling der HTML‑Ausgabe anpassen?
Absolut. Verwenden Sie HtmlViewOptions.setEmbedResources(false), um externe CSS‑Dateien zu erzeugen, und fügen Sie anschließend Ihr eigenes Stylesheet hinzu.

F: Wie gehe ich mit passwortgeschützten Dokumenten um?
Stellen Sie eine LoadOptions‑Instanz mit dem Passwort bereit:

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

LoadOptions ermöglicht es Ihnen, Dokument‑Ladeparameter wie Passwörter anzugeben.

F: Ist es möglich, nur bestimmte Seiten zu rendern?
Ja – verwenden Sie die überladene view‑Methode, die eine PageNumber‑Sammlung akzeptiert:

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

PageNumber repräsentiert einen spezifischen Seitenindex, der beim Rendern einer Teilmenge von Seiten verwendet wird.

F: Warum ist das Rendering bei großen Dokumenten langsam?
Große Dateien benötigen mehr Verarbeitungszeit. Verbessern Sie die Geschwindigkeit, indem Sie nur benötigte Seiten rendern, externe Ressourcen nutzen, den JVM‑Heap erhöhen und asynchrones Processing aktivieren.

F: Wie kann ich den Rendering‑Fortschritt überwachen?
Obwohl GroupDocs Viewer keine integrierten Callbacks bietet, können Sie die Operation mit System.nanoTime() vor und nach viewer.view() zeitlich messen, um die Dauer zu protokollieren.

F: Was passiert, wenn das Quell‑Dokument beschädigt ist?
Die Bibliothek wirft eine ViewerException. Wickeln Sie den Aufruf in einen try‑catch‑Block und protokollieren Sie den Fehler für ein sanftes Degradieren.

F: Kann ich GroupDocs Viewer in einer kommerziellen Anwendung verwenden?
Ja, aber eine kommerzielle Lizenz ist erforderlich. Die kostenlose Testversion enthält Wasserzeichen, die für den Produktionseinsatz entfernt werden müssen.

F: Gibt es Nutzungslimits?
Die Bibliothek selbst legt keine Limits fest, jedoch kann Ihr Lizenzvertrag Nutzungskappen definieren. Prüfen Sie Ihren Vertrag für Details.

F: Darf ich Anwendungen, die GroupDocs Viewer enthalten, weiterverteilen?
Sie dürfen Ihre eigene Anwendung verbreiten, jedoch nicht die GroupDocs‑Bibliotheks‑Binärdateien selbst. Prüfen Sie die Lizenzbedingungen für die Einhaltung.

Nächste Schritte und fortgeschrittene Themen

Sie haben nun eine solide Grundlage für Word in HTML konvertieren mit erhaltenen Kommentaren. Hier sind einige Richtungen, um Ihr Fachwissen zu vertiefen:

  • Wasserzeichen – benutzerdefinierte Wasserzeichen zu gerenderten Seiten hinzufügen für Branding oder Vertraulichkeit.
  • Metadaten‑Extraktion – Autor, Erstellungsdatum und Seitenzahl über viewer.getDocumentInfo() abrufen.
  • Benutzerdefinierte Viewer – spezialisierte Viewer für PDFs, Tabellenkalkulationen oder Präsentationen erstellen, die Kommentare unterschiedlich ausblenden oder hervorheben.
  • Integration von Cloud‑Speicher – Dateien direkt aus AWS S3, Azure Blob oder Google Drive rendern, ohne sie lokal herunterzuladen.

Empfohlener Lernpfad

  1. Mit verschiedenen Dateitypen experimentieren – probieren Sie Excel-, PowerPoint- und PDF-Dateien aus, um zu sehen, wie Kommentare in den verschiedenen Formaten behandelt werden.
  2. Einfachen Web‑Viewer erstellen – eine minimale HTML‑Seite erstellen, die das generierte HTML über ein <iframe> oder AJAX lädt.
  3. Das GroupDocs‑Ökosystem erkunden – sich GroupDocs Annotation, Comparison und Signature für End‑to‑End‑Dokumenten‑Workflows ansehen.
  4. Der Community beitreten – im GroupDocs Forum mitwirken für Tipps, Beispielprojekte und Support.

Hilfe und Support erhalten

Offizielle Ressourcen

Community‑Ressourcen

  • Stack Overflow (tag: groupdocs-viewer)
  • Reddit‑Programmier‑Communities
  • Java‑Entwickler‑Discord‑Server

Zuletzt aktualisiert: 2026-05-21
Getestet mit: GroupDocs.Viewer 25.2 für 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());
}

Verwandte Tutorials