Usar o Barramento de Serviço do Azure em aplicativos Spring

Este artigo mostra como usar o Barramento de Serviço do Azure em aplicativos Java criados com o Spring Framework.

O Azure fornece uma plataforma de mensagens assíncronas chamada Barramento de Serviço do Azure (Barramento de Serviço), que se baseia no padrão AMQP 1.0 (Advanced Message Queueing Protocol 1.0). Você pode usar o Barramento de Serviço em toda a gama de plataformas do Azure com suporte.

O Spring Cloud Azure fornece vários módulos para enviar e receber mensagens de filas e assinaturas de tópicos/do Barramento de Serviço usando estruturas do Spring.

Você pode usar os seguintes módulos independentemente ou combiná-los para diferentes casos de uso:

• O Spring Cloud Azure Service Bus Starter permite que você envie e receba mensagens com a biblioteca de cliente do SDK Java do Service Bus com recursos do Spring Boot.

• O Spring Cloud Azure Service Bus JMS Starter permite que você use a API JMS para enviar e receber mensagens com filas e tópicos/assinaturas do Barramento de Serviço.

• O Spring Messaging Azure Service Bus permite que você interaja com o Service Bus por meio da API do Spring Messaging .

• O Spring Integration Azure Service Bus permite que você conecte os Canais de Mensagem de Integração do Spring com o Service Bus.

• O Spring Cloud Stream Binder for Service Bus permite que você use o Service Bus como um middleware de mensagens em aplicativos Spring Cloud Stream.

Pré-requisitos

• Uma assinatura do Azure – crie uma gratuitamente.
• Java Development Kit (JDK) versão 8 ou superior.
• Apache Maven, versão 3.0 ou superior.
• Um Barramento de Serviço do Azure e fila ou tópico/assinatura. Se você não tiver um, crie uma fila ou tópico do Barramento de Serviço. Para obter mais informações, consulte Usar o portal do Azure para criar um namespace do Barramento de Serviço e uma fila ou Usar o portal do Azure para criar um tópico do Barramento de Serviço e assinaturas para o tópico.
• Se você não tiver um aplicativo Spring Boot, crie um projeto Maven com o Spring Initializr. Selecione Projeto Maven e, em Dependências, adicione a dependência do Spring Web e selecione Java versão 8 ou superior.

Observação

Para conceder à sua conta acesso aos recursos do Barramento de Serviço, em seu namespace recém-criado do Barramento de Serviço do Azure, atribua as funções Remetente de Dados do Barramento de Serviço do Azure e Receptor de Dados do Barramento de Serviço do Azure à conta do Microsoft Entra que você está usando no momento. Para obter mais informações, confira Atribuir funções do Azure usando o portal do Azure.

Importante

O Spring Boot versão 2.5 ou superior é necessário para concluir as etapas deste tutorial.

Preparar o ambiente local

Neste tutorial, as configurações e o código não têm nenhuma operação de autenticação. No entanto, a conexão com um serviço do Azure requer autenticação. Para concluir a autenticação, você precisa usar a biblioteca de cliente do Azure Identity. O Spring Cloud Azure usa DefaultAzureCredentialo , que a biblioteca de Identidade do Azure fornece para ajudá-lo a obter credenciais sem alterações de código.

DefaultAzureCredential dá suporte a vários métodos de autenticação e determina qual método usar no runtime. Essa abordagem permite que seu aplicativo use métodos de autenticação diferentes em ambientes diferentes, como ambientes locais ou de produção, sem implementar código específico do ambiente. Para obter mais informações, consulte a seção DefaultAzureCredential de Autenticar aplicativos Java hospedados no Azure.

Para usar a CLI do Azure, IntelliJ ou outros métodos para concluir a autenticação em ambientes de desenvolvimento local, consulte Autenticação do Azure em ambientes de desenvolvimento Java. Para concluir a autenticação em ambientes de hospedagem do Azure, recomendamos usar a identidade gerenciada. Para obter mais informações, confira O que são as identidades gerenciadas para recursos do Azure?

Observação

No momento, a API do Barramento de Serviço do Azure para JMS não oferece suporte ao DefaultAzureCredential. Se você estiver usando o Spring JMS com o Service Bus, ignore esta etapa.

Usar o Spring Cloud Azure Service Bus Starter

