Tutorial di GroupDocs Viewer per Java: Convertire Word in HTML e Visualizzare Documenti con Commenti

Introduzione

Se hai bisogno di convertire Word in HTML mantenendo ogni nota, commento o annotazione del revisore, sei nel posto giusto. Molti sviluppatori Java si imbattono in un ostacolo quando la conversione dei documenti elimina il prezioso feedback incorporato nel file originale. Questo tutorial ti guida nell’uso di GroupDocs Viewer per Java per convertire Word in HTML e visualizzare una vasta gamma di tipi di documento — Word, Excel, PowerPoint, PDF e altro — senza perdere alcun dato dei commenti.

Render Documents with Comments with GroupDocs.Viewer for Java

Render Documents with Comments with GroupDocs.Viewer for Java

Cosa imparerai in questo tutorial:

  • Configurazione completa di GroupDocs Viewer
  • Passo‑a‑passo convertire Word in HTML con i commenti conservati
  • Soluzioni comuni di risoluzione dei problemi e trappole da evitare
  • Modelli di implementazione reali e migliori pratiche
  • Tecniche di ottimizzazione delle prestazioni per l’uso in produzione

Risposte rapide

  • GroupDocs Viewer può convertire Word in HTML? Sì — abilita il rendering HTML e il supporto dei commenti in una singola riga di codice.
  • I commenti rimangono nell’output HTML? Assolutamente — setRenderComments(true) conserva ogni commento e annotazione.
  • Quale versione di Java è necessaria? JDK 8 o superiore.
  • È necessaria una licenza per la produzione? Una licenza completa rimuove le filigrane e sblocca tutte le funzionalità.
  • Come migliorare la velocità di rendering? Renderizza pagine specifiche, usa risorse esterne e aumenta la dimensione dell’heap JVM.

Cos’è “convertire word in html” con commenti?

“Convertire Word in HTML” significa trasformare un file Microsoft Word .docx in un documento HTML pronto per il web mantenendo il layout originale, lo stile e tutti i commenti incorporati. Questo processo consente ai browser di visualizzare il documento esattamente come previsto dagli autori, completo del feedback dei revisori.

Perché scegliere GroupDocs Viewer per Java?

Prima di immergerci nel codice, esploriamo perché GroupDocs Viewer è la libreria di riferimento per il rendering di documenti basati su Java:

  • +170 formati supportati – la libreria gestisce tutto, dai file DOCX ai file CAD, fornendoti una singola dipendenza per tutte le tue esigenze di conversione.
  • Nessuna installazione di Office di terze parti – funziona su qualsiasi OS senza necessità di Microsoft Office, LibreOffice o altri runtime pesanti.
  • Preserva formattazione e annotazioni – commenti, note a piè di pagina e modifiche tracciate sopravvivono alla conversione intatti.
  • Motore veloce e leggero – documenti tipici di 100 pagine vengono renderizzati in meno di 2 secondi su un server standard a 4 core.
  • Documentazione solida e community attiva – troverai esempi, forum e supporto rapido ogni volta che incontri un problema.

Quando utilizzare questo approccio

  • Creare visualizzatori di documenti basati sul web che devono mostrare le note dei revisori
  • Creare piattaforme di revisione collaborativa dove il feedback deve rimanere visibile
  • Convertire contratti legacy per la visualizzazione online nei portali legali
  • Sviluppare soluzioni e‑learning che incorporano i commenti dell’istruttore nel materiale di studio

Prerequisiti e configurazione dell’ambiente

Cosa ti serve

  • Java Development Kit (JDK) 8+ – l’ambiente di esecuzione che alimenta la tua applicazione.
  • Maven 3.6+ – per la gestione delle dipendenze e la compilazione del progetto.
  • IDE a tua scelta – IntelliJ IDEA, Eclipse o VS Code.
  • Documenti di esempio con commenti – file DOCX, XLSX, PPTX che contengono note dei revisori.

Configurazione del tuo ambiente di sviluppo

Passo 1: Verifica l’installazione di Java

