Implementieren von Server-Sent Events (SSE) mit Python und Go

In den heutigen interaktiven Webanwendungen sind Datenaktualisierungen in Echtzeit für die Verbesserung des Benutzererlebnisses von entscheidender Bedeutung. Unter den verschiedenen Echtzeit-Kommunikationstechnologien stechen Server-Sent Events (SSE) als einfache, aber effektive Lösung hervor. SSE ermöglicht es Servern, Echtzeitaktualisierungen über HTTP an Clients zu übertragen.

Was ist SSE?

Server-Sent Events (SSE) ist eine Technologie, die es dem Server ermöglicht, Daten proaktiv an den Client zu übertragen, auch bekannt als „Event Stream“. Es basiert auf dem HTTP-Protokoll und nutzt dessen langlebige Verbindungseigenschaften. SSE stellt eine dauerhafte Verbindung zwischen dem Client und dem Server her, sodass der Server Datenaktualisierungen in Echtzeit an den Client senden kann. Der Client kann jedoch keine Daten über SSE an den Server zurücksenden.

Warum SSE wählen?

Vom Server gesendete Ereignisse sind Teil der HTML5-Spezifikation und wurden speziell für die Übertragung von Ereignissen vom Server an den Client entwickelt. Seine Einfachheit, die automatische Wiederverbindung und die Ereignisverfolgungsfunktionen machen es ideal für Szenarien, die einen unidirektionalen Datenfluss erfordern. SSE bietet eine außergewöhnlich gute Leistung, wenn Daten in eine Richtung gestreamt werden.

Überblick

SSE ermöglicht es dem Server, Nachrichten in Echtzeit an den Browser zu senden. Als Teil der HTML5-Spezifikation beinhaltet es:

• Kommunikationsprotokoll: Verwendet HTTP.
• Ereignisobjekte: Verfügbar auf der Browserseite.

Während WebSockets auch Echtzeitkommunikation bieten, unterscheiden sie sich erheblich:

Feature	SSE	WebSockets
Protocol Basis	HTTP	TCP
Data Flow	Unidirectional (server to client)	Full-duplex (bidirectional)
Complexity	Lightweight and simple	More complex
Reconnection	Built-in	Manual implementation needed
Message Tracking	Automatic	Manual implementation needed
Data Types	Text or Base64-encoded binary	Various data types supported
Event Types Support	Custom events supported	Custom events not supported
Limitations	HTTP/1.1 or HTTP/2	Unlimited connections

Serverimplementierung

Protokollimplementierung

Im Wesentlichen initiiert der Browser eine HTTP-Anfrage und der Server antwortet mit einem HTTP-Status zusammen mit diesen Headern:

Content-Type: text/event-stream
Cache-Control: no-cache
Connection: keep-alive

SSE gibt an, dass der MIME-Typ für Ereignisströme text/event-stream sein muss. Browser sollten keine Daten zwischenspeichern und Verbindungen sollten dauerhaft bleiben (Keep-Alive).

Nachrichtenformat

Ereignisströme verwenden UTF-8-codierten Text oder Base64-codierte Binärnachrichten, die mit gzip komprimiert wurden. Jede Nachricht besteht aus einem oder mehreren Feldern im Format Feldname : Feldwert. Jedes Feld endet mit einem n. Zeilen, die mit einem Doppelpunkt beginnen, sind Kommentare, die vom Browser ignoriert werden. Mehrere Nachrichten in einem Push werden durch Leerzeilen (nn) getrennt.

Zu den Schlüsselfeldern gehören:

• Ereignis: Der Ereignistyp.
• id: Die Ereignis-ID, die vom Browser verwendet wird, um das zuletzt empfangene Ereignis zur erneuten Verbindung zu verfolgen.
• Wiederholen: Die Wartezeit (in ms), die der Browser nach einem Fehler benötigt, um die Verbindung erneut zu versuchen.
• Daten: Die Nachrichtendaten.

Beispiel: SSE mit Python

Hier ist eine Implementierung mit Python:

from flask import Flask, Response

app = Flask(__name__)

