GroupDocs Viewer Java‑handledning: Konvertera Word till HTML och rendera dokument med kommentarer

Introduktion

Om du behöver konvertera Word till HTML samtidigt som du behåller varje granskares anteckning, kommentar eller annotation, har du hamnat på rätt plats. Många Java‑utvecklare stöter på problem när dokumentkonvertering tar bort den värdefulla återkopplingen som är inbäddad i originalfilen. Denna handledning visar dig hur du använder GroupDocs Viewer för Java för att konvertera Word till HTML och rendera ett brett spektrum av dokumenttyper — Word, Excel, PowerPoint, PDF och mer — utan att förlora någon kommentarsdata.

Render Documents with Comments with GroupDocs.Viewer for Java

Render Documents with Comments with GroupDocs.Viewer for Java

Vad du kommer att behärska i den här handledningen:

  • Fullständig installation och konfiguration av GroupDocs Viewer
  • Steg‑för‑steg konvertera Word till HTML med kommentarer bevarade
  • Vanliga felsökningslösningar och fallgropar att undvika
  • Verkliga implementeringsmönster och bästa praxis
  • Prestandaoptimeringstekniker för produktionsanvändning

Snabba svar

  • Kan GroupDocs Viewer konvertera Word till HTML? Ja — aktivera HTML‑rendering och kommentarsstöd i en enda kodrad.
  • Behåller kommentarer sig i HTML‑utdata? Absolut — setRenderComments(true) bevarar varje kommentar och annotation.
  • Vilken Java‑version krävs? JDK 8 eller högre.
  • Behövs en licens för produktion? En full licens tar bort vattenstämplar och låser upp alla funktioner.
  • Hur förbättrar man renderingshastigheten? Rendera specifika sidor, använd externa resurser och öka JVM‑heap‑storleken.

Vad är “konvertera word till html” med kommentarer?

“Convert Word to HTML” betyder att omvandla en Microsoft Word .docx-fil till ett web‑klart HTML‑dokument samtidigt som den ursprungliga layouten, stilen och eventuella inbäddade kommentarer bevaras. Denna process gör det möjligt för webbläsare att visa dokumentet exakt som författarna avsett, komplett med granskningsåterkoppling.

Varför välja GroupDocs Viewer för Java?

Innan vi dyker ner i koden, låt oss utforska varför GroupDocs Viewer är det självklara biblioteket för Java‑baserad dokumentrendering:

  • 170+ stödda format – biblioteket hanterar allt från DOCX till CAD‑filer, vilket ger dig ett enda beroende för alla dina konverteringsbehov.
  • Ingen tredjeparts Office‑installation – det fungerar på alla OS utan att behöva Microsoft Office, LibreOffice eller andra tunga körmiljöer.
  • Bevarar formatering och annotationer – kommentarer, fotnoter och spårade ändringar överlever konverteringen intakta.
  • Snabb, lättviktig motor – typiska 100‑sidiga dokument renderas på under 2 sekunder på en standard 4‑kärnig server.
  • Robust dokumentation och aktiv community – du hittar exempel, forum och snabb support när du stöter på problem.

När du ska använda detta tillvägagångssätt

  • Bygga webb‑baserade dokumentvisare som behöver visa granskningsanteckningar
  • Skapa samarbetsgranskningsplattformar där återkoppling måste förbli synlig
  • Konvertera äldre kontrakt för online‑visning i juridiska portaler
  • Utveckla e‑learning‑lösningar som bäddar in instruktörskommentarer i studiematerial

Förutsättningar och miljöinställning

Vad du behöver

  • Java Development Kit (JDK) 8+ – runtime‑miljön som driver din applikation.
  • Maven 3.6+ – för beroendehantering och byggning av projektet.
  • IDE du föredrar – IntelliJ IDEA, Eclipse eller VS Code.
  • Exempeldokument med kommentarer – DOCX-, XLSX- och PPTX‑filer som innehåller granskningsanteckningar.

Så ställer du in din utvecklingsmiljö

Steg 1: Verifiera Java‑installation

Open a terminal and run:

java -version

Du bör se en versionssträng som börjar med 1.8 eller högre. Om inte, ladda ner den senaste JDK från den officiella Oracle‑ eller OpenJDK‑webbplatsen.

