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

7 minutes

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

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 -

Remarque

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, en regard 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 référentiel 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 des clés de sécurité Azure Cache pour Redis

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

Si vous disposez de l’utilitaire jq , vous pouvez utiliser la ligne de commande unique suivante pour vérifier la préparation :
```
az redis show --name $AZ_REDIS_NAME --resource-group $AZ_RESOURCE_GROUP | jq '.provisioningState'
```
Lorsque 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 au cache Azure 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 <redisName> réservé par le nom de votre instance Redis, puis remplacez l’espace <redisPrimaryKey> réservé par la primaryKey valeur 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 exécutant l’application demoApplication exécutable 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
```

Passez à l’unité suivante pour apprendre à utiliser Azure Cache pour Redis pour stocker les données de session HTTP via Spring Session.