streamalism.org

1. הקדמה

gRPC היא מסגרת RPC בעלת קוד ביצועים גבוהים שפותחה לראשונה על ידי גוגל. זה עוזר בביטול קוד boilerplate ועוזר בחיבור שירותי פוליגלוט במרכזי נתונים ומעבר להם.

2. סקירה כללית

המסגרת מבוססת על מודל שרת לקוח של שיחות פרוצדורות מרחוק. יישום לקוח יכול להתקשר ישירות לשיטות ביישום שרת כאילו מדובר באובייקט מקומי.

מאמר זה ישתמש בצעדים הבאים ליצירת יישום שרת לקוח טיפוסי באמצעות gRPC:

1. הגדר שירות ב- .proto קוֹבֶץ
2. צור קוד שרת ולקוח באמצעות מהדר מאגר הפרוטוקולים
3. צור את יישום השרת, יישם את ממשקי השירות שנוצרו והשרצה את שרת ה- gRPC
4. צור את יישום הלקוח, תוך ביצוע שיחות RPC באמצעות תלויים שנוצרו

בואו נגדיר פשוט HelloService שמחזיר ברכות בתמורה לשם הפרטי ושם המשפחה.

3. תלות Maven

בואו נוסיף תלות ב- grpc-netty, grpc-protobuf ו- grpc-stub:

 io.grpc grpc-netty 1.16.1 io.grpc grpc-protobuf 1.16.1 io.grpc grpc-stub 1.16.1 

4. הגדרת השירות

אנו מתחילים בהגדרת שירות, ציון שיטות שניתן לקרוא להן מרחוק יחד עם הפרמטרים וסוגי ההחזר שלהם.

זה נעשה ב .proto קובץ באמצעות מאגרי הפרוטוקול. הם משמשים גם לתיאור מבנה הודעות המטען.

4.1. תצורות בסיסיות

תן לנו ליצור a HelloService.proto קובץ לדוגמא שלנו HelloService. אנו מתחילים להוסיף מעט פרטי תצורה בסיסיים:

תחביר = "פרוטו 3"; אפשרות java_multiple_files = true; חבילה org.baeldung.grpc;

השורה הראשונה מספרת למהדר באיזה תחביר משתמשים בקובץ זה. כברירת מחדל, המהדר מייצר את כל קוד Java בקובץ Java יחיד. השורה השנייה עוקפת הגדרה זו, והכל ייווצר בקבצים בודדים.

לבסוף, אנו מציינים את החבילה בה אנו רוצים להשתמש עבור שיעורי Java שנוצרו.

4.2. הגדרת מבנה המסר

לאחר מכן, אנו מגדירים את המסר:

הודעה HelloRequest {string firstName = 1; מחרוזת lastName = 2; }

זה מגדיר את מטען הבקשה. כאן כל תכונה שנכנסת למסר מוגדרת יחד עם הסוג שלה.

יש להקצות מספר ייחודי לכל מאפיין, שנקרא כתג. תג זה משמש מאגר הפרוטוקולים לייצוג התכונה במקום להשתמש בשם התכונה.

לכן, בניגוד ל- JSON שם נעביר את שם התכונה שם פרטי בכל פעם, חיץ פרוטוקול ישתמש במספר 1 כדי לייצג שם פרטי. הגדרת מטען התגובה דומה לבקשה.

שים לב שאנו יכולים להשתמש באותו תג במספר סוגי הודעות:

הודעה HelloResponse {ברכת מחרוזת = 1; }

4.3. הגדרת חוזה השירות

לסיום, בואו נגדיר את חוזה השירות. בשביל שלנו HelloService אנו מגדירים א שלום() מבצע:

שירות HelloService {rpc שלום (HelloRequest) מחזיר (HelloResponse); }

ה שלום() הפעולה מקבלת בקשה יונירית ומחזירה תגובה יונירית. gRPC תומך גם בסטרימינג באמצעות קידומת זרם מילת מפתח לבקשה ולתגובה.

5. יצירת הקוד

עכשיו אנחנו עוברים את HelloService.proto הקובץ למהדר חיץ הפרוטוקול פרוטוק כדי ליצור קבצי Java. ישנן מספר דרכים להפעיל את זה.

5.1. באמצעות מהדר מאגר פרוטוקולים

ראשית, אנו צריכים את מהדר המאגר פרוטוקולים. אנו יכולים לבחור מתוך בינאריות רבות שהורכבו מראש.

בנוסף, עלינו להשיג את תוסף ה- gRPC Java Codegen.

לבסוף, אנו יכולים להשתמש בפקודה הבאה כדי ליצור את הקוד:

protoc - plugin = protoc-gen-grpc-java = $ PATH_TO_PLUGIN -I = $ SRC_DIR --java_out = $ DST_DIR --grpc-java_out = $ DST_DIR $ SRC_DIR / HelloService.proto

5.2. באמצעות תוסף Maven

כמפתח, היית רוצה שייצור הקוד ישולב היטב במערכת הבניין שלך. gRPC מספק א תוסף protobuf-maven עבור מערכת הבנייה של Maven:

   kr.motd.maven os-maven-plugin 1.6.1 org.xolstice.maven.plugins protobuf-maven-plugin 0.6.1 com.google.protobuf: protoc: 3.3.0: exe: $ {os.detected.classifier} grpc-java io.grpc: protoc-gen-grpc-java: 1.4.0: exe: $ {os.detected.classifier} הידור הידור-מותאם אישית 

