Korzystanie z usługi Azure Service Bus w aplikacjach Spring

W tym artykule pokazano, jak używać usługi Azure Service Bus w aplikacjach Java utworzonych za pomocą platformy Spring Framework.

Platforma Azure udostępnia asynchroniczną platformę obsługi komunikatów o nazwie Azure Service Bus (Service Bus ), która jest oparta na standardzie Advanced Message Queueing Protocol 1.0 (AMQP 1.0). Usługę Service Bus można używać na różnych obsługiwanych platformach platformy Azure.

Platforma Spring Cloud Azure udostępnia różne moduły do wysyłania komunikatów do kolejek i tematów usługi Service Bus oraz / przy użyciu platform Spring.

Następujące moduły można użyć niezależnie lub połączyć je w różnych przypadkach użycia:

• Rozwiązanie Spring Cloud Azure Service Bus Starter umożliwia wysyłanie i odbieranie komunikatów za pomocą biblioteki klienta zestawu JAVA SDK usługi Service Bus z funkcjami platformy Spring Boot.

• Spring Cloud Azure Service Bus JMS Starter umożliwia używanie interfejsu API JMS do wysyłania i odbierania komunikatów za pomocą kolejek i tematów/subskrypcji usługi Service Bus.

• Usługa Azure Service Bus spring Messaging umożliwia interakcję z usługą Service Bus za pośrednictwem interfejsu API spring messaging .

• Integracja spring z usługą Azure Service Bus umożliwia łączenie kanałów komunikatów integracji spring z usługą Service Bus.

• Usługa Spring Cloud Stream Binder dla usługi Service Bus umożliwia korzystanie z usługi Service Bus jako oprogramowania pośredniczącego do obsługi komunikatów w aplikacjach Spring Cloud Stream.

• Subskrypcja platformy Azure — utwórz bezpłatnie.
• Zestaw Java Development Kit (JDK) w wersji 8 lub nowszej.
• Apache Maven, wersja 3.0 lub nowsza.
• Usługa Azure Service Bus i kolejka lub temat/subskrypcja. Jeśli go nie masz, utwórz kolejkę lub temat usługi Service Bus. Aby uzyskać więcej informacji, zobacz Tworzenie przestrzeni nazw usługi Service Bus i kolejki za pomocą witryny Azure Portal lub Tworzenie tematu i subskrypcji usługi Service Bus w temacie za pomocą witryny Azure Portal.
• Jeśli nie masz aplikacji Spring Boot, utwórz projekt Maven za pomocą narzędzia Spring Initializr. Pamiętaj, aby wybrać pozycję Projekt Maven i w obszarze Zależności dodaj zależność Spring Web , a następnie wybierz pozycję Java w wersji 8 lub nowszej.

W tym samouczku konfiguracje i kod nie mają żadnych operacji uwierzytelniania. Jednak nawiązywanie połączenia z usługą platformy Azure wymaga uwierzytelniania. Aby ukończyć uwierzytelnianie, należy użyć biblioteki klienta tożsamości platformy Azure. Platforma Spring Cloud na platformie Azure używa DefaultAzureCredentialbiblioteki tożsamości platformy Azure, która ułatwia 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 w temacie Uwierzytelnianie aplikacji Java hostowanych na platformie Azure.

Aby użyć interfejsu wiersza polecenia platformy Azure, środowiska IntelliJ lub innych metod do ukończenia uwierzytelniania w lokalnych środowiskach deweloperskich, zobacz Uwierzytelnianie platformy Azure w środowiskach deweloperskich Java. Aby ukończyć uwierzytelnianie w środowiskach hostingu platformy Azure, zalecamy użycie tożsamości zarządzanej. Aby uzyskać więcej informacji, zobacz Co to są tożsamości zarządzane dla zasobów platformy Azure?

