Anstatt das **Caching** manuell zu verwalten, können Sie **Annotationen** verwenden, die den Prozess automatisch **verwalten**. Werfen wir einen Blick auf die verfügbaren **Annotationen**.

## Caching-Ergebnisse

Die `@Cacheable` **Annotation** wird auf **Methoden** angewendet, deren **Ergebnisse** **gecached** werden sollen. Wenn die **Methode** erneut mit denselben **Parametern** aufgerufen wird, wird das **Ergebnis** aus dem **Cache** abgerufen.

```java
@Cacheable(value = "usersCache", key = "#userId")
public User getUserById(String userId) {
    return userRepository.findById(userId);
}
```

In diesem Beispiel speichert die `getUserById` **Methode** das **Ergebnis** einer **Benutzerabfrage** nach ihrer `ID` in einem **Cache** namens `"usersCache"`. Wenn die **Methode** erneut mit derselben `userId` aufgerufen wird, werden die **Daten** aus dem **Cache** abgerufen, anstatt die **Abfrage** gegen die **Datenbank** auszuführen.

## Aktualisierung des Caches

Die `@CachePut` **Annotation** aktualisiert den **Cache** jedes Mal, wenn die **Methode** ausgeführt wird, unabhängig davon, ob das **Ergebnis** zuvor **zwischengespeichert** wurde.

```java
@CachePut(value = "usersCache", key = "#user.id")
public User updateUser(User user) {
    return userRepository.save(user);
}
```

Die `@CachePut` **Annotation** wird verwendet, um den **Cache** jedes Mal zu **aktualisieren**, wenn die `updateUser` **Methode** aufgerufen wird. Dies ist nützlich, wenn sich die **Daten** ändern und Sie den **Cache** mit den Änderungen in der **Datenbank** **synchronisieren** müssen. Der **Cache** wird mit dem **Schlüssel** aktualisiert, der der **Benutzer-ID** entspricht.

# Cache leeren
Die `@CacheEvict` **Annotation** wird verwendet, um **Daten** aus dem **Cache** zu **entfernen**, zum Beispiel wenn ein **Benutzer** aus der **Datenbank** **gelöscht** wird.

```java
@CacheEvict(value = "usersCache", key = "#userId")
public void deleteUser(String userId) {
    userRepository.deleteById(userId);
}
```

In diesem **Beispiel** entfernt die `deleteUser` **Methode** den **Eintrag** aus dem **Cache** mit dem **Schlüssel**, der `userId` entspricht.

# Kombinierte Cache-Operationen
Die `@Caching` **Annotation** ermöglicht es, **mehrere Cache-Operationen** innerhalb einer **einzelnen Methode** durchzuführen, indem `@CachePut` und `@CacheEvict` kombiniert werden.

```java
@Caching(
    put = { @CachePut(value = "usersCache", key = "#user.id") },
    evict = { @CacheEvict(value = "usersCache", key = "#user.id") }
)
public User updateUser(User user) {
    return userRepository.save(user);
}
```

In diesem **Beispiel** aktualisiert die `updateUser`-**Methode** gleichzeitig den **Cache** mit dem **neuen Zustand** des **Benutzers** unter Verwendung von `@CachePut` und **entfernt** den **alten Eintrag** aus dem **Cache** unter Verwendung von `@CacheEvict`. Dies ist nützlich, wenn Sie **mehrere Cache-Operationen** gleichzeitig **ausführen** müssen.

Wann würden Sie `@CacheEvict` verwenden?

Was ist der Zweck der `@CachePut`-Annotation?

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

Annotationen für die Arbeit mit Cache

Caching-Ergebnisse

Aktualisierung des Caches

Cache leeren

Kombinierte Cache-Operationen

1. Wann würden Sie `@CacheEvict` verwenden?

2. Was ist der Zweck der `@CachePut`-Annotation?