Utiliser Azure Service Bus dans les applications Spring
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.16.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
version4.19.0
sur . 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 laentity-type
valeur entopic
.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 deServiceBusProcessorClient
.@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é, configurezspring.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 etServiceBusProcessorClient
lesServiceBusSenderClient
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 Se connecter à 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.16.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
version4.19.0
sur . 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éthodesend
dansJmsTemplate
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 surMessageConverter
, 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 lecontainerFactory
doit êtretopicJmsListenerContainerFactory
. Ajoutez également lesubscription
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.16.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
version4.19.0
sur . 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
valeurtopic
par .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 legroup
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.16.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
version4.19.0
sur . 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.16.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
version4.19.0
sur . 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 suivantConsumer
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
valeurtopic
.
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
Voir aussi
Pour plus d’informations sur les démarrages Spring Boot disponibles pour Microsoft Azure, consultez Qu’est-ce que Spring Cloud Azure ?