Senden und Empfangen von Nachrichten für Azure Service Bus-Warteschlangen (Java)

In dieser Schnellstartanleitung erstellen Sie eine Java-App zum Senden und Empfangen von Nachrichten für eine Azure Service Bus-Warteschlange.

Voraussetzungen

• Ein Azure-Abonnement. Um dieses Tutorial abzuschließen, benötigen Sie ein Azure-Konto. Sie können Ihre MSDN-Abonnentenvorteile aktivieren oder sich für ein kostenloses Konto registrieren.
• Installieren Sie das Azure SDK für Java. Wenn Sie Eclipse verwenden, können Sie das Azure-Toolkit für Eclipse installieren, in dem das Azure SDK für Java enthalten ist. Sie können dann Ihrem Projekt die Microsoft Azure-Bibliotheken für Java hinzufügen. Lesen Sie bei Verwendung von IntelliJ die Informationen unter Installieren des Azure-Toolkits für IntelliJ.

Erstellen eines Namespace im Azure-Portal

Um mit der Verwendung von Service Bus-Nachrichtenentitäten in Azure beginnen zu können, müssen Sie zuerst einen Namespace mit einem in Azure eindeutigen Namen erstellen. Ein Namespace ist ein Bereichscontainer für Service Bus-Ressourcen (Warteschlangen, Themen usw.) innerhalb Ihrer Anwendung.

So erstellen Sie einen Namespace

1. Melden Sie sich beim Azure-Portal an.

2. Navigieren Sie zur Seite Alle Dienste.

3. Wählen Sie im linken Navigationsbereich in der Kategorienliste Integration aus, zeigen Sie mit dem Mauszeiger auf Service Bus, und wählen Sie auf der Service Bus-Kachel die Schaltfläche + aus.

   

4. Führen Sie auf der Seite Namespace erstellen auf der Registerkarte Grundlagen die folgenden Schritte aus:

   1. Wählen Sie unter Abonnement ein Azure-Abonnement aus, in dem der Namespace erstellt werden soll.

   2. Wählen Sie unter Ressourcengruppe eine vorhandene Ressourcengruppe für den Namespace aus, oder erstellen Sie eine neue Ressourcengruppe.

   3. Geben Sie einen Namen für den Namespace ein. Der Namespacename sollte den folgenden Namenskonventionen entsprechen:

      • Der Name muss innerhalb von Azure eindeutig sein. Das System überprüft sofort, ob dieser Name verfügbar ist.
      • Die Länge des Namens beträgt mindestens 6 und maximal 50 Zeichen.
      • Der Name darf nur Buchstaben, Zahlen und Bindestriche („-“) enthalten.
      • Der Name muss mit einem Buchstaben beginnen und mit einem Buchstaben oder einer Ziffer enden.
      • Der Name endet nicht mit „-sb“ oder „-mgmt“.

   4. Wählen Sie unter Standort die Region aus, in der Ihr Namespace gehostet werden soll.

   5. Wählen Sie unter Tarif den Tarif (Basic, Standard oder Premium) für den Namespace aus. Wählen Sie für diesen Schnellstart die Option Standard aus.

      Wichtig

      Wenn Sie Themen und Abonnements nutzen möchten, wählen Sie entweder Standard oder Premium aus. Themen/Abonnements werden für den Basic-Tarif nicht unterstützt.

      Wenn Sie den Tarif Premium auswählen, geben Sie die Anzahl von Messagingeinheiten an. Der Premium-Tarif bietet Ressourcenisolierung auf CPU- und Arbeitsspeicherebene, sodass die einzelnen Workloads voneinander isoliert ausgeführt werden. Dieser Ressourcencontainer wird als Messagingeinheit bezeichnet. Ein Premium-Namespace verfügt über mindestens eine Messagingeinheit. Sie können 1, 2, 4, 8 oder 16 Messagingeinheiten für jeden Service Bus Premium-Namespace auswählen. Weitere Informationen finden Sie unter Service Bus Premium- und Standard-Preisstufe für Messaging.

   6. Wählen Sie am unteren Rand der Seite die Option Bewerten + erstellen aus.

      

   7. Überprüfen Sie die Einstellungen auf der Seite Überprüfen und erstellen, und wählen Sie Erstellen aus.

5. Wählen Sie nach der erfolgreichen Bereitstellung der Ressource auf der Bereitstellungsseite Zur Ressource wechseln aus.

   

6. Die Startseite für Ihren Service Bus-Namespace wird angezeigt.

   

Erstellen einer Warteschlange im Azure-Portal

