Serverströmning förklarad
Förstå och implementera serverbaserad strömning, där en server skickar flera svar på en enda klientbegäran.
Serverströmning förklarad är en gratis lektion i gRPC och högpresterande API:er på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för gRPC och högpresterande API:er, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i gRPC och högpresterande API:er innehåller totalt 4 lektioner.
Grunderna i serverstreaming
I gRPC innebär ett server-side streaming-anrop att klienten skickar en enda begäran, medan servern svarar med en sekvens av meddelanden.
Tänk på det som att prenumerera på ett nyhetsbrev: du skickar en begäran (prenumerera) och servern skickar många uppdateringar över tid (nyhetsbrev).
Användningsområden för streaming
Serverstreaming passar perfekt i situationer där servern behöver skicka uppdateringar eller stora mängder data till klienten över tid. Vanliga användningsområden är:
- Dataflöden i realtid: Aktiekurser och sensoravläsningar.
- Aviseringar: Varningar och chattmeddelanden.
- Nedladdning av stora datamängder: Att dela upp en stor fil i mindre delar.
Protobuf för serverstreaming
För att definiera en server-side streaming-metod i din .proto-fil lägger du helt enkelt till nyckelordet stream före typen för svaret.
Detta talar om för gRPC att servern ska skicka flera meddelanden för varje klientbegäran, inte bara ett.
Protobuf-exempel med streaming
Så här definierar du en tjänst som strömmar meddelanden från servern:
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;
}Implementera serverstreamen
På serversidan tar streamingmetoden emot ett enda begärandeobjekt, precis som vid ett unary-anrop. I stället för att returnera ett enda svar använder du dock en StreamObserver för att skicka flera svar tillbaka till klienten.
Vanligtvis loopar du och skickar meddelanden och anropar sedan onCompleted() när du är klar.
Servermetodens struktur
Servermetoden för ett streaminganrop tar emot begäran och en StreamObserver. Ni skickar svar via responseObserver.onNext() och signalerar att anropet är klart med 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);
}Ta emot streamade svar
Klienten gör ett enda anrop, men måste sedan vänta på och behandla flera svar. Den tillhandahåller en StreamObserver för att hantera inkommande meddelanden, fel och klarhetssignalen från servern.
Denna observerare har metoderna onNext(), onError() och onCompleted().
Klientens stream-observerare
Klientens StreamObserver definierar hur den reagerar på varje händelse från serverns stream. Den behandlar varje onNext-meddelande tills onCompleted anropas.
// 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);Fullständig serverstreamtjänst
Här är en komplett gRPC-server som implementerar server-side streaming-metoden SubscribeToNotifications. Kör denna först och därefter klienten!
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);
}
}
}Fullständig klient för streammottagning
Kör nu denna klientkod. Den ansluter till servern och tar emot streamen med aviseringar.
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);
}
}Kontroll av streammetod
Ni bygger en gRPC-tjänst där en klient begär en lista över de senaste loggposterna och servern kontinuerligt skickar nya poster när de uppstår. Vilken Protobuf-definition konfigurerar metoden GetLogStream korrekt?
Sammanfattning av streaming
Bra jobbat! I den här lektionen har ni lärt er om server-side streaming i gRPC.
- Det gör det möjligt för en server att skicka flera svar på en enda klientbegäran.
- Det definieras genom nyckelordet
streampå svarstypen i Protobuf. - Ni har implementerat både server- och klientlogik för att hantera dessa kontinuerliga dataflöden.
Härnäst utforskar vi client-side streaming, där klienten skickar flera begäranden!
Lär dig gRPC och högpresterande API:er med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Serverströmning förklarad” gratis?
Ja – hela texten till ”Serverströmning förklarad” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i gRPC och högpresterande API:er, kan Ni uppgradera till CoddyKit PRO. Kursen i gRPC och högpresterande API:er innehåller totalt 4 lektioner.
Vad lär jag mig i ”Serverströmning förklarad”?
Förstå och implementera serverbaserad strömning, där en server skickar flera svar på en enda klientbegäran. Ni övar på gRPC och högpresterande API:er med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig gRPC och högpresterande API:er?
Du behöver inga förkunskaper. Utbildningen i gRPC och högpresterande API:er på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Serverströmning förklarad”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här gRPC och högpresterande API:er-lektionen?
Ja. Varje gRPC och högpresterande API:er-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Serverströmning förklarad
- Klientströmning förklarad
- Dubbelriktad strömning
- Flödeskontroll och backpressure för streaming