Einführung in Spring Data Redis

Übersicht

Dieser Artikel ist eine Einführung in Spring Data Redis, die die Abstraktionen der Spring Data Platform für Redis bereitstellt – den beliebten In-Memory-Datenstrukturspeicher.

Redis wird von einer Keystore-basierten Datenstruktur gesteuert, um Daten zu speichern, und kann als Datenbank, Cache, Nachrichtenbroker usw. verwendet werden.

Wir können die gängigen Muster von Spring-Daten (Vorlagen usw.) verwenden.), während sie auch die traditionelle Einfachheit aller Spring Data-Projekte haben.

Maven-Abhängigkeiten

Beginnen wir mit der Deklaration der Spring Data Redis-Abhängigkeiten im 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>

Die neuesten Versionen von spring-data-redis und jedis können von Maven Central heruntergeladen werden.

Alternativ können wir den Spring Boot Starter für Redis verwenden, wodurch separate Spring-data- und Jedis-Abhängigkeiten entfallen:

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

Auch hier bietet Maven Central die neuesten Versionsinformationen.

Die Redis-Konfiguration

Um die Verbindungseinstellungen zwischen dem Anwendungsclient und der Redis-Serverinstanz zu definieren, müssen wir einen Redis-Client verwenden.

Es gibt eine Reihe von Redis-Client-Implementierungen für Java. In diesem Tutorial verwenden wir Jedis – eine einfache und leistungsstarke Redis-Client-Implementierung.

Es gibt gute Unterstützung für XML- und Java-Konfiguration im Rahmen; Für dieses Tutorial werden wir Java-basierte Konfiguration verwenden.

3.1. Java-Konfiguration

Beginnen wir mit den Konfigurations-Bean-Definitionen:

@BeanJedisConnectionFactory jedisConnectionFactory() { return new JedisConnectionFactory();}@Beanpublic RedisTemplate<String, Object> redisTemplate() { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(jedisConnectionFactory()); return template;}

Die Konfiguration ist recht einfach. Zunächst definieren wir mit dem Jedis-Client eine ConnectionFactory.

Dann haben wir eine RedisTemplate mit der jedisConnectionFactory definiert. Dies kann zum Abfragen von Daten mit einem benutzerdefinierten Repository verwendet werden.

3.2. Benutzerdefinierte Verbindungseigenschaften

Möglicherweise haben Sie bereits bemerkt, dass die üblichen verbindungsbezogenen Eigenschaften in der obigen Konfiguration fehlen. Beispielsweise fehlen die Serveradresse und der Port in der Konfiguration. Der Grund ist einfach: In unserem Beispiel verwenden wir die Standardwerte.

Wenn wir jedoch die Verbindungsdetails konfigurieren müssen, können wir die jedisConnectionFactory-Konfiguration jederzeit wie folgt ändern:

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

Redis Repository

Verwenden wir eine Student-Entität für unsere Beispiele:

@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. Das Spring Data Repository

Erstellen wir nun das StudentRepository wie folgt:

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

Datenzugriff mit StudentRepository

Durch Erweitern von CrudRepository in StudentRepository erhalten wir automatisch einen vollständigen Satz von Persistenzmethoden, die CRUD-Funktionen ausführen.

5.1. Speichern eines neuen Schülerobjekts

Speichern wir ein neues Schülerobjekt im Datenspeicher:

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

5.2. Abrufen eines vorhandenen Schülerobjekts

Wir können die korrekte Einfügung des Schülers im vorherigen Abschnitt überprüfen, indem wir die Schülerdaten abrufen:

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

5.3. Aktualisieren eines vorhandenen Schülerobjekts

Ändern wir den Namen des oben abgerufenen Schülers und speichern ihn erneut:

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

Schließlich können wir die Daten des Schülers erneut abrufen und überprüfen, ob der Name im Datenspeicher aktualisiert wurde.

5.4. Löschen einer vorhandenen Schülerdaten

Wir können die oben eingefügten Schülerdaten löschen:

studentRepository.deleteById(student.getId());

Jetzt können wir nach dem Student-Objekt suchen und überprüfen, ob das Ergebnis null ist.

5.5. Finde alle Schülerdaten

Wir können ein paar Schülerobjekte einfügen:

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);

Wir können dies auch erreichen, indem wir eine Sammlung einfügen. Dafür gibt es eine andere Methode – saveAll() –, die ein einzelnes iterierbares Objekt akzeptiert, das mehrere Schülerobjekte enthält, die beibehalten werden sollen.

Um alle eingefügten Schüler zu finden, können wir die Methode findAll():

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

Dann können wir schnell die Größe der Schülerliste überprüfen oder eine größere Granularität überprüfen, indem wir die Eigenschaften jedes Objekts überprüfen.

Fazit