1. Wählen Sie auf der Seite Service Bus-Namespace im linken Navigationsmenü die Option Warteschlangen aus.

2. Wählen Sie auf der Seite Warteschlangen auf der Symbolleiste die Option + Warteschlange aus.

3. Geben Sie einen Namen für die Warteschlange ein, und lassen Sie die anderen Werte unverändert.

4. Wählen Sie jetzt Erstellen.

   

Authentifizieren der App bei Azure

In dieser Schnellstartanleitung werden zwei Möglichkeiten zum Herstellen einer Verbindung mit Azure Service Bus gezeigt: kennwortlos und Verbindungszeichenfolge.

Die erste Option zeigt, wie Sie über Ihren Sicherheitsprinzipal in Microsoft Entra ID und die rollenbasierte Zugriffssteuerung (Role-Based Access Control, RBAC) eine Verbindung mit einem Service Bus-Namespace herstellen. Sie müssen sich keine Gedanken darüber machen, dass hartcodierte Verbindungszeichenfolgen in Ihrem Code oder in einer Konfigurationsdatei oder in einem sicheren Speicher wie Azure Key Vault vorhanden sind.

Die zweite Option zeigt, wie Sie mithilfe einer Verbindungszeichenfolge eine Verbindung mit einem Service Bus-Namespace herstellen. Wenn Sie noch nicht mit Azure vertraut sind, ist die Option mit der Verbindungszeichenfolge möglicherweise einfacher. In realen Anwendungen und Produktionsumgebungen wird die kennwortlose Option empfohlen. Weitere Informationen finden Sie unter Authentifizierung und Autorisierung. Weitere Informationen zur kennwortlosen Authentifizierung finden Sie auch auf der Übersichtsseite.

Senden von Nachrichten an eine Warteschlange

In diesem Abschnitt erstellen Sie ein Java-Konsolenprojekt und fügen Code zum Senden von Nachrichten an die von Ihnen weiter oben erstellte Warteschlange hinzu.

Erstellen eines Java-Konsolenprojekts

Erstellen Sie ein Java-Projekt mit Eclipse oder einem Tool Ihrer Wahl.

Konfigurieren Ihrer Anwendung für die Verwendung von Service Bus

Fügen Sie Verweise auf Azure Core- und Azure Service Bus-Bibliotheken hinzu.

Wenn Sie Eclipse verwenden und eine Java-Konsolenanwendung erstellt haben, konvertieren Sie Ihr Java-Projekt in ein Maven-Projekt: Klicken Sie im Fenster Paket-Explorer mit der rechten Maustaste auf das Projekt, und wählen Sie Konfigurieren->In Maven-Projekt konvertieren aus. Fügen Sie dann Abhängigkeiten zu diesen beiden Bibliotheken hinzu, wie im folgenden Beispiel gezeigt.

    <dependencies>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-messaging-servicebus</artifactId>
            <version>7.13.3</version>
        </dependency>
        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-identity</artifactId>
            <version>1.8.0</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

        <dependency>
            <groupId>com.azure</groupId>
            <artifactId>azure-messaging-servicebus</artifactId>
            <version>7.13.3</version>
        </dependency>

Hinzufügen von Code für das Senden von Nachrichten an die Warteschlange

1. Fügen Sie die folgenden import-Anweisungen für das Thema der Java-Datei hinzu.

   • Kennwortlos (empfohlen)
   • Verbindungszeichenfolge

   import com.azure.messaging.servicebus.*;
   import com.azure.identity.*;
   
   import java.util.concurrent.TimeUnit;
   import java.util.Arrays;
   import java.util.List;
   

2. Definieren Sie in der Klasse Variablen für die Verbindungszeichenfolge und den Warteschlangennamen.

   • Kennwortlos (empfohlen)
   • Verbindungszeichenfolge

   static String queueName = "<QUEUE NAME>";
   

   Wichtig

   Ersetzen Sie <QUEUE NAME> durch den Namen der Warteschlange.

3. Fügen Sie in der Klasse eine Methode mit dem Namen sendMessage zum Senden einer Nachricht an die Warteschlange hinzu.

   • Kennwortlos (empfohlen)
   • Verbindungszeichenfolge

   Wichtig

   Ersetzen Sie NAMESPACENAME durch den Namen Ihres Service Bus-Namespace.

   static void sendMessage()
   {
       // create a token using the default Azure credential
       DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
               .build();
   
       ServiceBusSenderClient senderClient = new ServiceBusClientBuilder()
               .fullyQualifiedNamespace("NAMESPACENAME.servicebus.windows.net")
               .credential(credential)
               .sender()
               .queueName(queueName)
               .buildClient();
   
       // send one message to the queue
       senderClient.sendMessage(new ServiceBusMessage("Hello, World!"));
       System.out.println("Sent a single message to the queue: " + queueName);
   }
   
   

