Verwenden Sie Azure Storage-Warteschlangen in Spring-Anwendungen

In diesem Artikel wird die Verwendung von Azure Storage Queue in Java Anwendungen veranschaulicht, die mit Spring Framework erstellt wurden.

Azure Storage Warteschlange implementiert cloudbasierte Warteschlangen, um die Kommunikation zwischen Komponenten einer verteilten Anwendung zu ermöglichen. Jede Warteschlange verwaltet eine Liste von Nachrichten, die von einer Absenderkomponente hinzugefügt und einer Empfängerkomponente verarbeitet werden kann. Bei einer Warteschlange kann Ihre Anwendung entsprechend den Anforderungen sofort skaliert werden.

Spring Cloud Azure bietet verschiedene Module für die Verwendung des Spring Frameworks zum Senden von Nachrichten an und zum Empfangen von Nachrichten von Azure Storage Warteschlangen. Sie können diese Module unabhängig verwenden oder für verschiedene Anwendungsfälle kombinieren, wie in der folgenden Liste beschrieben:

• mit Spring Cloud Azure Storage Queue Starter können Sie Nachrichten mit Speicherwarteschlangen Java SDK-Clientbibliothek mit Spring Boot-Features senden und empfangen.

• mit Spring Messaging Azure Storage Queue können Sie über die API Spring Messaging mit Speicherwarteschlangen interagieren.

• Mit Spring Integration Azure Storage Queue können Sie Spring Integration Message Channels mit Speicherwarteschlangen verbinden.

Voraussetzungen

• Ein Azure-Abonnement – create one for free.

• Java Development Kit (JDK), Version 8 oder höher.

• Apache Maven.

• Azure CLI.

• Ein Azure Storage Konto und Azure Warteschlangen. Wenn Sie nicht über diese Ressourcen verfügen, erstellen Sie zuerst ein Speicherkonto, und erstellen Sie dann eine Warteschlange. Weitere Informationen finden Sie unter Speicherkonto erstellen und dem Abschnitt Warteschlange erstellen von Schnellstart: Erstellen Sie eine Warteschlange und fügen Sie eine Nachricht mit dem Azure-Portal hinzu.

• Ein Spring Boot-Anwendung. Wenn Sie keines haben, erstellen Sie mit Spring Initializr ein Maven-Projekt. Wählen Sie Maven Project aus, und fügen Sie unter Dependencies die Spring Web Abhängigkeit hinzu, und wählen Sie dann Java Version 8 oder höher aus.

Hinweis

Um Ihrem Konto Zugriff auf Ressourcen zu gewähren, weisen Sie in Ihrem neu erstellten Azure Storage Konto die rolle Storage Queue Data Contributor dem aktuell verwendeten Microsoft Entra Konto zu. Weitere Informationen finden Sie unter Assign Azure Rollen mithilfe des Azure Portals.

Wichtig

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

Bereiten Sie Ihre lokale Umgebung vor

In diesem Tutorial verfügen die Konfigurationen und der Code nicht über Authentifizierungsvorgänge. Für die Verbindung mit einem Azure-Dienst ist jedoch eine Authentifizierung erforderlich. Um die Authentifizierung abzuschließen, müssen Sie die Azure Identity-Clientbibliothek verwenden. Spring Cloud Azure verwendet DefaultAzureCredential, die die Azure Identity-Bibliothek bereitstellt, 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 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 zum Ausführen der Authentifizierung in lokalen Entwicklungsumgebungen mit Azure CLI, IntelliJ oder anderen Methoden 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?

Verwenden des Spring Cloud Azure Storage Queue Starters

Das Spring Cloud Azure Storage Queue Starter-Modul importiert die Azure Storage Warteschlangen-Clientbibliothek für Java gemeinsam mit dem Spring Boot Framework. Sie können Spring Cloud Azure und die Azure SDK zusammen in einem nicht gegenseitig ausschließenden Muster verwenden. Daher können Sie die Speicherwarteschlange Java Client-API in Ihrer Spring-Anwendung weiterhin verwenden.

Hinzufügen von Abhängigkeiten

