java redis caching: Cache de Documentos em Java com Redis

Em aplicações web modernas, servir o mesmo documento convertido repetidamente pode desperdiçar ciclos de CPU e inflar os tempos de resposta. java redis caching resolve esse problema armazenando a saída da conversão em um armazenamento de dados rápido, em memória, de modo que solicitações subsequentes sejam atendidas instantaneamente. Neste tutorial você aprenderá como integrar o Redis em um fluxo de trabalho do GroupDocs.Conversion, configurar TTLs e medir os ganhos de desempenho que pode esperar.

Respostas Rápidas

  • O que este tutorial cobre? Um tutorial completo de java redis caching que integra Redis com GroupDocs.Conversion.
  • Por que usar o Redis? Ele oferece latência sub‑milissegundo, suporta expiração TTL e escala horizontalmente em múltiplas instâncias da aplicação.
  • Preciso de uma licença GroupDocs? Uma licença de avaliação ou temporária serve para testes; uma licença completa é necessária para implantações em produção.
  • Quais são os principais passos? Adicionar dependências Maven, configurar um JedisPool, criar métodos auxiliares de cache e conectar o cache ao pipeline de conversão.
  • Qual versão do Java é suportada? Java 8+ (compatível com as versões mais recentes do GroupDocs.Conversion).

O que é cache de documentos com Redis?

Cachear documentos com Redis significa persistir a saída binária de uma conversão (por exemplo, um array de bytes PDF) no Redis para que solicitações futuras idênticas possam recuperar os bytes em cache em vez de executar novamente o motor de conversão. Isso elimina trabalho redundante de CPU, reduz a largura de banda de rede e oferece uma experiência de usuário final mais fluida.

Por que implementar cache Redis em Java?

Carregue seu documento uma vez, armazene o resultado e sirva-o instantaneamente em acessos repetidos. O cache suportado por Redis pode reduzir o tempo de conversão em até 90 % para arquivos acessados com frequência, diminuir custos de infraestrutura ao reduzir o uso de CPU e fornecer uma única fonte de verdade para todos os nós da aplicação em um ambiente clusterizado.

Pré-requisitos

  • GroupDocs.Conversion – versão 25.2 ou mais recente (suporta 120+ formatos de entrada e saída).
  • Jedis (o cliente oficial do Redis para Java).
  • Uma instância Redis em execução (o desenvolvimento local pode usar o padrão localhost:6379).
  • Maven para gerenciamento de dependências.
  • Familiaridade básica com tratamento de exceções Java e fluxos de I/O.

Configurando GroupDocs.Conversion para Java

GroupDocs.Conversion é uma biblioteca Java que converte e renderiza documentos para uma ampla gama de formatos, lidando automaticamente com preservação de layout, incorporação de fontes e extração de imagens.

Adicione o repositório GroupDocs e a dependência ao seu pom.xml:

<repositories>
    <repository>
        <id>groupdocs-maven</id>
        <url>https://repo.groupdocs.com/maven</url>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>com.groupdocs</groupId>
        <artifactId>groupdocs-conversion</artifactId>
        <version>25.2.0</version>
    </dependency>
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>4.2.3</version>
    </dependency>
</dependencies>

Aquisição de Licença

Você pode começar com um Free Trial, solicitar uma Temporary License para avaliação ou adquirir uma License completa para uso em produção.

Inicialize o GroupDocs.Conversion no seu código Java:

import com.groupdocs.conversion.*;

ConversionConfig config = new ConversionConfig();
config.setLicensePath("path/to/license/file.lic");
ConversionApi conversionApi = new ConversionApi(config);

Guia de Implementação

Criando um Cache Personalizado Usando Redis

Visão Geral

Um cache Redis personalizado mantém os bytes do documento renderizado, permitindo recuperação instantânea em solicitações repetidas.

Configurando JedisPool

JedisPool é um pool thread‑safe de conexões Redis reutilizáveis que minimiza a sobrecarga de sockets e melhora a taxa de transferência.

import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(20);               // maximum active connections
poolConfig.setMaxIdle(10);                // maximum idle connections
poolConfig.setMinIdle(2);                 // minimum idle connections
JedisPool jedisPool = new JedisPool(poolConfig, "localhost", 6379);

Armazenando e Recuperando Dados em Cache

