Usar Hubs de Eventos em aplicativos Spring

Este artigo mostra-lhe como usar Hubs de Eventos do Azure em aplicações Java construídas com o Spring Framework.

Hubs de Eventos do Azure é uma plataforma de streaming de big data e serviço de ingestão de eventos. Pode receber e processar milhões de eventos por segundo. Os dados enviados para um hub de eventos podem ser transformados e armazenados usando qualquer fornecedor de análise em tempo real e adaptadores de armazenamento ou agregação.

O Spring Cloud Azure fornece vários módulos para enviar e receber mensagens de Event Hubs utilizando frameworks Spring.

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

• Spring Cloud Hubs de Eventos do Azure Starter permite-lhe enviar e receber mensagens com Event Hubs Java biblioteca cliente SDK com funcionalidades Spring Boot.

• Spring Messaging Hubs de Eventos do Azure permite-lhe interagir com os Event Hubs através da API Spring Messaging.

• Spring Integration Hubs de Eventos do Azure permite-lhe ligar o Spring Integration Message Channels com Event Hubs.

• Spring Cloud Azure Stream Event Hubs Binder permite-lhe usar os Event Hubs como middleware de mensagens em aplicações Spring Cloud Stream.

• Spring Kafka com Hubs de Eventos do Azure permite-te usar Spring Kafka para enviar e receber mensagens dos Event Hubs.

• Spring Cloud Stream Kafka Binder com Hubs de Eventos do Azure permite-lhe enviar e receber mensagens através do Spring Cloud Stream Kafka Binder com Event Hubs.

Pré-requisitos

• Assinatura do Azure - crie uma gratuitamente.

• Java Development Kit (JDK), versão 8 ou superior.

• Apache Maven.

• CLI do Azure.

• Uma instância do Hubs de Eventos do Azure. Para mais informações, consulte Quickstart: Criar um hub de eventos usando Azure portal.

• Uma conta de Armazenamento do Azure para checkpoints do Event Hubs. Para obter mais informações, veja Criar uma conta de armazenamento.

• Um aplicativo Spring Boot. Se você não tiver um, crie um projeto Maven com o Spring Initializr. Lembre-se de selecionar Maven Project e, em Dependências, adicionar a dependência Spring Web e depois selecionar Java versão 8 ou superior.

Nota

Para dar acesso à sua conta a recursos, em Hubs de Eventos do Azure, atribua os papéis Hubs de Eventos do Azure Data Receiver e Hubs de Eventos do Azure Data Sender à conta Microsoft Entra que estás a usar atualmente. Depois, na conta Armazenamento do Azure, atribui a função Storage Blob Data Contributor à conta Microsoft Entra que estás a usar atualmente. Para mais informações sobre a concessão de funções de acesso, consulte Atribuir Azure funções usando o portal Azure e Autorizar o acesso aos recursos do Event Hubs usando Microsoft Entra ID.

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, ligar-se a um serviço Azure requer autenticação. Para completar a autenticação, precisa de usar a biblioteca cliente Azure Identity. O Spring Cloud Azure utiliza DefaultAzureCredential, que a biblioteca Azure Identity fornece para te ajudar a obter credenciais sem quaisquer 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 mais informações, consulte a secção DefaultAzureCredential de Authenticate Azure-hosted Java applications.

Para usar CLI do Azure, IntelliJ ou outros métodos para completar a autenticação em ambientes de desenvolvimento locais, veja Azure autenticação em ambientes de desenvolvimento Java. Para completar a autenticação em ambientes de alojamento Azure, recomendamos o uso de identidade gerida. Para mais informações, consulte O que são identidades geridas para Azure recursos?

Use Spring Cloud Hubs de Eventos do Azure Starter

O módulo Spring Cloud Hubs de Eventos do Azure Starter importa o Event Hubs Java biblioteca do cliente com o framework Spring Boot. Pode usar o Spring Cloud Azure e o SDK do Azure em conjunto, num padrão não mutuamente exclusivo. Assim, pode continuar a usar a API cliente Java do Event Hubs na sua aplicação Spring.

Adicionar dependências

Para instalar o módulo Spring Cloud Hubs de Eventos do Azure Starter, adicione as seguintes dependências ao seu ficheiro pom.xml:

• A Lista de Materiais Spring Cloud Azure (BOM):

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

  Nota

  Se estiveres a usar o Spring Boot 4.0.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 7.2.0.

  Se estiveres a usar o Spring Boot 3.5.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 6.2.0.

  Se estiveres a usar o Spring Boot 3.1.x-3.5.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 5.25.0.

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

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

  Para mais informações sobre a versão usada nesta BOM, veja Qual Versão do Spring Cloud Azure Devo Usar.

• The Spring Cloud Hubs de Eventos do Azure artefact:

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

Codifique o aplicativo para enviar e receber mensagens

Este guia ensina-te a usar os clientes Java do Event Hubs no contexto de uma aplicação Spring. Aqui, apresentamos as duas opções a seguir:

• Use a autoconfiguração do Spring Boot e utilize clientes pré-configurados do contexto do Spring (recomendado).
• Crie o cliente programaticamente.

A injeção automatizada de componentes de cliente do contentor Spring IoC tem as seguintes vantagens, que podem proporcionar uma experiência mais flexível e eficiente ao desenvolver com clientes do Event Hubs:

• Ele aplica 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 do construtor e registrar esse cliente no contexto do aplicativo. Esta delegação permite que você se concentre em como usar os clientes de acordo com os requisitos do seu negócio.
• 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.

As seções a seguir fornecem exemplos de código que mostram como usar EventProcessorClient e EventHubProducerClient com as duas alternativas.

Nota

Azure Java SDK para Centros de Eventos oferece múltiplos clientes para interagir com os Hubs de Eventos. O starter também fornece configuração automática para todos os clientes de Hubs de Eventos, bem como para os criadores de clientes. Este artigo usa apenas EventProcessorClient e EventHubProducerClient como exemplos.

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

Para enviar e receber mensagens de Hubs de Eventos, configure o aplicativo usando as seguintes etapas:

1. Use as seguintes definições de propriedades para configurar o namespace dos Hubs de Eventos e o nome do Hub de Eventos:

   spring.cloud.azure.eventhubs.namespace=<your event-hubs-namespace>
   spring.cloud.azure.eventhubs.event-hub-name=<your-event-hub-name>
   spring.cloud.azure.eventhubs.processor.checkpoint-store.account-name=<your-storage-account-name>
   spring.cloud.azure.eventhubs.processor.checkpoint-store.container-name=<your-storage-account-container-name>
   spring.cloud.azure.eventhubs.processor.consumer-group=$Default
   

2. Crie uma nova classe EventHubProcessorClientConfiguration Java como mostrado no exemplo seguinte. Essa classe é usada para registrar a mensagem e o manipulador de erros para EventProcessorClient.

   import com.azure.spring.cloud.service.eventhubs.consumer.EventHubsErrorHandler;
   import com.azure.spring.cloud.service.eventhubs.consumer.EventHubsRecordMessageListener;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   
   @Configuration
   public class EventHubProcessorClientConfiguration {
   
       private static final Logger LOGGER = LoggerFactory.getLogger(EventHubProcessorClientConfiguration.class);
   
       @Bean
       EventHubsRecordMessageListener processEvent() {
           return eventContext->LOGGER.info("Processing event from partition {} with sequence number {} with body: {}",
               eventContext.getPartitionContext().getPartitionId(), eventContext.getEventData().getSequenceNumber(),
               eventContext.getEventData().getBodyAsString());
       }
   
       @Bean
       EventHubsErrorHandler processError() {
           return errorContext->LOGGER.info("Error occurred in partition processor for partition {}, {}",
               errorContext.getPartitionContext().getPartitionId(),
               errorContext.getThrowable());
       }
   
   }
   

3. Injete o EventProcessorClient e EventHubProducerClient em seu aplicativo Spring e chame as APIs relacionadas para enviar e receber mensagens, conforme mostrado no exemplo a seguir:

   import com.azure.messaging.eventhubs.EventData;
   import com.azure.messaging.eventhubs.EventHubProducerClient;
   import com.azure.messaging.eventhubs.EventProcessorClient;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   import java.util.Collections;
   import java.util.concurrent.TimeUnit;
   
   @SpringBootApplication
   public class EventHubClientApplication implements CommandLineRunner {
   
       private static final Logger LOGGER = LoggerFactory.getLogger(EventHubClientApplication.class);
       private final EventHubProducerClient eventHubProducerClient;
       private final EventProcessorClient eventProcessorClient;
   
       public EventHubClientApplication(EventHubProducerClient eventHubProducerClient,
                                        EventProcessorClient eventProcessorClient) {
           this.eventHubProducerClient = eventHubProducerClient;
           this.eventProcessorClient = eventProcessorClient;
       }
   
       public static void main(String[] args) {
           SpringApplication.run(EventHubClientApplication.class, args);
       }
   
       @Override
       public void run(String... args) throws Exception {
           eventProcessorClient.start();
           // Wait for the processor client to be ready
           TimeUnit.SECONDS.sleep(10);
   
           eventHubProducerClient.send(Collections.singletonList(new EventData("Hello World")));
           LOGGER.info("Successfully sent a message to Event Hubs.");
           eventHubProducerClient.close();
           LOGGER.info("Skip stopping and closing the processor since the processor may not complete the receiving process yet.");
       }
   
   }
   

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

   Successfully sent a message to Event Hubs.
   ...
   Processing event from partition 0 with sequence number 0 with body: Hello World
   ...
   Stopping and closing the processor.
   

Construa o programa cliente de forma programática

