Senden oder Empfangen von Ereignissen an bzw. von Azure Event Hubs unter Verwendung von Java (azure-eventhubs)Use Java to send events to or receive events from Azure Event Hubs (azure-eventhubs)

In dieser Schnellstartanleitung erfahren Sie, wie Sie mithilfe des Java-Pakets azure-eventhubs Ereignisse an einen Event Hub senden bzw. von dort empfangen.This quickstart shows how to send events to and receive events from an event hub using the azure-eventhubs Java package.

Warnung

In dieser Schnellstartanleitung werden die alten Paketen azure-eventhubs und azure-eventhubs-eph verwendet.This quickstart uses the old azure-eventhubs and azure-eventhubs-eph packages. Eine Schnellstartanleitung, in der das aktuelle Paket von azure-messaging-eventhubs verwendet wird, finden Sie unter Senden oder Empfangen von Ereignissen an bzw. von Azure Event Hubs unter Verwendung von Java (azure-messaging-eventhubs).For a quickstart that uses the latest azure-messaging-eventhubs package, see Send and receive events using azure-messaging-eventhubs. Informationen zur Umstellung Ihrer Anwendung vom alten auf das neue Paket finden Sie im Handbuch für die Migration von „azure-eventhubs“ zu „azure-messaging-eventhubs“.To move your application from using the old package to new one, see the Guide to migrate from azure-eventhubs to azure-messaging-eventhubs.

VoraussetzungenPrerequisites

Wenn Sie mit Azure Event Hubs noch nicht vertraut sind, lesen Sie vor dem Durcharbeiten dieser Schnellstartanleitung die Informationen unter Übersicht über Event Hubs.If you are new to Azure Event Hubs, see Event Hubs overview before you do this quickstart.

Zum Durchführen dieser Schnellstartanleitung benötigen Sie Folgendes:To complete this quickstart, you need the following prerequisites:

  • Microsoft Azure-Abonnement.Microsoft Azure subscription. Für die Verwendung von Azure-Diensten benötigen Sie ein Abonnement. Das gilt auch für Azure Event Hubs.To use Azure services, including Azure Event Hubs, you need a subscription. Falls Sie noch nicht über ein Azure-Konto verfügen, können Sie sich für eine kostenlose Testversion registrieren oder beim Erstellen eines Kontos Ihre MSDN-Abonnentenvorteile nutzen.If you don't have an existing Azure account, you can sign up for a free trial or use your MSDN subscriber benefits when you create an account.
  • Eine Java-Entwicklungsumgebung.A Java development environment. In dieser Schnellstartanleitung wird Eclipse verwendet.This quickstart uses Eclipse.
  • Erstellen Sie einen Event Hubs-Namespace und einen Event Hub.Create an Event Hubs namespace and an event hub. Verwenden Sie zunächst das Azure-Portal, um einen Namespace vom Typ „Event Hubs“ zu erstellen, und beschaffen Sie die Verwaltungsanmeldeinformationen, die Ihre Anwendung für die Kommunikation mit dem Event Hub benötigt.The first step is to use the Azure portal to create a namespace of type Event Hubs, and obtain the management credentials your application needs to communicate with the event hub. Erstellen Sie anhand der Anleitung in diesem Artikel einen Namespace und einen Event Hub.To create a namespace and an event hub, follow the procedure in this article. Gehen Sie anschließend wie im Artikel beschrieben vor, um den Wert des Zugriffsschlüssels für den Event Hub abzurufen: Abrufen der Verbindungszeichenfolge.Then, get the value of access key for the event hub by following instructions from the article: Get connection string. Sie verwenden den Zugriffsschlüssel im Code, den Sie später in dieser Schnellstartanleitung schreiben.You use the access key in the code you write later in this quickstart. Der Standardschlüsselname lautet: RootManageSharedAccessKey.The default key name is: RootManageSharedAccessKey.

Senden von EreignisseSend events

In diesem Abschnitt erfahren Sie, wie Sie eine Java-Anwendung zum Senden von Ereignissen an einen Event Hub erstellen.This section shows you how to create a Java application to send events an event hub.

Hinweis

