spring-boot
Mise en cache avec Redis à l'aide de Spring Boot pour MongoDB

Pourquoi mettre en cache?

Aujourd'hui, la performance est l'une des mesures les plus importantes que nous devons évaluer lors du développement d'un service / d'une application Web. Garder les clients engagés est essentiel à tout produit et pour cette raison, il est extrêmement important d'améliorer les performances et de réduire les temps de chargement des pages.

Lors de l'exécution d'un serveur Web qui interagit avec une base de données, ses opérations peuvent devenir un goulot d'étranglement. MongoDB ne fait pas exception ici et, à mesure que notre base de données MongoDB évolue, les choses peuvent vraiment ralentir. Ce problème peut même s'aggraver si le serveur de base de données est détaché du serveur Web. Dans de tels systèmes, la communication avec la base de données peut entraîner une surcharge importante.

Heureusement, nous pouvons utiliser une méthode appelée mise en cache pour accélérer les choses. Dans cet exemple, nous allons présenter cette méthode et voir comment nous pouvons l'utiliser pour améliorer les performances de notre application à l'aide de Spring Cache, de Spring Data et de Redis.

Le système de base

Dans un premier temps, nous allons créer un serveur Web de base qui stocke les données dans MongoDB. Pour cette démonstration, nous l'appellerons «Bibliothèque rapide». Le serveur aura deux opérations de base:

POST /book : cet endpoint recevra le titre, l'auteur et le contenu du livre, et créera une entrée de livre dans la base de données.

GET /book/ {title} : ce noeud final obtiendra un titre et retournera son contenu. Nous supposons que les titres identifient de manière unique les livres (il n'y aura donc pas deux livres avec le même titre). Une meilleure alternative serait bien sûr d'utiliser un identifiant. Cependant, pour garder les choses simples, nous utiliserons simplement le titre.

Ceci est un système de bibliothèque simple, mais nous ajouterons des capacités plus avancées ultérieurement.

Maintenant, créons le projet en utilisant Spring Tool Suite (construction en utilisant eclipse) et Spring Starter Project

Nous construisons notre projet en utilisant Java et pour construire nous utilisons maven, sélectionnez des valeurs et cliquez sur suivant

Sélectionnez MongoDB, Redis à partir de NOSQL et Web à partir du module Web et cliquez sur Terminer. Nous utilisons Lombok pour la génération automatique des Setters et des getters de valeurs de modèle. Nous devons donc ajouter la dépendance de Lombok au POM.

MongoDbRedisCacheApplication.java contient la méthode principale utilisée pour exécuter l'application Spring Boot Application

Créer un modèle de livre contenant l'id, le titre du livre, l'auteur, la description et annoter avec @Data pour générer des règles et des getters automatiques à partir du projet jar lombok

package com.example;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.index.Indexed;
import lombok.Data;
@Data
public class Book {
    @Id
    private String id;
    @Indexed
    private String title;
    private String author;
    private String description;
}

Spring Data crée automatiquement toutes les opérations CRUD de base. Créons donc BookRepository.Java, qui recherche livre par titre et supprime le livre

package com.example;
import org.springframework.data.mongodb.repository.MongoRepository;
public interface BookRepository  extends MongoRepository<Book, String>
{
    Book findByTitle(String title);
    void delete(String title);
}

Créons webservicesController qui enregistre les données sur MongoDB et récupère les données par idTitle (titre de la propriété @PathVariable).

package com.example;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class WebServicesController {
    @Autowired
    BookRepository repository;
    @Autowired
    MongoTemplate mongoTemplate;
    @RequestMapping(value = "/book", method = RequestMethod.POST)
    public Book saveBook(Book book) 
    {
        return repository.save(book);
    }
    @RequestMapping(value = "/book/{title}", method = RequestMethod.GET)
    public Book findBookByTitle(@PathVariable String title) 
    {
        Book insertedBook = repository.findByTitle(title);
        return insertedBook;
    }
}

Ajout du cache Jusqu'à présent, nous avons créé un service Web de bibliothèque de base, mais ce n'est pas incroyablement rapide. Dans cette section, nous allons essayer d'optimiser la méthode findBookByTitle () en mettant en cache les résultats.

Pour avoir une meilleure idée de la façon dont nous allons atteindre cet objectif, revenons à l'exemple des personnes assises dans une bibliothèque traditionnelle. Disons qu'ils veulent trouver le livre avec un certain titre. Tout d'abord, ils regarderont autour de la table pour voir s'ils l'ont déjà apportée. S'ils ont, c'est génial! Ils ont juste eu un succès de cache qui trouve un élément dans le cache. S'ils ne l'ont pas trouvé, ils ont manqué le cache, ce qui signifie qu'ils n'ont pas trouvé l'élément dans le cache. Dans le cas d'un article manquant, ils devront chercher le livre dans la bibliothèque. Quand ils le trouvent, ils le gardent sur leur table ou l'insèrent dans le cache.

Dans notre exemple, nous suivrons exactement le même algorithme pour la méthode findBookByTitle (). Lorsqu'on vous demande un livre avec un certain titre, nous le rechercherons dans le cache. Si non trouvé, nous le chercherons dans le stockage principal, c'est-à-dire notre base de données MongoDB.

Utiliser Redis

L'ajout de spring-boot-data-redis à notre chemin de classe permettra au démarrage du printemps d'effectuer sa magie. Il créera toutes les opérations nécessaires en configurant automatiquement

Annotons maintenant la méthode avec la ligne ci-dessous pour mettre en cache et laisser Spring Boot faire sa magie

@Cacheable (value = "book", key = "#title")

Pour supprimer du cache lorsqu'un enregistrement est supprimé, annotez simplement avec la ligne ci-dessous dans BookRepository et laissez Spring Boot gérer la suppression du cache pour nous.

@CacheEvict (value = "book", key = "#title")

Pour mettre à jour les données, nous devons ajouter la ligne ci-dessous à la méthode et laisser la botte de printemps gérer

@CachePut(value = "book", key = "#title")

Vous pouvez trouver le code complet du projet sur GitHub