A Azure Storage-üzenetsor használata Spring-alkalmazásokban

Ez a cikk bemutatja, hogyan használható a Azure Storage Queue Java Spring Framework használatával készült alkalmazásokban.

Azure Storage Queue felhőalapú üzenetsorokat implementál az elosztott alkalmazások összetevői közötti kommunikáció engedélyezéséhez. Minden üzenetsor fenntartja a feladó összetevő által felvehető és a fogadó összetevő által feldolgozott üzenetek listáját. Amikor sor van, az alkalmazás azonnal skálázható az igények kielégítése érdekében.

A Spring-keretrendszerek használatával a Spring Cloud Azure különböző modulokat biztosít, amelyek lehetővé teszik az üzenetek küldését az Azure Storage Sorokba és fogadását onnan. Ezeket a modulokat egymástól függetlenül is használhatja, vagy kombinálhatja őket különböző használati esetekhez, az alábbi listában leírtak szerint:

• Spring Cloud Azure Storage Queue Starter lehetővé teszi az üzenetek küldését és fogadását a Storage Queues Java SDK ügyfélkönyvtárával a Spring Boot-funkciókkal.

• Spring Messaging Azure Storage üzenetsor lehetővé teszi a tárolási üzenetsorok használatát a Spring Messaging API-n keresztül.

• Spring Integration Azure Storage Queue lehetővé teszi a Spring Integration Message Channels csatlakoztatását a Storage üzenetsorokhoz.

Előfeltételek

• Egy Azure előfizetés – ingyenes előfizetés.

• Java Fejlesztői készlet (JDK), 8-es vagy újabb verzió.

• Apache Maven.

• Azure CLI.

• Egy Azure Storage fiók és Azure üzenetsorok. Ha nem rendelkezik ezekkel az erőforrásokkal, először hozzon létre egy tárhelyfiókot, majd hozzon létre egy üzenetsort az Azure Queues szolgáltatásban. További információért lásd: Tárfiók létrehozása és a Sor létrehozása szakaszt a Gyorsútmutató: Sor létrehozása és üzenet hozzáadása az Azure-portállal.

• Egy Spring Boot-alkalmazás. Ha még nem rendelkezik ilyennel, hozzon létre egy Maven-projektet a Spring Initializrsegítségével. Mindenképpen válassza a Maven Project lehetőséget, majd a Dependencies területen adja hozzá a Spring web függőséget, majd válassza Java 8-es vagy újabb verziót.

Feljegyzés

Ha hozzáférést szeretne adni a fiókjának az erőforrásokhoz, az újonnan létrehozott Azure Storage fiókjában rendelje hozzá a Storage Queue Data Contributor szerepkört az éppen használt Microsoft Entra fiókhoz. További információkért lásd: Azure szerepkörök hozzárendelése az Azure portálon.

Fontos

Az oktatóanyag lépéseinek elvégzéséhez a Spring Boot 2.5-ös vagy újabb verziójára van szükség.

A helyi környezet előkészítése

Ebben az oktatóanyagban a konfigurációk és a kód nem rendelkeznek hitelesítési műveletekkel. Az Azure szolgáltatáshoz való csatlakozáshoz azonban hitelesítés szükséges. A hitelesítés befejezéséhez a Azure Identity ügyfélkódtárat kell használnia. A Spring Cloud Azure DefaultAzureCredential használ, amelyet az Azure Identitástár biztosít a hitelesítő adatok kódmódosítások nélküli beszerzéséhez.

DefaultAzureCredential több hitelesítési módszert támogat, és meghatározza, hogy melyik metódust használja futásidőben. Ez a megközelítés lehetővé teszi, hogy az alkalmazás különböző hitelesítési módszereket használjon különböző környezetekben – például helyi vagy éles környezetekben – környezetspecifikus kód implementálása nélkül. További információért lásd a DefaultAzureCredential szakaszt a(z) Authenticate Azure által üzemeltetett Java alkalmazások dokumentumban.

Ha Azure CLI, IntelliJ vagy más módszereket szeretne használni a helyi fejlesztési környezetekben történő hitelesítés befejezéséhez, tekintse meg Azure hitelesítést Java fejlesztési környezetekben. A hitelesítés Azure üzemeltetési környezetekben való befejezéséhez ajánlott felügyelt identitást használni. További információ: Mi az Azure-erőforrások felügyelt identitásai?

Spring Cloud Azure Storage Queue Starter használata

A Spring Cloud Azure Storage Queue Starter modul a Spring Boot-keretrendszerrel importál Azure Storage Queue ügyfélkódtárat Java számára. A Spring Cloud Azure és az Azure SDK nem kizárólagosan használható együtt. Így továbbra is használhatja a Storage Queue Java ügyfél API-t a Spring-alkalmazásban.

Függőségek hozzáadása

A Spring Cloud Azure Storage Queue Starter modul telepítéséhez adja hozzá a következő függőségeket a pom.xml fájlhoz:

• A Spring Cloud Azure Anyagjegyzék (BOM):

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

  Feljegyzés

  Ha Spring Boot 4.0.x-et használ, állítsa a verziót a spring-cloud-azure-dependencies következőre 7.4.0: .

  Ha a Spring Boot 3.5.x-et használja, állítsa a verziót a spring-cloud-azure-dependencies következőre 6.5.0: .

  Ha a Spring Boot 3.1.x-3.5.x verziót használja, mindenképpen állítsa be a verziót spring-cloud-azure-dependencies-ra/c1.

  Ha a Spring Boot 2.x-et használja, mindenképpen állítsa be a spring-cloud-azure-dependencies verziót 4.20.0-re.

  Ezt az anyagjegyzéket (BOM) a <dependencyManagement> fájl szakaszában kell konfigurálni. Ez biztosítja, hogy minden Spring Cloud-Azure függőség ugyanazt a verziót használja.

  Az anyagjegyzékhez használt verzióval kapcsolatos további információkért lásd: Melyik verzióját a Spring Cloud Azure-nak érdemes használnom?.

• A Spring Cloud Azure Queue Storage Queue összetevő:

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

Az alkalmazás kódolása üzenetek küldéséhez és fogadásához

Ez a szakasz bemutatja, hogyan használhatja a Azure Queue Storage-ügyfeleket egy Spring-alkalmazás kontextusában. A következő két lehetőség közül választhat:

• Használja a Spring Boot automatikus konfigurálását, és használja a Spring-környezetből származó beépített ügyfeleket (ajánlott).
• Hozza létre a klienst programozás útján.

Az automatikus konfigurációval automatikusan bekötheti az ügyfél beaneket a Spring inversion-of-control (IoC) konténerből. Ez a megközelítés rugalmasabb és hatékonyabb élményt nyújt a Storage Queue-ügyfelekkel való fejlesztés során. Az automatikus konfigurálás az alábbi előnyökkel jár:

• Az automatikus konfigurálás külső konfigurációt használ, hogy ugyanazt az alkalmazáskódot használhassa különböző környezetekben.

• A Spring Boot-keretrendszerbe delegálhatja a szerkesztői minta megismerésének és az ügyfelek alkalmazáskörnyezetbe való regisztrálásának folyamatát. Csak arra összpontosít, hogyan használhatja az ügyfeleket saját üzleti igényei szerint.

• Az állapotjelző használatával megvizsgálhatja az alkalmazás és a belső összetevők állapotát és állapotát.

Az alábbi szakaszokban szereplő kód példák bemutatják, hogyan használható QueueClient a leírt két alternatíva.

Tanács.

Azure Java Tárolási sorhoz készült SDK többféle klienst biztosít a Tárolási sor használatához. A kezdőprogram emellett automatikus konfigurálást is biztosít az összes Storage Queue-ügyfélhez és ügyfélkészítőhöz. Ez a cikk csak példaként használja a QueueClient részt.

A Spring Boot automatikus konfigurációjának használata

Ha üzeneteket szeretne küldeni Azure Storage üzenetsorokra, és üzeneteket szeretne fogadni, az alkalmazás konfigurálásához kövesse az alábbi lépéseket:

1. Konfigurálja a tárfiók nevét és az üzenetsor nevét az alábbi példában látható módon:

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

2. Injektálja a QueueClient Spring-alkalmazásba, és hívja meg a kapcsolódó API-kat üzenetek küldéséhez, ahogyan az alábbi példában látható:

   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. Indítsa el az alkalmazást. Az indítás után az alkalmazás az alábbi példához hasonló naplókat hoz létre:

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

Az ügyfél programozott módon történő felépítése

Az ügyfélkomponenseket önállóan is létrehozhatja, de a folyamat bonyolult. A Spring Boot-alkalmazásokban kezelnie kell a tulajdonságokat, meg kell tanulnia a szerkesztői mintát, és regisztrálnia kell az ügyfeleket a Spring-alkalmazás környezetében. Az alábbi lépések bemutatják, hogyan teheti ezt meg.

1. Hozza létre az ügyfelet programozott módon a Spring-alkalmazásban az alábbi példában látható módon. Mindenképpen cserélje le a <storage-account-name> helyőrzőt a saját értékére.

   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. Indítsa el az alkalmazást. Az indítás után az alkalmazás az alábbi példához hasonló naplókat hoz létre:

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

Az alábbi lista azokat az okokat mutatja be, amelyek miatt a kód nem rugalmas vagy kecses:

• A tárfiókok és az üzenetsorok nevei nehezen kódoltak.
• Ha a Spring-környezetből szeretne @Value konfigurációkat lekérni, az application.properties fájlban nem szerepelhetnek IDE-tippek.
• Ha mikroszolgáltatási forgatókönyve van, minden projektben meg kell duplikálnia a kódot, és könnyen hibázhat, és nehéz konzisztensnek lennie.

Szerencsére a Spring Cloud Azure-rel nem szükséges önállóan elkészíteni a beaneket. Ehelyett közvetlenül injektálhatja őket, és használhatja a már ismert konfigurációs tulajdonságokat a tárolási üzenetsor konfigurálásához. További információért lásd a Spring Cloud Azure konfigurációs tulajdonságait.

A Spring Cloud Azure a következő globális konfigurációkat is biztosítja a különböző forgatókönyvekhez. További információkért lásd: Spring Cloud Azure globális konfigurációs tulajdonságai.

• Proxybeállítások.
• Újrapróbálkozás beállításai.

Különböző Azure felhőkhöz is csatlakozhat. További információ: Kapcsolódás különböző Azure felhőkhöz.

Spring Messaging Azure Storage queue használata

A Spring üzenetküldési Azure Storage sor modul támogatja a Spring üzenetküldési keretrendszert az Azure Queue Storage segítségével.

Ha Spring Messaging Azure Storage Queue szolgáltatást használ, a StorageQueueTemplate funkcióval aszinkron módon és szinkron módon küldhet üzeneteket a tárolási üzenetsorokra.

Az alábbi szakaszok bemutatják, hogyan használhatja a Spring Messaging Azure Storage Queue-ot üzenetek küldésére és fogadására a tárolási üzenetsorokból.

Függőségek hozzáadása

A Spring Messaging Azure Storage Queue modul telepítéséhez adja hozzá a következő függőségeket a pom.xml fájlhoz:

• A Spring Cloud Azure Anyagjegyzék (BOM):

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

  Feljegyzés

  Ha Spring Boot 4.0.x-et használ, állítsa a verziót a spring-cloud-azure-dependencies következőre 7.4.0: .

  Ha a Spring Boot 3.5.x-et használja, állítsa a verziót a spring-cloud-azure-dependencies következőre 6.5.0: .

  Ha a Spring Boot 3.1.x-3.5.x verziót használja, mindenképpen állítsa be a verziót spring-cloud-azure-dependencies-ra/c1.

  Ha a Spring Boot 2.x-et használja, mindenképpen állítsa be a spring-cloud-azure-dependencies verziót 4.20.0-re.

  Ezt az anyagjegyzéket (BOM) a <dependencyManagement> fájl szakaszában kell konfigurálni. Ez biztosítja, hogy minden Spring Cloud-Azure függőség ugyanazt a verziót használja.

  Az anyagjegyzékhez használt verzióval kapcsolatos további információkért lásd: Melyik verzióját a Spring Cloud Azure-nak érdemes használnom?.

• A Spring Cloud Azure kezdő- és Spring Messaging Storage-üzenetsor összetevői:

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

Az alkalmazás kódolása üzenetek küldéséhez és fogadásához

Az alkalmazás konfigurálásához és kódolásához kövesse az alábbi lépéseket:

1. Konfigurálja az Azure Storage fióknevét a tárolási soraihoz az alábbi példában látható módon:

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

2. Küldjön egy feladót és egy fogadót, hogy üzeneteket küldjön és fogadjon a Spring használatával, ahogyan az az alábbi példában látható. Mindenképpen cserélje le a <storage-queue-name> helyőrzőt a saját értékére.

   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. Indítsa el az alkalmazást. Az indítás után az alkalmazás az alábbi példához hasonló naplókat hoz létre:

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

Spring Integration Azure Storage Queue használata

A Spring Integration Azure Storage Queue modul támogatást nyújt a Spring Integration keretrendszerhez a tárolási üzenetsorok használatával.

Ha a Spring-alkalmazás Spring Integration üzenetcsatornákat használ, csatornaadapterekkel irányíthatja az üzeneteket az üzenetcsatornák és a tárolási üzenetsor között. A bejövő csatornaadapter üzeneteket továbbít egy tárolási üzenetsorból egy üzenetcsatornába. A kimenő csatornaadapter üzeneteket tesz közzé egy üzenetcsatornából egy tárolási üzenetsorba.

Az alábbi szakaszok bemutatják, hogyan küldhet és fogadhat üzeneteket a Spring Integration Azure Storage Queue használatával tárolósorokra és tárolósorokból.

Függőségek hozzáadása

A Spring Integration Azure Storage Queue modul telepítéséhez adja hozzá a következő függőségeket a pom.xml fájlhoz:

• A Spring Cloud Azure Anyagjegyzék (BOM):

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

  Feljegyzés

  Ha Spring Boot 4.0.x-et használ, állítsa a verziót a spring-cloud-azure-dependencies következőre 7.4.0: .

  Ha a Spring Boot 3.5.x-et használja, állítsa a verziót a spring-cloud-azure-dependencies következőre 6.5.0: .

  Ha a Spring Boot 3.1.x-3.5.x verziót használja, mindenképpen állítsa be a verziót spring-cloud-azure-dependencies-ra/c1.

  Ha a Spring Boot 2.x-et használja, mindenképpen állítsa be a spring-cloud-azure-dependencies verziót 4.20.0-re.

  Ezt az anyagjegyzéket (BOM) a <dependencyManagement> fájl szakaszában kell konfigurálni. Ez biztosítja, hogy minden Spring Cloud-Azure függőség ugyanazt a verziót használja.

  Az anyagjegyzékhez használt verzióval kapcsolatos további információkért lásd: Melyik verzióját a Spring Cloud Azure-nak érdemes használnom?.

• A Spring Integration Azure Storage Queue-összetevők:

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

Az alkalmazás kódolása üzenetek küldéséhez és fogadásához

Az alkalmazás konfigurálásához és kódolásához kövesse az alábbi lépéseket:

1. Konfigurálja az Azure Storage tárfiók nevét a tárolási sorokhoz.

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

2. Hozzon létre egy új QueueReceiveConfiguration Java osztályt az alábbi példában látható módon. Ez az osztály egy üzenet fogadó definiálására szolgál. Mindenképpen cserélje le a <storage-queue-name> helyőrzőt a saját értékére.

   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. Hozzon létre egy új QueueSendConfiguration Java osztályt az alábbi példában látható módon. Ez az osztály egy üzenetküldő definiálására szolgál. Mindenképpen cserélje le a <storage-queue-name> helyőrzőt a saját értékére.

   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. Küldjön egy feladót és egy fogadót, hogy üzeneteket küldjön és fogadjon a Spring használatával.

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

   Tanács.

   Ne felejtse el hozzáadni a @EnableIntegration megjegyzést, amely lehetővé teszi a Spring Integration-infrastruktúrát.

5. Indítsa el az alkalmazást. Az indítás után az alkalmazás az alábbi példához hasonló naplókat hoz létre:

   Message was sent successfully.
   Received message: Hello World
   

Üzembe helyezés a Azure Spring Apps

Most, hogy a Spring Boot-alkalmazás helyi tesztelés alatt fut, ideje bevezetni éles környezetbe. Azure Spring Apps megkönnyíti a Spring Boot-alkalmazások Azure való üzembe helyezését kódmódosítások nélkül. A szolgáltatás kezeli a Spring-alkalmazások infrastruktúráját, hogy a fejlesztők a kódjukra összpontosíthassanak. Azure Spring Apps teljes körű monitorozás és diagnosztika, konfigurációkezelés, szolgáltatásfelderítés, CI/CD-integráció, kék-zöld környezetek és egyebek használatával biztosítja az életciklus-felügyeletet. Az alkalmazás Azure Spring Apps való üzembe helyezéséről a A Azure Spring Apps első alkalmazás üzembe helyezéséről szóló cikkben olvashat.

Következő lépések

Azure a Spring-fejlesztőknekSpring Cloud Azure Tároló Várólista Minták

Lásd még

A Microsoft Azure elérhető Spring Boot Starterekről további információt a Mi a Spring Cloud Azure?