Utiliser Azure Service Bus dans les applications Spring

Cet article explique comment utiliser Azure Service Bus dans Java applications créées avec Spring Framework.

Azure fournit une plateforme de messagerie asynchrone appelée Azure Service Bus (Service Bus), qui est basée sur la norme Advanced Message Queueing Protocol 1.0 (AMQP 1.0). Vous pouvez utiliser Service Bus sur la plage de plateformes de Azure prises en charge.

Spring Cloud Azure fournit différents modules permettant d’envoyer et de recevoir des messages depuis Service Bus files d’attente et topiques/ et abonnements à l’aide des frameworks Spring.

Vous pouvez utiliser les modules suivants indépendamment ou les combiner pour différents cas d'utilisation :

Spring Cloud Azure Service Bus Starter vous permet d’envoyer et de recevoir des messages avec la bibliothèque cliente Service Bus Java SDK avec les fonctionnalités Spring Boot.
Spring Cloud Azure Service Bus JMS Starter vous permet d’utiliser l’API JMS pour envoyer et recevoir des messages avec Service Bus files d’attente et rubriques/abonnements.
Spring Messaging Azure Service Bus vous permet d’interagir avec Service Bus via l’API Spring Messaging.
Spring Integration Azure Service Bus vous permet de connecter Spring Integration Message Channels avec Service Bus.
Spring Cloud Stream Binder pour Service Bus vous permet d’utiliser Service Bus comme intergiciel de messagerie dans les applications Spring Cloud Stream.

Prérequis

Un abonnement Azure - créez-en un gratuitement.
Java Kit de développement (JDK) version 8 ou ultérieure.
Apache Maven, version 3.0 ou supérieure.
Un Azure Service Bus et une file d’attente ou une rubrique/abonnement. Si vous n'en avez pas, créez une file d'attente ou une rubrique Service Bus. Pour plus d’informations, consultez Utiliser Azure portail pour créer un espace de noms Service Bus et une file d’attente ou Utilisez le portail Azure pour créer une rubrique Service Bus et des abonnements à la rubrique.
Si vous n'avez pas d'application Spring Boot, créez un projet Maven avec Spring Initializr. Veillez à sélectionner Maven Project et, sous Dependencies, ajoutez la dépendance Spring Web, puis sélectionnez Java version 8 ou ultérieure.

Remarque

Pour accorder à votre compte l’accès à vos ressources Service Bus, dans votre espace de noms Azure Service Bus nouvellement créé, affectez les rôles Azure Service Bus Expéditeur de données et Azure Service Bus Récepteur de données aux rôles Microsoft Entra compte 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 de la section Authentification des 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 d’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 ?

Remarque

Azure Service Bus pour l'API JMS ne prend actuellement pas en charge DefaultAzureCredential. Si vous utilisez Spring JMS avec Service Bus, ignorez cette étape.

Utiliser Spring Cloud Azure Service Bus Starter

Le module Spring Cloud Azure Service Bus Starter importe Service Bus Java bibliothèque cliente avec l’infrastructure Spring Boot. Vous pouvez utiliser Spring Cloud Azure et le Azure SDK ensemble, dans un modèle non mutuellement exclusif. Par conséquent, vous pouvez continuer à utiliser l’API cliente Service Bus Java dans votre application Spring.

Ajouter la dépendance Service Bus

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

Le Bill of Materials (BOM) de Spring Cloud Azure :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.1.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.1.0.

Si vous utilisez Spring Boot 3.5.x, assurez-vous de définir la version spring-cloud-azure-dependencies à 6.1.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.

L'artéfact Service Bus de Spring Cloud Azure

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

Codez l'application pour envoyer et recevoir des messages

Ce guide explique comment utiliser les clients Service Bus Java dans le contexte d’une application Spring. Nous présentons ici deux alternatives. Il est recommandé d’utiliser la configuration automatique de Spring Boot et utilisez des clients prêts à l’emploi à partir du contexte Spring. L'autre solution consiste à créer vos propres clients par programmation.

