streamalism.org

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

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

במאמר זה נלמד כיצד להשתמש ב- Ratpack ונבנה באמצעותו אפליקציה קטנה.

2. מדוע Ratpack?

היתרונות העיקריים של Ratpack:

• זה קל מאוד, מהיר וניתן להרחבה
• הוא צורך פחות זיכרון ממסגרות אחרות כגון DropWizard; ניתן למצוא כאן תוצאה מעניינת של השוואת ביצועים
• מכיוון שהוא בנוי על גבי נטי, Ratpack הוא לגמרי מונע אירועים ואינו חוסם אופי
• יש לו תמיכה ב רעיון ניהול תלות
• יותר כמו אביב מַגָף, ל- Ratpack ספריות בדיקה משלה להגדרת מקרי בדיקה במהירות

3. יצירת יישום

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

3.1. תלות Maven

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

 io.ratpack ratpack-core 1.4.5 io.ratpack ratpack-test 1.4.5 

אתה יכול לבדוק את הגרסה האחרונה ב- Maven Central.

שים לב שלמרות שאנו משתמשים ב- Maven כמערכת הבנייה שלנו, בהתאם להמלצת Ratpack, עדיף להשתמש בה Gradle ככלי לבנות מכיוון של- Ratpack יש תמיכה מהדרגה הראשונה של Gradle באמצעות תוסף Gradle של Ratpack.

אנו יכולים להשתמש בסקריפט ה- Gradle הבא:

buildscript {repositories {jcenter ()} תלות {classpath "io.ratpack: ratpack-gradle: 1.4.5"}} החל תוסף: "io.ratpack.ratpack-java" מאגרים {jcenter ()} תלות {testCompile 'junit: junit: 4.11 'runtime "org.slf4j: slf4j-simple: 1.7.21"} מבחן {testLogging {אירועים' התחיל ',' עבר '}} 

3.2. בניית האפליקציה

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

class class יישום {public static void main (String [] args) זורק Exception {RatpackServer.start (server -> server.handlers (chain -> chain. get (ctx -> ctx.render ("ברוכים הבאים ל Baeldung ratpack !!!) ")))); }}

כפי שאנו רואים, באמצעות RatpackServer כעת אנו יכולים להפעיל את השרת (יציאת ברירת מחדל 5050). ה מטפלים () השיטה לוקחת פונקציה שמקבלת אובייקט שרשרת, הממפה את כל הבקשות הנכנסות בהתאמה. "ממשק API של Handler Chain" זה משמש לבניית אסטרטגיית הטיפול בתגובות.

אם נפעיל את קטע הקוד הזה ונלחץ על הדפדפן בכתובת // localhost: 5050, "ברוך הבא ל- Baeldung ratpack !!!" צריך להיות מוצג.

באופן דומה, אנו יכולים למפות בקשת HTTP POST.

3.3. טיפול בפרמטרים של נתיבי URL

בדוגמה הבאה, עלינו ללכוד איזה פרמטר לנתיב URL ביישום שלנו. ב- Ratpack אנו משתמשים ב- PathTokens כדי ללכוד אותם:

RatpackServer.start (server -> handlers server (chain -> chain .get (": name", ctx -> ctx.render ("Hello" + ctx.getPathTokens (). Get ("name") + "!!) ! "))));

הנה, אנו ממפים את שֵׁם פרמטר URL בכל פעם שבקשה כמו // localhost: 5050 / John יגיע, התגובה תהיה "שלום ג'ון !!!".

3.4. שינוי כותרת בקשה / תגובה עם / בלי מסנן

לפעמים, עלינו לשנות את כותרת תגובת ה- HTTP המוטבעת על פי הצורך שלנו. ל- Ratpack יש MutableHeaders להתאמה אישית של תגובות יוצאות.

לדוגמה, עלינו לשנות את הכותרות הבאות בתגובה: בקרת גישה-אפשר-מקור, קבל שפה, ו קבל-צ'ארסט:

RatpackServer.start (שרת -> server.handlers (שרשרת -> chain.all (ctx -> {כותרות MutableHeaders = ctx.getResponse (). GetHeaders (); headers.set ("בקרת גישה-אפשר-מקור", " * "); headers.set (" Accept-Language "," en-us "); headers.set (" Accept-Charset "," UTF-8 "); ctx.next ();}). get (" : name ", ctx -> ctx .render (" Hello "+ ctx.getPathTokens (). get (" name ") +" !!! ")));

על ידי שימוש ב MutableHeaders קבענו מגדירים את שלושת הכותרות ודוחפים אותם פנימה שַׁרשֶׁרֶת.

באותו אופן, אנו יכולים לבדוק גם את כותרות הבקשות הנכנסות:

ctx.getRequest (). getHeaders (). get ("// TODO")

את אותו הדבר ניתן להשיג על ידי יצירת פילטר. ל- Ratpack יש מטפל מִמְשָׁק, שניתן ליישם כדי ליצור פילטר. יש לה רק שיטה אחת ידית(), שלוקח את הזרם הֶקשֵׁר כפרמטר:

המחלקה הציבורית RequestValidatorFilter מיישמת את המטפל {@Override ידית הריק הציבורי (Context ctx) זורקת Exception {MutableHeaders headers = ctx.getResponse (). getHeaders (); headers.set ("בקרת גישה-אפשר-מקור", "*"); ctx.next (); }}

אנו יכולים להשתמש במסנן זה באופן הבא:

RatpackServer.start (שרת -> server.handlers (שרשרת -> שרשרת. כל (RequestValidatorFilter חדש ()). Get (ctx -> ctx.render ("ברוך הבא ל- rateld baeldung !!!")))); }