Um das Spring Cloud Azure Storage Queue Starter-Modul zu installieren, fügen Sie die folgenden Abhängigkeiten zu Ihrer Datei pom.xml hinzu:

• Die Spring Cloud Azure Bill of Materials (BOM):

  <dependencyManagement>
     <dependencies>
       <dependency>
         <groupId>com.azure.spring</groupId>
         <artifactId>spring-cloud-azure-dependencies</artifactId>
         <version>7.1.0</version>
         <type>pom</type>
         <scope>import</scope>
         </dependency>
     </dependencies>
  </dependencyManagement>
  

  Hinweis

  Wenn Sie Spring Boot 4.0.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 7.1.0festlegen.

  Wenn Sie Spring Boot 3.5.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 6.1.0festlegen.

  Wenn Sie Spring Boot 3.1.x-3.5.x verwenden, stellen Sie sicher, dass Sie die Version spring-cloud-azure-dependencies auf 5.25.0 setzen.

  Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 4.20.0 festlegen.

  Diese Stückliste (Bill of Material, BOM) sollte im Abschnitt <dependencyManagement> Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud-Azure Abhängigkeiten dieselbe Version verwenden.

  Weitere Informationen zur version, die für diese BOM verwendet wird, finden Sie unter Which Version of Spring Cloud Azure Should I Use.

• Das Spring Cloud Azure Queue Storage Warteschlangenartefakt:

  <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter-storage-queue</artifactId>
  </dependency>
  

Codieren Ihrer Anwendung zum Senden und Empfangen von Nachrichten

In diesem Abschnitt erfahren Sie, wie Sie die Azure Queue Storage Clients im Kontext einer Spring-Anwendung verwenden. Sie haben die folgenden zwei Optionen:

• Verwenden Sie die Autokonfiguration von Spring Boot und verwenden Sie fertige Clients aus dem Spring-Kontext (empfohlen).
• Erstellen Sie den Client programmgesteuert.

Mit der automatischen Konfiguration können Sie die Client-Beans aus dem Spring-Kompromittierungsindikator-Container (IoC) automatisch verbinden. Dieser Ansatz bietet Ihnen bei der Entwicklung mit Storage Queue-Clients eine flexiblere und effizientere Erfahrung. Autokonfiguration hat die folgenden Vorteile:

• Autokonfiguration verwendet die externisierte Konfiguration, sodass Sie mit demselben Anwendungscode in verschiedenen Umgebungen arbeiten können.

• Sie können den Prozess des Erlernens des Generatormusters und das Registrieren der Clients im Anwendungskontext an das Spring Boot-Framework delegieren. Sie konzentrieren sich nur darauf, wie Sie die Clients für Ihre eigenen geschäftlichen Anforderungen nutzen können.

• Sie können die Integritätsanzeige verwenden, um den Status und die Integrität Ihrer Anwendung und interner Komponenten zu überprüfen.

Die Codebeispiele in den folgenden Abschnitten zeigen, wie Sie QueueClient mit den beiden beschriebenen Alternativen verwenden können.

Tipp

Azure Java SDK für die Speicherwarteschlange stellt mehrere Clients für die Interaktion mit der Speicherwarteschlange bereit. Der Starter bietet auch die automatische Konfiguration für alle Storage Queue-Clients und Client-Generatoren. In diesem Artikel wird nur QueueClient als Beispiel verwendet.

Verwenden der Autokonfiguration von Spring Boot

Wenn Sie Nachrichten an Azure Storage Warteschlangen senden und empfangen möchten, führen Sie die folgenden Schritte aus, um die Anwendung zu konfigurieren:

1. Konfigurieren Sie Ihren Speicherkontonamen und den Warteschlangennamen, wie im folgenden Beispiel gezeigt:

   spring.cloud.azure.storage.queue.account-name=<your-storage-account-name>
   spring.cloud.azure.storage.queue.queue-name=<your-storage-queue-name>
   