Moduł startowy Spring Cloud Azure Service Bus importuje bibliotekę klienta Java usługi Service Bus z platformą Spring Boot. Platformy Azure i zestawu Azure SDK platformy Spring można używać razem we wzorcu, który nie wyklucza się wzajemnie. W związku z tym możesz nadal używać interfejsu API klienta Java usługi Service Bus w aplikacji Spring.

Aby zainstalować moduł startowy spring Cloud Azure Service Bus, dodaj następujące zależności do pliku pom.xml :

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

  XML Kopiuj

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

  Uwaga

  Jeśli używasz środowiska Spring Boot 2.x, pamiętaj, aby ustawić spring-cloud-azure-dependencies wersję na 4.19.0. Ten rachunek materiału (BOM) należy skonfigurować w <dependencyManagement> sekcji pliku pom.xml . Gwarantuje to, że wszystkie zależności platformy Azure platformy Spring Cloud korzystają z tej samej wersji. Aby uzyskać więcej informacji na temat wersji używanej dla tego modelu BOM, zobacz Która wersja platformy Spring Cloud platformy Azure powinna być używana.

• Artefakt spring Cloud Azure Service Bus:

  XML Kopiuj

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

W tym przewodniku pokazano, jak używać klientów Java usługi Service Bus w kontekście aplikacji Spring. Tutaj wprowadzamy dwie alternatywy. Zalecanym sposobem jest użycie autokonfiguracji spring boot i użycie nieaktualnych klientów z kontekstu Spring. Alternatywnym sposobem jest programowe kompilowanie klientów.

Pierwszy sposób, który obejmuje automatyczne podłączanie fasoli klienta z kontenera Spring IoC, ma następujące zalety w porównaniu z drugą metodą. Te korzyści zapewniają bardziej elastyczne i wydajne środowisko podczas opracowywania za pomocą klientów usługi Service Bus.

• Można użyć konfiguracji zewnętrznej, aby można było pracować z tym samym kodem aplikacji w różnych środowiskach.

• Możesz delegować proces uczenia się wzorca konstruktora i rejestrowania tego klienta w kontekście aplikacji do platformy Spring Boot. To delegowanie umożliwia skoncentrowanie się na sposobie korzystania z klientów z własnymi wymaganiami biznesowymi.

• Wskaźnik kondycji można użyć w łatwy sposób, aby sprawdzić stan i kondycję aplikacji i składników wewnętrznych.

W poniższym przykładzie kodu pokazano, jak używać metod ServiceBusSenderClient i ServiceBusProcessorClient z tymi dwiema alternatywami.

Aby wysyłać komunikaty do usługi Service Bus i odbierać je z usługi Service Bus, skonfiguruj aplikację, wykonując następujące kroki:

1. Skonfiguruj przestrzeń nazw i kolejkę usługi Service Bus, jak pokazano w poniższym przykładzie:

   properties Kopiuj

   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
   

   Porada

   W tym miejscu jako przykład użyjemy kolejki usługi Service Bus. Aby użyć tematu spring.cloud.azure.servicebus.processor.subscription-name /subskrypcji, musisz dodać właściwość i zmienić entity-type wartość na topic.

2. Utwórz nową ServiceBusProcessorClientConfiguration klasę Java, jak pokazano w poniższym przykładzie. Ta klasa służy do rejestrowania komunikatu i procedury obsługi błędów programu ServiceBusProcessorClient.

   Java Kopiuj

   @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. Wstrzykuj element ServiceBusSenderClient w aplikacji Spring i wywołaj powiązane interfejsy API w celu wysyłania komunikatów, jak pokazano w poniższym przykładzie:

   Java Kopiuj

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

   Uwaga

   Domyślnie cykl życia automatycznie wirowanej ServiceBusProcessorClient fasoli jest zarządzany przez kontekst Spring. Procesor jest uruchamiany automatycznie po uruchomieniu kontekstu aplikacji Spring i zatrzymany po zatrzymaniu kontekstu aplikacji Spring. Aby wyłączyć tę funkcję, skonfiguruj element spring.cloud.azure.servicebus.processor.auto-startup=false.