3.5. JSON Parser

Ratpack משתמש באופן פנימי ג'קסון מהיר יותר לניתוח JSON. אנו יכולים להשתמש במודול ג'קסון כדי לנתח כל אובייקט ל- JSON.

בואו ליצור שיעור POJO פשוט שישמש לניתוח:

שכבה ציבורית עובד {פרטי מזהה ארוך; כותרת מחרוזת פרטית; שם מחרוזת פרטי; // גטרים וקובעים}

הנה, יצרנו מחלקה אחת פשוטה בשם POJO עוֹבֵד, שיש לו שלושה פרמטרים: מזהה, כותרת, ו שֵׁם. עכשיו נשתמש בזה עוֹבֵד התנגדות להמרה ל- JSON והחזרת אותו כאשר כתובת URL מסוימת נפגעת:

רשימת עובדים = ArrayList חדש (); workers.add (עובד חדש (1L, "מר", "ג'ון דו")); workers.add (עובד חדש (2L, "מר", "שלג לבן"); RatpackServer.start (שרת -> server.handlers (שרשרת -> שרשרת .get ("נתונים / עובדים", ctx -> ctx.render (Jackson.json (עובדים))));

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

נקודה לציין כאן היא ש אנחנו לא משתמשים ObjectMapper בכלל מכיוון שמודול ג'קסון של Ratpack יעשה את הצורך בטיסה.

3.6. מסד נתונים בזיכרון

ל- Ratpack יש תמיכה מהשורה הראשונה במסדי נתונים בזיכרון. הוא משתמש ב- HikariCP לאיחוד חיבורי JDBC. על מנת להשתמש בו, עלינו להוסיף את התלות במודול HikariCP של Ratpack ב- pom.xml:

 io.ratpack ratpack-hikari 1.4.5 

אם אנו משתמשים Gradle, יש להוסיף את אותו הדבר בקובץ build Gradle:

הידור ratpack. תלות ('hikari')

כעת עלינו ליצור קובץ SQL עם הצהרות DDL בטבלה, כך שהטבלאות נוצרות ברגע שהשרת פועל. אנו ניצור את DDL.sql קובץ ב- src / main / resources ספריה והוסף לתוכה כמה הצהרות DDL.

מכיוון שאנו משתמשים במסד נתונים של H2, עלינו להוסיף תלות גם לכך.

כעת, באמצעות HikariModule, אנו יכולים לאתחל את מסד הנתונים בזמן הריצה:

RatpackServer.start (server -> server.registry (Guice.registry (bindings -> bindings.module (HikariModule.class, config -> {config.setDataSourceClassName ("org.h2.jdbcx.JdbcDataSource"); config.addDataSourceProperty (" URL "," jdbc: h2: mem: baeldung; INIT = RUNSCRIPT FROM 'classpath: /DDL.sql' ");}))) handlers (...));

4. בדיקות

כפי שצוין קודם לכן, ל- Ratpack יש תמיכה מהשורה הראשונה במקרים של בדיקות jUnit. באמצעות MainClassApplicationUnderTest אנו יכולים ליצור מקרי בדיקה בקלות ולבדוק את נקודות הקצה:

@RunWith (JUnit4.class) מחלקה ציבורית ApplicationTest {MainClassApplicationUnderTest appUnderTest = MainClassApplicationUnderTest חדש (Application.class); @Test הציבור בטל givenDefaultUrl_getStaticText () {assertEquals ("ברוך הבא ל- Baeldung Ratpack !!!", appUnderTest.getHttpClient (). GetText ("/")); } @Test ציבורי בטל שניתןDynamicUrl_getDynamicText () {assertEquals ("שלום dummybot !!!", appUnderTest.getHttpClient (). GetText ("/ dummybot")); } @Test הציבור בטל givenUrl_getListOfEmployee () זורק JsonProcessingException {רשימת עובדים = ArrayList חדש (); ממפה ObjectMapper = ObjectMapper חדש (); workers.add (עובד חדש (1L, "מר", "ג'ון דו")); workers.add (עובד חדש (2L, "מר", "שלג לבן"); assertEquals (mapper.writeValueAsString (עובדים), appUnderTest.getHttpClient (). getText ("/ נתונים / עובדים")); } @ לאחר כיבוי הריק הפומבי () {appUnderTest.close (); }}

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

5. מסקנה

במאמר זה ראינו את הפשטות של השימוש ב- Ratpack.

כמו תמיד, קוד המקור המלא זמין ב- GitHub.