Utiliser Event Hubs dans les applications Spring

Cet article explique comment utiliser Azure Event Hubs dans Java applications créées avec le Spring Framework.

Azure Event Hubs est une plateforme de diffusion en continu Big Data et un service d’ingestion d’événements. Il peut recevoir et traiter des millions d’événements par seconde. Les données envoyées à un concentrateur d’événements peuvent être transformées et stockées à l’aide d’un fournisseur d’analyse en temps réel ou d’adaptateurs de traitement par lot/stockage.

Spring Cloud Azure fournit différents modules pour l’envoi de messages et la réception de messages à partir d’Event Hubs à l’aide de frameworks Spring.

Vous pouvez utiliser les modules suivants indépendamment ou les combiner pour différents cas d'utilisation :

Spring Cloud Azure Event Hubs Starter vous permet d’envoyer et de recevoir des messages avec la bibliothèque cliente event Hubs Java SDK avec les fonctionnalités Spring Boot.
Spring Messaging Azure Event Hubs vous permet d’interagir avec Event Hubs via Spring Messaging API.
Spring Integration Azure Event Hubs vous permet de connecter Spring Integration Message Channels avec Event Hubs.
Spring Cloud Azure Stream Event Hubs Binder vous permet d’utiliser Event Hubs comme intergiciel de messagerie dans les applications Spring Cloud Stream.
Spring Kafka avec Azure Event Hubs vous permet d’utiliser Spring Kafka pour envoyer et recevoir des messages à partir d’Event Hubs.
Spring Cloud Stream Kafka Binder avec Azure Event Hubs vous permet d’envoyer et de recevoir un message via Spring Cloud Stream Kafka Binder avec Event Hubs.

Prérequis

Un abonnement Azure - créez-en un gratuitement.
Java Kit de développement (JDK), version 8 ou ultérieure.
Apache Maven.
Azure CLI.

Une instance de Azure Event Hubs. Pour plus d’informations, consultez Quickstart : Create an event hub using Azure portal.
Un compte stockage Azure pour les points de contrôle Event Hubs. Pour plus d’informations, consultez Créer un compte de stockage.
Une application Spring Boot. Si vous n’en avez pas, créez un projet Maven avec Spring Initializr. N’oubliez pas de sélectionner Maven Project et, sous Dependencies, ajoutez la dépendance Spring Web, puis sélectionnez Java version 8 ou ultérieure.

Remarque

Pour accorder à votre compte l'accès aux ressources, dans Azure Event Hubs, affectez le rôle Azure Event Hubs Data Receiver et Azure Event Hubs Data Sender au compte Microsoft Entra que vous utilisez actuellement. Ensuite, dans le compte stockage Azure, attribuez le rôle Storage Blob Data Contributor au compte Microsoft Entra que vous utilisez actuellement. Pour plus d’informations sur l’octroi de rôles d’accès, consultez Assigner des rôles Azure à l’aide du portail Azure et Autoriser l’accès aux ressources Event Hubs à l’aide de Microsoft Entra ID.

Importante

La version 2.5 ou supérieure de Spring Boot est nécessaire pour réaliser les étapes de ce tutoriel.

Préparer votre environnement local

Dans ce tutoriel, les configurations et le code ne comportent aucune opération d'authentification. Toutefois, la connexion à un service Azure nécessite une authentification. Pour terminer l’authentification, vous devez utiliser la bibliothèque de client Azure Identity. Spring Cloud Azure utilise DefaultAzureCredential, que la bibliothèque Azure Identity fournit pour vous aider à obtenir des informations d’identification sans aucune modification du code.

DefaultAzureCredential prend en charge plusieurs méthodes d’authentification et détermine quelle méthode doit être utilisée au moment de l’exécution. Cette approche permet à votre application d'utiliser différentes méthodes d'authentification dans différents environnements - tels que les environnements locaux ou de production - sans implémenter de code spécifique à l'environnement. Pour plus d’informations, consultez la section DefaultAzureCredential d’Authentifier les applications Java hébergées sur Azure.

Pour utiliser Azure CLI, IntelliJ ou d'autres méthodes pour terminer l’authentification dans les environnements de développement locaux, consultez l’authentification Azure dans les environnements de développement Java. Pour terminer l’authentification dans Azure environnements d’hébergement, nous vous recommandons d’utiliser l’identité managée. Pour plus d’informations, consultez Qu’est-ce que les identités managées pour les ressources Azure ?

