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

Článek
01/18/2024

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

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

Spring Cloud Azure poskytuje různé moduly pro odesílání zpráv do front a přijímání zpráv z front a témat/ služby Service Bus pomocí architektur Spring.

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

Úvodní sada Spring Cloud Azure Service Bus umožňuje odesílat a přijímat zprávy pomocí klientské knihovny sady Service Bus Java SDK s funkcemi Spring Boot.
Úvodní sada Spring Cloud Azure Service Bus JMS umožňuje používat rozhraní JMS API k odesílání a přijímání zpráv s frontami a tématy a odběry služby Service Bus.
Spring Messaging Azure Service Bus umožňuje interakci se službou Service Bus prostřednictvím rozhraní Spring Messaging API.
Spring Integration Azure Service Bus umožňuje připojit kanály Spring Integration Message Channels se službou Service Bus.
Spring Cloud Stream Binder pro Service Bus umožňuje používat Service Bus jako middleware zasílání zpráv v aplikacích Spring Cloud Stream.

Požadavky

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

Poznámka:

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

Důležité

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

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

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

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

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

Poznámka:

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

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

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

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

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

Kusovník materiálů (BOM) Spring Cloud v Azure:
```
<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>
```
Poznámka:

Pokud používáte Spring Boot 2.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 4.19.0. Tato faktura materiálu (BOM) by měla být nakonfigurována v <dependencyManagement> části vašeho pom.xml souboru. Tím se zajistí, že všechny závislosti Azure Spring Cloudu budou používat stejnou verzi. Další informace o verzi použité pro tuto kusovníku najdete v tématu Jakou verzi Spring Cloud Azure mám použít.

Artefakt Spring Cloud Azure Service Bus:

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

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

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

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

Můžete použít externalizovanou konfiguraci , abyste mohli pracovat se stejným kódem aplikace v různých prostředích.
Proces učení modelu tvůrce a registraci tohoto klienta můžete delegovat do kontextu aplikace do architektury Spring Boot. Toto delegování vám umožní zaměřit se na to, jak používat klienty s vlastními obchodními požadavky.
Indikátor stavu můžete snadno použít ke kontrole stavu a stavu aplikace a interních komponent.

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

Poznámka:

Sada Azure Java SDK pro Service Bus poskytuje více klientům pro interakci se službou Service Bus. Úvodní sada také poskytuje automatickou konfiguraci pro všechny klienty Služby Service Bus a tvůrce klientů. Zde používáme pouze ServiceBusSenderClient a ServiceBusProcessorClient jako příklady.

Použití funkce Spring Boot Autoconfiguration

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

Nakonfigurujte obor názvů a frontu služby Service Bus, jak je znázorněno v následujícím příkladu:
```
spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
spring.cloud.azure.servicebus.entity-name=<your-servicebus-queue-name>
spring.cloud.azure.servicebus.entity-type=queue
```
Tip

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

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

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

ServiceBusSenderClient Vložení aplikace Spring a volání souvisejících rozhraní API pro odesílání zpráv, jak je znázorněno v následujícím příkladu:

@SpringBootApplication
public class ServiceBusQueueApplication implements CommandLineRunner {

    private final ServiceBusSenderClient senderClient;

    public ServiceBusQueueApplication(ServiceBusSenderClient senderClient) {
        this.senderClient = senderClient;
    }

    public static void main(String[] args) {
        SpringApplication.run(ServiceBusQueueApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        // send one message to the queue
        senderClient.sendMessage(new ServiceBusMessage("Hello, World!"));
        System.out.printf("Sent a message to the queue");
        senderClient.close();

        // wait the processor client to consume messages
        TimeUnit.SECONDS.sleep(10);
    }

}

Poznámka:

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

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

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

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

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

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

@Configuration(proxyBeanMethods = false)
public class ServiceBusClientConfiguration {

