Ratpack עם גרובי

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

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

בנוסף, Ratpack מספק גם אינטגרציה עם טכנולוגיות ומסגרות כמו Google Guice, Spring Boot, RxJava ו- Hystrix.

במדריך זה נחקור כיצד להשתמש ב- Ratpack עם Groovy.

2. למה גרובי?

גרובי היא שפה עוצמתית ודינמית הפועלת ב- JVM.

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

Ratpack מספק שילוב קל עם גרובי דרך ratpack-groovy ו חבורת הבוגדיםמבחן גרובי ספריות.

3. יישום Ratpack באמצעות סקריפט גרובי

ממשקי ה- API של Ratpack Groovy בנויים בג'אווה כך שהם יכולים להשתלב בקלות עם יישומי Java ו- Groovy. הם זמינים ב- ratpack.groovy חֲבִילָה.

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

@Grab ('io.ratpack: ratpack-groovy: 1.6.1') ייבא ratpack סטטי.groovy.Groovy.ratpack ratpack {מטפלים {קבלו {render 'שלום עולם מ Ratpack עם Groovy !!' }}}

זה המטפל הראשון שלנו, טיפול בבקשת GET. כל מה שהיינו צריכים לעשות היה להוסיף קצת DSL בסיסי כדי לאפשר את שרת Ratpack.

בואו נפעיל את זה כתסריט גרובי כדי להפעיל את היישום. כברירת מחדל, היישום יהיה זמין בתאריך // localhost: 5050:

$ curl -s localhost: 5050 שלום עולם מ Ratpack עם Groovy !!

אנו יכולים גם להגדיר את היציאה באמצעות ServerConfig:

ratpack {serverConfig {port (5056)}}

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

4. ניהול תלות Ratpack-Groovy

ישנן מספר דרכים להפעלה ratpack-groovy תמיכה.

4.1. עַנָב

אנו יכולים להשתמש במנהל התלות המשובץ של גרובי ענבים.

זה פשוט כמו להוסיף הערה לשלנו Ratpack.groovy תַסרִיט:

@Grab ('io.ratpack: ratpack-groovy: 1.6.1') ייבא ratpack סטטי.groovy.Groovy.ratpack

4.2. תלות של Maven

לבנייה במייבון, כל מה שאנחנו צריכים זה להוסיף את התלות עבור ratpack-groovy סִפְרִיָה:

 io.ratpack ratpack-groovy $ {ratpack.version} 

4.3. Gradle

אנחנו יכולים לאפשר ratpack-groovy שילוב, על ידי הוספת תוסף ה- Gradle של Ratpack ל- Groovy in build.gradle:

תוספים {id 'io.ratpack.ratpack-groovy' גרסה '1.6.1'}

5. מטפלי Ratpack בגרובי

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

אנו יכולים לטפל בבקשות אינטרנט בשיטות HTTP כמו GET ו- POST:

מטפלים {get ("greet /: name") {ctx -> לדקלם "Hello" + ctx.getPathTokens (). get ("name") + "!!!" }} 

אנו יכולים לבדוק את בקשת האינטרנט הזו דרך // localhost: 5050 / שלום /:

$ curl -s localhost: 5050 / greet / נורמן שלום נורמן !!!

בקוד המטפל, ctx האם ה הֶקשֵׁר אובייקט רישום המעניק גישה למשתני נתיב, אובייקטי בקשה ותגובה.

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

בואו נחזיר את JSON, שהומר ממפת גרובי:

get ("data") {render Jackson.json ([title: "Mr", name: "Norman", country: "USA"))} 
$ curl -s localhost: 5050 / data {"title": "Mr", "name": "Norman", "country": "USA"}

פה, ג'קסון.ג'סון משמש לביצוע ההמרה.

6. Ratpack מבטיח בגרובי

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

הבטחות דומות לאלה המשמשות ב- JavaScript והן קצת כמו Java עתיד. אנחנו יכולים לחשוב על א הַבטָחָה כייצוג של ערך שיהיה זמין בעתיד:

פרסם ("משתמש") {משתמש מבטיח = לנתח (ג'קסון.פרומזון (משתמש)) משתמש. ואז {u -> הפוך את u.name}}

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

בואו נבין את הקוד הזה ביתר פירוט. פה, ג'קסון. מג'סון מנתח את ה- JSON של גוף הבקשה באמצעות ה- ObjectMapperמִשׁתַמֵשׁ. ואז, המובנה הֶקשֵׁר.לְנַתֵחַ השיטה קושרת אותו ל הַבטָחָה לְהִתְנַגֵד.

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

תלתל -X POST -H 'סוג תוכן: יישום / json' - נתונים \ '{"id": 3, "title": "Mrs", "name": "Jiney Weiber", "country": "UK "} '\ // localhost: 5050 / עובדת ג'יני ווייבר

עלינו לציין כי ספריית Promise עשירה למדי ומאפשרת לנו לשרשר פעולות באמצעות פונקציות כמו מַפָּה ו flatMap.

7. שילוב עם מסד נתונים

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

אנחנו יכולים להשתמש ב- Ratpack HikariModule בכיתה שהיא הרחבה של מאגר החיבורים HikariCP JDBC, או Groovy S.ql לשילוב בסיס נתונים.

7.1. HikariModule

כדי להוסיף תמיכה ב- HikariCP, ראשית נוסיף את התלות הבאה של Hikari ו- H2 Maven שלנו pom.xml:

 io.ratpack ratpack-hikari $ {ratpack.version} com.h2database h2 $ {h2.version} 

לחלופין, אנו יכולים להוסיף את התלות הבאה שלנו build.gradle:

תלות {הידור ratpack.dependency ('hikari') הידור "com.h2database: h2: $ h2.version"}

עכשיו, נכריז HikariModule תחת כריכות סגירה לבריכת החיבור:

ייבא ratpack.hikari.HikariModule ratpack {bindings {module (HikariModule) {config -> config.dataSourceClassName = 'org.h2.jdbcx.JdbcDataSource' config.addDataSourceProperty ('URL', "jdbc: h2: mem: devDB; INIT = RUNSCRIPT מאת 'classpath: /User.sql' ")}}} 

לבסוף, כולנו מוכנים להשתמש בו לביצוע פעולות בסיסי נתונים פשוטות באמצעות Java חיבור ו הצהרה מוכנה:

get ('fetchUserName /: id') {Context ctx -> חיבור חיבור = ctx.get (DataSource.class) .getConnection () PreparedStatement queryStatement = connection.prepareStatement ("בחר שם ממשתמש איפה ID =?") queryStatement.setInt (1, Integer.parseInt (ctx.getPathTokens (). Get ("id"))) ResultSet resultSet = queryStatement.executeQuery () resultSet.next () render resultSet.getString (1)} 

בואו לבדוק שהמטפל עובד כצפוי:

$ curl -s localhost: 5050 / fetchUserName / 1 נורמן פוטר

7.2. קִצבִּי מ"ר מעמד

אנחנו יכולים להשתמש בגרובי מ"ר לפעולות מהירות של מסדי נתונים, באמצעות שיטות כמו שורות ו executeInsert:

קבל ('fetchUsers') {def db = [url: 'jdbc: h2: mem: devDB'] def sql = Sql.newInstance (db.url, db.user, db.password) def משתמשים = sql.rows (" בחר * מהמשתמש "); עיבוד (Jackson.json (משתמשים))} 
$ curl -s localhost: 5050 / fetchUsers [{"ID": 1, "TITLE": "Mr", "NAME": "Norman Potter", "COUNTRY": "USA"}, {"ID": 2, "TITLE": "מיס", "NAME": "קטי סמית", "COUNTRY": "FRANCE"}]

בוא נכתוב דוגמה של HTTP POST עם מ"ר:

post ('addUser') {parse (Jackson.fromJson (User)). ואז {u -> def db = [url: 'jdbc: h2: mem: devDB'] Sql sql = Sql.newInstance (db.url, db .user, db.password) sql.executeInsert ("הכנס לערכי משתמש (?,?,?,?)", [u.id, u.title, u.name, u.country]) מעבד "משתמש $ u .name הוכנס "}}
$ curl -X POST -H 'סוג תוכן: יישום / json' - נתונים \ '{"id": 3, "title": "Mrs", "name": "Jiney Weiber", "country": " בריטניה "} '\ // localhost: 5050 / משתמש המשתמש Jiney Weiber הוכנס

8. בדיקת יחידות

8.1. הגדרת המבחנים

כפי שנדון, Ratpack מספק גם את חבורת הבוגדיםמבחן גרובי ספרייה עבור בדיקות א ratpack-groovy יישום.

כדי להשתמש בו, אנו יכולים להוסיף אותו כתלות של Maven אצלנו pom.xml:

 io.ratpack ratpack-groovy-test 1.6.1 

לחלופין, אנו יכולים להוסיף את התלות של Gradle ב- שלנו build.gradle:

testCompile ratpack.dependency ('groovy-test')

ואז עלינו ליצור מעמד ראשי גרובי RatpackGroovyApp.groovy לתת לנו לבדוק את Ratpack.groovy תַסרִיט.

מחלקה ציבורית RatpackGroovyApp {public static void main (String [] args) {File file = new File ("src / main / groovy / com / baeldung / Ratpack.groovy"); def shell = GroovyShell חדש () shell.evaluate (file)}}

כאשר מריצים מבחני גרובי כמבחני JUnit, הכיתה תפעיל את Ratpack.groovy באמצעות סקריפט GroovyShell. בתורו, הוא יפעיל את שרת Ratpack לבדיקה.

עכשיו בואו נכתוב את שיעור הבדיקות הגרוביות שלנו RatpackGroovySpec.groovy יחד עם הקוד להפעלת שרת Ratpack דרך ה- RatpackGroovyApp:

class RatpackGroovySpec {ServerBackedApplicationUnderTest ratpackGroovyApp = new MainClassApplicationUnderTest (RatpackGroovyApp.class) @Delegate TestHttpClient client = TestHttpClient.testHttpClient (ratpackGroovyApp)}

Ratpack מספק MainClassApplicationUnderTest כדי ללעוג למחלקת היישומים להפעלת השרת.

8.2. כתיבת המבחנים שלנו

בואו נכתוב את המבחנים שלנו, החל ממבחן בסיסי מאוד כדי לבדוק אם היישום יכול להתחיל:

@Test בטל "בדוק אם האפליקציה מופעלת" () {מתי: get ("") ואז: assert response.statusCode == 200 assert response.body.text == "שלום עולם מ Ratpack עם Groovy !!" }

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

@Test בטל "test fetchUsers" () {when: get ("fetchUsers") ואז: assert response.statusCode == 200 assert response.body.text == '[{"ID": 1, "TITLE": "Mr. "," NAME ":" נורמן פוטר "," COUNTRY ":" USA "}, {" ID ": 2," TITLE ":" Miss "," NAME ":" Ketty Smith "," COUNTRY ":" FRANCE "}] '}

מסגרת הבדיקה של Ratpack דואגת להפעיל ולעצור את השרת עבורנו.

9. מסקנה

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

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

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

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


$config[zx-auto] not found$config[zx-overlay] not found