Utiliser Spring Cloud Azure Event Hubs Starter

Le module Spring Cloud Azure Event Hubs Starter importe le module Event Hubs Java bibliothèque cliente avec l’infrastructure Spring Boot. Vous pouvez utiliser Spring Cloud Azure et le Kit de développement logiciel (SDK) Azure ensemble, dans un modèle non mutuellement exclusif. Par conséquent, vous pouvez continuer à utiliser l’API cliente Event Hubs Java dans votre application Spring.

Ajout de dépendances

Pour installer le module Spring Cloud Azure Event Hubs Starter, ajoutez les dépendances suivantes à votre fichier pom.xml :

Le Spring Cloud Azure Bill of Materials (BOM) :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.4.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 4.0.x, définissez la spring-cloud-azure-dependencies version 7.4.0sur .

Si vous utilisez Spring Boot 3.5.x, définissez la spring-cloud-azure-dependencies version 6.5.0sur .

Si vous utilisez Spring Boot 3.1.x-3.5.x, veillez à définir la version spring-cloud-azure-dependencies5.25.0.

Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.20.0.

Cette liste de matériel (BOM) doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela garantit que toutes les dépendances spring Cloud Azure utilisent la même version.

Pour plus d’informations sur la version utilisée pour ce boM, consultez Which Version of Spring Cloud Azure Should I Use.

L’artéfact Spring Cloud Azure Event Hubs

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

Codez l'application pour envoyer et recevoir des messages

Ce guide explique comment utiliser les clients Event Hubs Java dans le contexte d’une application Spring. Nous vous présentons les deux options suivantes :

Utilisez la configuration automatique de Spring Boot et utilisez des clients prêts à l’emploi à partir du contexte Spring (recommandé).
Construire le client par programme.

La méthode d’injection automatique des composants client depuis le conteneur Spring IdC présente les avantages suivants, offrant une expérience de développement plus souple et efficace avec les clients Event Hubs :

Il applique la configuration externalisée afin que vous puissiez utiliser le même code d’application dans différents environnements.
Vous pouvez déléguer au cadre Spring Boot le processus d'apprentissage du modèle de construction et l'enregistrement de ce client dans le contexte de l'application. Cette délégation vous permet de vous concentrer sur la manière d'utiliser les clients en fonction de vos propres besoins commerciaux.
Vous pouvez utiliser l'indicateur d'intégrité de manière simple pour inspecter l'état et l'intégrité de votre application et de ses composants internes.

Les sections suivantes fournissent des exemples de code qui vous montrent comment utiliser EventProcessorClient et EventHubProducerClient avec les deux alternatives.

Remarque

Azure Java SDK pour Event Hubs fournit plusieurs clients pour interagir avec Event Hubs. Le starter fournit également une autoconfiguration pour tous les clients Event Hubs ainsi que pour les constructeurs de clients. Cet article n'utilise que EventProcessorClient et EventHubProducerClient comme exemples.

Utiliser l'autoconfiguration de Spring Boot

Pour envoyer des messages aux Event Hubs et en recevoir, configurez l'application en suivant les étapes suivantes :

Utilisez les paramètres de propriété suivants pour configurer votre espace de noms Event Hubs et le nom du hub d'événements :

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

Créez une classe EventHubProcessorClientConfiguration Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour enregistrer le gestionnaire de messages et d'erreurs pour 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());
    }

}

Injectez les EventProcessorClient et EventHubProducerClient dans votre application Spring et appelez les API correspondantes pour envoyer et recevoir des messages, comme le montre l'exemple suivant :

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

}

Lancez l’application. Vous voyez des logs similaires à l'exemple suivant :

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.

Construire le client par programme

Vous pouvez créer vous-même les composants client, mais le processus est complexe. Dans les applications Spring Boot, vous devez gérer les propriétés, apprendre le modèle de construction et enregistrer le client dans votre contexte d'application Spring. Les étapes suivantes vous montrent comment procéder :

Créez une classe EventHubClientConfiguration Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour déclarer les beans EventProcessorClient et EventHubProducerClient. Veillez à remplacer les espaces réservés <your event-hubs-namespace>, <your-event-hub-name>, <your-storage-account-name>, et <your-storage-account-container-name> par vos valeurs réelles.

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

}

Injectez les EventProcessorClient et EventHubProducerClient dans votre application Spring, comme indiqué dans l'exemple suivant :

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

}