Sie können diese Schnellstartvorlage als Beispiel aus GitHub herunterladen, die Zeichenfolgen EventHubConnectionString und EventHubName durch die Werte für Ihren Event Hub ersetzen und das Beispiel dann ausführen.You can download this quickstart as a sample from the GitHub, replace EventHubConnectionString and EventHubName strings with your event hub values, and run it. Alternativ können Sie auch die Schritte in dieser Schnellstartanleitung ausführen, um eine eigene Vorlage zu erstellen.Alternatively, you can follow the steps in this quickstart to create your own.

Hinzufügen von Verweisen auf die Azure Event Hubs-BibliothekAdd reference to Azure Event Hubs library

Die Java-Clientbibliothek für Event Hubs steht für die Verwendung in Maven-Projekten über das zentrale Maven-Repository bereit.The Java client library for Event Hubs is available for use in Maven projects from the Maven Central Repository. Sie können über die folgende Abhängigkeitsdeklaration in Ihrer Maven-Projektdatei auf diese Bibliothek verweisen:You can reference this library using the following dependency declaration inside your Maven project file:

<dependency>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>azure-eventhubs</artifactId>
    <version>2.2.0</version>
</dependency>

Für unterschiedliche Arten von Buildumgebungen können Sie explizit die zuletzt veröffentlichten JAR-Dateien aus dem zentralen Maven-Repository abrufen.For different types of build environments, you can explicitly obtain the latest released JAR files from the Maven Central Repository.

Um einen einfachen Ereignisherausgeber zu erhalten, importieren Sie das Paket com.microsoft.azure.eventhubs für die Event Hubs-Clientklassen und das Paket com.microsoft.azure.servicebus für Hilfsklassen, z.B. häufige Ausnahmen für den Azure Service Bus-Messagingclient.For a simple event publisher, import the com.microsoft.azure.eventhubs package for the Event Hubs client classes and the com.microsoft.azure.servicebus package for utility classes such as common exceptions that are shared with the Azure Service Bus messaging client.

Schreiben von Code zum Senden von Nachrichten an den Event HubWrite code to send messages to the event hub

Erstellen Sie für das folgende Beispiel zuerst ein neues Maven-Projekt für eine Konsolen-/Shellanwendung in Ihrer bevorzugten Java-Entwicklungsumgebung.For the following sample, first create a new Maven project for a console/shell application in your favorite Java development environment. Fügen Sie eine Klasse namens SimpleSend sowie den folgenden Code zur Klasse hinzu:Add a class named SimpleSend, and add the following code to the class:

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.microsoft.azure.eventhubs.ConnectionStringBuilder;
import com.microsoft.azure.eventhubs.EventData;
import com.microsoft.azure.eventhubs.EventHubClient;
import com.microsoft.azure.eventhubs.EventHubException;

import java.io.IOException;
import java.nio.charset.Charset;
import java.time.Instant;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;

public class SimpleSend {

    public static void main(String[] args)
            throws EventHubException, ExecutionException, InterruptedException, IOException {
            
            
    }
 }

Erstellen einer VerbindungszeichenfolgeConstruct connection string

Verwenden Sie die ConnectionStringBuilder-Klasse, um einen Verbindungszeichenfolgenwert an die Event Hubs-Clientinstanz zu übergeben.Use the ConnectionStringBuilder class to construct a connection string value to pass to the Event Hubs client instance. Ersetzen Sie die Platzhalter in Klammern durch die Werte, die beim Erstellen des Namespace und von Event Hub abgerufen wurden:Replace the placeholders with the values you obtained when you created the namespace and event hub:

        final ConnectionStringBuilder connStr = new ConnectionStringBuilder()
                .setNamespaceName("<EVENTHUB NAMESPACE") 
                .setEventHubName("EVENT HUB")
                .setSasKeyName("RootManageSharedAccessKey")
                .setSasKey("SHARED ACCESS KEY");

Schreiben von Code zum Senden von EreignissenWrite code to send events