2. Fügen Sie die QueueClient in Ihre Spring-Anwendung ein, und rufen Sie die zugehörigen APIs zum Senden von Nachrichten auf, wie im folgenden Beispiel gezeigt:

   import com.azure.storage.queue.QueueClient;
   import com.azure.storage.queue.models.QueueMessageItem;
   import com.azure.storage.queue.models.SendMessageResult;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   public class StorageQueueClientApplication implements CommandLineRunner {
   
       private final static Logger logger = LoggerFactory.getLogger(StorageQueueClientApplication.class);
   
       @Autowired
       private QueueClient queueClient;
   
       public static void main(String[] args) {
           SpringApplication.run(StorageQueueClientApplication.class, args);
       }
   
       @Override
       public void run(String... args) {
        // Using the QueueClient object, call the create method to create the queue in your storage account.
           queueClient.create();
           SendMessageResult sendMessageResult = queueClient.sendMessage("Hello world");
           logger.info("Send message id: {}", sendMessageResult.getMessageId());
   
           QueueMessageItem queueMessageItem = queueClient.receiveMessage();
           logger.info("Received message: {}", new String(queueMessageItem.getBody().toBytes()));
       }
   
   }
   

3. Starten Sie die Anwendung. Nach dem Start erzeugt die Anwendung Protokolle ähnlich dem folgenden Beispiel:

   Send message id: ...
   Received message: Hello world
   

Erstellen Sie den Client programmgesteuert

Sie können die Client Beans selbst erstellen, aber das Verfahren ist kompliziert. In Spring Boot-Anwendungen müssen Sie Eigenschaften verwalten, das Generatormuster erlernen und die Clients in Ihrem Spring-Anwendungskontext registrieren. Die folgenden Schritte veranschaulichen die Vorgehensweise.

1. Erstellen Sie den Client programmgesteuert in Ihrer Spring-Anwendung, wie im folgenden Beispiel gezeigt. Ersetzen Sie den <storage-account-name> Platzhalter durch Ihren eigenen Wert.

   import com.azure.identity.DefaultAzureCredentialBuilder;
   import com.azure.storage.queue.QueueClient;
   import com.azure.storage.queue.QueueClientBuilder;
   import com.azure.storage.queue.models.QueueMessageItem;
   import com.azure.storage.queue.models.SendMessageResult;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   public class StorageQueueClientApplication implements CommandLineRunner {
   
       private final static String queueName = "test-queue";
       private final static String endpoint = "https://<storage-account-name>.queue.core.windows.net/";
       private final static Logger logger = LoggerFactory.getLogger(StorageQueueClientApplication.class);
   
       QueueClient queueClient = new QueueClientBuilder()
           .endpoint(endpoint)
           .queueName(queueName)
           .credential(new DefaultAzureCredentialBuilder().build())
           .buildClient();
   
       public static void main(String[] args) {
           SpringApplication.run(StorageQueueClientApplication.class, args);
       }
   
       @Override
       public void run(String... args) {
        // Using the QueueClient object, call the create method to create the queue in your storage account.
           queueClient.create();
           SendMessageResult sendMessageResult = queueClient.sendMessage("Hello world");
           logger.info("Send message id: {}", sendMessageResult.getMessageId());
   
           QueueMessageItem queueMessageItem = queueClient.receiveMessage();
           logger.info("Received message: {}", new String(queueMessageItem.getBody().toBytes()));
       }
   
   }
   

2. Starten Sie die Anwendung. Nach dem Start erzeugt die Anwendung Protokolle ähnlich dem folgenden Beispiel:

   Send message id: ...
   Received message: Hello world
   

In der folgenden Liste sind Gründe aufgeführt, warum dieser Code nicht flexibel oder elegant ist.

• Die Speicherkonto- und Warteschlangennamen sind fest codiert.
• 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 es mit Spring Cloud Azure nicht erforderlich, die Client-Beans selbst zu erstellen. Stattdessen können Sie sie direkt einfügen und die Konfigurationseigenschaften verwenden, mit denen Sie bereits vertraut sind, um die Storage-Warteschlange zu konfigurieren. Weitere Informationen finden Sie unter Spring Cloud Azure Konfigurationseigenschaften.

Spring Cloud Azure bietet auch die folgenden globalen Konfigurationen für verschiedene Szenarien. Weitere Informationen finden Sie unter Spring Cloud Azure globalen Konfigurationseigenschaften.