4. Uruchom aplikację. Wyświetlane są dzienniki podobne do następującego przykładu:

   Output Kopiuj

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

Możesz samodzielnie skompilować fasolę klienta, ale proces jest skomplikowany. W aplikacjach Spring Boot musisz zarządzać właściwościami, uczyć się wzorca konstruktora i rejestrować klienta w kontekście aplikacji Spring. W poniższym przykładzie kodu pokazano, jak to zrobić:

1. Utwórz nową ServiceBusClientConfiguration klasę Java, jak pokazano w poniższym przykładzie. Ta klasa służy do deklarowania fasoli ServiceBusSenderClient i ServiceBusProcessorClient .

   Java Kopiuj

   @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());
       }
   }
   

   Uwaga

   Pamiętaj, aby zastąpić <service-bus-fully-qualified-namespace> symbol zastępczy nazwą hosta usługi Service Bus z witryny Azure Portal. Zastąp <service-bus-queue-name> symbol zastępczy własną nazwą kolejki skonfigurowaną w przestrzeni nazw usługi Service Bus.

2. Wstrzyknąć fasolę klienta do aplikacji, jak pokazano w poniższym przykładzie:

   Java Kopiuj

   @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. Uruchom aplikację. Wyświetlane są dzienniki podobne do następującego przykładu:

   Output Kopiuj

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

Na poniższej liście przedstawiono przyczyny, dla których ten kod nie jest elastyczny lub elastyczny:

• Przestrzeń nazw i nazwy kolejki/tematu/subskrypcji są zakodowane w kodzie twardym.
• Jeśli używasz @Value polecenia do pobierania konfiguracji ze środowiska Spring, nie możesz mieć wskazówek dotyczących środowiska IDE w pliku application.properties .
• Jeśli masz scenariusz mikrousług, musisz zduplikować kod w każdym projekcie i łatwo jest popełnić błędy i trudno go spójnie.

Na szczęście samodzielne kompilowanie fasoli klienta nie jest konieczne w przypadku platformy Azure Spring Cloud. Zamiast tego możesz bezpośrednio wstrzyknąć fasolę i użyć właściwości konfiguracji, które już znasz, aby skonfigurować usługę Service Bus.

Platforma Spring Cloud Azure udostępnia również następujące konfiguracje globalne dla różnych scenariuszy. Aby uzyskać więcej informacji, zobacz sekcję Global configuration for Azure Service SDK (Konfiguracja globalna zestawów SDK usługi platformy Azure) w konfiguracji platformy Azure Spring Cloud.

• Opcje serwera proxy.
• Opcje ponawiania prób.
• Opcje klienta transportu amQP.

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

Moduł startowy Spring Cloud Azure Service Bus JMS zapewnia integrację rozwiązania Spring JMS z usługą Service Bus. W poniższym wideo opisano sposób integrowania aplikacji Spring JMS z usługą Azure Service Bus przy użyciu programu JMS 2.0.

W tym przewodniku pokazano, jak używać szablonu startowego Spring Cloud Azure Service Bus dla interfejsu API JMS do wysyłania komunikatów do usługi Service Bus i odbierania ich z usługi Service Bus.

Aby zainstalować moduł startowy spring Cloud Azure Service Bus JMS, dodaj następujące zależności do pliku pom.xml :

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

  XML Kopiuj

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

  Uwaga

  Jeśli używasz środowiska Spring Boot 2.x, pamiętaj, aby ustawić spring-cloud-azure-dependencies wersję na 4.19.0. Ten rachunek materiału (BOM) należy skonfigurować w <dependencyManagement> sekcji pliku pom.xml . Gwarantuje to, że wszystkie zależności platformy Azure platformy Spring Cloud korzystają z tej samej wersji. Aby uzyskać więcej informacji na temat wersji używanej dla tego modelu BOM, zobacz Która wersja platformy Spring Cloud platformy Azure powinna być używana.

• Artefakt JMS spring Cloud w usłudze Azure Service Bus:

  XML Kopiuj

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

