Tutorial do GroupDocs Viewer Java: Converter Word para HTML e Renderizar Documentos com Comentários

Introdução

Se você precisa converter Word para HTML mantendo todas as notas, comentários ou anotações dos revisores, você chegou ao lugar certo. Muitos desenvolvedores Java encontram um obstáculo quando a conversão de documentos remove o feedback valioso incorporado no arquivo original. Este tutorial orienta você a usar o GroupDocs Viewer para Java para converter Word para HTML e renderizar uma ampla variedade de tipos de documentos — Word, Excel, PowerPoint, PDF e mais — sem perder nenhum dado de comentário.

Render Documents with Comments with GroupDocs.Viewer for Java

Render Documents with Comments with GroupDocs.Viewer for Java

O que você dominará neste tutorial:

  • Configuração completa do GroupDocs Viewer
  • Passo a passo converter Word para HTML com comentários preservados
  • Soluções comuns de solução de problemas e armadilhas a evitar
  • Padrões de implementação do mundo real e melhores práticas
  • Técnicas de otimização de desempenho para uso em produção

Respostas Rápidas

  • O GroupDocs Viewer pode converter Word para HTML? Sim — habilite a renderização HTML e o suporte a comentários em uma única linha de código.
  • Os comentários permanecem na saída HTML? Absolutamente — setRenderComments(true) preserva todos os comentários e anotações.
  • Qual versão do Java é necessária? JDK 8 ou superior.
  • É necessária uma licença para produção? Uma licença completa remove marcas d’água e desbloqueia todos os recursos.
  • Como melhorar a velocidade de renderização? Renderize páginas específicas, use recursos externos e aumente o tamanho do heap da JVM.

O que é “converter word para html” com comentários?

“Converter Word para HTML” significa transformar um arquivo Microsoft Word .docx em um documento HTML pronto para a web, mantendo o layout original, o estilo e quaisquer comentários incorporados. Esse processo permite que os navegadores exibam o documento exatamente como os autores pretendiam, completo com o feedback dos revisores.

Por que escolher o GroupDocs Viewer para Java?

Antes de mergulharmos no código, vamos explorar por que o GroupDocs Viewer é a biblioteca ideal para renderização de documentos baseada em Java:

  • Mais de 170 formatos suportados – a biblioteca lida com tudo, desde DOCX até arquivos CAD, oferecendo uma única dependência para todas as suas necessidades de conversão.
  • Nenhuma instalação de Office de terceiros – funciona em qualquer SO sem precisar do Microsoft Office, LibreOffice ou outros runtimes pesados.
  • Preserva formatação e anotações – comentários, notas de rodapé e controle de alterações permanecem intactos na conversão.
  • Motor rápido e leve – documentos típicos de 100 páginas são renderizados em menos de 2 segundos em um servidor padrão de 4 núcleos.
  • Documentação robusta e comunidade ativa – você encontrará exemplos, fóruns e suporte rápido sempre que encontrar um problema.

Quando usar esta abordagem

  • Construir visualizadores de documentos baseados na web que precisam mostrar notas dos revisores
  • Criar plataformas colaborativas de revisão onde o feedback deve permanecer visível
  • Converter contratos legados para exibição online em portais jurídicos
  • Desenvolver soluções de e‑learning que incorporam comentários do instrutor no material de estudo

Pré-requisitos e Configuração do Ambiente

O que você precisará

  • Java Development Kit (JDK) 8+ – o runtime que alimenta sua aplicação.
  • Maven 3.6+ – para gerenciamento de dependências e construção do projeto.
  • IDE de sua escolha – IntelliJ IDEA, Eclipse ou VS Code.
  • Documentos de exemplo com comentários – arquivos DOCX, XLSX, PPTX que contêm notas de revisores.

Configurando seu ambiente de desenvolvimento

Etapa 1: Verificar a instalação do Java

Open a terminal and run:

java -version

Você deve ver uma string de versão começando com 1.8 ou superior. Caso contrário, baixe o JDK mais recente no site oficial da Oracle ou OpenJDK.

Etapa 2: Verificar a instalação do Maven

