Ajout des dépendences nécessaires

Pour intégrer Redis à Spring Boot avec le pool de connexions Lettuce, incluez ces dépendances dans votre fichier pom.xml.

<!-- Dépendance Spring Data Redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- Dépendance pour le pool de connexions -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

Paramétrage des propriétés Redis

Configurez les paramètres Redis dans le fichier application.yml. Voici des exemples pour le déploiement standalone et en cluster.

Version satndalone

spring:
  redis:
    host: 192.168.40.156
    port: 6379
    password: 123456  # Laissez vide si aucune authentification
    lettuce:
      pool:
        max-active: 8   # Connexions actives maximales
        max-idle: 8     # Connexions inactives maximales
        min-idle: 0     # Connexions inactives minimales
        max-wait: -1ms  # Temps d'attente maximal (-1 pour illimité)

Version cluster

spring:
  redis:
    timeout: 6000ms
    database: 0
    cluster:
      nodes:
        - 192.168.40.156:7001
        - 192.168.40.156:7002
        - 192.168.40.157:7003
        - 192.168.40.157:7004
        - 192.168.40.158:7005
        - 192.168.40.158:7006
      max-redirects: 3  # Redirections maximales en cas d'échec
    lettuce:
      pool:
        max-active: 1000  # Capacité maximale du pool
        max-idle: 10      # Connexions inactives maximales
        min-idle: 5       # Connexions inactives minimales
        max-wait: -1ms    # Temps d'attente maximal

Définition de la classe de configuration

Créez une classe Java pour personnaliser le RedisTemplate et gérer le cache, avec une sérialisation JSON adaptée.

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import javax.annotation.Resource;
import java.util.HashSet;
import java.util.Set;

@Configuration
@EnableCaching
public class ConfigRedis {

    @Resource
    private LettuceConnectionFactory usineConnexion;

    @Bean
    public KeyGenerator createurCles() {
        return (objetCible, methode, parametres) -> {
            StringBuilder cle = new StringBuilder();
            cle.append(objetCible.getClass().getName());
            cle.append(methode.getName());
            for (Object param : parametres) {
                cle.append(param.toString());
            }
            return cle.toString();
        };
    }

    @Bean
    public RedisCacheManager managerCache() {
        RedisCacheManager.RedisCacheManagerBuilder constructeur =
                RedisCacheManager.RedisCacheManagerBuilder.fromConnectionFactory(usineConnexion);
        Set<string> nomsCache = new HashSet<>();
        nomsCache.add("cacheDonnees");
        constructeur.initialCacheNames(nomsCache);
        return constructeur.build();
    }

    @Bean
    public RedisTemplate<String, Object> templateRedis(LettuceConnectionFactory connexion) {
        GenericJackson2JsonRedisSerializer serialiseurJson = new GenericJackson2JsonRedisSerializer();
        StringRedisSerializer serialiseurTexte = new StringRedisSerializer();

        RedisTemplate<String, Object> modele = new RedisTemplate<>();
        modele.setConnectionFactory(connexion);
        modele.setKeySerializer(serialiseurTexte);
        modele.setValueSerializer(serialiseurJson);
        modele.setHashKeySerializer(serialiseurTexte);
        modele.setHashValueSerializer(serialiseurJson);
        modele.afterPropertiesSet();
        return modele;
    }
}
</string>

Cette configuration établit une cnonexion optimisée à Redis via Lettuce, avec des sérialiseurs JSON pour les valeurs et de texte pour les clés, facilitant l'intégration dans les applications Spring Boot.