    private static final String SERVICE_BUS_FQDN = "<service-bus-fully-qualified-namespace>";
    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    @Bean
    ServiceBusClientBuilder serviceBusClientBuilder() {
        return new ServiceBusClientBuilder()
                   .fullyQualifiedNamespace(SERVICE_BUS_FQDN)
                   .credential(new DefaultAzureCredentialBuilder().build());
    }

    @Bean
    ServiceBusSenderClient serviceBusSenderClient(ServiceBusClientBuilder builder) {
        return builder
               .sender()
               .queueName(QUEUE_NAME)
               .buildClient();
    }

    @Bean
    ServiceBusProcessorClient serviceBusProcessorClient(ServiceBusClientBuilder builder) {
        return builder.processor()
                      .queueName(QUEUE_NAME)
                      .processMessage(ServiceBusClientConfiguration::processMessage)
                      .processError(ServiceBusClientConfiguration::processError)
                      .buildProcessorClient();
    }

    private static void processMessage(ServiceBusReceivedMessageContext context) {
        ServiceBusReceivedMessage message = context.getMessage();
        System.out.printf("Processing message. Id: %s, Sequence #: %s. Contents: %s%n",
            message.getMessageId(), message.getSequenceNumber(), message.getBody());
    }

    private static void processError(ServiceBusErrorContext context) {
        System.out.printf("Error when receiving messages from namespace: '%s'. Entity: '%s'%n",
                context.getFullyQualifiedNamespace(), context.getEntityPath());
    }
}

Poznámka:

Zástupný text nahraďte <service-bus-fully-qualified-namespace> názvem hostitele služby Service Bus z webu Azure Portal. <service-bus-queue-name> Zástupný text nahraďte vlastním názvem fronty nakonfigurovaným v oboru názvů služby Service Bus.

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

@SpringBootApplication
public class ServiceBusQueueApplication implements CommandLineRunner {

    private final ServiceBusSenderClient senderClient;

    private final ServiceBusProcessorClient processorClient;

    public ServiceBusQueueApplication(ServiceBusSenderClient senderClient, ServiceBusProcessorClient processorClient) {
        this.senderClient = senderClient;
        this.processorClient = processorClient;
    }

    public static void main(String[] args) {
        SpringApplication.run(ServiceBusQueueApplication.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        // send one message to the queue
        senderClient.sendMessage(new ServiceBusMessage("Hello, World!"));
        System.out.printf("Sent a message to the queue");
        senderClient.close();

        System.out.printf("Starting the processor");
        processorClient.start();
        TimeUnit.SECONDS.sleep(10);
        System.out.printf("Stopping and closing the processor");
        processorClient.close();
    }

}

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

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

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

Názvy oborů názvů a front, tématu nebo odběru jsou pevně zakódované.
Pokud používáte @Value k získání konfigurací z prostředí Spring, nemůžete mít v souboru application.properties rady ide.
Pokud máte scénář mikroslužby, musíte kód v každém projektu duplikovat a je snadné udělat chyby a těžko být konzistentní.

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

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

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

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

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

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

V této příručce se dozvíte, jak pomocí úvodní sady Spring Cloud Azure Service Bus pro rozhraní JMS API odesílat a přijímat zprávy ze služby Service Bus a přijímat je.

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

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

Kusovník materiálů (BOM) Spring Cloud v Azure:
```
<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>
```
Poznámka:

Pokud používáte Spring Boot 2.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 4.19.0. Tato faktura materiálu (BOM) by měla být nakonfigurována v <dependencyManagement> části vašeho pom.xml souboru. Tím se zajistí, že všechny závislosti Azure Spring Cloudu budou používat stejnou verzi. Další informace o verzi použité pro tuto kusovníku najdete v tématu Jakou verzi Spring Cloud Azure mám použít.

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

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

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

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

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

Vytvořte příjemce zprávy.

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

    private static final long serialVersionUID = -295422703255886286L;

    private String name;

    public User() {
    }