Run:

mvn -v

O Maven deve relatar sua versão e a versão do Java que ele usa. Instale o Maven a partir do site da Apache se o comando não for reconhecido.

Etapa 3: Criar um novo projeto Maven

Generate a skeleton project with:

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

Navegue até a pasta recém-criada viewer-demo e você está pronto para adicionar o GroupDocs Viewer.

Configurando o GroupDocs.Viewer para Java

Adicionando a dependência

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>

Dica profissional: Sempre verifique a página de lançamentos do GroupDocs para a versão mais recente. A biblioteca é mantida ativamente com atualizações regulares e correções de bugs.

Entendendo as opções de licenciamento

GroupDocs offers flexible licensing that fits different project needs:

  • Teste gratuito (Perfeito para aprendizado): avaliação de 30 dias com acesso total aos recursos e marcas d’água de avaliação.
  • Licença temporária (Para desenvolvimento): avaliação estendida sem marcas d’água; ideal para projetos de prova de conceito. Solicite em Página de Licença Temporária do GroupDocs.
  • Licença completa (Pronta para produção): Sem limitações ou marcas d’água, uso comercial permitido. Disponível em Página de Compra do GroupDocs.

Padrão básico de inicialização

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

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

Por que esse padrão funciona:

  • Gerenciamento automático de recursos previne vazamentos de memória.
  • Tratamento de exceções captura problemas comuns de acesso a arquivos.
  • Código limpo e legível que é fácil de manter em projetos grandes.

Implementação Central: Renderizando Documentos com Comentários

Entendendo o processo

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

  1. Análise do documento – analisa o arquivo de entrada e constrói uma representação interna.
  2. Extração de comentários – identifica cada comentário, nota de rodapé e anotação.
  3. Geração de HTML – cria HTML limpo e compatível com padrões que espelha o layout original.
  4. Manipulação de recursos – agrupa imagens, CSS e fontes, seja embutido ou como arquivos externos.

Implementação passo a passo

Etapa 1: Configurar seus caminhos de arquivo

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

Por que essa abordagem:

  • Usa a moderna API Path do Java NIO.2, que é mais confiável que java.io.File.
  • Nomes de variáveis descritivos facilitam a depuração.
  • O placeholder {0} no padrão de saída é substituído automaticamente pelos números das páginas.

Etapa 2: Configurar opções de renderização HTML

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

HtmlViewOptions configura como o documento é renderizado para HTML, incluindo manipulação de recursos e renderização de comentários.

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

Detalhes chave de configuração:

  • forEmbeddedResources() incorpora CSS, imagens e fontes diretamente no HTML, tornando a saída portátil.
  • setRenderComments(true) é a única linha que garante que converter word para html retenha todas as notas dos revisores.
  • A alternativa forExternalResources() permite armazenar os recursos separadamente se você preferir um arquivo HTML mais leve.

Etapa 3: Executar a renderização

Now we bring everything together:

Viewer is the primary class used to load a document and perform rendering operations.

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

A chamada view lê o arquivo Word, extrai comentários, gera páginas HTML e as grava em output/html. Cada página é salva como page_1.html, page_2.html, etc.

Exemplo completo em funcionamento

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

Configuração avançada e opções

Configurando diretórios de saída 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 comuns e solução de problemas

Problema 1: Erros “Arquivo não 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: Comentários não aparecem na saída

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: Erros de falta de memória com 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: Desempenho de renderização lento

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

Padrões de implementação do mundo real

Padrão 1: Integração com aplicação 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);
    }
}

Padrão 2: Processamento em lote de múltiplos 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.

Otimização de desempenho e melhores práticas

Dicas de gerenciamento de memória

  • Sempre use try‑with‑resources para instâncias de Viewer.
  • Processar documentos grandes em lotes ao invés de carregar tudo na memória de uma vez.
  • Monitorar o uso do heap da JVM com ferramentas como VisualVM e ajustar -Xmx conforme necessário.
  • Implementar cache adequado para documentos acessados com frequência, evitando renderizações repetidas.

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

Estratégias de cache

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.