O módulo inicial do Spring Cloud Azure Service Bus importaa biblioteca de cliente Java do Service Bus com a estrutura Spring Boot. Você pode usar o Spring Cloud Azure e o SDK do Azure juntos, em um padrão não mutuamente exclusivo. Assim, você pode continuar usando a API do cliente Java do Service Bus em seu aplicativo Spring.

Adicionar a dependência do Service Bus

Para instalar o módulo Spring Cloud Azure Service Bus Starter, adicione as seguintes dependências ao arquivo pom.xml :

• A lista de materiais do Spring Cloud Azure (BOM):

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

  Observação

  Se você estiver usando o Spring Boot 2.x, certifique-se de definir a spring-cloud-azure-dependencies versão como 4.17.0. Esta lista de materiais (BOM) deve ser configurada <dependencyManagement> na seção do arquivo pom.xml . Isso garante que todas as dependências do Spring Cloud Azure estejam usando a mesma versão. Para obter mais informações sobre a versão usada para esta BOM, consulte Qual versão do Spring Cloud Azure devo usar.

• O artefato do Barramento de Serviço do Spring Cloud Azure:

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

Codifique o aplicativo para enviar e receber mensagens

Este guia ensina como usar os clientes Java do Service Bus no contexto de um aplicativo Spring. Aqui apresentamos duas alternativas. A maneira recomendada é usar a configuração automática do Spring Boot e usar clientes prontos para uso no contexto do Spring. A maneira alternativa é construir clientes por conta própria programaticamente.

A primeira forma, que envolve a fiação automática dos beans do cliente a partir do contêiner Spring IoC, tem as seguintes vantagens quando comparada com a segunda via. Esses benefícios oferecem uma experiência mais flexível e eficiente ao desenvolver com clientes do Service Bus.

• Você pode usar a configuração externalizada para que possa trabalhar com o mesmo código de aplicativo em ambientes diferentes.

• Você pode delegar o processo de aprendizado do padrão do construtor e registrar esse cliente no contexto do aplicativo para a estrutura do Spring Boot. Essa delegação permite que você se concentre em como usar os clientes com seus próprios requisitos de negócios.

• Você pode usar o indicador de integridade de uma maneira fácil para inspecionar o status e a integridade do aplicativo e dos componentes internos.

O exemplo de código a seguir mostra como usar ServiceBusSenderClient e ServiceBusProcessorClient com essas duas alternativas.

Observação

O SDK Java do Azure para Service Bus fornece vários clientes para interagir com o Service Bus. O iniciador também fornece configuração automática para todos os clientes do Service Bus e construtores de clientes. Aqui usamos apenas ServiceBusSenderClient e ServiceBusProcessorClient como exemplos.

Usar a configuração automática do Spring Boot

Para enviar e receber mensagens do Service Bus, configure o aplicativo usando as seguintes etapas:

1. Configure o namespace e a fila do Barramento de Serviço, conforme mostrado no exemplo a seguir:

   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
   

   Dica

   Aqui usamos a fila do Barramento de Serviço como exemplo. Para usar tópico/assinatura, você precisa adicionar a spring.cloud.azure.servicebus.processor.subscription-name propriedade e alterar o entity-type valor para topic.

2. Crie uma nova ServiceBusProcessorClientConfiguration classe Java, conforme mostrado no exemplo a seguir. Essa classe é usada para registrar a mensagem e o manipulador de erros do 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. Injete o ServiceBusSenderClient em seu aplicativo Spring e chame as APIs relacionadas para enviar mensagens, conforme mostrado no exemplo a seguir:

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

   Observação

   Por padrão, o ciclo de vida do bean com conexão ServiceBusProcessorClient automática é gerenciado pelo contexto Spring. O processador é iniciado automaticamente quando o Spring Application Context é iniciado e interrompido quando o Spring Application Context é interrompido. Para desativar esse recurso, configure spring.cloud.azure.servicebus.processor.auto-startup=falseo .

4. Inicie o aplicativo. São mostrados logs semelhantes ao exemplo a seguir:

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

Criar clientes do Service Bus programaticamente

Você pode criar esses beans de cliente sozinho, mas o processo é complicado. Nos aplicativos Spring Boot, você precisa gerenciar propriedades, aprender o padrão do construtor e registrar o cliente no contexto do aplicativo Spring. O exemplo de código a seguir mostra como fazer isso:

