Go Academy · Lezione

Streaming dal server e dal client

Streaming bidirezionale e backpressure

Streaming dal server e dal client è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

Tipi di streaming gRPC

Oltre alle RPC unarie, gRPC supporta tre modalità di streaming: server-streaming (il server ne invia molte), client-streaming (il client ne invia molte) e bidirezionale (entrambi trasmettono).

Server streaming in .proto

Utilizzi la parola chiave stream prima del tipo di risposta:

service EventService {
    rpc ListEvents (ListEventsRequest) returns (stream Event);
}

Implementazione del server streaming

Il server invia più messaggi chiamando stream.Send() e restituisce nil al termine:

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
}

Il client riceve uno stream dal server

Il client chiama Recv() in un ciclo fino a io.EOF:

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

Utilizzi stream prima del tipo di richiesta:

service UploadService {
    rpc Upload (stream Chunk) returns (UploadResponse);
}

Implementazione del client streaming

Il client invia più messaggi, quindi chiude lo stream con CloseAndRecv:

stream, _ := client.Upload(ctx)
for _, chunk := range chunks {
    stream.Send(chunk)
}
resp, err := stream.CloseAndRecv()

Il server riceve uno stream dal client

Chiami stream.Recv() in un ciclo fino a io.EOF, quindi restituisca la risposta finale:

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)
    }
}

Streaming bidirezionale

Il client e il server possono entrambi inviare e ricevere in modo indipendente. Lo dichiari con stream su entrambi i lati nel file .proto.

service ChatService {
    rpc Chat (stream Message) returns (stream Message);
}

Implementazione del server bidirezionale

Il server riceve in una goroutine e invia in modo indipendente:

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})
    }
}

Controllo del flusso

gRPC utilizza il controllo del flusso di HTTP/2 per impedire che i mittenti veloci sovraccarichino i destinatari lenti. Le chiamate a Recv() applicano naturalmente la contropressione: l'invio si blocca quando il destinatario non sta leggendo.

Cancellazione del contesto

Passi un contesto con una scadenza o una cancellazione a tutte le chiamate di streaming. Lo stream viene cancellato quando il contesto è terminato, causando la restituzione di un errore da parte di Recv/Send.

Verifica rapida

In che modo il server di una RPC server-streaming segnala di aver terminato l'invio?

Riepilogo: streaming gRPC

Punti chiave:

Stream del server: parola chiave stream sulla risposta; il server chiama Send()
Stream del client: parola chiave stream sulla richiesta; il client chiama Send(), quindi CloseAndRecv()
Bidirezionale: stream su entrambi i lati; goroutine indipendenti per Send e Recv
La cancellazione del contesto si applica a tutte le chiamate di streaming

Domande Frequenti

La lezione «Streaming dal server e dal client» è gratuita?

Sì — il testo completo di «Streaming dal server e dal client» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «Streaming dal server e dal client»?

Streaming bidirezionale e backpressure Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Streaming dal server e dal client»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy