Server- und Client-Streaming
Bidirektionales Streaming und Backpressure
Server- und Client-Streaming ist eine kostenlose Go Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Go Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.
gRPC-Streaming-Typen
gRPC unterstützt neben unären Aufrufen drei Streaming-Modi: Server-Streaming (der Server sendet viele Nachrichten), Client-Streaming (der Client sendet viele Nachrichten) und bidirektionales Streaming (beide Seiten streamen).
Server-Streaming in .proto
Verwenden Sie das Schlüsselwort stream vor dem Antworttyp:
service EventService {
rpc ListEvents (ListEventsRequest) returns (stream Event);
}Implementierung von Server-Streaming
Der Server sendet mehrere Nachrichten, indem er stream.Send() aufruft, und gibt nil zurück, wenn er fertig ist:
func (s *server) ListEvents(req *pb.ListEventsRequest, stream pb.EventService_ListEventsServer) error {
for _, event := range s.events {
if err := stream.Send(event); err != nil { return err }
}
return nil
}Client empfängt einen Server-Stream
Der Client ruft Recv() in einer Schleife bis io.EOF auf:
stream, err := client.ListEvents(ctx, &pb.ListEventsRequest{})
for {
event, err := stream.Recv()
if err == io.EOF { break }
if err != nil { log.Fatal(err) }
fmt.Println(event)
}Client-Streaming in .proto
Verwenden Sie stream vor dem Anfragetyp:
service UploadService {
rpc Upload (stream Chunk) returns (UploadResponse);
}Implementierung von Client-Streaming
Der Client sendet mehrere Nachrichten und schließt anschließend den Stream mit CloseAndRecv:
stream, _ := client.Upload(ctx)
for _, chunk := range chunks {
stream.Send(chunk)
}
resp, err := stream.CloseAndRecv()Server empfängt einen Client-Stream
Rufen Sie stream.Recv() in einer Schleife bis io.EOF auf und geben Sie anschließend die endgültige Antwort zurück:
func (s *server) Upload(stream pb.UploadService_UploadServer) error {
for {
chunk, err := stream.Recv()
if err == io.EOF {
return stream.SendAndClose(&pb.UploadResponse{Received: total})
}
if err != nil { return err }
total += len(chunk.Data)
}
}Bidirektionales Streaming
Client und Server können unabhängig voneinander senden und empfangen. Deklarieren Sie dies mit stream auf beiden Seiten in der .proto-Datei.
service ChatService {
rpc Chat (stream Message) returns (stream Message);
}Implementierung eines bidirektionalen Servers
Der Server empfängt in einer Goroutine und sendet unabhängig davon:
func (s *server) Chat(stream pb.ChatService_ChatServer) error {
for {
msg, err := stream.Recv()
if err == io.EOF { return nil }
if err != nil { return err }
stream.Send(&pb.Message{Text: "echo: " + msg.Text})
}
}Flusskontrolle
gRPC verwendet die HTTP/2-Flusskontrolle, um zu verhindern, dass schnelle Sender langsame Empfänger überlasten. Aufrufe von Recv() wenden auf natürliche Weise Backpressure an — das Senden wird blockiert, wenn der Empfänger nicht liest.
Kontextabbruch
Übergeben Sie allen Streaming-Aufrufen einen Kontext mit Zeitlimit oder Abbruchmöglichkeit. Der Stream wird abgebrochen, sobald der Kontext beendet ist, wodurch Recv/Send einen Fehler zurückgeben.
Kurzer Test
Wie signalisiert ein Server eines Server-Streaming-RPCs, dass er das Senden beendet hat?
Zusammenfassung: gRPC-Streaming
Wichtige Punkte:
- Server-Stream: Schlüsselwort stream bei der Antwort; der Server ruft Send() auf
- Client-Stream: Schlüsselwort stream bei der Anfrage; der Client ruft Send() und anschließend CloseAndRecv() auf
- Bidirektional: stream auf beiden Seiten; unabhängige Send- und Recv-Goroutinen
- Kontextabbruch gilt für alle Streaming-Aufrufe
Lerne Go mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 51
- Lektionen
- 203
Häufig gestellte Fragen
Ist die Lektion „Server- und Client-Streaming“ kostenlos?
Ja — der vollständige Text von „Server- und Client-Streaming“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Go Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Go Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Server- und Client-Streaming“?
Bidirektionales Streaming und Backpressure Du übst Go Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Go Academy zu starten?
Keine Vorkenntnisse erforderlich. Go Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Server- und Client-Streaming“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Go Academy-Lektion Code schreiben und ausführen?
Ja. Jede Go Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Protocol Buffers und .proto-Dateien
- Einen unären gRPC-Service implementieren
- Server- und Client-Streaming
- gRPC-Interceptoren und Metadaten