Os métodos auxiliares abaixo serializam um array de bytes para uma string Base64 para armazenamento seguro e o recuperam de volta para um array de bytes.

import java.util.Base64;
import redis.clients.jedis.Jedis;

public class RedisCacheHelper {

    private final JedisPool pool;
    private final int ttlSeconds; // time‑to‑live for cached entries

    public RedisCacheHelper(JedisPool pool, int ttlSeconds) {
        this.pool = pool;
        this.ttlSeconds = ttlSeconds;
    }

    public void put(String key, byte[] data) {
        try (Jedis jedis = pool.getResource()) {
            String encoded = Base64.getEncoder().encodeToString(data);
            jedis.setex(key, ttlSeconds, encoded); // configure redis ttl
        }
    }

    public byte[] get(String key) {
        try (Jedis jedis = pool.getResource()) {
            String encoded = jedis.get(key);
            return encoded != null ? Base64.getDecoder().decode(encoded) : null;
        }
    }
}

Integração com GroupDocs.Conversion

Agora conecte o cache ao fluxo de trabalho de conversão. O método verifica o cache primeiro; se houver um miss, ele executa a conversão, armazena o resultado e retorna os bytes.

import com.groupdocs.conversion.options.convertoptions.PdfConvertOptions;

public class DocumentService {

    private final ConversionApi conversionApi;
    private final RedisCacheHelper cacheHelper;

    public DocumentService(ConversionApi conversionApi, RedisCacheHelper cacheHelper) {
        this.conversionApi = conversionApi;
        this.cacheHelper = cacheHelper;
    }

    public byte[] convertToPdf(String sourcePath, PdfConvertOptions options) throws Exception {
        // Build a deterministic cache key
        String cacheKey = "pdf:" + sourcePath + ":" + options.hashCode();

        // Attempt to fetch from Redis
        byte[] cached = cacheHelper.get(cacheKey);
        if (cached != null) {
            // Cache hit – return stored bytes
            return cached;
        }

        // Cache miss – perform conversion
        byte[] result = conversionApi.convert(sourcePath, options).toByteArray();

        // Store result for future calls
        cacheHelper.put(cacheKey, result);
        return result;
    }
}

Como implementar cache java redis?

ConversionApi é a classe principal no GroupDocs.Conversion que executa operações de conversão de documentos.

Carregue seu documento fonte, gere uma chave de cache determinística, procure-a no Redis e invoque ConversionApi apenas quando a chave estiver ausente. Esse padrão garante que cada conversão única seja realizada uma vez, depois servida a partir do cache durante a duração do TTL configurado.

Dicas de Solução de Problemas

  • Verifique se o servidor Redis está acessível (redis-cli ping deve retornar PONG).
  • Certifique-se de que o host e a porta do JedisPool correspondam à sua implantação Redis.
  • Envolva chamadas de cache em blocos try‑catch para lidar com falhas de conectividade sem interromper o fluxo de conversão.
  • Monitore a memória do Redis (INFO memory) e defina políticas maxmemory (ex.: volatile-lru) para expulsar entradas antigas de forma graciosa.
  • Se encontrar OutOfMemoryError na JVM, aumente o tamanho do heap ou habilite -XX:+UseCompressedOops.

Aplicações Práticas

  1. Portais de alto tráfego – Sirva PDFs solicitados com frequência (catálogos, whitepapers) instantaneamente.
  2. DMS empresarial – Reduza a carga quando usuários visualizam repetidamente os mesmos contratos ou documentos de política.
  3. E‑commerce – Cacheie faturas geradas ou catálogos de produtos para acelerar o checkout.
  4. Plataformas de aprendizado – Entregue notas de aula e e‑books sem reprocessar a cada solicitação de estudante.
  5. Serviços jurídicos – Acelere a distribuição de processos enquanto mantém baixos custos de armazenamento.

Considerações de Desempenho

  • Ajuste o Redis – Modifique maxmemory, escolha uma política de expulsão como allkeys-lru e defina valores de timeout adequados ao seu padrão de tráfego.
  • Acompanhe as taxas de acerto/miss do cache – Use INFO stats ou os contadores keyspace_hits / keyspace_misses do Redis para afinar os TTLs.
  • Dimensionamento do heap JVM – Garanta que o heap comporte os buffers do GroupDocs; uma regra prática é 1 GB de heap para cada 100 MB de carga de conversão simultânea.
  • Conversões em lote – Ao converter muitos arquivos, reutilize uma única instância Jedis por thread para minimizar a rotatividade de sockets.

