Event Hubs in Spring-Anwendungen verwenden

In diesem Artikel erfahren Sie, wie Sie Azure Event Hubs in Java Anwendungen verwenden, die mit dem Spring Framework erstellt wurden.

Azure Event Hubs ist eine Big Data Streaming-Plattform und ein Ereignisaufnahmedienst. Mit diesem Dienst können Millionen von Ereignissen pro Sekunde empfangen und verarbeitet werden. An einen Event Hub gesendete Daten können transformiert und mithilfe eines beliebigen Echtzeitanalyse-Anbieters oder eines Batchverarbeitungs- und Speicheradapters gespeichert werden.

Spring Cloud Azure bietet verschiedene Module zum Senden von Nachrichten an und empfangen von Nachrichten von Event Hubs mithilfe von Spring Frameworks.

Sie können die folgenden Module unabhängig voneinander verwenden oder für unterschiedliche Anwendungsfälle kombinieren:

mit Spring Cloud Azure Event Hubs Starter können Sie Nachrichten mit Event Hubs Java SDK-Clientbibliothek mit Spring Boot-Features senden und empfangen.
mit Spring Messaging Azure Event Hubs können Sie über Spring Messaging-API mit Event Hubs interagieren.
mit Spring Integration Azure Event Hubs können Sie Spring Integration Message Channels mit Event Hubs verbinden.
mit Spring Cloud Azure Stream Event Hubs Binder können Sie Event Hubs als Messaging-Middleware in Spring Cloud Stream-Anwendungen verwenden.
mit Spring Kafka mit Azure Event Hubs können Sie Spring Kafka verwenden, um Nachrichten an Event Hubs zu senden und zu empfangen.
Spring Cloud Stream Kafka Binder mit Azure Event Hubs ermöglicht Es Ihnen, Nachrichten über Spring Cloud Stream Kafka Binder mit Event Hubs zu senden und zu empfangen.

Voraussetzungen

Ein Azure-Abonnement – create one for free.
Java Development Kit (JDK), Version 8 oder höher.
Apache Maven.
Azure CLI.

Eine Azure Event Hubs Instanz. Weitere Informationen finden Sie unter Quickstart: Erstellen eines Event Hubs mit Azure Portal.
Ein Azure-Speicherkonto für Event Hubs-Checkpoints. Weitere Informationen finden Sie unter Erstellen eines Speicherkontos.
Ein Spring Boot-Anwendung. Wenn Sie keines haben, erstellen Sie ein Maven-Projekt mit dem Spring Initializr. Denken Sie daran, Maven Project auszuwählen, und wählen Sie unter Dependencies die Spring Web-Abhängigkeit aus, und wählen Sie dann Java Version 8 oder höher aus.

Hinweis

Um Ihrem Konto Zugriff auf Ressourcen zu gewähren, weisen Sie in Azure Event Hubs die Azure Event Hubs Data Receiver und Azure Event Hubs Data Sender Rolle dem aktuell verwendeten Microsoft Entra Konto zu. Weisen Sie dann im Azure Storage Konto die Rolle Storage Blob Data Contributor dem aktuell verwendeten Microsoft Entra Konto zu. Weitere Informationen zum Gewähren von Zugriffsrollen finden Sie unter Assign Azure Rollen mithilfe des Azure Portals und Authorize access to Event Hubs resources using Microsoft Entra ID.

Wichtig

Für die Schritte in diesem Tutorial wird mindestens die Spring Boot-Version 2.5 benötigt.

Bereiten Sie Ihre lokale Umgebung vor

In diesem Tutorial verfügen die Konfigurationen und der Code nicht über Authentifizierungsvorgänge. Für die Verbindung mit einem Azure-Dienst ist jedoch eine Authentifizierung erforderlich. Um die Authentifizierung abzuschließen, müssen Sie die Azure Identity-Clientbibliothek verwenden. Spring Cloud Azure verwendet DefaultAzureCredential, die die Azure Identity-Bibliothek bereitstellt, um Anmeldeinformationen ohne Codeänderungen zu erhalten.

„DefaultAzureCredential“ unterstützt mehrere Authentifizierungsmethoden und bestimmt, welche Methode zur Laufzeit verwendet wird. Mit diesem Ansatz kann Ihre Anwendung verschiedene Authentifizierungsmethoden in unterschiedlichen Umgebungen verwenden – z. B. in lokalen oder Produktionsumgebungen –, ohne dass umgebungsspezifischer Code implementiert werden muss. Weitere Informationen finden Sie im Abschnitt DefaultAzureCredential von Authentifizierung für Azure-gehostete Java-Anwendungen.

