Eine **Liste** bewahrt die **Reihenfolge** der Elemente und unterstützt den **Zugriff nach Index**. Dies macht sie geeignet für Aufgaben wie das Erstellen von **Aufgabenwarteschlangen**, **Ereignisprotokollierung** oder das Speichern von **Echtzeitdaten** wie **jüngste Benutzeraktivitäten**.

# Die Hauptbefehle für die Arbeit mit Listen in Redis

Die **Schlüsselbefehle** für die Arbeit mit Listen in **Redis** umfassen mehrere Kategorien, die jeweils eine bestimmte Aufgabe ansprechen: **Hinzufügen**, **Abrufen**, **Lesen**, **Ändern**, **Löschen von Elementen** und Verwalten der **Größe** der Liste.

## Hinzufügen von Elementen zu einer Liste

Redis bietet **zwei Befehle** zum **Hinzufügen** von Elementen zu einer Liste: `LPUSH` und `RPUSH`, die Elemente jeweils am **Anfang** und am **Ende** der Liste hinzufügen.

```
LPUSH tasks "Task1" "Task2"  # adds to the beginning
RPUSH tasks "Task3" "Task4"  # adds to the end
```

**Nach der Ausführung** dieser Befehle wird die `tasks` **Liste** so aussehen: `["Task2", "Task1", "Task3", "Task4"]`.

## Entfernen von Elementen aus einer Liste

Um **Elemente zu entfernen** aus einer Liste, bietet Redis **zwei Befehle**: `LPOP` und `RPOP`, die Elemente vom **Anfang** bzw. vom **Ende** der Liste entfernen und zurückgeben.

```
LPOP tasks  # removes and returns "Task2"
RPOP tasks  # removes and returns "Task4"
```

**Nach der Ausführung** dieser Befehle sieht die `tasks` **Liste** so aus: `["Task1", "Task3"]`.

## Lesen von Elementen aus einer Liste
Um **Elemente aus einer Liste zu lesen**, bietet Redis die Befehle `LRANGE`, `LINDEX` und `LLEN`. `LRANGE` und `LINDEX` ermöglichen es Ihnen, **Elemente nach Index abzurufen**, während `LLEN` die **Gesamtanzahl** der Elemente in der Liste zurückgibt.

```
LRANGE tasks 0 -1  # returns all elements in the list
LINDEX tasks 0    # returns the first element
LLEN tasks        # returns the length of the list
```

- `LRANGE` wird **alle Elemente** zurückgeben: `["Task1", "Task3"]`;
- `LINDEX` wird **"Task1"** zurückgeben;
- `LLEN` wird **2** zurückgeben.

## Eine Liste ändern
Um ein Element in einer Liste zu **ändern**, verwenden Sie den `LSET`-Befehl, der es Ihnen ermöglicht, ein Element an einem **bestimmten Index** zu **aktualisieren**.

```
LSET tasks 1 "UpdatedTask"  # updates the second element to "UpdatedTask"
```

**Nach der Ausführung** dieses Befehls wird die `tasks` **Liste** sein: `["Task1", "UpdatedTask"]`.

## Kürzen einer Liste
Der `LTRIM` **Befehl** wird verwendet, um eine Liste zu **kürzen**, wobei nur die **Elemente** innerhalb eines **spezifizierten Bereichs** beibehalten werden. Alle anderen Elemente werden **entfernt**.

```
LTRIM tasks 0 1  # keeps only the first two elements
```

Wenn die **Liste** `tasks` war: `["Task1", "Task2", "Task3"]`, **nach der Ausführung** des Befehls wird die Liste enthalten: `["Task1", "Task2"]`.

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.