• Proxy-Optionen.
• Wiederholungsoptionen.

Sie können auch eine Verbindung mit verschiedenen Azure Clouds herstellen. Weitere Informationen finden Sie unter Connect to different Azure clouds.

Verwenden der Spring Messaging-Azure Storage-Warteschlange

Das Modul Spring Messaging Azure Storage Queue bietet Unterstützung für das Spring Messaging Framework mit Azure Queue Storage.

Wenn Sie Spring Messaging Azure Storage Queue verwenden, können Sie das Feature StorageQueueTemplate verwenden, um Nachrichten asynchron und synchron an Speicherwarteschlangen zu senden.

In den folgenden Abschnitten wird gezeigt, wie Sie Spring Messaging Azure Storage Queue verwenden, um Nachrichten an Speicherwarteschlangen zu senden und nachrichten zu empfangen.

Hinzufügen von Abhängigkeiten

Um das Spring Messaging Azure Storage Queue-Modul zu installieren, fügen Sie der Datei pom.xml 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>7.1.0</version>
         <type>pom</type>
         <scope>import</scope>
         </dependency>
     </dependencies>
  </dependencyManagement>
  

  Hinweis

  Wenn Sie Spring Boot 4.0.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 7.1.0festlegen.

  Wenn Sie Spring Boot 3.5.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 6.1.0festlegen.

  Wenn Sie Spring Boot 3.1.x-3.5.x verwenden, stellen Sie sicher, dass Sie die Version spring-cloud-azure-dependencies auf 5.25.0 setzen.

  Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 4.20.0 festlegen.

  Diese Stückliste (Bill of Material, BOM) sollte im Abschnitt <dependencyManagement> Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud-Azure Abhängigkeiten dieselbe Version verwenden.

  Weitere Informationen zur version, die für diese BOM verwendet wird, finden Sie unter Which Version of Spring Cloud Azure Should I Use.

• Die Spring Cloud Azure Starter und Spring Messaging Storage Queue-Artefakte:

  <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter</artifactId>
  </dependency>
  <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-messaging-azure-storage-queue</artifactId>
  </dependency>
  

Codieren Ihrer Anwendung zum Senden und Empfangen von Nachrichten

Führen Sie die folgenden Schritte aus, um Ihre Anwendung zu konfigurieren und zu codieren:

1. Konfigurieren Sie den Namen des Azure-Speicherkontos für Ihre Storage-Queues, wie im folgenden Beispiel gezeigt:

   spring.cloud.azure.storage.queue.account-name=<your-storage-account-name>
   

2. Verbinden Sie einen Absender und einen Empfänger, um Nachrichten mit Spring zu senden und zu empfangen, wie im folgenden Beispiel gezeigt. Ersetzen Sie den <storage-queue-name> Platzhalter durch Ihren eigenen Wert.

   import com.azure.spring.messaging.AzureHeaders;
   import com.azure.spring.messaging.checkpoint.Checkpointer;
   import com.azure.spring.messaging.storage.queue.core.StorageQueueTemplate;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.beans.factory.annotation.Autowired;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.messaging.Message;
   import org.springframework.messaging.support.MessageBuilder;
   import java.time.Duration;
   
   @SpringBootApplication
   public class StorageQueueMessagingApplication implements CommandLineRunner {
   
       private static final Logger LOGGER = LoggerFactory.getLogger(StorageQueueMessagingApplication.class);
       private static final String STORAGE_QUEUE_NAME = "<storage-queue-name>";
   
       @Autowired
       StorageQueueTemplate storageQueueTemplate;
   
       public static void main(String[] args) {
           SpringApplication.run(StorageQueueMessagingApplication.class, args);
       }
   
       @Override
       public void run(String... args) {
           storageQueueTemplate
               .sendAsync(STORAGE_QUEUE_NAME, MessageBuilder.withPayload("Hello world").build())
               .subscribe();
           LOGGER.info("Message was sent successfully.");
   
           Message<?> message = storageQueueTemplate.receiveAsync(STORAGE_QUEUE_NAME, Duration.ofSeconds(30)).block();
           LOGGER.info("Received message: {}", new String((byte[]) message.getPayload()));
       }
   
   }
   

