Korzystanie z usługi Azure Service Bus w aplikacjach Spring

Artykuł
03/29/2025

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 i odbierania komunikatów z kolejek oraz tematów i subskrypcji usługi Service Bus przy użyciu frameworków 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.
Spring Messaging Azure Service Bus umożliwia interakcję z usługą Service Bus za pośrednictwem interfejsu API Spring Messaging.
Spring Integration Azure Service Bus umożliwia łączenie kanałów wiadomości Spring Integration 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.

Wymagania wstępne

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 oraz kolejka lub temat/subskrypcja. Jeśli go nie masz, utwórz kolejkę lub temat w usłudze 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.

Uwaga

Aby udzielić kontu dostępu do zasobów usługi Service Bus, w nowo utworzonej przestrzeni nazw usługi Azure Service Bus przypisz role Nadawca danych usługi Azure Service Bus i Odbiornik danych usługi Azure Service Bus do konta Microsoft Entra, z którego aktualnie korzystasz. Aby uzyskać więcej informacji, zobacz przypisywanie ról Azure za pomocą portalu Azure.

Ważne

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

Przygotowywanie środowiska lokalnego

W tym samouczku konfiguracje i kod nie zawierają 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?

Uwaga

Usługa Azure Service Bus dla API JMS obecnie nie obsługuje DefaultAzureCredential. Jeśli używasz programu Spring JMS z usługą Service Bus, zignoruj ten krok.

Skorzystanie ze startera Spring Cloud Azure Service Bus

Moduł Spring Cloud Azure Service Bus Starter importuje bibliotekę klienta Java dla usługi Service Bus wraz z platformą Spring Boot. Możesz używać Spring Cloud Azure razem z Azure SDK w sposób, który się wzajemnie nie wyklucza. W związku z tym możesz nadal używać interfejsu API klienta Java usługi Service Bus w aplikacji Spring.

Dodaj zależność usługi Service Bus

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):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.21.0</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 BOM (rachunek materiałowy) należy skonfigurować w sekcji <dependencyManagement> pliku pom.xml. Gwarantuje to, że wszystkie zależności Spring Cloud Azure korzystają z tej samej wersji. Aby uzyskać więcej informacji na temat wersji używanej dla tego modelu BOM, zobacz Którą wersję Spring Cloud Azure powinienem używać.

Artefakt Spring Cloud Azure Service Bus:

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

Kod aplikacji do wysyłania i odbierania komunikatów

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 korzystanie z gotowych klientów dostępnych w kontekście Spring. Alternatywnym sposobem jest programowe kompilowanie klientów.

Pierwszy sposób, który polega na automatycznym podłączaniu komponentów klienta z kontenera Spring IoC, ma następujące zalety w porównaniu z drugim sposobem. Te zalety zapewniają bardziej elastyczne i wydajne środowisko w pracy z klientami 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 wykorzystaniu klientów zgodnie 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.

Uwaga

Zestaw Azure Java SDK dla usługi Service Bus udostępnia wielu klientów do interakcji z usługą Service Bus. Starter zapewnia również automatyczną konfigurację dla wszystkich klientów usługi Service Bus i konstruktorów klientów. W tym miejscu używamy tylko ServiceBusSenderClient i ServiceBusProcessorClient jako przykładów.

Korzystanie z autokonfiguracji Spring Boot

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:

Skonfiguruj przestrzeń nazw i kolejkę usługi Service Bus, jak pokazano w poniższym przykładzie:
```
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
```
Napiwek

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

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.

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

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:

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

Uruchom aplikację. Wyświetlane są logi podobne do następujących przykładów:

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

Programowe kompilowanie klientów usługi Service Bus

Możesz samodzielnie zbudować komponenty 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ć:

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

@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 symbol <service-bus-queue-name> własną nazwą kolejki skonfigurowaną w przestrzeni nazw usługi Service Bus.

Wstrzyknij komponenty klienta do swojej aplikacji, jak pokazano w poniższym przykładzie:

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

}

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

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

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