@app.route('/events')
def sse_handler():
    def generate():
        paragraph = [
            "Hello, this is an example of a continuous text output.",
            "It contains multiple sentences, each of which will be sent to the client as an event.",
            "This is to simulate the functionality of Server-Sent Events (SSE).",
            "We can use this method to push real-time updates.",
            "End of sample text, thank you!",
        ]

        for sentence in paragraph:
            yield f"data: {sentence}\n\n"

            import time
            time.sleep(1)

    return Response(generate(), mimetype='text/event-stream')

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8081, debug=True)

Beispiel: SSE mit Go

Hier ist eine Implementierung mit Go:

package main

import (
    "fmt"
    "log"
    "net/http"
    "time"
)

func main() {
    http.HandleFunc("/events", sseHandler)

    fmt.Println("Starting server on :8080")
    if err := http.ListenAndServe(":8080", nil); err != nil {
        log.Fatalf("Server error: %v", err)
    }
}

func sseHandler(w http.ResponseWriter, r *http.Request) {
    flusher, ok := w.(http.Flusher)
    if !ok {
        http.Error(w, "Streaming unsupported!", http.StatusInternalServerError)
        return
    }

    w.Header().Set("Content-Type", "text/event-stream")
    w.Header().Set("Cache-Control", "no-cache")
    w.Header().Set("Connection", "keep-alive")

    paragraph := []string{
        "Hello, this is an example of a continuous text output.",
        "It contains multiple sentences, each of which will be sent to the client as an event.",
        "This is to simulate the functionality of Server-Sent Events (SSE).",
        "We can use this method to push real-time updates.",
        "End of sample text, thank you!",
    }

    for _, sentence := range paragraph {
        _, err := fmt.Fprintf(w, "data: %s\n\n", sentence)
        if err != nil {
            return
        }
        flusher.Flush()
        time.Sleep(1 * time.Second)
    }
}

Browser-API

Auf der Clientseite können Sie mit der EventSource-API von JavaScript ein EventSource-Objekt erstellen, um vom Server gesendete Ereignisse abzuhören. Sobald die Verbindung hergestellt ist, kann der Server Ereignismeldungen an den Browser senden. Der Browser verarbeitet diese Nachrichten, indem er auf die Ereignisse onmessage, onopen und onerror lauscht.

<!DOCTYPE html>
<html lang="de">
<Kopf>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>SSE-Beispiel ?</title>
</head>
<Körper>
    <h1>Beispiel für vom Server gesendete Ereignisse ?</h1>
    <div>



<h2>
  
  
  SSE-Debugging-Tools
</h2>

<p>Derzeit fehlt vielen beliebten Tools wie Postman, Insomnia, Bruno und ThunderClient die ausreichende Unterstützung für das Debuggen von Server-Sent Events (SSE). Diese Einschränkung kann während der Entwicklung ziemlich frustrierend sein. Glücklicherweise bietet EchoAPI hervorragende SSE-Debugging-Funktionen, die die Effizienz und Produktivität des Arbeitsablaufs erheblich verbessern.</p>

<p><img src="https://img.php.cn/upload/article/000/000/000/173482771419125.jpg" alt="Implementing Server-Sent Events (SSE) with Python and Go"></p>

<p>Wenn Sie mit SSE oder API-Debugging arbeiten, empfehle ich dringend, EchoAPI auszuprobieren. Es kann Ihr Debugging-Erlebnis revolutionieren und Ihren Entwicklungsprozess rationalisieren. Weitere Informationen finden Sie unter echoapi.com. </p><h3>
  
  
  Beispiel: EchoAPI-Client für SSE
</h3>

<p>In EchoAPI ist die Verwendung der SSE-Schnittstelle unkompliziert. Geben Sie einfach die URL ein, geben Sie die relevanten Parameter ein und klicken Sie auf „<strong>Senden</strong>“, um die Ergebnisse Ihrer Anfrage anzuzeigen.</p>

<p><img src="https://img.php.cn/upload/article/000/000/000/173482771591634.jpg" alt="Implementing Server-Sent Events (SSE) with Python and Go"></p>


          

            
        

Das obige ist der detaillierte Inhalt vonImplementieren von Server-Sent Events (SSE) mit Python und Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!