Azure Service Bus in Spring-Anwendungen verwenden

Artikel
10/04/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 Nachrichtenplattform 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 Senden von Nachrichten und Empfangen von Nachrichten aus Service Bus-Warteschlangen und Themen/abonnements mithilfe von Spring-Frameworks an.

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 Nachrichtenkanäle 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.
Einen Azure Service Bus und eine Warteschlange oder ein Thema/Abonnement. Wenn Sie keins haben, erstellen Sie eine Service Bus-Warteschlange oder ein Thema. Weitere Informationen finden Sie unter Verwenden des Azure-Portals zum Erstellen eines Service Bus-Namespaces und einer Warteschlange oder Verwenden des Azure-Portals zum Erstellen eines Service Bus-Themas und von Abonnements für das Thema.
Wenn Sie über keine Spring Boot-Anwendung verfügen, erstellen Sie mit Spring Initializr ein Maven-Projekt. 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 Weisen Sie Azure-Rollen über das Azure-Portal zu.

Wichtig

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

Vorbereiten der lokalen Umgebung

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 Authentifizieren von in 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 Starters

Das Spring Cloud Azure Service Bus Starter-Modul importiert die Service Bus-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-Startermodul 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.18.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.19.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.

Der erste Weg, der die Auto-Wiring der Client-Beans aus dem Spring-IoC-Container beinhaltet, hat gegenüber dem zweiten Weg die folgenden Vorteile. Diese Vorteile bieten Ihnen eine flexiblere und effizientere Erfahrung bei der Entwicklung mit Service Bus-Clients.

Sie können die externalisierte Konfiguration verwenden, sodass 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 Delegierung können Sie sich auf die Verwendung der Kunden mit Ihrer eigenen Geschäftsanforderungen 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 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 ordnungsgemäß ist:

Die Namespace- und Warteschlangen-/Themen-/Abonnementnamen sind hartcodiert.
Wenn Sie @Value verwenden, um Konfigurationen aus der Spring-Umgebung zu erhalten, können Sie keine IDE-Hinweise in Ihrer application.properties-Datei 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 Erstellen der Client-Beans selbst mit Spring Cloud Azure nicht erforderlich. Stattdessen können Sie die Beans 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-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 Starters

Das Spring Cloud Azure Service Bus JMS Starter-Modul bietet 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-Startermodul 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.18.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.19.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 eine benutzerdefinierte MessageConverter-Bean definieren, um den Inhalt in JSON im Textformat 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

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

Achten Sie darauf, dass Sie die @EnableIntegration Anmerkung hinzufügen, die die Ermittlung von Methoden auslöst, die mit @JmsListener Anmerkungen versehen sind, und erstellen Sie im Hintergrund den Container für den Nachrichtenlistener.

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 den 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 Service Bus-Abhängigkeit

Um das Spring Messaging Azure Service Bus-Startermodul 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.18.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.19.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.

Die Spring Messaging Service Bus und 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

Achten Sie darauf, dass Sie die @EnableAzureMessaging Anmerkung hinzufügen, die die Ermittlung von Methoden auslöst, die mit @ServiceBusListener Anmerkungen versehen sind, und erstellen Sie im Hintergrund den Container für den Nachrichtenlistener.

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 den 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 in einer Service Bus-Warteschlange und einem 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-Startermodul 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.18.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.19.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 von Ihren Service Bus und die Warteschlange, 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 Bill of Materials (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.18.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.19.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 von Ihren Service Bus und die Warteschlange, wie im folgenden Beispiel gezeigt:
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
```
Erstellen des Nachrichtenempfängers.

Um Ihre Anwendung als Ereignissenke zu verwenden, konfigurieren Sie den Eingabeordner, indem Sie die folgende Information angeben:
- Deklarieren Sie eine Consumer Bean, die die Nachrichtenverarbeitungslogik definiert. Zum Beispiel folgende Consumer Bean wird 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 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 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-Thema zu senden, stellen Sie sicher, dass Sie die entity-type in topic ändern.
Starten Sie die Anwendung. Es werden Protokolle ähnlich dem 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. Mit Azure Spring Apps lassen sich Spring Boot-Anwendungen ganz einfach und ohne Codeänderungen in Azure bereitstellen. 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 verfügbaren Spring Boot Starter-Optionen für Microsoft Azure finden Sie unter Was ist Spring Cloud Azure?

Freigeben über

Azure Service Bus in Spring-Anwendungen verwenden

Voraussetzungen

Vorbereiten der lokalen Umgebung

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