Introduction à Jedis

Jedis constitue le client Java privilégié pour communiquer avec Redis. Cette bibliothèque offre une interface simple pour exécuter des opérations Redis à travers du code Java, alignant ses méthodes sur les commandes natives de Redis. Pour intégrer Jedis dans un projet Maven, ajoutez la dépendance suivante, en utilisant une version plus récente pour bénéficier des dernières améliorations :

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.7.0</version> 
</dependency>

Initialisation du client Redis

Pour démarrer une session avec Redis, créez une instance de Jedis en spécifiant l'adresse IP et le port du serveur. Si une authentification est configurée, utilisez la méthode adéquate :

Redis redis = new Redis("192.168.1.10", 6379);
// Si un mot de passe est défini dans redis.conf
// redis.auth("motDePasse");

Manipulation des clés

Les opérations sur les clés permettent de gérer l'existence, l'expiration et les attributs des entrées dans Redis. Voici un exemple illustrant diverses fonctions :

@Test
public void demoCles() {
    redis.flushDB(); // Nettoyer la base de données
    System.out.println(redis.echo("salut"));

    // Vérifier l'existence d'une clé
    redis.set("clePrincipale", "valeur1");
    redis.set("cleSecondaire", "valeur2");
    System.out.println("Existence de 'clePrincipale': " + redis.exists("clePrincipale"));

    // Obtenir une clé aléatoire
    String cleAleatoire = redis.randomKey();
    System.out.println("Clé aléatoire: " + cleAleatoire);

    // Définir une expiration de 120 secondes
    redis.expire("clePrincipale", 120);

    // Consulter le temps de vie restant en millisecondes
    System.out.println("Durée de vie (ms): " + redis.pttl("clePrincipale"));

    // Supprimer l'expiration
    redis.persist("clePrincipale");

    // Identifier le type de la clé
    System.out.println("Type: " + redis.type("clePrincipale"));

    // Exporter la valeur sous forme d'octets
    byte[] donnees = redis.dump("clePrincipale");
    System.out.println("Données exportées: " + new String(donnees));

    // Renommer une clé de manière conditionnelle
    redis.renamenx("clePrincipale", "nouvelleCle");
    System.out.println("'clePrincipale' existe: " + redis.exists("clePrincipale"));
    System.out.println("'nouvelleCle' existe: " + redis.exists("nouvelleCle"));

    // Rechercher des clés par motif
    Set<String> clesTrouvees = redis.keys("cle*");
    System.out.println("Cles correspondantes: " + clesTrouvees);

    // Supprimer une clé
    redis.del("nouvelleCle");
    System.out.println("'nouvelleCle' après suppression: " + redis.exists("nouvelleCle"));
}

Opérations sur les chaînes de caractères

Les chaînes de caractères sont le type de données le plus basique dans Redis. Les opérations incluent la définition, la récupération, la concaténation et la gestion des temps de vie :

@Test
public void demoChaines() {
    redis.set("messageAccueil", "Bonjour");
    System.out.println(redis.get("messageAccueil"));

    // Ajouter du texte à la fin de la chaîne
    redis.append("messageAccueil", " tout le monde");
    System.out.println(redis.get("messageAccueil"));

    // Écraser la valeur existante
    redis.set("messageAccueil", "Salutations");
    System.out.println(redis.get("messageAccueil"));

    // Définir une valeur avec une expiration de 5 secondes
    redis.setex("temporaire", 5, "effimere");
    System.out.println(redis.get("temporaire"));
    try {
        Thread.sleep(6000);
    } catch (InterruptedException e) {
        // Gestion des interruptions
    }
    System.out.println(redis.get("temporaire")); // Retourne null après expiration

    // Insérer plusieurs paires clé-valeur en une seule commande
    redis.mset("cleA", "valA", "cleB", "valB");
    List<String> valeurs = redis.mget("cleA", "cleB");
    System.out.println("Valeurs récupérées: " + valeurs);

    // Supprimer plusieurs clés simultanément
    redis.del("cleA", "cleB");
    System.out.println("'cleA' existe: " + redis.exists("cleA"));
}

Gestion des listes

Les listes dans Redis sont des séquences ordonnées d'éléments. Elles supportent les opérations d'ajout, de retrait, de consultation et de modification :

