Azure Service Bus in Spring-Anwendungen verwenden

2025-04-18

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 auf allen unterstützten Azure-Plattformen verwenden.

Spring Cloud Azure bietet verschiedene Module zum Austauschen von Nachrichten mit Service Bus-Warteschlangen und -Themen/-Abonnements 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

Ein Azure-Abonnement – kostenlos erstellen.
Java Development Kit (JDK) Version 8 oder höher.
Apache Maven, Version 3.0 oder höher.
Ein Azure Service Bus und eine Warteschlange oder ein Thema/Abonnement. Falls Sie noch keine haben, erstellen Sie eine Service Bus-Warteschlange oder ein Thema. Weitere Informationen finden Sie im Azure-Portal zum Erstellen eines Service Bus-Namespaces und einer Warteschlange oder verwenden sie das Azure-Portal, um ein Service Bus-Thema und Abonnements für das Thema zu erstellen.
Wenn Sie nicht über eine Spring Boot-Anwendung verfügen, erstellen Sie ein Maven-Projekt mit dem Spring Initializr. Wählen Sie "Maven Project " aus, und fügen Sie unter "Abhängigkeiten" die Spring Web-Abhängigkeit 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 Zuweisen von Azure-Rollen mithilfe des Azure-Portals.

Wichtig

Für die Schritte in diesem Tutorial wird mindestens die Spring Boot-Version 2.5 benötigt.

Bereiten Sie Ihre lokale Umgebung vor

In diesem Tutorial 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, was die Azure Identity-Bibliothek bereitstellt, um Sie beim Abrufen von Anmeldeinformationen ohne Codeänderungen zu unterstützen.

„DefaultAzureCredential“ unterstützt mehrere Authentifizierungsmethoden und bestimmt, welche Methode zur Laufzeit verwendet wird. Mit diesem Ansatz kann Ihre Anwendung verschiedene Authentifizierungsmethoden in unterschiedlichen Umgebungen verwenden – z. B. in lokalen oder Produktionsumgebungen –, ohne dass umgebungsspezifischer Code implementiert werden muss. Weitere Informationen finden Sie im Abschnitt DefaultAzureCredential von Authentifizierung von Java-Anwendungen, die von Azure gehostet werden.

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 Starters

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 zusammen in einem nicht gegenseitig ausschließenden Muster verwenden. Daher können Sie die Service Bus-Java-Client-API weiterhin in Ihrer Spring-Anwendung verwenden.

