Cache Redis Spring Boot
Dans cet article, nous allons configurer une application Spring Boot de base et l’intégrer avec le cache Redis. Alors que Redis est un magasin de données en mémoire open source, utilisé comme base de données, cache et courtier de messages, cette leçon ne démontrera que l’intégration du cache. Nous utiliserons l’outil Spring Initializr pour configurer rapidement le projet.
Configuration du Projet Spring Boot Redis
Nous utiliserons l’outil Spring Initializr pour configurer rapidement le projet. Nous utiliserons 3 dépendances comme indiqué ci-dessous: 
Téléchargez le projet et décompressez-le. Nous avons utilisé la dépendance de la base de données H2 car nous utiliserons une base de données embarquée qui perd toutes les données une fois l’application arrêtée.
Dépendances Maven pour le cache Redis de Spring Boot
Bien que nous ayons déjà terminé la configuration avec l’outil, si vous souhaitez le configurer manuellement, nous utilisons le système de construction Maven pour ce projet et voici les dépendances que nous avons utilisées:
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.9.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!-- for JPA support -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- for embedded database support -->
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
Assurez-vous d’utiliser la version stable de Spring Boot depuis le central Maven.
Définition du modèle
Pour sauvegarder un objet dans la base de données Redis, nous définissons un objet modèle Person avec des champs de base:
package com.journaldev.rediscachedemo;
import javax.persistence.*;
import java.io.Serializable;
@Entity
public class User implements Serializable {
private static final long serialVersionUID = 7156526077883281623L;
@Id
@SequenceGenerator(name = "SEQ_GEN", sequenceName = "SEQ_USER", allocationSize = 1)
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_GEN")
private Long id;
private String name;
private long followers;
public User() {
}
public User(String name, long followers) {
this.name = name;
this.followers = followers;
}
// getters et setters standard
@Override
public String toString() {
return String.format("User{id=%d, name='%s', followers=%d}", id, name, followers);
}
}
C’est un POJO standard avec des getters et des setters.
Configuration du cache Redis
Avec Spring Boot et la dépendance requise déjà en place avec Maven, nous pouvons configurer une instance Redis locale avec seulement trois lignes dans notre fichier application.properties comme suit:
# Configuration Redis
spring.cache.type=redis
spring.redis.host=localhost
spring.redis.port=6379
De plus, utilisez l’annotation @EnableCaching sur la classe principale de Spring Boot:
package com.journaldev.rediscachedemo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
@SpringBootApplication
@EnableCaching
public class Application implements CommandLineRunner {
private final Logger LOG = LoggerFactory.getLogger(getClass());
private final UserRepository userRepository;
@Autowired
public Application(UserRepository userRepository) {
this.userRepository = userRepository;
}
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
@Override
public void run(String... strings) {
// Remplissage de la base de données embarquée ici
LOG.info("Saving users. Current user count is {}.", userRepository.count());
User shubham = new User("Shubham", 2000);
User pankaj = new User("Pankaj", 29000);
User lewis = new User("Lewis", 550);
userRepository.save(shubham);
userRepository.save(pankaj);
userRepository.save(lewis);
LOG.info("Done saving users. Data: {}.", userRepository.findAll());
}
}
Nous avons ajouté un CommandLineRunner car nous voulons peupler des données d’exemple dans la base de données H2 intégrée.
Définition du Repository
Avant de montrer comment Redis fonctionne, nous allons simplement définir un Repository pour les fonctionnalités liées à JPA :
package com.journaldev.rediscachedemo;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface UserRepository extends JpaRepository { }
Il n’a pas de méthodes appelées pour le moment car nous n’en avons pas besoin.
Définition du Contrôleur
Les contrôleurs sont l’endroit où le cache Redis est appelé pour agir. En fait, c’est le meilleur endroit pour le faire car le cache y est directement associé, la requête n’aura même pas besoin d’entrer dans le code du service pour attendre les résultats mis en cache. Voici le squelette du contrôleur :
package com.journaldev.rediscachedemo;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.web.bind.annotation.*;
@RestController
public class UserController {
private final Logger LOG = LoggerFactory.getLogger(getClass());
private final UserRepository userRepository;
@Autowired
public UserController(UserRepository userRepository) {
this.userRepository = userRepository;
}
...
}
Maintenant, pour mettre quelque chose dans le cache, nous utilisons l’annotation @Cacheable :
@Cacheable(value = "users", key = "#userId", unless = "#result.followers < 12000")
@RequestMapping(value = "/{userId}", method = RequestMethod.GET)
public User getUser(@PathVariable String userId) {
LOG.info("Getting user with ID {}.", userId);
return userRepository.findOne(Long.valueOf(userId));
}
Dans le mappage ci-dessus, la méthode getUser mettra une personne dans un cache nommé ‘users’, identifie cette personne par la clé ‘userId’ et ne stockera qu’un utilisateur avec plus de 12 000 abonnés. Cela garantit que le cache est peuplé d’utilisateurs très populaires et souvent interrogés. De plus, nous avons intentionnellement ajouté une instruction de journalisation dans l’appel API. Faisons quelques appels API depuis Postman à ce moment. Voici les appels que nous avons faits :
localhost:8090/1
localhost:8090/1
localhost:8090/2
localhost:8090/2
Si nous examinons les journaux, voici ce qu’ils contiendront :
... : Getting user with ID 1.
... : Getting user with ID 1.
... : Getting user with ID 2.
Remarquez quelque chose ? Nous avons effectué quatre appels d’API, mais seulement trois déclarations de journal étaient présentes. C’est parce que l’utilisateur avec l’ID 2 a 29000 abonnés et, par conséquent, ses données étaient mises en cache. Cela signifie que lorsqu’un appel d’API a été effectué pour cela, les données ont été renvoyées du cache et aucun appel de base de données n’a été effectué pour cela !
Mise à jour du cache
Les valeurs du cache devraient également être mises à jour chaque fois que les valeurs réelles de leurs objets sont mises à jour. Cela peut être fait en utilisant l’annotation @CachePut:
@CachePut(value = "users", key = "#user.id")
@PutMapping("/update")
public User updatePersonByID(@RequestBody User user) {
userRepository.save(user);
return user;
}
Avec cela, une personne est à nouveau identifiée par son ID et est mise à jour avec les résultats.
Effacement du cache
Si certaines données doivent être supprimées de la base de données réelle, il n’y aura plus d’intérêt à les conserver dans le cache. Nous pouvons effacer les données du cache en utilisant l’annotation @CacheEvict:
@CacheEvict(value = "users", allEntries=true)
@DeleteMapping("/{id}")
public void deleteUserByID(@PathVariable Long id) {
LOG.info("deleting person with id {}", id);
userRepository.delete(id);
}
Dans le dernier mappage, nous avons simplement expulsé les entrées du cache et n’avons rien fait d’autre.
Exécution de l’application de cache Redis Spring Boot
Nous pouvons exécuter cette application simplement en utilisant une seule commande :
mvn spring-boot:run
Limites de la cache Redis
Bien que Redis soit très rapide, il n’a toujours pas de limites sur le stockage de n’importe quelle quantité de données sur un système 64 bits. Il ne peut stocker que 3 Go de données sur un système 32 bits. Une mémoire disponible plus importante peut entraîner un taux de réussite plus élevé, mais cela aura tendance à cesser une fois que Redis occupe trop de mémoire. Lorsque la taille de la cache atteint la limite de mémoire, les anciennes données sont supprimées pour faire place aux nouvelles.
Résumé
Dans cette leçon, nous avons examiné la puissance que nous offre Redis Cache pour une interaction rapide avec les données et comment nous pouvons l’intégrer avec Spring Boot grâce à une configuration minimale mais puissante. N’hésitez pas à laisser des commentaires ci-dessous.
Source:
https://www.digitalocean.com/community/tutorials/spring-boot-redis-cache