1. Crie uma nova ServiceBusClientConfiguration classe Java, conforme mostrado no exemplo a seguir. Essa classe é usada para declarar o ServiceBusSenderClient e ServiceBusProcessorClient beans.

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

   Observação

   Certifique-se de substituir o <service-bus-fully-qualified-namespace> espaço reservado pelo nome de host do Barramento de Serviço no portal do Azure. Substitua o espaço reservado <service-bus-queue-name> pelo seu próprio nome de fila configurado no namespace do Barramento de Serviço.

2. Injete os beans do cliente em seu aplicativo, conforme mostrado no exemplo a seguir:

   @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. Inicie o aplicativo. São mostrados logs semelhantes ao exemplo a seguir:

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

A lista a seguir mostra os motivos pelos quais esse código não é flexível ou normal:

• O namespace e os nomes de fila/tópico/assinatura são codificados.
• Se você usar @Value para obter configurações do ambiente Spring, não poderá ter dicas do IDE no arquivo application.properties .
• Se você tiver um cenário de microsserviço, deverá duplicar o código em cada projeto, e é fácil cometer erros e difícil ser consistente.

Felizmente, criar os beans do cliente sozinho não é necessário com o Spring Cloud Azure. Em vez disso, você pode injetar diretamente os beans e usar as propriedades de configuração com as quais já está familiarizado para configurar o Service Bus.

O Spring Cloud Azure também fornece as seguintes configurações globais para diferentes cenários. Para obter mais informações, consulte a seção Configuração global para SDKs de serviço do Azure da configuração do Spring Cloud Azure.

• Opções de proxy.
• Opções de repetição novamente.
• Opções do cliente de transporte AMQP.

Você também pode se conectar a diferentes nuvens do Azure. Para obter mais informações, consulte Conectar-se a diferentes nuvens do Azure.

Usar o Spring Cloud Azure Service Bus JMS Starter

O módulo Spring Cloud Azure Service Bus JMS Starter fornece integração do Spring JMS com o Service Bus. O vídeo a seguir descreve como integrar aplicativos Spring JMS com o Barramento de Serviço do Azure usando JMS 2.0.

Este guia mostra como usar o Spring Cloud Azure Service Bus Starter para JMS API para enviar e receber mensagens do Service Bus.

Adicionar a dependência do Service Bus

Para instalar o módulo JMS Starter do Spring Cloud Azure Service Bus, adicione as seguintes dependências ao arquivo pom.xml :

• A lista de materiais do Spring Cloud Azure (BOM):

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

  Observação

  Se você estiver usando o Spring Boot 2.x, certifique-se de definir a spring-cloud-azure-dependencies versão como 4.17.0. Esta lista de materiais (BOM) deve ser configurada <dependencyManagement> na seção do arquivo pom.xml . Isso garante que todas as dependências do Spring Cloud Azure estejam usando a mesma versão. Para obter mais informações sobre a versão usada para esta BOM, consulte Qual versão do Spring Cloud Azure devo usar.

• O artefato JMS do Spring Cloud Azure Service Bus:

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

Codifique o aplicativo para enviar e receber mensagens

1. Configure a cadeia de conexão e a camada de preços para o Service Bus, conforme mostrado no exemplo a seguir:

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

2. Crie o receptor da mensagem.

   O Spring fornece os meios para publicar mensagens em qualquer POJO (Plain Old Java Object). Primeiro, defina uma classe genérica User que armazena e recupera o nome do usuário, conforme mostrado no exemplo a seguir:

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

   Dica

   Serializable será implementado para usar o método send em JmsTemplate na estrutura do Spring. Caso contrário, você deve definir um bean personalizado MessageConverter para serializar o conteúdo para JSON no formato de texto. Para saber mais sobre o MessageConverter, confira o projeto de iniciador de JMS do Spring.

3. A partir daqui, você pode criar uma nova QueueReceiveService classe Java, conforme mostrado no exemplo a seguir. Essa classe é usada para definir um receptor de mensagem.

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

   Observação

   Certifique-se de substituir o espaço reservado <service-bus-queue-name> por seu próprio nome de fila configurado no namespace do Barramento de Serviço.

   Se você estiver usando um tópico/assinatura, altere o destination parâmetro como o nome do tópico e o containerFactory deve ser topicJmsListenerContainerFactory. Além disso, adicione o subscription parâmetro para descrever o nome da assinatura.