Apri un terminale e esegui:

java -version

Dovresti vedere una stringa di versione che inizia con 1.8 o superiore. In caso contrario, scarica l’ultima JDK dal sito ufficiale di Oracle o OpenJDK.

Passo 2: Controlla l’installazione di Maven

Esegui:

mvn -v

Maven dovrebbe riportare la sua versione e la versione di Java in uso. Installa Maven dal sito Apache se il comando non è riconosciuto.

Passo 3: Crea un nuovo progetto Maven

Genera uno scheletro di progetto con:

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

Naviga nella cartella appena creata viewer-demo e sei pronto ad aggiungere GroupDocs Viewer.

Configurazione di GroupDocs.Viewer per Java

Aggiungere la dipendenza

Il primo passo in qualsiasi tutorial di GroupDocs Viewer Java è inserire la libreria nel tuo progetto. Aggiungi questa configurazione al tuo file pom.xml:

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

Suggerimento: Controlla sempre la pagina delle release di GroupDocs per l’ultima versione. La libreria è attivamente mantenuta con aggiornamenti regolari e correzioni di bug.

Comprendere le opzioni di licenza

GroupDocs offre licenze flessibili che si adattano a diverse esigenze di progetto:

  • Prova gratuita (Perfetta per l’apprendimento): valutazione di 30 giorni con accesso completo alle funzionalità e filigrane di valutazione.
  • Licenza temporanea (Per sviluppo): valutazione estesa senza filigrane; ideale per progetti proof‑of‑concept. Richiedi su Pagina licenza temporanea di GroupDocs.
  • Licenza completa (Pronta per la produzione): nessuna limitazione o filigrana, uso commerciale consentito. Disponibile su Pagina di acquisto di GroupDocs.

Modello di inizializzazione di base

Ecco il modello fondamentale che utilizzerai in tutto questo tutorial:

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

Perché questo modello funziona:

  • Gestione automatica delle risorse previene perdite di memoria.
  • Gestione delle eccezioni cattura problemi comuni di accesso ai file.
  • Codice pulito e leggibile facile da mantenere in progetti di grandi dimensioni.

Implementazione principale: Rendering di documenti con commenti

Comprendere il processo

Quando renderizzi un documento con GroupDocs Viewer, la libreria esegue quattro passaggi chiave:

  1. Analisi del documento – analizza il file di input e costruisce una rappresentazione interna.
  2. Estrazione dei commenti – identifica ogni commento, nota a piè di pagina e annotazione.
  3. Generazione HTML – crea HTML pulito e conforme agli standard che rispecchia il layout originale.
  4. Gestione delle risorse – raggruppa immagini, CSS e font inline o come file esterni.

Implementazione passo‑a‑passo

Passo 1: Configura i percorsi dei file

Organizza i percorsi di input e output fin dall’inizio per evitare errori legati ai percorsi:

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

Perché questo approccio:

  • Utilizza la moderna API Java NIO.2 Path, più affidabile di java.io.File.
  • Nomi di variabili descrittivi facilitano il debug.
  • Il segnaposto {0} nel pattern di output viene sostituito automaticamente con i numeri di pagina.

Passo 2: Configura le opzioni di rendering HTML

Qui avviene la magia. Diciamo a GroupDocs esattamente come vogliamo che il documento venga renderizzato:

HtmlViewOptions configura come il documento viene renderizzato in HTML, includendo la gestione delle risorse e il rendering dei commenti.

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

Dettagli chiave della configurazione:

  • forEmbeddedResources() incorpora CSS, immagini e font direttamente nell’HTML, rendendo l’output portabile.
  • setRenderComments(true) è la singola riga che garantisce che convertire word in html mantenga tutte le note dei revisori.
  • L’alternativa forExternalResources() consente di memorizzare le risorse separatamente se preferisci un file HTML più leggero.

Passo 3: Esegui il rendering

Ora uniamo tutto:

Viewer è la classe principale usata per caricare un documento ed eseguire le operazioni di rendering.

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

