Generere gRPC-kode

Velkommen tilbake! I forrige leksjon lærte vi hvordan vi definerer datastrukturer og tjenester ved hjelp av Protocol Buffers (Protobuf).

Men hvordan bruker vi egentlig disse definisjonene i programmeringsspråket vi foretrekker? Det er her kodegenerering kommer inn!

Det er prosessen med å opprette kildekode automatisk fra et skjema, slik at du slipper å skrive gjentakende standardkode.

gRPC er i stor grad avhengig av generert kode, ofte kalt stubber eller proxyer. Disse stubene fungerer som en bro mellom programlogikken din og de underliggende mekanismene for gRPC-kommunikasjon.

• Klientstubber: Tilbyr metoder som gjenspeiler tjenesten som er definert i .proto-filen. Når du kaller en metode på en klientstub, pakker den inn dataene, sender dem over nettverket og pakker ut svaret.
• Serverstubber: Definerer et grensesnitt som serverimplementasjonen din må oppfylle. Den håndterer mottak av forespørsler, videresender dem til koden din og sender svar tilbake.

Magien bak genereringen av disse stubbene er Protobuf Compiler, vanligvis kalt protoc.

protoc er et kommandolinjeverktøy som leser .proto-filene dine og genererer kildekode i ulike språk, basert på programtilleggene du angir.

Det er en avgjørende komponent i alle gRPC-prosjekter, siden det sikrer sterk typing og konsistente kommunikasjonsgrensesnitt på tvers av ulike tjenester og språk.

Den generelle syntaksen for bruk av protoc ser omtrent slik ut:

protoc --<LANG>_out=. --grpc_out=. my_service.proto

• --<LANG>_out=.: Dette flagget forteller protoc at det skal generere Protobuf-meldingsklasser for et bestemt språk (for eksempel --java_out eller --python_out), og hvor de skal plasseres (. betyr gjeldende katalog).
• --grpc_out=.: Dette flagget, som ofte brukes sammen med et gRPC-spesifikt programtillegg, genererer gRPC-tjenestegrensesnittet og stubklassene.
• my_service.proto: Banen til Protobuf-definisjonsfilen din.

Før du kan generere kode, må du installere protoc. Installasjonsprosessen varierer mellom operativsystemer:

• Last ned binærfil: Du kan laste ned forhåndskompilerte binærfiler fra den offisielle siden for Protobuf-utgivelser på GitHub.
• Pakkeadministratorer: På Linux kan du bruke apt-get install protobuf-compiler. På macOS kan du bruke brew install protobuf.
• Bygg fra kildekode: Avanserte brukere kan kompilere det fra kildekoden.

Kontroller alltid at protoc finnes i systemets PATH.

La oss bruke en enkel greet.proto-fil for å demonstrere kodegenerering. Denne filen definerer en Greeter-tjeneste og meldingene den bruker:

syntax = "proto3";

package greeter;

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Dette er inndataene til protoc-kompilatoren vår.

For å generere Java-kode fra greet.proto bruker vi vanligvis en kommando som denne:

protoc \
  --plugin=protoc-gen-grpc-java=/path/to/grpc-java-plugin \
  --java_out=. \
  --grpc_out=. \
  greet.proto

Her forteller --plugin eksplisitt protoc hvor gRPC Java-programtillegget finnes. Dette er nødvendig for å generere gRPC-tjenestegrensesnittene.

Etter at du har kjørt protoc, finner du nye Java-filer i den angitte utdatakatalogen. For eksempelet med greet.proto vil du vanligvis se:

• GreeterGrpc.java: Inneholder den abstrakte GreeterImplBase-tjenesten og klientstubklassene (for eksempel GreeterBlockingStub og GreeterFutureStub).
• Greet.java: En beholderklasse som inneholder de genererte Protobuf-meldingsklassene, for eksempel HelloRequest og HelloReply, samt builderne og tilgangsmetodene deres.

Disse filene håndterer all serialisering, deserialisering og nettverkskommunikasjon.

Det er viktig å forstå at protoc i seg selv bare genererer de grunnleggende Protobuf-meldingsklassene.

For å generere gRPC-spesifikke tjenestegrensesnitt og stubber bruker den programtillegg. For Java trenger du for eksempel programtillegget protoc-gen-grpc-java.

Hvert språk som støttes av gRPC (Python, Go, C++, Node.js og så videre) har sitt eget programtillegg, som integreres med protoc for å produsere den nødvendige gRPC-koden.

Godt jobbet! Du har lært den grunnleggende prosessen for å generere gRPC-kode:

• Vi har forstått hvorfor stubber er avgjørende for gRPC-kommunikasjon.
• Vi har blitt kjent med protoc-kompilatoren, verktøyet som utfører kodegenereringen.
• Vi har sett hvordan programtillegg utvider protoc slik at det kan generere språkspesifikk gRPC-kode.
• Vi har gått gjennom et eksempel på å generere Java-kode fra en .proto-definisjon.

Deretter skal vi bruke den genererte koden til å implementere en enkel unary gRPC-tjeneste og klient!