Você pode construir os componentes do cliente por si mesmo, 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. As etapas a seguir mostram como fazer isso:

1. Crie uma nova classe EventHubClientConfiguration Java como mostrado no exemplo seguinte. Esta classe é usada para declarar os beans EventProcessorClient e EventHubProducerClient. Certifique-se de substituir os marcadores de posição <your event-hubs-namespace>, <your-event-hub-name>, <your-storage-account-name> e <your-storage-account-container-name> pelos seus valores reais.

   import com.azure.identity.DefaultAzureCredentialBuilder;
   import com.azure.messaging.eventhubs.EventHubClientBuilder;
   import com.azure.messaging.eventhubs.EventHubProducerClient;
   import com.azure.messaging.eventhubs.EventProcessorClient;
   import com.azure.messaging.eventhubs.EventProcessorClientBuilder;
   import com.azure.messaging.eventhubs.checkpointstore.blob.BlobCheckpointStore;
   import com.azure.messaging.eventhubs.models.ErrorContext;
   import com.azure.messaging.eventhubs.models.EventContext;
   import com.azure.storage.blob.BlobContainerAsyncClient;
   import com.azure.storage.blob.BlobContainerClientBuilder;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   
   @Configuration
   public class EventHubClientConfiguration {
   
       private static final Logger LOGGER = LoggerFactory.getLogger(EventHubClientConfiguration.class);
       private static final String EVENT_HUB_FULLY_QUALIFIED_NAMESPACE = "<your event-hubs-namespace>.servicebus.windows.net";
       private static final String EVENT_HUB_NAME = "<your-event-hub-name>";
       private static final String CONSUMER_GROUP = "$Default";
       private static final String STORAGE_ACCOUNT_ENDPOINT = "https://<your-storage-account-name>.blob.core.windows.net";
       private static final String STORAGE_CONTAINER_NAME = "<your-storage-account-container-name>";
   
       @Bean
       EventHubClientBuilder eventHubClientBuilder() {
           return new EventHubClientBuilder().credential(EVENT_HUB_FULLY_QUALIFIED_NAMESPACE, EVENT_HUB_NAME,
               new DefaultAzureCredentialBuilder()
                   .build());
       }
   
       @Bean
       BlobContainerClientBuilder blobContainerClientBuilder() {
           return new BlobContainerClientBuilder().credential(new DefaultAzureCredentialBuilder()
                                                      .build())
                                                  .endpoint(STORAGE_ACCOUNT_ENDPOINT)
                                                  .containerName(STORAGE_CONTAINER_NAME);
       }
   
       @Bean
       BlobContainerAsyncClient blobContainerAsyncClient(BlobContainerClientBuilder blobContainerClientBuilder) {
           return blobContainerClientBuilder.buildAsyncClient();
       }
   
       @Bean
       EventProcessorClientBuilder eventProcessorClientBuilder(BlobContainerAsyncClient blobContainerAsyncClient) {
           return new EventProcessorClientBuilder().credential(EVENT_HUB_FULLY_QUALIFIED_NAMESPACE, EVENT_HUB_NAME,
                                                       new DefaultAzureCredentialBuilder()
                                                           .build())
                                                   .consumerGroup(CONSUMER_GROUP)
                                                   .checkpointStore(new BlobCheckpointStore(blobContainerAsyncClient))
                                                   .processEvent(EventHubClientConfiguration::processEvent)
                                                   .processError(EventHubClientConfiguration::processError);
       }
   
       @Bean
       EventHubProducerClient eventHubProducerClient(EventHubClientBuilder eventHubClientBuilder) {
           return eventHubClientBuilder.buildProducerClient();
   
       }
   
       @Bean
       EventProcessorClient eventProcessorClient(EventProcessorClientBuilder eventProcessorClientBuilder) {
           return eventProcessorClientBuilder.buildEventProcessorClient();
       }
   
       public static void processEvent(EventContext eventContext) {
           LOGGER.info("Processing event from partition {} with sequence number {} with body: {}",
               eventContext.getPartitionContext().getPartitionId(), eventContext.getEventData().getSequenceNumber(),
               eventContext.getEventData().getBodyAsString());
       }
   
       public static void processError(ErrorContext errorContext) {
           LOGGER.info("Error occurred in partition processor for partition {}, {}",
               errorContext.getPartitionContext().getPartitionId(),
               errorContext.getThrowable());
       }
   
   }
   