Quando usar o GroupDocs Viewer vs alternativas

O GroupDocs Viewer é perfeito para

  • Sistemas de gerenciamento de documentos – precisam exibir muitos tipos de arquivos com anotações.
  • Plataformas colaborativas de revisão – comentários devem permanecer visíveis a todos os participantes.
  • Ferramentas educacionais – notas dos instrutores aparecem ao lado dos slides de aula.
  • Aplicações jurídicas – contratos com comentários de advogados requerem renderização fiel.

Considere alternativas quando

  • Exibição simples de PDF – visualizadores de PDF nativos do navegador podem ser suficientes.
  • Conversão básica de imagens – ImageIO ou bibliotecas semelhantes são mais leves.
  • Extração pura de texto – Apache POI ou iText podem ser mais adequados.

Perguntas frequentes

P: Posso renderizar documentos sem comentários?
R: Sim — basta omitir a chamada setRenderComments(true) ou defini-la como false.

P: Quais formatos de arquivo suportam renderização de comentários?
R: A maioria dos principais formatos — incluindo DOC/DOCX, XLS/XLSX, PPT/PPTX, PDF e muitos outros. Consulte a documentação oficial para a lista completa.

P: Posso personalizar o estilo da saída HTML?
R: Absolutamente. Use HtmlViewOptions.setEmbedResources(false) para gerar arquivos CSS externos, então adicione sua própria folha de estilos após a renderização.

P: Como lidar com documentos protegidos por senha?
R: 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);
}

P: É possível renderizar apenas páginas específicas?
R: Sim — use o método sobrecarregado view que aceita uma coleção PageNumber:

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

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

P: Por que a renderização é lenta para documentos grandes?
R: Large files require more processing time. Improve speed by rendering only needed pages, using external resources, increasing JVM heap, and enabling asynchronous processing.

P: Como posso monitorar o progresso da renderização?
R: While GroupDocs Viewer lacks built‑in callbacks, you can time the operation with System.nanoTime() before and after viewer.view() to log duration.

P: O que acontece se o documento fonte estiver corrompido?
R: The library throws a ViewerException. Wrap the call in a try‑catch block and log the error for graceful degradation.

P: Posso usar o GroupDocs Viewer em uma aplicação comercial?
R: Yes, but a commercial license is required. The free trial includes watermarks that must be removed for production use.

P: Existem limites de uso?
R: The library itself imposes no limits, though your license agreement may define usage caps. Review your contract for details.

P: Posso redistribuir aplicações que incluam o GroupDocs Viewer?
R: You may distribute your own application, but you cannot redistribute the GroupDocs library binaries themselves. Check the license terms for compliance.

Próximos passos e tópicos avançados

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

  • Marca d’água – adicione marcas d’água personalizadas às páginas renderizadas para branding ou confidencialidade.
  • Extração de metadados – recupere autor, data de criação e contagem de páginas via viewer.getDocumentInfo().
  • Visualizadores personalizados – crie visualizadores especializados para PDFs, planilhas ou apresentações que ocultem ou realcem comentários de forma diferente.
  • Integração com armazenamento em nuvem – renderize arquivos diretamente do AWS S3, Azure Blob ou Google Drive sem baixá‑los localmente.

Caminho de aprendizado recomendado

  1. Experimente diferentes tipos de arquivo – teste arquivos Excel, PowerPoint e PDF para ver como os comentários são tratados em diferentes formatos.
  2. Construa um visualizador web simples – crie uma página HTML mínima que carregue o HTML gerado via <iframe> ou AJAX.
  3. Explore o ecossistema GroupDocs – veja GroupDocs Annotation, Comparison e Signature para fluxos de trabalho de documentos de ponta a ponta.
  4. Junte‑se à comunidade – participe do Fórum GroupDocs para dicas, projetos de exemplo e suporte.

Obtendo ajuda e suporte

Official Resources

Community Resources

  • Stack Overflow (tag: groupdocs-viewer)
  • Comunidades de programação no Reddit
  • Servidores Discord de desenvolvedores Java

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

Tutoriais relacionados