Implémentation de mise en cache dans une application Java à l'aide de redis

Installez et exécutez Redis et démarrez le service Redis à l'aide de la commande docker; 2. Ajouter des dépendances Redis pour Jedis ou Spring Boot dans le projet Maven; 3. Utilisez le client Jedis pour connecter Redis et implémenter SetEx pour définir le cache avec un temps d'expiration, faire attention à la fermeture de la connexion ou à l'utilisation du pool de connexion; 4. Configurer les paramètres Redis dans Spring Boot via Application.yml, activez l'annotation @EnableCaching et utilisez @Cacheable, @Cacheput et @Cacheevict pour implémenter la mise en cache au niveau de la méthode; 5. Personnaliser Redemplate pour utiliser Jackson2JSonRisserializer pour sérialiser les objets complexes au format JSON pour améliorer la lisibilité et les performances; 6. Suivez les meilleures pratiques: définissez TTL pour éviter les fuites de mémoire, utilisez des noms de clés significatifs, les manquements du cache de gérer gracieusement, utilisez des pools de connexion dans des environnements de production et montez l'état redis. Grâce à ces étapes, les applications Java peuvent intégrer efficacement le cache Redis, réduire considérablement la charge de base de données et améliorer la vitesse de réponse, réalisant finalement une couche d'accès aux données haute performance.

La mise en cache dans une application Java peut considérablement améliorer les performances en réduisant la charge de la base de données et en accélérant les temps de réponse. Redis est l'un des magasins de données en mémoire les plus populaires utilisés pour la mise en cache en raison de sa vitesse, de sa flexibilité et de son ensemble de fonctionnalités riches. Voici comment implémenter la mise en cache basée sur Redis dans une application Java.

1. Configurer Redis et dépendances

Tout d'abord, assurez-vous que Redis est installé et en cours d'exécution. Vous pouvez le télécharger à partir de redis.io ou utiliser Docker:

 Docker Run -P 6379: 6379 - Name redis-server -d redis

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

 <dépendance>
    <GroupId> redis.clients </rombandid>
    <ArtefactId> Jedis </Retifactid>
    <version> 4.5.0 </ version> <! - Utilisez la dernière stable ->
</Dependance>

Alternativement, si vous utilisez Spring Boot, incluez:

 <dépendance>
    <GroupId> org.springFramework.boot </romp grouped>
    <ArtefactId> Spring-Boot-Starter-Data-Redis </Retifactid>
</Dependance>

2. Connectez-vous à Redis à l'aide de Jedis (autonome)

Jedis est un client Redis léger pour Java. Voici un exemple simple pour connecter et utiliser Redis:

 Importer redis.clients.jedis.Jedis;

classe publique Rediscache {
    Jedis Jedis privé;

    public rediscache () {
        this.jedis = new Jedis ("localhost", 6379);
    }

    public void set (clé de chaîne, valeur de chaîne) {
        Jedis.sex (Key, 3600, valeur); // Cache pendant 1 heure
    }

    public String get (string key) {
        return jedis.get (clé);
    }

    public void close () {
        if (jedis! = null) {
            jedis.close ();
        }
    }
}

• setex(key, seconds, value) définit une clé avec un temps d'expiration (TTL), ce qui est essentiel pour éviter les données périmées.
• Fermez toujours la connexion ou utilisez un pool de connexion en production.

3. Utilisez Redis avec Spring Boot (recommandé)

Spring Boot simplifie l'intégration Redis avec la configuration automatique et la mise en cache basée sur l'annotation.

Configurer application.yml :

 printemps:
  redis:
    Hôte: localhost
    Port: 6379
  Cache:
    Type: redis
    redis:
      Temps de vie: 3600000 # 1 heure en millions de secondes

Activer la mise en cache:

Ajouter @EnableCaching à votre classe d'application principale:

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

Utilisez des annotations de mise en cache:

Appliquer @Cacheable , @CachePut et @CacheEvict sur les méthodes de service:

 @Service
classe publique UserService {

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

    @Cacheput (valeur = "utilisateurs", key = "# user.id")
    Public User UpdateUser (utilisateur utilisateur) {
        // Mettre à jour l'utilisateur et mettre à jour le cache
        return userRepository.save (utilisateur);
    }

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

Cela cache automatiquement le résultat de getUserById() , donc les appels ultérieurs avec le même ID ignorent la base de données.

4. sérialiser les objets complexes

Par défaut, Spring utilise la sérialisation JDK, qui n'est pas efficace. Personnalisez le modèle redis pour utiliser JSON:

 @Configuration
@Enablecaching
classe publique Redisconfig {

    @Haricot
    public reistetemplate <String, objet> redesttemplate (redéconnectionfactory usine) {
        Redistetemplate <String, objet> template = new redesttemplate <> ();
        template.setConnectionFactory (Factory);

        // Utilisez Jackson2jsonredisSerializer pour une meilleure lecture
        Jackson2jsonredisserializer <ser utilisateur> serializer = new jackson2jsonredisserializer <> (user.class);
        template.setValueLeSerializer (sérialiseur);
        template.setKeySerializer (new StringRedisSerializer ());
        Template.sethAshKeySerializer (new StringRedisSerializer ());
        template.sethAshValueSerializer (sérialiseur);
        template.afterpropertiseset ();

        modèle de retour;
    }
}

Désormais, des objets complexes comme User sont stockés au format JSON lisible dans Redis.

5. meilleures pratiques

• Définissez TTL (temps pour vivre): définissez toujours l'expiration sur les données mises en cache pour éviter les fuites de mémoire.
• Utilisez des clés significatives: les touches de structure comme user::123 ou product:category:latest .
• Gire Cache manque gracieusement: si Redis est en panne, retombez dans la base de données (et enregistrez le problème).
• Utilisez le regroupement de connexion: en production, configurez les Jedis ou la laitue avec la mise en commun.
• Moniteur Redis: Utilisez redis-cli monitor ou les outils comme RedisInsight pour inspecter l'utilisation du cache.

Conclusion

L'utilisation de Redis pour la mise en cache en Java, en particulier avec Spring Boot, peut augmenter considérablement les performances avec un minimum de modifications de code. Que vous utilisiez des Jedis bruts pour un contrôle fin ou la mise en cache déclarative de Spring pour la simplicité, Redis fournit une couche rapide et fiable entre votre application et les sources de données lentes.

Fondamentalement: connectez Redis, les résultats de la méthode de cache, sérialisez intelligemment et expirez judicieusement les données. C'est le cœur.

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!