4. Fügen Sie in der Klasse eine Methode mit dem Namen createMessages zum Erstellen einer Liste mit Nachrichten hinzu. Normalerweise erhalten Sie diese Nachrichten von den verschiedenen Teilen Ihrer Anwendung. Hier erstellen wir eine Liste mit Beispielnachrichten.

   static List<ServiceBusMessage> createMessages()
   {
       // create a list of messages and return it to the caller
       ServiceBusMessage[] messages = {
               new ServiceBusMessage("First message"),
               new ServiceBusMessage("Second message"),
               new ServiceBusMessage("Third message")
       };
       return Arrays.asList(messages);
   }
   

5. Fügen Sie eine Methode mit dem Namen sendMessageBatch zum Senden von Nachrichten an die von Ihnen erstellte Warteschlange hinzu. Mit dieser Methode wird ein ServiceBusSenderClient für die Warteschlange erstellt, die createMessages-Methode zum Abrufen der Liste mit den Nachrichten aufgerufen und mindestens ein Batch vorbereitet. Anschließend werden die Batches an die Warteschlange gesendet.

   • Kennwortlos (empfohlen)
   • Verbindungszeichenfolge

   Wichtig

   Ersetzen Sie NAMESPACENAME durch den Namen Ihres Service Bus-Namespace.

   static void sendMessageBatch()
   {
       // create a token using the default Azure credential
       DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
               .build();
   
       ServiceBusSenderClient senderClient = new ServiceBusClientBuilder()
               .fullyQualifiedNamespace("NAMESPACENAME.servicebus.windows.net")
               .credential(credential)
               .sender()
               .queueName(queueName)
               .buildClient();
   
       // Creates an ServiceBusMessageBatch where the ServiceBus.
       ServiceBusMessageBatch messageBatch = senderClient.createMessageBatch();
   
       // create a list of messages
       List<ServiceBusMessage> listOfMessages = createMessages();
   
       // We try to add as many messages as a batch can fit based on the maximum size and send to Service Bus when
       // the batch can hold no more messages. Create a new batch for next set of messages and repeat until all
       // messages are sent.
       for (ServiceBusMessage message : listOfMessages) {
           if (messageBatch.tryAddMessage(message)) {
               continue;
           }
   
           // The batch is full, so we create a new batch and send the batch.
           senderClient.sendMessages(messageBatch);
           System.out.println("Sent a batch of messages to the queue: " + queueName);
   
           // create a new batch
           messageBatch = senderClient.createMessageBatch();
   
           // Add that message that we couldn't before.
           if (!messageBatch.tryAddMessage(message)) {
               System.err.printf("Message is too large for an empty batch. Skipping. Max size: %s.", messageBatch.getMaxSizeInBytes());
           }
       }
   
       if (messageBatch.getCount() > 0) {
           senderClient.sendMessages(messageBatch);
           System.out.println("Sent a batch of messages to the queue: " + queueName);
       }
   
       //close the client
       senderClient.close();
   }
   

Empfangen von Nachrichten aus einer Warteschlange

In diesem Abschnitt fügen Sie Code hinzu, mit dem Nachrichten aus der Warteschlange abgerufen werden.

1. Fügen Sie eine Methode mit dem Namen receiveMessages hinzu, um Nachrichten von der Warteschlange zu empfangen. Mit dieser Methode wird ein ServiceBusProcessorClient-Element für die Warteschlange erstellt, indem ein Handler für die Verarbeitung von Nachrichten und ein anderer für die Verarbeitung von Fehlern angegeben wird. Anschließend wird der Prozessor gestartet, und es wird einige Sekunden lang abgewartet. Die empfangenen Nachrichten werden ausgegeben, und dann wird der Prozessor angehalten und geschlossen.

   • Kennwortlos (empfohlen)
   • Verbindungszeichenfolge

   Wichtig

   • Ersetzen Sie NAMESPACENAME durch den Namen Ihres Service Bus-Namespace.
   • Ersetzen Sie QueueTest in QueueTest::processMessage im Code durch den Namen Ihrer Klasse.

   // handles received messages
   static void receiveMessages() throws InterruptedException
   {
       DefaultAzureCredential credential = new DefaultAzureCredentialBuilder()
               .build();
   
       ServiceBusProcessorClient processorClient = new ServiceBusClientBuilder()
               .fullyQualifiedNamespace("NAMESPACENAME.servicebus.windows.net")
               .credential(credential)
               .processor()
               .queueName(queueName)
               .processMessage(context -> processMessage(context))
               .processError(context -> processError(context))
               .buildProcessorClient();
   
       System.out.println("Starting the processor");
       processorClient.start();
   
       TimeUnit.SECONDS.sleep(10);
       System.out.println("Stopping and closing the processor");
       processorClient.close();
   }
   

