מבוא ל- Vert.x

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

במאמר זה נדון ב- Vert.x, נסקור את מושגי הליבה שלו וניצור איתו שירות אינטרנט פשוט RESTfull.

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

2. אודות Vert.x

Vert.x הוא ערכת כלים לפיתוח תוכנה עם קוד פתוח, ריאקטיבי ומגדל ממפתחי Eclipse.

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

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

אנו קוראים לזה פוליגלוט בזכות תמיכתו במספר שפות JVM ולא JVM כמו Java, Groovy, Ruby, Python ו- JavaScript.

3. התקנה

כדי להשתמש ב- Vert.x עלינו להוסיף את התלות של Maven:

 io.vertx vertx-core 3.4.1 

הגרסה האחרונה של התלות נמצאת כאן.

3. ורטיקלים

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

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

כדי ליצור קודקוד ב- JAVA, המחלקה חייבת ליישם io.vertx.core.Verticle ממשק, או כל אחד מתתי קבוצות המשנה שלו.

4. אוטובוס אירועים

זוהי מערכת העצבים של כל יישום Vert.x.

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

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

5. יישום Vert.x פשוט

בואו ליצור יישום פשוט עם קודקוד ונפרוס אותו באמצעות vertx למשל. כדי ליצור את קודקודנו, נאריך את ה-

כדי ליצור את קודקודנו, נאריך את ה- io.vertx.core.AbstractVerticle בכיתה ולדרוס את הַתחָלָה() שיטה:

המעמד הציבורי HelloVerticle מרחיב את AbstractVerticle {@Override public void start (Future Future) {LOGGER.info ("ברוך הבא ל- Vertx"); }}

ה הַתחָלָה() השיטה תופעל על ידי vertx למשל כאשר קודקוד נפרס. השיטה נוקטת io.vertx.core.Future כפרמטר, שניתן להשתמש בו כדי לגלות את המצב של פריסה אסינכרונית של קודקוד.

עכשיו בואו נפרוס את הקודקוד:

חלל סטטי ציבורי ראשי (String [] args) {Vertx vertx = Vertx.vertx (); vertx.deployVerticle (HelloVerticle חדש ()); }

באופן דומה, אנו יכולים לעקוף את תפסיק() שיטה מה- תקציר פורטיקול class, שיופעל בזמן כיבוי קודקוד:

@ ביטול עצירה בטלנית ציבורית () {LOGGER.info ("כיבוי יישום"); }

6. שרת HTTP

עכשיו בואו נסובב שרת HTTP באמצעות קודקוד:

@ התחל החלל בטל ציבורי (עתיד עתידי) {vertx.createHttpServer () .requestHandler (r -> r.response (). End ("ברוך הבא ל- Vert.x Intro");}). Listenen (config (). GetInteger ( "http.port", 9090), תוצאה -> {if (result.succeeded ()) {future.complete ();} אחר {future.fail (result.cause ());}}); }

עקפנו את הַתחָלָה() שיטה ליצור שרת HTTP וצירף אליו מטפל בקשות. ה requestHandler () השיטה נקראת בכל פעם שהשרת מקבל בקשה.

לבסוף, השרת מחויב ליציאה, ו- AsyncResult המטפל מועבר ל להקשיב() שיטה אם החיבור או אתחול השרת מוצלחים באמצעות future.complete () אוֹ future.fail () במקרה של שגיאות כלשהן.

ציין זאת: config.getInteger () שיטה, הוא קריאת הערך עבור תצורת יציאת HTTP אשר נטען מחיצוני conf.json קוֹבֶץ.

בואו לבדוק את השרת שלנו:

@ מבחן ציבורי בטל כאשר קיבלו תגובה_סוף הצלחה (TestContext testContext) {Async async = testContext.async (); vertx.createHttpClient () .getNow (יציאה, "localhost", "/", תגובה -> {respons.handler (responsBody -> {testContext.assertTrue (responseBody.toString (). מכיל ("שלום")); סינכרון. השלם ();});}); }

לצורך הבדיקה, נשתמש ביחידת vertx יחד עם JUnit .:

 מבחן io.vertx vertx-unit 3.4.1 

אנחנו יכולים לקבל את הגרסה האחרונה כאן.

קודקוד הפרוס נמצא בתוך vertx למשל ב להכין() שיטת מבחן היחידה:

@ לפני התקנת החלל הציבורי (TestContext testContext) {vertx = Vertx.vertx (); vertx.deployVerticle (SimpleServerVerticle.class.getName (), testContext.asyncAssertSuccess ()); }

באופן דומה, ה vertx מופע סגור ב @ AfterClass tearDown () שיטה:

@ לאחר ביטול הריק הציבורי (TestContext testContext) {vertx.close (testContext.asyncAssertSuccess ()); }

שימו לב שה- התקנת @BeforeClass () שיטה לוקח TestContext טַעֲנָה. זה עוזר לשליטה ובדיקה של ההתנהגות האסינכרונית של הבדיקה. לדוגמה, פריסת הקודקוד היא אסינכרונית, כך שבעצם איננו יכולים לבדוק שום דבר אלא אם כן הוא נפרס כהלכה.

יש לנו פרמטר שני ל- deployVerticle () שיטה, testContext.asyncAssertSuccess (). טשלו משמש כדי לדעת אם השרת פרוס כהלכה או שאירעו תקלות כלשהן. זה מחכה ל future.complete () או future.fail () בקודקוד השרת שייקרא. במקרה של כישלון, הוא נכשל במבחן.

7. RESTful WebService

יצרנו שרת HTTP, מאפשר כעת להשתמש בו לארח RESTfull WebService. על מנת לעשות זאת נצטרך עוד מודול Vert.x שנקרא vertx-web. זה נותן הרבה תכונות נוספות לפיתוח אתרים בנוסף vertx-core.

בואו נוסיף את התלות שלנו pom.xml:

 io.vertx vertx-web 3.4.1 

אנו יכולים למצוא את הגרסה האחרונה כאן.

7.1. נתב ו מסלולים

בואו ניצור נתב עבור שירות ה- WebService שלנו. נתב זה ייקח מסלול פשוט של שיטת GET ושיטת המטפל getArtilces ():

נתב נתב = Router.router (vertx); router.get ("/ api / baeldung / articles / article /: id") .handler (זה :: getArticles);

ה getArticle () שיטה היא שיטה פשוטה שמחזירה חדשה מאמר לְהִתְנַגֵד:

חלל פרטי getArticles (RoutingContext routingContext) {Article String = routingContext.request () .getParam ("id"); מאמר מאמר = מאמר חדש (ArticleId, "זהו מבוא ל- vertx", "baeldung", "01-02-2017", 1578); routingContext.response () .putHeader ("סוג תוכן", "application / json") .setStatusCode (200). end (Json.encodePrettily (מאמר)); }

א נתב, כאשר מקבל בקשה, מחפש את המסלול התואם ומעביר את הבקשה הלאה. ה מסלולים שיש שיטה מטפלת המשויכת אליו לעשות סיכום עם הבקשה.

במקרה שלנו, המטפל קורא ל getArticle () שיטה. זה מקבל את routingContext חפץ כוויכוח. נגזר את פרמטר הנתיב תְעוּדַת זֶהוּת, ויוצר an מאמר להתנגד עם זה.

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

7.2. מוֹסִיף נתב לשרת

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

vertx.createHttpServer () .requestHandler (router :: accept) .listen (config (). getInteger ("http.port", 8080), result -> {if (result.succeeded ()) {future.complete (); } אחר {future.fail (result.cause ());}});

שימו לב שהוספנו requestHandler (נתב :: קבל) לשרת. זה מורה לשרת להפעיל את ה- לְקַבֵּל() של ה נתב להתנגד כאשר כל בקשה מתקבלת.

עכשיו בואו לבדוק את ה- WebService שלנו:

@ מבחן חלל ציבורי givenId_whenReceivedArticle_thenSuccess (TestContext testContext) {Async async = testContext.async (); vertx.createHttpClient () .getNow (8080, "localhost", "/ api / baeldung / articles / article / 12345", תגובה -> {respons.handler (responseBody -> {testContext.assertTrue (responseBody.toString (). מכיל ("\" id \ ": \" 12345 \ "")); async.complete ();});}); }

8. אריזת Vert.x יישום

כדי לארוז את היישום כארכיון Java שניתן לפרוס (.jar) נשתמש בתוסף Maven Shade והתצורות ב- ביצוע תָג:

    io.vertx.core.Starter com.baeldung.SimpleServerVerticle $ {project.build.directory} / $ {project.artifactId} - $ {project.version} -app.jar 

בתוך ה כניסות מניפסט, ראשי- Verticle מציין את נקודת ההתחלה של היישום ואת מעמד ראשי הוא מחלקה Vert.x אשר יוצר את vertx מופע ופורס את ראשי- Verticle.

9. מסקנה

במאמר מבוא זה דנו בערכת הכלים Vert.x ובתפיסות היסוד שלה. ראה כיצד ליצור שרת HTTP, עם Vert.x וגם RESTFull WebService והראה כיצד לבדוק אותם באמצעות vertx-unit.

לבסוף ארז את היישום כצנצנת הפעלה.

היישום המלא של קטעי הקוד זמין ב- GitHub.