Exercice - Créer une application Spring Boot qui utilise Spring Data Redis

7 minutes

Dans cette unité, vous allez créer une application Spring Boot qui utilise Spring Data Redis pour stocker et récupérer des données dans Azure Cache pour Redis. Vous pouvez créer l’application, à l’exception de la connexion finale à Azure Cache pour Redis, en attendant que le déploiement de votre instance Azure Cache pour Redis se termine.

Créer le projet Spring Boot

Pour créer votre projet Spring Boot, exécutez la ligne de commande Spring Initializr suivante :

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 -

Notes

La commande utilise les composants Spring Web et Spring Data Redis. Spring Data Redis utilise le pilote Redis Lettuce, que vous pouvez également utiliser pour des tâches plus avancées.

Ajouter du code Spring pour gérer les données

Dans votre projet Spring Boot, à côté de la classe DemoApplication, ajoutez un objet de domaine Todo, comme suit :

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;
    }
}

Créez un dépôt Spring Data Redis appelé TodoRepository pour gérer cette collection, comme suit :

package com.example.demo;

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

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

}

Ajoutez un contrôleur Spring MVC appelé TodoController, comme suit :

 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();
    }
}

Obtenir les clés de sécurité d’Azure Cache pour Redis

Exécutez la commande suivante pour vérifier si votre instance Azure Cache pour Redis est prête à l’emploi.
```
az redis show --name $AZ_REDIS_NAME --resource-group $AZ_RESOURCE_GROUP
```
La commande retourne des données JSON qui contiennent un attribut provisioningState. Quand provisioningState a la valeur Succeeded, votre instance Azure Cache pour Redis est totalement disponible.
Conseil

Si vous disposez de l’utilitaire jq, vous pouvez entrer la ligne de commande suivante pour vérifier l’état de la préparation :
```
az redis show --name $AZ_REDIS_NAME --resource-group $AZ_RESOURCE_GROUP | jq '.provisioningState'
```
Quand l’instance Azure Cache pour Redis est prête, exécutez la commande suivante pour récupérer ses clés de sécurité :
```
az redis list-keys \
    --resource-group $AZ_RESOURCE_GROUP \
    --name $AZ_REDIS_NAME
```
Copiez la valeur primaryKey de la sortie pour l’utiliser à l’étape suivante.

Configurer Spring Boot pour se connecter à Azure Cache pour Redis

Ouvrez le fichier de configuration src/main/resources/application.properties dans votre application et ajoutez les propriétés suivantes. Remplacez l’espace réservé <redisName> par le nom de votre instance Redis, puis remplacez l’espace réservé <redisPrimaryKey> par la valeur primaryKey obtenue à l’étape précédente.

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

Tester localement l’application

Exécutez votre application Spring Boot, soit en lançant l’exécutable DemoApplication dans votre environnement de développement, soit en exécutant le plug-in Spring Boot Maven comme suit :
```
./mvnw spring-boot:run
```

Une fois l’application en cours d’exécution, stockez des données dans Redis à l’aide de la commande suivante :

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

Récupérez maintenant ces données à partir de Redis :
```
curl http://127.0.0.1:8080
```