Perguntas Frequentes

Q: Posso usar esta abordagem com outros formatos de saída do GroupDocs?
A: Absolutamente. O mesmo padrão de cache funciona para DOCX, HTML, imagens e mais – basta mudar o tipo ConvertOptions.

Q: Como escolher uma boa chave de cache?
A: Combine o caminho do arquivo fonte, as opções de conversão e quaisquer identificadores de versão. Isso garante unicidade por configuração.

Q: E se um documento mudar depois de ser cacheado?
A: Invalide o cache manualmente (ex.: exclua a chave) ou use um TTL mais curto para que dados obsoletos expirem rapidamente.

Q: O Redis é a única opção de cache?
A: Não, mas o Redis oferece baixa latência, TTL embutido e amplo suporte a clientes Java, tornando‑o uma escolha popular para este cenário.

Q: Isso aumenta o uso de memória no servidor de aplicação?
A: Mínimo. O trabalho pesado é feito pelo Redis; a aplicação mantém apenas conexões de curta duração via Jedis.

Conclusão

Agora você tem um tutorial completo de java redis caching que demonstra como cachear documentos usando Redis e GroupDocs.Conversion. Ao persistir a saída renderizada no Redis, você aumentará o desempenho de renderização, reduzirá o tempo de conversão e proporcionará uma experiência mais fluida aos usuários finais. Experimente diferentes valores de TTL, monitore métricas de cache e estenda o padrão a outros formatos de documento à medida que sua aplicação cresce.

Última atualização: 2026-07-19
Testado com: GroupDocs.Conversion 25.2, Jedis 4.2.3
Autor: GroupDocs

<repositories>
   <repository>
      <id>repository.groupdocs.com</id>
      <name>GroupDocs Repository</name>
      <url>https://releases.groupdocs.com/conversion/java/</url>
   </repository>
</repositories>

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

import com.groupdocs.conversion.Converter;
import com.groupdocs.conversion.options.convert.PdfConvertOptions;

public class DocumentConversion {
    public static void main(String[] args) {
        // Initialize the Converter with a document path
        Converter converter = new Converter("input.docx");
        
        // Set up conversion options for PDF
        PdfConvertOptions options = new PdfConvertOptions();
        converter.convert("output.pdf", options);
    }
}

import redis.clients.jedis.JedisPool;

public class CacheManager {
    private static JedisPool jedisPool = new JedisPool("localhost", 6379);
    
    public static void main(String[] args) {
        // Additional cache setup code here
    }
}

import redis.clients.jedis.Jedis;

public class CacheManager {

    public static void storeDocument(String key, String documentContent) {
        try (Jedis jedis = jedisPool.getResource()) {
            // Set the content in Redis cache with an expiration time of one hour
            jedis.setex(key, 3600, documentContent);
        }
    }

    public static String retrieveDocument(String key) {
        try (Jedis jedis = jedisPool.getResource()) {
            return jedis.get(key); // Retrieve cached content if available
        }
    }
}

public class DocumentConversion {

    public static void convertWithCache(String inputPath, String outputPath) {
        Converter converter = new Converter(inputPath);
        PdfConvertOptions options = new PdfConvertOptions();

        // Generate a cache key based on the document path and conversion settings
        String cacheKey = "doc:" + inputPath;

        // Check if the converted document is already cached
        String cachedDocument = CacheManager.retrieveDocument(cacheKey);

        if (cachedDocument != null) {
            System.out.println("Using cached version of the document.");
            // Save cached content to output file
            Files.write(Paths.get(outputPath), cachedDocument.getBytes());
        } else {
            // Perform conversion and cache the result
            converter.convert(output -> {
                String documentContent = new String(output.toByteArray());
                CacheManager.storeDocument(cacheKey, documentContent);
                Files.write(Paths.get(outputPath), output.toByteArray());
            }, options);
        }
    }

    public static void main(String[] args) {
        convertWithCache("input.docx", "output.pdf");
    }
}

Tutoriais Relacionados