Utiliser stockage Azure file d’attente dans les applications Spring

Cet article montre comment utiliser stockage Azure File d’attente dans Java applications créées avec Spring Framework.

Azure Queue Storage met en œuvre des files d’attente dans le cloud pour permettre la communication entre composants d’une application distribuée. Chaque file d’attente gère une liste de messages qui peuvent être ajoutés par un composant expéditeur et traités par un composant récepteur. Avec une file d'attente, votre application peut s'adapter immédiatement pour répondre à la demande.

Spring Cloud Azure fournit différents modules permettant d’utiliser des frameworks Spring pour envoyer des messages et recevoir des messages provenant de files d’attente stockage Azure. Vous pouvez utiliser ces modules indépendamment ou les combiner pour différents cas d'utilisation, comme décrit dans la liste suivante :

Prérequis

Remarque

Pour accorder à votre compte l'accès aux ressources, dans votre compte stockage Azure nouvellement créé, attribuez le rôle Storage Queue Data Contributor au compte Microsoft Entra que vous utilisez actuellement. Pour plus d’informations, consultez Assigner des rôles Azure à l’aide du portail Azure.

Importante

La version 2.5 ou supérieure de Spring Boot est nécessaire pour réaliser les étapes de ce tutoriel.

Préparer votre environnement local

Dans ce tutoriel, les configurations et le code ne comportent aucune opération d'authentification. Toutefois, la connexion à un service Azure nécessite une authentification. Pour terminer l’authentification, vous devez utiliser la bibliothèque de client Azure Identity. Spring Cloud Azure utilise DefaultAzureCredential, que la bibliothèque Azure Identity fournit pour vous aider à obtenir des informations d’identification sans aucune modification du code.

DefaultAzureCredential prend en charge plusieurs méthodes d’authentification et détermine quelle méthode doit être utilisée au moment de l’exécution. Cette approche permet à votre application d'utiliser différentes méthodes d'authentification dans différents environnements - tels que les environnements locaux ou de production - sans implémenter de code spécifique à l'environnement. Pour plus d’informations, consultez la section DefaultAzureCredential d’Authentifier les applications Java hébergées sur Azure.

Pour utiliser Azure CLI, IntelliJ ou d'autres méthodes pour terminer l’authentification dans les environnements de développement locaux, consultez l’authentification Azure dans les environnements de développement Java. Pour terminer l’authentification dans Azure environnements d’hébergement, nous vous recommandons d’utiliser l’identité managée. Pour plus d’informations, consultez Qu’est-ce que les identités managées pour les ressources Azure ?

Utiliser Spring Cloud stockage Azure Queue Starter

Le module Spring Cloud stockage Azure Queue Starter importe bibliothèque de client stockage Azure Queue pour Java avec le framework Spring Boot. Vous pouvez utiliser Spring Cloud Azure et le Kit de développement logiciel (SDK) Azure ensemble, dans un modèle non mutuellement exclusif. Par conséquent, vous pouvez continuer à utiliser l’API cliente file d’attente de stockage Java dans votre application Spring.

Ajout de dépendances

Pour installer le module Spring Cloud stockage Azure Queue Starter, ajoutez les dépendances suivantes à votre fichier pom.xml :

  • Le Spring Cloud Azure Bill of Materials (BOM) :

    <dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.3.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

    Remarque

    Si vous utilisez Spring Boot 4.0.x, veillez à mettre la spring-cloud-azure-dependencies version à 7.3.0.

    Si vous utilisez Spring Boot 3.5.x, assurez-vous de définir la version spring-cloud-azure-dependencies à 6.4.0.

    Si vous utilisez Spring Boot 3.1.x-3.5.x, veillez à définir la version spring-cloud-azure-dependencies5.25.0.

    Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.20.0.

    Cette liste de matériel (BOM) doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela garantit que toutes les dépendances spring Cloud Azure utilisent la même version.

    Pour plus d’informations sur la version utilisée pour ce boM, consultez Which Version of Spring Cloud Azure Should I Use.

  • Artefact de file d’attente Stockage File d'attente Azure Spring Cloud :

    <dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter-storage-queue</artifactId>
</dependency>

Codez votre application pour envoyer et recevoir des messages

