streamalism.org

1. הקדמה

במדריך זה נלמד על אביב שילוב Java DSL ליצירת שילובי יישומים.

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

2. תלות

האביב שילוב Java DSL הוא חלק מ- Core Integration Spring.

אז נוכל להוסיף את התלות:

 org.springframework.integration spring-integration-core 5.0.6.RELEASE 

וכדי לעבוד על היישום שלנו להעברת קבצים, נצטרך גם קובץ שילוב אביב:

 org.springframework.integration spring-integration-file 5.0.6.RELEASE 

3. שילוב אביב Java DSL

לפני Java DSL, המשתמשים היו מגדירים רכיבי אינטגרציה של אביב ב- XML.

ה- DSL מציג כמה בונים שוטפים שמהם אנו יכולים ליצור קו צינור שלם של שילוב אביב אך ורק בג'אווה.

אז, בואו נגיד שרצינו ליצור ערוץ שמגדיל את כל הנתונים שמגיעים דרך הצינור.

בעבר היינו עשויים:

ועכשיו נוכל במקום זאת לעשות:

@Bean Public IntegrationFlow upcaseFlow () {return IntegrationFlows.from ("input") .transform (String :: toUpperCase) .get (); }

4. האפליקציה להעברת קבצים

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

4.1. זרימת אינטגרציה

אבן הבניין הראשונה לה אנו זקוקים היא זרימת אינטגרציה, אותה אנו יכולים לקבל מה- IntegrationFlows בּוֹנֶה:

IntegrationFlows.from (...)

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

• MessageSourceס
• MessageChannels, ו
• חוּטס

נדבר על שלושתם בקרוב.

אחרי שהתקשרנו מ, כמה שיטות התאמה אישית זמינות כעת עבורנו:

זרימת IntegrationFlow = IntegrationFlows.from (sourceDirectory ()) .filter (onlyJpgs ()) .handle (targetDirectory ()) // הוסף רכיבים נוספים. Get ();

בסופו של דבר, IntegrationFlows תמיד יפיק מופע של IntegrationFlow, שהוא התוצר הסופי של כל אפליקציית אביב שילוב.

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

4.2. תיאור מקור קלט

ראשית, כדי להעביר קבצים, נצטרך לציין לזרימת האינטגרציה שלנו איפה זה צריך לחפש אותם, ולשם כך, אנחנו צריכים a MessageSource:

@Bean ציבורי MessageSource sourceDirectory () {// .. צור מקור הודעה}

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

באופן ספציפי יותר, אנו זקוקים למשהו שיכול לְהִסְתָגֵל אותו מקור חיצוני לייצוג המסרים באביב. ומאז זה הִסתַגְלוּת מתמקד קֶלֶט, אלה נקראים לעתים קרובות מתאמי ערוץ קלט.

ה אביב-שילוב-קובץ התלות נותנת לנו מתאם ערוצי קלט שמתאים למקרה השימוש שלנו: FileReadingMessage מקור:

@Bean MessageSource sourceDirectory () {FileReadingMessageSource messageSource = חדש FileReadingMessageSource (); messageSource.setDirectory (קובץ חדש (INPUT_DIR)); return messageSource; }

הנה, שלנו FileReadingMessageSource יקרא ספריה שניתנה על ידי INPUT_DIR וייצור MessageSource מזה.

בואו נציין זאת כמקור שלנו ב- IntegrationFlows.from קְרִיאָה:

IntegrationFlows.from (sourceDirectory ());

4.3. קביעת תצורה של מקור קלט

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

כדי להקל על כך, מ יכול גם לקחת תוספת מגדרים כהתאמה אישית נוספת של מקור הקלט:

IntegrationFlows.from (sourceDirectory (), תצורה -> configurer.poller (Pollers.fixedDelay (10000)));

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

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

4.4. סינון הודעות ממקור קלט

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

לשם כך אנו יכולים להשתמש GenericSelector:

@Bean Public GenericSelector onlyJpgs () {להחזיר GenericSelector חדש () {@Override ציבורי בוליאני ציבורי (מקור קובץ) {return source.getName (). EndsWith (". Jpg"); }}; }

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

IntegrationFlows.from (sourceDirectory ()) .filter (onlyJpgs ());

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

IntegrationFlows.from (sourceDirectory ()) .filter (source -> ((File) source) .getName (). EndsWith (". Jpg"));

4.5. טיפול בהודעות עם מפעילי שירות

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

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

בואו נשתמש ב- FileWritingMessageHandler מפעיל שירות מ אביב-שילוב-קובץ:

@Bean MessageHandler public targetDirectory () {FileWritingMessageHandler handler = FileWritingMessageHandler חדש (קובץ חדש (OUTPUT_DIR)); handler.setFileExistsMode (FileExistsMode.REPLACE); handler.setExpectReply (false); מטפל בחזרה; }

הנה, שלנו FileWritingMessageHandler יכתוב כל אחד הוֹדָעָה מטען שהוא מקבל אליו OUTPUT_DIR.

שוב, בואו נעדכן:

IntegrationFlows.from (sourceDirectory ()) .filter (onlyJpgs ()) .handle (targetDirectory ());

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

4.6. הפעלת זרימת האינטגרציה שלנו

כאשר הוספנו את כל הרכיבים שלנו אנו צריכים רשום את שלנו IntegrationFlow כשעועית להפעיל אותו:

@Bean IntegrationFlow הציבור FileMover () {להחזיר IntegrationFlows.from (sourceDirectory (), c -> c.poller (Pollers.fixedDelay (10000))). פילטר (onlyJpgs ()). ידית (targetDirectory ()) .get () ; }

ה לקבל תמציות שיטה IntegrationFlow למשל שעלינו להירשם כשעועית אביבית.

ברגע שהקשר היישום שלנו נטען, כל הרכיבים שלנו כלולים ב IntegrationFlow הופעל.

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

5. רכיבים נוספים

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

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

5.1. ערוצי הודעות

כאמור, א ערוץ הודעות היא דרך נוספת לאתחל זרימה:

IntegrationFlows.from ("anyChannel")

אנו יכולים לקרוא זאת כ"נא למצוא או ליצור שעועית ערוץ שנקראת anyChannel. לאחר מכן, קרא את כל הנתונים שמוזנים אליהם anyChannel מזרימות אחרות. "

אבל, באמת זה מטרה כללית יותר מכך.

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

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

@Bean PriorityChannel ציבורי באלפביתיות () {החזר PriorityChannel חדש (1000, (שמאל, ימין) -> ((קובץ) שמאל. GetPayload ()). GetName (). CompareTo ((((קובץ) right.getPayload ()). GetName ())); }

ואז נוכל להוסיף קריאה ל- עָרוּץ בין הזרימה שלנו:

@Bean IntegrationFlow publicMover () {החזר IntegrationFlows.from (sourceDirectory ()) .filter (onlyJpgs ()) .channel ("אלפביתית"). ידית (targetDirectory ()) .get (); }

יש עשרות ערוצים לבחירה, חלק מהשימושיות יותר הן במקביל, ביקורת או התמדה בינאית (תחשוב על מאגרי קפקא או JMS).

כמו כן, ערוצים יכולים להיות חזקים בשילוב עם לְגַשֵׁרס.

5.2. לְגַשֵׁר

כשאנחנו רוצים לשלב שני ערוצים, אנו משתמשים ב- לְגַשֵׁר.

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

@Bean קובץ IntegrationFlow ציבורי () {להחזיר IntegrationFlows.from (sourceDirectory ()) .filter (onlyJpgs ()) .channel ("holdingTank") .get (); }

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

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

@Bean קובץ IntegrationFlow ציבורי () {return IntegrationFlows.from ("holdingTank") .bridge (e -> e.poller (Pollers.fixedRate (1, TimeUnit.SECONDS, 20))) .handle (targetDirectory ()) .get (); }

שוב, מכיוון שכתבנו לערוץ ביניים, כעת נוכל להוסיף זרימה נוספת שלוקח את אותם קבצים וכותב אותם בקצב אחר:

@Bean IntegrationFlow עודFileWriter () {להחזיר IntegrationFlows.from ("holdingTank") .bridge (e -> e.poller (Pollers.fixedRate (2, TimeUnit.SECONDS, 10))) .handle (anotherTargetDirectory ()) .get (); }

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

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

6. מסקנה

במאמר זה ראינו דרכים שונות להשתמש ב- Spring Integration Java DSL לבניית צינורות אינטגרציה שונים.

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

כמו כן, בדקנו כמה רכיבים אחרים כמו ערוצים וגשרים.

קוד המקור השלם המשמש במדריך זה זמין ב- Github.