Tutorial de GroupDocs Viewer para Java: Convertir Word a HTML y Renderizar Documentos con Comentarios

Introducción

Si necesitas convertir Word a HTML mientras mantienes cada nota, comentario o anotación del revisor, has llegado al lugar correcto. Muchos desarrolladores Java se topan con un obstáculo cuando la conversión de documentos elimina los valiosos comentarios incrustados en el archivo original. Este tutorial te guía a través del uso de GroupDocs Viewer para Java para convertir Word a HTML y renderizar una amplia gama de tipos de documentos—Word, Excel, PowerPoint, PDF y más—sin perder ningún dato de comentarios.

Descubrirás por qué GroupDocs Viewer es una opción lista para producción, cómo configurar el entorno, el código exacto que necesitas y trucos probados para mantener el rendimiento ágil incluso con archivos grandes.

Renderizar documentos con comentarios con GroupDocs.Viewer para Java

Lo que dominarás en este tutorial:

• Configuración e instalación completa de GroupDocs Viewer
• convert Word to HTML paso a paso con comentarios preservados
• Soluciones comunes de resolución de problemas y trampas a evitar
• Patrones de implementación del mundo real y mejores prácticas
• Técnicas de optimización de rendimiento para uso en producción

Respuestas rápidas

• ¿Puede GroupDocs Viewer convertir Word a HTML? Sí—habilita la renderización HTML y el soporte de comentarios en una sola línea de código.
• ¿Los comentarios permanecen en la salida HTML? Absolutamente—setRenderComments(true) preserva cada comentario y anotación.
• ¿Qué versión de Java se requiere? JDK 8 o superior.
• ¿Se necesita una licencia para producción? Una licencia completa elimina las marcas de agua y desbloquea todas las funciones.
• ¿Cómo mejorar la velocidad de renderizado? Renderiza páginas específicas, usa recursos externos y aumenta el tamaño del heap de la JVM.

Qué es “convertir word a html” con comentarios?

“Convert Word to HTML” significa transformar un archivo Microsoft Word .docx en un documento HTML listo para la web, manteniendo el diseño original, el estilo y cualquier comentario incrustado. Este proceso permite que los navegadores muestren el documento exactamente como los autores lo pretendían, completo con la retroalimentación del revisor.

¿Por qué elegir GroupDocs Viewer para Java?

Before we dive into code, let’s explore why GroupDocs Viewer is the go‑to library for Java‑based document rendering:

• Más de 170 formatos compatibles – la biblioteca maneja todo, desde DOCX hasta archivos CAD, brindándote una única dependencia para todas tus necesidades de conversión.
• Sin instalación de Office de terceros – funciona en cualquier SO sin necesidad de Microsoft Office, LibreOffice u otros entornos pesados.
• Preserva el formato y las anotaciones – los comentarios, notas al pie y cambios controlados sobreviven a la conversión intactos.
• Motor rápido y ligero – documentos típicos de 100 páginas se renderizan en menos de 2 segundos en un servidor estándar de 4 núcleos.
• Documentación robusta y comunidad activa – encontrarás ejemplos, foros y soporte rápido siempre que encuentres un problema.

Cuándo usar este enfoque

• Construir visores de documentos basados en web que necesiten mostrar notas de los revisores
• Crear plataformas de revisión colaborativa donde la retroalimentación debe permanecer visible
• Convertir contratos heredados para su visualización en línea en portales legales
• Desarrollar soluciones de e‑learning que incrusten comentarios del instructor en el material de estudio

Requisitos previos y configuración del entorno

Lo que necesitarás

• Java Development Kit (JDK) 8+ – el runtime que impulsa tu aplicación.
• Maven 3.6+ – para la gestión de dependencias y la construcción del proyecto.
• IDE de tu elección – IntelliJ IDEA, Eclipse o VS Code.
• Documentos de muestra con comentarios – archivos DOCX, XLSX, PPTX que contienen notas de los revisores.

Configuración de tu entorno de desarrollo

Paso 1: Verificar la instalación de Java

Open a terminal and run:

java -version

Deberías ver una cadena de versión que comience con 1.8 o superior. Si no, descarga el JDK más reciente desde el sitio web oficial de Oracle o OpenJDK.

Paso 2: Verificar la instalación de Maven

Run:

mvn -v

Maven debería mostrar su versión y la versión de Java que utiliza. Instala Maven desde el sitio web de Apache si el comando no se reconoce.

Paso 3: Crear un nuevo proyecto Maven

Generate a skeleton project with:

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

Navega a la carpeta recién creada viewer-demo y estarás listo para añadir GroupDocs Viewer.

Configuración de GroupDocs.Viewer para Java

Añadiendo la dependencia

The first step in any GroupDocs Viewer Java tutorial is getting the library into your project. Add this configuration to your pom.xml file:

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

Consejo profesional: Siempre revisa la página de lanzamientos de GroupDocs para obtener la última versión. La biblioteca se mantiene activamente con actualizaciones regulares y correcciones de errores.

Comprendiendo las opciones de licencia

GroupDocs offers flexible licensing that fits different project needs:

• Prueba gratuita (Perfecta para aprender): evaluación de 30 días con acceso completo a funciones y marcas de agua de evaluación.
• Licencia temporal (Para desarrollo): evaluación extendida sin marcas de agua; ideal para proyectos de prueba de concepto. Solicítala en la Página de licencia temporal de GroupDocs.
• Licencia completa (Lista para producción): sin limitaciones ni marcas de agua, uso comercial permitido. Disponible en la Página de compra de GroupDocs.

Patrón básico de inicialización

Here’s the fundamental pattern you’ll use throughout this tutorial:

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

Why This Pattern Works:

• Gestión automática de recursos previene fugas de memoria.
• Manejo de excepciones captura problemas comunes de acceso a archivos.
• Código limpio y legible que es fácil de mantener en proyectos grandes.

Implementación central: Renderizado de documentos con comentarios

Entendiendo el proceso

When you render a document with GroupDocs Viewer, the library performs four key steps:

1. Análisis del documento – analiza el archivo de entrada y construye una representación interna.
2. Extracción de comentarios – identifica cada comentario, nota al pie y anotación.
3. Generación de HTML – crea HTML limpio y conforme a estándares que refleja el diseño original.
4. Manejo de recursos – agrupa imágenes, CSS y fuentes ya sea en línea o como archivos externos.

Implementación paso a paso

Paso 1: Configurar tus rutas de archivo

Organise your input and output locations early to avoid path‑related errors:

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

Why This Approach:

• Utiliza la API moderna Java NIO.2 Path, que es más fiable que java.io.File.
• Nombres de variables descriptivos facilitan la depuración.
• El marcador {0} en el patrón de salida se reemplaza automáticamente con los números de página.

Paso 2: Configurar opciones de renderizado HTML

This is where the magic happens. We tell GroupDocs exactly how we want the document rendered:

HtmlViewOptions configura cómo se renderiza el documento a HTML, incluyendo el manejo de recursos y el renderizado de comentarios.

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

Key Configuration Details:

• forEmbeddedResources() incrusta CSS, imágenes y fuentes directamente en el HTML, haciendo la salida portátil.
• setRenderComments(true) es la única línea que asegura que convertir word a html conserve todas las notas de los revisores.
• La alternativa forExternalResources() te permite almacenar los recursos por separado si prefieres un archivo HTML más ligero.

Paso 3: Ejecutar el renderizado

Now we bring everything together:

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

La llamada view lee el archivo Word, extrae los comentarios, genera páginas HTML y las escribe en output/html. Cada página se guarda como page_1.html, page_2.html, etc.

Ejemplo completo en funcionamiento

Putting all pieces together gives you a single, runnable class that converts a Word document to HTML while keeping comments intact. (The full source code is available in the official GitHub repository.)

Configuración avanzada y opciones

Configuración de directorios de salida dinámicos

For larger applications you may want to generate output directories based on user IDs or timestamps:

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

Problemas comunes y solución de errores

Problema 1: Errores “Archivo no encontrado”

Make sure the input path is absolute or relative to the working directory, and verify file permissions. Using Path objects helps avoid common string‑concatenation mistakes.

Problema 2: Los comentarios no aparecen en la salida

Double‑check that setRenderComments(true) is called before viewer.view(). Also ensure the source document actually contains comments; you can inspect them via viewer.getDocumentInfo().getComments().

Problema 3: Errores de falta de memoria con documentos grandes

GroupDocs Viewer streams data, but extremely large files (> 500 pages) may still strain the JVM heap. Increase heap size with -Xmx4g or render only needed pages.

Problema 4: Rendimiento de renderizado lento

Render specific page ranges using viewer.view(pageRange, viewOptions). External resources (forExternalResources()) also reduce HTML payload size, speeding up browser rendering.

Patrones de implementación del mundo real

Patrón 1: Integración en aplicación web

Integrate the rendering logic into a Spring Boot controller to serve HTML on demand:

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

Patrón 2: Procesamiento por lotes de múltiples documentos

When you need to convert a whole folder of Word files, loop through the directory and reuse the same HtmlViewOptions instance to minimise object creation overhead.

Optimización de rendimiento y mejores prácticas

Consejos de gestión de memoria

• Siempre usa try‑with‑resources para instancias de Viewer.
• Procesa documentos grandes por lotes en lugar de cargar todo en memoria de una vez.
• Monitorea el uso del heap de la JVM con herramientas como VisualVM y ajusta -Xmx según sea necesario.
• Implementa un caché adecuado para documentos accedidos frecuentemente y evitar renderizados repetidos.

Directrices de uso de recursos

For Small Applications (< 100 documents/day):

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

For High‑Volume Applications (1000+ documents/day):

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

Estrategias de caché

Store rendered HTML in a distributed cache (e.g., Redis) keyed by document hash. When a request arrives, check the cache first; if a hit, serve the cached HTML instantly, bypassing the rendering engine.

Cuándo usar GroupDocs Viewer vs alternativas

GroupDocs Viewer es perfecto para