@Test
public void demoListes() {
    String nomListe = "fileAttente";
    redis.del(nomListe);

    // Ajouter des éléments à la fin de la liste
    redis.rpush(nomListe, "premier", "deuxieme", "troisieme");
    redis.rpush(nomListe, "quatrieme", "cinquieme");

    // Déterminer la longueur de la liste
    System.out.println("Nombre d'éléments: " + redis.llen(nomListe));

    // Afficher tous les éléments
    System.out.println("Contenu complet: " + redis.lrange(nomListe, 0, -1));

    // Accéder à un élément par son index
    System.out.println("Élément à l'index 2: " + redis.lindex(nomListe, 2));

    // Modifier un élément à un index spécifique
    redis.lset(nomListe, 2, "elementModifie");
    System.out.println("Après modification: " + redis.lrange(nomListe, 0, -1));

    // Insérer des éléments au début de la liste
    redis.lpush(nomListe, "nouveauDebut", "autreDebut");
    System.out.println("Après ajout au début: " + redis.lrange(nomListe, 0, -1));

    // Retirer des éléments des extrémités
    String retireFin = redis.rpop(nomListe);
    String retireDebut = redis.lpop(nomListe);
    System.out.println("Éléments retirés: " + retireFin + ", " + retireDebut);

    // Supprimer des occurrences spécifiques
    redis.lrem(nomListe, 1, "troisieme");
    System.out.println("Après suppression: " + redis.lrange(nomListe, 0, -1));

    // Extraire une sous-liste et limiter la liste
    System.out.println("Sous-liste index 0 à 2: " + redis.lrange(nomListe, 0, 2));
    redis.ltrim(nomListe, 0, 2);
    System.out.println("Liste après troncation: " + redis.lrange(nomListe, 0, -1));
}

Utilisation des ensembles

Les ensembles stockent des éléments uniques non ordonnés. Ils permettent des opérations ensemblistes comme l'intersection, l'union et la différence :

@Test
public void demoEnsembles() {
    redis.flushDB();
    String ensemble1 = "donneesUtilisateur";
    String ensemble2 = "donneesSysteme";

    // Remplir les ensembles
    redis.sadd(ensemble1, "alpha", "beta", "gamma");
    redis.sadd(ensemble2, "beta", "gamma", "delta");

    // Compter les éléments
    System.out.println("Taille de " + ensemble1 + ": " + redis.scard(ensemble1));

    // Calculer et stocker l'intersection
    redis.sinterstore("resultatIntersection", ensemble1, ensemble2);
    System.out.println("Intersection: " + redis.smembers("resultatIntersection"));

    // Calculer et stocker l'union
    redis.sunionstore("resultatUnion", ensemble1, ensemble2);
    System.out.println("Union: " + redis.smembers("resultatUnion"));

    // Calculer la différence (éléments dans ensemble1 mais pas dans ensemble2)
    redis.sdiffstore("resultatDifference", ensemble1, ensemble2);
    System.out.println("Différence: " + redis.smembers("resultatDifference"));

    // Vérifier l'appartenance d'un élément
    System.out.println("'alpha' dans " + ensemble1 + "? " + redis.sismember(ensemble1, "alpha"));

    // Sélectionner un élément aléatoire
    System.out.println("Élément aléatoire: " + redis.srandmember(ensemble1));

    // Déplacer un élément entre ensembles
    redis.smove(ensemble1, ensemble2, "alpha");
    System.out.println(ensemble1 + " après déplacement: " + redis.smembers(ensemble1));
    System.out.println(ensemble2 + " après déplacement: " + redis.smembers(ensemble2));

    // Retirer et récupérer un élément aléatoire
    String retire = redis.spop(ensemble2);
    System.out.println("Élément retiré de " + ensemble2 + ": " + retire);

    // Supprimer des éléments spécifiques
    redis.srem(ensemble2, "gamma", "delta");
    System.out.println(ensemble2 + " après suppression: " + redis.smembers(ensemble2));
}

Travail avec les ensembles triés

Les ensembles triés associent chaque élément à un score, permettant un classement automatique. Ils sont utiles pour des classements ou des requêtes par plage de valeurs :