2. Fügen Sie die Methode processMessage hinzu, um eine Nachricht zu verarbeiten, die aus dem Service Bus-Abonnement empfangen wurde.

   private static void processMessage(ServiceBusReceivedMessageContext context) {
       ServiceBusReceivedMessage message = context.getMessage();
       System.out.printf("Processing message. Session: %s, Sequence #: %s. Contents: %s%n", message.getMessageId(),
           message.getSequenceNumber(), message.getBody());
   }
   

3. Fügen Sie die Methode processError zum Behandeln von Fehlermeldungen hinzu.

   private static void processError(ServiceBusErrorContext context) {
       System.out.printf("Error when receiving messages from namespace: '%s'. Entity: '%s'%n",
           context.getFullyQualifiedNamespace(), context.getEntityPath());
   
       if (!(context.getException() instanceof ServiceBusException)) {
           System.out.printf("Non-ServiceBusException occurred: %s%n", context.getException());
           return;
       }
   
       ServiceBusException exception = (ServiceBusException) context.getException();
       ServiceBusFailureReason reason = exception.getReason();
   
       if (reason == ServiceBusFailureReason.MESSAGING_ENTITY_DISABLED
           || reason == ServiceBusFailureReason.MESSAGING_ENTITY_NOT_FOUND
           || reason == ServiceBusFailureReason.UNAUTHORIZED) {
           System.out.printf("An unrecoverable error occurred. Stopping processing with reason %s: %s%n",
               reason, exception.getMessage());
       } else if (reason == ServiceBusFailureReason.MESSAGE_LOCK_LOST) {
           System.out.printf("Message lock lost for message: %s%n", context.getException());
       } else if (reason == ServiceBusFailureReason.SERVICE_BUSY) {
           try {
               // Choosing an arbitrary amount of time to wait until trying again.
               TimeUnit.SECONDS.sleep(1);
           } catch (InterruptedException e) {
               System.err.println("Unable to sleep for period of time");
           }
       } else {
           System.out.printf("Error source %s, reason %s, message: %s%n", context.getErrorSource(),
               reason, context.getException());
       }
   }
   

4. Aktualisieren Sie die main-Methode, um die Methoden sendMessage, sendMessageBatch und receiveMessages aufzurufen und InterruptedException auszulösen.

   public static void main(String[] args) throws InterruptedException {
       sendMessage();
       sendMessageBatch();
       receiveMessages();
   }
   

Ausführen der App

Sent a single message to the queue: myqueue
Sent a batch of messages to the queue: myqueue
Starting the processor
Processing message. Session: 88d961dd801f449e9c3e0f8a5393a527, Sequence #: 1. Contents: Hello, World!
Processing message. Session: e90c8d9039ce403bbe1d0ec7038033a0, Sequence #: 2. Contents: First message
Processing message. Session: 311a216a560c47d184f9831984e6ac1d, Sequence #: 3. Contents: Second message
Processing message. Session: f9a871be07414baf9505f2c3d466c4ab, Sequence #: 4. Contents: Third message
Stopping and closing the processor

Auf der Seite Übersicht für den Service Bus-Namespace im Azure-Portal wird die Anzahl eingehender und ausgehender Nachrichten angezeigt. Warten Sie etwa eine Minute lang, und aktualisieren Sie die Seite dann, damit die neuesten Werte angezeigt werden.

Wählen Sie auf der Seite Übersicht die Warteschlange aus, um zur Seite Service Bus-Warteschlange zu navigieren. Auf dieser Seite wird auch die Anzahl eingehender und ausgehender Nachrichten angezeigt. Darüber hinaus werden noch weitere Informationen wie etwa die aktuelle Größe der Warteschlange, die maximale Größe und die Anzahl aktiver Nachrichten angezeigt.

Nächste Schritte

Weitere Informationen finden Sie in der folgenden Dokumentation bzw. unter den folgenden Beispielen:

• Azure Service Bus-Clientbibliothek für Java: Infodatei
• Beispiele bei GitHub
• Java-API-Referenz