    public User(String name) {
        setName(name);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
```
Tip

Serializable se implementuje tak, aby se použila metoda send v rámci JmsTemplate v architektuře Spring. Jinak byste měli definovat vlastní MessageConverter bean pro serializaci obsahu do formátu JSON v textovém formátu. Další informace o objektu MessageConverter najdete v oficiálním projektu úvodní sady Spring JMS.
Odtud můžete vytvořit novou QueueReceiveService třídu Java, jak je znázorněno v následujícím příkladu. Tato třída slouží k definování příjemce zprávy.
```
@Component
public class QueueReceiveService {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    @JmsListener(destination = QUEUE_NAME, containerFactory = "jmsListenerContainerFactory")
    public void receiveMessage(User user) {
        System.out.printf("Received a message from %s.", user.getName());
    }
}
```
Poznámka:

Zástupný symbol nahraďte <service-bus-queue-name> vlastním názvem fronty nakonfigurovaným v oboru názvů služby Service Bus.

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

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

@SpringBootApplication
@EnableJms
public class ServiceBusJmsStarterApplication {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(ServiceBusJMSQueueApplication.class, args);
        JmsTemplate jmsTemplate = context.getBean(JmsTemplate.class);

        // Send a message with a POJO - the template reuse the message converter
        System.out.println("Sending a user message.");
        jmsTemplate.convertAndSend(QUEUE_NAME, new User("Tom"));
    }
}

Poznámka:

Zástupný symbol nahraďte <service-bus-queue-name> vlastním názvem fronty nakonfigurovaným v oboru názvů služby Service Bus.

Tip

Nezapomeňte přidat poznámku @EnableIntegration , která aktivuje zjišťování metod anotovaných @JmsListenerpomocí , vytvoření kontejneru naslouchacího procesu zpráv pod obálkami.

Spusťte aplikaci. Zobrazí se protokoly podobné následujícímu příkladu:
```
Sending a user message.
Received a message from Tom.
```

Další informace

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

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

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

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

ServiceBusTemplate: odesílání zpráv do front a témat služby Service Bus asynchronně a synchronně.
@ServiceBusListener: Označte metodu jako cíl naslouchacího procesu zpráv služby Service Bus v cíli.

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

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

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

Kusovník materiálů (BOM) Spring Cloud v Azure:
```
<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>
```
Poznámka:

Pokud používáte Spring Boot 2.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 4.19.0. Tato faktura materiálu (BOM) by měla být nakonfigurována v <dependencyManagement> části vašeho pom.xml souboru. Tím se zajistí, že všechny závislosti Azure Spring Cloudu budou používat stejnou verzi. Další informace o verzi použité pro tuto kusovníku najdete v tématu Jakou verzi Spring Cloud Azure mám použít.

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

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

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

Nakonfigurujte obor názvů a typ fronty pro službu Service Bus, jak je znázorněno v následujícím příkladu:
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
spring.cloud.azure.servicebus.entity-type=queue
```
Poznámka:

Pokud používáte téma nebo předplatné, změňte spring.cloud.azure.servicebus.entity-type hodnotu na topic.
Vytvořte novou ConsumerService třídu Java, jak je znázorněno v následujícím příkladu. Tato třída slouží k definování příjemce zprávy.
```
@Service
public class ConsumerService {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    @ServiceBusListener(destination = QUEUE_NAME)
    public void handleMessageFromServiceBus(String message) {
        System.out.printf("Consume message: %s%n", message);
    }

}
```
Poznámka:

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

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

@SpringBootApplication
@EnableAzureMessaging
public class Application {

    private static final String QUEUE_NAME = "<service-bus-queue-name>";

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(Application.class);
        ServiceBusTemplate serviceBusTemplate = applicationContext.getBean(ServiceBusTemplate.class);
        System.out.println("Sending a message to the queue.");
        serviceBusTemplate.sendAsync(QUEUE_NAME, MessageBuilder.withPayload("Hello world").build()).subscribe();
    }
}

Tip

Nezapomeňte přidat poznámku @EnableAzureMessaging , která aktivuje zjišťování metod anotovaných @ServiceBusListenerpomocí , vytvoření kontejneru naslouchacího procesu zpráv pod obálkami.

Spusťte aplikaci. Zobrazí se protokoly podobné následujícímu příkladu:
```
Sending a message to the queue.
Consume message: Hello world.
```

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

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

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

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

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

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

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

Kusovník materiálů (BOM) Spring Cloud v Azure:
```
<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>
```
Poznámka:

Pokud používáte Spring Boot 2.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 4.19.0. Tato faktura materiálu (BOM) by měla být nakonfigurována v <dependencyManagement> části vašeho pom.xml souboru. Tím se zajistí, že všechny závislosti Azure Spring Cloudu budou používat stejnou verzi. Další informace o verzi použité pro tuto kusovníku najdete v tématu Jakou verzi Spring Cloud Azure mám použít.

Artefakt integrace služby Azure Service Bus služby Spring Cloud:

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

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

Nakonfigurujte obor názvů služby Service Bus, jak je znázorněno v následujícím příkladu:
```
spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
```

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

@Configuration
public class QueueReceiveConfiguration {

