gRPC & High Performance APIs · Leçon

Le flux serveur expliqué

Comprenez et mettez en œuvre le flux côté serveur, dans lequel un serveur envoie plusieurs réponses à une seule demande du client.

Le flux serveur expliqué est une leçon gRPC & High Performance APIs gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage gRPC & High Performance APIs, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours gRPC & High Performance APIs comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Server Streaming Basics

In gRPC, a server-side streaming call is when a client sends a single request, but the server responds with a sequence of messages.

Think of it like subscribing to a newsletter: you send one request (subscribe), and the server sends you many updates over time (newsletters).

Use Cases for Streaming

Server streaming is perfect for scenarios where the server needs to push updates or a large amount of data to the client over time. Common uses include:

Real-time data feeds: Stock prices, sensor readings.
Notifications: Alerts, chat messages.
Large data downloads: Breaking a big file into smaller chunks.

Protobuf for Server Streaming

To define a server-side streaming method in your .proto file, you simply add the stream keyword before the response type.

This tells gRPC that the server will send multiple messages for each client request, not just one.

Streaming Protobuf Example

Here's how you define a service that streams messages from the server:

syntax = "proto3";

option java_package = "com.coddykit.grpc";
option java_outer_classname = "StreamingProto";

service NotifierService {
  rpc SubscribeToNotifications (SubscriptionRequest) returns (stream Notification);
}

message SubscriptionRequest {
  string userId = 1;
}

message Notification {
  string message = 1;
  int64 timestamp = 2;
}

Implementing the Server Stream

On the server side, your streaming method will receive a single request object, just like a unary call. However, instead of returning a single response, you'll use a StreamObserver to send multiple responses back to the client.

You'll typically loop and send messages, then call onCompleted() when done.

Server Method Structure

The server method for a streaming call takes the request and a StreamObserver. You send responses via responseObserver.onNext() and signal completion with responseObserver.onCompleted().

// Example (Java)
public void subscribeToNotifications(SubscriptionRequest request,
    io.grpc.stub.StreamObserver<Notification> responseObserver) {

  String userId = request.getUserId();
  System.out.println("Client " + userId + " subscribed.");

  // Simulate sending multiple notifications
  for (int i = 0; i < 3; i++) {
    Notification notification = Notification.newBuilder()
        .setMessage("Update " + (i + 1) + " for " + userId)
        .setTimestamp(System.currentTimeMillis())
        .build();
    responseObserver.onNext(notification); // Send a message
    try {
      Thread.sleep(1000); // Wait a bit
    } catch (InterruptedException e) { /* handle */ }
  }

  responseObserver.onCompleted(); // Signal completion
  System.out.println("Finished sending notifications to " + userId);
}

Receiving Streamed Responses

The client makes a single call, but then it needs to wait and process multiple responses. It provides a StreamObserver to handle the incoming messages, errors, and the completion signal from the server.

This observer will have onNext(), onError(), and onCompleted() methods.

Client Stream Observer

The client's StreamObserver defines how it reacts to each event from the server stream. It processes each onNext message until onCompleted is called.

// Example (Java)
StreamObserver<Notification> responseObserver = new StreamObserver<Notification>() {
  @Override
  public void onNext(Notification notification) {
    System.out.println("Received: " + notification.getMessage());
  }

  @Override
  public void onError(Throwable t) {
    System.err.println("Error: " + t.getMessage());
  }

  @Override
  public void onCompleted() {
    System.out.println("Server stream completed.");
  }
};

// Call the streaming method
// asyncStub.subscribeToNotifications(request, responseObserver);

Complete Server Stream Service

Here's a complete gRPC server that implements the SubscribeToNotifications server-side streaming method. Run this first, then the client!

import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.stub.StreamObserver;
import com.coddykit.grpc.StreamingProto.SubscriptionRequest;
import com.coddykit.grpc.StreamingProto.Notification;
import com.coddykit.grpc.NotifierServiceGrpc.NotifierServiceImplBase;

public class StreamingServer {

  private Server server;

  private void start() throws Exception {
    int port = 50051;
    server = ServerBuilder.forPort(port)
        .addService(new NotifierServiceImpl())
        .build()
        .start();
    System.out.println("Server started, listening on " + port);

    Runtime.getRuntime().addShutdownHook(new Thread() {
      @Override
      public void run() {
        System.err.println("*** shutting down gRPC server since JVM is shutting down");
        StreamingServer.this.stop();
        System.err.println("*** server shut down");
      }
    });
  }

