Introduction à Spring Data Redis

1. Vue d'ensemble

Cet article est une introduction à Spring Data Redis , qui fournit les abstractions de la plate-forme Spring Data à Redis - le célèbre magasin de structures de données en mémoire.

Redis est piloté par une structure de données basée sur le keystore pour conserver les données et peut être utilisé comme base de données, cache, courtier de messages, etc.

Nous pourrons utiliser les modèles communs de Spring Data (modèles, etc.), tout en ayant la simplicité traditionnelle de tous les projets Spring Data.

2. Dépendances de Maven

Commençons par déclarer les dépendances de Spring Data Redis dans le pom.xml :

 org.springframework.data spring-data-redis 2.3.3.RELEASE   redis.clients jedis 3.3.0 jar 

Les dernières versions de spring-data-redis et jedis peuvent être téléchargées à partir de Maven Central.

Alternativement, nous pouvons utiliser le démarreur Spring Boot pour Redis, ce qui éliminera le besoin de dépendances séparées de spring-data et de jedis :

 org.springframework.boot spring-boot-starter-data-redis 2.3.3.RELEASE 

Encore une fois, Maven central offre les dernières informations de version.

3. La configuration Redis

Pour définir les paramètres de connexion entre le client d'application et l'instance du serveur Redis, nous devons utiliser un client Redis.

Un certain nombre d'implémentations de client Redis sont disponibles pour Java. Dans ce didacticiel, nous utiliserons Jedis - une implémentation de client Redis simple et puissante .

Il existe un bon support pour la configuration XML et Java dans le framework; pour ce didacticiel, nous utiliserons une configuration basée sur Java.

3.1. Configuration Java

Commençons par les définitions de bean de configuration:

@Bean JedisConnectionFactory jedisConnectionFactory() { return new JedisConnectionFactory(); } @Bean public RedisTemplate redisTemplate() { RedisTemplate template = new RedisTemplate(); template.setConnectionFactory(jedisConnectionFactory()); return template; } 

La configuration est assez simple. Tout d'abord, en utilisant le client Jedis, nous définissons une connectionFactory .

Ensuite, nous avons défini un RedisTemplate à l'aide de jedisConnectionFactory. Cela peut être utilisé pour interroger des données avec un référentiel personnalisé.

3.2. Propriétés de connexion personnalisées

Vous avez peut-être déjà remarqué que les propriétés habituelles liées à la connexion sont manquantes dans la configuration ci-dessus. Par exemple, l'adresse du serveur et le port sont manquants dans la configuration. La raison est simple: pour notre exemple, nous utilisons les valeurs par défaut.

Cependant, si nous devons configurer les détails de connexion, nous pouvons toujours modifier la configuration de jedisConnectionFactory comme suit:

@Bean JedisConnectionFactory jedisConnectionFactory() { JedisConnectionFactory jedisConFactory = new JedisConnectionFactory(); jedisConFactory.setHostName("localhost"); jedisConFactory.setPort(6379); return jedisConFactory; }

4. Référentiel Redis

Utilisons une entité Student pour nos exemples:

@RedisHash("Student") public class Student implements Serializable { public enum Gender { MALE, FEMALE } private String id; private String name; private Gender gender; private int grade; // ... }

4.1. Le référentiel de données Spring

Créons maintenant le StudentRepository comme suit:

@Repository public interface StudentRepository extends CrudRepository {}

5. Accès aux données à l'aide de StudentRepository

En étendant CrudRepository dans StudentRepository , nous obtenons automatiquement un ensemble complet de méthodes de persistance qui exécutent la fonctionnalité CRUD.

5.1. Enregistrer un nouvel objet étudiant

Sauvegardons un nouvel objet étudiant dans le magasin de données:

Student student = new Student( "Eng2015001", "John Doe", Student.Gender.MALE, 1); studentRepository.save(student);

5.2. Récupération d'un objet étudiant existant

Nous pouvons vérifier l'insertion correcte de l'étudiant dans la section précédente en récupérant les données de l'étudiant:

Student retrievedStudent = studentRepository.findById("Eng2015001").get();

5.3. Mettre à jour un objet étudiant existant

Modifions le nom de l'élève récupéré ci-dessus et sauvegardons-le à nouveau:

retrievedStudent.setName("Richard Watson"); studentRepository.save(student);

Enfin, nous pouvons à nouveau récupérer les données de l'étudiant et vérifier que le nom est mis à jour dans le magasin de données.

5.4. Suppression des données d'un étudiant existantes

Nous pouvons supprimer les données d'étudiant insérées ci-dessus:

studentRepository.deleteById(student.getId());

Nous pouvons maintenant rechercher l'objet étudiant et vérifier que le résultat est nul .

5.5. Rechercher toutes les données des étudiants

Nous pouvons insérer quelques objets étudiants:

Student engStudent = new Student( "Eng2015001", "John Doe", Student.Gender.MALE, 1); Student medStudent = new Student( "Med2015001", "Gareth Houston", Student.Gender.MALE, 2); studentRepository.save(engStudent); studentRepository.save(medStudent);

Nous pouvons également y parvenir en insérant une collection. Pour cela, il existe une méthode différente - saveAll () - qui accepte un seul objet Iterable contenant plusieurs objets étudiants que nous voulons conserver.

Pour trouver tous les étudiants insérés, nous pouvons utiliser la méthode findAll () :

List students = new ArrayList(); studentRepository.findAll().forEach(students::add);

Ensuite, nous pouvons vérifier rapidement la taille de la liste des étudiants ou vérifier une plus grande granularité en vérifiant les propriétés de chaque objet.

6. Conclusion

Dans ce tutoriel, nous avons passé en revue les bases de Spring Data Redis. Le code source des exemples ci-dessus se trouve dans un projet GitHub.