La première méthode, qui implique le câblage automatique des beans clients à partir du conteneur Spring IoC, présente les avantages suivants par rapport à la seconde méthode. Ces avantages vous offrent une expérience plus flexible et efficace lors du développement avec Service Bus clients.

Vous pouvez utiliser une configuration externalisée afin de pouvoir 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 d'enregistrement de ce client dans le contexte de l'application. Cette délégation vous permet de vous concentrer sur la manière d'utiliser les clients en fonction de vos propres exigences commerciales.
Vous pouvez utiliser l'indicateur d'intégrité de manière simple pour inspecter l'état et l'intégrité de votre application et de ses composants internes.

L'exemple de code suivant vous montre comment utiliser ServiceBusSenderClient et ServiceBusProcessorClient avec ces deux alternatives.

Remarque

Azure Java SDK pour Service Bus fournit plusieurs clients pour interagir avec Service Bus. Le starter fournit également une configuration automatique pour tous les clients du Service Bus et les générateurs de clients. Nous n'utilisons ici que ServiceBusSenderClient et ServiceBusProcessorClient comme exemples.

Utiliser l'autoconfiguration de Spring Boot

Pour envoyer et recevoir des messages à partir de Service Bus, configurez l’application en procédant comme suit :

Configurez votre espace de noms et votre file d’attente Service Bus, comme illustré dans l’exemple suivant :
```
spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
spring.cloud.azure.servicebus.entity-name=<your-servicebus-queue-name>
spring.cloud.azure.servicebus.entity-type=queue
```
Conseil

Nous utilisons ici une file d’attente Service Bus comme exemple. Pour utiliser la rubrique/abonnement, vous devez ajouter la propriété spring.cloud.azure.servicebus.processor.subscription-name et changer la valeur entity-type en topic.

Créez une classe ServiceBusProcessorClientConfiguration Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour enregistrer le message et le gestionnaire d'erreur de ServiceBusProcessorClient

@Configuration(proxyBeanMethods = false)
public class ServiceBusProcessorClientConfiguration {

    @Bean
    ServiceBusRecordMessageListener processMessage() {
        return context -> {
            ServiceBusReceivedMessage message = context.getMessage();
            System.out.printf("Processing message. Id: %s, Sequence #: %s. Contents: %s%n", message.getMessageId(),
                    message.getSequenceNumber(), message.getBody());
        };
    }

    @Bean
    ServiceBusErrorHandler processError() {
        return context -> {
            System.out.printf("Error when receiving messages from namespace: '%s'. Entity: '%s'%n",
                    context.getFullyQualifiedNamespace(), context.getEntityPath());
        };
    }
}

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

@SpringBootApplication
public class ServiceBusQueueApplication implements CommandLineRunner {

    private final ServiceBusSenderClient senderClient;

    public ServiceBusQueueApplication(ServiceBusSenderClient senderClient) {
        this.senderClient = senderClient;
    }

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

    @Override
    public void run(String... args) throws Exception {
        // send one message to the queue
        senderClient.sendMessage(new ServiceBusMessage("Hello, World!"));
        System.out.printf("Sent a message to the queue");
        senderClient.close();

        // wait the processor client to consume messages
        TimeUnit.SECONDS.sleep(10);
    }

}

Remarque

Par défaut, le cycle de vie du bean autowired ServiceBusProcessorClient est géré par le contexte Spring. Le processeur est automatiquement démarré lorsque le Spring Application Context démarre, et arrêté lorsque le Spring Application Context s'arrête. Pour désactiver cette fonctionnalité, configurez spring.cloud.azure.servicebus.processor.auto-startup=false.

Lancez l’application. Des journaux d’activité similaires à l’exemple suivant s’affichent :

Sent a message to the queue
Processing message. Id: 6f405435200047069a3caf80893a80bc, Sequence #: 1. Contents: Hello, World!

Générer des clients Service Bus par programmation