3. Starten Sie die Anwendung. Nach dem Start erzeugt die Anwendung Protokolle ähnlich dem folgenden Beispiel:

   Message was sent successfully.
   ...
   Received message: Hello World
   

Verwenden von Spring Integration mit Azure Storage Warteschlange

Das Modul Spring Integration Azure Storage Queue bietet Unterstützung für das Spring Integration Framework mit Speicherwarteschlangen.

Wenn Ihre Spring-Anwendung Spring Integration-Nachrichtenkanäle verwendet, können Sie Nachrichten mithilfe von Kanaladaptern zwischen Ihren Nachrichtenkanälen und Storage-Warteschlangen weiterleiten. Ein eingehender Kanaladapter leitet Nachrichten aus einer Storage-Warteschlange an einen Nachrichtenkanal weiter. Ein ausgehender Kanaladapter veröffentlicht Nachrichten aus einem Nachrichtenkanal in einer Speicherwarteschlange.

In den folgenden Abschnitten wird gezeigt, wie Sie spring Integration Azure Storage Queue zum Senden und Empfangen von Nachrichten an und von Speicherwarteschlangen verwenden.

Hinzufügen von Abhängigkeiten

Um das Spring Integration Azure Storage Queue-Modul zu installieren, fügen Sie der Datei pom.xml 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>7.1.0</version>
         <type>pom</type>
         <scope>import</scope>
         </dependency>
     </dependencies>
  </dependencyManagement>
  

  Hinweis

  Wenn Sie Spring Boot 4.0.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 7.1.0festlegen.

  Wenn Sie Spring Boot 3.5.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 6.1.0festlegen.

  Wenn Sie Spring Boot 3.1.x-3.5.x verwenden, stellen Sie sicher, dass Sie die Version spring-cloud-azure-dependencies auf 5.25.0 setzen.

  Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 4.20.0 festlegen.

  Diese Stückliste (Bill of Material, BOM) sollte im Abschnitt <dependencyManagement> Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud-Azure Abhängigkeiten dieselbe Version verwenden.

  Weitere Informationen zur version, die für diese BOM verwendet wird, finden Sie unter Which Version of Spring Cloud Azure Should I Use.

• Die Spring Integration Azure Storage Queue-Artefakte:

  <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter-integration-storage-queue</artifactId>
  </dependency>
  

Codieren Ihrer Anwendung zum Senden und Empfangen von Nachrichten

Führen Sie die folgenden Schritte aus, um Ihre Anwendung zu konfigurieren und zu codieren:

1. Konfigurieren Sie den Namen des Azure-Storage-Kontos für Ihre Warteschlangen für Speicher.

   spring.cloud.azure.storage.queue.account-name=<your-storage-account-name>
   

2. Erstellen Sie eine neue QueueReceiveConfiguration Java-Klasse, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um einen Nachrichtenempfänger zu definieren. Ersetzen Sie den <storage-queue-name> Platzhalter durch Ihren eigenen Wert.

   import com.azure.spring.integration.storage.queue.inbound.StorageQueueMessageSource;
   import com.azure.spring.messaging.AzureHeaders;
   import com.azure.spring.messaging.checkpoint.Checkpointer;
   import com.azure.spring.messaging.storage.queue.core.StorageQueueTemplate;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.integration.annotation.InboundChannelAdapter;
   import org.springframework.integration.annotation.Poller;
   import org.springframework.integration.annotation.ServiceActivator;
   import org.springframework.messaging.handler.annotation.Header;
   
   @Configuration
   public class QueueReceiveConfiguration {
   
       private static final Logger LOGGER = LoggerFactory.getLogger(QueueReceiveConfiguration.class);
       private static final String STORAGE_QUEUE_NAME = "<storage-queue-name>";
       private static final String INPUT_CHANNEL = "input";
   
       @Bean
       @InboundChannelAdapter(channel = INPUT_CHANNEL, poller = @Poller(fixedDelay = "1000"))
       public StorageQueueMessageSource storageQueueMessageSource(StorageQueueTemplate storageQueueTemplate) {
           return new StorageQueueMessageSource(STORAGE_QUEUE_NAME, storageQueueTemplate);
       }
   
       @ServiceActivator(inputChannel = INPUT_CHANNEL)
       public void messageReceiver(byte[] payload, @Header(AzureHeaders.CHECKPOINTER) Checkpointer checkpointer) {
           String message = new String(payload);
           LOGGER.info("Received message: {}", message);
       }
   
   }
   

