Die ereignisgesteuerte Architektur in Java mit Apache Kafka erm?glicht skalierbare, locker gekoppelte Systeme, indem er Ereignisse für die asynchrone Kommunikation verwendet. 1. Produzenten ver?ffentlichen Ereignisse zu Themen, und Verbraucher reagieren ohne direkte Abh?ngigkeiten. 2. Kafka bietet dauerhafte, partitionierte Protokolle mit Wiederholbarkeit und hohem Durchsatz. 3. Verwenden Sie die Kafka-Clients-Bibliothek in Java mit Kafkaproducer und Kafkaconsumer zur manuellen Steuerung. 4. Produzenten senden strukturierte Ereignisse (vorzugsweise JSON oder AVRO) an Themen, die ProductErrecord mit Callback -Handhabung verwenden. 5. Verbraucher befragen Nachrichten in einer Schleife, verarbeiten sie und begehen Offsets und verwenden optional Verbrauchergruppen für die horizontale Skalierung. 6. Zu den besten Verfahren geh?ren eine aussagekr?ftige Namensnamen, Ereignisversionierung, Fehlerbehandlung, Vermeidung von Blockiervorg?ngen, überwachung der Verbraucherverz?gerung und der Gew?hrleistung der Idempotenz. 7. Verwenden Sie optional Spring Kafka mit @kafkalistener und Kafkatemplate für eine vereinfachte, annotationsgetriebene Entwicklung. Durch den Beginn eines einzelnen Workflows wie Auftragsverarbeitung und Nutzung der Zuverl?ssigkeit von Kafka k?nnen Java-basierte verteilte Systeme durch ereignisgesteuerte Design Reaktionsf?higkeit, Resilienz und Wartbarkeit erreichen.

Event-gesteuerte Architektur (EDA) in Java mit Apache Kafka ist eine leistungsstarke Kombination zum Aufbau skalierbarer, belastbarer und locker gekoppelter Systeme. Anstelle von Komponenten, die sich direkt anrufen, kommunizieren sie durch Ereignisse - etwas passierte und andere reagieren. Apache Kafka ist aufgrund seiner Funktionen für hohe Durchsatz, Haltbarkeit und Echtzeit-Verarbeitungsfunktionen als Rückgrat für solche Architekturen ausgestattet.

So k?nnen Sie EDA in Java mit Kafka effektiv implementieren.

1. Kernkonzepte ereignisgesteuerter Architektur

In EDA:

• Produzenten ver?ffentlichen Ereignisse (Nachrichten) zu Themen.
• Verbraucher abonnieren Themen und reagieren auf Ereignisse.
• Die Kommunikation ist asynchron und entkoppelt .
• Komponenten müssen sich nicht über die Ereignisse informieren.

Mit Kafka:

• Themen sind langlebige, partitionierte Protokolle.
• Die Ereignisse werden für eine konfigurierbare Zeit gespeichert und erm?glichen eine Wiederholung.
• Mehrere Verbraucher k?nnen denselben Ereignisstrom unabh?ngig lesen.

Dies macht Kafka ideal für Microservices, Echtzeitanalysen, Prüfungsprotokollierung und vieles mehr.

2. Einrichten von Kafka in einem Java -Projekt

Verwenden Sie die Apache Kafka Client Library in Ihrem Maven- oder Gradle -Projekt.

Maven -Abh?ngigkeit:

 <De vorangehen>
    <gruppe> org.apache.kafka </Groupid>
    <artifactid> Kafka-Clients </artifactid>
    <version> 3.7.0 </Version>
</abh?ngig>

Sie werden haupts?chlich verwenden:

• KafkaProducer - Ereignisse senden
• KafkaConsumer - Ereignisse empfangen und verarbeiten

Betrachten Sie auch Spring Kafka , wenn Sie Spring Boot verwenden-es vereinfacht die Konfiguration und Annotationsentwicklung.

3. Produzieren von Ereignissen in Java

Um eine Veranstaltung zu ver?ffentlichen, erstellen Sie einen KafkaProducer und senden Sie Nachrichten an ein Thema.

 import org.apache.kafka.clients.Producer.*;
Import Java.util.Properties;