Steg 2: Kontrollera Maven‑installation

Run:

mvn -v

Maven should report its version and the Java version it uses. Install Maven from the Apache website if the command is not recognised.

Steg 3: Skapa ett nytt Maven‑projekt

Generate a skeleton project with:

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

Navigera in i den nyss skapade viewer-demo‑mappen och du är redo att lägga till GroupDocs Viewer.

Så ställer du in GroupDocs.Viewer för Java

Lägg till beroendet

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>

Proffstips: Kontrollera alltid GroupDocs releases page för den senaste versionen. Biblioteket underhålls aktivt med regelbundna uppdateringar och buggfixar.

Förstå licensalternativ

GroupDocs offers flexible licensing that fits different project needs:

  • Gratis provperiod (Perfekt för lärande): 30‑dagars utvärdering med full åtkomst till funktioner och utvärderingsvattenstämplar.
  • Tillfällig licens (För utveckling): Utökad utvärdering utan vattenstämplar; idealisk för proof‑of‑concept‑projekt. Begär på GroupDocs Temporary License Page.
  • Full licens (Produktionsklar): Inga begränsningar eller vattenstämplar, kommersiell användning tillåten. Tillgänglig på GroupDocs Purchase Page.

Grundläggande initieringsmönster

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:

  • Automatisk resurshantering förhindrar minnesläckor.
  • Undantagshantering fångar vanliga fil‑åtkomstproblem.
  • Ren, läsbar kod som är lätt att underhålla i stora projekt.

Kärnimplementation: Rendera dokument med kommentarer

Förstå processen

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

  1. Dokumentanalys – analyserar indatafilen och bygger en intern representation.
  2. Kommentarsextraktion – identifierar varje kommentar, fotnot och annotation.
  3. HTML‑generering – skapar ren, standard‑kompatibel HTML som speglar den ursprungliga layouten.
  4. Resurshantering – samlar bilder, CSS och typsnitt antingen inline eller som externa filer.

Steg‑för‑steg‑implementering

Steg 1: Ställ in dina filsökvägar

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:

  • Använder modern Java NIO.2 Path‑API, som är mer pålitlig än java.io.File.
  • Beskrivande variabelnamn underlättar felsökning.
  • {0}‑platshållaren i utmatningsmönstret ersätts automatiskt med sidnummer.

Steg 2: Konfigurera HTML‑renderingsalternativ

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

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

Key Configuration Details:

  • forEmbeddedResources() bäddar in CSS, bilder och typsnitt direkt i HTML, vilket gör utdata portabel.
  • setRenderComments(true) är den enda raden som säkerställer att convert word to html behåller alla granskningsanteckningar.
  • Alternativet forExternalResources() låter dig lagra resurser separat om du föredrar en smalare HTML‑fil.

Steg 3: Utför renderingen

Now we bring everything together:

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

The view call reads the Word file, extracts comments, generates HTML pages, and writes them to output/html. Each page is saved as page_1.html, page_2.html, etc.

Komplett fungerande exempel

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.)

Avancerad konfiguration och alternativ

Ställ in dynamiska utmatningskataloger

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

Vanliga problem och felsökning

Problem 1: “File Not Found”-fel

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.

Problem 2: Kommentarer visas inte i utdata

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().

Problem 3: Minnesbristfel med stora dokument

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.

Problem 4: Långsam renderingsprestanda

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

Verkliga implementeringsmönster

Mönster 1: Webapplikationsintegration

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

Mönster 2: Batch‑behandling av flera dokument

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.

Prestandaoptimering och bästa praxis

Tips för minneshantering

  • Använd alltid try‑with‑resources för Viewer‑instanser.
  • Processa stora dokument i batcher snarare än att ladda allt i minnet på en gång.
  • Övervaka JVM‑heap‑användning med verktyg som VisualVM och justera -Xmx vid behov.
  • Implementera korrekt cachning för ofta åtkomna dokument för att undvika upprepad rendering.

Riktlinjer för resursanvändning

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

Cachningsstrategier

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.

När du ska använda GroupDocs Viewer vs alternativ

