Korzystanie z usługi Azure Service Bus w aplikacjach Spring

Artykuł
01/18/2024

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 subskrypcji tematów/ 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.

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

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 aktualnie używanego konta firmy Microsoft. 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 2.5 lub nowsza.

Przygotowywanie środowiska lokalnego

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?

Uwaga

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

Używanie szablonu startowego Spring Cloud Azure Service Bus

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.

Dodawanie zależności 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.19.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 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:

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

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

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.

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ą dzienniki podobne do następującego przykładu:

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

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

Wstrzyknąć fasolę klienta do 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 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.

Korzystanie z szablonu 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.

Dodawanie zależności 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.19.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 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:

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

Napiwek

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.

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

Korzystanie z usługi Azure Service Bus spring messaging

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.

Dodawanie zależności 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.19.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 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:

<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 destination adnotacji jako nazwę tematu i dodaj group parametr , 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 odnajdywanie metod z adnotacjami za pomocą @ServiceBusListenerpolecenia , tworząc kontener odbiornika komunikatów w obszarze okładek.

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

Korzystanie z usługi Azure Service Bus integracji spring

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.

Dodawanie zależności 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.19.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 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:

<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 umożliwia infrastrukturę integracji spring.

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

Korzystanie z powiązania usługi Spring Cloud Stream Service Bus

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.

Dodawanie zależności 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):
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>5.19.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 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:

<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 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:
```
@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:
```
# 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:
```
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ć wartość na entity-type topic.
Uruchom aplikację. Wyświetlane są dzienniki podobne do następującego przykładu:
```
Sending a message.
New message received: 'Hello world'.
```

Wdrażanie w usłudze 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ł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.

Następne kroki

Przykłady dla platformy Azure dla deweloperów platformy Spring Cloud w usłudze Azure Service Bus

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

Używanie szablonu startowego Spring Cloud Azure Service Bus

Dodawanie zależności 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 szablonu startowego Spring Cloud Azure Service Bus JMS

Dodawanie zależności usługi Service Bus

Kod aplikacji do wysyłania i odbierania komunikatów

Inne informacje

Korzystanie z usługi Azure Service Bus spring messaging

Dodawanie zależności usługi Service Bus

Kod aplikacji do wysyłania i odbierania komunikatów

Korzystanie z usługi Azure Service Bus integracji spring

Dodawanie zależności usługi Service Bus

Kod aplikacji do wysyłania i odbierania komunikatów

Korzystanie z powiązania usługi Spring Cloud Stream Service Bus

Dodawanie zależności usługi Service Bus

Kod aplikacji do wysyłania i odbierania komunikatów

Wdrażanie w usłudze Azure Spring Apps

Następne kroki

Zobacz też

Opinia

Dodatkowe zasoby