Introduction à Spring Data Redis

Aperçu

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

Redis est piloté par une structure de données basée sur un magasin de clés 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 courants des données de printemps (modèles, etc.), tout en ayant la simplicité traditionnelle de tous les projets de données Spring.

Dépendances Maven

Commençons par déclarer les dépendances Redis des données Spring dans le pom.xml:

<dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> <version>2.3.3.RELEASE</version> </dependency><dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.3.0</version> <type>jar</type></dependency>

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 spring-data et jedis distinctes:

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>2.3.3.RELEASE</version></dependency>

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

La configuration Redis

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

Un certain nombre d’implémentations client Redis sont disponibles pour Java. Dans ce tutoriel, nous allons utiliser Jedis – une implémentation client Redis simple et puissante.

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

3.1. Configuration Java

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

@BeanJedisConnectionFactory jedisConnectionFactory() { return new JedisConnectionFactory();}@Beanpublic RedisTemplate<String, Object> redisTemplate() { RedisTemplate<String, Object> 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 jedisConnectionFactory comme suit:

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

Référentiel Redis

Utilisons une entité étudiante 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:

@Repositorypublic interface StudentRepository extends CrudRepository<Student, String> {}

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. Enregistrement d’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. Mise à jour d’un objet Étudiant existant

Changeons le nom de l’étudiant récupéré ci-dessus et sauvegardons-le à nouveau:

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

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

5.4. Suppression d’une donnée d’étudiant existante

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

studentRepository.deleteById(student.getId());

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

5.5. Retrouvez toutes les données de l’élève

Nous pouvons insérer quelques objets de l’élève:

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 itérable contenant plusieurs objets étudiants que nous voulons conserver.

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

List<Student> 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.

Conclusion