    private static final String INPUT_CHANNEL = "queue.input";
    private static final String QUEUE_NAME = "<your-servicebus-queue-name>";
    private static final String SERVICE_BUS_MESSAGE_LISTENER_CONTAINER = "queue-listener-container";

    /**
     * This message receiver binding with {@link ServiceBusInboundChannelAdapter}
     * via {@link MessageChannel} has name {@value INPUT_CHANNEL}
     */
    @ServiceActivator(inputChannel = INPUT_CHANNEL)
    public void messageReceiver(byte[] payload) {
        String message = new String(payload);
        System.out.printf("New message received: '%s'%n", message);
    }

    @Bean(SERVICE_BUS_MESSAGE_LISTENER_CONTAINER)
    public ServiceBusMessageListenerContainer messageListenerContainer(ServiceBusProcessorFactory processorFactory) {
        ServiceBusContainerProperties containerProperties = new ServiceBusContainerProperties();
        containerProperties.setEntityName(QUEUE_NAME);
        return new ServiceBusMessageListenerContainer(processorFactory, containerProperties);
    }

    @Bean
    public ServiceBusInboundChannelAdapter queueMessageChannelAdapter(
        @Qualifier(INPUT_CHANNEL) MessageChannel inputChannel,
        @Qualifier(SERVICE_BUS_MESSAGE_LISTENER_CONTAINER) ServiceBusMessageListenerContainer listenerContainer) {
        ServiceBusInboundChannelAdapter adapter = new ServiceBusInboundChannelAdapter(listenerContainer);
        adapter.setOutputChannel(inputChannel);
        return adapter;
    }

    @Bean(name = INPUT_CHANNEL)
    public MessageChannel input() {
        return new DirectChannel();
    }
}

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

@Configuration
public class QueueSendConfiguration {

    private static final String OUTPUT_CHANNEL = "queue.output";
    private static final String QUEUE_NAME = "<your-servicebus-queue-name>";

    @Bean
    @ServiceActivator(inputChannel = OUTPUT_CHANNEL)
    public MessageHandler queueMessageSender(ServiceBusTemplate serviceBusTemplate) {
        serviceBusTemplate.setDefaultEntityType(ServiceBusEntityType.QUEUE);
        DefaultMessageHandler handler = new DefaultMessageHandler(QUEUE_NAME, serviceBusTemplate);
        handler.setSendCallback(new ListenableFutureCallback<Void>() {
            @Override
            public void onSuccess(Void result) {
                System.out.println("Message was sent successfully.");
            }

            @Override
            public void onFailure(Throwable ex) {
                System.out.println("There was an error sending the message.");
            }
        });

        return handler;
    }