Na szczęście samodzielne tworzenie komponentów klienta nie jest konieczne w przypadku Spring Cloud Azure. Zamiast tego możesz bezpośrednio wstrzyknąć beany i użyć właściwości konfiguracji, które już znasz, do skonfigurowania usługi 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ę Konfiguracja globalna dla zestawów SDK usług platformy Azure w konfiguracji Spring Cloud Azure.

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.

Korzystanie z pakietu startowego Spring Cloud Azure Service Bus JMS

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.

Dodaj zależność 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):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.21.0</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. Zestawienie materiałowe (BOM) należy skonfigurować w sekcji <dependencyManagement> pliku pom.xml. Gwarantuje to, że wszystkie zależności Spring Cloud Azure korzystają z tej samej wersji. Aby uzyskać więcej informacji na temat wersji używanej dla tego BOM, zobacz Którą wersję Spring Cloud Azure powinienem używać.

Artefakt Spring Cloud Azure Service Bus JMS:

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

Kod aplikacji do wysyłania i odbierania komunikatów

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

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

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:
```
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;
    }
}
```
Napiwek

Implementacja Serializable jest przeprowadzana w celu użycia metody send w frameworku Spring JmsTemplate. W przeciwnym razie należy zdefiniować dostosowany komponent MessageConverter, aby serializować zawartość do formatu JSON jako tekst. Aby uzyskać więcej informacji na temat funkcji MessageConverter, zobacz oficjalną stronę projektu szablonu startowego Spring JMS .
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.
```
@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.

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

@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ć element zastępczy <service-bus-queue-name> własną nazwą kolejki skonfigurowaną w przestrzeni nazw usługi Service Bus.

Napiwek

Pamiętaj, aby dodać adnotację @EnableIntegration, która wyzwala odkrywanie metod oznaczonych annotacją @JmsListener, tworząc w tle kontener odbiorcy komunikatów.

Uruchom aplikację. Wyświetlane są logi jak w poniższym przykładzie:
```
Sending a user message.
Received a message from Tom.
```

Inne informacje

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

Użyj Spring Messaging Azure Service Bus

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

Jeśli używasz Spring Messaging Azure Service Bus, 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.

Dodaj zależność 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):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.21.0</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. Ta struktura materiałowa (BOM) powinna być skonfigurowana w sekcji <dependencyManagement> pliku pom.xml. Gwarantuje to, że wszystkie zależności Spring Cloud Azure korzystają z tej samej wersji. Aby uzyskać więcej informacji na temat wersji używanej dla tego BOM, zobacz Którą wersję Spring Cloud Azure powinna być używana.

Artefakty startowe Spring Messaging Service Bus i Spring Cloud 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>

Kod aplikacji do wysyłania i odbierania komunikatów

Skonfiguruj przestrzeń nazw i typ kolejki dla usługi Service Bus, jak pokazano w poniższym przykładzie:
```
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.

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

@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 adnotacji destination na nazwę tematu i dodaj parametr group, aby opisać nazwę subskrypcji.

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

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

Napiwek

Pamiętaj, aby dodać adnotację @EnableAzureMessaging, która wyzwala odkrywanie metod oznaczonych adnotacją @ServiceBusListener, tworząc automatycznie kontener odbiornika komunikatów.

Uruchom aplikację. Wyświetlane są logi podobne do następującego przykładu.
```
Sending a message to the queue.
Consume message: Hello world.
```

Korzystanie z usługi Spring Integration Azure Service Bus

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

Jeśli Twoja aplikacja Spring używa kanałów wiadomości Spring Integration, możesz kierować wiadomości pomiędzy kanałami wiadomości a Service Bus używając adapterów kanałów.

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

Przewodnik ten pokazuje, jak używać Spring Integration z Azure Service Bus do wysyłania i odbierania komunikatów z usługi Service Bus.

Dodaj zależność 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):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.21.0</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 BOM (Bill of Material) należy skonfigurować w <dependencyManagement> sekcji pliku pom.xml. Gwarantuje to, że wszystkie zależności Spring Cloud Azure korzystają z tej samej wersji. Aby uzyskać więcej informacji na temat wersji używanej dla tego BOM, zobacz Którą wersję Spring Cloud Azure powinienem użyć.

Artefakt integracji rozwiązania Spring Cloud Azure Service Bus:

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

