Korzystanie z kolejki Azure Storage w aplikacjach Spring

W tym artykule pokazano, jak używać Azure Storage Queue w aplikacjach Java utworzonych za pomocą Spring Framework.

Azure Storage Queue implementuje kolejki oparte na chmurze, aby umożliwić komunikację między składnikami aplikacji rozproszonej. Każda kolejka przechowuje listę komunikatów, które mogą być dodawane przez składnik nadawcy i przetwarzane przez składnik odbiorcy. Dzięki kolejce aplikacja może być skalowana natychmiastowo, aby sprostać zapotrzebowaniu.

Spring Cloud Azure udostępnia różne moduły służące do wysyłania i odbierania komunikatów z kolejek Azure Storage. Możesz użyć tych modułów niezależnie lub połączyć je w różnych przypadkach użycia, zgodnie z opisem na poniższej liście:

• Spring Cloud Azure Storage Queue Starter umożliwia wysyłanie i odbieranie komunikatów za pomocą biblioteki klienta zestawu Storage Queues Java SDK z funkcjami platformy Spring Boot.

• Spring Messaging Azure Storage Queue umożliwia interakcję z kolejkami magazynu za pośrednictwem interfejsu API Spring Messaging.

• Spring Integration Azure Storage Queue umożliwia łączenie kanałów Spring Integration Message Channels z kolejkami magazynu.

Wymagania wstępne

• Subskrypcja Azure — utwórz ją bezpłatnie.

• Java Development Kit (JDK) w wersji 8 lub nowszej.

• Apache Maven.

• Interfejs wiersza polecenia platformy Azure.

• Konto Azure Storage i kolejki Azure. Jeśli nie masz tych zasobów, najpierw utwórz konto magazynowe, i następnie utwórz kolejkę. Aby uzyskać więcej informacji, zobacz Tworzenie konta magazynu i Tworzenie kolejki sekcji Quickstart: Tworzenie kolejki i dodawanie komunikatu za pomocą portalu Azure.

• Aplikacja Spring Boot. Jeśli go nie masz, utwórz projekt Maven za pomocą narzędzia Spring Initializr. Pamiętaj, aby wybrać Maven Project i w obszarze Dependencies dodaj Spring Web, a następnie wybierz Java 8 lub nowszą.

Uwaga

Aby przyznać Twojemu kontu dostęp do zasobów, na nowo utworzonym koncie Azure Storage przypisz rolę Storage Queue Data Contributor do konta Microsoft Entra, które obecnie używasz. Aby uzyskać więcej informacji, zobacz Przypisania ról Azure przy użyciu portalu Azure.

Ważne

Do wykonania kroków opisanych w tym samouczku wymagana jest wersja Spring Boot 2.5 lub wyższa.

Przygotowywanie środowiska lokalnego

W tym samouczku konfiguracje i kod nie mają żadnych operacji uwierzytelniania. Jednak nawiązywanie połączenia z usługą Azure wymaga uwierzytelniania. Aby ukończyć uwierzytelnianie, należy użyć biblioteki klienta Azure Identity. Usługa Spring Cloud Azure używa DefaultAzureCredential, którą udostępnia biblioteka Azure Identity, aby ułatwić uzyskiwanie poświadczeń bez żadnych zmian w kodzie.

DefaultAzureCredential obsługuje wiele metod uwierzytelniania i określa, która metoda ma być używana w czasie wykonywania. Takie podejście umożliwia aplikacji używanie różnych metod uwierzytelniania w różnych środowiskach — takich jak środowiska lokalne lub produkcyjne — bez implementowania kodu specyficznego dla środowiska. Aby uzyskać więcej informacji, zobacz sekcję DefaultAzureCredential sekcji Authenticate Azure-hosted Java applications.

Aby użyć Azure CLI, IntelliJ lub innych metod w celu przeprowadzenia uwierzytelniania w lokalnych środowiskach deweloperskich, zobacz uwierzytelnianie Azure w środowiskach Java deweloperskich. Aby ukończyć uwierzytelnianie w środowiskach hostingu Azure, zalecamy użycie tożsamości zarządzanej. Aby uzyskać więcej informacji, zobacz Jak są tożsamości zarządzane dla zasobów Azure?

Użycie Spring Cloud Azure Storage Queue Starter