La chiamata view legge il file Word, estrae i commenti, genera le pagine HTML e le scrive in output/html. Ogni pagina viene salvata come page_1.html, page_2.html, ecc.

Esempio completo funzionante

Unire tutti i pezzi fornisce una singola classe eseguibile che converte un documento Word in HTML mantenendo intatti i commenti. (Il codice sorgente completo è disponibile nel repository ufficiale su GitHub.)

Configurazione avanzata e opzioni

Configurazione di directory di output dinamiche

Per applicazioni più grandi potresti voler generare directory di output basate su ID utente o timestamp:

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

Problemi comuni e risoluzione

Problema 1: Errori “File non trovato”

Assicurati che il percorso di input sia assoluto o relativo alla directory di lavoro e verifica i permessi del file. L’uso di oggetti Path aiuta a evitare errori comuni di concatenazione di stringhe.

Problema 2: I commenti non compaiono nell’output

Verifica che setRenderComments(true) sia chiamato prima di viewer.view(). Inoltre, assicurati che il documento sorgente contenga effettivamente commenti; puoi ispezionarli tramite viewer.getDocumentInfo().getComments().

Problema 3: Errori di Out of Memory con documenti di grandi dimensioni

GroupDocs Viewer trasmette i dati in streaming, ma file estremamente grandi (> 500 pagine) possono comunque sovraccaricare l’heap JVM. Aumenta la dimensione dell’heap con -Xmx4g o renderizza solo le pagine necessarie.

Problema 4: Prestazioni di rendering lente

Renderizza intervalli di pagine specifici usando viewer.view(pageRange, viewOptions). Le risorse esterne (forExternalResources()) riducono anche la dimensione del payload HTML, accelerando il rendering nel browser.

Modelli di implementazione nel mondo reale

Modello 1: Integrazione in applicazioni web

Integra la logica di rendering in un controller Spring Boot per servire HTML su richiesta:

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

Modello 2: Elaborazione batch di più documenti

Quando devi convertire un’intera cartella di file Word, itera sulla directory e riutilizza la stessa istanza di HtmlViewOptions per ridurre al minimo l’overhead di creazione degli oggetti.

Ottimizzazione delle prestazioni e migliori pratiche

Suggerimenti per la gestione della memoria

  • Usa sempre try‑with‑resources per le istanze di Viewer.
  • Elabora documenti di grandi dimensioni in batch invece di caricare tutto in memoria contemporaneamente.
  • Monitora l’uso dell’heap JVM con strumenti come VisualVM e regola -Xmx secondo necessità.
  • Implementa una cache adeguata per i documenti frequentemente accessati per evitare rendering ripetuti.

Linee guida per l’uso delle risorse

Per applicazioni piccole (< 100 documenti/giorno):

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

Per applicazioni ad alto volume (1000+ documenti/giorno):

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

Strategie di caching

Memorizza l’HTML renderizzato in una cache distribuita (ad es., Redis) indicizzata dall’hash del documento. Quando arriva una richiesta, controlla prima la cache; se trovi un risultato, servi immediatamente l’HTML memorizzato, bypassando il motore di rendering.

Quando usare GroupDocs Viewer vs alternative

GroupDocs Viewer è perfetto per

  • Sistemi di gestione documentale – necessitano di visualizzare molti tipi di file con annotazioni.
  • Piattaforme di revisione collaborativa – i commenti devono rimanere visibili a tutti i partecipanti.
  • Strumenti educativi – le note degli istruttori appaiono accanto alle diapositive delle lezioni.
  • Applicazioni legali – contratti con commenti legali richiedono un rendering fedele.

Considera alternative quando

  • Visualizzazione PDF semplice – i visualizzatori PDF nativi del browser possono essere sufficienti.
  • Conversione immagine di base – ImageIO o librerie simili sono più leggere.
  • Estrazione di puro testo – Apache POI o iText potrebbero essere più appropriati.

Domande frequenti

Q: Posso renderizzare documenti senza commenti?
A: Sì — basta omettere la chiamata setRenderComments(true) o impostarla a false.