Vous pouvez créer vous-même ces composants client, mais le processus est complexe. Dans les applications Spring Boot, vous devez gérer les propriétés, apprendre le modèle de construction et enregistrer le client dans votre contexte d'application Spring. L'exemple de code suivant montre comment procéder :

Créez une classe ServiceBusClientConfiguration Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour déclarer les beans ServiceBusSenderClient et ServiceBusProcessorClient.

@Configuration(proxyBeanMethods = false)
public class ServiceBusClientConfiguration {

    private static final String SERVICE_BUS_FQDN = "<service-bus-fully-qualified-namespace>";
    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    @Bean
    ServiceBusClientBuilder serviceBusClientBuilder() {
        return new ServiceBusClientBuilder()
                   .fullyQualifiedNamespace(SERVICE_BUS_FQDN)
                   .credential(new DefaultAzureCredentialBuilder().build());
    }

    @Bean
    ServiceBusSenderClient serviceBusSenderClient(ServiceBusClientBuilder builder) {
        return builder
               .sender()
               .queueName(QUEUE_NAME)
               .buildClient();
    }

    @Bean
    ServiceBusProcessorClient serviceBusProcessorClient(ServiceBusClientBuilder builder) {
        return builder.processor()
                      .queueName(QUEUE_NAME)
                      .processMessage(ServiceBusClientConfiguration::processMessage)
                      .processError(ServiceBusClientConfiguration::processError)
                      .buildProcessorClient();
    }

    private static void processMessage(ServiceBusReceivedMessageContext context) {
        ServiceBusReceivedMessage message = context.getMessage();
        System.out.printf("Processing message. Id: %s, Sequence #: %s. Contents: %s%n",
            message.getMessageId(), message.getSequenceNumber(), message.getBody());
    }

    private static void processError(ServiceBusErrorContext context) {
        System.out.printf("Error when receiving messages from namespace: '%s'. Entity: '%s'%n",
                context.getFullyQualifiedNamespace(), context.getEntityPath());
    }
}

Remarque

Veillez à remplacer l’espace réservé <service-bus-fully-qualified-namespace> par votre nom d’hôte du Service Bus depuis le portail Azure. Remplacez l’espace réservé <service-bus-queue-name> par votre propre nom de file d’attente configuré dans votre espace de noms Service Bus.

Injectez les composants Beans clients dans votre application, comme illustré dans l’exemple suivant :

@SpringBootApplication
public class ServiceBusQueueApplication implements CommandLineRunner {

    private final ServiceBusSenderClient senderClient;

    private final ServiceBusProcessorClient processorClient;

    public ServiceBusQueueApplication(ServiceBusSenderClient senderClient, ServiceBusProcessorClient processorClient) {
        this.senderClient = senderClient;
        this.processorClient = processorClient;
    }

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

    @Override
    public void run(String... args) throws Exception {
        // send one message to the queue
        senderClient.sendMessage(new ServiceBusMessage("Hello, World!"));
        System.out.printf("Sent a message to the queue");
        senderClient.close();

        System.out.printf("Starting the processor");
        processorClient.start();
        TimeUnit.SECONDS.sleep(10);
        System.out.printf("Stopping and closing the processor");
        processorClient.close();
    }

}

Lancez l’application. Des journaux d’activité similaires à l’exemple suivant s’affichent :

Sent a message to the queue
Starting the processor
...
Processing message. Id: 6f405435200047069a3caf80893a80bc, Sequence #: 1. Contents: Hello, World!
Stopping and closing the processor

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

L'espace de noms et les noms de file d'attente/sujet/abonnement 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, il n'est pas nécessaire de créer vous-même les beans clients avec Spring Cloud Azure. Au lieu de cela, vous pouvez injecter directement les haricots et utiliser les propriétés configuration que vous connaissez déjà pour configurer Service Bus.

Spring Cloud Azure fournit également les configurations globales suivantes pour différents scénarios. Pour plus d'informations, consultez la section configuration globale pour les SDK Azure Service de la Spring Cloud Azure configuration.

Options de proxy.
Options de réessai.
Options du client de transport AMQP.

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

