mise en cache java redis : mettre en cache les documents en Java avec Redis

Dans les applications web modernes, servir le même document converti à plusieurs reprises peut gaspiller des cycles CPU et augmenter les temps de réponse. java redis caching résout ce problème en stockant la sortie de conversion dans un magasin de données rapide, en mémoire, de sorte que les requêtes suivantes sont servies instantanément. Dans ce tutoriel, vous apprendrez comment intégrer Redis dans un flux de travail GroupDocs.Conversion, configurer les TTL et mesurer les gains de performance que vous pouvez attendre.

Réponses rapides

  • Quel est le sujet de ce tutoriel ? Un tutoriel complet sur la mise en cache java redis qui intègre Redis avec GroupDocs.Conversion.
  • Pourquoi utiliser Redis ? Il offre une latence sous‑milliseconde, prend en charge l’expiration TTL et s’échelonne horizontalement sur plusieurs instances d’application.
  • Ai‑je besoin d’une licence GroupDocs ? Une licence d’essai ou temporaire suffit pour les tests ; une licence complète est requise pour les déploiements en production.
  • Quelles sont les principales étapes ? Ajouter les dépendances Maven, configurer un JedisPool, créer des méthodes d’aide au cache et brancher le cache dans le pipeline de conversion.
  • Quelle version de Java est prise en charge ? Java 8+ (compatible avec les dernières versions de GroupDocs.Conversion).

Qu’est‑ce que la mise en cache de documents avec Redis ?

La mise en cache de documents avec Redis consiste à persister la sortie binaire d’une conversion (par ex., un tableau d’octets PDF) dans Redis afin que les futures requêtes identiques puissent récupérer les octets mis en cache au lieu de relancer le moteur de conversion. Cela élimine le travail CPU redondant, réduit la bande passante réseau et offre une expérience utilisateur plus fluide.

Pourquoi implémenter un cache Redis en Java ?

Chargez votre document une fois, stockez le résultat et servez‑le instantanément lors des accès répétés. Le cache basé sur Redis peut réduire le temps de conversion jusqu’à 90 % pour les fichiers fréquemment consultés, diminuer les coûts d’infrastructure en réduisant l’utilisation CPU, et fournir une source unique de vérité pour tous les nœuds d’application dans un environnement clusterisé.

Prérequis

  • GroupDocs.Conversion – version 25.2 ou plus récente (prend en charge 120+ formats d’entrée et de sortie).
  • Jedis (le client officiel Redis pour Java).
  • Une instance Redis en cours d’exécution (le développement local peut utiliser le défaut localhost:6379).
  • Maven pour la gestion des dépendances.
  • Familiarité de base avec la gestion des exceptions Java et les flux I/O.

Configuration de GroupDocs.Conversion pour Java

GroupDocs.Conversion est une bibliothèque Java qui convertit et rend les documents dans un large éventail de formats, en gérant automatiquement la préservation de la mise en page, l’incorporation des polices et l’extraction d’images.

Ajoutez le dépôt GroupDocs et la dépendance à votre 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>

Obtention de licence

Vous pouvez commencer avec un Essai gratuit, demander une Licence temporaire pour l’évaluation, ou acheter une Licence complète pour la production.

Initialisez GroupDocs.Conversion dans votre code Java :

import com.groupdocs.conversion.*;

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

Guide d’implémentation

Création d’un cache personnalisé avec Redis

Vue d’ensemble

Un cache Redis personnalisé conserve les octets du document rendu, permettant une récupération instantanée lors de requêtes répétées.

Configuration de JedisPool

JedisPool est un pool thread‑safe de connexions Redis réutilisables qui minimise la surcharge des sockets et améliore le débit.

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

Stockage et récupération des données en cache

Les méthodes d’aide ci‑dessous sérialisent un tableau d’octets en chaîne Base64 pour un stockage sûr et le récupèrent ensuite sous forme de tableau d’octets.

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

Intégration avec GroupDocs.Conversion

Intégrez maintenant le cache dans le flux de travail de conversion. La méthode vérifie d’abord le cache ; en cas de miss, elle effectue la conversion, stocke le résultat et renvoie les octets.

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

Comment mettre en œuvre la mise en cache java redis ?