Informationen zum Ausführen der Authentifizierung in lokalen Entwicklungsumgebungen mit Azure CLI, IntelliJ oder anderen Methoden finden Sie unter Azure Authentifizierung in Java Entwicklungsumgebungen. Um die Authentifizierung in Azure Hostingumgebungen abzuschließen, empfehlen wir die Verwendung der verwalteten Identität. Weitere Informationen finden Sie unter Was sind verwaltete Identitäten für Azure-Ressourcen?

Verwenden von Spring Cloud Azure Event Hubs Starter

Das Modul Spring Cloud Azure Event Hubs Starter importiert die Event Hubs Java Clientbibliothek mit dem Spring Boot Framework. Sie können Spring Cloud Azure und die Azure SDK zusammen in einem nicht gegenseitig ausschließenden Muster verwenden. Daher können Sie die Event Hubs Java Client-API in Ihrer Spring-Anwendung weiterhin verwenden.

Hinzufügen von Abhängigkeiten

Um das Spring Cloud Azure Event Hubs Starter-Modul zu installieren, fügen Sie der Datei pom.xml die folgenden Abhängigkeiten hinzu:

Die Spring Cloud Azure Bill of Materials (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>
```
Hinweis

Wenn Sie Spring Boot 4.0.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 7.2.0festlegen.

Wenn Sie Spring Boot 3.5.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 6.2.0festlegen.

Wenn Sie Spring Boot 3.1.x-3.5.x verwenden, stellen Sie sicher, dass Sie die Version spring-cloud-azure-dependencies auf 5.25.0 setzen.

Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 4.20.0 festlegen.

Diese Stückliste (Bill of Material, BOM) sollte im Abschnitt <dependencyManagement> Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud-Azure Abhängigkeiten dieselbe Version verwenden.

Weitere Informationen zu der Version, die für diese BOM verwendet wird, finden Sie unter Welche Version von Spring Cloud Azure sollte ich verwenden?

Das Spring Cloud Azure Event Hubs Artefakt:

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

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

In diesem Leitfaden erfahren Sie, wie Sie die Event Hubs Java Clients im Kontext einer Spring-Anwendung verwenden. Hier werden die folgenden beiden Optionen vorgestellt:

Verwenden Sie die Autokonfiguration von Spring Boot und verwenden Sie fertige Clients aus dem Spring-Kontext (empfohlen).
Erstellen Sie den Client programmgesteuert.

Die Methode des Autowiring von Client-Beans aus dem Spring-IoC-Container hat die folgenden Vorteile, die Ihnen eine flexiblere und effizientere Erfahrung bei der Entwicklung mit Event-Hubs-Clients bieten können:

Sie wendet die externalisierte Konfiguration an, sodass Sie mit demselben Anwendungscode in verschiedenen Umgebungen arbeiten können.
Sie können das Spring Boot Framework an den Prozess des Lernens des Generatormusters delegieren und diesen Client für den Anwendungskontext registrieren. Mit dieser Delegierung können Sie sich auf die Verwendung der Kunden mit Ihrer eigenen Geschäftsanforderung konzentrieren.
Sie können die Integritätsanzeige auf einfache Weise verwenden, um den Status und die Integrität Ihrer Anwendung und interner Komponenten zu überprüfen.

In den folgenden Abschnitten finden Sie Codebeispiele, in denen gezeigt wird, wie Sie die beiden Alternativen EventProcessorClient und EventHubProducerClient verwenden können.

Hinweis

Azure Java SDK für Event Hubs bietet mehrere Clients für die Interaktion mit Event Hubs. Der Starter bietet auch die automatische Konfiguration für alle Event Hubs-Clients sowie Client-Generatoren. In diesem Artikel werden nur EventProcessorClient und EventHubProducerClient als Beispiele verwendet.

Verwenden der Autokonfiguration von Spring Boot

Um Nachrichten an Event Hubs zu senden und zu empfangen, konfigurieren Sie die Anwendung mithilfe der folgenden Schritte:

Verwenden Sie die folgenden Eigenschafteneinstellungen, um ihren Event Hubs-Namespace und den Event Hub-Namen zu konfigurieren:

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

Erstellen Sie eine neue EventHubProcessorClientConfiguration Java-Klasse, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um die Nachricht und den Fehlerhandler für EventProcessorClient zu registrieren.

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

}

Fügen Sie die EventProcessorClient und EventHubProducerClient in der Spring-Anwendung ein, und rufen Sie die zugehörigen APIs zum Senden und Empfangen von Nachrichten auf, wie im folgenden Beispiel gezeigt:

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

}

Starten Sie die Anwendung. Es werden Protokolle ähnlich dem folgenden Beispiel angezeigt:

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.

Erstellen Sie den Client programmgesteuert

Sie können die Client Beans selbst erstellen, aber das Verfahren ist kompliziert. In Spring Boot-Anwendungen müssen Sie Eigenschaften verwalten, das Generatormuster erlernen und den Client in Ihrem Spring-Anwendungskontext registrieren. Die folgenden Schritte veranschaulichen die Vorgehensweise:

Erstellen Sie eine neue EventHubClientConfiguration Java-Klasse, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um die EventProcessorClient und EventHubProducerClient Bean zu deklarieren. Achten Sie darauf, dass Sie die <your event-hubs-namespace>, <your-event-hub-name>, <your-storage-account-name> und <your-storage-account-container-name> Platzhalter mit Ihren tatsächlichen Werten ersetzen.

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

}

Fügen Sie die EventProcessorClient und EventHubProducerClient in Ihre Spring-Anwendung ein, wie im folgenden Beispiel gezeigt:

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

}

Starten Sie die Anwendung. Es werden Protokolle ähnlich dem folgenden Beispiel angezeigt:

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.

In der folgenden Liste sind einige Gründe aufgeführt, warum dieser Code nicht flexibel oder elegant ist:

Der Event Hubs-Namespace und der Event Hub-Name sind hartcodiert.
Wenn Sie @Value verwenden, um Konfigurationen aus der Spring-Umgebung zu erhalten, können Sie keine IDE-Hinweise in Ihrer application.properties-Datei haben.
Wenn Sie über ein Microservice-Szenario verfügen, müssen Sie den Code in jedem Projekt duplizieren, und es ist einfach, Fehler zu machen und schwer konsistent zu sein.

Glücklicherweise müssen Client-Beans mit Spring Cloud Azure nicht selbst erstellt werden. Stattdessen können Sie sie direkt einfügen und die Konfigurationseigenschaften verwenden, mit denen Sie bereits vertraut sind, um die Speicherwarteschlange zu konfigurieren. Weitere Informationen finden Sie unter Spring Cloud Azure Configuration.

Spring Cloud Azure bietet auch die folgenden globalen Konfigurationen für verschiedene Szenarien. Weitere Informationen finden Sie im Abschnitt Globale Konfiguration für Azure Service SDKs der Spring Cloud Azure-Konfiguration.

Proxy-Optionen.
Wiederholungsoptionen.
AMQP-Transportclientoptionen.

Sie können auch eine Verbindung mit verschiedenen Azure Clouds herstellen. Weitere Informationen finden Sie unter Connect to different Azure clouds.

Azure Event Hubs mit Spring Messaging verwenden

Das Modul Spring Messaging Azure Event Hubs bietet Unterstützung für Spring Messaging Framework mit Event Hubs.

Wenn Sie Spring Messaging Azure Event Hubs verwenden, können Sie die folgenden Features verwenden:

EventHubsTemplate: Nachrichten asynchron und synchron an einen Event Hub senden.
@EventHubsListener: Markieren Sie eine Methode als Ziel eines Event Hubs-Nachrichtenlisteners am Ziel.

In diesem Handbuch erfahren Sie, wie Sie Spring Messaging-Azure Event Hubs verwenden, um Nachrichten an Event Hubs zu senden und zu empfangen.

Hinzufügen von Abhängigkeiten

Um das Spring Messaging-Azure Event Hubs-Modul zu installieren, fügen Sie der Datei pom.xml die folgenden Abhängigkeiten hinzu:

Die Spring Cloud Azure Bill of Materials (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>
```
Hinweis

Wenn Sie Spring Boot 4.0.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 7.2.0festlegen.

Wenn Sie Spring Boot 3.5.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 6.2.0festlegen.

Wenn Sie Spring Boot 3.1.x-3.5.x verwenden, stellen Sie sicher, dass Sie die Version spring-cloud-azure-dependencies auf 5.25.0 setzen.

Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 4.20.0 festlegen.

Diese Stückliste (Bill of Material, BOM) sollte im Abschnitt <dependencyManagement> Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud-Azure Abhängigkeiten dieselbe Version verwenden.

Weitere Informationen zur Version, die für dieses BOM genutzt wird, finden Sie unter Welche Version von Spring Cloud Azure sollte ich verwenden.

Die Spring Cloud Azure Starter, Spring Messaging Event Hubs und Azure Event Hubs Checkpoint-Store-Artefakte:

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

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Um Nachrichten an Event Hubs zu senden und zu empfangen, konfigurieren Sie die Anwendung mithilfe der folgenden Schritte:

Verwenden Sie die folgenden Eigenschaftseinstellungen, um den Event Hubs-Namespace und den Storage Blob zu konfigurieren:

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>

Erstellen Sie eine neue ConsumerService Java-Klasse, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um einen Nachrichtenempfänger zu definieren. Ersetzen Sie den <your-event-hub-name> Platzhalter durch Ihren tatsächlichen Wert.

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

}

