Utiliser Azure Service Bus dans les applications Spring

Article
01/18/2024

Cet article explique comment utiliser Azure Service Bus dans les applications Java 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 dans toute la gamme de plateformes Azure prises en charge.

Spring Cloud Azure fournit différents modules pour l’envoi de messages vers et la réception de messages à partir de files d’attente et d’abonnements aux rubriques/ Service Bus à l’aide de frameworks Spring.

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

Spring Cloud Azure Service Bus Starter vous permet d’envoyer et de recevoir des messages avec la bibliothèque de client du Kit de développement logiciel (SDK) Java Service Bus 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 des files d’attente et des rubriques/abonnements 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 canaux de messages Spring Integration à 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 - En créer un gratuitement
Kit de développement Java (JDK) version 8 ou ultérieure.
Apache Maven, version 3.0 ou ultérieure.
Un service 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 Portail Azure pour créer un espace de noms Service Bus et une file d’attente ou utiliser le Portail Azure pour créer une rubrique et des abonnements Service Bus à la rubrique.
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éé, affectez les rôles Expéditeur de données Azure Service Bus et Récepteur de données Azure Service Bus au compte Microsoft Entra que vous utilisez actuellement. Pour plus d’informations, consultez Attribuer des rôles Azure en utilisant le portail Azure.

Important

Spring Boot version 2.5 ou ultérieure est nécessaire pour suivre les étapes décrites dans ce didacticiel.

Préparer votre environnement local

Dans ce tutoriel, les configurations et le code n’ont 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 d’identités Azure 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 des applications Java hébergées par 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 les environnements d’hébergement Azure, nous vous recommandons d’utiliser l’identité managée. Pour plus d’informations, consultez Que sont les identités managées pour les ressources Azure ?

Remarque

Actuellement, l’API Azure Service Bus pour JMS ne prend 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 la bibliothèque de client Java Service Bus avec l’infrastructure 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 Java 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 :

The Spring Cloud Azure Bill of Materials (BOM) :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.11.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 2.x, veillez à définir la spring-cloud-azure-dependencies version 4.17.0sur . Cette facture de matériel (BOM) doit être configurée dans la <dependencyManagement> section de votre fichier pom.xml . Cela garantit que toutes les dépendances Azure Spring Cloud utilisent la même version. Pour plus d’informations sur la version utilisée pour ce boM, consultez La version de Spring Cloud Azure à utiliser.

Artefact Spring Cloud Azure Service Bus :

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

Coder l’application pour envoyer et recevoir des messages

Ce guide explique comment utiliser les clients Java Service Bus dans le contexte d’une application Spring. Ici, nous présentons deux alternatives. La méthode recommandée consiste à utiliser la configuration automatique Spring Boot et à utiliser des clients prêtes à l’emploi à partir du contexte Spring. L’alternative consiste à créer des clients par programme.

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

Vous pouvez utiliser la configuration externalisée afin de pouvoir utiliser le même code d’application dans différents environnements.
Vous pouvez déléguer le processus d’apprentissage du modèle de générateur et inscrire ce client dans le contexte d’application dans l’infrastructure Spring Boot. Cette délégation vous permet de vous concentrer sur l’utilisation des clients avec vos propres besoins métier.
Vous pouvez utiliser l’indicateur d’intégrité de manière simple pour inspecter l’état et l’intégrité de votre application et des composants internes.

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

Remarque

Le Kit de développement logiciel (SDK) Java Azure pour Service Bus fournit plusieurs clients pour interagir avec Service Bus. Le démarrage fournit également une configuration automatique pour tous les clients et les générateurs de clients Service Bus. Ici, nous utilisons uniquement ServiceBusSenderClient et ServiceBusProcessorClient en tant qu’exemples.

Utiliser la configuration automatique 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

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

Créez une ServiceBusProcessorClientConfiguration classe Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour inscrire le message et le gestionnaire d’erreurs 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 code dans votre application Spring et appelez les API associées pour envoyer des messages, comme illustré dans 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 haricot autowired ServiceBusProcessorClient est géré par le contexte Spring. Le processeur est automatiquement démarré lorsque le contexte de l’application Spring démarre et s’arrête lorsque le contexte de l’application Spring s’arrête. Pour désactiver cette fonctionnalité, configurez spring.cloud.azure.servicebus.processor.auto-startup=false.