התוסף / תוסף os-maven-plugin מייצר מאפייני פרויקט שימושיים שונים התלויים בפלטפורמה כמו $ {os.detected.classifier}

6. יצירת השרת

לא משנה באיזו שיטה אתה משתמש לייצור קוד, ייווצרו קבצי המפתח הבאים:

• HelloRequest.java - מכיל את שלום בקשה הגדרת סוג
• HelloResponse.java – זה מכיל את HelleResponse הגדרת סוג
• HelloServiceImplBase.java – זה מכיל את המעמד המופשט HelloServiceImplBase המספק יישום של כל הפעולות שהגדרנו בממשק השירות

6.1. עקיפת מחלקת בסיס השירות

ה יישום ברירת המחדל של הכיתה המופשטת HelloServiceImplBase זה לזרוק חריגה של זמן ריצהio.grpc.StatusRuntimeException אומר שהשיטה לא מיושמת.

אנו נרחיב את המעמד הזה ונעקוף את ה שלום() השיטה המוזכרת בהגדרת השירות שלנו:

מחלקה ציבורית HelloServiceImpl מרחיב את HelloServiceImplBase {@Override public void hello (HelloRequest request, StreamObserver responseObserver) {String greeting = new StringBuilder () .append ("Hello,") .append (request.getFirstName ()) .append (""). נספח (request.getLastName ()) .toString (); HelloResponse response = HelloResponse.newBuilder () .setGreeting (greeting) .build (); responseObserver.onNext (תגובה); responseObserver.onCompleted (); }}

אם נשווה את החתימה של שלום() עם זה שכתבנו ב- HellService.proto קובץ, נבחין שהוא לא חוזר שלום תגובה. במקום זאת, נדרש הטיעון השני כ- StreamObserver, שהוא צופה בתגובה, שיחה חזרה לשרת להתקשר עם תגובתו.

בדרך זו הלקוח מקבל אפשרות לבצע שיחה חוסמת או שיחה לא חוסמת.

gRPC משתמש בבונים ליצירת אובייקטים. אנו משתמשים HelloResponse.newBuilder () והגדר את טקסט הברכה לבניית א שלום תגובה לְהִתְנַגֵד. הגדרנו אובייקט זה ל- responseObserver בהבא() שיטה לשלוח אותו ללקוח.

לבסוף, אנחנו צריכים להתקשר onCompleted () כדי לציין שסיימנו להתמודד עם RPC, אחרת החיבור יתלה, והלקוח פשוט ימתין שייכנס מידע נוסף.

6.2. הפעלת שרת ה- Grpc

לאחר מכן, עלינו להפעיל את שרת ה- gRPC כדי להאזין לבקשות נכנסות:

מחלקה ציבורית GrpcServer {main public static void (String [] args) {Server server = ServerBuilder .forPort (8080) .addService (HelloServiceImpl new ()). build (); server.start (); server.awaitTermination (); }}

הנה, שוב אנו משתמשים בבונה כדי ליצור שרת gRPC ביציאה 8080 ולהוסיף את HelloServiceImpl שירות שהגדרנו. הַתחָלָה() היה מפעיל את השרת. בדוגמה שלנו, אנחנו נתקשר awaitTermination () כדי לשמור על השרת פועל בחזית וחוסם את ההנחיה.

7. יצירת הלקוח

gRPC מספק מבנה ערוצים הממצה את הפרטים הבסיסיים כמו חיבור, איגום חיבורים, איזון עומסים וכו '.

ניצור ערוץ באמצעות ManagedChannelBuilder. כאן אנו מציינים את כתובת השרת ואת היציאה.

נשתמש בטקסט רגיל ללא כל הצפנה:

מחלקה ציבורית GrpcClient {main static public void main (String [] args) {ManagedChannel channel = ManagedChannelBuilder.forAddress ("localhost", 8080) .usePlaintext () .build (); HelloServiceGrpc.HelloServiceBlockingStub stub = HelloServiceGrpc.newBlockingStub (ערוץ); HelloResponse helloResponse = stub.hello (HelloRequest.newBuilder () .setFirstName ("Baeldung") .setLastName ("gRPC") .build ()); channel.shutdown (); }}

לאחר מכן, עלינו ליצור תקע בו נשתמש כדי להתקשר אליו בפועל שלום(). הסטאב הוא הדרך העיקרית של לקוחות לקיים אינטראקציה עם השרת. כשמשתמשים בתלים שנוצרו אוטומטית, בכיתת הבדים יהיו קונסטרוקציות לעטיפת הערוץ.

כאן אנו משתמשים בדל חסימה / סינכרוני כך ששיחת RPC תמתין לשרת להגיב, או שתחזיר תגובה או תעלה חריג. ישנם שני סוגים אחרים של גבעולים המסופקים על ידי gRPC, המאפשרים שיחות לא חוסמות / אסינכרוניות.

לבסוף, הזמן להכין את שלום() שיחת RPC. כאן אנו עוברים את שלום בקשה. אנו יכולים להשתמש בקובעים שנוצרו אוטומטית כדי להגדיר את ה- שם פרטי, שם משפחה תכונות של שלום בקשה לְהִתְנַגֵד.

אנו מחזירים את שלום תגובה אובייקט שהוחזר מהשרת.

8. מסקנה

במדריך זה ראינו כיצד נוכל להשתמש ב- gRPC כדי להקל על פיתוח התקשורת בין שני שירותים על ידי התמקדות בהגדרת השירות ומאפשר ל- gRPC לטפל בכל קוד הדף.

כרגיל, תוכלו למצוא את המקורות ב- GitHub.