gRPC en API's met hoge prestaties · Les

Eenvoudige unaray gRPC-service

Implementeer vanaf nul een eenvoudige gRPC-service en -client met een request-responsepatroon en gegenereerde code.

Les 3 van 411 stappen

Eenvoudige unaray gRPC-service is een gratis gRPC en API's met hoge prestaties-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject gRPC en API's met hoge prestaties. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus gRPC en API's met hoge prestaties bevat in totaal 4 lessen.

Uniaire RPC: eenvoudige interacties

In gRPC is een uniaire RPC het eenvoudigste communicatiepatroon. Het lijkt op een traditionele functieaanroep waarbij een client één verzoek naar de server stuurt en de server één antwoord terugstuurt.

U kunt het zien als een standaardmodel van 'verzoek en antwoord'. De client wacht op het antwoord van de server voordat deze verdergaat.

De client stuurt één bericht.
De server stuurt één bericht terug.
Dit is het meest voorkomende RPC-type.

Onze Protobuf bekijken

Voordat we met de implementatie beginnen, halen we kort onze eenvoudige Protocol Buffer-definitie (Protobuf) terug. Dit schema definieert de service en berichten die we gebruiken.

We implementeren de Greeter-service met een SayHello-methode.

syntax = "proto3";

option java_multiple_files = true;
option java_package = "com.example.grpc.helloworld";
option java_outer_classname = "HelloWorldProto";

package helloworld;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

(Houd er rekening mee dat codegeneratie in een vorige les is behandeld.)

Server: de basisklasse uitbreiden

Na het genereren van code vanuit ons .proto-bestand maakt gRPC een abstracte basisklasse voor onze server. Voor onze Greeter-service is dat GreeterGrpc.GreeterImplBase.

Om onze service te implementeren, maken we een nieuwe klasse die deze basisklasse uitbreidt en de servicemethode(n) overschrijft.

class GreeterImpl extends GreeterGrpc.GreeterImplBase {
    @Override
    public void sayHello(HelloRequest req,
                         StreamObserver<HelloReply> resObserver) {
        // ... implementation goes here ...
    }
}

Met StreamObserver sturen we het antwoord terug.

Serverlogica: antwoord opbouwen

In de sayHello-methode ontvangen we de HelloRequest. Vervolgens kunnen we deze verwerken en onze HelloReply opbouwen.

De methode StreamObserver.onNext() stuurt het antwoord, en onCompleted() geeft aan dat de RPC is voltooid.

class GreeterImpl extends GreeterGrpc.GreeterImplBase {
    @Override
    public void sayHello(HelloRequest req,
                         StreamObserver<HelloReply> resObserver) {
        System.out.println("Received name: " + req.getName());
        HelloReply reply = HelloReply.newBuilder()
                                   .setMessage("Hello " + req.getName())
                                   .build();
        resObserver.onNext(reply);     // Send the response
        resObserver.onCompleted();  // Mark RPC as complete
    }
}

Volledige serverimplementatie

Nu voegen we alles samen om een gRPC-server te maken en te starten. Deze server luistert op een specifieke poort naar binnenkomende clientverzoeken.

Probeer deze code uit te voeren en ga daarna verder met de clientimplementatie!

package com.example.grpc.helloworld;

import io.grpc.Server;
import io.grpc.ServerBuilder;
import io.grpc.stub.StreamObserver;

import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class HelloWorldServer {
    private Server server;

    private void start() throws IOException {
        int port = 50051;
        server = ServerBuilder.forPort(port)
                .addService(new GreeterImpl())
                .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");
                try {
                    HelloWorldServer.this.stop();
                } catch (InterruptedException e) {
                    e.printStackTrace(System.err);
                }
                System.err.println("*** server shut down");
            }
        });
    }

    private void stop() throws InterruptedException {
        if (server != null) {
            server.shutdown().awaitTermination(30, TimeUnit.SECONDS);
        }
    }

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

    public static void main(String[] args) throws IOException, InterruptedException {
        final HelloWorldServer server = new HelloWorldServer();
        server.start();
        server.blockUntilShutdown();
    }

    static class GreeterImpl extends GreeterGrpc.GreeterImplBase {
        @Override
        public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
            System.out.println("Received: " + req.getName());
            HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
            responseObserver.onNext(reply);
            responseObserver.onCompleted();
        }
    }
}

Clientstub: verbinden en aanroepen

Aan de clientzijde genereert gRPC ook 'stubs'. Deze stubs bieden de methoden om de externe service aan te roepen, waardoor het aanvoelt als een lokale methodeaanroep.

Voor uniaire RPC's gebruiken we vaak een blokkerende stub, wat betekent dat de client wacht op het antwoord van de server.

// Blocking stub for our Greeter service
GreeterGrpc.GreeterBlockingStub blockingStub;

De stub verwerkt alle onderliggende details van de netwerkcommunicatie voor u!

Clientkanaal: de verbinding