1. Skonfiguruj parametry połączenia i warstwę cenową dla usługi Service Bus, jak pokazano w poniższym przykładzie:

   properties Kopiuj

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

2. Utwórz odbiornik komunikatów.

   Platforma Spring umożliwia publikowanie komunikatów w dowolnym obiekcie POJO (zwykły stary obiekt Java). Najpierw zdefiniuj klasę ogólną User , która przechowuje i pobiera nazwę użytkownika, jak pokazano w poniższym przykładzie:

   Java Kopiuj

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

   Porada

   Implementacja interfejsu Serializable obejmuje używanie metody send szablonu JmsTemplate platformy Spring. W przeciwnym razie należy zdefiniować dostosowaną MessageConverter fasolę, aby serializować zawartość do formatu JSON w formacie tekstowym. Aby uzyskać więcej informacji na temat funkcji MessageConverter, zobacz oficjalną stronę projektu szablonu startowego Spring JMS .

3. W tym miejscu możesz utworzyć nową QueueReceiveService klasę Języka Java, jak pokazano w poniższym przykładzie. Ta klasa służy do definiowania odbiornika komunikatów.

   Java Kopiuj

   @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());
       }
   }
   

   Uwaga

   Pamiętaj, aby zastąpić <service-bus-queue-name> symbol zastępczy własną nazwą kolejki skonfigurowaną w przestrzeni nazw usługi Service Bus.

   Jeśli używasz tematu/subskrypcji, zmień destination parametr jako nazwę tematu i containerFactory powinien mieć wartość topicJmsListenerContainerFactory. Dodaj również parametr , subscription aby opisać nazwę subskrypcji.

4. Podłącz nadawcę i odbiorcę do wysyłania i odbierania komunikatów za pomocą platformy Spring, jak pokazano w poniższym przykładzie:

   Java Kopiuj

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

   Uwaga

   Pamiętaj, aby zastąpić <service-bus-queue-name> symbol zastępczy własną nazwą kolejki skonfigurowaną w przestrzeni nazw usługi Service Bus.

   Porada

   Pamiętaj, aby dodać adnotację @EnableIntegration , która wyzwala odnajdywanie metod z adnotacjami za pomocą @JmsListenerpolecenia , tworząc kontener odbiornika komunikatów w obszarze okładek.

5. Uruchom aplikację. Wyświetlane są dzienniki podobne do następującego przykładu:

   Output Kopiuj

   Sending a user message.
   Received a message from Tom.
   

Aby uzyskać więcej informacji, zobacz How to use JMS API with Service Bus and AMQP 1.0 (Jak używać interfejsu API JMS z usługą Service Bus i amQP 1.0).

Moduł Spring Messaging usługi Azure Service Bus zapewnia obsługę platformy Spring Messaging za pomocą usługi Service Bus.

Jeśli używasz usługi Azure Service Bus spring Messaging, możesz użyć następujących funkcji:

• ServiceBusTemplate: wysyła komunikaty do kolejek i tematów usługi Service Bus asynchronicznie i synchronicznie.
• @ServiceBusListener: oznacza metodę docelową odbiornika komunikatów usługi Service Bus w miejscu docelowym.

W tym przewodniku pokazano, jak używać usługi Azure Service Bus spring Messaging do wysyłania komunikatów i odbierania komunikatów z usługi Service Bus.

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

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

  XML Kopiuj

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

  Uwaga

  Jeśli używasz środowiska Spring Boot 2.x, pamiętaj, aby ustawić spring-cloud-azure-dependencies wersję na 4.19.0. Ten rachunek materiału (BOM) należy skonfigurować w <dependencyManagement> sekcji pliku pom.xml . Gwarantuje to, że wszystkie zależności platformy Azure platformy Spring Cloud korzystają z tej samej wersji. Aby uzyskać więcej informacji na temat wersji używanej dla tego modelu BOM, zobacz Która wersja platformy Spring Cloud platformy Azure powinna być używana.