Hinzufügen der Service Bus-Abhä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 Stückliste (Bill of Materials, BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.22.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 auf 4.20.0 festlegen. 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 Methode, bei der die Client-Beans automatisch aus dem Spring-IoC-Container verknüpft werden, bietet im Vergleich zur zweiten Methode die folgenden Vorteile: 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 Erlernens des Builder-Musters und der Registrierung dieses Clients im Anwendungskontext an das Spring Boot-Framework delegieren. Mit dieser Befugnisübertragung können Sie sich darauf konzentrieren, wie Sie die Clients mit Ihren eigenen Geschäftsanforderungen verwenden.
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 ServiceBusSenderClient und ServiceBusProcessorClient mit diesen beiden Alternativen verwenden.

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.

Verwenden der Autokonfiguration von Spring Boot

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 den entity-type Wert in topic ändern.

Erstellen Sie eine neue ServiceBusProcessorClientConfiguration Java-Klasse, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um die Nachricht und den Fehlerhandler von ServiceBusProcessorClient zu registrieren.

@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 in Ihre 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 AutoWired ServiceBusProcessorClient-Bean durch den Spring-Kontext verwaltet. Der Prozessor wird automatisch gestartet, wenn der Spring-Anwendungskontext startet, und beendet, wenn der Spring-Anwendungskontext endet. Zum Deaktivieren dieses Features konfigurieren Sie spring.cloud.azure.servicebus.processor.auto-startup=false.

Starten Sie die Anwendung. Es werden Protokolle ähnlich dem folgenden Beispiel angezeigt:

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

Programmgesteuertes Erstellen von Service Bus-Clients

Sie können diese Client Beans selbst erstellen, aber das Verfahren ist kompliziert. In Spring Boot-Anwendungen müssen Sie Eigenschaften verwalten, das Generatormuster erlernen und den Client in Ihrem Spring-Anwendungskontext registrieren. Der folgende Code zeigt, wie Sie dabei vorgehen müssen:

Erstellen Sie eine neue ServiceBusClientConfiguration Java-Klasse, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um die ServiceBusSenderClient und ServiceBusProcessorClient Bean 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 Service Bus-Hostnamen aus dem Azure-Portal. Ersetzen Sie den Platzhalter <service-bus-queue-name> durch den Namen Ihrer eigenen Warteschlange, die in Ihrem Service Bus-Namespace konfiguriert ist.

Fügen Sie die Client Beans in Ihre Anwendung ein, 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 ähnlich dem folgenden Beispiel angezeigt:

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 elegant ist.

Der Namespace und die Namen für Warteschlange/Thema/Abonnement sind fest programmiert.
Wenn Sie @Value verwenden, um Konfigurationen aus der Spring-Umgebung zu erhalten, können Sie in der Datei application.properties keine IDE-Vorschläge haben.
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 eigenhändige Erstellen von Client-Beans mit Spring Cloud Azure nicht 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.

Proxy-Optionen.
Wiederholungsoptionen.
AMQP-Transportclient-Optionen

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 Starters

Das Spring Cloud Azure Service Bus JMS Starter-Modul bietet eine Spring JMS Integration mit Service Bus. Im folgenden Video wird beschrieben, wie Spring JMS-Anwendungen mithilfe von JMS 2.0 in Azure Service Bus integriert werden:

Dieser Leitfaden zeigt Ihnen, wie Sie Spring Cloud Azure Service Bus Starter für JMS-API verwenden, um Nachrichten an Service Bus zu senden und von dort zu empfangen.

Hinzufügen der Service Bus-Abhä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 Stückliste (Bill of Materials, BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.22.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 auf 4.20.0 festlegen. 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 des Nachrichtenempfängers.

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 die send-Methode in JmsTemplate im Spring-Framework zu verwenden. Andernfalls sollten Sie ein benutzerdefiniertes MessageConverter-Bean definieren, um den Inhalt im Textformat in JSON zu serialisieren. Weitere Informationen über MessageConverter finden Sie im offiziellen Spring JMS Starter-Projekt.
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

Achten Sie darauf, den Platzhalter <service-bus-queue-name> durch den Namen Ihrer eigenen Warteschlange zu ersetzen, der in Ihrem Service Bus-Namespace konfiguriert ist.

Wenn Sie ein Thema/Abonnement verwenden, ändern Sie den destination Parameter als Themennamen, und dies containerFactory sollte topicJmsListenerContainerFactory sein. Fügen Sie außerdem den subscription-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

Achten Sie darauf, den Platzhalter <service-bus-queue-name> durch den Namen Ihrer eigenen Warteschlange zu ersetzen, der in Ihrem Service Bus-Namespace konfiguriert ist.

Tipp

Bitte vergessen Sie nicht, die Anmerkung @EnableIntegration hinzuzufügen, die die Erkennung von mit @JmsListener gekennzeichneten Methoden auslöst und im Hintergrund den Nachrichten-Listener-Container erstellt.

Starten Sie die Anwendung. Es werden Protokolle ähnlich dem folgenden Beispiel angezeigt:
```
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 des 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: Senden Sie Nachrichten asynchron und synchron an Service Bus-Warteschlangen und -Themen.
@ServiceBusListener: Markieren Sie eine Methode als Ziel eines Service Bus-Nachrichtenempfängers am Zielort.

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 Service Bus-Abhä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 Stückliste (Bill of Materials, BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.22.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 auf 4.20.0 festlegen. 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.

Der Spring Messaging Service Bus und die Spring Cloud Azure-Starter-Artefakte:

<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 Service Bus, 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 in topic.
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 den group-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

Bitte vergessen Sie nicht, die Anmerkung @EnableAzureMessaging hinzuzufügen, die die Erkennung von mit @ServiceBusListener gekennzeichneten Methoden auslöst und im Hintergrund den Nachrichten-Listener-Container erstellt.

Starten Sie die Anwendung. Es werden Protokolle ähnlich dem folgenden Beispiel angezeigt:
```
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 Service Bus-Warteschlange oder einem Abonnement an einen Nachrichtenkanal weiter. Ein ausgehender Kanaladapter veröffentlicht Nachrichten aus einem Nachrichtenkanal an eine Service Bus-Warteschlange und ein Thema.

In diesem Leitfaden erfahren Sie, wie Sie mit Spring Integration Azure Service Bus Nachrichten an Service Bus senden und empfangen können.

Hinzufügen der Service Bus-Abhä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 Stückliste (Bill of Materials, BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.22.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 auf 4.20.0 festlegen. 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 Integration-Artefakt:

<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 Service Bus, 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 Nachrichtenabsender 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 ähnlich dem folgenden Beispiel angezeigt:
```
Message was sent successfully.
New message received: 'Hello World'
```

Verwenden von Spring Cloud Stream Service Bus Binder

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 mit Spring Cloud Stream Service Bus Binder Nachrichten an Service Bus senden und empfangen können.

Hinzufügen der Service Bus-Abhängigkeit

Um das Spring 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 Stückliste (Bill of Materials, BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.22.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 auf 4.20.0 festlegen. 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 Integration-Artefakt:

<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 Service Bus, wie im folgenden Beispiel gezeigt:
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
```
Erstellen des Nachrichtenempfängers.

Um Ihre Anwendung als Ereignisaufnehmer zu verwenden, konfigurieren Sie die Eingabebindung, indem Sie die folgende Information angeben:
- Deklarieren Sie eine Consumer Bean, die die Nachrichtenverarbeitungslogik definiert. Zum Beispiel wird die folgende Consumer-Bean consume genannt:
```
@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 queue-Namen für die Verwendung anzugeben, indem Sie den Platzhalter <service-bus-queue-name> 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
  
  Um eine Service Bus-Abonnement zu nutzen, ändern Sie die consume-in-0-Bindungseigenschaften wie im folgenden Beispiel gezeigt:
```
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 des Nachrichtenabsenders.

Um Ihre Anwendung als Ereignisquelle zu verwenden, konfigurieren Sie den Ausgabeordner, indem Sie die folgende Information angeben:
- Definieren Sie eine Supplier Bean, 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 queue Namen für das 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 Service Bus-Topic zu senden, stellen Sie sicher, dass Sie die entity-type in topic ändern.
Starten Sie die Anwendung. Ihnen werden Protokolle angezeigt, die dem folgenden Beispiel ähneln:
```
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

Azure für Spring-Entwickler Spring Cloud Azure Service Bus Beispiele

Siehe auch

Weitere Informationen zu weiteren Spring Boot Starters für Microsoft Azure finden Sie unter Was ist Spring Cloud Azure?

Freigeben über

Azure Service Bus in Spring-Anwendungen verwenden

Voraussetzungen

Bereiten Sie Ihre lokale Umgebung vor

Verwenden des Spring Cloud Azure Service Bus Starters

Hinzufügen der Service Bus-Abhängigkeit

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Verwenden der Autokonfiguration von Spring Boot

Programmgesteuertes Erstellen von Service Bus-Clients

Verwenden des Spring Cloud Azure Service Bus JMS Starters

Hinzufügen der Service Bus-Abhängigkeit

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Weitere Informationen

Verwenden des Spring Messaging Azure Service Bus

Hinzufügen der Service Bus-Abhängigkeit

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Verwenden von Spring Integration Azure Service Bus

Hinzufügen der Service Bus-Abhängigkeit

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Verwenden von Spring Cloud Stream Service Bus Binder

Hinzufügen der Service Bus-Abhängigkeit

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Bereitstellen in Azure Spring Apps

Nächste Schritte

Siehe auch

Feedback

Zusätzliche Ressourcen