Übung: Erstellen einer Spring Boot-Anwendung, die Spring Data Redis verwendet

7 Minuten

In dieser Lerneinheit erstellen Sie eine Spring Boot-Anwendung, die Spring Data Redis verwendet, um Daten in Azure Cache for Redis zu speichern und abzurufen. Sie können die Anwendung erstellen (mit Ausnahme der abschließenden Verbindung mit Azure Cache for Redis), während Sie auf den Abschluss der Bereitstellung Ihrer Azure Cache for Redis-Instanz warten.

Erstellen eines Spring Boot-Projekts

Führen Sie zum Erstellen Ihres Spring Boot-Projekts die folgende Spring Initializr-Befehlszeile aus:

curl https://start.spring.io/starter.tgz -d type=maven-project -d dependencies=web,data-redis -d baseDir=spring-redis-application -d bootVersion=2.4.1.RELEASE -d javaVersion=1.8 | tar -xzvf -

Hinweis

Der Befehl verwendet die Komponenten Spring Web und Spring Data Redis. Spring Data Redis verwendet den Lettuce-Redis-Treiber, den Sie auch für umfangreichere Aufgaben verwenden können.

Hinzufügen von Spring-Code zum Verwalten von Daten

Fügen Sie in Ihrem Spring Boot-Projekt neben der DemoApplication-Klasse wie folgt ein Todo-Domänenobjekt hinzu:

package com.example.demo;

import org.springframework.data.annotation.Id;
import org.springframework.data.redis.core.RedisHash;

import java.io.Serializable;

@RedisHash("Todo")
public class Todo implements Serializable {

    public Todo() {
    }

    public Todo(String description, String details, boolean done) {
        this.description = description;
        this.details = details;
        this.done = done;
    }

    @Id
    private Long id;

    private String description;

    private String details;

    private boolean done;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getDetails() {
        return details;
    }

    public void setDetails(String details) {
        this.details = details;
    }

    public boolean isDone() {
        return done;
    }

    public void setDone(boolean done) {
        this.done = done;
    }
}

Erstellen Sie wie folgt ein Spring Data Redis-Repository namens TodoRepository, um diese Sammlung zu verwalten:

package com.example.demo;

import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface TodoRepository extends CrudRepository<Todo, String> {

}

Fügen Sie wie folgt einen Spring MVC-Controller namens TodoController hinzu:

 package com.example.demo;

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/")
public class TodoController {

    private final TodoRepository todoRepository;

    public TodoController(TodoRepository todoRepository) {
        this.todoRepository = todoRepository;
    }

    @PostMapping("/")
    @ResponseStatus(HttpStatus.CREATED)
    public Todo createTodo(@RequestBody Todo todo) {
        return todoRepository.save(todo);
    }

    @GetMapping("/")
    public Iterable<Todo> findAllTodos() {
        return todoRepository.findAll();
    }
}

Abrufen von Azure Cache for Redis-Sicherheitsschlüsseln

Führen Sie den folgenden Befehl aus, um zu überprüfen, ob Ihre Azure Cache for Redis-Instanz einsatzbereit ist.
```
az redis show --name $AZ_REDIS_NAME --resource-group $AZ_RESOURCE_GROUP
```
Der Befehl gibt JSON-Daten zurück, die ein provisioningState-Attribut enthalten. Wenn provisioningState den Wert Succeeded aufweist, ist Ihre Azure Cache for Redis-Instanz vollständig verfügbar.
Tipp

Wenn Sie über das Hilfsprogramm jq verfügen, können Sie die Bereitschaft mit der folgenden einzelnen Befehlszeile überprüfen:
```
az redis show --name $AZ_REDIS_NAME --resource-group $AZ_RESOURCE_GROUP | jq '.provisioningState'
```
Wenn die Azure Cache for Redis-Instanz bereit ist, führen Sie den folgenden Befehl aus, um die Sicherheitsschlüssel abzurufen:
```
az redis list-keys \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_REDIS_NAME
```
Kopieren Sie den primaryKey-Wert zur Verwendung im nächsten Schritt.

Konfigurieren von Spring Boot zum Herstellen einer Verbindung zu Azure Cache for Redis

Öffnen Sie die Konfigurationsdatei src/main/resources/application.properties in Ihrer Anwendung, und fügen Sie die folgenden Eigenschaften hinzu. Ersetzen Sie den Platzhalter <redisName> durch den Namen Ihrer Redis-Instanz und den Platzhalter <redisPrimaryKey> durch den primaryKey-Wert, den Sie im vorherigen Schritt abgerufen haben.

spring.redis.host=<redisName>.redis.cache.windows.net
spring.redis.password=<redisPrimaryKey>
spring.redis.port=6380
spring.redis.ssl=true

Lokales Testen der Anwendung

Führen Sie Ihre Spring Boot-Anwendung aus, indem Sie entweder in Ihrer Entwicklungsumgebung die ausführbare Datei zur DemoApplication oder das Spring Boot Maven-Plug-In wie folgt ausführen:
```
./mvnw spring-boot:run
```

Wenn die Anwendung ausgeführt wird, speichern Sie mit dem folgenden Befehl einige Daten in Redis:

curl -d '{"description":"a description", "details":"some details"}' -H "Content-Type: application/json" -X POST http://127.0.0.1:8080

Rufen Sie diese Daten nun aus Redis ab:
```
curl http://127.0.0.1:8080
```