Verbinden Sie einen Absender und einen Empfänger, um Nachrichten mit Spring zu senden und zu empfangen, wie im folgenden Beispiel gezeigt. Ersetzen Sie den <your-event-hub-name> Platzhalter durch Ihren tatsächlichen Wert.

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

}

Tipp

Denken Sie daran, die @EnableAzureMessaging Anmerkung hinzuzufügen, die die Ermittlung von Methoden auslöst, die mit @EventHubsListener Anmerkungen versehen sind, und erstellen Sie im Hintergrund den Container für den Nachrichtenlistener.

Starten Sie die Anwendung. Es werden Protokolle ähnlich dem folgenden Beispiel angezeigt:
```
Sending a message to the Event Hubs.
New message received: Hello world
```

Verwendung von Spring Integration Azure Event Hubs

Das Modul Spring Integration Azure Event Hubs bietet Unterstützung für das Spring Integration Framework mit Event Hubs.

Wenn Ihre Spring-Anwendung Spring Integration-Nachrichtenkanäle verwendet, können Sie Nachrichten mithilfe von Kanaladaptern zwischen Ihren Nachrichtenkanälen und Event Hubs weiterleiten.

Ein eingehender Kanaladapter leitet Nachrichten von einem Event Hub an einen Nachrichtenkanal weiter. Ein ausgehender Kanaladapter veröffentlicht Nachrichten aus einem Nachrichtenkanal in einem Event Hub.

