Použití služby Azure Service Bus v aplikacích Spring

V tomto článku se dozvíte, jak používat Azure Service Bus v aplikacích Java vytvořených pomocí Spring Frameworku.

Azure poskytuje asynchronní platformu zasílání zpráv s názvem Azure Service Bus (Service Bus ), která je založená na standardu AMQP 1.0 (Advanced Message Queueing Protocol 1.0 ). Service Bus můžete používat napříč celou řadou podporovaných platforem Azure.

Spring Cloud Azure poskytuje různé moduly pro odesílání zpráv do front a témat a přijímání zpráv z front a témat služby Service Bus a z odběrů, to vše pomocí frameworků Spring.

Následující moduly můžete použít nezávisle nebo je kombinovat pro různé případy použití:

• Úvodní sada Spring Cloud Azure Service Bus umožňuje odesílat a přijímat zprávy pomocí klientské knihovny sady Service Bus Java SDK s funkcemi Spring Boot.

• Úvodní sada Spring Cloud Azure Service Bus JMS umožňuje používat rozhraní JMS API k odesílání a přijímání zpráv s frontami a tématy/předplatnými služby Service Bus.

• Spring Messaging Azure Service Bus umožňuje interakci se službou Service Bus prostřednictvím rozhraní Spring Messaging API.

• Spring Integration Azure Service Bus umožňuje připojit kanály Spring Integration Message Channels se službou Service Bus.

• Spring Cloud Stream Binder pro Service Bus umožňuje používat Service Bus jako middleware zasílání zpráv v aplikacích Spring Cloud Stream.

Požadavky

• Předplatné Azure – vytvořte si ho zdarma.
• Java Development Kit (JDK) verze 8 nebo vyšší.
• Apache Maven verze 3.0 nebo vyšší.
• Azure Service Bus a fronta nebo téma/předplatné. Pokud ho nemáte, vytvořte frontu nebo topik služby Service Bus. Další informace najdete v tématu Použití Azure Portal k vytvoření oboru názvů služby Service Bus a fronty nebo Použití Azure Portal k vytvoření tématu služby Service Bus a odběrů k tomuto tématu.
• Pokud nemáte aplikaci Spring Boot, vytvořte projekt Maven pomocí aplikace Spring Initializr. Nezapomeňte vybrat projekt Maven a v části Závislosti přidejte závislost Spring Web a pak vyberte Javu verze 8 nebo vyšší.

Poznámka:

Pokud chcete účtu udělit přístup k prostředkům služby Service Bus, přiřaďte v nově vytvořeném oboru názvů služby Azure Service Bus roli Odesílatele dat služby Azure Service Bus a roli Příjemce dat služby Azure Service Bus k účtu Microsoft Entra, který aktuálně používáte. Další informace najdete v tématu Přiřazení rolí Azure pomocí webu Azure Portal.

Důležité

K dokončení kroků v tomto kurzu se vyžaduje Spring Boot verze 2.5 nebo vyšší.

Příprava místního prostředí

V tomto kurzu konfigurace a kód nemají žádné ověřovací operace. Připojení ke službě Azure ale vyžaduje ověření. K dokončení ověřování je potřeba použít klientskou knihovnu Azure Identity. Spring Cloud Azure používá DefaultAzureCredential, kterou poskytuje knihovna identit Azure, která vám pomůže získat přihlašovací údaje bez jakýchkoli změn kódu.

DefaultAzureCredential podporuje více metod ověřování a určuje, kterou metodu použít za běhu. Tento přístup umožňuje vaší aplikaci používat různé metody ověřování v různých prostředích , jako jsou místní nebo produkční prostředí, bez implementace kódu specifického pro prostředí. Další informace najdete v části DefaultAzureCredentialpro ověřování aplikací Java hostovaných v Azure.

Pokud chcete k dokončení ověřování v místních vývojových prostředích použít Azure CLI, IntelliJ nebo jiné metody, prohlédni si ověřování Azure ve vývojových prostředích Java. K dokončení ověřování v hostitelských prostředích Azure doporučujeme použít spravovanou identitu. Další informace najdete v tématu Co jsou spravované identity pro prostředky Azure?

Poznámka:

Azure Service Bus pro rozhraní API JMS v současné době nepodporuje DefaultAzureCredential. Pokud používáte Spring JMS se službou Service Bus, ignorujte tento krok.

