Verwenden von Azure Service Bus in Spring-Anwendungen

Artikel
01/18/2024

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 DefaultAzureCredentialderzeit 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.11.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.17.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 den entity-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 von ServiceBusProcessorClient.

@Configuration(proxyBeanMethods = false)
public class ServiceBusProcessorClientConfiguration {

    @Bean
    ServiceBusRecordMessageListener processMessage() {
        return context -> {
            ServiceBusReceivedMessage message = context.getMessage();
            System.out.printf("Processing message. Id: %s, Sequence #: %s. Contents: %s%n", message.getMessageId(),
                    message.getSequenceNumber(), message.getBody());
        };
    }

    @Bean
    ServiceBusErrorHandler processError() {
        return context -> {
            System.out.printf("Error when receiving messages from namespace: '%s'. Entity: '%s'%n",
                    context.getFullyQualifiedNamespace(), context.getEntityPath());
        };
    }
}

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 Sie spring.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 die ServiceBusSenderClientServiceBusProcessorClient 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 Verbinden für verschiedene 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.11.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.17.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 die send-Methode in JmsTemplate im Spring-Framework zu verwenden. Andernfalls sollten Sie eine angepasste MessageConverter Bohnen definieren, um den Inhalt im Textformat in JSON zu serialisieren. Weitere Informationen über MessageConverter 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 dies containerFactory sollte sein topicJmsListenerContainerFactory. 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

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 @JmsListenerAnmerkungen 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.11.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.17.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 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 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
@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 @ServiceBusListenerAnmerkungen 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.11.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.17.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.11.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.17.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 folgende Consumer 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 in topic" ä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

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

Weitere Informationen

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

Verwenden von Azure Service Bus in Spring-Anwendungen

Voraussetzungen

Vorbereiten der lokalen Umgebung

Verwenden des Spring Cloud Azure Service Bus Starter

Hinzufügen der Dienstbusabhängigkeit

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Automatische Konfiguration des Federstarts verwenden

Programmgesteuertes Erstellen von ServiceBus-Clients

Verwenden des Spring Cloud Azure Service Bus JMS Starter

Hinzufügen der Dienstbusabhängigkeit

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Weitere Informationen

Verwenden von Spring Messaging Azure Service Bus

Hinzufügen der Dienstbusabhängigkeit

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Verwenden von Spring Integration Azure Service Bus

Hinzufügen der Dienstbusabhängigkeit

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Feder Cloud Stream Service Bus Binder verwenden

Hinzufügen der Dienstbusabhängigkeit

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Bereitstellen in Azure Spring Apps

Nächste Schritte

Weitere Informationen

Feedback

Feedback

Zusätzliche Ressourcen