Lancez l’application. Vous voyez des journaux similaires à l’exemple suivant :

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

Créer des clients Service Bus par programmation

Vous pouvez créer ces haricots 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 générateur et inscrire le client dans votre contexte d’application Spring. L’exemple de code suivant montre comment procéder :

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

@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 <service-bus-fully-qualified-namespace> réservé par le nom d’hôte Service Bus de l’Portail Azure. Remplacez l’espace <service-bus-queue-name> réservé par votre propre nom de file d’attente configuré dans votre espace de noms Service Bus.

Injectez les haricots 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. Vous voyez des journaux similaires à l’exemple suivant :

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 approprié :

Les noms d’espace de noms et de file d’attente/rubrique/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, la création des haricots clients par vous-même n’est pas nécessaire avec Spring Cloud Azure. Au lieu de cela, vous pouvez injecter directement les haricots 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 des kits SDK Azure Service de la configuration Azure Spring Cloud.

Options de proxy.
Options de nouvelle tentative.
Options du client de transport AMQP.

Vous pouvez également vous connecter à différents clouds Azure. Pour plus d’informations, consultez Connecter sur différents clouds Azure.

Utiliser Spring Cloud Azure Service Bus JMS Starter

Le module Spring Cloud Azure Service Bus JMS Starter fournit l’intégration de Spring JMS à 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 à partir 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 :

The Spring Cloud Azure Bill of Materials (BOM) :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.11.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 2.x, veillez à définir la spring-cloud-azure-dependencies version 4.17.0sur . Cette facture de matériel (BOM) doit être configurée dans la <dependencyManagement> section de votre fichier pom.xml . Cela garantit que toutes les dépendances Azure Spring Cloud utilisent la même version. Pour plus d’informations sur la version utilisée pour ce boM, consultez La version de Spring Cloud Azure à utiliser.

Artefact JMS Spring Cloud Azure Service Bus :

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

Coder l’application pour envoyer et recevoir des messages

Configurez le niveau chaîne de connexion et 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 sur 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 illustré dans 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 haricot personnalisé MessageConverter pour sérialiser le contenu au format 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 QueueReceiveService classe Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour définir un récepteur de messages.
```
@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 <service-bus-queue-name> réservé par votre propre nom de file d’attente configuré dans votre espace de noms Service Bus.

Si vous utilisez une rubrique/abonnement, modifiez le destination paramètre comme nom de rubrique et le containerFactory doit être topicJmsListenerContainerFactory. Ajoutez également le subscription paramètre pour décrire le nom de l’abonnement.

Connecter un expéditeur et un récepteur pour envoyer et recevoir des messages avec Spring, comme illustré dans 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 <service-bus-queue-name> réservé 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, en créant le conteneur d’écouteurs de message sous les couvertures.

Lancez l’application. Vous voyez des journaux similaires à l’exemple suivant :
```
Sending a user message.
Received a message from Tom.
```

Autres informations

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

Utiliser Spring Messaging Azure Service Bus

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

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

ServiceBusTemplate: envoyez des messages aux files d’attente et rubriques Service Bus de manière asynchrone et synchrone.
@ServiceBusListener: marquez une méthode comme cible d’un écouteur de message Service Bus sur la destination.

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

The Spring Cloud Azure Bill of Materials (BOM) :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.11.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 2.x, veillez à définir la spring-cloud-azure-dependencies version 4.17.0sur . Cette facture de matériel (BOM) doit être configurée dans la <dependencyManagement> section de votre fichier pom.xml . Cela garantit que toutes les dépendances Azure Spring Cloud utilisent la même version. Pour plus d’informations sur la version utilisée pour ce boM, consultez La version de Spring Cloud Azure à utiliser.

Artefacts 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>

Coder 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/abonnement, remplacez la spring.cloud.azure.servicebus.entity-type valeur topicpar .
Créez une ConsumerService classe Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour définir un récepteur de messages.
```
@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/abonnement, modifiez le paramètre d’annotation comme nom de destination rubrique et ajoutez le subscription paramètre pour décrire le nom de l’abonnement.

