Wie verwende ich die Nachrichtenwarteschlange in Go?

Nachrichtenwarteschlange ist ein gängiges Systemarchitekturmuster, das eine äußerst wichtige Rolle bei der Handhabung hoher Parallelität und asynchroner Aufgabenverarbeitung spielt. In der Go-Sprache ist die Verwendung von Nachrichtenwarteschlangen durch einige Open-Source-Nachrichtenwarteschlangenbibliotheken und -tools sehr bequem und einfach geworden.

In diesem Artikel wird die Verwendung von Nachrichtenwarteschlangen in Go vorgestellt, einschließlich der folgenden:

1. Nachrichtenwarteschlangen verstehen
2. Allgemeine Nachrichtenwarteschlange
3. Die Vorteile und anwendbaren Szenarien der Verwendung der Nachrichtenwarteschlange in Go
4. Nachrichtenwarteschlangenbibliothek in der Go-Sprache
5. Ein Beispiel zeigt, wie die Nachrichtenwarteschlange in verwendet wird Go

Nachrichtenwarteschlange verstehen

Nachrichtenwarteschlange ist ein Architekturmuster, das Warteschlangen zum Zwischenspeichern, asynchronen Übertragen und Speichern von Nachrichten verwendet. Nachrichtenwarteschlangen sind im Allgemeinen in drei Teile unterteilt: Produzenten, Verbraucher und Warteschlangen. Der Produzent sendet die Nachricht an die Warteschlange und der Verbraucher nimmt die Nachricht zur Verarbeitung aus der Warteschlange. Der Zweck der Nachrichtenwarteschlange besteht darin, die Zeit- und Raumabhängigkeiten zwischen Produzenten und Verbrauchern zu entkoppeln und eine asynchrone Aufgabenverarbeitung zu implementieren.

Die Nachrichtenwarteschlange kann Daten zwischenspeichern, asynchrone Verarbeitung, Spitzenlastausgleich (um viele gleichzeitige Anforderungen in kurzer Zeit zu bewältigen) und Lastausgleich implementieren usw. Sie ist eine wichtige Komponente zur Unterstützung der Entwurf großer verteilter Systeme.

Gemeinsame Nachrichtenwarteschlange

Es gibt viele Nachrichtenwarteschlangenbibliotheken und -tools auf dem Markt, die verschiedene Programmiersprachen unterstützen. Die gebräuchlichsten sind die folgenden:

# 🎜🎜#

RabbitMQ: RabbitMQ ist ein Open-Source-Nachrichtenwarteschlangensystem, das mehrere Protokolle und Programmiersprachen wie AMQP, STOMP, MQTT usw. unterstützt. Entwickler können über verschiedene Sprachclients wie Go, Java darauf zugreifen , Python usw. RabbitMQ ist in der Sprache Erlang geschrieben und wird häufig zur Unterstützung von Echtzeitverarbeitungsszenarien wie IoT, Gruppenchat und Überwachung verwendet.
1. Apache Kafka: Apache Kafka ist ein Nachrichtenwarteschlangensystem, das auf dem Publish/Subscribe-Modell basiert. Es wurde von LinkedIn entwickelt und wird hauptsächlich zur kontinuierlichen Streaming-Datenverarbeitung verwendet. Kafka verteilt Nachrichten über mehrere Partitionen, um einen hohen Durchsatz und eine hohe Skalierbarkeit zu unterstützen.
2. ActiveMQ: ActiveMQ ist ein beliebtes JMS-basiertes Nachrichtenwarteschlangensystem, das mehrere Übertragungsprotokolle und den Zugriff auf Programmiersprachen wie AMQP, STOMP, Openwire usw. unterstützt.
3. NSQ: NSQ ist eine verteilte Echtzeit-Nachrichtenverarbeitungsplattform, die aus zwei Komponenten besteht: nsq und nsqd ist ein TCP-Proxyserver für die Client-Interaktion, während nsqd ein Dienst für persistente Nachrichten und Warteschlangen ist . .

Vorteile und anwendbare Szenarien der Verwendung von Nachrichtenwarteschlangen in Go

Die Go-Sprache unterstützt nativ Coroutinen, daher ist die Verwendung von Nachrichtenwarteschlangen zur Verarbeitung asynchroner Aufgaben besonders geeignet. Die Go-Sprache bietet viele Open-Source-Bibliotheken und Tools für Nachrichtenwarteschlangen, die auch relativ bequem zu verwenden sind.

Da die Nachrichtenwarteschlange Nachrichten außerdem asynchron verarbeitet, können Aufgaben ausgelagert werden, um eine hohe Parallelität auf einem einzelnen Computer zu vermeiden. Daher kann die Nachrichtenwarteschlange in den folgenden Szenarien verwendet werden:

Verarbeitung großer Datenmengen: z. B. Verarbeitung großer Mengen von Serverdaten in Website-Protokollen, Stresstests usw. ;
1. Asynchrone Verarbeitung und Aufgabenverteilung: wie E-Mail-Versand, SMS-Benachrichtigung usw.;
2. Verteilte Aufgabenwarteschlange: wie 0-Warteschlange, Rückstandswarteschlange usw.; 🎜🎜#
3. Mehrere gleichzeitige Verbraucherszenarien: z. B. Stromgeschäfts-Flash-Verkäufe, Kommentare mit hoher Parallelität usw.;
4. Anwendungsentkopplung und -erweiterung: z. B. die Integration externer Nachrichtendienstbenachrichtigungen und die Trennung von Daten Interaktion zwischen Systemen.
5. Nachrichtenwarteschlangenbibliothek in der Go-Sprache

In der Go-Sprache sind viele Open-Source-Nachrichtenwarteschlangenbibliotheken verfügbar, wie zum Beispiel:

#🎜 🎜 #

RabbitMQs AMQP-Client-Bibliothek: https://github.com/streadway/amqp;

Apache Kafkas Client-Bibliothek: https://github.com/confluentinc/ confluent-kafka-go ;
1. NSQ-Client-Bibliothek: https://github.com/nsqio/go-nsq.
3. Durch die Verwendung dieser Open-Source-Bibliotheken können problemlos Verbindungen zu verschiedenen Nachrichtenwarteschlangensystemen hergestellt werden, sodass sich Entwickler mehr auf die Logikentwicklung im Geschäftsbereich konzentrieren können, wodurch die Entwicklungseffizienz und die Lesbarkeit des Codes verbessert werden.

Zeigen Sie, wie Sie die Nachrichtenwarteschlange verwenden, indem Sie ein Beispiel durchgehen.

Nachfolgend zeigen wir, wie Sie die Nachrichtenwarteschlange verwenden, indem Sie ein einfaches Beispiel durchgehen.

Angenommen, wir möchten Bilddaten von einigen Websites crawlen und lokal speichern. Wir können go verwenden, um dieses Programm abzuschließen. Um das asynchrone Herunterladen einiger Bilder zu erreichen, verwenden wir RabbitMQ als Nachrichtenwarteschlange und führen die folgenden Schritte in Go aus:

RabbitMQ installieren

RabbitMQ installieren, Download von der offiziellen Website-Adresse: https://www.rabbitmq.com/download.html;

Configure RabbitMQ Geben Sie nach der Installation das bin-Verzeichnis ein (bitte ignorieren Sie das Suffix .bat für Nicht-Windows). Plattformen) und ausführen: ./rabbitmqctl start, RabbitMQ starten;
1. Erstellen Sie einen virtuellen MQ-Host, führen Sie aus: ./rabbitmqctl add_vhost test; : ./rabbitmqctl add_user test test, ./rabbitmqctl set_permissions -p test test ".
2. " ".
" ".*";
3. Starten Sie die RabbitMQ-Webverwaltungsoberfläche und Führen Sie Folgendes aus: ./rabbitmq-plugins aktivieren Sie Rabbitmq_management und geben Sie die Adresse http://localhost:15672 in den Browser ein, um die Verwaltungsoberfläche aufzurufen.
4. Code schreiben
5. Wir können die Bibliothek github.com/streadway/amqp verwenden, um mit RabbitMQ zu interagieren. Unten ist der Code.

Schreiben Sie zuerst den Crawler-Code, crawlen Sie die Bildadresse, die heruntergeladen werden muss, und senden Sie sie an RabbitMQ:

func main() {
    spider()
}

func spider() {
    url := "https://www.example.com"
    doc, _ := goquery.NewDocument(url)
    doc.Find(".img_wrapper img").Each(func(i int, s *goquery.Selection) {
        imgUrl, _ := s.Attr("src")
        publishToMQ(imgUrl)
    })
}

func publishToMQ(msg string) {
    conn, err := amqp.Dial("amqp://test:test@localhost:5672/test")
    failOnError(err, "Failed to connect to RabbitMQ")
    defer conn.Close()

    ch, err := conn.Channel()
    failOnError(err, "Failed to open a channel")
    defer ch.Close()

    q, err := ch.QueueDeclare(
        "image_downloader", // name
        true,               // durable
        false,              // delete when unused
        false,              // exclusive
        false,              // no-wait
        nil,                // arguments
    )
    failOnError(err, "Failed to declare a queue")

    err = ch.Publish(
        "",     // exchange
        q.Name, // routing key
        false,  // mandatory
        false,  // immediate
        amqp.Publishing{
            ContentType: "text/plain",
            Body:        []byte(msg),
        })
    failOnError(err, "Failed to publish a message")

    log.Printf(" [x] Sent %s", msg)
}

Dann schreibe den Bild-Downloader. Durch Abhören der Nachrichtenwarteschlange von RabbitMQ wird ein asynchrones Herunterladen von Bildern erreicht:

func main() {
    consumeMQ()
}

func consumeMQ() {
    conn, err := amqp.Dial("amqp://test:test@localhost:5672/test")
    failOnError(err, "Failed to connect to RabbitMQ")
    defer conn.Close()

    ch, err := conn.Channel()
    failOnError(err, "Failed to open a channel")
    defer ch.Close()

    q, err := ch.QueueDeclare(
        "image_downloader", // name
        true,               // durable
        false,              // delete when unused
        false,              // exclusive
        false,              // no-wait
        nil,                // arguments
    )
    failOnError(err, "Failed to declare a queue")

    msgs, err := ch.Consume(
        q.Name, // queue
        "",     // consumer
        true,   // auto-ack
        false,  // exclusive
        false,  // no-local
        false,  // no-wait
        nil,    // args
    )
    failOnError(err, "Failed to register a consumer")

    forever := make(chan bool)

    go func() {
        for d := range msgs {
            log.Printf("Received a message: %s", d.Body)
            downloadImage(string(d.Body))
        }
    }()

    log.Printf(" [*] Waiting for messages. To exit press CTRL+C")
    <-forever
}

func downloadImage(url string) {
    resp, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    file, err := os.Create(uuid.New().String() + ".jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    _, err = io.Copy(file, resp.Body)
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("Downloaded an image: %s", url)
}

Im obigen Code haben wir eine Arbeitswarteschlange „Bild-Downloader“ erstellt, nachdem der Produzent die Bildadresse des HTML analysiert hat Seite, es geht an die Arbeit Nachrichten in der Warteschlange senden. Der Verbraucher hört die Arbeitswarteschlange ab und ruft nach Erhalt der Nachricht die Funktion downloadImage auf, um die Bilddatei herunterzuladen.

Das obige Beispiel ist ein einfacher Anwendungsfall mit RabbitMQ. Die Verwendung anderer Nachrichtenwarteschlangenbibliotheken ist ähnlich, Sie müssen lediglich Verbindungen und Vorgänge über unterschiedliche APIs implementieren.

Übersicht

In diesem Artikel stellen wir vor und erklären, was eine Nachrichtenwarteschlange ist. In vielen Datenverarbeitungsszenarien ist der asynchrone Verbrauch unerlässlich. Die Go-Sprache macht die asynchrone Aufgabenverarbeitung aufgrund ihres eigenen Coroutine-Mechanismus einfach und effizient. In Verbindung mit den umfangreichen Open-Source-Bibliotheken der Go-Sprache selbst wird es äußerst einfach, Nachrichtenwarteschlangen zur Implementierung einer asynchronen Nachrichtenverarbeitung zu verwenden.

Anhand der obigen Beispiele können wir sehen, dass bei der Implementierung der asynchronen Aufgabenverarbeitung die Verwendung von Nachrichtenwarteschlangen die Verarbeitungseffizienz erheblich verbessern kann und die Verwendung von Nachrichtenwarteschlangen in der Go-Sprache auch sehr praktisch ist. In Projekten wird empfohlen, Open-Source-Nachrichtenwarteschlangenbibliotheken wie RabbitMQ oder Apache Kafka zu verwenden.

Das obige ist der detaillierte Inhalt vonWie verwende ich die Nachrichtenwarteschlange in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!