Lancez l’application. Vous voyez des logs similaires à l'exemple suivant :

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.

La liste suivante montre quelques raisons pour lesquelles ce code n'est pas flexible ou gracieux :

L'espace de noms et le nom du hub d'événements sont codés en dur.
Si vous utilisez @Value pour obtenir des configurations à partir de l’environnement Spring, vous ne pouvez pas avoir d’indicateurs IDE dans votre fichier application.properties .
Si vous avez un scénario de microservice, vous devez dupliquer le code dans chaque projet, et il est facile de faire des erreurs et difficile d'être cohérent.

Heureusement, créer les beans clients par soi-même n'est pas nécessaire avec Spring Cloud Azure. Au lieu de cela, vous pouvez les injecter directement et utiliser les propriétés de configuration que vous connaissez déjà pour configurer la file d'attente de stockage. Pour plus d’informations, consultez Spring Cloud Azure configuration.

Spring Cloud Azure fournit également les configurations globales suivantes pour différents scénarios. Pour plus d'informations, consultez la configuration Globale pour les SDK Azure Service de la configuration Spring Cloud Azure.

Options de proxy.
Options de réessai.
Options du client de transport AMQP.

Vous pouvez également vous connecter à différents clouds Azure. Pour plus d’informations, consultez Connect to different Azure clouds.

Utiliser le Azure Event Hubs Spring Messaging

Le module Spring Messaging Azure Event Hubs prend en charge Spring Messaging framework avec Event Hubs.

Si vous utilisez Spring Messaging Azure Event Hubs, vous pouvez utiliser les fonctionnalités suivantes :

EventHubsTemplate : envoie des messages à un Event Hubs de manière asynchrone et synchrone.
@EventHubsListener : Marque une méthode pour qu'elle soit la cible d'un écouteur de messages Event Hubs sur la destination.

Ce guide vous montre comment utiliser spring Messaging Azure Event Hubs pour envoyer et recevoir des messages à partir d’Event Hubs.

Ajout de dépendances

Pour installer le module Spring Messaging Azure Event Hubs, ajoutez les dépendances suivantes à votre fichier pom.xml :

Le Spring Cloud Azure Bill of Materials (BOM) :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.4.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 4.0.x, définissez la spring-cloud-azure-dependencies version 7.4.0sur .

Si vous utilisez Spring Boot 3.5.x, définissez la spring-cloud-azure-dependencies version 6.5.0sur .

Si vous utilisez Spring Boot 3.1.x-3.5.x, veillez à définir la version spring-cloud-azure-dependencies5.25.0.

Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.20.0.

Cette liste de matériel (BOM) doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela garantit que toutes les dépendances spring Cloud Azure utilisent la même version.

Pour plus d’informations sur la version utilisée pour ce boM, consultez Which Version of Spring Cloud Azure Should I Use.

Les artefacts Spring Cloud Azure Starter, Spring Messaging Event Hubs et Azure Event Hubs 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>

Codez l'application pour envoyer et recevoir des messages

Pour envoyer des messages aux Event Hubs et en recevoir, configurez l'application en suivant les étapes suivantes :

Utilisez les paramètres de propriété suivants pour configurer l'espace de noms et le Storage Blob d'Event Hubs :

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>

Créez une classe ConsumerService Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour définir un récepteur de message. Veillez à remplacer l'espace réservé <your-event-hub-name> par votre valeur réelle.

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

}

Connectez un émetteur et un récepteur pour envoyer et recevoir des messages avec Spring, comme indiqué dans l'exemple suivant. Veillez à remplacer l'espace réservé <your-event-hub-name> par votre valeur réelle.

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

}

Conseil

N'oubliez pas d'ajouter l'annotation @EnableAzureMessaging, qui déclenche la découverte des méthodes annotées avec @EventHubsListener, créant ainsi le conteneur d'écoute de messages sous les couvertures.

Lancez l’application. Vous voyez des logs similaires à l'exemple suivant :
```
Sending a message to the Event Hubs.
New message received: Hello world
```

Utiliser l'intégration Spring avec Azure Event Hubs

Le module Spring Integration Azure Event Hubs prend en charge l’infrastructure Spring Integration avec Event Hubs.

Si votre application Spring utilise des chaînes de messages Spring Integration, vous pouvez acheminer les messages entre vos chaînes de messages et les Event Hubs à l'aide d'adaptateurs de chaînes.