3. Erstellen Sie eine neue QueueSendConfiguration Java-Klasse, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um einen Nachrichtenabsender zu definieren. Ersetzen Sie den <storage-queue-name> Platzhalter durch Ihren eigenen Wert.

   import com.azure.spring.integration.core.handler.DefaultMessageHandler;
   import com.azure.spring.messaging.storage.queue.core.StorageQueueTemplate;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.integration.annotation.MessagingGateway;
   import org.springframework.integration.annotation.ServiceActivator;
   import org.springframework.messaging.MessageHandler;
   import org.springframework.util.concurrent.ListenableFutureCallback;
   
   @Configuration
   public class QueueSendConfiguration {
   
       private static final Logger LOGGER = LoggerFactory.getLogger(QueueSendConfiguration.class);
       private static final String STORAGE_QUEUE_NAME = "<storage-queue-name>";
       private static final String OUTPUT_CHANNEL = "output";
   
       @Bean
       @ServiceActivator(inputChannel = OUTPUT_CHANNEL)
       public MessageHandler messageSender(StorageQueueTemplate storageQueueTemplate) {
           DefaultMessageHandler handler = new DefaultMessageHandler(STORAGE_QUEUE_NAME, storageQueueTemplate);
           handler.setSendCallback(new ListenableFutureCallback<Void>() {
               @Override
               public void onSuccess(Void result) {
                   LOGGER.info("Message was sent successfully.");
               }
   
               @Override
               public void onFailure(Throwable ex) {
                   LOGGER.info("There was an error sending the message.");
               }
           });
           return handler;
       }
   
       @MessagingGateway(defaultRequestChannel = OUTPUT_CHANNEL)
       public interface StorageQueueOutboundGateway {
           void send(String text);
       }
   
   }
   

4. Verkabeln Sie einen Absender und einen Empfänger, um Nachrichten mit Spring zu senden und zu empfangen.

   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.context.ConfigurableApplicationContext;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.integration.config.EnableIntegration;
   
   @SpringBootApplication
   @EnableIntegration
   @Configuration(proxyBeanMethods = false)
   public class StorageQueueIntegrationApplication {
   
       public static void main(String[] args) {
           ConfigurableApplicationContext applicationContext = SpringApplication.run(StorageQueueIntegrationApplication.class, args);
           QueueSendConfiguration.StorageQueueOutboundGateway storageQueueOutboundGateway = applicationContext.getBeanQueueSendConfiguration.StorageQueueOutboundGateway.class);
           storageQueueOutboundGateway.send("Hello World");
       }
   
   }
   

   Tipp

   Denken Sie daran, die @EnableIntegration Anmerkung hinzuzufügen, die die Spring Integration-Infrastruktur ermöglicht.

5. Starten Sie die Anwendung. Nach dem Start erzeugt die Anwendung Protokolle ähnlich dem folgenden Beispiel:

   Message was sent successfully.
   Received message: 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 auf 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 Lebenszyklusverwaltung mit umfassender Überwachung und Diagnose, Konfigurationsverwaltung, Dienstermittlung, CI/CD-Integration, blaugrünen Bereitstellungen und mehr. Informationen zum Bereitstellen Ihrer Anwendung auf Azure Spring Apps finden Sie unter Deploy your first application to Azure Spring Apps.

Nächste Schritte

Azure für Spring-EntwicklerSpring Cloud Azure Storage Queue Samples

Siehe auch

Weitere Informationen zu den für Microsoft Azure verfügbaren Spring Boot Starters finden Sie unter What is Spring Cloud Azure?