• Artefakty startowe Spring Messaging Service Bus i Spring Cloud Na platformie Azure:

  XML Kopiuj

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

1. Skonfiguruj przestrzeń nazw i typ kolejki dla usługi Service Bus, jak pokazano w poniższym przykładzie:

   properties Kopiuj

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

   Uwaga

   Jeśli używasz tematu/subskrypcji, zmień spring.cloud.azure.servicebus.entity-type wartość na topic.

2. Utwórz nową ConsumerService klasę Java, jak pokazano w poniższym przykładzie. Ta klasa służy do definiowania odbiornika komunikatów.

   Java Kopiuj

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

   Uwaga

   Jeśli używasz tematu/subskrypcji, zmień parametr destination adnotacji jako nazwę tematu i dodaj group parametr , aby opisać nazwę subskrypcji.

3. Podłącz nadawcę i odbiorcę do wysyłania i odbierania komunikatów za pomocą platformy Spring, jak pokazano w poniższym przykładzie:

   Java Kopiuj

   @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();
       }
   }
   

   Porada

   Pamiętaj, aby dodać adnotację @EnableAzureMessaging , która wyzwala odnajdywanie metod z adnotacjami za pomocą @ServiceBusListenerpolecenia , tworząc kontener odbiornika komunikatów w obszarze okładek.

4. Uruchom aplikację. Wyświetlane są dzienniki podobne do następującego przykładu:

   Output Kopiuj

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

Moduł Spring Integration Azure Service Bus zapewnia obsługę platformy Spring Integration Framework z usługą Service Bus.

Jeśli aplikacja Spring używa kanałów komunikatów integracji platformy Spring, możesz kierować komunikaty między kanałami komunikatów i usługą Service Bus przy użyciu kart kanału.

Adapter kanału przychodzącego przekazuje komunikaty z kolejki usługi Service Bus lub subskrypcji do kanału komunikatów. Karta kanału wychodzącego publikuje komunikaty z kanału komunikatów do kolejki i tematu usługi Service Bus.

W tym przewodniku pokazano, jak używać usługi Azure Service Bus integracji spring do wysyłania komunikatów i odbierania komunikatów z usługi Service Bus.

Aby zainstalować moduł Start integracji rozwiązania Spring Cloud Azure Service Bus, dodaj następujące zależności do pliku pom.xml :

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

  XML Kopiuj

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

  Uwaga

  Jeśli używasz środowiska Spring Boot 2.x, pamiętaj, aby ustawić spring-cloud-azure-dependencies wersję na 4.19.0. Ten rachunek materiału (BOM) należy skonfigurować w <dependencyManagement> sekcji pliku pom.xml . Gwarantuje to, że wszystkie zależności platformy Azure platformy Spring Cloud korzystają z tej samej wersji. Aby uzyskać więcej informacji na temat wersji używanej dla tego modelu BOM, zobacz Która wersja platformy Spring Cloud platformy Azure powinna być używana.

• Artefakt integracji rozwiązania Spring Cloud Azure Service Bus:

  XML Kopiuj

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

1. Skonfiguruj przestrzeń nazw usługi Service Bus, jak pokazano w poniższym przykładzie:

   properties Kopiuj

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

2. Utwórz nową QueueReceiveConfiguration klasę Java, jak pokazano w poniższym przykładzie. Ta klasa służy do definiowania odbiornika komunikatów.

   Java Kopiuj

   @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. Utwórz nową QueueSendConfiguration klasę Java, jak pokazano w poniższym przykładzie. Ta klasa służy do definiowania nadawcy komunikatów.

   Java Kopiuj

   @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. Podłącz nadawcę i odbiorcę do wysyłania i odbierania komunikatów za pomocą platformy Spring, jak pokazano w poniższym przykładzie:

   Java Kopiuj

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

   Porada

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

5. Uruchom aplikację. Wyświetlane są dzienniki podobne do następującego przykładu:

   Output Kopiuj

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

