Jedis est un client Java robuste et très utilisé pour Redis, une base de données clé-valeur en mémoire performante. Ce guide présente les bases de l'établissement de connexions avec un serveur Redis en utilisant Jedis, à la fois via une connexion directe simple et en exploitant le mécanisme de pool de connexions pour une gestion plus efficace des ressources.

Configuration du Projet Maven

Pour commencer, créez un nouveau projet Maven. La première étape consiste à ajouter la dépednance Jedis à votre fichier pom.xml. Cela permettra à votre projet d'accéder à toutes les classes et méthodes offertes par la bibliothèque Jedis.

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>fr.example</groupId>
 <artifactId>jedis-introduction</artifactId>
 <version>1.0.0-SNAPSHOT</version>
 
 <properties>
   <java.version>1.8</java.version>
   <jedis.version>2.9.0</jedis.version>
 </properties>

 <dependencies>
     <dependency>
       <groupId>redis.clients</groupId>
       <artifactId>jedis</artifactId>
       <version>${jedis.version}</version>
   </dependency>
 </dependencies>
</project>

Connexion Directe à Redis avec Jedis

Une fois le projet configuré, vous pouvez établir une connexion directe à votre serveur Redis. L'exemple suivant illustre comment créer une instance Jedis, s'authentifier, puis stocker et récupérer une valeur simple.

package fr.example.redis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.exceptions.JedisConnectionException;

public class SimpleJedisConnection {
   public static void main(String[] args) {
       // Définir l'hôte et le port de votre instance Redis
       String redisHost = "192.168.8.102";
       int redisPort = 6379;
       String password = "123456"; // Mot de passe pour l'authentification Redis

       Jedis clientJedis = null;
       try {
           // Établir une connexion directe avec le serveur Redis
           clientJedis = new Jedis(redisHost, redisPort);
           System.out.println("Connexion à Redis établie avec succès.");

           // S'authentifier auprès du serveur Redis (si un mot de passe est configuré)
           clientJedis.auth(password);
           System.out.println("Authentification Redis réussie.");

           // Stocker une paire clé-valeur
           String key = "messageApp";
           String initialValue = "Bonjour de Jedis!";
           clientJedis.set(key, initialValue);
           System.out.println("Valeur définie pour la clé '" + key + "': " + initialValue);

           // Récupérer la valeur associée à la clé
           String retrievedValue = clientJedis.get(key);
           System.out.println("Valeur récupérée pour la clé '" + key + "': " + retrievedValue);

       } catch (JedisConnectionException e) {
           System.err.println("Erreur de connexion à Redis : Vérifiez l'hôte, le port et la connectivité réseau. " + e.getMessage());
           e.printStackTrace();
       } catch (Exception e) {
           System.err.println("Une erreur inattendue s'est produite lors de l'opération Jedis : " + e.getMessage());
           e.printStackTrace();
       } finally {
           // Fermer la connexion Jedis pour libérer les ressources
           if (clientJedis != null) {
               clientJedis.close();
               System.out.println("Connexion Jedis fermée.");
           }
       }
   }
}

Dépannage des Problèmes de Connexion Fréquents

Lors de la première connexion à Redis, plusieurs problèmes courants peuvent survenir. Voici comment les résoudre :

1. Erreur de Délai d'Attente de Connexion (java.net.SocketTimeoutException: connect timed out)

Cette erreur indique généralement que le client Java ne peut pas atteindre le port Redis sur le serveur. La cause la plus probable est un pare-feu bloquant la connexion. Assurez-vous que le port 6379 (ou le port Redis configuré) est ouvert sur le serveur.

Exemple de commandes pour ouvrir le port 6379 avec firewalld sur Linux :

sudo firewall-cmd --zone=public --add-port=6379/tcp --permanent
sudo firewall-cmd --reload

2. Erreur de Connexion Refusée (java.net.ConnectException: Connection refused: connect)

Cette erreur se produit souvent lorsque Redis n'est pas configuré pour écouter les connexions provenant d'adresses IP externes. Par défaut, Redis peut être configuré pour n'écouter que 127.0.0.1 (localhost).

Pour résoudre ce problème, éditez le fichier de configuration redis.conf (généralement situé dans /etc/redis/redis.conf ou /usr/local/redis/redis.conf) et commentez ou modifiez la dierctive bind :

# Trouvez la ligne suivante:
# bind 127.0.0.1 -::1
# Et commentez-la ou modifiez-la pour permettre l'écoute sur toutes les interfaces ou une interface spécifique:
# bind 0.0.0.0
# Ou commentez-la entièrement pour écouter sur toutes les interfaces disponibles.

N'oubliez pas de redémarrer le service Redis après avoir modifié le fichier de configuration.