• Sistemas de gestión de documentos – necesitan mostrar muchos tipos de archivo con anotaciones.
• Plataformas de revisión colaborativa – los comentarios deben permanecer visibles para todos los participantes.
• Herramientas educativas – las notas de los instructores aparecen junto a las diapositivas de la presentación.
• Aplicaciones legales – los contratos con comentarios de abogados requieren un renderizado fiel.

Considera alternativas cuando

• Visualización simple de PDF – los visores PDF nativos del navegador pueden ser suficientes.
• Conversión básica de imágenes – ImageIO u otras bibliotecas similares son más ligeras.
• Extracción pura de texto – Apache POI o iText pueden ser más apropiados.

Preguntas frecuentes

P: ¿Puedo renderizar documentos sin comentarios?
R: Sí—simplemente omite la llamada setRenderComments(true) o configúrala a false.

P: ¿Qué formatos de archivo admiten el renderizado de comentarios?
R: La mayoría de los formatos principales—incluidos DOC/DOCX, XLS/XLSX, PPT/PPTX, PDF y muchos más. Consulta la documentación oficial para la lista completa.

P: ¿Puedo personalizar el estilo de salida HTML?
R: Absolutamente. Usa HtmlViewOptions.setEmbedResources(false) para generar archivos CSS externos, luego añade tu propia hoja de estilos después del renderizado.

P: ¿Cómo manejo documentos protegidos con contraseña?
R: Proporciona una instancia de LoadOptions con la contraseña:

LoadOptions te permite especificar parámetros de carga del documento, como contraseñas.

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

P: ¿Es posible renderizar solo páginas específicas?
R: Sí—usa el método sobrecargado view que acepta una colección de PageNumber:

PageNumber representa un índice de página específico usado al renderizar un subconjunto de páginas.

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

P: ¿Por qué el renderizado es lento para documentos grandes?
R: Los archivos grandes requieren más tiempo de procesamiento. Mejora la velocidad renderizando solo las páginas necesarias, usando recursos externos, aumentando el heap de la JVM y habilitando el procesamiento asíncrono.

P: ¿Cómo puedo monitorizar el progreso del renderizado?
R: Aunque GroupDocs Viewer no tiene callbacks incorporados, puedes medir el tiempo de la operación con System.nanoTime() antes y después de viewer.view() para registrar la duración.

P: ¿Qué ocurre si el documento fuente está corrupto?
R: La biblioteca lanza una ViewerException. Envuelve la llamada en un bloque try‑catch y registra el error para una degradación elegante.

P: ¿Puedo usar GroupDocs Viewer en una aplicación comercial?
R: Sí, pero se requiere una licencia comercial. La prueba gratuita incluye marcas de agua que deben eliminarse para uso en producción.

P: ¿Hay límites de uso?
R: La biblioteca en sí no impone límites, aunque tu acuerdo de licencia puede definir topes de uso. Revisa tu contrato para más detalles.

P: ¿Puedo redistribuir aplicaciones que incluyan GroupDocs Viewer?
R: Puedes distribuir tu propia aplicación, pero no puedes redistribuir los binarios de la biblioteca GroupDocs. Revisa los términos de la licencia para cumplir.

Próximos pasos y temas avanzados

Ahora tienes una base sólida para convertir word a html mientras preservas los comentarios. Aquí tienes algunas direcciones para profundizar tu experiencia:

1. Marca de agua – añade marcas de agua personalizadas a las páginas renderizadas para branding o confidencialidad.
2. Extracción de metadatos – recupera autor, fecha de creación y recuento de páginas mediante viewer.getDocumentInfo().
3. Visores personalizados – crea visores especializados para PDFs, hojas de cálculo o presentaciones que oculten o resalten los comentarios de forma diferente.
4. Integración con almacenamiento en la nube – renderiza archivos directamente desde AWS S3, Azure Blob o Google Drive sin descargarlos localmente.

Ruta de aprendizaje recomendada

1. Experimenta con diferentes tipos de archivo – prueba archivos Excel, PowerPoint y PDF para ver cómo se manejan los comentarios en distintos formatos.
2. Construye un visor web simple – crea una página HTML mínima que cargue el HTML generado mediante un <iframe> o AJAX.
3. Explora el ecosistema GroupDocs – revisa GroupDocs Annotation, Comparison y Signature para flujos de trabajo de documentos de extremo a extremo.
4. Únete a la comunidad – participa en el Foro de GroupDocs para obtener consejos, proyectos de ejemplo y soporte.

Obtención de ayuda y soporte

Recursos oficiales

• Documentación de GroupDocs.Viewer
• Referencia API
• Foro de soporte
• Ejemplos en GitHub

Recursos de la comunidad

• Stack Overflow (etiqueta: groupdocs-viewer)
• Comunidades de programación en Reddit
• Servidores Discord de desarrolladores Java

Última actualización: 2026-05-21
Probado con: 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());
}

Tutoriales relacionados

• Renderizar cambios de seguimiento de Word en documentos Word con GroupDocs.Viewer para Java
• Renderizado HTML responsivo con GroupDocs.Viewer para Java: Guía completa
• Cómo cargar y renderizar documentos como HTML usando GroupDocs.Viewer para Java