2. Injete o EventProcessorClient e EventHubProducerClient na sua aplicação Spring, como mostrado no exemplo a seguir:

   import com.azure.messaging.eventhubs.EventData;
   import com.azure.messaging.eventhubs.EventHubProducerClient;
   import com.azure.messaging.eventhubs.EventProcessorClient;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   import java.util.Collections;
   import java.util.concurrent.TimeUnit;
   
   @SpringBootApplication
   public class EventHubClientApplication implements CommandLineRunner {
   
       private static final Logger LOGGER = LoggerFactory.getLogger(EventHubClientApplication.class);
       private final EventHubProducerClient eventHubProducerClient;
       private final EventProcessorClient eventProcessorClient;
   
       public EventHubClientApplication(EventHubProducerClient eventHubProducerClient,
                                        EventProcessorClient eventProcessorClient) {
           this.eventHubProducerClient = eventHubProducerClient;
           this.eventProcessorClient = eventProcessorClient;
       }
   
       public static void main(String[] args) {
           SpringApplication.run(EventHubClientApplication.class, args);
       }
   
       @Override
       public void run(String... args) throws Exception {
           eventProcessorClient.start();
           // Wait for the processor client to be ready
           TimeUnit.SECONDS.sleep(10);
   
           eventHubProducerClient.send(Collections.singletonList(new EventData("Hello World")));
           LOGGER.info("Successfully sent a message to Event Hubs.");
           eventHubProducerClient.close();
           LOGGER.info("Stopping and closing the processor");
           eventProcessorClient.stop();
       }
   
   }
   

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

   Successfully sent a message to Event Hubs.
   ...
   Processing event from partition 0 with sequence number 0 with body: Hello World
   ...
   Stopping and closing the processor.
   

A lista a seguir mostra alguns motivos pelos quais este código não é flexível ou elegante:

• O namespace dos Hubs de Eventos e o nome do hub de eventos 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, não é necessário construir os beans do cliente por conta própria com o Spring Cloud Azure. Em vez disso, você pode injetá-los diretamente e usar as propriedades de configuração com as quais já está familiarizado para configurar a fila de armazenamento. Para mais informações, consulte configuração do Spring Cloud Azure.

O Spring Cloud Azure também fornece as seguintes configurações globais para diferentes cenários. Para mais informações, consulte a 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
• Opções do cliente de transporte AMQP.

Também podes ligar-te a diferentes clouds do Azure. Para mais informações, veja Conectar-se a diferentes nuvens Azure.

Utilize o Spring Messaging com o Hubs de Eventos do Azure

O módulo Spring Messaging Hubs de Eventos do Azure fornece suporte para o framework Spring Messaging com Event Hubs.

Se estiver a usar o Spring Messaging Hubs de Eventos do Azure, pode usar as seguintes funcionalidades:

• EventHubsTemplate: Envie mensagens para Hubs de Eventos de forma assíncrona e síncrona.
• @EventHubsListener: Marque um método para ser o alvo de um ouvinte de mensagens dos Hubs de Eventos no destino.

Este guia mostra-lhe como usar o Spring Messaging Hubs de Eventos do Azure para enviar e receber mensagens dos Event Hubs.

Adicionar dependências

Para instalar o módulo Spring Messaging Hubs de Eventos do Azure, adicione as seguintes dependências ao seu ficheiro pom.xml:

• A Lista de Materiais Spring Cloud Azure (BOM):

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

  Nota

  Se estiveres a usar o Spring Boot 4.0.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 7.2.0.

  Se estiveres a usar o Spring Boot 3.5.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 6.2.0.

  Se estiveres a usar o Spring Boot 3.1.x-3.5.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 5.25.0.

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

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

  Para mais informações sobre a versão usada nesta BOM, veja Qual Versão do Spring Cloud Azure Devo Usar.

• Os componentes iniciais do Spring Cloud Azure, Spring Messaging Event Hubs e Hubs de Eventos do Azure Checkpoint Store:

  <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter</artifactId>
  </dependency>
  <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-messaging-azure-eventhubs</artifactId>
  </dependency>
  <dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-messaging-eventhubs-checkpointstore-blob</artifactId>
  </dependency>
  

Codifique o aplicativo para enviar e receber mensagens

Para enviar e receber mensagens de Hubs de Eventos, configure o aplicativo usando as seguintes etapas:

1. Use as seguintes configurações de propriedade para configurar o namespace dos Hubs de Eventos e o Blob de Armazenamento:

   spring.cloud.azure.eventhubs.namespace=<your event-hubs-namespace>
   spring.cloud.azure.eventhubs.processor.checkpoint-store.account-name=<your-storage-account-name>
   spring.cloud.azure.eventhubs.processor.checkpoint-store.container-name=<your-storage-account-container-name>
   

2. Crie uma nova classe ConsumerService Java como mostrado no exemplo seguinte. Esta classe é usada para definir um recetor de mensagem. Certifique-se de substituir o marcador <your-event-hub-name> pelo seu valor real.

   import com.azure.spring.messaging.eventhubs.implementation.core.annotation.EventHubsListener;
   import org.springframework.stereotype.Service;
   
   @Service
   public class ConsumerService {
   
       private static final String EVENT_HUB_NAME = "<your-event-hub-name>";
       private static final String CONSUMER_GROUP = "$DEFAULT";
   
       @EventHubsListener(destination = EVENT_HUB_NAME, group = CONSUMER_GROUP)
       public void handleMessageFromEventHub(String message) {
           System.out.printf("New message received: %s%n", message);
       }
   
   }
   

3. Conecte um remetente e um recetor para enviar e receber mensagens com o Spring, conforme mostrado no exemplo a seguir. Certifique-se de substituir o marcador <your-event-hub-name> pelo seu valor real.

   import com.azure.spring.messaging.eventhubs.core.EventHubsTemplate;
   import com.azure.spring.messaging.implementation.annotation.EnableAzureMessaging;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.context.ConfigurableApplicationContext;
   import org.springframework.messaging.support.MessageBuilder;
   
   @SpringBootApplication
   @EnableAzureMessaging
   public class EventHubMessagingApplication {
   
       private static final String EVENT_HUB_NAME = "<your-event-hub-name>";
       private static final Logger LOGGER = LoggerFactory.getLogger(EventHubMessagingApplication.class);
   
       public static void main(String[] args) {
           ConfigurableApplicationContext applicationContext = SpringApplication.run(EventHubMessagingApplication.class);
           EventHubsTemplate eventHubsTemplate = applicationContext.getBean(EventHubsTemplate.class);
           LOGGER.info("Sending a message to the Event Hubs.");
           eventHubsTemplate.sendAsync(EVENT_HUB_NAME, MessageBuilder.withPayload("Hello world").build()).subscribe();
       }
   
   }
   

   Gorjeta

   Lembre-se de adicionar a anotação @EnableAzureMessaging, que aciona a descoberta de métodos anotados com @EventHubsListener, criando o contêiner de escuta de mensagens nos bastidores.

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

   Sending a message to the Event Hubs.
   New message received: Hello world
   

Utilize o Spring Integration Hubs de Eventos do Azure

O módulo Spring Integration Hubs de Eventos do Azure fornece suporte para o framework Spring Integration com Event Hubs.

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

Um adaptador de canal de entrada encaminha mensagens de um hub de eventos para um canal de mensagens. Um adaptador de canal de saída publica mensagens de um canal de mensagens para um hub de eventos.

Este guia mostra-lhe como usar o Spring Integration Hubs de Eventos do Azure para enviar e receber mensagens dos Event Hubs.

Adicionar dependências

Para instalar o módulo Spring Cloud Hubs de Eventos do Azure Integration Starter, adicione as seguintes dependências ao seu ficheiro pom.xml:

• A Lista de Materiais Spring Cloud Azure (BOM):

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

  Nota

  Se estiveres a usar o Spring Boot 4.0.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 7.2.0.

  Se estiveres a usar o Spring Boot 3.5.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 6.2.0.

  Se estiveres a usar o Spring Boot 3.1.x-3.5.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 5.25.0.

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

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

  Para mais informações sobre a versão usada nesta BOM, veja Qual Versão do Spring Cloud Azure Devo Usar.

• O artefacto de integração Spring Cloud Hubs de Eventos do Azure:

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

Codifique o aplicativo para enviar e receber mensagens

Para enviar e receber mensagens de Hubs de Eventos, configure o aplicativo usando as seguintes etapas:

1. Use as seguintes configurações de propriedade para configurar o namespace dos Hubs de Eventos e o Blob de Armazenamento:

   spring.cloud.azure.eventhubs.namespace=<your event-hubs-namespace>
   spring.cloud.azure.eventhubs.processor.checkpoint-store.account-name=<your-storage-account-name>
   spring.cloud.azure.eventhubs.processor.checkpoint-store.container-name=<your-storage-account-container-name>
   