Cette section vous montre comment utiliser les clients Stockage File d'attente Azure dans le contexte d’une application Spring. Vous avez les deux options suivantes :

  • Utilisez l'autoconfiguration de Spring Boot et les clients préconfigurés du contexte Spring (recommandé).
  • Construire le client par programme.

Avec l'autoconfiguration, vous câblez automatiquement les beans clients à partir du conteneur d'inversion de contrôle (IoC) de Spring. Cette approche vous offre une expérience plus flexible et plus efficace lorsque vous développez avec des clients Storage Queue. L'autoconfiguration présente les avantages suivants :

  • L'autoconfiguration utilise une configuration externalisée afin que vous puissiez travailler avec le même code d'application dans différents environnements.

  • Vous pouvez déléguer au cadre Spring Boot le processus d'apprentissage du modèle de construction et l'enregistrement des clients dans le contexte de l'application. Vous vous concentrez uniquement sur la manière d'utiliser les clients avec vos propres exigences commerciales.

  • Vous pouvez utiliser l'indicateur d'intégrité pour inspecter l'état et l'intégrité de votre application et de vos composants internes.

Les exemples de code des sections suivantes vous montrent comment utiliser QueueClient avec les deux alternatives décrites.

Conseil

Azure Java SDK pour la file d’attente de stockage fournit plusieurs clients pour interagir avec la file d’attente de stockage. Le starter fournit également une autoconfiguration pour tous les clients Storage Queue et les constructeurs de clients. Cet article n'utilise que QueueClient comme exemple.

Utiliser l'autoconfiguration de Spring Boot

Pour envoyer et recevoir des messages à partir de stockage Azure files d’attente, procédez comme suit pour configurer l’application :

  1. Configurez le nom de votre compte de stockage et le nom de votre file d'attente, comme indiqué dans l'exemple suivant :

    spring.cloud.azure.storage.queue.account-name=<your-storage-account-name>
spring.cloud.azure.storage.queue.queue-name=<your-storage-queue-name>

  2. Injectez le QueueClient dans votre application Spring et appelez les API correspondantes pour envoyer des messages, comme le montre l'exemple suivant :

    import com.azure.storage.queue.QueueClient;
import com.azure.storage.queue.models.QueueMessageItem;
import com.azure.storage.queue.models.SendMessageResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class StorageQueueClientApplication implements CommandLineRunner {

    private final static Logger logger = LoggerFactory.getLogger(StorageQueueClientApplication.class);

    @Autowired
    private QueueClient queueClient;

    public static void main(String[] args) {
        SpringApplication.run(StorageQueueClientApplication.class, args);
    }

    @Override
    public void run(String... args) {
     // Using the QueueClient object, call the create method to create the queue in your storage account.
        queueClient.create();
        SendMessageResult sendMessageResult = queueClient.sendMessage("Hello world");
        logger.info("Send message id: {}", sendMessageResult.getMessageId());

        QueueMessageItem queueMessageItem = queueClient.receiveMessage();
        logger.info("Received message: {}", new String(queueMessageItem.getBody().toBytes()));
    }

}

  3. Lancez l’application. Après le lancement, l'application produit des logs similaires à l'exemple suivant :

    Send message id: ...
Received message: Hello world

Construire le client par programme

Vous pouvez créer les beans de client vous-même, mais le processus est compliqué. Dans les applications Spring Boot, vous devez gérer les propriétés, apprendre le modèle de constructeur et enregistrer les clients dans votre contexte d'application Spring. Les étapes suivantes vous montrent comment procéder.

  1. Construisez le client par programme dans votre application Spring, comme le montre l'exemple suivant. Veillez à remplacer l'espace réservé <storage-account-name> par votre propre valeur.

    import com.azure.identity.DefaultAzureCredentialBuilder;