4. Conecte um remetente e um receptor para enviar e receber mensagens com o Spring, conforme mostrado no exemplo a seguir:

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

   Observação

   Certifique-se de substituir o espaço reservado <service-bus-queue-name> por seu próprio nome de fila configurado no namespace do Barramento de Serviço.

   Dica

   Certifique-se de adicionar a @EnableIntegration anotação, que dispara a descoberta de métodos anotados com @JmsListener, criando o contêiner de escuta de mensagens sob as capas.

5. Inicie o aplicativo. São mostrados logs semelhantes ao exemplo a seguir:

   Sending a user message.
   Received a message from Tom.
   

Outras informações

Para obter mais informações, consulte Como usar a API JMS com o Service Bus e o AMQP 1.0.

Usar o Spring Messaging Azure Service Bus

O módulo Spring Messaging Azure Service Bus fornece suporte para a estrutura Spring Messaging com Service Bus.

Se você estiver usando o Spring Messaging Azure Service Bus, poderá usar os seguintes recursos:

• ServiceBusTemplate: envie mensagens para filas e tópicos do Barramento de Serviço de forma assíncrona e síncrona.
• @ServiceBusListener: marque um método para ser o destino de um ouvinte de mensagens do Service Bus no destino.

Este guia mostra como usar o Spring Messaging Azure Service Bus para enviar e receber mensagens do Service Bus.

Adicionar a dependência do Service Bus

Para instalar o módulo Spring Messaging Azure Service Bus, adicione as seguintes dependências ao arquivo pom.xml :

• A lista de materiais do Spring Cloud Azure (BOM):

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

  Observação

  Se você estiver usando o Spring Boot 2.x, certifique-se de definir a spring-cloud-azure-dependencies versão como 4.17.0. Esta lista de materiais (BOM) deve ser configurada <dependencyManagement> na seção do arquivo pom.xml . Isso garante que todas as dependências do Spring Cloud Azure estejam usando a mesma versão. Para obter mais informações sobre a versão usada para esta BOM, consulte Qual versão do Spring Cloud Azure devo usar.

• Os artefatos iniciais do Spring Messaging Service Bus e do 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>
  

Codifique o aplicativo para enviar e receber mensagens

1. Configure o namespace e o tipo de fila para o Service Bus, conforme mostrado no exemplo a seguir:

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

   Observação

   Se você estiver usando um tópico/assinatura, altere o spring.cloud.azure.servicebus.entity-type valor para topic.

2. Crie uma nova ConsumerService classe Java, conforme mostrado no exemplo a seguir. Essa classe é usada para definir um receptor de mensagem.

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

   Observação

   Se você estiver usando um tópico/assinatura, altere o parâmetro de anotação de como o nome do destination tópico e adicione o subscription parâmetro para descrever o nome da assinatura.

3. Conecte um remetente e um receptor para enviar e receber mensagens com o Spring, conforme mostrado no exemplo a seguir:

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

   Dica

   Certifique-se de adicionar a @EnableAzureMessaging anotação, que dispara a descoberta de métodos anotados com @ServiceBusListener, criando o contêiner de escuta de mensagens sob as capas.

4. Inicie o aplicativo. São mostrados logs semelhantes ao exemplo a seguir:

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

Usar o Spring Integration Azure Service Bus

O módulo Spring Integration Azure Service Bus fornece suporte para a estrutura Spring Integration com Service Bus.

Se seu aplicativo Spring usa canais de mensagem Spring Integration, você pode rotear mensagens entre seus canais de mensagem e Service Bus usando adaptadores de canal.

Um adaptador de canal de entrada encaminha mensagens de uma fila ou assinatura do Barramento de Serviço para um canal de mensagens. Um adaptador de canal de saída publica mensagens de um canal de mensagens em uma fila e tópico do Barramento de Serviço.

Este guia mostra como usar o Spring Integration Azure Service Bus para enviar e receber mensagens do Service Bus.

Adicionar a dependência do Service Bus

Para instalar o módulo inicial de integração do Spring Cloud Azure Service Bus Starter, adicione as seguintes dependências ao arquivo pom.xml :

• A lista de materiais do Spring Cloud Azure (BOM):

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

  Observação

  Se você estiver usando o Spring Boot 2.x, certifique-se de definir a spring-cloud-azure-dependencies versão como 4.17.0. Esta lista de materiais (BOM) deve ser configurada <dependencyManagement> na seção do arquivo pom.xml . Isso garante que todas as dependências do Spring Cloud Azure estejam usando a mesma versão. Para obter mais informações sobre a versão usada para esta BOM, consulte Qual versão do Spring Cloud Azure devo usar.