Un adaptateur de canal entrant redirecte les messages d'un hub d'événements vers une chaîne de messages. Un adaptateur de chaîne sortant publie les messages d'une chaîne de messages vers un hub d'événements.

Ce guide vous montre comment utiliser Spring Integration Azure Event Hubs pour envoyer et recevoir des messages à partir d’Event Hubs.

Ajout de dépendances

Pour installer le module Spring Cloud Azure Event Hubs Integration Starter, ajoutez les dépendances suivantes à votre fichier pom.xml :

Le Spring Cloud Azure Bill of Materials (BOM) :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.4.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 4.0.x, définissez la spring-cloud-azure-dependencies version 7.4.0sur .

Si vous utilisez Spring Boot 3.5.x, définissez la spring-cloud-azure-dependencies version 6.5.0sur .

Si vous utilisez Spring Boot 3.1.x-3.5.x, veillez à définir la version spring-cloud-azure-dependencies5.25.0.

Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.20.0.

Cette liste de matériel (BOM) doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela garantit que toutes les dépendances spring Cloud Azure utilisent la même version.

Pour plus d’informations sur la version utilisée pour ce boM, consultez Which Version of Spring Cloud Azure Should I Use.

Artefact d’intégration Spring Cloud Azure Event Hubs :

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

Codez l'application pour envoyer et recevoir des messages

Pour envoyer des messages aux Event Hubs et en recevoir, configurez l'application en suivant les étapes suivantes :

Utilisez les paramètres de propriété suivants pour configurer l'espace de noms et le Storage Blob d'Event Hubs :

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>

Créez une classe MessageReceiveConfiguration Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour définir un récepteur de message. Veillez à remplacer l'espace réservé <your-event-hub-name> par votre valeur réelle.

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

}

Créez une classe MessageSendConfiguration Java, comme illustré dans l’exemple suivant. Cette classe est utilisée pour définir un expéditeur de messages. Veillez à remplacer l'espace réservé <your-event-hub-name> par votre valeur réelle.

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

}

Connectez un émetteur et un récepteur pour envoyer et recevoir des messages avec Spring, comme le montre l'exemple suivant :

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

Conseil

N'oubliez pas d'ajouter l'annotation @EnableIntegration, qui active l'infrastructure d'intégration Spring.

Lancez l’application. Vous voyez des logs similaires à l'exemple suivant :
```
Message was sent successfully.
New message received: Hello World
```

Utiliser Spring Cloud Azure Stream Event Hubs Binder

Pour appeler l’API Event Hubs dans une application Spring Cloud Stream, utilisez le module Spring Cloud Azure Event Hubs Stream Binder.

Ce guide vous montre comment utiliser le module Spring Cloud Stream Event Hubs Binder pour envoyer des messages à des Event Hubs et en recevoir de ces derniers.

Ajout de dépendances

Pour installer le module Spring Cloud Azure Event Hubs Stream Binder, ajoutez les dépendances suivantes à votre fichier pom.xml :

Le Spring Cloud Azure Bill of Materials (BOM) :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.4.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 4.0.x, définissez la spring-cloud-azure-dependencies version 7.4.0sur .

Si vous utilisez Spring Boot 3.5.x, définissez la spring-cloud-azure-dependencies version 6.5.0sur .

Si vous utilisez Spring Boot 3.1.x-3.5.x, veillez à définir la version spring-cloud-azure-dependencies5.25.0.

Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.20.0.

Cette liste de matériel (BOM) doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela garantit que toutes les dépendances spring Cloud Azure utilisent la même version.

Pour plus d’informations sur la version utilisée pour ce boM, consultez Which Version of Spring Cloud Azure Should I Use.

L'artéfact Spring Cloud Azure Event Hubs Stream Binder :

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

Codez l'application pour envoyer et recevoir des messages

Pour envoyer des messages aux Event Hubs et en recevoir, configurez l'application en suivant les étapes suivantes :

Utilisez les paramètres de propriété suivants pour configurer l'espace de noms et le Storage Blob d'Event Hubs :

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>

Créez le récepteur de messages.

Pour utiliser votre application en tant que récepteur d'événements, configurez le binder d'entrée en effectuant les tâches suivantes :

Déclarez un bean Consumer qui définit la logique de traitement des messages. Par exemple, le bean Consumer suivant est nommé consume :

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

Ajoutez la configuration suivante pour préciser le nom Event Hub pour consommer. Veillez à remplacer l'espace réservé <your-event-hub-name> par votre valeur réelle.

# 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

Créez l'expéditeur de messages.

Pour utiliser votre application en tant que source d'événements, configurez le liant de sortie en effectuant les tâches suivantes :
- Définissez un bean Supplier qui définit la provenance des messages au sein de votre application, comme le montre l'exemple suivant :
```
@Bean
public Supplier<Message<String>> supply() {
    return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}
```
- Ajoutez la configuration suivante pour spécifier le nom Event Hub pour l'envoi. Veillez à remplacer l'espace réservé <your-event-hub-name> par votre valeur réelle.
```
# "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>
```
Lancez l’application. Vous voyez des logs similaires à l'exemple suivant :
```
Sending a message.
New message received: Hello world.
```

Utiliser Spring Kafka avec Azure Event Hubs

Event Hubs fournit un point de terminaison Kafka que vos applications existantes basées sur Kafka peuvent utiliser. Cette approche constitue une alternative à l'exécution de votre propre cluster Kafka. Event Hubs fonctionne avec un grand nombre de vos applications Kafka existantes. Pour plus d’informations, consultez Event Hubs pour Apache Kafka.

Ce guide vous montre comment utiliser Azure Event Hubs et Spring Kafka pour envoyer et recevoir des messages à partir d’Event Hubs.

Ajout de dépendances

Pour installer les modules Spring Cloud Azure starter et Spring Kafka, ajoutez les dépendances suivantes à votre fichier pom.xml :

Le Spring Cloud Azure Bill of Materials (BOM) :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.4.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 4.0.x, définissez la spring-cloud-azure-dependencies version 7.4.0sur .

Si vous utilisez Spring Boot 3.5.x, définissez la spring-cloud-azure-dependencies version 6.5.0sur .

Si vous utilisez Spring Boot 3.1.x-3.5.x, veillez à définir la version spring-cloud-azure-dependencies5.25.0.

Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.20.0.

Cette liste de matériel (BOM) doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela garantit que toutes les dépendances spring Cloud Azure utilisent la même version.

Pour plus d’informations sur la version utilisée pour ce boM, consultez Which Version of Spring Cloud Azure Should I Use.

L’artefact Spring Cloud Azure Starter et l’artefact 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>

Codez l'application pour envoyer et recevoir des messages

Pour envoyer des messages aux Event Hubs et en recevoir, configurez l'application en suivant les étapes suivantes :

Utilisez le paramètre de propriété suivant pour configurer l'espace de noms Event Hubs :
```
spring.kafka.bootstrap-servers=<your event-hubs-namespace>.servicebus.windows.net:9093
```

Utilisez KafkaTemplate pour envoyer des messages et @KafkaListener pour en recevoir, comme indiqué dans l'exemple suivant. Veillez à remplacer l'espace réservé <your-event-hub-name> par votre valeur réelle.

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

}

Lancez l’application. Vous voyez des logs similaires à l'exemple suivant :
```
Message was sent successfully.
New message received: Hello world
```

Utiliser Spring Cloud Stream Kafka Binder avec Azure Event Hubs

Spring Cloud Stream est un framework qui permet aux développeurs d'applications d'écrire des microservices axés sur les messages. Le pont entre un système de messagerie et Spring Cloud Stream passe par l'abstraction du binder. Il existe des binders pour plusieurs systèmes de messagerie, mais l'un des binders les plus utilisés est celui d'Apache Kafka.

Ce guide vous montre comment utiliser Azure Event Hubs et Spring Cloud Stream Kafka Binder pour envoyer et recevoir des messages à partir d’Event Hubs.

Ajout de dépendances

Pour installer le démarreur Spring Cloud Azure et les modules de liaison Spring Cloud Stream Kafka, ajoutez les dépendances suivantes à votre fichier pom.xml :

Le Spring Cloud Azure Bill of Materials (BOM) :
```
<dependencyManagement>
   <dependencies>
     <dependency>
       <groupId>com.azure.spring</groupId>
       <artifactId>spring-cloud-azure-dependencies</artifactId>
       <version>7.4.0</version>
       <type>pom</type>
       <scope>import</scope>
       </dependency>
   </dependencies>
</dependencyManagement>
```
Remarque

Si vous utilisez Spring Boot 4.0.x, définissez la spring-cloud-azure-dependencies version 7.4.0sur .

Si vous utilisez Spring Boot 3.5.x, définissez la spring-cloud-azure-dependencies version 6.5.0sur .