Kod aplikacji do wysyłania i odbierania komunikatów

Skonfiguruj przestrzeń nazw usługi Service Bus, jak pokazano w poniższym przykładzie:
```
spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
```

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

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

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

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

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

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

}

Napiwek

Pamiętaj, aby dodać adnotację @EnableIntegration, która aktywuje infrastrukturę Spring Integration.

Uruchom aplikację. Wyświetlane są dzienniki podobne do następującego przykładu:
```
Message was sent successfully.
New message received: 'Hello World'
```

Korzystanie ze spoiwa usługi Spring Cloud Stream Service Bus

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

W tym przewodniku pokazano, jak używać bindera Spring Cloud Stream Service Bus do wysyłania i odbierania komunikatów z usługi Service Bus.

Dodaj zależność usługi Service Bus

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

Projekt Spring Cloud Azure Bill of Materials (BOM):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.21.0</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. Ta lista materiałowa (BOM) powinna być skonfigurowana w <dependencyManagement> sekcji pliku pom.xml. Gwarantuje to, że wszystkie biblioteki Spring Cloud Azure korzystają z tej samej wersji. Aby uzyskać więcej informacji na temat wersji używanej dla tego BOM, zobacz Którą wersję Spring Cloud Azure powinienem używać.

Artefakt integracji rozwiązania Spring Cloud Azure Service Bus:

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

Kod aplikacji do wysyłania i odbierania komunikatów

Skonfiguruj przestrzeń nazw usługi Service Bus, jak pokazano w poniższym przykładzie:
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
```
Utwórz odbiornik komunikatów.

Aby użyć aplikacji jako odbiornika zdarzeń, skonfiguruj powiązanie wejściowe, określając następujące informacje:
- Zadeklaruj komponent Consumer, który definiuje logikę obsługi komunikatów. Na przykład następująca Consumer fasola ma nazwę consume:
```
@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 wykorzystania, zastępując <service-bus-queue-name> symbol zastępczy, jak widać w poniższym przykładzie:
```
# 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, należy zmienić consume-in-0 właściwości powiązania zgodnie z poniższym przykładem:
```
spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-topic-name>
spring.cloud.stream.bindings.consume-in-0.group=<service-bus-subscription-name>
```
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.
```
@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:
```
# "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ć entity-type na topic.
Uruchom aplikację. Wyświetlane są dzienniki podobne do następującego przykładu:
```
Sending a message.
New message received: 'Hello world'.
```

Wdrażanie do usługi Azure Spring Apps

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łej i ciągłego wdrażania (CI/CD), wdrożeń blue-green i nie tylko. Aby wdrożyć aplikację w usłudze Azure Spring Apps, zobacz Wdrażanie pierwszej aplikacji w usłudze Azure Spring Apps.

Następne kroki

Azure dla deweloperów Spring Przykłady Azure Service Bus z Spring Cloud

Zobacz też

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?

Udostępnij za pośrednictwem

Korzystanie z usługi Azure Service Bus w aplikacjach Spring

Wymagania wstępne

Przygotowywanie środowiska lokalnego

Skorzystanie ze startera Spring Cloud Azure Service Bus

Dodaj zależność usługi Service Bus

Kod aplikacji do wysyłania i odbierania komunikatów

Korzystanie z autokonfiguracji Spring Boot

Programowe kompilowanie klientów usługi Service Bus

Korzystanie z pakietu startowego Spring Cloud Azure Service Bus JMS

Dodaj zależność usługi Service Bus

Kod aplikacji do wysyłania i odbierania komunikatów

Inne informacje

Użyj Spring Messaging Azure Service Bus

Dodaj zależność usługi Service Bus

Kod aplikacji do wysyłania i odbierania komunikatów

Korzystanie z usługi Spring Integration Azure Service Bus

Dodaj zależność usługi Service Bus

Kod aplikacji do wysyłania i odbierania komunikatów

Korzystanie ze spoiwa usługi Spring Cloud Stream Service Bus

Dodaj zależność usługi Service Bus

Kod aplikacji do wysyłania i odbierania komunikatów

Wdrażanie do usługi Azure Spring Apps

Następne kroki

Zobacz też

Opinia

Dodatkowe zasoby