Utiliser Spring Cloud Azure Service Bus JMS Starter

Le module Spring Cloud Azure Service Bus JMS Starter fournit Spring JMS intégration à Service Bus. La vidéo suivante explique comment intégrer des applications Spring JMS à Azure Service Bus à l’aide de JMS 2.0.

Ce guide vous montre comment utiliser Spring Cloud Azure Service Bus Starter pour l’API JMS pour envoyer et recevoir des messages de Service Bus.

Ajouter la dépendance Service Bus

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

Le Bill of Materials (BOM) de Spring Cloud Azure :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.1.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.1.0.

Si vous utilisez Spring Boot 3.5.x, assurez-vous de définir la version spring-cloud-azure-dependencies à 6.1.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.

L’artéfact JMS de Spring Cloud Azure Service Bus :

<dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-starter-servicebus-jms</artifactId>
</dependency>

Codez l'application pour envoyer et recevoir des messages

Configurez la chaîne de connexion et le niveau tarifaire de votre Service Bus, comme indiqué dans l’exemple suivant :

spring.jms.servicebus.connection-string=<service-bus-namespace-connection-string>
spring.jms.servicebus.pricing-tier=<service-bus-pricing-tier>

Créez le récepteur de messages.

Spring fournit les moyens de publier des messages dans n’importe quel objet POJO (Objet Java ancien brut). Tout d'abord, définissez une classe générique User qui stocke et récupère le nom de l'utilisateur, comme le montre l'exemple suivant :
```
public class User implements Serializable {

    private static final long serialVersionUID = -295422703255886286L;

    private String name;

    public User() {
    }

    public User(String name) {
        setName(name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
```
Conseil

Serializable est implémenté pour utiliser la méthode send dans JmsTemplate dans l’infrastructure Spring. Sinon, vous devez définir un bean MessageConverter personnalisé pour sérialiser le contenu en JSON au format texte. Pour plus d’informations sur MessageConverter, consultez le projet de démarrage JMS Spring officiel.
À partir de là, vous pouvez créer une classe QueueReceiveService Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour définir un récepteur de message.
```
@Component
public class QueueReceiveService {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    @JmsListener(destination = QUEUE_NAME, containerFactory = "jmsListenerContainerFactory")
    public void receiveMessage(User user) {
        System.out.printf("Received a message from %s.", user.getName());
    }
}
```
Remarque

Veillez à remplacer l’espace réservé <service-bus-queue-name> par votre propre nom de file d’attente configuré dans votre espace de noms Service Bus.

Si vous utilisez une rubrique/un abonnement, remplacez le paramètre destination par le nom de la rubrique et le paramètre containerFactory par topicJmsListenerContainerFactory. Ajoutez également le paramètre subscription pour décrire le nom de l'abonnement.

Connectez un émetteur et un récepteur pour envoyer et recevoir des messages avec Spring, comme le montre l'exemple suivant :

@SpringBootApplication
@EnableJms
public class ServiceBusJmsStarterApplication {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(ServiceBusJMSQueueApplication.class, args);
        JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);

        // Send a message with a POJO - the template reuse the message converter
        System.out.println("Sending a user message.");
        jmsTemplate.convertAndSend(QUEUE_NAME, new User("Tom"));
    }
}

Remarque

Veillez à remplacer l’espace réservé <service-bus-queue-name> par votre propre nom de file d’attente configuré dans votre espace de noms Service Bus.

Conseil

Veillez à ajouter l'annotation @EnableIntegration, qui déclenche la découverte des méthodes annotées avec @JmsListener, créant ainsi le conteneur d'écoute de messages en arrière-plan.

Lancez l’application. Des journaux d’activité similaires à l’exemple suivant s’affichent :
```
Sending a user message.
Received a message from Tom.
```

Autres informations

Pour plus d’informations, consultez How to use JMS API with Service Bus and AMQP 1.0.

Utiliser Spring Messaging avec Azure Service Bus

Le module Spring Messaging Azure Service Bus prend en charge Spring Messaging framework avec Service Bus.

Si vous utilisez Spring Messaging Azure Service Bus, vous pouvez utiliser les fonctionnalités suivantes :

ServiceBusTemplate : envoyez des messages aux files et aux sujets de Service Bus de manière asynchrone et synchrone.
@ServiceBusListener : indiquez une méthode comme cible d'un écouteur de messages Service Bus sur la destination.

Ce guide vous montre comment utiliser spring Messaging Azure Service Bus pour envoyer et recevoir des messages de Service Bus.

Ajouter la dépendance Service Bus

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

Le Bill of Materials (BOM) de Spring Cloud Azure :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.1.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.1.0.

Si vous utilisez Spring Boot 3.5.x, assurez-vous de définir la version spring-cloud-azure-dependencies à 6.1.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 modules de démarrage Spring Messaging Service Bus et Spring Cloud Azure :

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

Codez l'application pour envoyer et recevoir des messages

Configurez l’espace de noms et le type de file d’attente pour votre Service Bus, comme illustré dans l’exemple suivant :
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
spring.cloud.azure.servicebus.entity-type=queue
```
Remarque

Si vous utilisez une rubrique/un abonnement, remplacez la valeur spring.cloud.azure.servicebus.entity-type par topic.
Créez une classe ConsumerService Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour définir un récepteur de message.
```
@Service
public class ConsumerService {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    @ServiceBusListener(destination = QUEUE_NAME)
    public void handleMessageFromServiceBus(String message) {
        System.out.printf("Consume message: %s%n", message);
    }

}
```
Remarque

Si vous utilisez une rubrique/un abonnement, modifiez le paramètre d'annotation destination en tant que nom de la rubrique, et ajoutez le paramètre group pour décrire le nom de l'abonnement.

Connectez un émetteur et un récepteur pour envoyer et recevoir des messages avec Spring, comme le montre l'exemple suivant :

@SpringBootApplication
@EnableAzureMessaging
public class Application {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(Application.class);
        ServiceBusTemplate serviceBusTemplate = applicationContext.getBean(ServiceBusTemplate.class);
        System.out.println("Sending a message to the queue.");
        serviceBusTemplate.sendAsync(QUEUE_NAME, MessageBuilder.withPayload("Hello world").build()).subscribe();
    }
}

Conseil

Veillez à ajouter l'annotation @EnableAzureMessaging, qui déclenche la découverte des méthodes annotées avec @ServiceBusListener, créant ainsi le conteneur d'écoute de messages en arrière-plan.

Lancez l’application. Des journaux d’activité similaires à l’exemple suivant s’affichent :
```
Sending a message to the queue.
Consume message: Hello world.
```

Utiliser spring Integration Azure Service Bus

Le module Spring Integration Azure Service Bus prend en charge l’infrastructure Spring Integration avec Service Bus.

Si votre application Spring utilise des canaux de messages Spring Integration, vous pouvez router les messages entre vos canaux de messages et le Service Bus à l’aide d’adaptateurs de canal.

Un adaptateur de canal entrant transmet les messages d’une file d’attente ou d’un abonnement Service Bus à un canal de message. Un adaptateur de canal sortant publie des messages d’un canal de message dans une file d’attente et une rubrique Service Bus.

Ce guide vous montre comment utiliser spring Integration Azure Service Bus pour envoyer et recevoir des messages de Service Bus.

Ajouter la dépendance Service Bus

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

Le Bill of Materials (BOM) de Spring Cloud Azure :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.1.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.1.0.

Si vous utilisez Spring Boot 3.5.x, assurez-vous de définir la version spring-cloud-azure-dependencies à 6.1.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 d’intégration Azure Service Bus Spring Cloud :

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

Codez l'application pour envoyer et recevoir des messages

Configurez l’espace de noms de votre Service Bus, comme illustré dans l’exemple suivant :
```
spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
```

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.

@Configuration
public class QueueReceiveConfiguration {

    private static final String INPUT_CHANNEL = "queue.input";
    private static final String QUEUE_NAME = "<your-servicebus-queue-name>";
    private static final String SERVICE_BUS_MESSAGE_LISTENER_CONTAINER = "queue-listener-container";

    /**
     * This message receiver binding with {@link ServiceBusInboundChannelAdapter}
     * via {@link MessageChannel} has name {@value INPUT_CHANNEL}
     */
    @ServiceActivator(inputChannel = INPUT_CHANNEL)
    public void messageReceiver(byte[] payload) {
        String message = new String(payload);
        System.out.printf("New message received: '%s'%n", message);
    }

    @Bean(SERVICE_BUS_MESSAGE_LISTENER_CONTAINER)
    public ServiceBusMessageListenerContainer messageListenerContainer(ServiceBusProcessorFactory processorFactory) {
        ServiceBusContainerProperties containerProperties = new ServiceBusContainerProperties();
        containerProperties.setEntityName(QUEUE_NAME);
        return new ServiceBusMessageListenerContainer(processorFactory, containerProperties);
    }

    @Bean
    public ServiceBusInboundChannelAdapter queueMessageChannelAdapter(
        @Qualifier(INPUT_CHANNEL) MessageChannel inputChannel,
        @Qualifier(SERVICE_BUS_MESSAGE_LISTENER_CONTAINER) ServiceBusMessageListenerContainer listenerContainer) {
        ServiceBusInboundChannelAdapter adapter = new ServiceBusInboundChannelAdapter(listenerContainer);
        adapter.setOutputChannel(inputChannel);
        return adapter;
    }

    @Bean(name = INPUT_CHANNEL)
    public MessageChannel input() {
        return new DirectChannel();
    }
}

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.

@Configuration
public class QueueSendConfiguration {

    private static final String OUTPUT_CHANNEL = "queue.output";
    private static final String QUEUE_NAME = "<your-servicebus-queue-name>";

    @Bean
    @ServiceActivator(inputChannel = OUTPUT_CHANNEL)
    public MessageHandler queueMessageSender(ServiceBusTemplate serviceBusTemplate) {
        serviceBusTemplate.setDefaultEntityType(ServiceBusEntityType.QUEUE);
        DefaultMessageHandler handler = new DefaultMessageHandler(QUEUE_NAME, serviceBusTemplate);
        handler.setSendCallback(new ListenableFutureCallback<Void>() {
            @Override
            public void onSuccess(Void result) {
                System.out.println("Message was sent successfully.");
            }

            @Override
            public void onFailure(Throwable ex) {
                System.out.println("There was an error sending the message.");
            }
        });

        return handler;
    }

    /**
     * Message gateway binding with {@link MessageHandler}
     * via {@link MessageChannel} has name {@value OUTPUT_CHANNEL}
     */
    @MessagingGateway(defaultRequestChannel = OUTPUT_CHANNEL)
    public interface QueueOutboundGateway {
        void send(String text);
    }
}

Connectez un émetteur et un récepteur pour envoyer et recevoir des messages avec Spring, comme le montre l'exemple suivant :

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

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(ServiceBusIntegrationApplication.class, args);
        QueueSendConfiguration.QueueOutboundGateway outboundGateway = applicationContext.getBean(QueueSendConfiguration.QueueOutboundGateway.class);
        System.out.println("Sending a message to the queue");
        outboundGateway.send("Hello World");
    }

}

Conseil

Veillez à ajouter l'annotation @EnableIntegration, qui active l'infrastructure d'intégration Spring.

Lancez l’application. Des journaux d’activité similaires à l’exemple suivant s’affichent :
```
Message was sent successfully.
New message received: 'Hello World'
```

Utiliser Spring Cloud Stream Service Bus Binder

Pour appeler l’API Service Bus dans une application Spring Cloud Stream, utilisez le module Spring Cloud Azure Service Bus Stream Binder.

Ce guide vous montre comment utiliser Spring Cloud Stream Service Bus Binder pour envoyer et recevoir des messages de Service Bus.

Ajouter la dépendance Service Bus

Pour installer le module Spring Cloud Azure Service Bus Stream Binder, ajoutez les dépendances suivantes à votre fichier pom.xml :

Le Bill of Materials (BOM) de Spring Cloud Azure :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.1.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.1.0.

Si vous utilisez Spring Boot 3.5.x, assurez-vous de définir la version spring-cloud-azure-dependencies à 6.1.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 d’intégration Azure Service Bus Spring Cloud :

<dependency>
  <groupId>com.azure.spring</groupId>
  <artifactId>spring-cloud-azure-stream-binder-servicebus</artifactId>
</dependency>

Codez l'application pour envoyer et recevoir des messages

Configurez l’espace de noms de votre Service Bus, comme illustré dans l’exemple suivant :
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
```
Créez le récepteur de messages.

Pour utiliser votre application en tant que récepteur d'événements, configurez le binder d'entrée en spécifiant les informations suivantes :
- Déclarez un bean Consumer qui définit la logique de traitement des messages. Par exemple, le bean Consumer suivant est nommé consume :
```
@Bean
public Consumer<Message<String>> consume() {
    return message -> {
        System.out.printf("New message received: '%s'.%n", message.getPayload());
    };
}
```
- Ajoutez la configuration pour spécifier le nom queue pour la consommation en remplaçant l'espace réservé <service-bus-queue-name>, comme indiqué dans l'exemple suivant :
```
# name for the `Consumer` bean
spring.cloud.function.definition=consume
spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-queue-name>
```
  Remarque
  
  Pour accéder à un abonnement Service Bus, veillez à modifier les propriétés de liaison consume-in-0, comme indiqué dans l’exemple suivant :
```
spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-topic-name>
spring.cloud.stream.bindings.consume-in-0.group=<service-bus-subscription-name>
```
Créez l'expéditeur de messages.

Pour utiliser votre application en tant que source d'événements, configurez le liant de sortie en spécifiant les informations suivantes :
- Définissez un bean Supplier qui définit la provenance des messages au sein de votre application.
```
@Bean
return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}
```
- Ajoutez la configuration pour spécifier le nom queue pour l'envoi en remplaçant l'espace réservé <your-servicebus-queue-name> dans l'exemple suivant :
```
# "consume" is added from the previous step
spring.cloud.function.definition=consume;supply
spring.cloud.stream.bindings.supply-out-0.destination=<your-servicebus-queue-name>
spring.cloud.stream.servicebus.bindings.supply-out-0.producer.entity-type=queue
```
  Remarque
  
  Pour envoyer à une rubrique Service Bus, veillez à modifier le entity-type sur topic.