import com.azure.storage.queue.QueueClient;
import com.azure.storage.queue.QueueClientBuilder;
import com.azure.storage.queue.models.QueueMessageItem;
import com.azure.storage.queue.models.SendMessageResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class StorageQueueClientApplication implements CommandLineRunner {

    private final static String queueName = "test-queue";
    private final static String endpoint = "https://<storage-account-name>.queue.core.windows.net/";
    private final static Logger logger = LoggerFactory.getLogger(StorageQueueClientApplication.class);

    QueueClient queueClient = new QueueClientBuilder()
        .endpoint(endpoint)
        .queueName(queueName)
        .credential(new DefaultAzureCredentialBuilder().build())
        .buildClient();

    public static void main(String[] args) {
        SpringApplication.run(StorageQueueClientApplication.class, args);
    }

    @Override
    public void run(String... args) {
     // Using the QueueClient object, call the create method to create the queue in your storage account.
        queueClient.create();
        SendMessageResult sendMessageResult = queueClient.sendMessage("Hello world");
        logger.info("Send message id: {}", sendMessageResult.getMessageId());

        QueueMessageItem queueMessageItem = queueClient.receiveMessage();
        logger.info("Received message: {}", new String(queueMessageItem.getBody().toBytes()));
    }

}

  2. Lancez l’application. Après le lancement, l'application produit des logs similaires à l'exemple suivant :

    Send message id: ...
Received message: Hello world

La liste suivante montre les raisons pour lesquelles ce code n'est pas flexible ou gracieux :

  • Les noms des comptes de stockage et des files d'attente sont codés en dur.
  • Si vous utilisez @Value pour obtenir des configurations à partir de l’environnement Spring, vous ne pouvez pas avoir d’indicateurs IDE dans votre fichier application.properties .
  • Si vous avez un scénario de microservice, vous devez dupliquer le code dans chaque projet, et il est facile de faire des erreurs et difficile d'être cohérent.

Heureusement, créer les beans clients par soi-même n'est pas nécessaire avec Spring Cloud Azure. Au lieu de cela, vous pouvez les injecter directement et utiliser les propriétés de configuration que vous connaissez déjà pour configurer la file d'attente de stockage. Pour plus d’informations, consultez les propriétés de configuration Spring Cloud Azure.

Spring Cloud Azure fournit également les configurations globales suivantes pour différents scénarios. Pour plus d’informations, consultez Spring Cloud Azure propriétés de configuration globales.

  • Options de proxy.
  • Options de réessai.

Vous pouvez également vous connecter à différents clouds Azure. Pour plus d’informations, consultez Connect to different Azure clouds.

Utiliser stockage Azure Queue de Spring Messaging

Le module Spring Messaging stockage Azure Queue prend en charge l’infrastructure Spring Messaging avec Stockage File d'attente Azure.

Si vous utilisez Spring Messaging Azure Queue Storage, vous pouvez utiliser la fonctionnalité StorageQueueTemplate pour envoyer des messages aux files d'attente de façon asynchrone et synchrone.

Les sections suivantes vous montrent comment utiliser Spring Messaging avec stockage Azure Queue pour envoyer des messages vers et recevoir des messages depuis des files d'attente de stockage.

Ajout de dépendances

Pour installer le module Spring Messaging stockage Azure Queue, ajoutez les dépendances suivantes à votre fichier pom.xml :

  • Le Spring Cloud Azure Bill of Materials (BOM) :

    <dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.3.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

    Remarque

    Si vous utilisez Spring Boot 4.0.x, veillez à mettre la spring-cloud-azure-dependencies version à 7.3.0.

    Si vous utilisez Spring Boot 3.5.x, assurez-vous de définir la version spring-cloud-azure-dependencies à 6.4.0.

    Si vous utilisez Spring Boot 3.1.x-3.5.x, veillez à définir la version spring-cloud-azure-dependencies5.25.0.

    Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.20.0.

    Cette liste de matériel (BOM) doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela garantit que toutes les dépendances spring Cloud Azure utilisent la même version.

    Pour plus d’informations sur la version utilisée pour ce boM, consultez Which Version of Spring Cloud Azure Should I Use.

  • Les composants Spring Cloud Azure Starter et les files d'attente de stockage Spring Messaging :

    <dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter</artifactId>
</dependency>
<dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-messaging-azure-storage-queue</artifactId>
</dependency>

Codez votre application pour envoyer et recevoir des messages

Suivez les étapes suivantes pour configurer et coder votre application :

  1. Configurez le nom du compte stockage Azure pour vos files d’attente de stockage, comme illustré dans l’exemple suivant :

    spring.cloud.azure.storage.queue.account-name=<your-storage-account-name>

  2. Connectez un émetteur et un récepteur pour envoyer et recevoir des messages avec Spring, comme indiqué dans l'exemple suivant. Veillez à remplacer l'espace réservé <storage-queue-name> par votre propre valeur.

    import com.azure.spring.messaging.AzureHeaders;