2. Crie uma nova classe MessageReceiveConfiguration Java como mostrado no exemplo seguinte. Esta classe é usada para definir um recetor de mensagem. Certifique-se de substituir o marcador <your-event-hub-name> pelo seu valor real.

   import com.azure.spring.integration.eventhubs.inbound.EventHubsInboundChannelAdapter;
   import com.azure.spring.messaging.eventhubs.core.EventHubsProcessorFactory;
   import com.azure.spring.messaging.eventhubs.core.checkpoint.CheckpointConfig;
   import com.azure.spring.messaging.eventhubs.core.checkpoint.CheckpointMode;
   import com.azure.spring.messaging.eventhubs.core.listener.EventHubsMessageListenerContainer;
   import com.azure.spring.messaging.eventhubs.core.properties.EventHubsContainerProperties;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.beans.factory.annotation.Qualifier;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.integration.annotation.ServiceActivator;
   import org.springframework.integration.channel.DirectChannel;
   import org.springframework.messaging.MessageChannel;
   
   @Configuration
   public class MessageReceiveConfiguration {
   
       private static final String INPUT_CHANNEL = "input";
       private static final String EVENT_HUB_NAME = "<your-event-hub-name>";
       private static final String CONSUMER_GROUP = "$Default";
       private static final Logger LOGGER = LoggerFactory.getLogger(MessageReceiveConfiguration.class);
   
       @ServiceActivator(inputChannel = INPUT_CHANNEL)
       public void messageReceiver(byte[] payload) {
           String message = new String(payload);
           LOGGER.info("New message received: {}", message);
       }
   
       @Bean
       public EventHubsMessageListenerContainer messageListenerContainer(EventHubsProcessorFactory processorFactory) {
           EventHubsContainerProperties containerProperties = new EventHubsContainerProperties();
           containerProperties.setEventHubName(EVENT_HUB_NAME);
           containerProperties.setConsumerGroup(CONSUMER_GROUP);
           containerProperties.setCheckpointConfig(new CheckpointConfig(CheckpointMode.MANUAL));
           return new EventHubsMessageListenerContainer(processorFactory, containerProperties);
       }
   
       @Bean
       public EventHubsInboundChannelAdapter messageChannelAdapter(@Qualifier(INPUT_CHANNEL) MessageChannel inputChannel,
                                                                   EventHubsMessageListenerContainer listenerContainer) {
           EventHubsInboundChannelAdapter adapter = new EventHubsInboundChannelAdapter(listenerContainer);
           adapter.setOutputChannel(inputChannel);
           return adapter;
       }
   
       @Bean
       public MessageChannel input() {
           return new DirectChannel();
       }
   
   }
   

3. Crie uma nova classe MessageSendConfiguration Java como mostrado no exemplo seguinte. Essa classe é usada para definir um remetente de mensagem. Certifique-se de substituir o marcador <your-event-hub-name> pelo seu valor real.

   import com.azure.spring.integration.core.handler.DefaultMessageHandler;
   import com.azure.spring.messaging.eventhubs.core.EventHubsTemplate;
   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.context.annotation.Bean;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.integration.annotation.MessagingGateway;
   import org.springframework.integration.annotation.ServiceActivator;
   import org.springframework.messaging.MessageHandler;
   import org.springframework.util.concurrent.ListenableFutureCallback;
   
   @Configuration
   public class MessageSendConfiguration {
   
       private static final Logger LOGGER = LoggerFactory.getLogger(MessageSendConfiguration.class);
       private static final String OUTPUT_CHANNEL = "output";
       private static final String EVENT_HUB_NAME = "<your-event-hub-name>";
   
       @Bean
       @ServiceActivator(inputChannel = OUTPUT_CHANNEL)
       public MessageHandler messageSender(EventHubsTemplate eventHubsTemplate) {
           DefaultMessageHandler handler = new DefaultMessageHandler(EVENT_HUB_NAME, eventHubsTemplate);
           handler.setSendCallback(new ListenableFutureCallback<Void>() {
               @Override
               public void onSuccess(Void result) {
                   LOGGER.info("Message was sent successfully.");
               }
   
               @Override
               public void onFailure(Throwable ex) {
                   LOGGER.error("There was an error sending the message.", ex);
               }
           });
   
           return handler;
       }
   
       @MessagingGateway(defaultRequestChannel = OUTPUT_CHANNEL)
       public interface EventHubOutboundGateway {
           void send(String text);
       }
   
   }
   

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

   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.context.ConfigurableApplicationContext;
   import org.springframework.context.annotation.Configuration;
   import org.springframework.integration.config.EnableIntegration;
   
   @SpringBootApplication
   @EnableIntegration
   @Configuration(proxyBeanMethods = false)
   public class EventHubIntegrationApplication {
   
       public static void main(String[] args) {
           ConfigurableApplicationContext applicationContext = SpringApplication.run(EventHubIntegrationApplication.class, args);
           MessageSendConfiguration.EventHubOutboundGateway outboundGateway = applicationContext.getBean(MessageSendConfiguration.EventHubOutboundGateway.class);
           outboundGateway.send("Hello World");
       }
   }
   

   Gorjeta

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

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

   Message was sent successfully.
   New message received: Hello World
   

Use Spring Cloud Azure Stream Event Hubs Binder

Para chamar a API dos Event Hubs numa aplicação Spring Cloud Stream, utilize o módulo Spring Cloud Hubs de Eventos do Azure Stream Binder.

Este guia mostra como usar o Spring Cloud Stream Event Hubs Binder para enviar e receber mensagens de Hubs de Eventos.

Adicionar dependências

Para instalar o módulo Spring Cloud Hubs de Eventos do Azure Stream Binder, adicione as seguintes dependências ao seu ficheiro pom.xml:

• A Lista de Materiais Spring Cloud Azure (BOM):

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

  Nota

  Se estiveres a usar o Spring Boot 4.0.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 7.2.0.

  Se estiveres a usar o Spring Boot 3.5.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 6.2.0.

  Se estiveres a usar o Spring Boot 3.1.x-3.5.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 5.25.0.

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

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

  Para mais informações sobre a versão usada nesta BOM, veja Qual Versão do Spring Cloud Azure Devo Usar.