3. Erreur de Mode Protégé (redis.clients.jedis.exceptions.JedisDataException: DENIED Redis is running in protected mode because protected mode is enabled)

Redis dispose d'un "mode protégé" qui limite l'accès aux clients non authentifiés provenant d'adresses IP différentes de localhost. Si vous devez accéder à Redis à distance sans désactiver ce mode, la meilleure pratique est de configurer un mot de passe pour Redis et de l'utiliser pour l'authentification.

Pour définir un mot de passe pour Redis (ici, "123456") via la CLI Redis :

[root@localhost redis]# ./bin/redis-cli
127.0.0.1:6379> config set requirepass 123456
OK
127.0.0.1:6379> config rewrite
OK
127.0.0.1:6379> quit

Après cela, toute tentative d'accès sans authentification échouera. Vous devrez fournir le mot de passe via AUTH dans la CLI ou la méthode auth() dans Jedis.

[root@localhost redis]# ./bin/redis-cli
127.0.0.1:6379> get messageApp
(error) NOAUTH Authentication required.
127.0.0.1:6379> auth 123456
OK
127.0.0.1:6379> get messageApp
"Bonjour de Jedis!"

Assurez-vous que le mot de passe défini dans le code Java correspond à celui configuré sur le serveur Redis.

Gestion des Connexions avec Jedis Pool

Pour les applications en production ou celles nécessitant des performances optimales, l'utilisation d'un pool de connexions est essentielle. Un JedisPool gère un ensemble de connexions à Redis, réduisant la sucrharge liée à l'ouverture et à la fermeture répétées des connexions.

package fr.example.redis;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.exceptions.JedisConnectionException;
import redis.clients.jedis.exceptions.JedisDataException;

public class RedisConnectionPoolExample {
   private static final String REDIS_HOST = "192.168.8.102";
   private static final int REDIS_PORT = 6379;
   private static final String REDIS_PASSWORD = "123456"; // Mot de passe Redis

   public static void main(String[] args) {
       // Configuration du pool de connexions
       JedisPoolConfig poolConfiguration = new JedisPoolConfig();
       poolConfiguration.setMaxTotal(50);         // Nombre maximal de connexions actives dans le pool
       poolConfiguration.setMaxIdle(5);           // Nombre maximal de connexions inactives dans le pool
       poolConfiguration.setMinIdle(1);           // Nombre minimal de connexions inactives dans le pool
       poolConfiguration.setBlockWhenExhausted(true); // Bloquer les appels getResource() si le pool est épuisé

       JedisPool connectionManager = null;
       Jedis resource = null;

       try {
           // Initialisation du pool de connexions Jedis.
           // Le mot de passe peut être passé directement au constructeur du pool.
           connectionManager = new JedisPool(poolConfiguration, REDIS_HOST, REDIS_PORT, 2000, REDIS_PASSWORD);
           System.out.println("JedisPool initialisé avec succès.");

           // Obtenir une instance Jedis du pool.
           // Cette instance est une connexion prête à l'emploi.
           resource = connectionManager.getResource();
           System.out.println("Instance Jedis obtenue du pool.");

           // Effectuer des opérations Redis
           String appKey = "config.appName";
           String appValue = "MonApplicationJedis";
           resource.set(appKey, appValue);
           System.out.println("Clé '" + appKey + "' définie avec la valeur : " + resource.get(appKey));

           String userKey = "user:1001:email";
           resource.set(userKey, "utilisateur@exemple.com");
           System.out.println("Clé '" + userKey + "' définie avec la valeur : " + resource.get(userKey));

       } catch (JedisConnectionException e) {
           System.err.println("Erreur de connexion au pool Redis : " + e.getMessage());
           e.printStackTrace();
       } catch (JedisDataException e) {
           System.err.println("Erreur de données Redis (ex: authentification ou commande invalide) : " + e.getMessage());
           e.printStackTrace();
       } catch (Exception e) {
           System.err.println("Une erreur inattendue s'est produite lors de l'utilisation du pool : " + e.getMessage());
           e.printStackTrace();
       } finally {
           // Très important : Retourner l'instance Jedis au pool.
           // La méthode close() sur une ressource Jedis obtenue d'un pool ne ferme pas la connexion physique,
           // mais la renvoie au pool pour une réutilisation.
           if (resource != null) {
               resource.close();
               System.out.println("Instance Jedis retournée au pool.");
           }
           // Fermer le pool de connexions lors de l'arrêt de l'application
           // C'est une opération coûteuse et ne doit être appelée qu'une seule fois à la fin du cycle de vie de l'application.
           if (connectionManager != null) {
               connectionManager.close();
               System.out.println("Pool de connexions Jedis fermé.");
           }
       }
   }
}