Wir werden unsere Anwendung vollständig **zusammenbauen** und sie mit **Redis** und **Spring Boot** testen. **Caching** wird die Anfragenbearbeitung erheblich beschleunigen und die Belastung der **Datenbank** reduzieren.

# Kurze Zusammenfassung aus dem Video
In unserem Programm haben wir die **folgende Logik** verwendet: Wenn ein Benutzer zur Haupt**datenbank** **hinzugefügt** wird, werden seine Daten nicht **zwischengespeichert**, da dies noch nicht notwendig ist.

```java
@Transactional
public User createUser(User user) {
    return userRepository.save(user);
}
```

Die Methode `createUser` **speichert** den Benutzer einfach in der **Datenbank**.

Wenn eine **Anfrage** eingeht, um die **Daten eines Benutzers** nach `ID` abzurufen, prüfen wir zuerst, ob die **Informationen** im **Redis-Cache** verfügbar sind. Dies hilft, unnötige **Datenbankabfragen** zu vermeiden, wenn die Daten bereits **zwischengespeichert** sind.

```java
@Transactional
@Cacheable(value = "user-cache", key = "#id")
@SneakyThrows
public User getUserById(Long id) {
    Thread.sleep(100);
    return userRepository.findById(id).orElseThrow(
            () -> new RuntimeException(String.format("User with this id: %d not found", id))
    );
}
```

Mit der `@Cacheable`-Annotation **cachen** wir die Daten unter dem Schlüssel `user-cache`, der den Wert der **id** enthält (`user-cache:20` für einen Benutzer mit der ID `20`). Wenn die Daten im **Cache** sind, werden sie abgerufen und zurückgegeben. Wenn die Daten nicht im **Cache** sind, fragt die Methode die **Datenbank** ab.

Beim **Löschen von Daten** aus der **Datenbank** ist es wichtig, sie auch aus dem **Cache** zu **entfernen**, um sicherzustellen, dass die Daten **konsistent** bleiben und keine veralteten Informationen verwendet werden.

```java
@CacheEvict(value="user-cache", key="#id")
public void deleteUser(Long id) {
    userRepository.deleteById(id);
}
```

Die `deleteUser`-Methode **löscht** den Benutzer aus der **Datenbank** und **entfernt** seine Daten aus dem **Redis-Cache**, um die Verwendung von **veralteten Informationen** in zukünftigen Abfragen zu verhindern.

# Vorteile des Cachings

Jetzt zum spannenden Teil — warum haben wir **Caching** implementiert? Nach dem Hinzufügen des **Redis-Cache** wurden Anfragen viel **schneller** — buchstäblich bis zu **20 Mal schneller**! Dies wird in den untenstehenden Screenshots deutlich gezeigt.

## Vor dem Caching

Vor der Implementierung des **Caching** ging jede Anfrage direkt an die **Datenbank**, was zu erheblichen **Verzögerungen** bei der Verarbeitung führte.

## Nach dem Caching
Mit **Caching** werden die meisten Anfragen jetzt von **Redis** bearbeitet, was die **Antwortzeit erheblich reduziert**.

# Zusammenfassung
**Caching** mit **Redis** hat es uns ermöglicht, die **Leistung** der Anwendung zu **optimieren**, die **Verarbeitungsgeschwindigkeit** von Anfragen zu **erhöhen** und die **Belastung** der **Datenbank** zu **reduzieren**. Dieser Ansatz ist besonders vorteilhaft für **Anwendungen mit hohem Datenverkehr**, bei denen die **Geschwindigkeit** der Anfrageverarbeitung entscheidend ist.

Dieser Kurs führt Sie in die Grundlagen von Redis und dessen Einsatz in realen Anwendungen ein. Wir behandeln wichtige Redis-Befehle, Datentypen, Schlüsselablauf und Transaktionen sowie die Integration von Redis mit Spring für effizientes Daten-Caching.

Dieser Abschnitt bietet eine Einführung in Redis, hebt seine Kernfunktionen und gängige Anwendungsfälle hervor. Sie lernen, wie Sie Redis auf verschiedenen Plattformen, einschließlich Windows und macOS, installieren und sich mit den Grundlagen der Verbindung und des Starts des Redis-Servers vertraut machen.

Hier erkunden wir die wesentlichen Redis-Befehle zur effektiven Verwaltung und Manipulation von Daten. Sie lernen, wie Sie Daten mit Befehlen wie SET, GET, EXISTS, INCR, DECR setzen, abrufen, inkrementieren und löschen und praktische Aufgaben bewältigen, um diese Konzepte in realen Szenarien anzuwenden.

Hier lernen Sie die wichtigsten Redis-Datentypen kennen, darunter Listen, Sets, Sorted Sets und Hashes. Sie werden ihre Funktionalität und praktische Anwendungen durch gezielte Übungen erkunden, die Ihr Verständnis jedes Datentyps vertiefen sollen.

Sie werden die erweiterten Funktionen von Redis erkunden, einschließlich der Verwaltung von Schlüssel-Lebenszyklen, der Ausführung von Transaktionen und der Nutzung des Pub/Sub-Nachrichtensystems. Zusätzlich lernen Sie wesentliche Sicherheitspraktiken kennen, um Ihre Redis-Umgebung vor unbefugtem Zugriff zu schützen.

Dieser Abschnitt führt in die Grundlagen des Cachings ein und zeigt, wie Redis als Cache in einer Spring-Anwendung konfiguriert wird. Er behandelt wichtige Caching-Anmerkungen und praktische Beispiele für das Caching von Abfragen in Webanwendungen und schließt mit einer Zusammenfassung der Hauptkonzepte ab.

Einführung in Redis

Praktische Verwendung von Hashes

Kurze Zusammenfassung aus dem Video

Vorteile des Cachings

Vor dem Caching

Nach dem Caching

Zusammenfassung