Použití úvodní sady Spring Cloud Azure Service Bus

Úvodní modul Spring Cloud Azure Service Bus importuje klientskou knihovnu Service Bus Java s architekturou Spring Boot. Spring Cloud Azure a sadu Azure SDK můžete používat společně v nesouvisejících vzorech. Proto můžete v aplikaci Spring dál používat klientské rozhraní API služby Service Bus v Javě.

Přidání závislosti služby Service Bus

Pokud chcete nainstalovat modul Spring Cloud Azure Service Bus Starter, přidejte do souboru pom.xml následující závislosti:

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

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

  Poznámka:

  Pokud používáte Spring Boot 3.0.x-3.4.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 5.23.0.

  Pokud používáte Spring Boot 2.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 4.20.0.

  Tato faktura materiálu (KUSOVNÍK) by měla být nakonfigurovaná v <dependencyManagement> části souboru pom.xml . Tím se zajistí, že všechny závislosti Azure Spring Cloudu budou používat stejnou verzi.

  Další informace o verzi použité pro tuto kusovníku najdete v tématu Jakou verzi Spring Cloud Azure mám použít.

• Artefakt Spring Cloud Azure Service Bus:

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

Kódování aplikace pro odesílání a příjem zpráv

V této příručce se naučíte používat klienty Service Bus Java v kontextu aplikace Spring. Zde představujeme dvě alternativy. Doporučeným způsobem je použít automatickou konfiguraci Spring Boot a používat předem používané klienty z kontextu Spring. Alternativním způsobem je vytvářet klienty prostřednictvím kódu programu.

První způsob, který zahrnuje automatické propojení klientských beanů z kontejneru Spring IoC, má v porovnání s druhým způsobem následující výhody. Tyto výhody poskytují flexibilnější a efektivnější prostředí při vývoji s využitím klientů služby Service Bus.

• Můžete použít externalizovanou konfiguraci , abyste mohli pracovat se stejným kódem aplikace v různých prostředích.

• Proces učení modelu tvůrce a registraci tohoto klienta můžete delegovat do kontextu aplikace do architektury Spring Boot. Toto delegování vám umožní zaměřit se na to, jak používat klienty s vlastními obchodními požadavky.

• Indikátor stavu můžete snadno použít ke kontrole stavu a stavu aplikace a interních komponent.

Následující příklad kódu ukazuje, jak používat ServiceBusSenderClient a ServiceBusProcessorClient s těmito dvěma alternativami.

Poznámka:

Sada Azure Java SDK pro Service Bus poskytuje více klientům pro interakci se službou Service Bus. Startér také poskytuje autokonfiguraci pro všechny klienty Service Bus a tvůrce klientů. Zde používáme pouze ServiceBusSenderClient a ServiceBusProcessorClient jako příklady.

Použití funkce Spring Boot Autoconfiguration

Pokud chcete odesílat zprávy do služby Service Bus a přijímat zprávy, nakonfigurujte aplikaci pomocí následujícího postupu:

1. Nakonfigurujte obor názvů a frontu služby Service Bus, jak je znázorněno v následujícím příkladu:

   spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
   spring.cloud.azure.servicebus.entity-name=<your-servicebus-queue-name>
   spring.cloud.azure.servicebus.entity-type=queue
   

   Návod

   Tady jako příklad používáme frontu služby Service Bus. Pokud chcete použít téma nebo předplatné, musíte přidat spring.cloud.azure.servicebus.processor.subscription-name vlastnost a změnit entity-type hodnotu na topic.

2. Vytvořte novou ServiceBusProcessorClientConfiguration třídu Java, jak je znázorněno v následujícím příkladu. Tato třída slouží k registraci obslužné rutiny zpráv a chyb pro ServiceBusProcessorClient.

   @Configuration(proxyBeanMethods = false)
   public class ServiceBusProcessorClientConfiguration {
   
       @Bean
       ServiceBusRecordMessageListener processMessage() {
           return context -> {
               ServiceBusReceivedMessage message = context.getMessage();
               System.out.printf("Processing message. Id: %s, Sequence #: %s. Contents: %s%n", message.getMessageId(),
                       message.getSequenceNumber(), message.getBody());
           };
       }
   
       @Bean
       ServiceBusErrorHandler processError() {
           return context -> {
               System.out.printf("Error when receiving messages from namespace: '%s'. Entity: '%s'%n",
                       context.getFullyQualifiedNamespace(), context.getEntityPath());
           };
       }
   }
   

