In diesem Beitrag werden wir eine Beispiel-Spring-Boot-Anwendung einrichten und sie mit Redis Cache integrieren. Während Redis ein Open-Source in-Memory-Datenstrukturspeicher ist, der als Datenbank, Cache und Message-Broker verwendet wird, wird diese Lektion nur die Caching-Integration demonstrieren. Wir werden das Spring Initializr-Tool verwenden, um das Projekt schnell einzurichten.
Einrichtung des Spring Boot Redis Cache Projekts
Wir werden das Spring Initializr-Tool verwenden, um das Projekt schnell einzurichten. Wir werden 3 Abhängigkeiten verwenden, wie unten gezeigt:
Laden Sie das Projekt herunter und entpacken Sie es. Wir haben die H2-Datenbankabhängigkeit verwendet, da wir eine eingebettete Datenbank verwenden werden, die alle Daten verliert, sobald die Anwendung gestoppt wurde.
Passende Infrastruktur bei centron
Zum Ausprobieren braucht es keine eigene Hardware: ccloud³ VMs mit vollem Root-Zugriff gibt es ab 3,12 € im Monat, stundengenau abgerechnet und in Sekunden bereit. Cloud Server mieten →
Maven-Abhängigkeiten für Spring Boot Redis Cache
Obwohl wir die Einrichtung bereits mit dem Tool abgeschlossen haben, wenn Sie es manuell einrichten möchten, verwenden wir das Maven-Build-System für dieses Projekt und hier sind die Abhängigkeiten, die wir verwendet haben:
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.9.RELEASE</version>
<relativePath/> <!-- Suche Elternteil im 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>
<!-- für JPA-Unterstützung -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<!-- für Unterstützung eingebetteter Datenbanken -->
<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>Stellen Sie sicher, dass Sie eine stabile Version von Spring Boot aus dem Maven-Zentral verwenden.
Definieren des Modells
Um ein Objekt in die Redis-Datenbank zu speichern, definieren wir ein Person-Modell-Objekt mit grundlegenden Feldern:
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;
}
//standard getter und setter
@Override
public String toString() {
return String.format("User{id=%d, name='%s', followers=%d}", id, name, followers);
}
}Es ist ein standardmäßiges POJO mit Getter und Setter.
Konfigurieren von Redis Cache
Mit Spring Boot und der erforderlichen Abhängigkeit bereits in Arbeit mit Maven, können wir eine lokale Redis-Instanz mit nur drei Zeilen in unserer application.properties-Datei konfigurieren:
# Redis-Konfig
spring.cache.type=redis
spring.redis.host=localhost
spring.redis.port=6379Verwenden Sie außerdem die Annotation @EnableCaching in der Spring-Boot-Hauptklasse:
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) {
//Befüllen der eingebetteten Datenbank hier
LOG.info("Speichern von Benutzern. Aktuelle Benutzeranzahl ist {}.", 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("Benutzer gespeichert. Daten: {}.", userRepository.findAll());
}
}Wir haben einen CommandLineRunner hinzugefügt, da wir einige Beispieldaten in der eingebetteten H2-Datenbank bereitstellen möchten.
Definieren des Repositories für unser Spring Boot Redis Rache Projekt
Bevor wir zeigen, wie Redis funktioniert, definieren wir zunächst ein Repository für die JPA-bezogene Funktionalität:
package com.journaldev.rediscachedemo;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
@Repository
public interface UserRepository extends JpaRepository { }Es hat bisher keine Methodenaufrufe, da wir keine benötigen.
Definieren des Controllers
Controller sind der Ort, an dem der Redis-Cache in Aktion gerufen wird. Eigentlich ist dies der beste Ort dafür, denn da ein Cache direkt damit assoziiert ist, muss die Anfrage nicht einmal in den Servicecode eintreten, um auf die gecachten Ergebnisse zu warten. Hier ist das Grundgerüst des Controllers:
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;
}
...
}Um etwas in den Cache zu legen, verwenden wir die 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));
}In der obigen Zuordnung wird die Methode getUser einen Benutzer in einen Cache mit dem Namen ‘users’ legen, diesen Benutzer durch den Schlüssel ‘userId’ identifizieren und nur einen Benutzer mit mehr als 12000 Followern speichern. Dies stellt sicher, dass der Cache mit Benutzern gefüllt wird, die sehr beliebt sind und oft abgefragt werden. Außerdem haben wir absichtlich eine Log-Aussage im API-Aufruf hinzugefügt. Lassen Sie uns in diesem Moment einige API-Aufrufe über Postman machen. Das sind die Aufrufe, die wir gemacht haben:
localhost:8090/1
localhost:8090/1
localhost:8090/2
localhost:8090/2
Wenn wir die Logs beachten, werden diese es sein:
... : Getting user with ID 1.
... : Getting user with ID 1.
... : Getting user with ID 2.
Bemerken Sie etwas? Wir haben vier API-Aufrufe gemacht, aber nur drei Log-Aussagen waren vorhanden. Dies liegt daran, dass der Benutzer mit der ID 2 29000 Follower hat und daher seine Daten gecacht wurden. Das bedeutet, dass bei einem API-Aufruf dafür die Daten aus dem Cache zurückgegeben wurden und kein DB-Aufruf für diesen gemacht wurde!
Aktualisieren des Caches
Cache-Werte sollten auch aktualisiert werden, wenn sich die tatsächlichen Werte ihrer Objekte ändern. Dies kann mit der Annotation @CachePut erreicht werden:
@CachePut(value = "users", key = "#user.id")
@PutMapping("/update")
public User updatePersonByID(@RequestBody User user) {
userRepository.save(user);
return user;
}Damit wird eine Person erneut durch ihre ID identifiziert und mit den Ergebnissen aktualisiert.
Cache löschen
Wenn einige Daten aus der eigentlichen Datenbank gelöscht werden sollen, macht es keinen Sinn, sie weiterhin im Cache zu behalten. Wir können Cache-Daten mit der Annotation @CacheEvict löschen:
@CacheEvict(value = "users", allEntries=true)
@DeleteMapping("/{id}")
public void deleteUserByID(@PathVariable Long id) {
LOG.info("deleting person with id {}", id);
userRepository.delete(id);
}In der letzten Zuordnung haben wir lediglich Cache-Einträge entfernt und nichts anderes getan.
Spring Boot Redis Cache Anwendung ausführen
Wir können diese App einfach mit einem einzigen Befehl ausführen:
mvn spring-boot:runGrenzen des Redis-Caches
Obwohl Redis sehr schnell ist, hat es dennoch keine Grenzen, jede Menge Daten auf einem 64-Bit-System zu speichern. Auf einem 32-Bit-System kann es nur 3GB Daten speichern. Mehr verfügbarer Speicher kann zu einer höheren Trefferrate führen, aber dies wird aufhören, sobald zu viel Speicher von Redis belegt ist. Wenn die Cache-Größe das Speicherlimit erreicht, werden alte Daten entfernt, um Platz für neue zu machen.
Zusammenfassung des Spring Boot Redis Cache Leitfadens
In dieser Lektion haben wir uns angesehen, welche Leistung Redis Cache uns mit schneller Dateninteraktion bietet und wie wir es mit minimaler und dennoch leistungsstarker Konfiguration in Spring Boot integrieren können.
Testen Sie Ihr Setup auf ccloud³
Registrieren Sie sich in der ccloud³ und erhalten Sie 200 € Startguthaben für Ihr Projekt – z. B. für eine PostgreSQL-VM mit automatischen Backups.