Erstellen Sie ein einzelnes Ereignis, indem Sie eine Zeichenfolge in die entsprechende UTF-8-Bytecodierung umwandeln.Create a singular event by transforming a string into its UTF-8 byte encoding. Erstellen Sie dann auf der Grundlage der Verbindungszeichenfolge eine neue Event Hubs-Clientinstanz, und senden Sie die Nachricht:Then, create a new Event Hubs client instance from the connection string and send the message:

        final Gson gson = new GsonBuilder().create();

        // The Executor handles all asynchronous tasks and this is passed to the EventHubClient instance.
        // This enables the user to segregate their thread pool based on the work load.
        // This pool can then be shared across multiple EventHubClient instances.
        // The following sample uses a single thread executor, as there is only one EventHubClient instance,
        // handling different flavors of ingestion to Event Hubs here.
        final ScheduledExecutorService executorService = Executors.newScheduledThreadPool(4);

        // Each EventHubClient instance spins up a new TCP/SSL connection, which is expensive.
        // It is always a best practice to reuse these instances. The following sample shows this.
        final EventHubClient ehClient = EventHubClient.createSync(connStr.toString(), executorService);


        try {
            for (int i = 0; i < 10; i++) {

                String payload = "Message " + Integer.toString(i);
                byte[] payloadBytes = gson.toJson(payload).getBytes(Charset.defaultCharset());
                EventData sendEvent = EventData.create(payloadBytes);

                // Send - not tied to any partition
                // Event Hubs service will round-robin the events across all Event Hubs partitions.
                // This is the recommended & most reliable way to send to Event Hubs.
                ehClient.sendSync(sendEvent);
            }

            System.out.println(Instant.now() + ": Send Complete...");
            System.out.println("Press Enter to stop.");
            System.in.read();
        } finally {
            ehClient.closeSync();
            executorService.shutdown();
        }

Erstellen Sie das Programm, führen Sie es aus, und stellen Sie sicher, dass keine Fehler ausgelöst werden.Build and run the program, and ensure that there are no errors.

Glückwunsch!Congratulations! Sie haben jetzt Nachrichten an einen Event Hub gesendet.You have now sent messages to an event hub.

Anhang: So werden Nachrichten an Event Hub-Partitionen weitergeleitetAppendix: How messages are routed to EventHub partitions

Bevor die Nachrichten von Consumern abgerufen werden, müssen sie zuerst von den Herausgebern an die Partitionen veröffentlicht werden.Before messages are retrieved by consumers, they have to be published to the partitions first by the publishers. Wenn Nachrichten mit der sendSync()-Methode auf dem Objekt „com.microsoft.azure.eventhubs.EventHubClient“ synchron an Event Hub veröffentlichen werden, kann die Nachricht je nachdem, ob der Partitionsschlüssel angegeben ist oder nicht, an eine bestimmte Partition gesendet oder anhand der Roundrobin-Methode an alle verfügbaren Partitionen verteilt werden.When messages are published to event hub synchronously using the sendSync() method on the com.microsoft.azure.eventhubs.EventHubClient object, the message could be sent to a specific partition or distributed to all available partitions in a round-robin manner depending on whether the partition key is specified or not.

Wenn eine Zeichenfolge angegeben ist, die den Partitionsschlüssel darstellt, wird der Schlüssel angegeben wird, wird ein Hashwert für den Schlüssel erstellt, um zu bestimmen, an welche Partition das Ereignis gesendet wird.When a string representing the partition key is specified, the key will be hashed to determine which partition to send the event to.

Wenn der Partitionsschlüssel nicht festgelegt ist, werden Nachrichten per Roundrobin an alle verfügbaren Partitionen gesendet.When the partition key is not set, then messages will round-robined to all available partitions

// Serialize the event into bytes
byte[] payloadBytes = gson.toJson(messagePayload).getBytes(Charset.defaultCharset());

// Use the bytes to construct an {@link EventData} object
EventData sendEvent = EventData.create(payloadBytes);

// Transmits the event to event hub without a partition key
// If a partition key is not set, then we will round-robin to all topic partitions
eventHubClient.sendSync(sendEvent);

//  the partitionKey will be hash'ed to determine the partitionId to send the eventData to.
eventHubClient.sendSync(sendEvent, partitionKey);

// close the client at the end of your program
eventHubClient.closeSync();

Empfangen von EreignissenReceive events

Der Code in diesem Tutorial basiert auf dem EventProcessorSample-Code auf GitHub, den Sie untersuchen können, um die vollständige funktionierende Anwendung zu sehen.The code in this tutorial is based on the EventProcessorSample code on GitHub, which you can examine to see the full working application.