3. Vložte ServiceBusSenderClient do vaší aplikace Spring a volejte související API k odesílání zpráv, jak je znázorněno v následujícím příkladu:

   @SpringBootApplication
   public class ServiceBusQueueApplication implements CommandLineRunner {
   
       private final ServiceBusSenderClient senderClient;
   
       public ServiceBusQueueApplication(ServiceBusSenderClient senderClient) {
           this.senderClient = senderClient;
       }
   
       public static void main(String[] args) {
           SpringApplication.run(ServiceBusQueueApplication.class, args);
       }
   
       @Override
       public void run(String... args) throws Exception {
           // send one message to the queue
           senderClient.sendMessage(new ServiceBusMessage("Hello, World!"));
           System.out.printf("Sent a message to the queue");
           senderClient.close();
   
           // wait the processor client to consume messages
           TimeUnit.SECONDS.sleep(10);
       }
   
   }
   

   Poznámka:

   Ve výchozím nastavení je životní cyklus autowired ServiceBusProcessorClient bean spravován kontextem Spring. Procesor se automaticky spustí při spuštění kontextu aplikace Spring a zastaví se při zastavení kontextu aplikace Spring. Chcete-li tuto funkci zakázat, nakonfigurujte spring.cloud.azure.servicebus.processor.auto-startup=false.

4. Spusťte aplikaci. Zobrazí se protokoly podobné následujícímu příkladu:

   Sent a message to the queue
   Processing message. Id: 6f405435200047069a3caf80893a80bc, Sequence #: 1. Contents: Hello, World!
   

Programové sestavování klientů služby Service Bus

Klientské komponenty si můžete sestavit sami, ale proces je komplikovaný. V aplikacích Spring Boot musíte spravovat vlastnosti, zjistit vzor tvůrce a zaregistrovat klienta do kontextu aplikace Spring. Následující příklad kódu ukazuje, jak to udělat:

1. Vytvořte novou ServiceBusClientConfiguration třídu Java, jak je znázorněno v následujícím příkladu. Tato třída se používá k deklaraci ServiceBusSenderClient a ServiceBusProcessorClient beanů.

   @Configuration(proxyBeanMethods = false)
   public class ServiceBusClientConfiguration {
   
       private static final String SERVICE_BUS_FQDN = "<service-bus-fully-qualified-namespace>";
       private static final String QUEUE_NAME = "<service-bus-queue-name>";
   
       @Bean
       ServiceBusClientBuilder serviceBusClientBuilder() {
           return new ServiceBusClientBuilder()
                      .fullyQualifiedNamespace(SERVICE_BUS_FQDN)
                      .credential(new DefaultAzureCredentialBuilder().build());
       }
   
       @Bean
       ServiceBusSenderClient serviceBusSenderClient(ServiceBusClientBuilder builder) {
           return builder
                  .sender()
                  .queueName(QUEUE_NAME)
                  .buildClient();
       }
   
       @Bean
       ServiceBusProcessorClient serviceBusProcessorClient(ServiceBusClientBuilder builder) {
           return builder.processor()
                         .queueName(QUEUE_NAME)
                         .processMessage(ServiceBusClientConfiguration::processMessage)
                         .processError(ServiceBusClientConfiguration::processError)
                         .buildProcessorClient();
       }
   
       private static void processMessage(ServiceBusReceivedMessageContext context) {
           ServiceBusReceivedMessage message = context.getMessage();
           System.out.printf("Processing message. Id: %s, Sequence #: %s. Contents: %s%n",
               message.getMessageId(), message.getSequenceNumber(), message.getBody());
       }
   
       private static void processError(ServiceBusErrorContext context) {
           System.out.printf("Error when receiving messages from namespace: '%s'. Entity: '%s'%n",
                   context.getFullyQualifiedNamespace(), context.getEntityPath());
       }
   }
   

   Poznámka:

   Ujistěte se, že nahradíte zástupný symbol <service-bus-fully-qualified-namespace> názvem hostitele Service Bus z portálu Azure. Nahraďte zástupný text <service-bus-queue-name> vlastním názvem fronty nakonfigurovaným ve vašem prostoru názvů služby Service Bus.