Moduł startowy Spring Cloud Azure Storage Queue Starter importuje bibliotekę klienta kolejek Azure Storage Queue dla Java w ramach frameworku Spring Boot. Możesz użyć Azure Spring Cloud i Azure SDK razem, w nie wykluczającym się wzorcu. W związku z tym możesz kontynuować korzystanie z interfejsu API Java klienta kolejki Storage w aplikacji Spring.

Dodawanie zależności

Aby zainstalować moduł Spring Cloud Azure Storage Queue Starter, dodaj następujące zależności do pliku pom.xml:

• Projekt 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>
  

  Uwaga

  Jeśli używasz platformy Spring Boot 4.0.x, pamiętaj, aby ustawić spring-cloud-azure-dependencies wersję na 7.1.0.

  Jeśli używasz platformy Spring Boot 3.5.x, pamiętaj, aby ustawić spring-cloud-azure-dependencies wersję na 6.1.0.

  Jeśli używasz platformy Spring Boot 3.1.x-3.5.x, pamiętaj, aby ustawić spring-cloud-azure-dependencies wersję na 5.25.0.

  Jeśli używasz środowiska Spring Boot 2.x, ustaw wersję spring-cloud-azure-dependencies na 4.20.0.

  Tę listę materiałów (BOM) należy skonfigurować w sekcji <dependencyManagement> pliku pom.xml. Dzięki temu wszystkie zależności usługi Spring Cloud Azure korzystają z tej samej wersji.

  Aby uzyskać więcej informacji na temat wersji używanej dla tego modelu BOM, zobacz Jakiej wersji Spring Cloud Azure powinienem użyć.

• Artefakt Spring Cloud Azure Queue Storage Queue

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

Tworzenie kodu aplikacji w celu wysyłania i odbierania komunikatów

W tej sekcji pokazano, jak używać klientów Azure Queue Storage w kontekście aplikacji Spring. Dostępne są następujące dwie opcje:

• Użyj automatycznej konfiguracji platformy Spring Boot i użyj wbudowanych klientów z kontekstu Spring (zalecane).
• Programowe kompilowanie klienta.

Dzięki automatycznej konfiguracji można automatycznie wstrzykiwać beany klienta z kontenera IoC Spring. Takie podejście zapewnia bardziej elastyczne i wydajne środowisko z użyciem klientów kolejki Storage. Automatyczna konfiguracja ma następujące zalety:

• Autokonfiguracja używa konfiguracji zewnętrznej , dzięki czemu można pracować z tym samym kodem aplikacji w różnych środowiskach.

• Możesz delegować do struktury Spring Boot proces uczenia się wzorca konstruktora i rejestrowania klientów w kontekście aplikacji. Skupiasz się tylko na tym, jak używać klientów zgodnie z własnymi wymaganiami biznesowymi.

• Możesz użyć wskaźnika kondycji, aby sprawdzić stan i kondycję aplikacji oraz składników wewnętrznych.

W przykładach kodu w poniższych sekcjach pokazano, jak używać QueueClient z dwoma opisanymi alternatywami.

Napiwek

Azure Java SDK dla kolejki magazynującej zapewnia wiele klientów do interakcji z kolejką magazynującą. Starter zapewnia również automatyczną konfigurację dla wszystkich klientów kolejki magazynu i konstruktorów klientów. W tym artykule użyto tylko QueueClient jako przykładu.

Użyj autokonfiguracji Spring Boot

Aby wysyłać komunikaty do kolejek Azure Storage i odbierać je z nich, wykonaj następujące kroki, aby skonfigurować aplikację:

1. Skonfiguruj nazwę konta magazynowego i nazwę kolejki, jak pokazano w poniższym przykładzie:

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

2. Wstrzykuj element QueueClient w aplikacji Spring i wywołaj powiązane interfejsy API w celu wysyłania komunikatów, jak pokazano w poniższym przykładzie:

   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. Uruchom aplikację. Po uruchomieniu aplikacja generuje dzienniki podobne do następującego przykładu:

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

Programowe kompilowanie klienta

Możesz samodzielnie stworzyć komponenty klienta, ale proces jest skomplikowany. W aplikacjach Spring Boot musisz zarządzać właściwościami, uczyć się wzorca konstruktora i rejestrować klientów w kontekście aplikacji Spring. Poniższe kroki pokazują, jak to zrobić.