import com.azure.spring.messaging.checkpoint.Checkpointer;
import com.azure.spring.messaging.storage.queue.core.StorageQueueTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import java.time.Duration;

@SpringBootApplication
public class StorageQueueMessagingApplication implements CommandLineRunner {

    private static final Logger LOGGER = LoggerFactory.getLogger(StorageQueueMessagingApplication.class);
    private static final String STORAGE_QUEUE_NAME = "<storage-queue-name>";

    @Autowired
    StorageQueueTemplate storageQueueTemplate;

    public static void main(String[] args) {
        SpringApplication.run(StorageQueueMessagingApplication.class, args);
    }

    @Override
    public void run(String... args) {
        storageQueueTemplate
            .sendAsync(STORAGE_QUEUE_NAME, MessageBuilder.withPayload("Hello world").build())
            .subscribe();
        LOGGER.info("Message was sent successfully.");

        Message<?> message = storageQueueTemplate.receiveAsync(STORAGE_QUEUE_NAME, Duration.ofSeconds(30)).block();
        LOGGER.info("Received message: {}", new String((byte[]) message.getPayload()));
    }

}

  3. Lancez l’application. Après le lancement, l'application produit des logs similaires à l'exemple suivant :

    Message was sent successfully.
...
Received message: Hello World

Utiliser Spring Integration avec la file d'attente stockage Azure

Le module Spring Integration stockage Azure Queue prend en charge l’infrastructure Spring Integration avec des files d’attente de stockage.

Si votre application Spring utilise des canaux de messages Spring Integration, vous pouvez acheminer les messages entre vos canaux de messages et la file d'attente de stockage à l'aide d'adaptateurs de canaux. Un adaptateur de canal entrant redirecte les messages d'une file d'attente de stockage vers une chaîne de messages. Un adaptateur de canal sortant transmet les messages d'un canal de messages vers une file d'attente de stockage.

Les sections suivantes vous montrent comment utiliser Spring Integration stockage Azure Queue pour envoyer des messages sur et les recevoir des files d’attente de stockage.

Ajout de dépendances

Pour installer le module Spring Integration stockage Azure Queue, ajoutez les dépendances suivantes à votre fichier pom.xml :

  • Le Spring Cloud Azure Bill of Materials (BOM) :

    <dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.3.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>

    Remarque

    Si vous utilisez Spring Boot 4.0.x, veillez à mettre la spring-cloud-azure-dependencies version à 7.3.0.

    Si vous utilisez Spring Boot 3.5.x, assurez-vous de définir la version spring-cloud-azure-dependencies à 6.4.0.

    Si vous utilisez Spring Boot 3.1.x-3.5.x, veillez à définir la version spring-cloud-azure-dependencies5.25.0.

    Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.20.0.

    Cette liste de matériel (BOM) doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela garantit que toutes les dépendances spring Cloud Azure utilisent la même version.

    Pour plus d’informations sur la version utilisée pour ce boM, consultez Which Version of Spring Cloud Azure Should I Use.

  • Les artefacts de la file d'attente stockage Azure de Spring Integration :

    <dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter-integration-storage-queue</artifactId>
</dependency>

Codez votre application pour envoyer et recevoir des messages

Suivez les étapes suivantes pour configurer et coder votre application :

  1. Configurez le nom du compte stockage Azure pour vos files d’attente de stockage.

    spring.cloud.azure.storage.queue.account-name=<your-storage-account-name>

  2. Créez une classe QueueReceiveConfiguration Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour définir un récepteur de message. Veillez à remplacer l'espace réservé <storage-queue-name> par votre propre valeur.

    import com.azure.spring.integration.storage.queue.inbound.StorageQueueMessageSource;
import com.azure.spring.messaging.AzureHeaders;
import com.azure.spring.messaging.checkpoint.Checkpointer;
import com.azure.spring.messaging.storage.queue.core.StorageQueueTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.annotation.InboundChannelAdapter;
import org.springframework.integration.annotation.Poller;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.messaging.handler.annotation.Header;

@Configuration
public class QueueReceiveConfiguration {