2. Do aplikace vložíte klientské boby, jak je znázorněno v následujícím příkladu:

   @SpringBootApplication
   public class ServiceBusQueueApplication implements CommandLineRunner {
   
       private final ServiceBusSenderClient senderClient;
   
       private final ServiceBusProcessorClient processorClient;
   
       public ServiceBusQueueApplication(ServiceBusSenderClient senderClient, ServiceBusProcessorClient processorClient) {
           this.senderClient = senderClient;
           this.processorClient = processorClient;
       }
   
       public static void main(String[] args) {
           SpringApplication.run(ServiceBusQueueApplication.class, args);
       }
   
       @Override
       public void run(String... args) throws Exception {
           // send one message to the queue
           senderClient.sendMessage(new ServiceBusMessage("Hello, World!"));
           System.out.printf("Sent a message to the queue");
           senderClient.close();
   
           System.out.printf("Starting the processor");
           processorClient.start();
           TimeUnit.SECONDS.sleep(10);
           System.out.printf("Stopping and closing the processor");
           processorClient.close();
       }
   
   }
   

3. Spusťte aplikaci. Zobrazí se protokoly podobné následujícímu příkladu:

   Sent a message to the queue
   Starting the processor
   ...
   Processing message. Id: 6f405435200047069a3caf80893a80bc, Sequence #: 1. Contents: Hello, World!
   Stopping and closing the processor
   

Následující seznam ukazuje důvody, proč tento kód není flexibilní nebo elegantní:

• Názvy jmenných prostorů a front, témat nebo odběrů jsou pevně zakódované.
• Pokud používáte @Value k získání konfigurací z prostředí Spring, nebudete mít v souboru application.properties nápovědu IDE.
• Pokud máte scénář mikroslužby, musíte kód v každém projektu duplikovat a je snadné udělat chyby a těžko být konzistentní.

Naštěstí u Spring Cloud Azure není nutné sestavovat klientské beans. Místo toho můžete přímo vložit boby a použít vlastnosti konfigurace , které už znáte ke konfiguraci služby Service Bus.

Spring Cloud Azure také poskytuje následující globální konfigurace pro různé scénáře. Další informace najdete v části Globální konfigurace sad SDK služby Azure v rámci konfigurace Spring Cloud Azure.

• Možnosti proxy serveru.
• Možnosti opakování
• Možnosti přenosového klienta AMQP

Můžete se také připojit k různým cloudům Azure. Další informace najdete v tématu Připojení k různým cloudům Azure.

Použijte Spring Cloud Azure Service Bus JMS Starter

Úvodní modul Spring Cloud Azure Service Bus JMS poskytuje integraci Spring JMS se službou Service Bus. Následující video popisuje, jak integrovat aplikace Spring JMS se službou Azure Service Bus pomocí JMS 2.0.

Tato příručka vám ukáže, jak pomocí Spring Cloud Azure Service Bus Starteru pro rozhraní JMS API odesílat zprávy do služby Service Bus a přijímat je ze služby.

Přidání závislosti služby Service Bus

Pokud chcete nainstalovat modul Spring Cloud Azure Service Bus JMS Starter, přidejte do souboru pom.xml následující závislosti:

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

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

  Poznámka:

  Pokud používáte Spring Boot 3.0.x-3.4.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 5.23.0.

  Pokud používáte Spring Boot 2.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 4.20.0.

  Tato faktura materiálu (KUSOVNÍK) by měla být nakonfigurovaná v <dependencyManagement> části souboru pom.xml . Tím se zajistí, že všechny závislosti Azure Spring Cloudu budou používat stejnou verzi.

  Další informace o verzi použité pro tuto kusovníku najdete v tématu Jakou verzi Spring Cloud Azure mám použít.

• Artefakt JMS služby Azure Service Bus pro Spring Cloud

  <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter-servicebus-jms</artifactId>
  </dependency>
  

Kódování aplikace pro odesílání a příjem zpráv

1. Nakonfigurujte připojovací řetězec a cenovou úroveň služby Service Bus, jak je znázorněno v následujícím příkladu:

   spring.jms.servicebus.connection-string=<service-bus-namespace-connection-string>
   spring.jms.servicebus.pricing-tier=<service-bus-pricing-tier>
   

