Usare Hub eventi nelle applicazioni Spring

Questo articolo illustra come usare Hub eventi di Azure nelle applicazioni Java compilate con Spring Framework.

Hub eventi di Azure è una piattaforma di streaming di Big Data e un servizio di inserimento eventi. È in grado di ricevere ed elaborare milioni di eventi al secondo. I dati inviati a un event hub possono essere trasformati e archiviati utilizzando qualsiasi provider di analisi in tempo reale o adattatori per batch e archiviazione.

Spring Cloud Azure fornisce vari moduli per l'invio e la ricezione di messaggi da Hub eventi tramite framework Spring.

È possibile usare i moduli seguenti in modo indipendente o combinarli per casi d'uso diversi:

• Spring Cloud Hub eventi di Azure Starter consente di inviare e ricevere messaggi utilizzando la libreria client Java SDK di Event Hubs con le funzionalità di Spring Boot.

• Spring Messaging Hub eventi di Azure consente di interagire con Hub eventi tramite Spring Messaging API.

• Spring Integration Hub eventi di Azure consente di connettere Spring Integration Message Channels con Hub eventi.

• Spring Cloud Azure Stream Event Hubs Binder consente di usare Hub eventi come middleware di messaggistica nelle applicazioni Spring Cloud Stream.

• Spring Kafka con Hub eventi di Azure consente di usare Spring Kafka per inviare e ricevere messaggi da Hub eventi.

• Spring Cloud Stream Kafka Binder con Hub eventi di Azure consente di inviare e ricevere messaggi tramite Spring Cloud Stream Kafka Binder con Hub eventi.

Prerequisiti

• Una sottoscrizione Azure - crearne una gratuitamente.

• Java Development Kit (JDK) versione 8 o successiva.

• Apache Maven.

• interfaccia della riga di comando di Azure.

• Istanza di Hub eventi di Azure. Per altre informazioni, vedere Quickstart: Creare un hub eventi usando Azure portale.

• Un account Archiviazione di Azure per i checkpoint di Event Hubs. Per altre informazioni, vedere Creare un account di archiviazione.

• Applicazione Spring Boot. Se non lo hai, crea un progetto Maven con Spring Initializr. Ricordarsi di selezionare Maven Project e, in Dependencies aggiungere la dipendenza Spring Web quindi selezionare Java versione 8 o successiva.

Nota

Per concedere all'account l'accesso alle risorse, in Hub eventi di Azure, assegnare il ruolo Hub eventi di Azure Data Receiver e Hub eventi di Azure Data Sender all'account Microsoft Entra attualmente in uso. Quindi, nell'account Archiviazione di Azure assegnare il ruolo Storage Blob Data Contributor all'account Microsoft Entra in uso. Per altre informazioni sulla concessione dei ruoli di accesso, vedere Assign Azure roles using the Azure portal and Authorize access to Event Hubs resources using Microsoft Entra ID.

Importante

Spring Boot versione 2.5 o successiva è necessario per completare i passaggi di questa esercitazione.

Preparare l'ambiente locale

In questa esercitazione le configurazioni e il codice non dispongono di alcuna operazione di autenticazione. Tuttavia, la connessione a un servizio di Azure richiede l'autenticazione. Per completare l'autenticazione, è necessario usare la libreria client Azure Identity. Spring Cloud Azure usa DefaultAzureCredential, che la libreria di identità Azure fornisce per ottenere le credenziali senza modifiche al codice.

DefaultAzureCredential supporta più metodi di autenticazione e determina il metodo da usare in fase di esecuzione. Questo approccio consente all'app di usare metodi di autenticazione diversi in ambienti diversi, ad esempio ambienti locali o di produzione, senza implementare codice specifico dell'ambiente. Per altre informazioni, vedere la sezione DefaultAzureCredential di Authenticate Azure-hosted Java applications.

