Verwenden von Azure Service Bus in Spring-Anwendungen
In diesem Artikel erfahren Sie, wie Sie Azure Service Bus in Java-Anwendungen verwenden, die mit Spring Framework erstellt wurden.
Azure stellt eine asynchrone Messagingplattform namens Azure Service Bus (Service Bus ) bereit, die auf dem Standard Advanced Message Queueing Protocol 1.0 (AMQP 1.0) basiert. Sie können Service Bus über die verschiedenen unterstützten Azure-Plattformen hinweg verwenden.
Spring Cloud Azure bietet verschiedene Module zum Senden von Nachrichten an und Empfangen von Nachrichten aus Service Bus-Warteschlangen und Themenabonnements/ mithilfe von Spring-Frameworks.
Sie können die folgenden Module unabhängig voneinander verwenden oder für unterschiedliche Anwendungsfälle kombinieren:
Spring Cloud Azure Service Bus Starter ermöglicht Ihnen das Senden und Empfangen von Nachrichten mit der Service Bus Java SDK-Clientbibliothek mit Spring Boot-Features.
Spring Cloud Azure Service Bus JMS Starter ermöglicht Ihnen die Verwendung der JMS-API zum Senden und Empfangen von Nachrichten mit Service Bus-Warteschlangen und Themen/Abonnements.
Spring Messaging Azure Service Bus ermöglicht Ihnen die Interaktion mit Service Bus über die Spring Messaging-API .
Mit Spring Integration Azure Service Bus können Sie Spring Integration Message Channels mit Service Bus verbinden.
Spring Cloud Stream Binder for Service Bus ermöglicht Ihnen die Verwendung von Service Bus als Messaging-Middleware in Spring Cloud Stream-Anwendungen.
Voraussetzungen
- Azure-Abonnement (kostenloses Abonnement erstellen)
- Java Development Kit (JDK) Version 8 oder höher.
- Apache Maven, Version 3.0 oder höher.
- Ein Azure Service Bus und ein Thema/Abonnement. Wenn Sie keins haben, erstellen Sie eine ServiceBus-Warteschlange oder ein Thema. Weitere Informationen finden Sie unter "Verwenden von Azure-Portal" zum Erstellen eines ServiceBus-Namespace und einer Warteschlange oder zum Erstellen eines ServiceBus-Themas und -Abonnements für das Thema mithilfe der Azure-Portal.
- Wenn Sie nicht über eine Spring Boot-Anwendung verfügen, erstellen Sie ein Maven-Projekt mit dem Spring Initializr. Achten Sie darauf, Maven Project (Maven-Projekt) auszuwählen, fügen Sie unter Dependencies (Abhängigkeiten) die Abhängigkeit Spring Web hinzu, und wählen Sie dann Java-Version 8 oder höher aus.
Hinweis
Um Ihrem Konto Zugriff auf Ihre Service Bus-Ressourcen zu gewähren, weisen Sie im neu erstellten Azure Service Bus-Namespace die Rollen Azure Service Bus Data Sender und Azure Service Bus Data Receiver dem Microsoft Entra-Konto zu, das Sie derzeit verwenden. Weitere Informationen finden Sie unter Hinzufügen oder Entfernen von Azure-Rollenzuweisungen über das Azure-Portal.
Wichtig
Spring Boot Version 2.5 oder höher ist erforderlich, um die Schritte in diesem Lernprogramm auszuführen.
Vorbereiten der lokalen Umgebung
In diesem Lernprogramm verfügen die Konfigurationen und der Code nicht über Authentifizierungsvorgänge. Für die Verbindung mit einem Azure-Dienst ist jedoch eine Authentifizierung erforderlich. Um die Authentifizierung abzuschließen, müssen Sie die Azure Identity-Clientbibliothek verwenden. Spring Cloud Azure verwendet DefaultAzureCredential
, die von der Azure Identity-Bibliothek bereitgestellt wird, um Anmeldeinformationen ohne Codeänderungen zu erhalten.
„DefaultAzureCredential
“ unterstützt mehrere Authentifizierungsmethoden und bestimmt, welche Methode zur Laufzeit verwendet wird. Mit diesem Ansatz kann Ihre App unterschiedliche Authentifizierungsmethoden in verschiedenen Umgebungen ( z. B. lokale oder Produktionsumgebungen ) verwenden, ohne umgebungsspezifischen Code zu implementieren. Weitere Informationen finden Sie im Abschnitt "DefaultAzureCredential " der von Azure gehosteten Java-Anwendungen.
Informationen zur Verwendung von Azure CLI, IntelliJ oder anderen Methoden zum Abschließen der Authentifizierung in lokalen Entwicklungsumgebungen finden Sie unter Azure-Authentifizierung in Java-Entwicklungsumgebungen. Um die Authentifizierung in Azure-Hostingumgebungen abzuschließen, empfehlen wir die Verwendung der verwalteten Identität. Weitere Informationen finden Sie unter Was sind verwaltete Identitäten für Azure-Ressourcen?.
Hinweis
Azure Service Bus für JMS-API unterstützt DefaultAzureCredential
derzeit nicht. Wenn Sie Spring JMS mit Service Bus verwenden, ignorieren Sie diesen Schritt.
Verwenden des Spring Cloud Azure Service Bus Starter
Das Spring Cloud Azure Service Bus Starter-Modul importiert die Dienstbus-Java-Clientbibliothek mit Spring Boot Framework. Sie können Spring Cloud Azure und das Azure SDK gemeinsam in einem nicht gegenseitig ausschließenden Muster verwenden. Daher können Sie die Dienstbus-Java-Client-API weiterhin in Ihrer Spring-Anwendung verwenden.
Hinzufügen der Dienstbusabhängigkeit
Um das Spring Cloud Azure Service Bus Starter-Modul zu installieren, fügen Sie Ihrer pom.xml Datei die folgenden Abhängigkeiten hinzu:
Die Spring Cloud Azure Bill of Materials (BOM):
<dependencyManagement> <dependencies> <dependency> <groupId>com.azure.spring</groupId> <artifactId>spring-cloud-azure-dependencies</artifactId> <version>5.13.0</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>
Hinweis
Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die
spring-cloud-azure-dependencies
Version auf4.19.0
. Diese Stückliste (Bill of Material, BOM) sollte im<dependencyManagement>
Abschnitt Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud Azure-Abhängigkeiten dieselbe Version verwenden. Weitere Informationen zu der version, die für diese BOM verwendet wird, finden Sie unter Welche Version von Spring Cloud Azure sollte ich verwenden.Das Spring Cloud Azure Service Bus-Artefakt:
<dependency> <groupId>com.azure.spring</groupId> <artifactId>spring-cloud-azure-starter-servicebus</artifactId> </dependency>
Codieren der Anwendung zum Senden und Empfangen von Nachrichten
In diesem Leitfaden erfahren Sie, wie Sie die Service Bus Java-Clients im Kontext einer Spring-Anwendung verwenden. Hier stellen wir zwei Alternativen vor. Die empfohlene Methode besteht darin, die Autokonfiguration von Spring Boot zu verwenden und sofort einsatzbereite Clients aus dem Spring-Kontext zu verwenden. Die alternative Möglichkeit besteht darin, Clients programmgesteuert zu erstellen.
Die erste Möglichkeit, bei der die automatische Verkabelung der Kundenbohnen aus dem Spring IoC-Container beinhaltet, hat die folgenden Vorteile im Vergleich zum zweiten Weg. Diese Vorteile bieten Ihnen eine flexiblere und effizientere Erfahrung bei der Entwicklung mit Service Bus-Clients.
Sie können die externe Konfiguration verwenden, damit Sie mit demselben Anwendungscode in verschiedenen Umgebungen arbeiten können.
Sie können den Prozess des Lernens des Generatormusters delegieren und diesen Client für den Anwendungskontext im Spring Boot Framework registrieren. Mit dieser Delegierung können Sie sich auf die Verwendung der Kunden mit Ihren eigenen Geschäftlichen Anforderungen konzentrieren.
Sie können die Integritätsanzeige auf einfache Weise verwenden, um den Status und die Integrität Ihrer Anwendung und interner Komponenten zu überprüfen.
Im folgenden Codebeispiel wird gezeigt, wie Sie diese beiden Alternativen verwendenServiceBusSenderClient
.ServiceBusProcessorClient
Hinweis
Das Azure Java SDK für Service Bus bietet mehrere Clients für die Interaktion mit Service Bus. Der Starter bietet auch die automatische Konfiguration für alle Service Bus-Clients und Client-Generatoren. Hier verwenden wir nur ServiceBusSenderClient
und ServiceBusProcessorClient
als Beispiele.
Automatische Konfiguration des Federstarts verwenden
Um Nachrichten an Service Bus zu senden und zu empfangen, konfigurieren Sie die Anwendung mithilfe der folgenden Schritte:
Konfigurieren Sie Ihren Service Bus-Namespace und die Warteschlange, wie im folgenden Beispiel gezeigt:
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
Tipp
Hier verwenden wir die ServiceBus-Warteschlange als Beispiel. Um Themen/Abonnements zu verwenden, müssen Sie die
spring.cloud.azure.servicebus.processor.subscription-name
Eigenschaft hinzufügen und denentity-type
Wert in ändern.topic
Erstellen Sie eine neue
ServiceBusProcessorClientConfiguration
Java-Klasse, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um die Meldung und den Fehlerhandler vonServiceBusProcessorClient
.@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()); }; } }
Fügen Sie die
ServiceBusSenderClient
Spring-Anwendung ein, und rufen Sie die zugehörigen APIs zum Senden von Nachrichten auf, wie im folgenden Beispiel gezeigt:@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); } }
Hinweis
Standardmäßig wird der Lebenszyklus der automatisch verkabelten
ServiceBusProcessorClient
Bohnen vom Spring-Kontext verwaltet. Der Prozessor wird automatisch gestartet, wenn der Spring Application Context gestartet und beendet wird, wenn der Spring Application Context beendet wird. Um dieses Feature zu deaktivieren, konfigurieren Siespring.cloud.azure.servicebus.processor.auto-startup=false
.Starten Sie die Anwendung. Es werden Protokolle angezeigt, die dem folgenden Beispiel ähneln:
Sent a message to the queue Processing message. Id: 6f405435200047069a3caf80893a80bc, Sequence #: 1. Contents: Hello, World!
Programmgesteuertes Erstellen von ServiceBus-Clients
Sie können diese Bohnen selbst erstellen, aber der Prozess ist kompliziert. In Spring Boot-Anwendungen müssen Sie Eigenschaften verwalten, das Generatormuster erlernen und den Client in Ihrem Spring-Anwendungskontext registrieren. Das folgende Codebeispiel zeigt, wie Dies funktioniert:
Erstellen Sie eine neue
ServiceBusClientConfiguration
Java-Klasse, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um dieServiceBusSenderClient
ServiceBusProcessorClient
Bohnen zu deklarieren.@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()); } }
Hinweis
Ersetzen Sie den
<service-bus-fully-qualified-namespace>
Platzhalter unbedingt durch ihren ServiceBus-Hostnamen aus dem Azure-Portal. Ersetzen Sie den<service-bus-queue-name>
Platzhalter durch ihren eigenen Warteschlangennamen, der im Service Bus-Namespace konfiguriert ist.Injizieren Sie die Clientbohnen in Ihre Anwendung, wie im folgenden Beispiel gezeigt:
@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(); } }
Starten Sie die Anwendung. Es werden Protokolle angezeigt, die dem folgenden Beispiel ähneln:
Sent a message to the queue Starting the processor ... Processing message. Id: 6f405435200047069a3caf80893a80bc, Sequence #: 1. Contents: Hello, World! Stopping and closing the processor
In der folgenden Liste sind Gründe aufgeführt, warum dieser Code nicht flexibel oder ordnungsgemäß ist:
- Die Namespace- und Warteschlangen-/Themen-/Abonnementnamen sind hartcodiert.
- Wenn Sie
@Value
Konfigurationen aus der Spring-Umgebung abrufen, können Sie in der Datei "application.properties " keine IDE-Hinweise enthalten. - Wenn Sie über ein Microservice-Szenario verfügen, müssen Sie den Code in jedem Projekt duplizieren, und es ist einfach, Fehler zu machen und schwer konsistent zu sein.
Glücklicherweise ist das Erstellen der Clientbohnen selbst nicht mit Spring Cloud Azure erforderlich. Stattdessen können Sie die Bohnen direkt injizieren und die Konfigurationseigenschaften verwenden, mit denen Sie bereits vertraut sind, um Service Bus zu konfigurieren.
Spring Cloud Azure bietet auch die folgenden globalen Konfigurationen für verschiedene Szenarien. Weitere Informationen finden Sie im Abschnitt "Globale Konfiguration für Azure Service SDKs " der Spring Cloud Azure-Konfiguration.
- Proxyoptionen.
- Wiederholen Sie die Optionen.
- AMQP-Transportclientoptionen.
Sie können auch eine Verbindung mit verschiedenen Azure-Clouds herstellen. Weitere Informationen finden Sie unter Herstellen einer Verbindung mit verschiedenen Azure-Clouds.
Verwenden des Spring Cloud Azure Service Bus JMS Starter
Das Spring Cloud Azure Service Bus JMS Starter-Modul bietet spring JMS Integration in Service Bus. Das folgende Video beschreibt, wie Spring JMS-Anwendungen mit Azure Service Bus mit JMS 2.0 integriert werden.
In diesem Leitfaden wird gezeigt, wie Sie spring Cloud Azure Service Bus Starter für JMS-API verwenden, um Nachrichten an Service Bus zu senden und zu empfangen.
Hinzufügen der Dienstbusabhängigkeit
Um das Spring Cloud Azure Service Bus JMS Starter-Modul zu installieren, fügen Sie ihrer pom.xml Datei die folgenden Abhängigkeiten hinzu:
Die Spring Cloud Azure Bill of Materials (BOM):
<dependencyManagement> <dependencies> <dependency> <groupId>com.azure.spring</groupId> <artifactId>spring-cloud-azure-dependencies</artifactId> <version>5.13.0</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>
Hinweis
Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die
spring-cloud-azure-dependencies
Version auf4.19.0
. Diese Stückliste (Bill of Material, BOM) sollte im<dependencyManagement>
Abschnitt Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud Azure-Abhängigkeiten dieselbe Version verwenden. Weitere Informationen zu der version, die für diese BOM verwendet wird, finden Sie unter Welche Version von Spring Cloud Azure sollte ich verwenden.Das Spring Cloud Azure Service Bus JMS-Artefakt:
<dependency> <groupId>com.azure.spring</groupId> <artifactId>spring-cloud-azure-starter-servicebus-jms</artifactId> </dependency>
Codieren der Anwendung zum Senden und Empfangen von Nachrichten
Konfigurieren Sie die Verbindungszeichenfolge- und Preisstufe für Ihren Servicebus, wie im folgenden Beispiel gezeigt:
spring.jms.servicebus.connection-string=<service-bus-namespace-connection-string> spring.jms.servicebus.pricing-tier=<service-bus-pricing-tier>
Erstellen Sie den Nachrichtenempfänger.
Spring bietet die Möglichkeit, Nachrichten in einem beliebigen POJO (Plain Old Java Object) zu veröffentlichen. Definieren Sie zunächst eine generische
User
Klasse, die den Namen des Benutzers speichert und abruft, wie im folgenden Beispiel gezeigt: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; } }
Tipp
Serializable
wird implementiert, um diesend
-Methode inJmsTemplate
im Spring-Framework zu verwenden. Andernfalls sollten Sie eine angepassteMessageConverter
Bohnen definieren, um den Inhalt im Textformat in JSON zu serialisieren. Weitere Informationen überMessageConverter
finden Sie in der offiziellen Dokumentation des Spring JMS-Starterprojekts.Von hier aus können Sie eine neue
QueueReceiveService
Java-Klasse erstellen, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um einen Nachrichtenempfänger zu definieren.@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()); } }
Hinweis
Ersetzen Sie den
<service-bus-queue-name>
Platzhalter unbedingt durch ihren eigenen Warteschlangennamen, der im Service Bus-Namespace konfiguriert ist.Wenn Sie ein Thema/Abonnement verwenden, ändern Sie den
destination
Parameter als Themennamen, und diescontainerFactory
sollte seintopicJmsListenerContainerFactory
. Fügen Sie außerdem densubscription
Parameter hinzu, um den Abonnementnamen zu beschreiben.Verbinden Sie einen Absender und einen Empfänger, um Nachrichten mit Spring zu senden und zu empfangen, wie im folgenden Beispiel gezeigt:
@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")); } }
Hinweis
Ersetzen Sie den
<service-bus-queue-name>
Platzhalter unbedingt durch ihren eigenen Warteschlangennamen, der im Service Bus-Namespace konfiguriert ist.Tipp
Achten Sie darauf, die
@EnableIntegration
Anmerkung hinzuzufügen, die die Ermittlung von Methoden auslöst, die mit@JmsListener
Anmerkungen versehen sind, und erstellen Sie den Container für den Nachrichtenlistener unter den Deckeln.Starten Sie die Anwendung. Es werden Protokolle angezeigt, die dem folgenden Beispiel ähneln:
Sending a user message. Received a message from Tom.
Weitere Informationen
Weitere Informationen finden Sie unter Verwenden der JMS-API mit Service Bus und AMQP 1.0.
Verwenden von Spring Messaging Azure Service Bus
Das Spring Messaging Azure Service Bus-Modul bietet Unterstützung für das Spring Messaging-Framework mit Service Bus.
Wenn Sie Spring Messaging Azure Service Bus verwenden, können Sie die folgenden Features verwenden:
ServiceBusTemplate
: Nachrichten asynchron und synchron an Service Bus-Warteschlangen und -Themen senden.@ServiceBusListener
: Markieren Sie eine Methode als Ziel eines Service Bus-Nachrichtenlisteners am Ziel.
In diesem Leitfaden erfahren Sie, wie Sie mit Spring Messaging Azure Service Bus Nachrichten an Service Bus senden und empfangen können.
Hinzufügen der Dienstbusabhängigkeit
Um das Spring Messaging Azure Service Bus-Modul zu installieren, fügen Sie Ihrer pom.xml Datei die folgenden Abhängigkeiten hinzu:
Die Spring Cloud Azure Bill of Materials (BOM):
<dependencyManagement> <dependencies> <dependency> <groupId>com.azure.spring</groupId> <artifactId>spring-cloud-azure-dependencies</artifactId> <version>5.13.0</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>
Hinweis
Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die
spring-cloud-azure-dependencies
Version auf4.19.0
. Diese Stückliste (Bill of Material, BOM) sollte im<dependencyManagement>
Abschnitt Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud Azure-Abhängigkeiten dieselbe Version verwenden. Weitere Informationen zu der version, die für diese BOM verwendet wird, finden Sie unter Welche Version von Spring Cloud Azure sollte ich verwenden.Die Spring Messaging Service Bus und Spring Cloud Azure Startartefakte:
<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>
Codieren der Anwendung zum Senden und Empfangen von Nachrichten
Konfigurieren Sie den Namespace und den Warteschlangentyp für Ihren Servicebus, wie im folgenden Beispiel gezeigt:
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name> spring.cloud.azure.servicebus.entity-type=queue
Hinweis
Wenn Sie ein Thema/Abonnement verwenden, ändern Sie den
spring.cloud.azure.servicebus.entity-type
Wert intopic
.Erstellen Sie eine neue
ConsumerService
Java-Klasse, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um einen Nachrichtenempfänger zu definieren.@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); } }
Hinweis
Wenn Sie ein Thema/Abonnement verwenden, ändern Sie den Anmerkungsparameter
destination
als Themanamen, und fügen Sie dengroup
Parameter hinzu, um den Abonnementnamen zu beschreiben.Verbinden Sie einen Absender und einen Empfänger, um Nachrichten mit Spring zu senden und zu empfangen, wie im folgenden Beispiel gezeigt:
@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(); } }
Tipp
Achten Sie darauf, die
@EnableAzureMessaging
Anmerkung hinzuzufügen, die die Ermittlung von Methoden auslöst, die mit@ServiceBusListener
Anmerkungen versehen sind, und erstellen Sie den Container für den Nachrichtenlistener unter den Deckeln.Starten Sie die Anwendung. Es werden Protokolle angezeigt, die dem folgenden Beispiel ähneln:
Sending a message to the queue. Consume message: Hello world.
Verwenden von Spring Integration Azure Service Bus
Das Spring Integration Azure Service Bus-Modul bietet Unterstützung für das Spring Integration Framework mit Service Bus.
Wenn Ihre Spring-Anwendung Spring Integration-Nachrichtenkanäle verwendet, können Sie Nachrichten mithilfe von Kanaladaptern zwischen Ihren Nachrichtenkanälen und Service Bus weiterleiten.
Ein eingehender Kanaladapter leitet Nachrichten aus einer ServiceBus-Warteschlange oder einem Abonnement an einen Nachrichtenkanal weiter. Ein Ausgehender Kanaladapter veröffentlicht Nachrichten aus einem Nachrichtenkanal in einer ServiceBus-Warteschlange und einem Thema.
In diesem Leitfaden erfahren Sie, wie Sie mithilfe von Spring Integration Azure Service Bus Nachrichten an Service Bus senden und empfangen können.
Hinzufügen der Dienstbusabhängigkeit
Um das Spring Cloud Azure Service Bus Integration Starter-Modul zu installieren, fügen Sie Ihrer pom.xml Datei die folgenden Abhängigkeiten hinzu:
Die Spring Cloud Azure Bill of Materials (BOM):
<dependencyManagement> <dependencies> <dependency> <groupId>com.azure.spring</groupId> <artifactId>spring-cloud-azure-dependencies</artifactId> <version>5.13.0</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>
Hinweis
Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die
spring-cloud-azure-dependencies
Version auf4.19.0
. Diese Stückliste (Bill of Material, BOM) sollte im<dependencyManagement>
Abschnitt Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud Azure-Abhängigkeiten dieselbe Version verwenden. Weitere Informationen zu der version, die für diese BOM verwendet wird, finden Sie unter Welche Version von Spring Cloud Azure sollte ich verwenden.Das Artefakt "Spring Cloud Azure Service Bus Integration":
<dependency> <groupId>com.azure.spring</groupId> <artifactId>spring-cloud-azure-starter-integration-servicebus</artifactId> </dependency>
Codieren der Anwendung zum Senden und Empfangen von Nachrichten
Konfigurieren Sie den Namespace Ihres Servicebus, wie im folgenden Beispiel gezeigt:
spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
Erstellen Sie eine neue
QueueReceiveConfiguration
Java-Klasse, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um einen Nachrichtenempfänger zu definieren.@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(); } }
Erstellen Sie eine neue
QueueSendConfiguration
Java-Klasse, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um einen Nachrichtensender zu definieren.@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); } }
Verbinden Sie einen Absender und einen Empfänger, um Nachrichten mit Spring zu senden und zu empfangen, wie im folgenden Beispiel gezeigt:
@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"); } }
Tipp
Achten Sie darauf, die
@EnableIntegration
Anmerkung hinzuzufügen, die die Spring Integration-Infrastruktur ermöglicht.Starten Sie die Anwendung. Es werden Protokolle angezeigt, die dem folgenden Beispiel ähneln:
Message was sent successfully. New message received: 'Hello World'
Feder Cloud Stream Service Bus Binder verwenden
Um die Service Bus-API in einer Spring Cloud Stream-Anwendung aufzurufen, verwenden Sie das Spring Cloud Azure Service Bus Stream Binder-Modul.
In diesem Leitfaden erfahren Sie, wie Sie mithilfe des Spring Cloud Stream Service Bus Binder Nachrichten an Service Bus senden und empfangen können.
Hinzufügen der Dienstbusabhängigkeit
Um das Feder Cloud Azure Service Bus Stream Binder-Modul zu installieren, fügen Sie Ihrer pom.xml Datei die folgenden Abhängigkeiten hinzu:
Die Spring Cloud Azure Bill of Materials (BOM):
<dependencyManagement> <dependencies> <dependency> <groupId>com.azure.spring</groupId> <artifactId>spring-cloud-azure-dependencies</artifactId> <version>5.13.0</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>
Hinweis
Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die
spring-cloud-azure-dependencies
Version auf4.19.0
. Diese Stückliste (Bill of Material, BOM) sollte im<dependencyManagement>
Abschnitt Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud Azure-Abhängigkeiten dieselbe Version verwenden. Weitere Informationen zu der version, die für diese BOM verwendet wird, finden Sie unter Welche Version von Spring Cloud Azure sollte ich verwenden.Das Artefakt "Spring Cloud Azure Service Bus Integration":
<dependency> <groupId>com.azure.spring</groupId> <artifactId>spring-cloud-azure-stream-binder-servicebus</artifactId> </dependency>
Codieren der Anwendung zum Senden und Empfangen von Nachrichten
Konfigurieren Sie den Namespace Ihres Servicebus, wie im folgenden Beispiel gezeigt:
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
Erstellen Sie den Nachrichtenempfänger.
Um Ihre Anwendung als Ereignissenke zu verwenden, konfigurieren Sie den Eingabeordner, indem Sie die folgenden Informationen angeben:
Deklarieren Sie eine
Consumer
Bohnen, die die Nachrichtenverarbeitungslogik definiert. Der folgendeConsumer
Bohnenname lautet z. B. :consume
@Bean public Consumer<Message<String>> consume() { return message -> { System.out.printf("New message received: '%s'.%n", message.getPayload()); }; }
Fügen Sie die Konfiguration hinzu, um den Namen für die
queue
Nutzung anzugeben, indem Sie den<service-bus-queue-name>
Platzhalter ersetzen, wie im folgenden Beispiel gezeigt:# name for the `Consumer` bean spring.cloud.function.definition=consume spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-queue-name>
Hinweis
Wenn Sie ein Service Bus-Abonnement nutzen möchten, müssen Sie die
consume-in-0
Bindungseigenschaften wie im folgenden Beispiel gezeigt ändern:spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-topic-name> spring.cloud.stream.bindings.consume-in-0.group=<service-bus-subscription-name>
Erstellen Sie den Absender der Nachricht.
Um Ihre Anwendung als Ereignisquelle zu verwenden, konfigurieren Sie den Ausgabeordner, indem Sie die folgenden Informationen angeben:
Definieren Sie eine
Supplier
Bohnen, die definiert, wo Nachrichten aus Ihrer Anwendung stammen.@Bean return () -> { System.out.println("Sending a message."); return MessageBuilder.withPayload("Hello world").build(); }; }
Fügen Sie die Konfiguration hinzu, um den Namen für das
queue
Senden anzugeben, indem Sie den<your-servicebus-queue-name>
Platzhalter im folgenden Beispiel ersetzen:# "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
Hinweis
Um an ein ServiceBus-Thema zu senden, stellen Sie sicher, dass Sie die
entity-type
Datei intopic
" ändern.
Starten Sie die Anwendung. Es werden Protokolle wie im folgenden Beispiel angezeigt:
Sending a message. New message received: 'Hello world'.
Bereitstellen in Azure Spring Apps
Nachdem Sie nun die Spring Boot-Anwendung lokal ausgeführt haben, ist es an der Zeit, sie in die Produktion zu verschieben. Azure Spring Apps erleichtert die Bereitstellung von Spring Boot-Anwendungen in Azure ohne Codeänderungen. Der Dienst verwaltet die Infrastruktur von Spring-Anwendungen und ermöglicht es Entwicklern dadurch, sich auf ihren Code zu konzentrieren. Azure Spring Apps bietet eine Lebenszyklusverwaltung mit umfassender Überwachung und Diagnose, Konfigurationsverwaltung, Dienstermittlung, CI/CD-Integration, Blau/Grün-Bereitstellungen und mehr. Informationen zum Bereitstellen Ihrer Anwendung in Azure Spring Apps finden Sie unter Bereitstellen Ihrer ersten Anwendung in Azure Spring Apps.
Nächste Schritte
Weitere Informationen
Weitere Informationen zu weiteren Spring Boot Starters für Microsoft Azure finden Sie unter Was ist Spring Cloud Azure?
Feedback
https://aka.ms/ContentUserFeedback.
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unterFeedback senden und anzeigen für