• O artefato Spring Cloud Hubs de Eventos do Azure Stream Binder:

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

Codifique o aplicativo para enviar e receber mensagens

Para enviar e receber mensagens de Hubs de Eventos, configure o aplicativo usando as seguintes etapas:

1. Use as seguintes configurações de propriedade para configurar o namespace dos Hubs de Eventos e o Blob de Armazenamento:

   spring.cloud.azure.eventhubs.namespace=<your event-hubs-namespace>
   spring.cloud.azure.eventhubs.processor.checkpoint-store.account-name=<your-storage-account-name>
   spring.cloud.azure.eventhubs.processor.checkpoint-store.container-name=<your-storage-account-container-name>
   

2. Crie o recetor da mensagem.

   Para usar seu aplicativo como um coletor de eventos, configure o fichário de entrada concluindo as seguintes tarefas:

   • Declare um Consumer bean que define 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 seguinte configuração para especificar o nome Event Hub para consumo. Certifique-se de substituir o marcador <your-event-hub-name> pelo seu valor real.

     # name for the above `Consumer` bean
     spring.cloud.stream.function.definition=consume
     spring.cloud.stream.bindings.consume-in-0.destination=<your-event-hub-name>
     spring.cloud.stream.bindings.consume-in-0.group=$Default
     spring.cloud.stream.eventhubs.bindings.consume-in-0.consumer.checkpoint.mode=MANUAL
     

3. Crie o remetente da mensagem.

   Para usar seu aplicativo como uma fonte de eventos, configure o fichário de saída concluindo as seguintes tarefas:

   • Defina um Supplier bean que define de onde as mensagens vêm dentro do seu aplicativo, conforme mostrado no exemplo a seguir:

     @Bean
     public Supplier<Message<String>> supply() {
         return () -> {
             System.out.println("Sending a message.");
             return MessageBuilder.withPayload("Hello world").build();
         };
     }
     

   • Adicione a seguinte configuração para especificar o Event Hub nome para envio. Certifique-se de substituir o marcador <your-event-hub-name> pelo seu valor real.

     # "consume" is added from the above step
     spring.cloud.stream.function.definition=consume;supply
     spring.cloud.stream.bindings.supply-out-0.destination=<your-event-hub-name>
     

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

   Sending a message.
   New message received: Hello world.
   

Utilize Spring Kafka com o Hubs de Eventos do Azure

O Event Hubs fornece um ponto de extremidade Kafka que os seus aplicativos baseados em Kafka existentes podem usar. Essa abordagem fornece uma alternativa para executar seu próprio cluster Kafka. Os Hubs de Eventos funcionam com muitos dos seus aplicativos Kafka existentes. Para obter mais informações, consulte Hubs de eventos para Apache Kafka.

Este guia mostra-lhe como usar Hubs de Eventos do Azure e Spring Kafka para enviar e receber mensagens dos Centros de Eventos.

Adicionar dependências

Para instalar os módulos Spring Cloud Azure starter e Spring Kafka, adicione as seguintes dependências ao seu ficheiro pom.xml:

• A Lista de Materiais Spring Cloud Azure (BOM):

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

  Nota

  Se estiveres a usar o Spring Boot 4.0.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 7.2.0.

  Se estiveres a usar o Spring Boot 3.5.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 6.2.0.

  Se estiveres a usar o Spring Boot 3.1.x-3.5.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 5.25.0.

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

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

  Para mais informações sobre a versão usada nesta BOM, veja Qual Versão do Spring Cloud Azure Devo Usar.

• O starter Spring Cloud Azure e o artefacto Spring Kafka:

  <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
  </dependency>
  

Codifique o aplicativo para enviar e receber mensagens

Para enviar e receber mensagens de Hubs de Eventos, configure o aplicativo usando as seguintes etapas:

1. Use a seguinte configuração de propriedade para configurar o namespace Event Hubs:

   spring.kafka.bootstrap-servers=<your event-hubs-namespace>.servicebus.windows.net:9093
   

2. Use KafkaTemplate para enviar e @KafkaListener receber mensagens, conforme mostrado no exemplo a seguir. Certifique-se de substituir o marcador <your-event-hub-name> pelo seu valor real.

   import org.slf4j.Logger;
   import org.slf4j.LoggerFactory;
   import org.springframework.boot.CommandLineRunner;
   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   import org.springframework.kafka.annotation.KafkaListener;
   import org.springframework.kafka.core.KafkaTemplate;
   
   @SpringBootApplication
   public class EventHubKafkaApplication implements CommandLineRunner {
   
       private static final Logger LOGGER = LoggerFactory.getLogger(EventHubKafkaApplication.class);
       private static final String EVENT_HUB_NAME = "<your-event-hub-name>";
       private static final String CONSUMER_GROUP = "$Default";
       private final KafkaTemplate<String, String> kafkaTemplate;
   
       public EventHubKafkaApplication(KafkaTemplate<String, String> kafkaTemplate) {
           this.kafkaTemplate = kafkaTemplate;
       }
   
       public static void main(String[] args) {
           SpringApplication.run(EventHubKafkaApplication.class, args);
       }
   
       @Override
       public void run(String... args) {
           kafkaTemplate.send(EVENT_HUB_NAME, "Hello World");
           LOGGER.info("Message was sent successfully.");
       }
   
       @KafkaListener(topics = EVENT_HUB_NAME, groupId = CONSUMER_GROUP)
       public void receive(String message) {
           LOGGER.info("New message received: {}", message);
       }
   
   }
   

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

   Message was sent successfully.
   New message received: Hello world
   

