redis est utilisé pour la mise en cache dans les applications Java afin d'améliorer les performances en réduisant la charge de la base de données et en permettant une récupération rapide des données. 1. Installez Redis à l'aide de Docker: Docker Run -D -P 6379: 6379 Redis. 2. Ajouter le spring-boot-starter-data-redis et la laituce-core dépendances dans pom.xml. 3. Configurez la connexion Redis dans Application.yml avec les paramètres de l'h?te, du port et du pool. 4. Créez une classe Redisconfig avec @enableCaching, personnalisez Redemplate pour la sérialisation JSON à l'aide de génériques GenericJackSon2JsonRisSerializer. 5. Utilisez @cacheable pour récupérer à partir du cache ou exécuter et cache, @cacheput pour mettre à jour le cache après l'exécution, et @cacheevict pour supprimer les données mises en cache. 6. Définissez le haricot RediscacheManager avec EntryTTL (Durée. Ofminures (10)) pour définir l'expiration de 10 minutes. 7. Monitor Cache à l'aide de commandes redis-CLI comme les clés * et obtenez "Utilisateurs :: 1". 8. écrivez des tests unitaires pour valider les coups de cache et les manques. Les meilleures pratiques incluent l'utilisation de clés significatives, d'éviter les données grandes ou sensibles dans le cache, la manipulation du cache manque gracieusement et le réchauffement éventuellement du cache au démarrage. Cette intégration avec Spring Boot simplifie la mise en ?uvre de la mise en cache tout en améliorant considérablement les performances et l'évolutivité des applications.

L'ajout d'une couche de mise en cache à une application Java à l'aide de redis peut considérablement améliorer les performances en réduisant la charge de la base de données et en accélérant la récupération des données. Voici comment le mettre en ?uvre efficacement.

Pourquoi utiliser Redis pour la mise en cache?

Redis est un magasin de données en mémoire connu pour sa vitesse, sa flexibilité et sa prise en charge de diverses structures de données. C'est idéal pour la mise en cache parce que:

• Les données sont stockées dans RAM, permettant des opérations de lecture / écriture de moins de millisecondes.
• Il prend en charge l'expiration (TTL), qui aide à gérer les données périmées.
• Il s'intègre bien à Java via des clients comme la laitue et les Jedis.

étape 1: Configurer Redis et dépendances

Tout d'abord, assurez-vous que Redis est en cours d'exécution. Vous pouvez l'installer localement ou utiliser Docker:

 docker run -d -p 6379: 6379 redis

Ensuite, ajoutez les dépendances requises à votre pom.xml (pour maven):

 <dépendance>
    <GroupId> org.springFramework.boot </romp grouped>
    <ArtefactId> Spring-Boot-Starter-Data-Redis </Retifactid>
</Dependance>
<dépendance>
    <pouprid> io.lettuce </rombandid>
    <ArtefactId> Laitue-core </ arfactive>
</Dependance>

La laitue est le client Redis recommandé pour Spring Boot en raison de ses capacités asynchrones et non bloquantes.

étape 2: Configurer Redis dans Spring Boot

Dans application.yml ou application.properties , configurez la connexion redis:

 printemps:
  redis:
    H?te: localhost
    Port: 6379
    laitue:
      piscine:
        Max-actif: 8
        Max-Idle: 8
        min-idle: 0

Vous pouvez également personnaliser le RedisConnectionFactory et RedisTemplate si nécessaire:

 @Configuration
@Enablecaching
classe publique Redisconfig {

    @Haricot
    public reistetemplate <String, objet> reistemplate (redisconnectionFactory ConnectionFactory) {
        Redistetemplate <String, objet> template = new redesttemplate <> ();
        template.setConnectionFactory (ConnectionFactory);
        template.setKeySerializer (new StringRedisSerializer ());
        template.setValueLeSerializer (new GenericJackson2JSonRedisSerializer ());
        modèle de retour;
    }
}

