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 Estrutura do Spring.

O Azure fornece uma plataforma de mensagens assíncrona chamada Barramento de Serviço do Azure (Barramento de Serviço), que é baseada no padrão Advanced Message Queueing Protocol 1.0 (AMQP 1.0). Você pode usar o Barramento de Serviço em todas as plataformas do Azure compatíveis.

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

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

• O Barramento de Serviço do Iniciador do Azure Spring Cloud habilita que você envie e receba mensagens com a biblioteca de clientes do SDK Java do Barramento de Serviço com recursos do Spring Boot.

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

• O Barramento de Serviço do Azure Spring Messaging habilita que você interaja com o Barramento de Serviço por meio da API Spring Messaging.

• O Barramento de Serviço do Azure Spring Integration habilita que você conecte os Canais de mensagens com o Barramento de Serviço.

• O Spring Cloud Stream Binder para Barramento de Serviço habilita que você use o Barramento de Serviço 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 uma fila ou tópico/assinatura. Se você não tiver um, crie uma fila ou um 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 do Spring Boot, crie um projeto do 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 acesso à sua conta aos recursos do Barramento de Serviço, no namespace do Barramento de Serviço do Azure recém-criado, 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

É necessário o Spring Boot versão 2.5 ou superior para concluir as etapas neste tutorial.

Preparar o ambiente local

Nesse 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 clientes da Identidade do Azure. O Azure Spring Cloud usa DefaultAzureCredential, que a biblioteca Azure Identity fornece para ajudá-lo a obter credenciais sem nenhuma alteração de código.

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

Para usar a CLI do Azure, o IntelliJ ou outros métodos para concluir a autenticação em ambientes de desenvolvimento locais, 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

A API do Barramento de Serviço do Azure para JMS não dá suporte a DefaultAzureCredential. Se você estiver usando o Spring JMS com o Barramento de Serviço, ignore esta etapa.

Use o Barramento de Serviço do Iniciador do Azure Spring Cloud

O módulo Barramento de Serviço do Iniciador do Azure Spring Cloud importa a biblioteca de clientes Java do Barramento de Serviço com a estrutura Spring Boot. Você pode usar o Azure Spring Cloud 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 Barramento de Serviço em seu aplicativo Spring.

Adicionar a dependência do Barramento de Serviço

Para instalar o módulo do Barramento de Serviço do Iniciador do Azure Spring Cloud, adicione as seguintes dependências ao arquivo pom.xml:

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

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

  Observação

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

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

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

Codificar o aplicativo para enviar e receber mensagens

Este guia ensina como usar os clientes Java do Barramento de Serviço 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 do contexto do Spring. A maneira alternativa é criar clientes por conta própria programaticamente.

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

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

• Você pode delegar à estrutura do Spring Boot o processo de aprender o padrão de criação e registrar esse cliente no contexto do aplicativo para a estrutura do Spring Boot. Essa delegação o habilita a se concentrar em como usar os clientes com seus próprios requisitos de negócios.

• Você pode usar o indicador de integridade de 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 do Java do Azure para Barramento de Serviço fornece vários clientes para interagir com o Barramento de Serviço. O iniciador também fornece configuração automática para todos os clientes e construtores de clientes do Barramento de Serviço. Aqui usamos somente ServiceBusSenderClient e ServiceBusProcessorClient como exemplos.

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

Para enviar e receber mensagens do Barramento de Serviços, configure o aplicativo usando as seguintes etapas:

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

   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 propriedade spring.cloud.azure.servicebus.processor.subscription-name e alterar o valor entity-type para topic.

2. Crie uma nova classe Java ServiceBusProcessorClientConfiguration conforme mostrado no exemplo a seguir. Essa classe é usada para registrar o manipulador de mensagens e erros de 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 seguinte exemplo:

   @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 automática ServiceBusProcessorClient é gerenciado pelo contexto do Spring. O processador é iniciado automaticamente quando o Contexto do Aplicativo Spring é iniciado e interrompido quando o Contexto do Aplicativo Spring é interrompido. Para desabilitar o recurso, configure spring.cloud.azure.servicebus.processor.auto-startup=false.

4. Inicie o aplicativo. São exibidos logs semelhantes ao exemplo seguinte:

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

Criar clientes do Barramento de Serviço programaticamente

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

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

   @Configuration(proxyBeanMethods = false)
   public class ServiceBusClientConfiguration {
   
       private static final String SERVICE_BUS_FQDN = "<service-bus-fully-qualified-namespace>";
       private static final String QUEUE_NAME = "<service-bus-queue-name>";
   
       @Bean
       ServiceBusClientBuilder serviceBusClientBuilder() {
           return new ServiceBusClientBuilder()
                      .fullyQualifiedNamespace(SERVICE_BUS_FQDN)
                      .credential(new DefaultAzureCredentialBuilder().build());
       }
   
       @Bean
       ServiceBusSenderClient serviceBusSenderClient(ServiceBusClientBuilder builder) {
           return builder
                  .sender()
                  .queueName(QUEUE_NAME)
                  .buildClient();
       }
   
       @Bean
       ServiceBusProcessorClient serviceBusProcessorClient(ServiceBusClientBuilder builder) {
           return builder.processor()
                         .queueName(QUEUE_NAME)
                         .processMessage(ServiceBusClientConfiguration::processMessage)
                         .processError(ServiceBusClientConfiguration::processError)
                         .buildProcessorClient();
       }
   
       private static void processMessage(ServiceBusReceivedMessageContext context) {
           ServiceBusReceivedMessage message = context.getMessage();
           System.out.printf("Processing message. Id: %s, Sequence #: %s. Contents: %s%n",
               message.getMessageId(), message.getSequenceNumber(), message.getBody());
       }
   
       private static void processError(ServiceBusErrorContext context) {
           System.out.printf("Error when receiving messages from namespace: '%s'. Entity: '%s'%n",
                   context.getFullyQualifiedNamespace(), context.getEntityPath());
       }
   }
   

   Observação

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

2. Injete os beans do cliente em seu aplicativo, como mostrado no seguinte exemplo:

   @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 exibidos logs semelhantes ao exemplo seguinte:

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

A seguinte lista mostra alguns dos motivos pelos quais esse código não é flexível ou gracioso:

• O namespace e os nomes de fila/tópico/assinatura são codificados.
• Se você usa @Value para obter configurações do ambiente Spring, não pode ter dicas de IDE em seu 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 por conta própria não é necessário com o Azure Spring Cloud. 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 Barramento de Serviço.

O Azure Spring Cloud 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 Azure Spring Cloud.

• Opções de proxy.
• Opções de nova tentativa.
• Opções do cliente de transporte AMQP.

Você também pode se conectar a diferentes nuvens do Azure. Para saber mais, consulte Conectar a diferentes nuvens do Azure.

Use o JMS do Barramento de Serviço do Iniciador do Azure Spring Cloud

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

Este guia mostra como usar o Barramento de Serviço do Iniciador do Azure Spring Cloud para a API JMS para enviar e receber mensagens do Barramento de Serviço.

Adicionar a dependência do Barramento de Serviço

Para instalar o módulo do JMS do Barramento de Serviço do Iniciador do Azure Spring Cloud, adicione as seguintes dependências ao arquivo pom.xml:

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

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

  Observação

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

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

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

Codificar o aplicativo para enviar e receber mensagens

1. Configure a cadeia de conexão e o tipo de preços do seu Barramento de Serviço, conforme mostrado no seguinte exemplo:

   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 (objetos Java antigos). Primeiro, defina uma classe genérica User que armazena e recupera o nome do usuário, conforme mostrado no seguinte exemplo:

   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 em 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 classe Java QueueReceiveService, 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> com seu próprio nome de fila configurado no namespace do Barramento de Serviço.

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

4. Conecte um remetente e um destinatário para enviar e receber mensagens com o Spring, conforme mostrado no seguinte exemplo:

   @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> com seu próprio nome de fila configurado no namespace do Barramento de Serviço.

   Dica

   Certifique-se de adicionar a anotação @EnableIntegration, que aciona a descoberta de métodos anotados com @JmsListener, criando o contêiner do ouvinte de mensagem nos bastidores.

5. Inicie o aplicativo. São exibidos logs semelhantes ao exemplo seguinte:

   Sending a user message.
   Received a message from Tom.
   

Outras informações

Para obter mais informações, consulte Como usar a API do JMS com o Barramento de Serviço e o AMQP 1.0.

Usar o Barramento de Serviço do Azure Spring Messaging

O módulo do Barramento de Serviço do Azure do Spring Messaging fornece suporte para a estrutura Spring Messaging com o Barramento de Serviço.