Empfangen von Nachrichten mit EventProcessorHost in JavaReceive messages with EventProcessorHost in Java

EventProcessorHost ist eine Java-Klasse, die das Empfangen von Ereignissen von Event Hubs durch die Verwaltung von permanenten Prüfpunkten und parallelen Empfangsvorgängen von diesen Event Hubs vereinfacht.EventProcessorHost is a Java class that simplifies receiving events from Event Hubs by managing persistent checkpoints and parallel receives from those Event Hubs. Mit EventProcessorHost können Sie Ereignisse selbst dann auf mehrere Empfänger aufteilen, wenn diese auf verschiedenen Knoten gehostet werden.Using EventProcessorHost, you can split events across multiple receivers, even when hosted in different nodes. Dieses Beispiel zeigt, wie EventProcessorHost für einen einzelnen Empfänger verwendet wird.This example shows how to use EventProcessorHost for a single receiver.

Speicherkonto erstellenCreate a storage account

Zum Verwenden von EventProcessorHost benötigen Sie ein [Azure Storage-Konto][Azure Storage-Konto]:To use EventProcessorHost, you must have an [Azure Storage account][Azure Storage account]:

  1. Melden Sie sich beim Azure-Portal an, und wählen Sie auf der linken Seite des Bildschirms Ressource erstellen aus.Sign in the Azure portal, and select Create a resource on the left-hand side of the screen.

  2. Wählen Sie Speicher und anschließend Speicherkonto aus.Select Storage, then select Storage account. Geben Sie im Fenster Speicherkonto erstellen einen Namen für das Speicherkonto ein.In the Create storage account window, type a name for the storage account. Füllen Sie die restlichen Felder aus, wählen Sie Ihre gewünschte Region aus, und wählen Sie dann Erstellen aus.Complete the rest of the fields, select your desired region, and then select Create.

    Erstellen eines Speicherkontos im Azure-Portal

  3. Wählen Sie das neu erstellte Speicherkonto und anschließend Zugriffsschlüssel aus:Select the newly created storage account, and then select Access Keys:

    Abrufen von Zugriffsschlüsseln im Azure-Portal

    Kopieren Sie den Wert von „key1“ an einen temporären Speicherort.Copy the key1 value to a temporary location. Sie benötigen ihn später in diesem Tutorial.You use it later in this tutorial.

Erstellen eines Java-Projekts mit EventProcessorHostCreate a Java project using the EventProcessor Host

Die Java-Clientbibliothek für Event Hubs steht für die Verwendung in Maven-Projekten im zentralen Maven-Repository zur Verfügung. Sie können darauf verweisen, indem Sie in der Maven-Projektdatei die folgende Abhängigkeitsdeklaration verwenden:The Java client library for Event Hubs is available for use in Maven projects from the Maven Central Repository, and can be referenced using the following dependency declaration inside your Maven project file:

<dependency>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>azure-eventhubs</artifactId>
    <version>2.2.0</version>
</dependency>
<dependency>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>azure-eventhubs-eph</artifactId>
    <version>2.4.0</version>
</dependency>

