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

Tento článek ukazuje, jak používat Azure Service Bus v aplikacích Java vytvořených pomocí Spring Framework.

Azure poskytuje asynchronní platformu zasílání zpráv s názvem Azure Service Bus (Service Bus), která je založená na standardu Advanced Message Queueing Protocol 1.0 (AMQP 1.0). Můžete použít Service Bus v celé řadě podporovaných platforem Azure.

Spring Cloud Azure poskytuje různé moduly pro odesílání zpráv do a přijímání zpráv z Service Bus queues a topics/subscriptions pomocí architektur Spring.

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

Požadavky

Poznámka:

Pokud chcete svému účtu udělit přístup k vašim prostředkům Service Bus, přiřaďte v nově vytvořeném oboru názvů Azure Service Bus role Azure Service Bus Data Sender a Azure Service Bus Data Receiver účtu Microsoft Entra, který právě používáte. Další informace najdete v tématu Assignování rolí Azure pomocí portálu Azure.

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, které knihovna identit Azure poskytuje, aby vám pomohla 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 v části Authenticate Azure hostované Java aplikace.

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, přečtěte si Azure ověřování v Java vývojových prostředích. K dokončení ověřování v Azure hostitelských prostředích 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 s Service Bus, ignorujte tento krok.

Použití Startovacího balíčku Spring Cloud Azure Service Bus

Modul Spring Cloud Azure Service Bus Starter importuje Service Bus Java klientskou knihovnu s architekturou Spring Boot. Spring Cloud Azure a Azure SDK můžete používat společně, aniž by se vzájemně vylučovaly. Proto můžete v aplikaci Spring dál používat rozhraní API klienta Service Bus Java.

Přidej závislost na Service Bus

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

  • Spring Cloud Azure BOM:

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

    Poznámka:

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

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

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

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

    Tato faktura materiálu (BOM) by měla být nakonfigurována v <dependencyManagement> části vašeho pom.xml souboru. Tím zajistíte, že všechny závislosti Spring Cloud Azure budou používat stejnou verzi.

    Další informace o verzi použité pro tento kusovník najdete v tématu Kterou verzi Spring Cloud Azure bych měl použít.

  • Artefakt Spring Cloud Azure Service Bus:

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

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

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

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

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

Azure Java SDK pro Service Bus poskytuje několik klientů pro práci se Service Bus. Počáteční modul také poskytuje automatickou konfiguraci pro všechny klienty Service Bus a nástroje pro tvorbu 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 Service Bus a přijímat je, nakonfigurujte aplikaci pomocí následujícího postupu:

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

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

    Návod

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

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

    @Configuration(proxyBeanMethods = false)
public class ServiceBusProcessorClientConfiguration {

    @Bean
    ServiceBusRecordMessageListener processMessage() {
        return context -> {
            ServiceBusReceivedMessage message = context.getMessage();
            System.out.printf("Processing message. Id: %s, Sequence #: %s. Contents: %s%n", message.getMessageId(),
                    message.getSequenceNumber(), message.getBody());
        };
    }

    @Bean
    ServiceBusErrorHandler processError() {
        return context -> {
            System.out.printf("Error when receiving messages from namespace: '%s'. Entity: '%s'%n",
                    context.getFullyQualifiedNamespace(), context.getEntityPath());
        };
    }
}

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

    @SpringBootApplication
public class ServiceBusQueueApplication implements CommandLineRunner {

    private final ServiceBusSenderClient senderClient;

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

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

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

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

}

    Poznámka:

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

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

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

Programové sestavování klientů Service Bus

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

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

    @Configuration(proxyBeanMethods = false)
public class ServiceBusClientConfiguration {

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

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

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

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

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

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

    Poznámka:

    Nezapomeňte nahradit zástupný symbol <service-bus-fully-qualified-namespace> názvem hostitele Service Bus z portálu Azure. Zástupný symbol <service-bus-queue-name> nahraďte vlastním názvem fronty nakonfigurovaným v oboru názvů Service Bus.

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

    @SpringBootApplication
public class ServiceBusQueueApplication implements CommandLineRunner {

    private final ServiceBusSenderClient senderClient;

    private final ServiceBusProcessorClient processorClient;

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

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

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

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

}

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

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

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

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

Naštěstí není nezbytné vytvářet klientské komponenty sami pomocí služby Azure Spring Cloud. Místo toho můžete beany přímo vložit a použít vlastnosti konfigurace , které už znáte, ke konfiguraci 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 Spring Cloud Azure.

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

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

Použijte Spring Cloud Azure Service Bus JMS Starter

Modul Spring Cloud Azure Service Bus JMS Starter poskytuje Spring JMS integraci s Service Bus. Následující video popisuje, jak integrovat aplikace Spring JMS s Azure Service Bus pomocí JMS 2.0.


V této příručce se dozvíte, jak používat Spring Cloud Azure Service Bus Starter pro rozhraní JMS API k odesílání a přijímání zpráv z Service Bus.

Přidejte závislost na Service Bus

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

  • Spring Cloud Azure BOM:

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

    Poznámka:

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

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

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

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

    Tato faktura materiálu (BOM) by měla být nakonfigurována v <dependencyManagement> části vašeho pom.xml souboru. Tím zajistíte, že všechny závislosti Spring Cloud Azure budou používat stejnou verzi.