Per usare interfaccia della riga di comando di Azure, IntelliJ o altri metodi per completare l'autenticazione negli ambienti di sviluppo locali, vedere autenticazione Azure negli ambienti di sviluppo Java. Per completare l'autenticazione negli ambienti di hosting Azure, è consigliabile usare l'identità gestita. Per altre informazioni, vedere Che sono identità gestite per le risorse Azure?

Usare Spring Cloud Hub eventi di Azure Starter

Il modulo Spring Cloud Hub eventi di Azure Starter importa il Event Hub Java libreria client con il framework Spring Boot. È possibile usare Spring Cloud Azure e i Azure SDK insieme, in un modello non che si escludono a vicenda. È quindi possibile continuare a usare l'API client di Hub eventi Java nell'applicazione Spring.

Aggiungere le dipendenze

Per installare il modulo Spring Cloud Hub eventi di Azure Starter, aggiungere le dipendenze seguenti al file pom.xml:

• Spring Cloud Azure Bill of Materials (Elenco dei Materiali, 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 si usa Spring Boot 4.0.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 7.2.0.

  Se si usa Spring Boot 3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 6.2.0.

  Se si usa Spring Boot 3.1.x-3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 5.25.0.

  Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.20.0.

  Questo Bill of Material (BOM) deve essere configurato nella sezione <dependencyManagement> del file pom.xml. In questo modo, tutte le dipendenze di Spring Cloud Azure usano la stessa versione.

  Per ulteriori informazioni sulla versione utilizzata per questo BOM, consultare Quale versione di Spring Cloud Azure dovrei usare.

• Il componente Spring Cloud Hub eventi di Azure:

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

Scrivere il codice dell'applicazione per inviare e ricevere messaggi

Questa guida illustra come usare Hub eventi Java client nel contesto di un'applicazione Spring. In questo caso vengono presentate le due opzioni seguenti:

• Usare la configurazione automatica di Spring Boot e usare client predefiniti dal contesto Spring (scelta consigliata).
• Costruire il client programmaticamente.

La modalità di autowiring dei bean client dal contenitore Spring IoC offre i seguenti vantaggi, che permettono un'esperienza più flessibile ed efficiente durante lo sviluppo con i client di Event Hubs.

• Applica la configurazione esterna in modo che sia possibile usare lo stesso codice dell'applicazione in ambienti diversi.
• È possibile delegare al framework Spring Boot il processo di apprendimento del modello di generatore e la registrazione di questo client nel contesto dell'applicazione. Questa delega consente di concentrarsi su come usare i client con i propri requisiti aziendali.
• È possibile usare l'indicatore di integrità in modo semplice per controllare lo stato e l'integrità dell'applicazione e dei componenti interni.

Le sezioni seguenti forniscono esempi di codice che illustrano come usare EventProcessorClient e EventHubProducerClient con le due alternative.

Nota

Azure Java SDK per Hub eventi offre più client per interagire con Hub eventi. Lo starter fornisce anche la configurazione automatica per tutti i client di Hub eventi e per i generatori di client. Questo articolo usa solo EventProcessorClient e EventHubProducerClient come esempi.

Usare la configurazione automatica di Spring Boot

Per inviare e ricevere messaggi da Hub eventi, configurare l'applicazione attenendosi alla procedura seguente:

1. Usare le impostazioni delle proprietà seguenti per configurare lo spazio dei nomi di Event Hub e il nome dell'Event Hub:

   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. Creare una nuova classe EventHubProcessorClientConfiguration Java come illustrato nell'esempio seguente. Questa classe viene usata per registrare il messaggio e il gestore degli errori per 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. Iniettare il EventProcessorClient e EventHubProducerClient nella vostra applicazione Spring e chiamare le API pertinenti per inviare e ricevere messaggi, come mostrato nell'esempio che segue.

   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. Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:

   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.
   

Compilare il client programmaticamente

È possibile creare i componenti client da soli, ma il processo è complicato. Nelle applicazioni Spring Boot è necessario gestire le proprietà, apprendere il modello di generatore e registrare il client nel contesto dell'applicazione Spring. I passaggi seguenti illustrano come eseguire questa operazione:

1. Creare una nuova classe EventHubClientConfiguration Java come illustrato nell'esempio seguente. Questa classe viene utilizzata per dichiarare i bean EventProcessorClient e EventHubProducerClient. Assicurarsi di sostituire i segnaposto <your event-hubs-namespace>, <your-event-hub-name>, <your-storage-account-name> e <your-storage-account-container-name> con i valori effettivi.

   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. Inserire EventProcessorClient e EventHubProducerClient nella vostra applicazione Spring, come illustrato nell'esempio seguente:

   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. Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:

   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.
   

L'elenco seguente illustra alcuni motivi per cui questo codice non è flessibile o elegante:

• Lo spazio dei nomi di Hub eventi e il nome dell'hub eventi sono codificati in modo fisso.
• Se usi @Value per ottenere configurazioni dall'ambiente Spring, non è possibile avere suggerimenti IDE nel file application.properties.
• Se si ha uno scenario di microservizio, è necessario duplicare il codice in ogni progetto ed è facile commettere errori e rendere difficile la coerenza.

Fortunatamente, la costruzione dei bean client da soli non è necessaria con Spring Cloud Azure. È invece possibile iniettarli direttamente e usare le proprietà di configurazione già note per configurare la Storage queue. Per altre informazioni, vedere Spring Cloud Azure configuration.

Spring Cloud Azure fornisce anche le configurazioni globali seguenti per diversi scenari. Per altre informazioni, vedere la sezione Global configuration for Azure Service SDK della configurazione di Spring Cloud Azure configuration.

• Opzioni proxy.
• Opzioni di ripetizione dei tentativi.
• Opzioni del client di trasporto AMQP.

È anche possibile connettersi a cloud Azure diversi. Per altre informazioni, vedere Connect to different Azure clouds.

Usare il Spring Messaging e gli Hub eventi di Azure

Il modulo Spring Messaging Hub eventi di Azure fornisce il supporto per Spring Messaging framework con Hub eventi.

Se si usa Spring Messaging Hub eventi di Azure, è possibile usare le funzionalità seguenti:

• EventHubsTemplate: inviare messaggi a hub eventi in modo asincrono e sincrono.
• @EventHubsListener: contrassegnare un metodo come obiettivo di un listener di messaggi di Event Hubs nella destinazione.

Questa guida illustra come usare Spring Messaging Hub eventi di Azure per inviare e ricevere messaggi da Hub eventi.

Aggiungere le dipendenze

Per installare il modulo Spring Messaging Hub eventi di Azure, aggiungere le dipendenze seguenti al file pom.xml:

• Spring Cloud Azure Bill of Materials (Elenco dei Materiali, 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 si usa Spring Boot 4.0.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 7.2.0.

  Se si usa Spring Boot 3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 6.2.0.

  Se si usa Spring Boot 3.1.x-3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 5.25.0.

  Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.20.0.

  Questo Bill of Material (BOM) deve essere configurato nella sezione <dependencyManagement> del file pom.xml. In questo modo, tutte le dipendenze di Spring Cloud Azure usano la stessa versione.

  Per ulteriori informazioni sulla versione utilizzata per questo BOM, consultare Quale versione di Spring Cloud Azure dovrei usare.

• Lo starter Spring Cloud Azure, gli artefatti Spring Messaging Event Hubs e Hub eventi di 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>
  

Scrivere il codice dell'applicazione per inviare e ricevere messaggi

Per inviare e ricevere messaggi da Hub eventi, configurare l'applicazione attenendosi alla procedura seguente:

1. Usare le impostazioni delle proprietà seguenti per configurare lo Spazio dei Nomi di Hub Eventi e il Blob di Archiviazione.

   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. Creare una nuova classe ConsumerService Java come illustrato nell'esempio seguente. Questa classe viene usata per definire un ricevitore di messaggi. Assicurarsi di sostituire il <your-event-hub-name> segnaposto con il valore effettivo.

   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. Collegare un mittente e un destinatario per inviare e ricevere messaggi con Spring, come illustrato nell'esempio seguente. Assicurarsi di sostituire il <your-event-hub-name> segnaposto con il valore effettivo.

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

   Suggerimento

   Ricordarsi di aggiungere l'annotazione @EnableAzureMessaging, che attiva l'individuazione dei metodi annotati con @EventHubsListener, creando il contenitore del listener dei messaggi dietro le quinte.

4. Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:

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

Usare Spring Integration con gli Hub eventi di Azure

Il modulo Spring Integration Hub eventi di Azure fornisce supporto per il framework Spring Integration con Hub eventi.

Se la tua applicazione Spring utilizza i canali di messaggio di Spring Integration, è possibile instradare i messaggi tra i canali di messaggio e gli Event Hubs usando adattatori di canale.

Un adattatore del canale in ingresso inoltra i messaggi da un hub eventi a un canale di messaggio. Un adattatore di canale in uscita pubblica i messaggi da un canale di messaggi a un hub di eventi.

Questa guida illustra come usare Spring Integration Hub eventi di Azure per inviare e ricevere messaggi da Hub eventi.

Aggiungere le dipendenze

Per installare il modulo Spring Cloud Hub eventi di Azure Integration Starter, aggiungere le dipendenze seguenti al file pom.xml:

• Spring Cloud Azure Bill of Materials (Elenco dei Materiali, 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 si usa Spring Boot 4.0.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 7.2.0.

  Se si usa Spring Boot 3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 6.2.0.

  Se si usa Spring Boot 3.1.x-3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 5.25.0.

  Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.20.0.

  Questo Bill of Material (BOM) deve essere configurato nella sezione <dependencyManagement> del file pom.xml. In questo modo, tutte le dipendenze di Spring Cloud Azure usano la stessa versione.

  Per ulteriori informazioni sulla versione utilizzata per questo BOM, consultare Quale versione di Spring Cloud Azure dovrei usare.

• Il pacchetto di integrazione Spring Cloud Hub eventi di Azure:

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

Scrivere il codice dell'applicazione per inviare e ricevere messaggi

Per inviare e ricevere messaggi da Hub eventi, configurare l'applicazione attenendosi alla procedura seguente:

1. Usare le impostazioni delle proprietà seguenti per configurare lo Spazio dei Nomi di Hub Eventi e il Blob di Archiviazione.

   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. Creare una nuova classe MessageReceiveConfiguration Java come illustrato nell'esempio seguente. Questa classe viene usata per definire un ricevitore di messaggi. Assicurarsi di sostituire il <your-event-hub-name> segnaposto con il valore effettivo.

   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. Creare una nuova classe MessageSendConfiguration Java come illustrato nell'esempio seguente. Questa classe viene usata per definire un mittente di messaggi. Assicurarsi di sostituire il <your-event-hub-name> segnaposto con il valore effettivo.

   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. Collegare un mittente e un destinatario per inviare e ricevere messaggi con Spring, come illustrato nell'esempio seguente:

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

   Suggerimento

   Ricordarsi di aggiungere l'annotazione @EnableIntegration , che abilita l'infrastruttura Spring Integration.

5. Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:

   Message was sent successfully.
   New message received: Hello World
   

Usare Spring Cloud Azure Stream Event Hubs Binder

Per chiamare l'API di Hub eventi in un'applicazione Spring Cloud Stream, usare il modulo Spring Cloud Hub eventi di Azure Stream Binder.

Questa guida illustra come usare Spring Cloud Stream Event Hubs Binder per inviare e ricevere messaggi da Hub eventi.

Aggiungere le dipendenze

Per installare il modulo Spring Cloud Hub eventi di Azure Stream Binder, aggiungere le dipendenze seguenti al file pom.xml:

• Spring Cloud Azure Bill of Materials (Elenco dei Materiali, 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 si usa Spring Boot 4.0.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 7.2.0.

  Se si usa Spring Boot 3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 6.2.0.

  Se si usa Spring Boot 3.1.x-3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 5.25.0.

  Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.20.0.

  Questo Bill of Material (BOM) deve essere configurato nella sezione <dependencyManagement> del file pom.xml. In questo modo, tutte le dipendenze di Spring Cloud Azure usano la stessa versione.

  Per ulteriori informazioni sulla versione utilizzata per questo BOM, consultare Quale versione di Spring Cloud Azure dovrei usare.

• Artefatto di Spring Cloud Hub eventi di Azure Stream Binder:

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

Scrivere il codice dell'applicazione per inviare e ricevere messaggi

Per inviare e ricevere messaggi da Hub eventi, configurare l'applicazione attenendosi alla procedura seguente:

1. Usare le impostazioni delle proprietà seguenti per configurare lo Spazio dei Nomi di Hub Eventi e il Blob di Archiviazione.

   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. Creare il ricevitore di messaggi.

   Per usare l'applicazione come incorporatore di eventi, configurare il collegatore di input completando le operazioni seguenti:

   • Dichiarare un Consumer bean che definisce la logica di gestione dei messaggi. Ad esempio, il bean seguente Consumer è denominato consume:

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

   • Aggiungere la seguente configurazione per specificare il nome Event Hub per il consumo. Assicurarsi di sostituire il <your-event-hub-name> segnaposto con il valore effettivo.

     # 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. Creare il mittente del messaggio.

   Per utilizzare l'applicazione come fonte di eventi, configura il binder di output completando le seguenti attività:

   • Definire un Supplier bean che definisce dove provengono i messaggi dall'interno dell'applicazione, come illustrato nell'esempio seguente:

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

   • Aggiungere la configurazione seguente per specificare il nome per l'invio Event Hub . Assicurarsi di sostituire il <your-event-hub-name> segnaposto con il valore effettivo.

     # "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. Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:

   Sending a message.
   New message received: Hello world.
   

Usare Spring Kafka con Hub eventi di Azure

Hub eventi fornisce un endpoint Kafka che le applicazioni basate su Kafka esistenti possono usare. Questo approccio offre un'alternativa all'esecuzione del proprio cluster Kafka. Hub eventi funziona con numerose applicazioni Kafka esistenti. Per altre informazioni, vedere Hub eventi per Apache Kafka.

Questa guida illustra come usare Hub eventi di Azure e Spring Kafka per inviare e ricevere messaggi da Hub eventi.

Aggiungere le dipendenze

Per installare i moduli Spring Cloud Azure starter e Spring Kafka, aggiungere le dipendenze seguenti al file pom.xml:

• Spring Cloud Azure Bill of Materials (Elenco dei Materiali, 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 si usa Spring Boot 4.0.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 7.2.0.

  Se si usa Spring Boot 3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 6.2.0.

  Se si usa Spring Boot 3.1.x-3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 5.25.0.

  Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.20.0.

  Questo Bill of Material (BOM) deve essere configurato nella sezione <dependencyManagement> del file pom.xml. In questo modo, tutte le dipendenze di Spring Cloud Azure usano la stessa versione.

  Per ulteriori informazioni sulla versione utilizzata per questo BOM, consultare Quale versione di Spring Cloud Azure dovrei usare.

• Spring Cloud Azure starter e Spring Kafka artefatto:

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

Scrivere il codice dell'applicazione per inviare e ricevere messaggi

Per inviare e ricevere messaggi da Hub eventi, configurare l'applicazione attenendosi alla procedura seguente:

1. Usare la seguente impostazione della proprietà per configurare lo spazio dei nomi di Event Hubs:

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

2. Usare KafkaTemplate per inviare messaggi e @KafkaListener per ricevere messaggi, come illustrato nell'esempio seguente. Assicurarsi di sostituire il <your-event-hub-name> segnaposto con il valore effettivo.

   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. Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:

   Message was sent successfully.
   New message received: Hello world
   

Usare Spring Cloud Stream Kafka Binder con Hub eventi di Azure

Spring Cloud Stream è un framework che consente agli sviluppatori di applicazioni di scrivere microservizi basati su messaggi. Il bridge tra un sistema di messaggistica e Spring Cloud Stream è tramite l'astrazione del binder. I binder esistono per diversi sistemi di messaggistica, ma uno dei binder più usati è per Apache Kafka.

Questa guida illustra come usare Hub eventi di Azure e Spring Cloud Stream Kafka Binder per inviare e ricevere messaggi da Hub eventi.

Aggiungere le dipendenze

Per installare i moduli Spring Cloud Azure starter e Spring Cloud Stream Binder Kafka, aggiungendo le dipendenze seguenti al file pom.xml:

• Spring Cloud Azure Bill of Materials (Elenco dei Materiali, 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 si usa Spring Boot 4.0.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 7.2.0.

  Se si usa Spring Boot 3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 6.2.0.

  Se si usa Spring Boot 3.1.x-3.5.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 5.25.0.

  Se si usa Spring Boot 2.x, assicurarsi di impostare la spring-cloud-azure-dependencies versione su 4.20.0.

  Questo Bill of Material (BOM) deve essere configurato nella sezione <dependencyManagement> del file pom.xml. In questo modo, tutte le dipendenze di Spring Cloud Azure usano la stessa versione.

  Per ulteriori informazioni sulla versione utilizzata per questo BOM, consultare Quale versione di Spring Cloud Azure dovrei usare.

• L'artefatto iniziale di 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>
  

Scrivere il codice dell'applicazione per inviare e ricevere messaggi

Per inviare e ricevere messaggi da Hub eventi, configurare l'applicazione attenendosi alla procedura seguente:

1. È necessario usare la seguente impostazione della proprietà per configurare il broker Kafka.

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

2. Creare il ricevitore di messaggi.

   Per usare l'applicazione come incorporatore di eventi, configurare il collegatore di input completando le operazioni seguenti:

   • Dichiarare un Consumer bean che definisce la logica di gestione dei messaggi. Ad esempio, il bean seguente Consumer è denominato consume:

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

   • Aggiungere la seguente configurazione per specificare il nome Event Hub per il consumo. Assicurarsi di sostituire il <your-event-hub-name> segnaposto con il valore effettivo.

     # 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. Creare il mittente del messaggio.

   Per utilizzare l'applicazione come fonte di eventi, configura il binder di output completando le seguenti attività:

   • Definire un Supplier bean che definisce dove provengono i messaggi dall'interno dell'applicazione, come illustrato nell'esempio seguente:

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

   • Aggiungere la configurazione seguente per specificare il nome per l'invio Event Hub . Assicurarsi di sostituire il <your-event-hub-name> segnaposto con il valore effettivo.

     # "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. Avviare l’applicazione. Vengono visualizzati log simili all'esempio seguente:

   Sending a message.
   New message received: Hello world.
   

Effettuare la distribuzione su Azure Spring Apps

Ora che l'applicazione Spring Boot è in esecuzione in locale, è possibile spostarla nell'ambiente di produzione. Azure Spring Apps semplifica la distribuzione di applicazioni Spring Boot in Azure senza modifiche al codice. Il servizio gestisce l'infrastruttura delle applicazioni Spring per consentire agli sviluppatori di concentrarsi sul codice. Azure Spring Apps offre la gestione del ciclo di vita usando monitoraggio e diagnostica completi, gestione della configurazione, individuazione dei servizi, integrazione CI/CD, distribuzioni blu-verde e altro ancora. Per distribuire l'applicazione in Azure Spring Apps, vedere Distribuire la prima applicazione in Azure Spring Apps.

Passaggi successivi

Azure per sviluppatori SpringSpring Cloud Hub eventi di Azure Samples

Vedi anche

Per ulteriori informazioni sugli altri starter Spring Boot disponibili per Microsoft Azure, consultare Cos'è Spring Cloud Azure?