Connecter un expéditeur et un récepteur pour envoyer et recevoir des messages avec Spring, comme illustré dans 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, en créant le conteneur d’écouteurs de message sous les couvertures.

Lancez l’application. Vous voyez des journaux similaires à l’exemple suivant :
```
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 Service Bus à l’aide de cartes de canal.

Une carte de canal entrant transfère les messages d’une file d’attente ou d’un abonnement Service Bus vers 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 :

The Spring Cloud Azure Bill of Materials (BOM) :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.11.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 2.x, veillez à définir la spring-cloud-azure-dependencies version 4.17.0sur . Cette facture de matériel (BOM) doit être configurée dans la <dependencyManagement> section de votre fichier pom.xml . Cela garantit que toutes les dépendances Azure Spring Cloud utilisent la même version. Pour plus d’informations sur la version utilisée pour ce boM, consultez La version de Spring Cloud Azure à utiliser.

Artefact d’intégration Spring Cloud Azure Service Bus :

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

Coder 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 QueueReceiveConfiguration classe Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour définir un récepteur de messages.

@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 QueueSendConfiguration classe Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour définir un expéditeur de message.

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

Connecter un expéditeur et un récepteur pour envoyer et recevoir des messages avec Spring, comme illustré dans 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 Spring Integration.

Lancez l’application. Vous voyez des journaux similaires à l’exemple suivant :
```
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 :

The Spring Cloud Azure Bill of Materials (BOM) :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.11.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 2.x, veillez à définir la spring-cloud-azure-dependencies version 4.17.0sur . Cette facture de matériel (BOM) doit être configurée dans la <dependencyManagement> section de votre fichier pom.xml . Cela garantit que toutes les dépendances Azure Spring Cloud utilisent la même version. Pour plus d’informations sur la version utilisée pour ce boM, consultez La version de Spring Cloud Azure à utiliser.

Artefact d’intégration Spring Cloud Azure Service Bus :

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

Coder 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 comme récepteur d’événements, configurez le classeur d’entrée en spécifiant les informations suivantes :
- Déclarez un haricot qui définit la Consumer logique de gestion des messages. Par exemple, le haricot suivant Consumer 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 queue nom de consommation en remplaçant l’espace <service-bus-queue-name> réservé, comme illustré 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 utiliser à partir d’un abonnement Service Bus, veillez à modifier les consume-in-0 propriétés de liaison 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 du message.

Pour utiliser votre application comme source d’événement, configurez le classeur de sortie en spécifiant les informations suivantes :
- Définissez un Supplier haricot qui définit l’endroit où les messages proviennent de votre application.
```
@Bean
return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}
```
- Ajoutez la configuration pour spécifier le queue nom d’envoi en remplaçant l’espace <your-servicebus-queue-name> réservé 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 la entity-type valeur topic.
Lancez l’application. Vous voyez des journaux similaires à l’exemple suivant :
```
Sending a message.
New message received: 'Hello world'.
```

Déployer sur Azure Spring Apps

Maintenant que vous disposez de l’application Spring Boot en cours d’exécution localement, il est temps de le déplacer en production. Azure Spring Apps facilite le déploiement d’applications Spring Boot sur Azure sans aucune modification de 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, consultez Déployer votre première application sur Azure Spring Apps.

Étapes suivantes

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

Voir aussi

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

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

Coder l’application pour envoyer et recevoir des messages

Utiliser la configuration automatique Spring Boot

Créer des clients Service Bus par programmation

Utiliser Spring Cloud Azure Service Bus JMS Starter

Ajouter la dépendance Service Bus

Coder l’application pour envoyer et recevoir des messages

Autres informations

Utiliser Spring Messaging Azure Service Bus

Ajouter la dépendance Service Bus

Coder l’application pour envoyer et recevoir des messages

Utiliser Spring Integration Azure Service Bus

Ajouter la dépendance Service Bus

Coder l’application pour envoyer et recevoir des messages

Utiliser Spring Cloud Stream Service Bus Binder

Ajouter la dépendance Service Bus

Coder l’application pour envoyer et recevoir des messages

Déployer sur Azure Spring Apps

Étapes suivantes

Voir aussi

Commentaires

Commentaires

Ressources supplémentaires