Aby wywołać interfejs API usługi Service Bus w aplikacji Spring Cloud Stream , użyj modułu binder strumienia Spring Cloud Azure Service Bus.

W tym przewodniku pokazano, jak używać narzędzia binder usługi Service Bus spring Cloud Stream do wysyłania komunikatów do usługi Service Bus i odbierania ich z usługi Service Bus.

Aby zainstalować moduł binder strumienia Spring Cloud Azure Service Bus, dodaj następujące zależności do pliku pom.xml :

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

  XML Kopiuj

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

  Uwaga

  Jeśli używasz środowiska Spring Boot 2.x, pamiętaj, aby ustawić spring-cloud-azure-dependencies wersję na 4.19.0. Ten rachunek materiału (BOM) należy skonfigurować w <dependencyManagement> sekcji pliku pom.xml . Gwarantuje to, że wszystkie zależności platformy Azure platformy Spring Cloud korzystają z tej samej wersji. Aby uzyskać więcej informacji na temat wersji używanej dla tego modelu BOM, zobacz Która wersja platformy Spring Cloud platformy Azure powinna być używana.

• Artefakt integracji rozwiązania Spring Cloud Azure Service Bus:

  XML Kopiuj

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

1. Skonfiguruj przestrzeń nazw usługi Service Bus, jak pokazano w poniższym przykładzie:

   properties Kopiuj

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

2. Utwórz odbiornik komunikatów.

   Aby użyć aplikacji jako ujścia zdarzeń, skonfiguruj powiązanie wejściowe, określając następujące informacje:

   • Zadeklaruj fasolę definiującą logikę Consumer obsługi komunikatów. Na przykład następująca Consumer fasola ma nazwę consume:

     Java Kopiuj

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

   • Dodaj konfigurację, aby określić queue nazwę do użytku, zastępując <service-bus-queue-name> symbol zastępczy, jak pokazano w poniższym przykładzie:

     properties Kopiuj

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

     Uwaga

     Aby korzystać z subskrypcji usługi Service Bus, pamiętaj, aby zmienić consume-in-0 właściwości powiązania, jak pokazano w poniższym przykładzie:

     properties Kopiuj

     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. Utwórz nadawcę wiadomości.

   Aby użyć aplikacji jako źródła zdarzeń, skonfiguruj powiązanie wyjściowe, określając następujące informacje:

   • Zdefiniuj fasolę Supplier , która definiuje, gdzie komunikaty pochodzą z aplikacji.

     Java Kopiuj

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

   • Dodaj konfigurację, aby określić queue nazwę wysyłania, zastępując <your-servicebus-queue-name> symbol zastępczy w poniższym przykładzie:

     properties Kopiuj

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

     Uwaga

     Aby wysłać do tematu usługi Service Bus, pamiętaj, aby zmienić wartość na entity-typetopic.

4. Uruchom aplikację. Wyświetlane są dzienniki podobne do następującego przykładu:

   Output Kopiuj

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

Teraz, gdy aplikacja Spring Boot działa lokalnie, nadszedł czas, aby przenieść ją do środowiska produkcyjnego. Usługa Azure Spring Apps ułatwia wdrażanie aplikacji Spring Boot na platformie Azure bez żadnych zmian w kodzie. Usługa zarządza infrastrukturą aplikacji Spring, aby deweloperzy mogli skupić się na swoim kodzie. Usługa Azure Spring Apps zapewnia zarządzanie cyklem życia przy użyciu kompleksowego monitorowania i diagnostyki, zarządzania konfiguracją, odnajdywania usług, integracji/ciągłego wdrażania, wdrożeń niebieskich zielonych i nie tylko. Aby wdrożyć aplikację w usłudze Azure Spring Apps, zobacz Wdrażanie pierwszej aplikacji w usłudze Azure Spring Apps.

Aby uzyskać więcej informacji na temat dodatkowych szablonów startowych Spring Boot dostępnych dla platformy Microsoft Azure, zobacz Co to jest platforma Spring Cloud Azure?