Compartilhar via

Usar Azure Service Bus em aplicativos Spring

Este artigo mostra como usar Azure Service Bus em aplicativos Java criados com Spring Framework.

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

O Spring Cloud Azure fornece vários módulos para enviar mensagens e receber mensagens de Service Bus queues e topics/subscriptions usando estruturas spring.

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

Pré-requisitos

Observação

Para conceder acesso à sua conta aos recursos do Service Bus, no namespace Azure Service Bus recém-criado, atribua as funções Azure Service Bus Data Sender e Azure Service Bus Data Receiver ao Microsoft Entra conta que você está usando no momento. Para obter mais informações, consulte 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, conectar-se a um serviço Azure requer autenticação. Para concluir a autenticação, você precisa usar a biblioteca de clientes do Azure Identity. O Spring Cloud Azure usa DefaultAzureCredential, que a biblioteca de identidades 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 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, consulte a seção DefaultAzureCredential em Autenticar aplicativos Java hospedados no Azure.

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

Observação

Azure Service Bus para API JMS atualmente não dá suporte a DefaultAzureCredential. Se você estiver usando o Spring JMS com Service Bus, ignore esta etapa.

Usar o Spring Cloud Azure Service Bus Starter

O módulo Spring Cloud Azure Service Bus Starter importa biblioteca de cliente do Service Bus Java com a estrutura Spring Boot. Você pode usar o Spring Cloud Azure e o Azure SDK juntos, em um padrão não mutuamente exclusivo. Assim, você pode continuar usando a API do cliente Service Bus Java 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:

  • Spring Cloud Azure Bill of Materials (BOM):

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

    Observação

    Se você estiver usando o Spring Boot 4.0.x, defina a spring-cloud-azure-dependencies versão como 7.1.0.

    Se você estiver usando o Spring Boot 3.5.x, defina a spring-cloud-azure-dependencies versão como 6.1.0.

    Se você estiver usando o Spring Boot 3.1.x-3.5.x, defina a spring-cloud-azure-dependencies versão como 5.25.0.

    Se você estiver usando o Spring Boot 2.x, certifique-se de definir a spring-cloud-azure-dependencies versão como 4.20.0.

    Esta lista de materiais (BOM) deve ser configurada na <dependencyManagement> seção do arquivo pom.xml. Isso garante que todas as dependências de Azure do Spring Cloud estejam usando a mesma versão.

    Para obter mais informações sobre a versão usada para este BOM, consulte Which Version of Spring Cloud Azure Should I Use.

  • O artefato de Azure Service Bus do 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 Service Bus Java 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 programaticamente por conta própria.

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 proporcionam uma experiência mais flexível e eficiente ao desenvolver com clientes Service Bus.

  • 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 ao framework Spring Boot o processo de aprender o padrão builder e registrar este cliente no contexto do aplicativo. 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

Azure Java SDK para Service Bus fornece vários clientes para interagir com Service Bus. O starter também fornece autoconfiguração para todos os clientes do Service Bus e os montadores de clientes. Aqui usamos somente ServiceBusSenderClient e ServiceBusProcessorClient como exemplos.

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

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

  1. Configure o namespace e a fila 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

    Dica

    Aqui, usamos a fila do Service Bus 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 ServiceBusProcessorClientConfiguration Java, 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!

Desenvolver clientes do Service Bus de maneira programática

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 ServiceBusClientConfiguration Java, 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 Service Bus no portal do Azure. Substitua o marcador de posição <service-bus-queue-name> pelo nome da fila que você configurou no namespace do Service Bus.

  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, a criação dos componentes de cliente por conta própria não é necessária com o Spring Cloud Azure. Em vez disso, você pode injetar diretamente os beans e usar as propriedades de configuração com as quais você 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 dos SDKs de Serviço do Azure na configuração do Spring Cloud Azure.

  • 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 de Azure. Para obter mais informações, consulte Conectar a diferentes nuvens do Azure.

Usar o iniciador do JMS do Spring Cloud Azure Service Bus

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


Este guia mostra como usar o Spring Cloud Azure Service Bus Starter para API JMS para enviar mensagens e receber mensagens de 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:

  • Spring Cloud Azure Bill of Materials (BOM):

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

    Observação

    Se você estiver usando o Spring Boot 4.0.x, defina a spring-cloud-azure-dependencies versão como 7.1.0.

    Se você estiver usando o Spring Boot 3.5.x, defina a spring-cloud-azure-dependencies versão como 6.1.0.

    Se você estiver usando o Spring Boot 3.1.x-3.5.x, defina a spring-cloud-azure-dependencies versão como 5.25.0.

    Se você estiver usando o Spring Boot 2.x, certifique-se de definir a spring-cloud-azure-dependencies versão como 4.20.0.

    Esta lista de materiais (BOM) deve ser configurada na <dependencyManagement> seção do arquivo pom.xml. Isso garante que todas as dependências de Azure do Spring Cloud estejam usando a mesma versão.

    Para obter mais informações sobre a versão usada para este BOM, consulte Which Version of Spring Cloud Azure Should I Use.

  • O artefato JMS do Spring Cloud Azure Service Bus:

    <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 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 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 QueueReceiveService 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 marcador de posição <service-bus-queue-name> pelo nome da fila configurado no seu namespace do Service Bus.

    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 marcador de posição <service-bus-queue-name> pelo nome da fila configurado no seu namespace do Service Bus.

    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 JMS com Service Bus e AMQP 1.0.

Usar o Service Bus do Azure no Spring Messaging

O módulo Spring Messaging Azure Service Bus oferece suporte à 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 Service Bus de forma assíncrona e síncrona.
  • @ServiceBusListener: marque um método para ser o alvo de um ouvinte de mensagens do Service Bus no destino.

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

Adicionar a dependência do Service Bus

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

  • Spring Cloud Azure Bill of Materials (BOM):

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

    Observação

    Se você estiver usando o Spring Boot 4.0.x, defina a spring-cloud-azure-dependencies versão como 7.1.0.

    Se você estiver usando o Spring Boot 3.5.x, defina a spring-cloud-azure-dependencies versão como 6.1.0.

    Se você estiver usando o Spring Boot 3.1.x-3.5.x, defina a spring-cloud-azure-dependencies versão como 5.25.0.

    Se você estiver usando o Spring Boot 2.x, certifique-se de definir a spring-cloud-azure-dependencies versão como 4.20.0.

    Esta lista de materiais (BOM) deve ser configurada na <dependencyManagement> seção do arquivo pom.xml. Isso garante que todas as dependências de Azure do Spring Cloud estejam usando a mesma versão.

    Para obter mais informações sobre a versão usada para este BOM, consulte Which Version of Spring Cloud Azure Should I Use.

  • Os artefatos de inicialização 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>

Codificar 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 valor de spring.cloud.azure.servicebus.entity-type para topic.

  2. Crie uma nova classe ConsumerService 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 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 Spring Integration com Azure Service Bus

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

Se o aplicativo Spring usar canais de mensagem do Spring Integration, você poderá 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 Service Bus para um canal de mensagem. 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 mensagens e receber mensagens de Service Bus.

Adicionar a dependência do Service Bus

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

  • Spring Cloud Azure Bill of Materials (BOM):

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

    Observação

    Se você estiver usando o Spring Boot 4.0.x, defina a spring-cloud-azure-dependencies versão como 7.1.0.

    Se você estiver usando o Spring Boot 3.5.x, defina a spring-cloud-azure-dependencies versão como 6.1.0.

    Se você estiver usando o Spring Boot 3.1.x-3.5.x, defina a spring-cloud-azure-dependencies versão como 5.25.0.

    Se você estiver usando o Spring Boot 2.x, certifique-se de definir a spring-cloud-azure-dependencies versão como 4.20.0.

    Esta lista de materiais (BOM) deve ser configurada na <dependencyManagement> seção do arquivo pom.xml. Isso garante que todas as dependências de Azure do Spring Cloud estejam usando a mesma versão.

    Para obter mais informações sobre a versão usada para este BOM, consulte Which Version of Spring Cloud Azure Should I Use.

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

    <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 do Service Bus, conforme mostrado no exemplo a seguir:

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

  2. Crie uma nova classe QueueReceiveConfiguration 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 classe QueueSendConfiguration 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 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 Spring Cloud Stream Service Bus Binder

Para chamar a API 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 mensagens e receber mensagens de 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:

  • Spring Cloud Azure Bill of Materials (BOM):

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

    Observação

    Se você estiver usando o Spring Boot 4.0.x, defina a spring-cloud-azure-dependencies versão como 7.1.0.

    Se você estiver usando o Spring Boot 3.5.x, defina a spring-cloud-azure-dependencies versão como 6.1.0.

    Se você estiver usando o Spring Boot 3.1.x-3.5.x, defina a spring-cloud-azure-dependencies versão como 5.25.0.

    Se você estiver usando o Spring Boot 2.x, certifique-se de definir a spring-cloud-azure-dependencies versão como 4.20.0.

    Esta lista de materiais (BOM) deve ser configurada na <dependencyManagement> seção do arquivo pom.xml. Isso garante que todas as dependências de Azure do Spring Cloud estejam usando a mesma versão.

    Para obter mais informações sobre a versão usada para este BOM, consulte Which Version of Spring Cloud Azure Should I Use.

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

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

    • Declare um Consumer bean 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 de Service Bus, altere as propriedades de associação consume-in-0, 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 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 placeholder <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 de Service Bus, altere 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 em Azure Spring Apps

Agora que você tem o aplicativo Spring Boot em execução localmente, é hora de movê-lo para produção. Azure Spring Apps facilita a implantação de aplicativos Spring Boot para 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. Azure Spring Apps fornece gerenciamento de ciclo de vida usando monitoramento e diagnóstico abrangentes, gerenciamento de configuração, descoberta de serviço, integração de CI/CD, implantações azul-verde e muito mais. Para implantar seu aplicativo em Azure Spring Apps, consulte Deploy seu primeiro aplicativo para Azure Spring Apps.

Próximas etapas

Azure para desenvolvedores do SpringSpring Cloud Azure Service Bus Samples

Confira também

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

  • Last updated on