1. Skompiluj klienta programowo w aplikacji Spring, jak pokazano w poniższym przykładzie. Pamiętaj, aby zastąpić symbol zastępczy <storage-account-name> własną wartością.

   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. Uruchom aplikację. Po uruchomieniu aplikacja generuje dzienniki podobne do następującego przykładu:

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

Na poniższej liście przedstawiono przyczyny, dla których ten kod nie jest elastyczny ani elegancki.

• Nazwy kont magazynu i kolejek są zakodowane na twardym kodzie.
• Jeśli używasz @Value do pobierania konfiguracji ze środowiska Spring, nie możesz mieć wskazówek IDE w pliku application.properties.
• Jeśli masz scenariusz mikrousług, musisz zduplikować kod w każdym projekcie, a łatwo jest popełnić błędy i trudno trzymać spójność.

Na szczęście samodzielne tworzenie beanów klienta nie jest konieczne dzięki Spring Cloud Azure. Zamiast tego można je bezpośrednio wstrzyknąć i użyć właściwości konfiguracji, które już znasz, aby skonfigurować kolejkę pamięci masowej. Aby uzyskać więcej informacji, zobacz Spring Cloud Azure configuration properties.

Usługa Spring Cloud Azure udostępnia również następujące konfiguracje globalne dla różnych scenariuszy. Aby uzyskać więcej informacji, zobacz Spring Cloud Azure globalne właściwości konfiguracji.

• Opcje serwera proxy.
• Opcje ponawiania prób.

Możesz również nawiązać połączenie z różnymi chmurami Azure. Aby uzyskać więcej informacji, zobacz Połączenie z różnymi chmurami Azure.

Korzystanie z kolejki Azure Storage przy użyciu Spring Messaging

Moduł Spring Messaging Azure Storage Queue zapewnia obsługę platformy Spring Messaging z Azure Queue Storage.

Jeśli używasz Spring Messaging Azure Storage Queue, możesz użyć funkcji StorageQueueTemplate do wysyłania komunikatów do kolejek magazynowych asynchronicznie i synchronicznie.

W poniższych sekcjach pokazano, jak używać Spring Messaging z kolejkami Azure Storage do wysyłania i otrzymywania komunikatów z tych kolejek.

Dodawanie zależności

Aby zainstalować moduł Spring Messaging Azure Storage Queue, dodaj następujące zależności do pliku pom.xml:

• Projekt 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>
  

  Uwaga

  Jeśli używasz platformy Spring Boot 4.0.x, pamiętaj, aby ustawić spring-cloud-azure-dependencies wersję na 7.1.0.

  Jeśli używasz platformy Spring Boot 3.5.x, pamiętaj, aby ustawić spring-cloud-azure-dependencies wersję na 6.1.0.

  Jeśli używasz platformy Spring Boot 3.1.x-3.5.x, pamiętaj, aby ustawić spring-cloud-azure-dependencies wersję na 5.25.0.

  Jeśli używasz środowiska Spring Boot 2.x, ustaw wersję spring-cloud-azure-dependencies na 4.20.0.

  Tę listę materiałów (BOM) należy skonfigurować w sekcji <dependencyManagement> pliku pom.xml. Dzięki temu wszystkie zależności usługi Spring Cloud Azure korzystają z tej samej wersji.

  Aby uzyskać więcej informacji na temat wersji używanej dla tego modelu BOM, zobacz Jakiej wersji Spring Cloud Azure powinienem użyć.

• Artefakty startowe Spring Cloud Azure i kolejki magazynowania Spring Messaging.

  <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>
  

Tworzenie kodu aplikacji w celu wysyłania i odbierania komunikatów

Aby skonfigurować aplikację i kodować aplikację, wykonaj następujące kroki:

1. Skonfiguruj nazwę konta Azure Storage dla kolejek pamięci masowej, jak pokazano w poniższym przykładzie.

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

2. Podłącz nadawcę i odbiorcę do wysyłania i odbierania komunikatów za pomocą platformy Spring, jak pokazano w poniższym przykładzie. Pamiętaj, aby zastąpić symbol zastępczy <storage-queue-name> własną wartością.

   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. Uruchom aplikację. Po uruchomieniu aplikacja generuje dzienniki podobne do następującego przykładu:

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

Użycie kolejki Azure Storage w ramach Spring Integration

Moduł Spring Integration Azure Storage Queue zapewnia obsługę frameworku Spring Integration w kontekście kolejek magazynujących.

Jeśli aplikacja Spring używa kanałów wiadomości Spring Integration, możesz przekazywać wiadomości między kanałami a kolejką magazynującą przy użyciu adapterów kanałów. Adapter kanału przychodzącego przekazuje komunikaty z kolejki przechowywania do kanału wiadomości. Adapter kanału wychodzącego publikuje komunikaty z kanału wiadomości do kolejki magazynu.

W poniższych sekcjach pokazano, jak używać usługi Spring Integration Azure Storage Queue w celu wysyłania i odbierania komunikatów do i z kolejek pamięci masowej.

Dodawanie zależności

Aby zainstalować moduł Spring Integration Azure Storage Queue, dodaj następujące zależności do pliku pom.xml:

• Projekt 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>
  

  Uwaga

  Jeśli używasz platformy Spring Boot 4.0.x, pamiętaj, aby ustawić spring-cloud-azure-dependencies wersję na 7.1.0.

  Jeśli używasz platformy Spring Boot 3.5.x, pamiętaj, aby ustawić spring-cloud-azure-dependencies wersję na 6.1.0.

  Jeśli używasz platformy Spring Boot 3.1.x-3.5.x, pamiętaj, aby ustawić spring-cloud-azure-dependencies wersję na 5.25.0.

  Jeśli używasz środowiska Spring Boot 2.x, ustaw wersję spring-cloud-azure-dependencies na 4.20.0.

  Tę listę materiałów (BOM) należy skonfigurować w sekcji <dependencyManagement> pliku pom.xml. Dzięki temu wszystkie zależności usługi Spring Cloud Azure korzystają z tej samej wersji.

  Aby uzyskać więcej informacji na temat wersji używanej dla tego modelu BOM, zobacz Jakiej wersji Spring Cloud Azure powinienem użyć.

• Artefakty Spring Integration dla Azure Storage Queue.

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

Tworzenie kodu aplikacji w celu wysyłania i odbierania komunikatów

Aby skonfigurować aplikację i kodować aplikację, wykonaj następujące kroki:

1. Aby skonfigurować nazwę konta Azure Storage dla kolejek magazynowania.

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

2. Utwórz nową klasę QueueReceiveConfiguration Java, jak pokazano w poniższym przykładzie. Ta klasa służy do definiowania odbiornika komunikatów. Pamiętaj, aby zastąpić symbol zastępczy <storage-queue-name> własną wartością.

   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. Utwórz nową klasę QueueSendConfiguration Java, jak pokazano w poniższym przykładzie. Ta klasa służy do definiowania nadawcy komunikatów. Pamiętaj, aby zastąpić symbol zastępczy <storage-queue-name> własną wartością.

   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. Podłącz nadawcę i odbiorcę do wysyłania i odbierania komunikatów za pomocą platformy Spring.

   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");
       }
   
   }
   

   Napiwek

   Pamiętaj, aby dodać adnotację @EnableIntegration , która umożliwia korzystanie z infrastruktury integracji spring.

5. Uruchom aplikację. Po uruchomieniu aplikacja generuje dzienniki podobne do następującego przykładu:

   Message was sent successfully.
   Received message: Hello World
   

Wdróż do Azure Spring Apps

Teraz, gdy aplikacja Spring Boot działa lokalnie, nadszedł czas, aby przenieść ją do środowiska produkcyjnego. Azure Spring Apps ułatwia wdrażanie aplikacji Spring Boot w Azure bez żadnych zmian w kodzie. Usługa zarządza infrastrukturą aplikacji Spring, aby deweloperzy mogli skupić się na swoim kodzie. Azure Spring Apps zapewnia zarządzanie cyklem życia przy użyciu kompleksowego monitorowania i diagnostyki, zarządzania konfiguracją, odnajdywania usług, integracji CI/CD, wdrożeń blue-green oraz innych funkcji. Aby wdrożyć swoją pierwszą aplikację do Azure Spring Apps, zobacz Wdrażanie pierwszej aplikacji do Azure Spring Apps.

Następne kroki

Azure dla deweloperów platformy SpringSpring Azure Storage Queue Samples

Zobacz też

Aby uzyskać więcej informacji na temat Spring Boot Starters dostępnych dla Microsoft Azure, zobacz Czym jest Spring Cloud Azure?