Für unterschiedliche Arten von Buildumgebungen können Sie explizit die zuletzt veröffentlichten JAR-Dateien aus dem zentralen Maven-Repository abrufen.For different types of build environments, you can explicitly obtain the latest released JAR files from the Maven Central Repository.

  1. Erstellen Sie für das folgende Beispiel zuerst ein neues Maven-Projekt für eine Konsolen-/Shellanwendung in Ihrer bevorzugten Java-Entwicklungsumgebung.For the following sample, first create a new Maven project for a console/shell application in your favorite Java development environment. Die Klasse hat die Bezeichnung ErrorNotificationHandler.The class is called ErrorNotificationHandler.

    import java.util.function.Consumer;
    import com.microsoft.azure.eventprocessorhost.ExceptionReceivedEventArgs;
    
    public class ErrorNotificationHandler implements Consumer<ExceptionReceivedEventArgs>
    {
        @Override
        public void accept(ExceptionReceivedEventArgs t)
        {
            System.out.println("SAMPLE: Host " + t.getHostname() + " received general error notification during " + t.getAction() + ": " + t.getException().toString());
        }
    }
    
  2. Verwenden Sie den folgenden Code, um eine neue Klasse mit dem Namen EventProcessorSamplezu erstellen.Use the following code to create a new class called EventProcessorSample. Ersetzen Sie die Platzhalter durch die Werte, die Sie beim Erstellen des Event Hubs und des Speicherkontos verwendet haben:Replace the placeholders with the values used when you created the event hub and storage account:

    package com.microsoft.azure.eventhubs.samples.eventprocessorsample;
    
    import com.microsoft.azure.eventhubs.ConnectionStringBuilder;
    import com.microsoft.azure.eventhubs.EventData;
    import com.microsoft.azure.eventprocessorhost.CloseReason;
    import com.microsoft.azure.eventprocessorhost.EventProcessorHost;
    import com.microsoft.azure.eventprocessorhost.EventProcessorOptions;
    import com.microsoft.azure.eventprocessorhost.ExceptionReceivedEventArgs;
    import com.microsoft.azure.eventprocessorhost.IEventProcessor;
    import com.microsoft.azure.eventprocessorhost.PartitionContext;
    
    import java.util.concurrent.ExecutionException;
    import java.util.function.Consumer;
    
    public class EventProcessorSample
    {
        public static void main(String args[]) throws InterruptedException, ExecutionException
        {
            String consumerGroupName = "$Default";
            String namespaceName = "----NamespaceName----";
            String eventHubName = "----EventHubName----";
            String sasKeyName = "----SharedAccessSignatureKeyName----";
            String sasKey = "----SharedAccessSignatureKey----";
            String storageConnectionString = "----AzureStorageConnectionString----";
            String storageContainerName = "----StorageContainerName----";
            String hostNamePrefix = "----HostNamePrefix----";
    
            ConnectionStringBuilder eventHubConnectionString = new ConnectionStringBuilder()
                 .setNamespaceName(namespaceName)
                 .setEventHubName(eventHubName)
                 .setSasKeyName(sasKeyName)
                 .setSasKey(sasKey);
    
            EventProcessorHost host = new EventProcessorHost(
                 EventProcessorHost.createHostName(hostNamePrefix),
                 eventHubName,
                 consumerGroupName,
                 eventHubConnectionString.toString(),
                 storageConnectionString,
                 storageContainerName);
    
            System.out.println("Registering host named " + host.getHostName());
            EventProcessorOptions options = new EventProcessorOptions();
            options.setExceptionNotification(new ErrorNotificationHandler());
    
            host.registerEventProcessor(EventProcessor.class, options)
            .whenComplete((unused, e) ->
            {
                if (e != null)
                {
                    System.out.println("Failure while registering: " + e.toString());
                    if (e.getCause() != null)
                    {
                        System.out.println("Inner exception: " + e.getCause().toString());
                    }
                }
            })
            .thenAccept((unused) ->
            {
                System.out.println("Press enter to stop.");
                try 
                {
                    System.in.read();
                }
                catch (Exception e)
                {
                    System.out.println("Keyboard read failed: " + e.toString());
                }
            })
            .thenCompose((unused) ->
            {
                return host.unregisterEventProcessor();
            })
            .exceptionally((e) ->
            {
                System.out.println("Failure while unregistering: " + e.toString());
                if (e.getCause() != null)
                {
                    System.out.println("Inner exception: " + e.getCause().toString());
                }
                return null;
            })
            .get(); // Wait for everything to finish before exiting main!
    
            System.out.println("End of sample");
        }
    
  3. Erstellen Sie eine weitere Klasse mit dem Namen EventProcessor und dem folgenden Code:Create one more class called EventProcessor, using the following code:

    public static class EventProcessor implements IEventProcessor
    {
        private int checkpointBatchingCount = 0;
    
        // OnOpen is called when a new event processor instance is created by the host. 
        @Override
        public void onOpen(PartitionContext context) throws Exception
        {
            System.out.println("SAMPLE: Partition " + context.getPartitionId() + " is opening");
        }
    
        // OnClose is called when an event processor instance is being shut down. 
        @Override
        public void onClose(PartitionContext context, CloseReason reason) throws Exception
        {
            System.out.println("SAMPLE: Partition " + context.getPartitionId() + " is closing for reason " + reason.toString());
        }
    
        // onError is called when an error occurs in EventProcessorHost code that is tied to this partition, such as a receiver failure.
        @Override
        public void onError(PartitionContext context, Throwable error)
        {
            System.out.println("SAMPLE: Partition " + context.getPartitionId() + " onError: " + error.toString());
        }
    
        // onEvents is called when events are received on this partition of the Event Hub. 
        @Override
        public void onEvents(PartitionContext context, Iterable<EventData> events) throws Exception
        {
            System.out.println("SAMPLE: Partition " + context.getPartitionId() + " got event batch");
            int eventCount = 0;
            for (EventData data : events)
            {
                try
                {
                    System.out.println("SAMPLE (" + context.getPartitionId() + "," + data.getSystemProperties().getOffset() + "," +
                            data.getSystemProperties().getSequenceNumber() + "): " + new String(data.getBytes(), "UTF8"));
                    eventCount++;
    
                    // Checkpointing persists the current position in the event stream for this partition and means that the next
                    // time any host opens an event processor on this event hub+consumer group+partition combination, it will start
                    // receiving at the event after this one. 
                    this.checkpointBatchingCount++;
                    if ((checkpointBatchingCount % 5) == 0)
                    {
                        System.out.println("SAMPLE: Partition " + context.getPartitionId() + " checkpointing at " +
                            data.getSystemProperties().getOffset() + "," + data.getSystemProperties().getSequenceNumber());
                        // Checkpoints are created asynchronously. It is important to wait for the result of checkpointing
                        // before exiting onEvents or before creating the next checkpoint, to detect errors and to ensure proper ordering.
                        context.checkpoint(data).get();
                    }
                }
                catch (Exception e)
                {
                    System.out.println("Processing failed for an event: " + e.toString());
                }
            }
            System.out.println("SAMPLE: Partition " + context.getPartitionId() + " batch size was " + eventCount + " for host " + context.getOwner());
        }
    }
    

Dieses Lernprogramm verwendet eine einzelne Instanz von EventProcessorHost.This tutorial uses a single instance of EventProcessorHost. Zur Erhöhung des Durchsatzes wird empfohlen, mehrere Instanzen von EventProcessorHost auszuführen, wenn möglich auf verschiedenen Computern.To increase throughput, we recommend that you run multiple instances of EventProcessorHost, preferably on separate machines. Auf diese Weise wird ebenfalls Redundanz erzielt.It provides redundancy as well. In diesen Fällen koordinieren sich die verschiedenen automatisch untereinander, um die Last der eingegangenen Ereignisse ausgeglichen zu verteilen.In those cases, the various instances automatically coordinate with each other in order to load balance the received events. Wenn mehrere Empfänger für jeden Prozess alle Ereignisse verarbeiten sollen, müssen Sie das ConsumerGroup -Konzept verwenden.If you want multiple receivers to each process all the events, you must use the ConsumerGroup concept. Wenn Ereignisse von anderen Computern empfangen werden, kann es hilfreich sein, die EventProcessorHost-Instanzen nach den Computern (oder Rollen) zu benennen, auf denen sie bereitgestellt worden sind.When receiving events from different machines, it might be useful to specify names for EventProcessorHost instances based on the machines (or roles) in which they are deployed.

Veröffentlichen von Nachrichten an EventHubPublishing Messages to EventHub

Bevor die Nachrichten von Consumern abgerufen werden, müssen sie zuerst von den Herausgebern an die Partitionen veröffentlicht werden.Before messages are retrieved by consumers, they have to be published to the partitions first by the publishers. Hinweis: Wenn Nachrichten mit der sendSync()-Methode auf dem Objekt „com.microsoft.azure.eventhubs.EventHubClient“ synchron an Event Hub veröffentlichen werden, kann die Nachricht je nachdem, ob der Partitionsschlüssel angegeben ist oder nicht, an eine bestimmte Partition gesendet oder anhand der Roundrobin-Methode an alle verfügbaren Partitionen verteilt werden.It is worth noting that when messages are published to event hub synchronously using the sendSync() method on the com.microsoft.azure.eventhubs.EventHubClient object, the message could be sent to a specific partition or distributed to all available partitions in a round-robin manner depending on whether the partition key is specified or not.

Wenn eine Zeichenfolge angegeben ist, die den Partitionsschlüssel darstellt, wird der Schlüssel angegeben wird, wird ein Hashwert für den Schlüssel erstellt, um zu bestimmen, an welche Partition das Ereignis gesendet wird.When a string representing the partition key is specified, the key is hashed to determine which partition to send the event to.

Wenn der Partitionsschlüssel nicht festgelegt ist, werden Nachrichten mithilfe von Roundrobin an alle verfügbaren Partitionen gesendet.When the partition key is not set, then messages are round-robined to all available partitions

// Serialize the event into bytes
byte[] payloadBytes = gson.toJson(messagePayload).getBytes(Charset.defaultCharset());

// Use the bytes to construct an {@link EventData} object
EventData sendEvent = EventData.create(payloadBytes);

// Transmits the event to event hub without a partition key
// If a partition key is not set, then we will round-robin to all topic partitions
eventHubClient.sendSync(sendEvent);

//  the partitionKey will be hash'ed to determine the partitionId to send the eventData to.
eventHubClient.sendSync(sendEvent, partitionKey);

Implementieren eines benutzerdefinierten Prüfpunkt-Managers für EventProcessorHost (EPH)Implementing a Custom CheckpointManager for EventProcessorHost (EPH)

Die API bietet einen Mechanismus zum Implementieren Ihres benutzerdefinierten Prüfpunkt-Managers für Szenarien, in denen die Standardimplementierung nicht mit Ihrem Anwendungsfall kompatibel ist.The API provides a mechanism to implement your custom checkpoint manager for scenarios where the default implementation is not compatible with your use case.

Der standardmäßige Prüfpunkt-Manager verwendet Blobspeicher, aber wenn Sie den von EPH verwendeten Prüfpunkt-Manager durch Ihre eigene Implementierung ersetzen, können Sie Speicher Ihrer Wahl zum Sichern Ihrer Prüfpunkt-Manager-Implementierung verwenden.The default checkpoint manager uses blob storage but if you override the checkpoint manager used by EPH with your own implementation, you can use any store you want to back your checkpoint manager implementation.

Erstellen Sie eine Klasse, die die Schnittstelle „com.microsoft.azure.eventprocessorhost.ICheckpointManager“ implementiert.Create a class that implements the interface com.microsoft.azure.eventprocessorhost.ICheckpointManager

Verwenden Sie Ihre benutzerdefinierte Implementierung des Prüfpunkts-Managers (com.microsoft.azure.eventprocessorhost.ICheckpointManager).Use your custom implementation of the checkpoint manager (com.microsoft.azure.eventprocessorhost.ICheckpointManager)

In Ihrer Implementierung können Sie den standardmäßigen Prüfpunktmechanismus außer Kraft setzen und Ihre eigenen Prüfpunkte basierend auf Ihrem eigenen Datenspeicher (wie SQL Server, CosmosDB und Azure-Cache für Redis) implementieren.Within your implementation, you can override the default checkpointing mechanism and implement our own checkpoints based on your own data store (like SQL Server, CosmosDB, and Azure Cache for Redis). Es wird empfohlen, dass der zum Sichern Ihrer Prüfpunkt-Manager-Implementierung verwendete Speicher für alle EPH-Instanzen zugänglich ist, die Ereignisse für die Consumergruppe verarbeiten.We recommend that the store used to back your checkpoint manager implementation is accessible to all EPH instances that are processing events for the consumer group.

Sie können einen beliebigen Datenspeicher verwenden, der in Ihrer Umgebung verfügbar ist.You can use any datastore that is available in your environment.

Die Klasse „com.microsoft.azure.eventprocessorhost.EventProcessorHost“ bietet Ihnen zwei Konstruktoren, mit denen Sie den Prüfpunkt-Manager für Ihre EventProcessorHost-Instanz außer Kraft setzen können.The com.microsoft.azure.eventprocessorhost.EventProcessorHost class provides you with two constructors that allow you to override the checkpoint manager for your EventProcessorHost.

Nächste SchritteNext steps

Lesen Sie die folgenden Artikel:Read the following articles: