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

Artigo
01/18/2024

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íncrona 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 Service Bus em toda a variedade de plataformas do Azure com suporte.

O Spring Cloud Azure fornece vários módulos para enviar e receber mensagens de filas do Service Bus e assinaturas de tópicos/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 enviar e receber mensagens com a biblioteca de cliente Java SDK 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 Service Bus.
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 conectar 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 Service Bus. Para obter mais informações, consulte Usar o portal do Azure para criar um namespace do Service Bus e uma fila ou Usar o portal do Azure para criar um tópico do Service Bus e assinaturas para o tópico.
Se você não tiver um aplicativo Spring Boot, crie um projeto Maven com o Spring Initializr. Certifique-se de selecionar Projeto Maven e, em Dependências, adicione a dependência do Spring Web e, em seguida, selecione Java versão 8 ou superior.

Nota

Para conceder à sua conta acesso 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 Recetor de Dados do Barramento de Serviço do Azure à conta do Microsoft Entra que você está usando no momento. Para obter mais informações, consulte Utilizar o portal do Azure para atribuir funções do Azure.

Importante

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

Prepare o seu ambiente local

Neste tutorial, as configurações e o código não têm nenhuma operação de autenticação. No entanto, conectar-se a 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 Identidades do Azure fornece para ajudá-lo a obter credenciais sem alterações de código.

DefaultAzureCredential Suporta vários métodos de autenticação e determina qual método usar em tempo de execução. Essa abordagem permite que seu aplicativo use diferentes métodos de autenticação 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, o 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 o uso da identidade gerenciada. Para obter mais informações, consulte O que são identidades gerenciadas para recursos do Azure?

Nota

A API do Azure Service Bus for JMS atualmente 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 Spring Cloud Azure Service Bus Starter importa a 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 exclusivo mútuo. 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 seu 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>
```
Nota

Se estiver a utilizar o Spring Boot 2.x, certifique-se de que define a spring-cloud-azure-dependencies versão como 4.19.0. Esta lista de materiais (BOM) deve ser configurada na <dependencyManagement> seção do seu arquivo de 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 essa lista técnica, consulte Qual versão do Spring Cloud Azure devo usar.

O artefato do Spring Cloud Azure Service Bus:

<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 maneira, que envolve a fiação automática dos grãos 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 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 aprendizagem 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 seu aplicativo e componentes internos.

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

Nota

O SDK Java do Azure para Service Bus fornece vários clientes para interagir com o Service Bus. O acionador de partida também fornece configuração automática para todos os clientes e construtores de clientes do Service Bus. 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:

Configure seu namespace e fila do Service Bus, 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
```
Gorjeta

Aqui usamos a fila do Service Bus como exemplo. Para usar topic/subscription, você precisa adicionar a spring.cloud.azure.servicebus.processor.subscription-name propriedade e alterar o entity-type valor para topic.

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

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

}

Nota

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

Inicie a aplicação. São mostrados logs semelhantes ao exemplo a seguir:

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

Crie clientes do Service Bus programaticamente

Você pode construir esses grãos de cliente sozinho, mas o processo é complicado. Em 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:

Crie uma nova ServiceBusClientConfiguration classe Java conforme mostrado no exemplo a seguir. Esta classe é usada para declarar o e ServiceBusProcessorClient beansServiceBusSenderClient.

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

Nota

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

Injete os beans 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();
    }

}

Inicie a aplicação. 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:

Os nomes de namespace e 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 Azure Service Bus usando JMS 2.0.

Este guia mostra como usar o Spring Cloud Azure Service Bus Starter for 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 seu 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>
```
Nota

Se estiver a utilizar o Spring Boot 2.x, certifique-se de que define a spring-cloud-azure-dependencies versão como 4.19.0. Esta lista de materiais (BOM) deve ser configurada na <dependencyManagement> seção do seu arquivo de 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 essa lista técnica, 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

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>

Crie o recetor 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 armazene e recupere 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;
    }
}
```
Gorjeta

Serializable é implementado para utilizar o método send no JmsTemplate no Spring Framework. Caso contrário, você deve definir um bean personalizado MessageConverter para serializar o conteúdo para JSON em formato de texto. Para mais informações sobre MessageConverter, consulte o projeto oficial do Spring JMS Starter.
A partir daqui, você pode criar uma nova QueueReceiveService classe Java, conforme mostrado no exemplo a seguir. Esta classe é usada para definir um recetor 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());
    }
}
```
Nota

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

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.

Conecte um remetente e um recetor 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"));
    }
}

Nota

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

Gorjeta

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

Inicie a aplicação. 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 do Spring Messaging Azure Service Bus fornece suporte para a estrutura do Spring Messaging com o Service Bus.

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

ServiceBusTemplate: enviar mensagens para filas e tópicos do Service Bus 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 do Spring Messaging Azure Service Bus, adicione as seguintes dependências ao seu 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>
```
Nota

Se estiver a utilizar o Spring Boot 2.x, certifique-se de que define a spring-cloud-azure-dependencies versão como 4.19.0. Esta lista de materiais (BOM) deve ser configurada na <dependencyManagement> seção do seu arquivo de 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 essa lista técnica, 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

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

Se estiver a utilizar um tópico/subscrição, altere o spring.cloud.azure.servicebus.entity-type valor para topic.
Crie uma nova ConsumerService classe Java conforme mostrado no exemplo a seguir. Esta classe é usada para definir um recetor 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);
    }

}
```
Nota

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

Conecte um remetente e um recetor 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();
    }
}

Gorjeta

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

Inicie a aplicação. 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 do Spring Integration Azure Service Bus fornece suporte para a estrutura do Spring Integration com o Service Bus.

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

Um adaptador de canal de entrada encaminha mensagens de uma fila ou assinatura do Service Bus para um canal de mensagens. Um adaptador de canal de saída publica mensagens de um canal de mensagens para uma fila e um tópico do Service Bus.

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 Spring Cloud Azure Service Bus Integration Starter, adicione as seguintes dependências ao seu 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>
```
Nota

Se estiver a utilizar o Spring Boot 2.x, certifique-se de que define a spring-cloud-azure-dependencies versão como 4.19.0. Esta lista de materiais (BOM) deve ser configurada na <dependencyManagement> seção do seu arquivo de 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 essa lista técnica, 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

Configure o namespace do Service Bus, conforme mostrado no exemplo a seguir:
```
spring.cloud.azure.servicebus.namespace=<your-servicebus-namespace-name>
```

Crie uma nova QueueReceiveConfiguration classe Java conforme mostrado no exemplo a seguir. Esta classe é usada para definir um recetor 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();
    }
}

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

Conecte um remetente e um recetor 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");
    }

}

Gorjeta

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

Inicie a aplicação. 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 seu 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>
```
Nota

Se estiver a utilizar o Spring Boot 2.x, certifique-se de que define a spring-cloud-azure-dependencies versão como 4.19.0. Esta lista de materiais (BOM) deve ser configurada na <dependencyManagement> seção do seu arquivo de 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 essa lista técnica, 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

Configure o namespace do Service Bus, conforme mostrado no exemplo a seguir:
```
spring.cloud.azure.servicebus.namespace=<service-bus-namespace-name>
```
Crie o recetor 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 é chamado 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 para queue consumo 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>
```
  Nota
  
  Para consumir a partir de uma assinatura do Service Bus, certifique-se de alterar 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>
```
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 define de onde as mensagens vêm 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 espaço reservado <your-servicebus-queue-name> 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
```
  Nota
  
  Para enviar para um tópico do Service Bus, certifique-se de alterar o entity-type para topic.
Inicie a aplicação. 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. O Azure Spring Apps facilita a implantação de aplicativos Spring Boot no Azure sem alterações de código. O serviço gerencia a infraestrutura dos aplicativos Spring para que os desenvolvedores possam se concentrar em seu código. O Azure Spring Apps fornece gerenciamento do ciclo de vida usando monitoramento e diagnóstico abrangentes, gerenciamento de configuração, descoberta de serviços, integração de CI/CD, implantações azul-verde e muito mais. Para implantar seu aplicativo no Azure Spring Apps, consulte Implantar seu primeiro aplicativo no Azure Spring Apps.

Próximos passos

Azure para desenvolvedores do Spring Exemplos do Spring Cloud Azure Service Bus

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

Partilhar via

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

Pré-requisitos

Prepare o seu ambiente local

Usar o Spring Cloud Azure Service Bus Starter

Adicionar a dependência do Service Bus

Codifique o aplicativo para enviar e receber mensagens

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

Crie clientes do Service Bus programaticamente

Usar o Spring Cloud Azure Service Bus JMS Starter

Adicionar a dependência do Service Bus

Codifique o aplicativo para enviar e receber mensagens

Outras informações

Usar o Spring Messaging Azure Service Bus

Adicionar a dependência do Service Bus

Codifique o aplicativo para enviar e receber mensagens

Usar o Spring Integration Azure Service Bus

Adicionar a dependência do Service Bus

Codifique o aplicativo para enviar e receber mensagens

Usar o Spring Cloud Stream Service Bus Binder

Adicionar a dependência do Service Bus

Codifique o aplicativo para enviar e receber mensagens

Implantar no Azure Spring Apps

Próximos passos

Consulte também

Comentários

Recursos adicionais