Se você estiver usando o Barramento de Serviço do Azure Spring Messaging, poderá usar os seguintes recursos:

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

Este guia mostra como usar o Barramento de Serviço do Azure Spring Messaging para enviar e receber mensagens do Barramento de Serviço.

Adicionar a dependência do Barramento de Serviço

Para instalar o módulo de Barramento de Serviço do Azure Spring Messaging, adicione a seguinte dependência ao arquivo pom.xml:

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

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

  Observação

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

• Os artefatos do Barramento de Serviço do Spring Messaging e do iniciador do Azure Spring Cloud:

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

Codificar o aplicativo para enviar e receber mensagens

1. Configure o namespace e o tipo de fila para seu Barramento de Serviço, 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 valor de spring.cloud.azure.servicebus.entity-type para topic.

2. Crie uma nova classe Java ConsumerService 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 destination como o nome do tópico e adicione o parâmetro group para descrever o nome da assinatura.

3. Conecte um remetente e um destinatário para enviar e receber mensagens com o Spring, conforme mostrado no seguinte exemplo:

   @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 anotação @EnableAzureMessaging, que aciona a descoberta de métodos anotados com @ServiceBusListener, criando o contêiner do ouvinte de mensagem nos bastidores.

4. Inicie o aplicativo. São exibidos logs semelhantes ao exemplo seguinte:

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

Usar o Barramento do Serviço do Azure Spring Integration

O módulo de Barramento de Serviço do Azure do Spring Integration fornece suporte para a estrutura da Integração do Spring com o Barramento de Serviço.

Se o seu aplicativo Spring usa canais de mensagem da Integração do Spring, você pode rotear mensagens entre os canais de mensagem e o Barramento de Serviço 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 um tópico do Barramento de Serviço.

Este guia mostra como usar o Barramento de Serviço do Azure Spring Integration para enviar e receber mensagens do Barramento de Serviço.

Adicionar a dependência do Barramento de Serviço

Para instalar o módulo do Barramento de Serviço do Azure Spring Integration, adicione as seguintes dependências ao arquivo pom.xml:

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

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

  Observação

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

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

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

Codificar o aplicativo para enviar e receber mensagens

1. Configure o namespace da fila do Barramento de Serviço, conforme mostrado no seguinte exemplo:

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

2. Crie uma nova classe Java QueueReceiveConfiguration 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 classe Java QueueSendConfiguration 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 destinatário para enviar e receber mensagens com o Spring, conforme mostrado no seguinte exemplo:

   @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 anotação @EnableIntegration, que habilita a infraestrutura da Integração do Spring.

5. Inicie o aplicativo. São exibidos logs semelhantes ao exemplo seguinte:

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

Usar o Barramento de Serviço do Spring Cloud Stream Binder

Para chamar a API do Barramento de Serviço em um aplicativo Spring Cloud Stream, use o módulo de Barramento de Serviço do Azure Spring Cloud Stream Binder.

Este guia mostra como usar o Barramento de Serviço do Spring Cloud Stream Binder, para enviar e receber mensagens do Barramento de Serviço.

Adicionar a dependência do Barramento de Serviço

Para instalar o módulo do Barramento de Serviço do Azure Spring Cloud Stream Binder, adicione as seguintes dependências ao arquivo pom.xml:

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

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

  Observação

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

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

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

Codificar o aplicativo para enviar e receber mensagens

1. Configure o namespace da fila do Barramento de Serviço, conforme mostrado no seguinte exemplo:

   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 associador de entrada especificando as seguintes informações:

   • Declare um bean Consumer que define a lógica de manipulação de mensagens. Por exemplo, o bean a seguir Consumer tem o nome de 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 queue nome para consumo substituindo o espaço reservado <service-bus-queue-name>, conforme mostrado no seguinte exemplo:

     # 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, certifique-se de alterar as propriedades de associação consume-in-0, conforme mostrado no seguinte exemplo:

     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 associador de saída especificando as seguintes informações:

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

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

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

     # "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 Barramento de Serviço, certifique-se de alterar o entity-type para topic.

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

   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 produção. Os Aplicativos Spring do Azure facilita a implantação de aplicativos Spring Boot no Azure sem nenhuma alteração no 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

Desenvolvedores do Azure para SpringExemplos do Barramento de Serviço do Azure do Spring Cloud

Confira também

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