    /**
     * Message gateway binding with {@link MessageHandler}
     * via {@link MessageChannel} has name {@value OUTPUT_CHANNEL}
     */
    @MessagingGateway(defaultRequestChannel = OUTPUT_CHANNEL)
    public interface QueueOutboundGateway {
        void send(String text);
    }
}

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

@SpringBootApplication
@EnableIntegration
@Configuration(proxyBeanMethods = false)
public class ServiceBusIntegrationApplication {

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

}

Tip

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

Spusťte aplikaci. Zobrazí se protokoly podobné následujícímu příkladu:
```
Message was sent successfully.
New message received: 'Hello World'
```

Použití Binderu služby Spring Cloud Stream Service Bus

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

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

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

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

Kusovník materiálů (BOM) Spring Cloud v Azure:
```
<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>
```
Poznámka:

Pokud používáte Spring Boot 2.x, nezapomeňte nastavit spring-cloud-azure-dependencies verzi na 4.19.0. Tato faktura materiálu (BOM) by měla být nakonfigurována v <dependencyManagement> části vašeho pom.xml souboru. Tím se zajistí, že všechny závislosti Azure Spring Cloudu budou používat stejnou verzi. Další informace o verzi použité pro tuto kusovníku najdete v tématu Jakou verzi Spring Cloud Azure mám použít.

Artefakt integrace služby Azure Service Bus služby Spring Cloud:

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

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

Nakonfigurujte obor názvů služby Service Bus, jak je znázorněno v následujícím příkladu:
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
```
Vytvořte příjemce zprávy.

Pokud chcete aplikaci použít jako jímku událostí, nakonfigurujte vstupní pořadač zadáním následujících informací:
- Deklarujte bean, který definuje logiku Consumer zpracování zpráv. Například následující Consumer bean má název consume:
```
@Bean
public Consumer<Message<String>> consume() {
    return message -> {
        System.out.printf("New message received: '%s'.%n", message.getPayload());
    };
}
```
- Přidejte konfiguraci, která určuje queue název pro využívání nahrazením zástupného symbolu <service-bus-queue-name> , jak je znázorněno v následujícím příkladu:
```
# name for the `Consumer` bean
spring.cloud.function.definition=consume
spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-queue-name>
```
  Poznámka:
  
  Pokud chcete využívat předplatné služby Service Bus, nezapomeňte změnit consume-in-0 vlastnosti vazby, jak je znázorněno v následujícím příkladu:
```
spring.cloud.stream.bindings.consume-in-0.destination=<service-bus-topic-name>
spring.cloud.stream.bindings.consume-in-0.group=<service-bus-subscription-name>
```
Vytvořte odesílatele zprávy.

Pokud chcete aplikaci použít jako zdroj událostí, nakonfigurujte výstupní pořadač zadáním následujících informací:
- Supplier Definujte bean, který definuje, odkud zprávy pocházejí z vaší aplikace.
```
@Bean
return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}
```
- Přidejte konfiguraci pro zadání queue názvu pro odeslání nahrazením zástupného symbolu <your-servicebus-queue-name> v následujícím příkladu:
```
# "consume" is added from the previous step
spring.cloud.function.definition=consume;supply
spring.cloud.stream.bindings.supply-out-0.destination=<your-servicebus-queue-name>
spring.cloud.stream.servicebus.bindings.supply-out-0.producer.entity-type=queue
```
  Poznámka:
  
  Chcete-li odeslat do tématu služby Service Bus, nezapomeňte změnit entity-type na topic.
Spusťte aplikaci. Zobrazí se protokoly podobné následujícímu příkladu:
```
Sending a message.
New message received: 'Hello world'.
```

Nasazení do Azure Spring Apps

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

Další kroky

Ukázky služby Azure Service Bus pro vývojáře Spring Cloudu

Viz také

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

Sdílet prostřednictvím

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

Požadavky

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

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

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

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

Použití funkce Spring Boot Autoconfiguration

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

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

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

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

Další informace

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

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

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

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

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

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

Použití Binderu služby Spring Cloud Stream Service Bus

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

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

Nasazení do Azure Spring Apps

Další kroky

Viz také

Váš názor

Další materiály