2. Vytvořte příjemce zprávy.

   Spring poskytuje prostředky k publikování zpráv do libovolného objektu POJO (Plain Old Java Object). Nejprve definujte obecnou User třídu, která ukládá a načítá jméno uživatele, jak je znázorněno v následujícím příkladu:

   public class User implements Serializable {
   
       private static final long serialVersionUID = -295422703255886286L;
   
       private String name;
   
       public User() {
       }
   
       public User(String name) {
           setName(name);
       }
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   }
   

   Návod

   Serializable se implementuje tak, aby se použila metoda send v rámci JmsTemplate v architektuře Spring. Jinak byste měli definovat vlastní MessageConverter bean pro serializaci obsahu do formátu JSON v textovém formátu. Další informace najdete MessageConverterv oficiálním úvodním projektu Spring JMS.

3. Odtud můžete vytvořit novou QueueReceiveService třídu Java, jak je znázorněno v následujícím příkladu. Tato třída slouží k definování příjemce zprávy.

   @Component
   public class QueueReceiveService {
   
       private static final String QUEUE_NAME = "<service-bus-queue-name>";
   
       @JmsListener(destination = QUEUE_NAME, containerFactory = "jmsListenerContainerFactory")
       public void receiveMessage(User user) {
           System.out.printf("Received a message from %s.", user.getName());
       }
   }
   

   Poznámka:

   Nezapomeňte nahradit zástupný symbol <service-bus-queue-name> vlastním názvem fronty, který je nakonfigurován ve vašem oboru názvů služby Service Bus.

   Pokud používáte téma nebo předplatné, změňte destination parametr jako název tématu a containerFactory měl by být topicJmsListenerContainerFactory. Přidejte také parametr subscription pro popis názvu předplatného.

4. Vytvořte odesílatele a příjemce, aby odesílali a přijímali zprávy pomocí Springu, jak je znázorněno v následujícím příkladu:

   @SpringBootApplication
   @EnableJms
   public class ServiceBusJmsStarterApplication {
   
       private static final String QUEUE_NAME = "<service-bus-queue-name>";
   
       public static void main(String[] args) {
           ConfigurableApplicationContext context = SpringApplication.run(ServiceBusJMSQueueApplication.class, args);
           JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);
   
           // Send a message with a POJO - the template reuse the message converter
           System.out.println("Sending a user message.");
           jmsTemplate.convertAndSend(QUEUE_NAME, new User("Tom"));
       }
   }
   

   Poznámka:

   Nezapomeňte nahradit zástupný symbol <service-bus-queue-name> vlastním názvem fronty, který je nakonfigurován ve vašem oboru názvů služby Service Bus.

   Návod

   Nezapomeňte přidat anotaci @EnableIntegration, která spustí vyhledávání metod s anotací @JmsListener a automaticky vytvoří posluchačský kontejner pro zpracování zpráv na pozadí.

5. Spusťte aplikaci. Zobrazí se protokoly podobné následujícímu příkladu:

   Sending a user message.
   Received a message from Tom.
   

Další informace

Další informace najdete v tématu Použití rozhraní JMS API se službou Service Bus a AMQP 1.0.

Použití služby Spring Messaging v Azure Service Bus

Modul Spring Messaging Azure Service Bus poskytuje podporu pro architekturu Spring Messaging se službou Service Bus.

Pokud používáte Spring Messaging Azure Service Bus, můžete použít následující funkce:

• ServiceBusTemplate: odesílání zpráv do front a témat služby Service Bus asynchronně a synchronně.
• @ServiceBusListener: Označte metodu jako cíl naslouchání zpráv služby Service Bus na cílovém místě.

V této příručce se dozvíte, jak pomocí služby Spring Messaging Azure Service Bus odesílat zprávy a přijímat zprávy ze služby Service Bus.

Přidání závislosti služby Service Bus

Pokud chcete nainstalovat modul Spring Messaging azure Service Bus, přidejte do souboru pom.xml následující závislosti:

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

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

  Poznámka:

  Pokud používáte Spring Boot 3.0.x-3.4.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 5.23.0.

  Pokud používáte Spring Boot 2.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 4.20.0.

  Tato faktura materiálu (KUSOVNÍK) by měla být nakonfigurovaná v <dependencyManagement> části souboru pom.xml . Tím se zajistí, že všechny závislosti Azure Spring Cloudu budou používat stejnou verzi.

  Další informace o verzi použité pro tuto kusovníku najdete v tématu Jakou verzi Spring Cloud Azure mám použít.

• Úvodní artefakty Spring Messaging Service Bus a Spring Cloud v Azure:

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