L'utilisation GenericJackson2JsonRedisSerializer permet aux objets Java complexes d'être sérialisés en JSON et stockés dans redis.

étape 3: Activer et utiliser des annotations de mise en cache

Annotez votre classe d'application principale ou une classe de configuration avec @EnableCaching .

 @Springbootapplication
@Enablecaching
Application de classe publique {
    public static void main (String [] args) {
        SpringApplication.Run (application.class, args);
    }
}

Utilisez maintenant des annotations de mise en cache dans votre couche de service:

 @Service
classe publique UserService {

    @Autowired
    UserRepository privé UserRepository;

    @Cacheable (value = "utilisateurs", key = "#id")
    Utilisateur public getUserById (Long ID) {
        System.out.println ("Récupérer l'utilisateur à partir de DB:" ID);
        return userRepository.FindById (id) .Orelse (null);
    }

    @Cacheput (valeur = "utilisateurs", key = "# user.id")
    Public User UpdateUser (utilisateur utilisateur) {
        return userRepository.save (utilisateur);
    }

    @Cacheevict (valeur = "utilisateurs", key = "#id")
    public void DeleteUser (long id) {
        userRepository.deleteById (id);
    }
}

• @Cacheable : vérifie d'abord le cache. S'il est présent, renvoie la valeur mise en cache; Sinon, exécute la méthode et cache le résultat.
• @CachePut : exécute toujours la méthode et met à jour le cache.
• @CacheEvict : supprime l'entrée du cache (utile pour la suppression des opérations).

étape 4: gérer l'expiration et l'expiration du cache

Définissez TTL (Temps-to-Live) pour éviter les données périmées. Vous pouvez le définir à l'échelle mondiale en configuration:

 @Haricot
Public RediscacheManager CacheManager (RedisconnectionFactory ConnectionFactory) {
    RedisCacheconfiguration config = redisCacheconfiguration.defaultCacheConfig ()
        .Entryttl (durée.ofminutes (10)) // Le cache expire après 10 minutes
        .SerializeKeyswith (redesserializationContext.SerializationPair.FromSerializer (new StringRedisSerializer ()))
        .SerializeValues with (redesserializationContext.SerializationPair.FromSerializer (new GenericJackSon2JsonRedisSerializer ()));

    Retour RedisCacheManager.Builder (ConnectionFactory)
        .CacheDefault (config)
        .construire();
}

Cela garantit que les utilisateurs mis en cache sont automatiquement supprimés après 10 minutes.

étape 5: Surveillez et testez le cache

Utilisez Redis CLI pour inspecter les données mises en cache:

 redis-Cli
> Clés *
> Obtenez des "utilisateurs :: 1"

écrivez également des tests unitaires pour vérifier le comportement de mise en cache:

 @Test
void siCacheUseronFirstCall () {
    userService.getUserById (1L); // db hit
    userService.getUserById (1L); // devrait être mis en cache
    // Vérifiez que DB est appelé une seule fois
}

Utilisez des outils comme CacheManager de Spring ou la journalisation pour confirmer les coups / manches.

Meilleures pratiques

• Utilisez des touches de cache significatives : préférez @Cacheable(value = "users", key = "#id") sur des touches complexes ou longues.
• évitez de mettre en cache des données grandes ou sensibles : Gardez le cache léger et sécurisé.
• Planifiez les manquements de cache : votre application doit toujours fonctionner si Redis est en panne ou si les données ne sont pas mises en cache.
• Utilisez le réchauffement du cache pour les données critiques pendant le démarrage si nécessaire.

Fondamentalement, l'intégration de Redis en tant que couche de mise en cache en Java (en particulier avec Spring Boot) est simple et fournit des gains de performances immédiats. Avec une configuration appropriée et une utilisation intelligente des annotations, vous pouvez réduire la latence et la pression de la base de données sans compliquer votre code.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!