Go Academy · Pelajaran

Streaming Server dan Client

Streaming dua arah dan tekanan balik

Streaming Server dan Client adalah pelajaran Go Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Go Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Go Academy mencakup 4 pelajaran total.

Tipe streaming gRPC

gRPC mendukung tiga mode streaming selain unary: streaming server (server mengirim banyak pesan), streaming klien (klien mengirim banyak pesan), dan dua arah (keduanya melakukan streaming).

Streaming server dalam .proto

Gunakan kata kunci stream sebelum tipe respons:

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

Implementasi streaming server

Server mengirim beberapa pesan dengan memanggil stream.Send() dan mengembalikan nil setelah selesai:

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
}

Klien menerima streaming server

Klien memanggil Recv() dalam perulangan sampai 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)
}

Streaming klien dalam .proto

Gunakan stream sebelum tipe permintaan:

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

Implementasi streaming klien

Klien mengirim beberapa pesan, lalu menutup streaming dengan CloseAndRecv:

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

Server menerima streaming klien

Panggil stream.Recv() dalam perulangan sampai io.EOF, lalu kembalikan respons akhir:

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 dua arah

Klien dan server dapat mengirim serta menerima secara independen. Deklarasikan stream di kedua sisi dalam .proto.

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

Implementasi server dua arah

Server menerima dalam goroutine dan mengirim secara independen:

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

Pengendalian aliran

gRPC menggunakan pengendalian aliran HTTP/2 untuk mencegah pengirim yang cepat membebani penerima yang lambat. Pemanggilan Recv() secara alami menerapkan tekanan balik — pengiriman akan terblokir saat penerima tidak membaca.

Pembatalan konteks

Teruskan konteks dengan batas waktu atau pembatalan ke semua pemanggilan streaming. Streaming dibatalkan saat konteks selesai, sehingga Recv/Send mengembalikan galat.

Pemeriksaan Singkat

Bagaimana server RPC streaming server menandakan bahwa server telah selesai mengirim?

Ringkasan: Streaming gRPC

Poin-poin penting:

Streaming server: kata kunci stream pada respons; server memanggil Send()
Streaming klien: kata kunci stream pada permintaan; klien memanggil Send() lalu CloseAndRecv()
Dua arah: stream di kedua sisi; goroutine Send dan Recv yang independen
Pembatalan konteks berlaku untuk semua pemanggilan streaming

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Streaming Server dan Client” gratis?

Ya — teks lengkap “Streaming Server dan Client” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Go Academy, upgrade ke CoddyKit PRO. Kursus Go Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Streaming Server dan Client”?

Streaming dua arah dan tekanan balik Kamu berlatih Go Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Go Academy?

Tidak diperlukan pengalaman sebelumnya. Go Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.

Berapa lama pelajaran “Streaming Server dan Client” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Go Academy ini?

Ya. Setiap pelajaran Go Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Go Academy