Kódování aplikace pro odesílání a příjem zpráv

1. Nakonfigurujte obor názvů a typ fronty pro vaši službu Service Bus, jak je znázorněno v následujícím příkladu.

   spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
   spring.cloud.azure.servicebus.entity-type=queue
   

   Poznámka:

   Pokud používáte téma nebo předplatné, změňte spring.cloud.azure.servicebus.entity-type hodnotu na topic.

2. Vytvořte novou ConsumerService třídu Java, jak je znázorněno v následujícím příkladu. Tato třída slouží k definování příjemce zprávy.

   @Service
   public class ConsumerService {
   
       private static final String QUEUE_NAME = "<service-bus-queue-name>";
   
       @ServiceBusListener(destination = QUEUE_NAME)
       public void handleMessageFromServiceBus(String message) {
           System.out.printf("Consume message: %s%n", message);
       }
   
   }
   

   Poznámka:

   Pokud používáte téma nebo předplatné, změňte parametr poznámky destination jako název tématu a přidejte group parametr pro popis názvu předplatného.

3. Vytvořte odesílatele a příjemce, aby odesílali a přijímali zprávy pomocí Springu, jak je znázorněno v následujícím příkladu:

   @SpringBootApplication
   @EnableAzureMessaging
   public class Application {
   
       private static final String QUEUE_NAME = "<service-bus-queue-name>";
   
       public static void main(String[] args) {
           ConfigurableApplicationContext applicationContext = SpringApplication.run(Application.class);
           ServiceBusTemplate serviceBusTemplate = applicationContext.getBean(ServiceBusTemplate.class);
           System.out.println("Sending a message to the queue.");
           serviceBusTemplate.sendAsync(QUEUE_NAME, MessageBuilder.withPayload("Hello world").build()).subscribe();
       }
   }
   

   Návod

   Nezapomeňte přidat anotaci @EnableAzureMessaging, která spustí vyhledávání metod s anotací @ServiceBusListener a automaticky vytvoří posluchačský kontejner pro zpracování zpráv na pozadí.

4. Spusťte aplikaci. Zobrazí se protokoly podobné následujícímu příkladu:

   Sending a message to the queue.
   Consume message: Hello world.
   

Použití služby Spring Integration Azure Service Bus

Modul Spring Integration Azure Service Bus poskytuje podporu pro architekturu integrace Spring se službou Service Bus.

Pokud vaše aplikace Spring používá kanály zpráv Spring Integration, můžete směrovat zprávy mezi kanály zpráv a Service Bus pomocí adaptérů kanálů.

Adaptér příchozího kanálu předává zprávy z fronty služby Service Bus nebo odběru kanálu zpráv. Adaptér vystupujícího kanálu publikuje zprávy z kanálu zpráv do fronty nebo tématu služby Service Bus.

V této příručce se dozvíte, jak pomocí Spring Integration Azure Service Bus odesílat a přijímat zprávy.

Přidání závislosti služby Service Bus

Pokud chcete nainstalovat modul Spring Cloud Azure Service Bus Integration Starter, přidejte do souboru pom.xml následující závislosti:

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

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

  Poznámka:

  Pokud používáte Spring Boot 3.0.x-3.4.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 5.23.0.

  Pokud používáte Spring Boot 2.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 4.20.0.

  Tato faktura materiálu (KUSOVNÍK) by měla být nakonfigurovaná v <dependencyManagement> části souboru pom.xml . Tím se zajistí, že všechny závislosti Azure Spring Cloudu budou používat stejnou verzi.

  Další informace o verzi použité pro tuto kusovníku najdete v tématu Jakou verzi Spring Cloud Azure mám použít.

• Artefakt integrace služby Spring Cloud Azure Service Bus

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

Kódování aplikace pro odesílání a příjem zpráv

1. Nakonfigurujte obor názvů služby Service Bus, jak je znázorněno v následujícím příkladu:

   spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
   