?ffentliche Klasse OrderProducer {
    privater endgültiger Produzent <String, String> Produzent;

    public OrderProducer () {
        Eigenschaften props = neue Eigenschaften ();
        props.put ("bootstrap.servers", "localhost: 9092");
        props.put ("key.serializer", "org.apache.kafka.common.serialization.Stringserializer");
        props.put ("value.serializer", "org.apache.kafka.common.Serialization.Stringserializer");

        this.Producer = neuer Kafkaproducer <> (Requisiten);
    }

    public void sendorderevent (String orderId, String -Status) {
        String topic = "Order-Events";
        ProcousErrecord <string, string> record = 
            Neue ProductErrecord <> (Thema, orderId, "orderIDID" ist "Status);

        Produzent.Send (Record, (Metadaten, Ausnahme) -> {
            if (Ausnahme! = null) {
                System.err.println ("Meldung nicht gesendet:" Exception.getMessage ());
            } anders {
                System.out.println ("an Partition gesendet" metadata.partition ()   
                                   "mit Offset" metadata.offset ());
            }
        });
    }

    public void close () {
        Produzent.CLOSE ();
    }
}

Tipp: Verwenden Sie JSON oder AVRO für strukturierte Ereignisse anstelle von einfachen Saiten in der Produktion.

4. Ereignisse mit Kafka -Verbraucher konsumieren

Erstellen Sie einen Verbraucher, der Ereignisse aus einem Thema befragt und sie verarbeitet.

 import org.apache.kafka.clients.consumer.*;
java.time.duration importieren;
Import Java.util.Collections;
Import Java.util.Properties;

?ffentliche Klasse Orderconsumer {
    Private Final Kafkaconsumer <String, String> Verbraucher;
    private endgültige Zeichenfolge Topic = "Order-Events";

    public OrderConsumer () {
        Eigenschaften props = neue Eigenschaften ();
        props.put ("bootstrap.servers", "localhost: 9092");
        props.put ("Group.id", "Bestellprozessgruppe");
        props.put ("key.deserializer", "org.apache.kafka.common.serialization.stringDeserializer");
        props.put ("value.deserializer", "org.apache.kafka.common.serialization.stringDeserializer");
        props.put ("auto.offset.reset", "frühestens"); // oder "neuest"

        this.consumer = new Kafkaconsumer <> (Requisiten);
    }

    public void start () {
        Consumer.

        versuchen {
            while (wahr) {
                CENSONEERRECORDS <String, String> Records = Consumer.Poll (Duration.Ofmillis (1000));
                für (CENSELERRECORD <STRING, STRING> DRECKREISE: Datens?tze) {
                    System.out.printf ("Empfangen: Key =%s, value =%s, partition =%d, offset =%d%n",
                            record.key (), record.Value (), record.Partition (), record.Offset ());

                    // das Ereignis verarbeiten
                    ProcessOrDereEvent (record.Value ());
                }
                // Bei Bedarf einen Offset für manuell begehen
                Consumer.Commitsync ();
            }
        } Endlich {
            Consumer.close ();
        }
    }

    private void ProcessOrderEvent (String -Wert) {
        // Gesch?ftslogik: DB aktualisieren, Benutzer benachrichtigen, den n?chsten Schritt ausl?sen usw.
        System.out.println ("Verarbeitungsereignis:" Wert);
    }
}

Verwenden Sie Verbrauchergruppen, um horizontal zu skalieren - die Instanz in einer Gruppe liest aus verschiedenen Partitionen.

5. Best Practices für EDA mit Kafka in Java

• Verwenden Sie aussagekr?ftige Themennamen : z. user-signed-up , payment-failed , inventory-updated .
• Version Ihre Ereignisse : Schema -Version in der Ereignisnutzlast oder verwenden Sie Confluent Schema Registry .
• Fehlern ordnungsgem?? behandeln : Stürzen Sie nicht mit schlechten Nachrichten-leichten, wiederholen Sie oder senden Sie es an ein Thema für das Sackgassen.
• Vermeiden Sie lange Blockiervorg?nge bei Verbrauchern : Arbeiten Sie bei Bedarf in Threads oder Nachrichtenwarteschlangen.
• überwachen Sie die Verz?gerung : Verfolgen Sie die Verz?gerung der Verbrauchergruppe, um Verarbeitungsverz?gerungen zu erkennen.
• Verwenden Sie idempotente Verbraucher : Stellen Sie sicher, dass die Verarbeitung eines Ereignisses zweimal keine Nebenwirkungen verursacht.

6. Optional: Verwenden Sie den Einfachheit halber Spring Kafka

Mit Spring Boot k?nnen Sie Anmerkungen wie @KafkaListener und @SendTo verwenden.

 @Service
?ffentliche Klasse KafkaconumerService {

    @Kafkalistener (topics = "Order-Events", GroupID = "Order-Group"))
    public void listen (string message) {
        System.out.println ("erhalten über Spring Kafka:" Nachricht);
        // Event handhaben
    }
}

Und produzieren leicht:

 @Autowired
private kafkatemplate <String, String> Kafkatemplate;

public void sendEvent (String -Thema, Zeichenfolgeschlüssel, String Payload) {
    kafkatemplate.send (Thema, Schlüssel, Nutzlast);
}

Spring Kafka behandelt die Serialisierung, das F?den und die Fehlerhandhabung der Box.

Zusammenfassung

Erstellen eines ereignisgesteuerten Systems in Java mit Apache Kafka Mit Apache Kafka k?nnen Sie:

• Dekuple Services
• Unabh?ngig skalieren
• In Echtzeit reagieren
• Wiederholungsereignisse für die Wiederherstellung oder Analyse wiederholen

Starten Sie klein: W?hlen Sie einen Workflow (z. B. Auftragsverarbeitung), modellieren Sie ihn als Ereignisse und verbinden Sie Hersteller und Verbraucher. Dann nach Bedarf ausdehnen.

Mit Kafkas Zuverl?ssigkeit und Javas ?kosystem wird Eda nicht nur machbar, sondern auch in der Ebene wartbar und leistungsf?hig.

Wenn Sie verteilte Systeme in Java bauen, ist Kafka im Grunde eines der besten Tools, die ereignisgesteuert sind.

Das obige ist der detaillierte Inhalt vonEreignisgesteuerte Architektur in Java mit Apache Kafka. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!