Utiliser Azure Service Bus dans les applications Spring

Article
10/07/2024

Cet article vous montre comment utiliser Azure Service Bus dans les applications Java construites avec le cadre Spring.

Azure fournit une plateforme de messagerie asynchrone appelée Azure Service Bus (Service Bus), qui est basée sur le standard Advanced Message Queueing Protocol 1.0 (AMQP 1.0). Vous pouvez utiliser Service Bus sur l'ensemble des plateformes Azure prises en charge.

Spring Cloud Azure fournit divers modules permettant d'envoyer des messages vers les files d'attente et les rubriques/abonnements du Service Bus et d'en recevoir à 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 à l'aide de la bibliothèque client Service Bus Java SDK avec les fonctionnalités de Spring Boot.
Spring Cloud Azure Service Bus JMS Starter vous permet d'utiliser l'API JMS pour envoyer et recevoir des messages avec les files d'attente et les rubriques/abonnements de Service Bus.
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 les chaînes de messages Spring Integration avec Service Bus.
Spring Cloud Stream Binder for Service Bus vous permet d'utiliser Service Bus en tant qu'intergiciel de messagerie dans les applications Spring Cloud Stream.

Prérequis

Un abonnement Azure - En créer un gratuitement
Java Development Kit (JDK) version 8 ou supérieure.
Apache Maven, version 3.0 ou supérieure.
Un Azure Service Bus et une file d'attente ou une rubrique/un abonnement. Si vous n'en avez pas, créez une file d'attente ou une rubrique Service Bus. Pour plus d'informations, voir Utiliser le portail Azure pour créer un espace de noms Service Bus et une file d'attente ou Utiliser le portail Azure pour créer un sujet Service Bus et des abonnements au sujet.
Si vous n'avez pas d'application Spring Boot, créez un projet Maven avec Spring Initializr. Veillez à sélectionner Projet Maven et, sous Dépendances, 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éé, attribuez les rôles Azure Service Bus Data Sender et Azure Service Bus Data Receiver au compte Microsoft Entra que vous utilisez actuellement. Pour plus d’informations, consultez Attribuer des rôles Azure en utilisant le portail Azure.

Important

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. Cependant, la connexion à un service Azure nécessite une authentification. Pour compléter l'authentification, vous devez utiliser la bibliothèque client Azure Identity. Spring Cloud Azure utilise DefaultAzureCredential, que la bibliothèque Azure Identity fournit pour vous aider à obtenir des informations d'identification sans modifier le 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 page Authentifier les applications Java hébergées par Azure.

Pour utiliser Azure CLI, IntelliJ ou d'autres méthodes pour compléter l'authentification dans les environnements de développement locaux, consultez la section Authentification Azure dans les environnements de développement Java. Pour compléter l'authentification dans les environnements d'hébergement Azure, nous vous recommandons d'utiliser l'identité gérée. Pour plus d’informations, consultez Que sont les identités managées pour les ressources Azure ?

Remarque

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

Utilisez Spring Cloud Azure Service Bus Starter

Le module Spring Cloud Azure Service Bus Starter importe la bibliothèque client Java de Service Bus avec le framework Spring Boot. Vous pouvez utiliser Spring Cloud Azure et le SDK Azure ensemble, dans un schéma non mutuellement exclusif. Ainsi, vous pouvez continuer à utiliser l'API du client Java de Service Bus 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 :

La nomenclature Spring Cloud Azure :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.19.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.19.0. Cette nomenclature doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela permet de s'assurer que toutes les dépendances de Spring Cloud Azure utilisent la même version. Pour plus d'informations sur la version utilisée pour cette nomenclature, consultez Quelle version de Spring Cloud Azure dois-je utiliser.

L'artefact Spring Cloud Azure Service Bus :

<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 vous apprend à utiliser les clients Java Service Bus dans le contexte d'une application Spring. Nous présentons ici deux alternatives. La méthode recommandée est d'utiliser l'autoconfiguration Spring Boot et d'utiliser les clients prêts à l'emploi 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 donnent une expérience plus flexible et plus efficace lorsque vous développez avec des clients Service Bus.

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 for Service Bus fournit plusieurs clients pour interagir avec Service Bus. Le starter fournit également une autoconfiguration pour tous les clients Service Bus et les constructeurs de clients. Nous n'utilisons ici que ServiceBusSenderClient et ServiceBusProcessorClient comme exemples.

Utiliser l'autoconfiguration de Spring Boot

Pour envoyer des messages à Service Bus et en recevoir, configurez l'application en suivant les étapes suivantes :

Configurez votre espace de noms et votre file d'attente Service Bus, comme le montre 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 la file d'attente du 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 nouvelle classe Java ServiceBusProcessorClientConfiguration comme indiqué 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 similaires à l'exemple suivant s'affichent :

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

Construire des clients Service Bus de manière programmatique

Vous pouvez construire ces beans clients par 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 construction et enregistrer le client dans votre contexte d'application Spring. L'exemple de code suivant montre comment procéder :

Créez une nouvelle classe Java ServiceBusClientConfiguration comme indiqué 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 le nom d'hôte de votre Service Bus à partir du portail Azure. Remplacez l'espace réservé <service-bus-queue-name> par votre propre nom de file d'attente configuré dans l'espace de noms de votre bus de services.

Injectez les beans clients dans votre application, comme le montre 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 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 de l'environnement Spring, vous ne pouvez pas avoir de conseils 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, avec Spring Cloud Azure, il n'est pas nécessaire de créer soi-même les beans clients. Au lieu de cela, vous pouvez injecter directement les beans et utiliser les propriétés de 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 de services Azure de la configuration de Spring Cloud Azure.

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 la section Se connecter à différents clouds Azure.

Utilisez le module Spring Cloud Azure Service Bus JMS Starter

Le module Spring Cloud Azure Service Bus JMS Starter permet d'intégrer Spring JMS à Service Bus. La vidéo suivante décrit 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 afin d'envoyer des messages à Service Bus et d'en recevoir.

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 :

La nomenclature Spring Cloud Azure :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.19.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.19.0. Cette nomenclature doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela permet de s'assurer que toutes les dépendances de Spring Cloud Azure utilisent la même version. Pour plus d'informations sur la version utilisée pour cette nomenclature, consultez Quelle version de Spring Cloud Azure dois-je utiliser.

L'artefact Spring Cloud Azure Service Bus JMS :

<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 de service pour 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 permet de publier des messages vers n'importe quel POJO (Plain Old Java Object). 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, voir le projet de programme de démarrage JMS Spring officiel.
À partir de là, vous pouvez créer une nouvelle classe Java QueueReceiveService, comme le montre 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 l'espace de noms de votre bus de services.

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 l'espace de noms de votre bus de services.

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 sous les couvertures.

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

Autres informations

Pour plus d'informations, voir Comment utiliser l'API JMS avec Service Bus et AMQP 1.0.

Utilisez Spring Messaging Azure Service Bus

Le module Spring Messaging Azure Service Bus fournit un support pour le framework Spring Messaging avec Service Bus.

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

ServiceBusTemplate : envoie des messages aux files d'attente et aux rubriques de Service Bus de manière asynchrone et synchrone.
@ServiceBusListener : marque une méthode pour qu'elle soit la cible d'un auditeur de messages du bus de service sur la destination.

Ce guide vous montre comment utiliser Spring Messaging Azure Service Bus pour envoyer des messages à Service Bus 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 :

La nomenclature Spring Cloud Azure :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.19.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.19.0. Cette nomenclature doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela permet de s'assurer que toutes les dépendances de Spring Cloud Azure utilisent la même version. Pour plus d'informations sur la version utilisée pour cette nomenclature, consultez Quelle version de Spring Cloud Azure dois-je utiliser.

Les artefacts Spring Messaging Service Bus et Spring Cloud Azure starter :

<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 indiqué 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 nouvelle classe Java ConsumerService comme indiqué 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 sous les couvertures.

Lancez l’application. Des journaux 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 fournit un support pour le framework Spring Integration avec Service Bus.

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

Un adaptateur de canal entrant redirige les messages d'une file d'attente ou d'un abonnement Service Bus vers une chaîne de messages. Un adaptateur de canal sortant publie les messages d'une chaîne de messages vers une file d'attente et une rubrique de Service Bus.

Ce guide vous montre comment utiliser Spring Integration Azure Service Bus pour envoyer des messages à Service Bus et en recevoir.

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 :

La nomenclature Spring Cloud Azure :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.19.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.19.0. Cette nomenclature doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela permet de s'assurer que toutes les dépendances de Spring Cloud Azure utilisent la même version. Pour plus d'informations sur la version utilisée pour cette nomenclature, consultez Quelle version de Spring Cloud Azure dois-je utiliser.

L'artefact Spring Cloud Azure Service Bus Integration :

<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 indiqué dans l'exemple suivant :
```
spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
```

Créez une nouvelle classe Java QueueReceiveConfiguration comme indiqué 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 nouvelle classe Java QueueSendConfiguration comme indiqué 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 similaires à l'exemple suivant s'affichent :
```
Message was sent successfully.
New message received: 'Hello World'
```

Utilisez le liant du bus de service Spring Cloud Stream.

Pour appeler l'API du bus de services dans une application Spring Cloud Stream, utilisez le module Spring Cloud Azure Service Bus Stream Binder.

Ce guide vous montre comment utiliser le module Spring Cloud Stream Service Bus Binder pour envoyer des messages à Service Bus et en recevoir de celui-ci.

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 :

La nomenclature Spring Cloud Azure :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.19.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.19.0. Cette nomenclature doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela permet de s'assurer que toutes les dépendances de Spring Cloud Azure utilisent la même version. Pour plus d'informations sur la version utilisée pour cette nomenclature, consultez Quelle version de Spring Cloud Azure dois-je utiliser.

L'artefact Spring Cloud Azure Service Bus Integration :

<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 indiqué 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 consommer à partir d'un abonnement Service Bus, veillez à modifier les propriétés de l'obligation 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 du bus de service, veillez à remplacer entity-type par topic.
Lancez l’application. Vous verrez des journaux similaires à l'exemple suivant :
```
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 des 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 assure la gestion du cycle de vie en utilisant des outils complets, tels que la supervision et les diagnostics, la gestion des configurations, la découverte de services, l’intégration CI/CD, les déploiements bleus-verts, etc. Pour déployer votre application sur Azure Spring Apps, voir Déployer votre première application sur Azure Spring Apps.

Étapes suivantes

Azure pour les développeurs Spring Exemples de Spring Cloud Azure Service Bus

Voir aussi

Pour plus d'informations sur d'autres starters Spring Boot disponibles pour Microsoft Azure, consultez Qu'est-ce que Spring Cloud Azure ?

Partager via

Utiliser Azure Service Bus dans les applications Spring

Prérequis

Préparer votre environnement local

Utilisez 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

Construire des clients Service Bus de manière programmatique

Utilisez le module Spring Cloud Azure Service Bus JMS Starter

Ajouter la dépendance Service Bus

Codez l'application pour envoyer et recevoir des messages

Autres informations

Utilisez Spring Messaging 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

Utilisez le liant du bus de service Spring Cloud Stream.

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