  private void stop() {
    if (server != null) {
      server.shutdown();
    }
  }

  private void blockUntilShutdown() throws InterruptedException {
    if (server != null) {
      server.awaitTermination();
    }
  }

  public static void main(String[] args) throws Exception {
    final StreamingServer server = new StreamingServer();
    server.start();
    server.blockUntilShutdown();
  }

  static class NotifierServiceImpl extends NotifierServiceImplBase {
    @Override
    public void subscribeToNotifications(SubscriptionRequest request,
        StreamObserver<Notification> responseObserver) {

      String userId = request.getUserId();
      System.out.println("Server received subscription from: " + userId);

      for (int i = 0; i < 3; i++) {
        Notification notification = Notification.newBuilder()
            .setMessage("Update " + (i + 1) + " for " + userId)
            .setTimestamp(System.currentTimeMillis())
            .build();
        responseObserver.onNext(notification);
        try {
          Thread.sleep(1000); // Simulate some work
        } catch (InterruptedException e) {
          Thread.currentThread().interrupt();
          responseObserver.onError(e);
          return;
        }
      }
      responseObserver.onCompleted();
      System.out.println("Server finished sending notifications to: " + userId);
    }
  }
}

Complete Client Stream Receiver

Now, run this client code. It will connect to the server and receive the stream of notifications.

import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.stub.StreamObserver;
import com.coddykit.grpc.StreamingProto.SubscriptionRequest;
import com.coddykit.grpc.StreamingProto.Notification;
import com.coddykit.grpc.NotifierServiceGrpc;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

public class StreamingClient {

  public static void main(String[] args) throws InterruptedException {
    ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 50051)
        .usePlaintext() // For local testing, no TLS
        .build();

    NotifierServiceGrpc.Stub asyncStub = NotifierServiceGrpc.newStub(channel);

    CountDownLatch latch = new CountDownLatch(1);

    System.out.println("Client sending subscription request...");
    SubscriptionRequest request = SubscriptionRequest.newBuilder()
        .setUserId("user123")
        .build();

    asyncStub.subscribeToNotifications(request, new StreamObserver<Notification>() {
      @Override
      public void onNext(Notification notification) {
        System.out.println("Client received notification: " + notification.getMessage());
      }

      @Override
      public void onError(Throwable t) {
        System.err.println("Client received error: " + t.getMessage());
        latch.countDown();
      }

      @Override
      public void onCompleted() {
        System.out.println("Client stream completed.");
        latch.countDown();
      }
    });

    latch.await(5, TimeUnit.SECONDS); // Wait for stream to complete
    System.out.println("Client finished.");

    channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
  }
}

Stream Method Check

You're building a gRPC service where a client requests a list of recent log entries, and the server continuously sends new entries as they occur. Which Protobuf definition correctly sets up the GetLogStream method for this?

Streaming Recap

Great job! In this lesson, you've learned about server-side streaming in gRPC.

It allows a server to send multiple responses for a single client request.
It's defined using the stream keyword on the response type in Protobuf.
You implemented both server and client logic to handle these continuous data flows.

Next, we'll explore client-side streaming, where the client sends multiple requests!

Questions Fréquemment Posées

La leçon « Le flux serveur expliqué » est-elle gratuite ?

Oui — le texte complet de « Le flux serveur expliqué » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours gRPC & High Performance APIs, passe à CoddyKit PRO. Le cours gRPC & High Performance APIs comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Le flux serveur expliqué » ?

Comprenez et mettez en œuvre le flux côté serveur, dans lequel un serveur envoie plusieurs réponses à une seule demande du client. Tu pratiques gRPC & High Performance APIs avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer gRPC & High Performance APIs ?

Aucune expérience préalable n'est requise. gRPC & High Performance APIs sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Le flux serveur expliqué » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon gRPC & High Performance APIs ?

Oui. Chaque leçon gRPC & High Performance APIs inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Le flux serveur expliqué
Le flux client expliqué
Flux bidirectionnel
Contrôle du flux et rétropression des flux

← Retour à gRPC & High Performance APIs