Si vous utilisez Spring Boot 3.1.x-3.5.x, veillez à définir la version spring-cloud-azure-dependencies5.25.0.

Si vous utilisez Spring Boot 2.x, assurez-vous de définir la version spring-cloud-azure-dependencies sur 4.20.0.

Cette liste de matériel (BOM) doit être configurée dans la section <dependencyManagement> de votre fichier pom.xml. Cela garantit que toutes les dépendances spring Cloud Azure utilisent la même version.

Pour plus d’informations sur la version utilisée pour ce boM, consultez Which Version of Spring Cloud Azure Should I Use.

L’artefact de démarrage de 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>

Codez l'application pour envoyer et recevoir des messages

Pour envoyer des messages aux Event Hubs et en recevoir, configurez l'application en suivant les étapes suivantes :

Utilisez le paramètre de propriété suivant pour configurer le broker Kafka :

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

Créez le récepteur de messages.

Pour utiliser votre application en tant que récepteur d'événements, configurez le binder d'entrée en effectuant les tâches suivantes :
- Déclarez un bean Consumer qui définit la logique de traitement des messages. Par exemple, le bean Consumer suivant est nommé consume :
```
@Bean
public Consumer<Message<String>> consume() {
    return message -> {
        System.out.printf("New message received: %s%n", message.getPayload());
    };
}
```
- Ajoutez la configuration suivante pour préciser le nom Event Hub pour consommer. Veillez à remplacer l'espace réservé <your-event-hub-name> par votre valeur réelle.
```
# 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
```
Créez l'expéditeur de messages.

Pour utiliser votre application en tant que source d'événements, configurez le liant de sortie en effectuant les tâches suivantes :
- Définissez un bean Supplier qui définit la provenance des messages au sein de votre application, comme le montre l'exemple suivant :
```
@Bean
public Supplier<Message<String>> supply() {
    return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}
```
- Ajoutez la configuration suivante pour spécifier le nom Event Hub pour l'envoi. Veillez à remplacer l'espace réservé <your-event-hub-name> par votre valeur réelle.
```
# "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>
```
Lancez l’application. Vous voyez des logs similaires à l'exemple suivant :
```
Sending a message.
New message received: Hello world.
```

Déployer sur Azure Spring Apps

Maintenant que l'application Spring Boot fonctionne localement, il est temps de la mettre en production. Azure Spring Apps facilite le déploiement d’applications Spring Boot sur Azure sans aucune modification du code. Le service gère l’infrastructure des applications Spring, ce qui permet aux développeurs de se concentrer sur leur code. Azure Spring Apps fournit une gestion du cycle de vie à l’aide de la supervision et des diagnostics complets, de la gestion de la configuration, de la découverte de services, de l’intégration CI/CD, des déploiements bleu-vert, etc. Pour déployer votre application sur Azure Spring Apps, consultez Deploy your first application to Azure Spring Apps.

Étapes suivantes

Azure pour les développeurs Spring Spring Cloud Azure Event Hubs Samples

Voir aussi

Pour plus d’informations sur les autres démarrages Spring Boot disponibles pour Microsoft Azure, consultez Qu’est-ce que Spring Cloud Azure ?

Commentaires

Cette page a-t-elle été utile ?

Dernière mise à jour : 2026-03-11

Utiliser Event Hubs dans les applications Spring

Prérequis

Préparer votre environnement local

Utiliser Spring Cloud Azure Event Hubs Starter

Ajout de dépendances

Codez l'application pour envoyer et recevoir des messages

Utiliser l'autoconfiguration de Spring Boot

Construire le client par programme

Utiliser le Azure Event Hubs Spring Messaging

Ajout de dépendances

Codez l'application pour envoyer et recevoir des messages

Utiliser l'intégration Spring avec Azure Event Hubs

Ajout de dépendances

Codez l'application pour envoyer et recevoir des messages

Utiliser Spring Cloud Azure Stream Event Hubs Binder

Ajout de dépendances

Codez l'application pour envoyer et recevoir des messages

Utiliser Spring Kafka avec Azure Event Hubs

Ajout de dépendances

Codez l'application pour envoyer et recevoir des messages

Utiliser Spring Cloud Stream Kafka Binder avec Azure Event Hubs

Ajout de dépendances

Codez l'application pour envoyer et recevoir des messages

Déployer sur Azure Spring Apps

Étapes suivantes

Voir aussi

Commentaires

Ressources supplémentaires