Utilize o Spring Cloud Stream Kafka Binder com o Hubs de Eventos do Azure

O Spring Cloud Stream é uma estrutura que permite que os desenvolvedores de aplicativos escrevam microsserviços orientados por mensagens. A ponte entre um sistema de mensagens e o Spring Cloud Stream é através da abstração do fichário. Existem fichários para vários sistemas de mensagens, mas um dos fichários mais usados é para o Apache Kafka.

Este guia mostra-lhe como usar o Hubs de Eventos do Azure e o Spring Cloud Stream Kafka Binder para enviar mensagens e receber mensagens dos Event Hubs.

Adicionar dependências

Para instalar os módulos Spring Cloud Azure starter e Spring Cloud Stream binder Kafka, adicionando as seguintes dependências ao seu ficheiro pom.xml:

• A Lista de Materiais Spring Cloud Azure (BOM):

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

  Nota

  Se estiveres a usar o Spring Boot 4.0.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 7.2.0.

  Se estiveres a usar o Spring Boot 3.5.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 6.2.0.

  Se estiveres a usar o Spring Boot 3.1.x-3.5.x, certifica-te de definir a spring-cloud-azure-dependencies versão para 5.25.0.

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

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

  Para mais informações sobre a versão usada nesta BOM, veja Qual Versão do Spring Cloud Azure Devo Usar.

• O artefacto inicial do Spring Cloud Azure:

  <dependency>
    <groupId>com.azure.spring</groupId>
    <artifactId>spring-cloud-azure-starter</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-stream-binder-kafka</artifactId>
  </dependency>
  

Codifique o aplicativo para enviar e receber mensagens

Para enviar e receber mensagens de Hubs de Eventos, configure o aplicativo usando as seguintes etapas:

1. Use a seguinte configuração de propriedade para configurar o broker Kafka:

   spring.cloud.stream.kafka.binder.brokers=<your event-hubs-namespace>.servicebus.windows.net:9093
   

2. Crie o recetor da mensagem.

   Para usar seu aplicativo como um coletor de eventos, configure o fichário de entrada concluindo as seguintes tarefas:

   • Declare um Consumer bean que define 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 seguinte configuração para especificar o nome Event Hub para consumo. Certifique-se de substituir o marcador <your-event-hub-name> pelo seu valor real.

     # name for the above `Consumer` bean
     spring.cloud.stream.function.definition=consume
     spring.cloud.stream.bindings.consume-in-0.destination=<your-event-hub-name>
     spring.cloud.stream.bindings.consume-in-0.group=$Default
     

3. Crie o remetente da mensagem.

   Para usar seu aplicativo como uma fonte de eventos, configure o fichário de saída concluindo as seguintes tarefas:

   • Defina um Supplier bean que define de onde as mensagens vêm dentro do seu aplicativo, conforme mostrado no exemplo a seguir:

     @Bean
     public Supplier<Message<String>> supply() {
         return () -> {
             System.out.println("Sending a message.");
             return MessageBuilder.withPayload("Hello world").build();
         };
     }
     

   • Adicione a seguinte configuração para especificar o Event Hub nome para envio. Certifique-se de substituir o marcador <your-event-hub-name> pelo seu valor real.

     # "consume" is added from the above step
     spring.cloud.stream.function.definition=consume;supply
     spring.cloud.stream.bindings.supply-out-0.destination=<your-event-hub-name>
     

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

   Sending a message.
   New message received: Hello world.
   

Implementar no Azure Spring Apps

Agora que você tem o aplicativo Spring Boot em execução localmente, é hora de movê-lo para a produção. Azure Spring Apps facilita a implementação de aplicações Spring Boot para Azure sem quaisquer 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 oferece gestão do ciclo de vida através de monitorização e diagnóstico abrangentes, gestão de configuração, descoberta de serviços, integração CI/CD, implementações azul-verde e muito mais. Para implementar a sua aplicação para Azure Spring Apps, consulte Implante a sua primeira aplicação para Azure Spring Apps.

Próximos passos

Azure para desenvolvedores SpringExemplos do Spring Cloud Hubs de Eventos do Azure

Consulte também

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