• O artefato de integração do Spring Cloud Azure Service Bus:

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

Codifique o aplicativo para enviar e receber mensagens

1. Configure o namespace do Service Bus, conforme mostrado no exemplo a seguir:

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

2. Crie uma nova QueueReceiveConfiguration classe Java, conforme mostrado no exemplo a seguir. Essa classe é usada para definir um receptor de mensagem.

   @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. Crie uma nova QueueSendConfiguration classe Java, conforme mostrado no exemplo a seguir. Essa classe é usada para definir um remetente de mensagem.

   @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. Conecte um remetente e um receptor para enviar e receber mensagens com o Spring, conforme mostrado no exemplo a seguir:

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

   Dica

   Certifique-se de adicionar a @EnableIntegration anotação, que habilita a infraestrutura de integração do Spring.

5. Inicie o aplicativo. São mostrados logs semelhantes ao exemplo a seguir:

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

Usar o Spring Cloud Stream Service Bus Binder

Para chamar a API do Service Bus em um aplicativo Spring Cloud Stream , use o módulo Spring Cloud Azure Service Bus Stream Binder.

Este guia mostra como usar o Spring Cloud Stream Service Bus Binder para enviar e receber mensagens do Service Bus.

Adicionar a dependência do Service Bus

Para instalar o módulo Spring Cloud Azure Service Bus Stream Binder, adicione as seguintes dependências ao arquivo pom.xml :

• A lista de materiais do Spring Cloud Azure (BOM):

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

  Observação

  Se você estiver usando o Spring Boot 2.x, certifique-se de definir a spring-cloud-azure-dependencies versão como 4.17.0. Esta lista de materiais (BOM) deve ser configurada <dependencyManagement> na seção do arquivo pom.xml . Isso garante que todas as dependências do Spring Cloud Azure estejam usando a mesma versão. Para obter mais informações sobre a versão usada para esta BOM, consulte Qual versão do Spring Cloud Azure devo usar.

• O artefato de integração do Spring Cloud Azure Service Bus:

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

Codifique o aplicativo para enviar e receber mensagens

1. Configure o namespace do Service Bus, conforme mostrado no exemplo a seguir:

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

2. Crie o receptor da mensagem.

   Para usar seu aplicativo como um coletor de eventos, configure o fichário de entrada especificando as seguintes informações:

   • Declare um bean que define a Consumer lógica de manipulação de mensagens. Por exemplo, o seguinte Consumer bean é nomeado consume:

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

   • Adicione a configuração para especificar o nome a queue ser consumido substituindo o <service-bus-queue-name> espaço reservado, conforme mostrado no exemplo a seguir:

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

     Observação

     Para consumir de uma assinatura do Barramento de Serviço, altere as consume-in-0 propriedades de vinculação, conforme mostrado no exemplo a seguir:

     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. Crie o remetente da mensagem.

   Para usar seu aplicativo como uma fonte de eventos, configure o fichário de saída especificando as seguintes informações:

   • Defina um Supplier bean que defina de onde as mensagens vêm de dentro do seu aplicativo.

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

   • Adicione a configuração para especificar o nome para queue envio substituindo o <your-servicebus-queue-name> espaço reservado no exemplo a seguir:

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

     Observação

     Para enviar para um tópico do Service Bus, altere o entity-type para topic.

4. Inicie o aplicativo. Você verá logs semelhantes ao exemplo a seguir:

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

Implantar no Azure Spring Apps

Agora que você tem o aplicativo Spring Boot em execução localmente, é hora de movê-lo para a produção. Os Aplicativos Spring do Azure facilitam a implantação de aplicativos Spring Boot no Azure sem alterações de código. O serviço gerencia a infraestrutura dos aplicativos do Spring para que os desenvolvedores possam se concentrar no código. O Azure Spring Apps fornece gerenciamento de ciclo de vida usando monitoramento e diagnóstico abrangentes, gerenciamento de configuração, descoberta de serviços, integração de CI/CD, implantações em “blue-green” e muito mais. Para implantar seu aplicativo nos Aplicativos Spring do Azure, consulte Implantar seu primeiro aplicativo nos Aplicativos Spring do Azure.

Próximas etapas

Azure para desenvolvedoresdo Spring Exemplos do Barramento de Serviço do Azure do Spring Cloud

Confira também

Para obter mais informações sobre mais Spring Boot Starters disponíveis para o Microsoft Azure, consulte O que é o Spring Cloud Azure?