Generera gRPC-kod

Välkommen tillbaka! I den förra lektionen lärde vi oss att definiera datastrukturer och tjänster med Protocol Buffers (Protobuf).

Men hur använder vi egentligen dessa definitioner i vårt favoritprogrammeringsspråk? Det är där kodgenerering kommer in!

Det är processen att automatiskt skapa källkod från ett schema, så att du slipper skriva upprepad standardkod.

gRPC är starkt beroende av genererad kod, som ofta kallas stubs eller proxies. Dessa stubs fungerar som en bro mellan programmets logik och de underliggande kommunikationsmekanismerna i gRPC.

• Klientstubs: Tillhandahåller metoder som motsvarar tjänsten som definieras i din .proto-fil. När du anropar en metod i en klientstub paketerar den data, skickar den över nätverket och packar upp svaret.
• Serverstubs: Definierar ett gränssnitt som din serverimplementation måste uppfylla. Den hanterar mottagandet av begäranden, skickar dem vidare till din kod och returnerar svar.

Magin bakom genereringen av dessa stubs är Protobuf Compiler, som vanligtvis kallas protoc.

protoc är ett kommandoradsverktyg som läser dina .proto-filer och genererar källkod på olika språk, baserat på de plugins du anger.

Det är en viktig komponent i alla gRPC-projekt, eftersom det säkerställer stark typning och konsekventa kommunikationsgränssnitt mellan olika tjänster och språk.

Den allmänna syntaxen för att använda protoc ser ut ungefär så här:

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

• --<LANG>_out=.: Den här flaggan anger att protoc ska generera Protobuf-meddelandeklasser för ett specifikt språk (till exempel --java_out, --python_out) och var de ska placeras (. för den aktuella katalogen).
• --grpc_out=.: Den här flaggan, som ofta används tillsammans med ett gRPC-specifikt plugin, genererar gRPC-tjänstens gränssnitt och stubklasser.
• my_service.proto: Sökvägen till din Protobuf-definitionsfil.

Innan du kan generera kod måste du installera protoc. Installationsprocessen varierar beroende på operativsystem:

• Ladda ned binärfil: Du kan ladda ned förkompilerade binärfiler från den officiella sidan för Protobuf-utgåvor på GitHub.
• Pakethanterare: På Linux kan du använda apt-get install protobuf-compiler. På macOS använder du brew install protobuf.
• Bygg från källkod: Avancerade användare kan kompilera det från källkoden.

Se alltid till att protoc finns i systemets PATH.

Vi använder en enkel greet.proto-fil för att demonstrera kodgenerering. Den här filen definierar tjänsten Greeter och dess meddelanden:

syntax = "proto3";

package greeter;

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Det här är indata till vår protoc-kompilator.

För att generera Java-kod från vår greet.proto använder vi vanligtvis ett kommando som detta:

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

Här anger --plugin uttryckligen för protoc var gRPC Java-pluginet finns, vilket krävs för att generera gRPC-tjänstens gränssnitt.

När du har kört protoc hittar du nya Java-filer i den angivna utdatakatalogen. För vårt greet.proto-exempel ser du vanligtvis:

• GreeterGrpc.java: Innehåller den abstrakta tjänsten GreeterImplBase och klientens stubklasser (till exempel GreeterBlockingStub och GreeterFutureStub).
• Greet.java: En behållarklass som innehåller de genererade Protobuf-meddelandeklasserna, till exempel HelloRequest och HelloReply, tillsammans med deras builders och accessors.

De här filerna hanterar all information om serialisering, deserialisering och nätverkskommunikation.

Det är viktigt att förstå att protoc i sig bara genererar de grundläggande Protobuf-meddelandeklasserna.

För att generera de gRPC-specifika tjänstegränssnitten och stubbarna använder det plugins. För Java behöver du till exempel pluginet protoc-gen-grpc-java.

Varje språk som stöds av gRPC (Python, Go, C++, Node.js med flera) har ett eget specifikt plugin som integreras med protoc för att skapa den gRPC-kod som behövs.

Bra jobbat! Du har lärt dig den grundläggande processen för att generera gRPC-kod:

• Du har förstått varför stubbar är viktiga för gRPC-kommunikation.
• Du har bekantat dig med protoc-kompilatorn, verktyget som utför kodgenereringen.
• Du har sett hur plugins utökar protoc för att generera språkspecifik gRPC-kod.
• Du har gått igenom ett exempel på hur Java-kod genereras från en .proto-definition.

Nästa steg är att använda den genererade koden för att implementera en enkel unary gRPC-tjänst och klient!