GroupDocs Viewer är perfekt för

  • Dokumenthanteringssystem – behöver visa många filtyper med annotationer.
  • Samarbetsgranskningsplattformar – kommentarer måste förbli synliga för alla deltagare.
  • Utbildningsverktyg – instruktörskommentarer visas tillsammans med föreläsningsbilder.
  • Juridiska applikationer – kontrakt med juristkommentarer kräver trogen rendering.

Överväg alternativ när

  • Enkel PDF‑visning – inbyggda webbläsar‑PDF‑visare kan räcka.
  • Grundläggande bildkonvertering – ImageIO eller liknande bibliotek är lättare.
  • Ren textutvinning – Apache POI eller iText kan vara mer lämpliga.

Vanliga frågor

Q: Kan jag rendera dokument utan kommentarer?
A: Ja — utelämna helt enkelt anropet setRenderComments(true) eller sätt det till false.

Q: Vilka filformat stödjer rendering av kommentarer?
A: De flesta stora format — inklusive DOC/DOCX, XLS/XLSX, PPT/PPTX, PDF och många fler. Se den officiella dokumentationen för hela listan.

Q: Kan jag anpassa HTML‑utdataens stil?
A: Absolut. Använd HtmlViewOptions.setEmbedResources(false) för att generera externa CSS‑filer, och lägg sedan till din egen stylesheet efter rendering.

Q: Hur hanterar jag lösenordsskyddade dokument?
A: Provide a LoadOptions instance with the password:

LoadOptions allows you to specify document loading parameters such as passwords.

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

Q: Är det möjligt att rendera endast specifika sidor?
A: Yes — use the overloaded view method that accepts a PageNumber collection:

PageNumber represents a specific page index used when rendering a subset of pages.

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

Q: Varför är rendering långsam för stora dokument?
A: Large files require more processing time. Improve speed by rendering only needed pages, using external resources, increasing JVM heap, and enabling asynchronous processing.

Q: Hur kan jag övervaka renderingsförloppet?
A: While GroupDocs Viewer lacks built‑in callbacks, you can time the operation with System.nanoTime() before and after viewer.view() to log duration.

Q: Vad händer om källdokumentet är korrupt?
A: The library throws a ViewerException. Wrap the call in a try‑catch block and log the error for graceful degradation.

Q: Kan jag använda GroupDocs Viewer i en kommersiell applikation?
A: Yes, but a commercial license is required. The free trial includes watermarks that must be removed for production use.

Q: Finns det några användningsgränser?
A: The library itself imposes no limits, though your license agreement may define usage caps. Review your contract for details.

Q: Kan jag distribuera applikationer som inkluderar GroupDocs Viewer?
A: You may distribute your own application, but you cannot redistribute the GroupDocs library binaries themselves. Check the license terms for compliance.

Nästa steg och avancerade ämnen

You now have a solid foundation for convert word to html while preserving comments. Here are a few directions to deepen your expertise:

  • Vattenstämpling – lägg till anpassade vattenstämplar på renderade sidor för varumärkesbyggande eller konfidentialitet.
  • Metadata‑utvinning – hämta författare, skapandedatum och sidantal via viewer.getDocumentInfo().
  • Anpassade visare – bygg specialiserade visare för PDF‑, kalkylblads‑ eller presentationsfiler som döljer eller framhäver kommentarer på olika sätt.
  • Molnlagringsintegration – rendera filer direkt från AWS S3, Azure Blob eller Google Drive utan att ladda ner dem lokalt.

Rekommenderad inlärningsväg

  1. Experimentera med olika filtyper – prova Excel-, PowerPoint- och PDF‑filer för att se hur kommentarer hanteras i olika format.
  2. Bygg en enkel webbvisare – skapa en minimal HTML‑sida som laddar den genererade HTML:n via ett <iframe> eller AJAX.
  3. Utforska GroupDocs‑ekosystemet – titta på GroupDocs Annotation, Comparison och Signature för helhetsdokumentarbetsflöden.
  4. Gå med i communityn – delta i GroupDocs Forum för tips, exempelprojekt och support.

Få hjälp och support

Official Resources

Community Resources

  • Stack Overflow (tag: groupdocs-viewer)
  • Reddit‑programmeringsgemenskaper
  • Java‑utvecklare Discord‑servrar

Last Updated: 2026-05-21
Tested With: GroupDocs.Viewer 25.2 for Java
Author: 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());
}

Relaterade handledningar