Q: Quali formati di file supportano il rendering dei commenti?
A: La maggior parte dei formati principali — DOC/DOCX, XLS/XLSX, PPT/PPTX, PDF e molti altri. Consulta la documentazione ufficiale per l’elenco completo.

Q: Posso personalizzare lo stile dell’output HTML?
A: Assolutamente. Usa HtmlViewOptions.setEmbedResources(false) per generare file CSS esterni, poi aggiungi il tuo foglio di stile dopo il rendering.

Q: Come gestisco i documenti protetti da password?
A: Fornisci un’istanza LoadOptions con la password:

LoadOptions consente di specificare parametri di caricamento del documento come le password.

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

Q: È possibile renderizzare solo pagine specifiche?
A: Sì — usa il metodo view sovraccaricato che accetta una collezione PageNumber:

PageNumber rappresenta un indice di pagina specifico usato quando si renderizza un sottoinsieme di pagine.

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

Q: Perché il rendering è lento per documenti di grandi dimensioni?
A: I file di grandi dimensioni richiedono più tempo di elaborazione. Migliora la velocità renderizzando solo le pagine necessarie, usando risorse esterne, aumentando l’heap JVM e abilitando l’elaborazione asincrona.

Q: Come posso monitorare l’avanzamento del rendering?
A: Sebbene GroupDocs Viewer non abbia callback integrate, puoi misurare il tempo dell’operazione con System.nanoTime() prima e dopo viewer.view() per registrare la durata.

Q: Cosa succede se il documento sorgente è corrotto?
A: La libreria lancia una ViewerException. Avvolgi la chiamata in un blocco try‑catch e registra l’errore per una degradazione graduale.

Q: Posso usare GroupDocs Viewer in un’applicazione commerciale?
A: Sì, ma è necessaria una licenza commerciale. La prova gratuita include filigrane che devono essere rimosse per l’uso in produzione.

Q: Ci sono limiti di utilizzo?
A: La libreria stessa non impone limiti, sebbene il tuo accordo di licenza possa definire soglie di utilizzo. Controlla il tuo contratto per i dettagli.

Q: Posso ridistribuire applicazioni che includono GroupDocs Viewer?
A: Puoi distribuire la tua applicazione, ma non è consentita la redistribuzione dei binari della libreria GroupDocs. Verifica i termini di licenza per la conformità.

Passi successivi e argomenti avanzati

Ora hai una solida base per convertire word in html mantenendo i commenti. Ecco alcune direzioni per approfondire le tue competenze:

  1. Watermarking – aggiungi filigrane personalizzate alle pagine renderizzate per branding o riservatezza.
  2. Estrazione dei metadati – recupera autore, data di creazione e numero di pagine tramite viewer.getDocumentInfo().
  3. Visualizzatori personalizzati – costruisci visualizzatori specializzati per PDF, fogli di calcolo o presentazioni che nascondono o evidenziano i commenti in modo diverso.
  4. Integrazione con storage cloud – renderizza file direttamente da AWS S3, Azure Blob o Google Drive senza scaricarli localmente.

Percorso di apprendimento consigliato

  1. Sperimenta con diversi tipi di file – prova file Excel, PowerPoint e PDF per vedere come i commenti vengono gestiti nei vari formati.
  2. Crea un semplice visualizzatore web – crea una pagina HTML minimale che carica l’HTML generato tramite un <iframe> o AJAX.
  3. Esplora l’ecosistema GroupDocs – guarda GroupDocs Annotation, Comparison e Signature per flussi di lavoro documentali end‑to‑end.
  4. Unisciti alla community – partecipa al Forum GroupDocs per consigli, progetti di esempio e supporto.

Ottenere aiuto e supporto

Risorse ufficiali

Risorse della community

  • Stack Overflow (tag: groupdocs-viewer)
  • Community di programmazione su Reddit
  • Server Discord per sviluppatori Java

Ultimo aggiornamento: 2026-05-21
Testato con: GroupDocs.Viewer 25.2 per Java
Autore: 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());
}

Tutorial correlati