    Další informace o verzi použité pro tento kusovník najdete v tématu Kterou verzi Spring Cloud Azure bych měl použít.

  • Balíček Spring Cloud Azure Service Bus JMS:

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

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

  1. Nakonfigurujte připojovací řetězec a cenovou úroveň pro Service Bus, jak ukazuje následující příklad:

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

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

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

    public class User implements Serializable {

    private static final long serialVersionUID = -295422703255886286L;

    private String name;

    public User() {
    }

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

    public String getName() {
        return name;
    }

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

    Návod

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

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

    @Component
public class QueueReceiveService {

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

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

    Poznámka:

    Nezapomeňte nahradit zástupný symbol <service-bus-queue-name> vlastním názvem fronty nakonfigurovaným v oboru názvů Service Bus.

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

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

    @SpringBootApplication
@EnableJms
public class ServiceBusJmsStarterApplication {

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

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

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

    Poznámka:

    Nezapomeňte nahradit zástupný symbol <service-bus-queue-name> vlastním názvem fronty nakonfigurovaným v oboru názvů Service Bus.

    Návod

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

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

    Sending a user message.
Received a message from Tom.

Další informace

Další informace viz Jak používat rozhraní JMS API s Service Bus a AMQP 1.0.

Použití Spring Messaging pro Azure Service Bus

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

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

  • ServiceBusTemplate: posílání zpráv do front a témat Service Bus synchronně a asynchronně.
  • @ServiceBusListener: Označte metodu jako cíl naslouchacího zařízení pro zprávy Service Bus na určeném místě.

V této příručce se dozvíte, jak používat spring messaging Azure Service Bus k odesílání a přijímání zpráv z Service Bus.

Přidejte závislost na Service Bus

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

  • Spring Cloud Azure BOM:

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

    Poznámka:

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

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

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

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

    Tato faktura materiálu (BOM) by měla být nakonfigurována v <dependencyManagement> části vašeho pom.xml souboru. Tím zajistíte, že všechny závislosti Spring Cloud Azure budou používat stejnou verzi.

    Další informace o verzi použité pro tento kusovník najdete v tématu Kterou verzi Spring Cloud Azure bych měl použít.

  • Úvodní artefakty pro Spring Messaging Service Bus a 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>

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

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

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

    Poznámka:

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

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

    @Service
public class ConsumerService {

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

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

}

    Poznámka:

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

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

    @SpringBootApplication
@EnableAzureMessaging
public class Application {

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

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

    Návod

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

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

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

Použijte Spring Integration s Azure Service Bus

Modul integrace Spring Azure Service Bus poskytuje podporu pro architekturu integrace Spring s Service Bus.

Pokud 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 nebo odběru služby Service Bus do kanálu se zprávami. Adaptér odchozího kanálu odesílá zprávy z kanálu zpráv do fronty a topiku/fóra v rámci Service Bus.

V tomto průvodci se dozvíte, jak pomocí aplikace Spring Integration Azure Service Bus odesílat zprávy a přijímat zprávy z Service Bus.

Přidání závislosti Service Bus

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

  • Spring Cloud Azure BOM:

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

    Poznámka:

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

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

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

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

    Tato faktura materiálu (BOM) by měla být nakonfigurována v <dependencyManagement> části vašeho pom.xml souboru. Tím zajistíte, že všechny závislosti Spring Cloud Azure budou používat stejnou verzi.

    Další informace o verzi použité pro tento kusovník najdete v tématu Kterou verzi Spring Cloud Azure bych měl použít.

  • Artefakt integrace Azure Service Bus Spring Cloudu:

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

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

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

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

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

    @Configuration
public class QueueReceiveConfiguration {

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

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

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

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

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

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

    @Configuration
public class QueueSendConfiguration {

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

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

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

        return handler;
    }

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

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

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

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

}

    Návod

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

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

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

Použití aplikace Spring Cloud Stream Service Bus Binder

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

V této příručce se dozvíte, jak používat Spring Cloud Stream Service Bus Binder k odesílání a přijímání zpráv z Service Bus.

Přidej závislost na Service Bus

Pro instalaci modulu Spring Cloud Azure Service Bus Stream Binder přidejte následující závislosti do vašeho souboru pom.xml.

  • Spring Cloud Azure BOM:

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

    Poznámka:

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

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

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

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

    Tato faktura materiálu (BOM) by měla být nakonfigurována v <dependencyManagement> části vašeho pom.xml souboru. Tím zajistíte, že všechny závislosti Spring Cloud Azure budou používat stejnou verzi.

    Další informace o verzi použité pro tento kusovník najdete v tématu Kterou verzi Spring Cloud Azure bych měl použít.

  • Artefakt pro integraci Spring Cloud Azure Service Bus:

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

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

  1. Nakonfigurujte jmenný prostor svého Service Busu, jak je znázorněno v následujícím příkladu:

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

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

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

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

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

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

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

      Poznámka:

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

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

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

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

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

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

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

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

      Poznámka:

      Pokud chcete odeslat do tématu Service Bus, nezapomeňte změnit entity-type na topic.

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

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

Nasazení do Azure Spring Apps

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

Další kroky

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

Viz také

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

  • Last updated on