In diesem Leitfaden erfahren Sie, wie Sie Spring Integration Azure Event Hubs verwenden, um Nachrichten an Event Hubs zu senden und zu empfangen.

Hinzufügen von Abhängigkeiten

Um das Spring Cloud Azure Event Hubs Integration Starter-Modul zu installieren, fügen Sie die folgenden Abhängigkeiten zu Ihrer Datei pom.xml hinzu:

Die Spring Cloud Azure Bill of Materials (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>
```
Hinweis

Wenn Sie Spring Boot 4.0.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 7.2.0festlegen.

Wenn Sie Spring Boot 3.5.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 6.2.0festlegen.

Wenn Sie Spring Boot 3.1.x-3.5.x verwenden, stellen Sie sicher, dass Sie die Version spring-cloud-azure-dependencies auf 5.25.0 setzen.

Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 4.20.0 festlegen.

Diese Stückliste (Bill of Material, BOM) sollte im Abschnitt <dependencyManagement> Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud-Azure Abhängigkeiten dieselbe Version verwenden.

Weitere Informationen zur Version, die für dieses BOM genutzt wird, finden Sie unter Welche Version von Spring Cloud Azure sollte ich verwenden.

Das Spring Cloud Azure Event Hubs Integrationsartefakt:

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

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Um Nachrichten an Event Hubs zu senden und zu empfangen, konfigurieren Sie die Anwendung mithilfe der folgenden Schritte:

Verwenden Sie die folgenden Eigenschaftseinstellungen, um den Event Hubs-Namespace und den Storage Blob zu konfigurieren:

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>

Erstellen Sie eine neue MessageReceiveConfiguration Java-Klasse, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um einen Nachrichtenempfänger zu definieren. Ersetzen Sie den <your-event-hub-name> Platzhalter durch Ihren tatsächlichen Wert.

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

}

Erstellen Sie eine neue MessageSendConfiguration Java-Klasse, wie im folgenden Beispiel gezeigt. Diese Klasse wird verwendet, um einen Nachrichtenabsender zu definieren. Ersetzen Sie den <your-event-hub-name> Platzhalter durch Ihren tatsächlichen Wert.

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

}

Verbinden Sie einen Absender und einen Empfänger, um Nachrichten mit Spring zu senden und zu empfangen, wie im folgenden Beispiel gezeigt:

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

Tipp

Denken Sie daran, die @EnableIntegration Anmerkung hinzuzufügen, die die Spring Integration-Infrastruktur ermöglicht.

Starten Sie die Anwendung. Es werden Protokolle ähnlich dem folgenden Beispiel angezeigt:
```
Message was sent successfully.
New message received: Hello World
```

Verwendung von Spring Cloud Azure Stream Event Hubs Binder

Um die Event Hubs-API in einer Spring Cloud Stream-Anwendung aufzurufen, verwenden Sie das Spring Cloud Azure Event Hubs Stream Binder-Modul.

In diesem Leitfaden erfahren Sie, wie Sie Spring Cloud Stream Event Hubs Binder verwenden, um Nachrichten an Event Hubs zu senden und zu empfangen.

Hinzufügen von Abhängigkeiten

Um das Spring Cloud Azure Event Hubs Stream Binder-Modul zu installieren, fügen Sie die folgenden Abhängigkeiten zu Ihrer Datei pom.xml hinzu:

Die Spring Cloud Azure Bill of Materials (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>
```
Hinweis

Wenn Sie Spring Boot 4.0.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 7.2.0festlegen.

Wenn Sie Spring Boot 3.5.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 6.2.0festlegen.

Wenn Sie Spring Boot 3.1.x-3.5.x verwenden, stellen Sie sicher, dass Sie die Version spring-cloud-azure-dependencies auf 5.25.0 setzen.

Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 4.20.0 festlegen.

Diese Stückliste (Bill of Material, BOM) sollte im Abschnitt <dependencyManagement> Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud-Azure Abhängigkeiten dieselbe Version verwenden.

Weitere Informationen zur Version, die für dieses BOM genutzt wird, finden Sie unter Welche Version von Spring Cloud Azure sollte ich verwenden.

Das Spring Cloud Azure Event Hubs Stream Binder Artefakt:

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

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Um Nachrichten an Event Hubs zu senden und zu empfangen, konfigurieren Sie die Anwendung mithilfe der folgenden Schritte:

Verwenden Sie die folgenden Eigenschaftseinstellungen, um den Event Hubs-Namespace und den Storage Blob zu konfigurieren:

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>

Erstellen des Nachrichtenempfängers.

Um Ihre Anwendung als Ereignissenke zu verwenden, konfigurieren Sie den Eingabeordner, indem Sie die folgenden Aufgaben ausführen:
- Deklarieren Sie eine Consumer Bean, die die Nachrichtenverarbeitungslogik definiert. Zum Beispiel wird die folgende Consumer-Bean consume genannt:
```
@Bean
public Consumer<Message<String>> consume() {
     return message -> {
         System.out.printf("New message received: %s%n", message.getPayload());
     };
}
```
- Fügen Sie die folgende Konfiguration hinzu, um den Event Hub Namen für die Nutzung anzugeben. Ersetzen Sie den <your-event-hub-name> Platzhalter durch Ihren tatsächlichen Wert.
```
# 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
```
Erstellen des Nachrichtenabsenders.

Um Ihre Anwendung als Ereignisquelle zu verwenden, konfigurieren Sie den Ausgabeordner, indem Sie die folgenden Aufgaben ausführen:
- Definieren Sie eine Supplier Bean, die definiert, wo Nachrichten aus Ihrer Anwendung stammen, wie im folgenden Beispiel gezeigt:
```
@Bean
public Supplier<Message<String>> supply() {
    return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}
```
- Fügen Sie die folgende Konfiguration hinzu, um den Event Hub Namen für die Sendung anzugeben. Ersetzen Sie den <your-event-hub-name> Platzhalter durch Ihren tatsächlichen Wert.
```
# "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>
```
Starten Sie die Anwendung. Es werden Protokolle ähnlich dem folgenden Beispiel angezeigt:
```
Sending a message.
New message received: Hello world.
```

Verwenden von Spring Kafka mit Azure Event Hubs

Event Hubs bietet einen Kafka-Endpunkt, den Ihre bestehenden Kafka-basierten Anwendungen nutzen können. Dieser Ansatz stellt eine Alternative zum Ausführen eines eigenen Kafka-Clusters dar. Event Hubs funktioniert mit vielen Ihrer vorhandenen Kafka-Anwendungen. Weitere Informationen finden Sie unter Event Hubs für Apache Kafka.

In diesem Leitfaden erfahren Sie, wie Sie Azure Event Hubs und Spring Kafka verwenden, um Nachrichten an Event Hubs zu senden und zu empfangen.

Hinzufügen von Abhängigkeiten

Um die Spring Cloud Azure Starter- und Spring Kafka-Module zu installieren, fügen Sie die folgenden Abhängigkeiten zur Datei pom.xml hinzu:

Die Spring Cloud Azure Bill of Materials (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>
```
Hinweis

Wenn Sie Spring Boot 4.0.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 7.2.0festlegen.

Wenn Sie Spring Boot 3.5.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 6.2.0festlegen.

Wenn Sie Spring Boot 3.1.x-3.5.x verwenden, stellen Sie sicher, dass Sie die Version spring-cloud-azure-dependencies auf 5.25.0 setzen.

Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 4.20.0 festlegen.

Diese Stückliste (Bill of Material, BOM) sollte im Abschnitt <dependencyManagement> Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud-Azure Abhängigkeiten dieselbe Version verwenden.

Weitere Informationen zur Version, die für dieses BOM genutzt wird, finden Sie unter Welche Version von Spring Cloud Azure sollte ich verwenden.

Der Spring Cloud Azure Starter und das Spring Kafka Artefakt:

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

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Um Nachrichten an Event Hubs zu senden und zu empfangen, konfigurieren Sie die Anwendung mithilfe der folgenden Schritte:

Verwenden Sie die folgende Eigenschaftseinstellung, um den Event Hubs-Namespace zu konfigurieren:
```
spring.kafka.bootstrap-servers=<your event-hubs-namespace>.servicebus.windows.net:9093
```

Verwenden Sie KafkaTemplate, um Nachrichten zu senden und @KafkaListener um Nachrichten zu empfangen, wie im folgenden Beispiel gezeigt. Ersetzen Sie den <your-event-hub-name> Platzhalter durch Ihren tatsächlichen Wert.

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

}

Starten Sie die Anwendung. Es werden Protokolle ähnlich dem folgenden Beispiel angezeigt:
```
Message was sent successfully.
New message received: Hello world
```

Verwenden von Spring Cloud Stream Kafka Binder mit Azure Event Hubs

Spring Cloud Stream ist ein Framework, mit dem Anwendungsentwickler nachrichtengesteuerte Microservices schreiben können. Die Brücke zwischen einem Messagingsystem und Spring Cloud Stream erfolgt durch die Binderabstraktion. Binder existieren für mehrere Messaging-Systeme, aber einer der am häufigsten verwendeten Binder ist für Apache Kafka.

In diesem Leitfaden erfahren Sie, wie Sie Azure Event Hubs und Spring Cloud Stream Kafka Binder verwenden, um Nachrichten an Event Hubs zu senden und zu empfangen.

Hinzufügen von Abhängigkeiten

Um die Spring Cloud Azure Start- und Spring Cloud Stream-Ordner Kafka-Module zu installieren, fügen Sie die folgenden Abhängigkeiten zu Ihrer Datei pom.xml hinzu:

Die Spring Cloud Azure Bill of Materials (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>
```
Hinweis

Wenn Sie Spring Boot 4.0.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 7.2.0festlegen.

Wenn Sie Spring Boot 3.5.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 6.2.0festlegen.

Wenn Sie Spring Boot 3.1.x-3.5.x verwenden, stellen Sie sicher, dass Sie die Version spring-cloud-azure-dependencies auf 5.25.0 setzen.

Wenn Sie Spring Boot 2.x verwenden, stellen Sie sicher, dass Sie die spring-cloud-azure-dependencies Version auf 4.20.0 festlegen.

Diese Stückliste (Bill of Material, BOM) sollte im Abschnitt <dependencyManagement> Ihrer pom.xml Datei konfiguriert werden. Dadurch wird sichergestellt, dass alle Spring Cloud-Azure Abhängigkeiten dieselbe Version verwenden.

Weitere Informationen zur Version, die für dieses BOM genutzt wird, finden Sie unter Welche Version von Spring Cloud Azure sollte ich verwenden.

Das Spring Cloud Azure Startartefakt:

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

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Um Nachrichten an Event Hubs zu senden und zu empfangen, konfigurieren Sie die Anwendung mithilfe der folgenden Schritte:

Verwenden Sie die folgende Eigenschaftseinstellung, um den Kafka-Broker zu konfigurieren:

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

Erstellen des Nachrichtenempfängers.

Um Ihre Anwendung als Ereignissenke zu verwenden, konfigurieren Sie den Eingabeordner, indem Sie die folgenden Aufgaben ausführen:
- Deklarieren Sie eine Consumer Bean, die die Nachrichtenverarbeitungslogik definiert. Zum Beispiel wird die folgende Consumer-Bean consume genannt:
```
@Bean
public Consumer<Message<String>> consume() {
    return message -> {
        System.out.printf("New message received: %s%n", message.getPayload());
    };
}
```
- Fügen Sie die folgende Konfiguration hinzu, um den Event Hub Namen für die Nutzung anzugeben. Ersetzen Sie den <your-event-hub-name> Platzhalter durch Ihren tatsächlichen Wert.
```
# 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
```
Erstellen des Nachrichtenabsenders.

Um Ihre Anwendung als Ereignisquelle zu verwenden, konfigurieren Sie den Ausgabeordner, indem Sie die folgenden Aufgaben ausführen:
- Definieren Sie eine Supplier Bean, die definiert, wo Nachrichten aus Ihrer Anwendung stammen, wie im folgenden Beispiel gezeigt:
```
@Bean
public Supplier<Message<String>> supply() {
    return () -> {
        System.out.println("Sending a message.");
        return MessageBuilder.withPayload("Hello world").build();
    };
}
```
- Fügen Sie die folgende Konfiguration hinzu, um den Event Hub Namen für die Sendung anzugeben. Ersetzen Sie den <your-event-hub-name> Platzhalter durch Ihren tatsächlichen Wert.
```
# "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>
```
Starten Sie die Anwendung. Es werden Protokolle ähnlich dem folgenden Beispiel angezeigt:
```
Sending a message.
New message received: Hello world.
```

Bereitstellen für Azure Spring Apps

Nachdem Sie nun die Spring Boot-Anwendung lokal ausgeführt haben, ist es an der Zeit, sie in die Produktion zu verschieben. Azure Spring Apps erleichtert die Bereitstellung von Spring Boot-Anwendungen auf Azure ohne Codeänderungen. Der Dienst verwaltet die Infrastruktur von Spring-Anwendungen und ermöglicht es Entwicklern dadurch, sich auf ihren Code zu konzentrieren. Azure Spring Apps bietet Lebenszyklusverwaltung mit umfassender Überwachung und Diagnose, Konfigurationsverwaltung, Dienstermittlung, CI/CD-Integration, blaugrünen Bereitstellungen und mehr. So stellen Sie Ihre Anwendung bei Azure Spring Apps bereit: siehe Deploy your first application to Azure Spring Apps.

Nächste Schritte

Azure für Spring-Entwickler Spring Cloud Azure Event Hubs Samples

Siehe auch

Weitere Informationen zu den anderen Spring Boot Starters, die für Microsoft Azure verfügbar sind, finden Sie unter What is Spring Cloud Azure?

Feedback

War diese Seite hilfreich?

Last updated on 2026-03-11

Event Hubs in Spring-Anwendungen verwenden

Voraussetzungen

Bereiten Sie Ihre lokale Umgebung vor

Verwenden von Spring Cloud Azure Event Hubs Starter

Hinzufügen von Abhängigkeiten

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Verwenden der Autokonfiguration von Spring Boot

Erstellen Sie den Client programmgesteuert

Azure Event Hubs mit Spring Messaging verwenden

Hinzufügen von Abhängigkeiten

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Verwendung von Spring Integration Azure Event Hubs

Hinzufügen von Abhängigkeiten

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Verwendung von Spring Cloud Azure Stream Event Hubs Binder

Hinzufügen von Abhängigkeiten

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Verwenden von Spring Kafka mit Azure Event Hubs

Hinzufügen von Abhängigkeiten

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Verwenden von Spring Cloud Stream Kafka Binder mit Azure Event Hubs

Hinzufügen von Abhängigkeiten

Codieren der Anwendung zum Senden und Empfangen von Nachrichten

Bereitstellen für Azure Spring Apps

Nächste Schritte

Siehe auch

Feedback

Zusätzliche Ressourcen