@Test
public void demoEnsemblesTries() {
    redis.flushDB();
    String cle = "scoresJoueurs";

    // Ajouter des éléments avec des scores
    redis.zadd(cle, 1500.0, "alice");
    redis.zadd(cle, 2300.0, "bob");
    redis.zadd(cle, 1800.0, "charlie");
    Map<String, Double> joueurs = new HashMap<>();
    joueurs.put("diana", 2100.0);
    joueurs.put("eve", 1950.0);
    redis.zadd(cle, joueurs);

    // Obtenir le nombre d'éléments
    System.out.println("Nombre de joueurs: " + redis.zcard(cle));

    // Lister les éléments par score croissant
    Set<String> classementAsc = redis.zrange(cle, 0, -1);
    System.out.println("Classement ascendant: " + classementAsc);

    // Lister les éléments par score décroissant
    Set<String> classementDesc = redis.zrevrange(cle, 0, -1);
    System.out.println("Classement descendant: " + classementDesc);

    // Récupérer le score d'un élément
    System.out.println("Score de bob: " + redis.zscore(cle, "bob"));

    // Supprimer un élément
    redis.zrem(cle, "alice");
    System.out.println("Après suppression: " + redis.zrange(cle, 0, -1));

    // Compter les éléments dans une plage de scores
    System.out.println("Joueurs entre 1800 et 2200: " + redis.zcount(cle, 1800.0, 2200.0));
}

Opérations sur les hachages

Les hachages représentent des objets avec des paires champ-valeur. Ils sont idéaux pour stocker des structures complexes sous une seule clé :

@Test
public void demoHachages() {
    redis.flushDB();
    String objet = "profilUtilisateur";

    // Créer un hachage avec plusieurs champs
    Map<String, String> donnees = new HashMap<>();
    donnees.put("nom", "Dupont");
    donnees.put("age", "30");
    donnees.put("email", "dupont@example.com");
    redis.hmset(objet, donnees);
    redis.hset(objet, "actif", "true");

    // Lister tous les champs
    System.out.println("Champs: " + redis.hkeys(objet));

    // Récupérer toutes les valeurs
    System.out.println("Valeurs: " + redis.hvals(objet));

    // Obtenir la taille du hachage
    System.out.println("Nombre de champs: " + redis.hlen(objet));

    // Exporter l'ensemble du hachage
    Map<String, String> complet = redis.hgetAll(objet);
    System.out.println("Contenu complet: " + complet);

    // Vérifier l'existence d'un champ
    System.out.println("Champ 'age' existe? " + redis.hexists(objet, "age"));

    // Récupérer des valeurs spécifiques
    List<String> selection = redis.hmget(objet, "nom", "email");
    System.out.println("Valeurs sélectionnées: " + selection);

    // Accéder à une valeur unique
    System.out.println("Valeur de 'nom': " + redis.hget(objet, "nom"));

    // Supprimer un champ
    redis.hdel(objet, "email");
    System.out.println("Après suppression: " + redis.hgetAll(objet));

    // Incrémenter une valeur numérique
    redis.hincrBy(objet, "age", 5);
    System.out.println("Age incrémenté: " + redis.hget(objet, "age"));
}

Gestion des transactions

Les transactions dans Redis permettent d'exécuter un groupe de commandes de manière atomique. Avec Jedis, on utilise l'objet Transaction pour regrouper les opérations :

@Test
public void demoTransactions() {
    Transaction transaction = redis.multi();

    // Ajouter des commandes à la transaction
    transaction.set("transaction:cle1", "valeurTrans1");
    Response<String> reponse = transaction.get("transaction:cle1");

    transaction.zadd("transaction:ensemble", 10, "itemA");
    transaction.zadd("transaction:ensemble", 20, "itemB");
    transaction.zadd("transaction:ensemble", 15, "itemC");
    Response<Set<String>> elements = transaction.zrange("transaction:ensemble", 0, -1);

    // Exécuter la transaction
    transaction.exec();

    // Récupérer les résultats
    String valeurRecuperee = reponse.get();
    System.out.println("Valeur stockée: " + valeurRecuperee);

    Set<String> ensembleResultat = elements.get();
    System.out.println("Éléments de l'ensemble: " + ensembleResultat);
    System.out.println("Nombre d'éléments: " + ensembleResultat.size());
}