ConversionApi est la classe principale de GroupDocs.Conversion qui exécute les opérations de conversion de documents.

Chargez votre document source, générez une clé de cache déterministe, recherchez‑la dans Redis, et n’invoquez ConversionApi que lorsque la clé est absente. Ce modèle garantit que chaque conversion unique n’est effectuée qu’une fois, puis servie depuis le cache pendant la durée du TTL configuré.

Conseils de dépannage

  • Vérifiez que le serveur Redis est accessible (redis-cli ping doit renvoyer PONG).
  • Assurez‑vous que l’hôte et le port de JedisPool correspondent à votre déploiement Redis.
  • Enveloppez les appels au cache dans des blocs try‑catch pour gérer les interruptions de connexion sans interrompre le flux de conversion.
  • Surveillez la mémoire Redis (INFO memory) et définissez des politiques maxmemory (par ex., volatile-lru) pour évincer les anciennes entrées de façon fluide.
  • Si vous rencontrez OutOfMemoryError sur la JVM, augmentez la taille du heap ou activez -XX:+UseCompressedOops.

Applications pratiques

  1. Portails à fort trafic – Servir instantanément les PDF fréquemment demandés (catalogues, livres blancs).
  2. DMS d’entreprise – Réduire la charge lorsque les utilisateurs consultent à plusieurs reprises les mêmes contrats ou documents de politique.
  3. E‑commerce – Mettre en cache les factures générées ou les catalogues produits pour accélérer le processus de paiement.
  4. Plateformes d’apprentissage – Fournir notes de cours et e‑books sans re‑rendu à chaque demande d’étudiant.
  5. Services juridiques – Accélérer la distribution des dossiers de cas tout en maintenant les coûts de stockage bas.

Considérations de performance

  • Ajuster Redis – Modifiez maxmemory, choisissez une politique d’éviction comme allkeys-lru, et définissez des valeurs timeout appropriées selon votre trafic.
  • Suivre les ratios hit/miss du cache – Utilisez INFO stats ou les compteurs keyspace_hits / keyspace_misses de Redis pour affiner les TTL.
  • Dimensionnement du heap JVM – Assurez‑vous que le heap peut contenir les tampons GroupDocs ; une règle de base est 1 Go de heap pour chaque 100 Mo de charge de conversion concurrente.
  • Conversions par lots – Lors de la conversion de nombreux fichiers, réutilisez une seule instance Jedis par thread pour minimiser le churn des sockets.

Questions fréquentes

Q : Puis‑je utiliser cette approche avec d’autres formats de sortie GroupDocs ?
R : Absolument. Le même modèle de cache fonctionne pour DOCX, HTML, images, etc. – il suffit de changer le type ConvertOptions.

Q : Comment choisir une bonne clé de cache ?
R : Combinez le chemin du fichier source, les options de conversion et tout identifiant de version. Cela garantit l’unicité par configuration.

Q : Que se passe‑t‑il si un document change après avoir été mis en cache ?
R : Invalidez le cache manuellement (par ex., supprimez la clé) ou utilisez un TTL plus court afin que les données périmées expirent rapidement.

Q : Redis est‑il la seule option de mise en cache ?
R : Non, mais Redis offre une latence faible, un TTL intégré et un large support client Java, ce qui en fait un choix populaire pour ce scénario.

Q : Cette solution augmente‑t‑elle l’utilisation de mémoire sur le serveur d’application ?
R : Minimalement. Le travail lourd est effectué par Redis ; l’application ne conserve que des connexions de courte durée via Jedis.

Conclusion

Vous disposez maintenant d’un tutoriel complet java redis caching montrant comment mettre en cache des documents avec Redis et GroupDocs.Conversion. En persistant la sortie rendue dans Redis, vous augmenterez les performances de rendu, réduirez le temps de conversion et offrirez une expérience plus fluide aux utilisateurs finaux. Expérimentez avec différentes valeurs TTL, surveillez les métriques du cache et étendez le modèle à d’autres formats de documents à mesure que votre application se développe.

Dernière mise à jour : 2026-07-19
Testé avec : GroupDocs.Conversion 25.2, Jedis 4.2.3
Auteur : 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");
    }
}

Tutoriels associés