Lancez l’application. Des journaux d’activité similaires à l’exemple suivant s’affichent :
```
Sending a message.
New message received: '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 Spring Spring Cloud Azure Service Bus 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 ?

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-03-11

Partager via

Utiliser Azure Service Bus dans les applications Spring

Prérequis

Préparer votre environnement local

Utiliser Spring Cloud Azure Service Bus Starter

Ajouter la dépendance Service Bus

Codez l'application pour envoyer et recevoir des messages

Utiliser l'autoconfiguration de Spring Boot

Générer des clients Service Bus par programmation

Utiliser Spring Cloud Azure Service Bus JMS Starter

Ajouter la dépendance Service Bus

Codez l'application pour envoyer et recevoir des messages

Autres informations

Utiliser Spring Messaging avec Azure Service Bus

Ajouter la dépendance Service Bus

Codez l'application pour envoyer et recevoir des messages

Utiliser spring Integration Azure Service Bus

Ajouter la dépendance Service Bus

Codez l'application pour envoyer et recevoir des messages

Utiliser Spring Cloud Stream Service Bus Binder

Ajouter la dépendance Service Bus

Codez l'application pour envoyer et recevoir des messages

Déployer sur Azure Spring Apps

Étapes suivantes

Voir aussi

Commentaires

Ressources supplémentaires