Voordat de client een stub kan gebruiken, heeft deze een kanaal nodig. Een kanaal vertegenwoordigt een verbinding met een gRPC-server op een specifieke host en poort.

Kanalen hebben doorgaans een lange levensduur en kunnen voor meerdere RPC-aanroepen worden hergebruikt.

ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 50051)
                                            .usePlaintext() // No TLS for simplicity
                                            .build();
blockingStub = GreeterGrpc.newBlockingStub(channel);

usePlaintext() is geschikt voor lokale ontwikkeling, maar vermijd deze methode in productie!

Volledige clientimplementatie

Nu het kanaal en de stub klaar zijn, kunnen we onze uniaire RPC-aanroep uitvoeren. We bouwen een HelloRequest en sturen deze via de stub.

Voer de server uit de vorige stap uit en voer daarna deze client uit om het geheel in actie te zien!

package com.example.grpc.helloworld;

import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import io.grpc.StatusRuntimeException;

import java.util.concurrent.TimeUnit;

public class HelloWorldClient {
    private final ManagedChannel channel;
    private final GreeterGrpc.GreeterBlockingStub blockingStub;

    public HelloWorldClient(String host, int port) {
        channel = ManagedChannelBuilder.forAddress(host, port)
                .usePlaintext() // For simplicity, no TLS
                .build();
        blockingStub = GreeterGrpc.newBlockingStub(channel);
    }

    public void shutdown() throws InterruptedException {
        channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
    }

    public void greet(String name) {
        System.out.println("Will try to greet " + name + "...");
        HelloRequest request = HelloRequest.newBuilder().setName(name).build();
        HelloReply response;
        try {
            response = blockingStub.sayHello(request);
        } catch (StatusRuntimeException e) {
            System.err.println("RPC failed: " + e.getStatus());
            return;
        }
        System.out.println("Greeting: " + response.getMessage());
    }

    public static void main(String[] args) throws Exception {
        HelloWorldClient client = new HelloWorldClient("localhost", 50051);
        try {
            String user = "CoddyKit User";
            if (args.length > 0) {
                user = args[0];
            }
            client.greet(user);
        } finally {
            client.shutdown();
        }
    }
}

Uniaire stroom: verzoek en antwoord

Wanneer u de client uitvoert, stuurt deze de HelloRequest naar de server. De server ontvangt deze, verwerkt hem met onze GreeterImpl en stuurt een HelloReply terug.

Client: Maakt een kanaal en stub en bouwt een HelloRequest.
Client: Roept blockingStub.sayHello(request) aan.
Server: Ontvangt de HelloRequest in de sayHello-methode.
Server: Verwerkt het verzoek, bouwt een HelloReply en roept onNext() en onCompleted() aan.
Client: Ontvangt de HelloReply en gaat verder met de uitvoering.

Hiermee is één volledige uniaire RPC-cyclus voltooid!

Controle van de uniaire service

Bekijk een uniaire gRPC-service. Welk onderdeel is verantwoordelijk voor het ontvangen en verwerken van een verzoek en het terugsturen van één antwoord?

Beantwoord dit in de interactieve les

Samenvatting: eenvoudige uniaire RPC

Goed gedaan! U hebt geleerd hoe u een eenvoudige uniaire gRPC-service en -client implementeert:

U hebt het Protobuf-schema voor onze service bekeken.
U hebt de serverlogica geïmplementeerd door de gegenereerde basisklasse uit te breiden en verzoeken af te handelen.
U hebt een gRPC-server-instantie gemaakt en gestart.
Aan de clientzijde hebt u een kanaal gebruikt om verbinding te maken en een blokkerende stub om de RPC-aanroep uit te voeren.

Uniaire RPC's vormen de basis van gRPC en bieden een robuuste manier voor eenvoudige communicatie volgens het verzoek-en-antwoordmodel. Vervolgens verkennen we geavanceerdere streamingpatronen!

Gratis beginnen

Leer gRPC en API's met hoge prestaties met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Eenvoudige unaray gRPC-service” gratis?

Ja — de volledige tekst van “Eenvoudige unaray gRPC-service” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus gRPC en API's met hoge prestaties wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus gRPC en API's met hoge prestaties bevat in totaal 4 lessen.

Wat leer ik in “Eenvoudige unaray gRPC-service”?

Implementeer vanaf nul een eenvoudige gRPC-service en -client met een request-responsepatroon en gegenereerde code. Je oefent met gRPC en API's met hoge prestaties door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met gRPC en API's met hoge prestaties te beginnen?

Ervaring vooraf is niet nodig. gRPC en API's met hoge prestaties op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Eenvoudige unaray gRPC-service”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over gRPC en API's met hoge prestaties?

Ja. Elke les over gRPC en API's met hoge prestaties bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

Protobuf-schemadefinitie
gRPC-code genereren
Eenvoudige unaray gRPC-service
Streaming-RPC's: server, client en bidirectioneel

← Terug naar gRPC en API's met hoge prestaties