2. Vytvořte novou QueueReceiveConfiguration třídu Java, jak je znázorněno v následujícím příkladu. Tato třída slouží k definování příjemce zprávy.

   @Configuration
   public class QueueReceiveConfiguration {
   
       private static final String INPUT_CHANNEL = "queue.input";
       private static final String QUEUE_NAME = "<your-servicebus-queue-name>";
       private static final String SERVICE_BUS_MESSAGE_LISTENER_CONTAINER = "queue-listener-container";
   
       /**
        * This message receiver binding with {@link ServiceBusInboundChannelAdapter}
        * via {@link MessageChannel} has name {@value INPUT_CHANNEL}
        */
       @ServiceActivator(inputChannel = INPUT_CHANNEL)
       public void messageReceiver(byte[] payload) {
           String message = new String(payload);
           System.out.printf("New message received: '%s'%n", message);
       }
   
       @Bean(SERVICE_BUS_MESSAGE_LISTENER_CONTAINER)
       public ServiceBusMessageListenerContainer messageListenerContainer(ServiceBusProcessorFactory processorFactory) {
           ServiceBusContainerProperties containerProperties = new ServiceBusContainerProperties();
           containerProperties.setEntityName(QUEUE_NAME);
           return new ServiceBusMessageListenerContainer(processorFactory, containerProperties);
       }
   
       @Bean
       public ServiceBusInboundChannelAdapter queueMessageChannelAdapter(
           @Qualifier(INPUT_CHANNEL) MessageChannel inputChannel,
           @Qualifier(SERVICE_BUS_MESSAGE_LISTENER_CONTAINER) ServiceBusMessageListenerContainer listenerContainer) {
           ServiceBusInboundChannelAdapter adapter = new ServiceBusInboundChannelAdapter(listenerContainer);
           adapter.setOutputChannel(inputChannel);
           return adapter;
       }
   
       @Bean(name = INPUT_CHANNEL)
       public MessageChannel input() {
           return new DirectChannel();
       }
   }
   

3. Vytvořte novou QueueSendConfiguration třídu Java, jak je znázorněno v následujícím příkladu. Tato třída slouží k definování odesílatele zprávy.

   @Configuration
   public class QueueSendConfiguration {
   
       private static final String OUTPUT_CHANNEL = "queue.output";
       private static final String QUEUE_NAME = "<your-servicebus-queue-name>";
   
       @Bean
       @ServiceActivator(inputChannel = OUTPUT_CHANNEL)
       public MessageHandler queueMessageSender(ServiceBusTemplate serviceBusTemplate) {
           serviceBusTemplate.setDefaultEntityType(ServiceBusEntityType.QUEUE);
           DefaultMessageHandler handler = new DefaultMessageHandler(QUEUE_NAME, serviceBusTemplate);
           handler.setSendCallback(new ListenableFutureCallback<Void>() {
               @Override
               public void onSuccess(Void result) {
                   System.out.println("Message was sent successfully.");
               }
   
               @Override
               public void onFailure(Throwable ex) {
                   System.out.println("There was an error sending the message.");
               }
           });
   
           return handler;
       }
   
       /**
        * Message gateway binding with {@link MessageHandler}
        * via {@link MessageChannel} has name {@value OUTPUT_CHANNEL}
        */
       @MessagingGateway(defaultRequestChannel = OUTPUT_CHANNEL)
       public interface QueueOutboundGateway {
           void send(String text);
       }
   }
   

4. Vytvořte odesílatele a příjemce, aby odesílali a přijímali zprávy pomocí Springu, jak je znázorněno v následujícím příkladu:

   @SpringBootApplication
   @EnableIntegration
   @Configuration(proxyBeanMethods = false)
   public class ServiceBusIntegrationApplication {
   
       public static void main(String[] args) {
           ConfigurableApplicationContext applicationContext = SpringApplication.run(ServiceBusIntegrationApplication.class, args);
           QueueSendConfiguration.QueueOutboundGateway outboundGateway = applicationContext.getBean(QueueSendConfiguration.QueueOutboundGateway.class);
           System.out.println("Sending a message to the queue");
           outboundGateway.send("Hello World");
       }
   
   }
   

   Návod

   Nezapomeňte přidat poznámku @EnableIntegration , která umožňuje infrastrukturu integrace Spring.

5. Spusťte aplikaci. Zobrazí se protokoly podobné následujícímu příkladu:

   Message was sent successfully.
   New message received: 'Hello World'
   

Užijte služby Spring Cloud Stream Service Bus Binder

Pokud chcete volat rozhraní API služby Service Bus v aplikaci Spring Cloud Stream , použijte modul Spring Cloud Azure Service Bus Stream Binder.

V tomto průvodci se dozvíte, jak pomocí Spring Cloud Stream Service Bus Binder odesílat a přijímat zprávy z služby Service Bus.

Přidání závislosti služby Service Bus

Pokud chcete nainstalovat modul Spring Cloud Azure Service Bus Stream Binder, přidejte do souboru pom.xml následující závislosti:

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

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

  Poznámka:

  Pokud používáte Spring Boot 3.0.x-3.4.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 5.23.0.

  Pokud používáte Spring Boot 2.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 4.20.0.

  Tato faktura materiálu (KUSOVNÍK) by měla být nakonfigurovaná v <dependencyManagement> části souboru pom.xml . Tím se zajistí, že všechny závislosti Azure Spring Cloudu budou používat stejnou verzi.

  Další informace o verzi použité pro tuto kusovníku najdete v tématu Jakou verzi Spring Cloud Azure mám použít.

• Artefakt integrace služby Spring Cloud Azure Service Bus

  <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-stream-binder-servicebus</artifactId>
  </dependency>
  

Kódování aplikace pro odesílání a příjem zpráv

1. Nakonfigurujte obor názvů služby Service Bus, jak je znázorněno v následujícím příkladu:

   spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
   

2. Vytvořte příjemce zprávy.

   Pokud chcete aplikaci použít jako příjemce událostí, nakonfigurujte vstupní vazebník zadáním následujících informací:

   • Deklarujte Consumer bean, který definuje logiku zpracování zpráv. Například následující Consumer bean má název consume:

     @Bean
     public Consumer<Message<String>> consume() {
         return message -> {
             System.out.printf("New message received: '%s'.%n", message.getPayload());
         };
     }
     

   • Přidejte konfiguraci pro specifikaci názvu queue určeného pro použití, a to nahrazením zástupného symbolu <service-bus-queue-name>, jak je znázorněno v následujícím příkladu.

     # name for the `Consumer` bean
     spring.cloud.function.definition=consume
     spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-queue-name>
     

     Poznámka:

     Pokud chcete využívat předplatné služby Service Bus, nezapomeňte změnit consume-in-0 vlastnosti vazby, jak je znázorněno v následujícím příkladu:

     spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-topic-name>
     spring.cloud.stream.bindings.consume-in-0.group=<service-bus-subscription-name>
     

3. Vytvořte odesílatele zprávy.

   Pokud chcete aplikaci použít jako zdroj událostí, nakonfigurujte výstupní pořadač zadáním následujících informací:

   • Supplier Definujte bean, který definuje, odkud zprávy pocházejí z vaší aplikace.

     @Bean
     return () -> {
             System.out.println("Sending a message.");
             return MessageBuilder.withPayload("Hello world").build();
         };
     }
     

   • Přidejte konfiguraci pro zadání queue názvu pro odeslání nahrazením zástupného symbolu <your-servicebus-queue-name> v následujícím příkladu:

     # "consume" is added from the previous step
     spring.cloud.function.definition=consume;supply
     spring.cloud.stream.bindings.supply-out-0.destination=<your-servicebus-queue-name>
     spring.cloud.stream.servicebus.bindings.supply-out-0.producer.entity-type=queue
     

     Poznámka:

     Chcete-li odeslat do tématu služby Service Bus, nezapomeňte změnit entity-type na topic.

4. Spusťte aplikaci. Zobrazí se protokoly podobné následujícímu příkladu:

   Sending a message.
   New message received: 'Hello world'.
   

Nasazení do Azure Spring Apps

Teď, když máte aplikaci Spring Boot spuštěnou místně, je čas ji přesunout do produkčního prostředí. Azure Spring Apps usnadňuje nasazování aplikací Spring Boot do Azure bez jakýchkoli změn kódu. Služba spravuje infrastrukturu aplikací Spring, aby se vývojáři mohli soustředit na svůj kód. Azure Spring Apps poskytuje správu životního cyklu pomocí komplexního monitorování a diagnostiky, správy konfigurace, zjišťování služeb, integrace CI/CD, modrých zelených nasazení a dalších. Pokud chcete nasadit aplikaci do Azure Spring Apps, přečtěte si téma Nasazení první aplikace do Azure Spring Apps.

Další kroky

Azure pro vývojáře používající SpringUkázky služby Spring Cloud Azure Service Bus

Viz také

Další informace o dalších úvodních sadě Spring Boot dostupných pro Microsoft Azure najdete v tématu Co je Spring Cloud Azure?