    private static final Logger LOGGER = LoggerFactory.getLogger(QueueReceiveConfiguration.class);
    private static final String STORAGE_QUEUE_NAME = "<storage-queue-name>";
    private static final String INPUT_CHANNEL = "input";

    @Bean
    @InboundChannelAdapter(channel = INPUT_CHANNEL, poller = @Poller(fixedDelay = "1000"))
    public StorageQueueMessageSource storageQueueMessageSource(StorageQueueTemplate storageQueueTemplate) {
        return new StorageQueueMessageSource(STORAGE_QUEUE_NAME, storageQueueTemplate);
    }

    @ServiceActivator(inputChannel = INPUT_CHANNEL)
    public void messageReceiver(byte[] payload, @Header(AzureHeaders.CHECKPOINTER) Checkpointer checkpointer) {
        String message = new String(payload);
        LOGGER.info("Received message: {}", message);
    }

}

  3. Créez une classe QueueSendConfiguration Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour définir un expéditeur de messages. Veillez à remplacer l'espace réservé <storage-queue-name> par votre propre valeur.

    import com.azure.spring.integration.core.handler.DefaultMessageHandler;
import com.azure.spring.messaging.storage.queue.core.StorageQueueTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.annotation.MessagingGateway;
import org.springframework.integration.annotation.ServiceActivator;
import org.springframework.messaging.MessageHandler;
import org.springframework.util.concurrent.ListenableFutureCallback;

@Configuration
public class QueueSendConfiguration {

    private static final Logger LOGGER = LoggerFactory.getLogger(QueueSendConfiguration.class);
    private static final String STORAGE_QUEUE_NAME = "<storage-queue-name>";
    private static final String OUTPUT_CHANNEL = "output";

    @Bean
    @ServiceActivator(inputChannel = OUTPUT_CHANNEL)
    public MessageHandler messageSender(StorageQueueTemplate storageQueueTemplate) {
        DefaultMessageHandler handler = new DefaultMessageHandler(STORAGE_QUEUE_NAME, storageQueueTemplate);
        handler.setSendCallback(new ListenableFutureCallback<Void>() {
            @Override
            public void onSuccess(Void result) {
                LOGGER.info("Message was sent successfully.");
            }

            @Override
            public void onFailure(Throwable ex) {
                LOGGER.info("There was an error sending the message.");
            }
        });
        return handler;
    }

    @MessagingGateway(defaultRequestChannel = OUTPUT_CHANNEL)
    public interface StorageQueueOutboundGateway {
        void send(String text);
    }

}

  4. Créez un émetteur et un récepteur pour envoyer et recevoir des messages avec Spring.

    import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.integration.config.EnableIntegration;

@SpringBootApplication
@EnableIntegration
@Configuration(proxyBeanMethods = false)
public class StorageQueueIntegrationApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(StorageQueueIntegrationApplication.class, args);
        QueueSendConfiguration.StorageQueueOutboundGateway storageQueueOutboundGateway = applicationContext.getBeanQueueSendConfiguration.StorageQueueOutboundGateway.class);
        storageQueueOutboundGateway.send("Hello World");
    }

}

    Conseil

    N'oubliez pas d'ajouter l'annotation @EnableIntegration, qui active l'infrastructure d'intégration Spring.

  5. Lancez l’application. Après le lancement, l'application produit des logs similaires à l'exemple suivant :

    Message was sent successfully.
Received message: Hello World

Déployer sur Azure Spring Apps

Maintenant que l'application Spring Boot fonctionne localement, il est temps de la mettre en production. Azure Spring Apps facilite le déploiement d’applications Spring Boot sur Azure sans aucune modification du code. Le service gère l’infrastructure des applications Spring, ce qui permet aux développeurs de se concentrer sur leur code. Azure Spring Apps fournit une gestion du cycle de vie à l’aide de la supervision et des diagnostics complets, de la gestion de la configuration, de la découverte de services, de l’intégration CI/CD, des déploiements bleu-vert, etc. Pour déployer votre application sur Azure Spring Apps, consultez Deploy your first application to Azure Spring Apps.

Étapes suivantes

Azure pour les développeurs SpringSpring Cloud stockage Azure Queue Samples

Voir aussi

Pour plus d’informations sur les démarrages Spring Boot disponibles pour Microsoft Azure, consultez Qu’est-ce que Spring Cloud Azure ?

  • Last updated on