streamalism.org

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

Spring Batch הוא מסגרת חזקה לפיתוח יישומי אצווה חזקים. במדריך הקודם שלנו, הצגנו את Spring Batch.

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

2. תלות Maven

ראשית, נוסיף את אביב-אתחול-המתנע-אצווה שלנו pom.xml:

 org.springframework.boot spring-boot-starter-batch 2.4.0.RELEASE 

נוסיף גם את org.hsqldb תלות, אשר זמינה גם ממאבן סנטרל:

 org.hsqldb hsqldb 2.5.1 זמן ריצה 

3. הגדרת עבודת אצווה פשוטה באביב

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

3.1. מתחילים

נתחיל בהגדרת נקודת הכניסה ליישום:

@SpringBootApplication מחלקה ציבורית SpringBootBatchProcessingApplication {public static void main (String [] args) {SpringApplication.run (SpringBootBatchProcessingApplication.class, args); }}

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

נגדיר מאפיינים אלה במערכת שלנו src / main / resources / application.properties קוֹבֶץ:

file.input = coffee-list.csv

מאפיין זה מכיל את המיקום של רשימת הקלפים שלנו. כל שורה מכילה את המותג, המקור וכמה מאפיינים של הקפה שלנו:

הר כחול, ג'מייקה, Lavazza פירותי, קולומביה, Folgers חזק, אמריקה, סמוקי

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

לאחר מכן נוסיף סקריפט SQL schema-all.sql ליצור את שלנו קפה טבלה לאחסון הנתונים:

קפה טפטוף אם קיים; צור קפה שולחן (קפה_איד זהות גדולה לא מפתח ראשוני אפס, מותג VARCHAR (20), מקור VARCHAR (20), מאפיינים VARCHAR (30));

באופן נוח Spring Boot יפעיל סקריפט זה באופן אוטומטי במהלך ההפעלה.

3.2. שיעור תחום קפה

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

קפה בכיתה ציבורית {מותג מחרוזת פרטי; מקור מחרוזת פרטי; מאפייני מחרוזת פרטיים; קפה ציבורי (מותג מחרוזת, מקור מחרוזת, מאפייני מחרוזת) {this.brand = brand; this.origin = מוצא; זה.מאפיינים = מאפיינים; } // גטרים וקובעים}

כאמור, שלנו קפה האובייקט מכיל שלוש מאפיינים:

• מותג
• מקור
• כמה מאפיינים נוספים

4. תצורת עבודה

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

@Configuration @EnableBatchProcessing בכיתה ציבורית BatchConfiguration {@ JobBuilderFactory JobBuilderFactory ציבורי אוטומטי; @ StepBuilderFactory הציבורי האוטומטי stepBuilderFactory; @Value ("$ {file.input}") קלט מחרוזת קובץ פרטי; // ...}

ראשית, אנו מתחילים באביב סטנדרטי @תְצוּרָה מעמד. לאחר מכן, אנו מוסיפים א @EnableBatchProcessing ביאור לכיתה שלנו. יש לציין כי זה נותן לנו גישה לשעועית שימושית רבות התומכות בעבודות ויחסוך לנו הרבה עבודת רגליים.

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

בחלק האחרון של התצורה הראשונית שלנו, אנו כוללים התייחסות ל- file.input רכוש שהכרזנו עליו בעבר.

4.1. קורא וכותב לתפקידנו

כעת נוכל להגדיר שעועית קורא בתצורה שלנו:

@Bean הקורא FlatFileItemReader הציבורי () {להחזיר FlatFileItemReaderBuilder חדש (). שם ("coffeeItemReader") .resource (חדש ClassPathResource (fileInput)). מוגבלת (). Names (מחרוזת חדשה [] {"brand", "origin", " מאפיינים "}) .fieldSetMapper (BeanWrapperFieldSetMapper חדש () {{setTargetType (Coffee.class);}}) .build (); }

בקצרה, שעועית הקורא שלנו שהוגדרה לעיל מחפשת קובץ שנקרא coffee-list.csv ומנתח כל פריט ל- a קפה לְהִתְנַגֵד.

כמו כן, אנו מגדירים שעועית סופרת:

@Bean JdbcBatchItemWriter הציבורי (DataSource dataSource) {החזר JdbcBatchItemWriterBuilder חדש () .itemSqlParameterSourceProvider (חדש BeanPropertyItemSqlParameterSourceProvider ()).. .dataSource (dataSource) .build (); }

הפעם, אנו כוללים את הצהרת SQL הדרושה להכנסת פריט קפה יחיד למסד הנתונים שלנו, המונע על ידי מאפייני שעועית ג'אווה של קפה לְהִתְנַגֵד. בקלות את מקור מידע נוצר אוטומטית על ידי @EnableBatchProcessing ביאור.

4.2. להרכיב את העבודה שלנו

לבסוף, עלינו להוסיף את שלבי העבודה והתצורה בפועל:

@Bean ציבור עבודות importUserJob (JobCompletionNotificationListener מאזין, שלב שלב 1) {להחזיר jobBuilderFactory.get ("importUserJob") .incrementer (חדש RunIdIncrementer ()). Listenener (מאזין) .flow (step1) .end () .build (); } @Bean שלב שלב 1 (JdbcBatchItemWriter כותב) {החזר stepBuilderFactory.get ("שלב 1"). נתח (10). קורא (קורא ()). מעבד (מעבד ()). סופר (כותב) .בניין (); } @Bean מעבד CoffeeItemProcessor ציבורי () {להחזיר CoffeeItemProcessor חדש (); }

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

בואו נסתכל מה עושה צעד זה:

• ראשית, אנו מגדירים את הצעד שלנו כך שהוא יכתוב עד עשרה רשומות בכל פעם באמצעות ה- נתח (10) הַצהָרָה
• לאחר מכן, אנו קוראים בנתוני הקפה באמצעות שעועית הקורא שלנו, אותה הגדרנו באמצעות קוֹרֵא שיטה
• לאחר מכן, אנו מעבירים את כל פריטי הקפה שלנו למעבד מותאם אישית בו אנו מיישמים היגיון עסקי מותאם אישית
• לבסוף, אנו כותבים כל פריט קפה למסד הנתונים באמצעות הכותב שראינו קודם

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

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

5. מעבד קפה בהתאמה אישית

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

מחלקה ציבורית CoffeeItemProcessor מיישם ItemProcessor {פרטי פרטי לוגר לוגר LOGGER = LoggerFactory.getLogger (CoffeeItemProcessor.class); תהליך הקפה הציבורי של @Override (קפה קפה סופי) מעניק חריג {מותג מחרוזת = coffee.getBrand (). ToUpperCase (); מקור מחרוזת = coffee.getOrigin (). ToUpperCase (); מחרוזות מחרוזות = coffee.getCharacteristics (). ToUpperCase (); קפה transformedCoffee = קפה חדש (מותג, מקור, סדירות); LOGGER.info ("המרת ({}) ל- ({})", קפה, transformedCoffee); להחזיר transformedCoffee; }}

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

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

6. סיום עבודה

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

@ ביטול הרווח הציבורי afterJob (JobExecution jobExecution) {if (jobExecution.getStatus () == BatchStatus.COMPLETED) {LOGGER.info ("!!! העבודה הסתיימה! הזמן לאמת את התוצאות"); שאילתת מחרוזת = "בחר מותג, מקור, מאפיינים מקפה"; jdbcTemplate.query (שאילתה, (rs, שורה) -> קפה חדש (rs.getString (1), rs.getString (2), rs.getString (3))). עבור כל (קפה -> LOGGER.info ("נמצא במאגר. ", קפה)); }}

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

7. ניהול העבודה שלנו

עכשיו שיש לנו הכל במקום לנהל את העבודה שלנו, כאן מגיע החלק המהנה. בואו נמשיך וננהל את העבודה שלנו:

... 17: 41: 16.336 [main] INFO c.b.b.JobCompletionNotificationListener - !!! העבודה הסתיימה! הגיע הזמן לאמת את התוצאות 17: 41: 16.336 [main] INFO c.b.b.JobCompletionNotificationListener - נמצא בבסיס הנתונים. 17: 41: 16.337 [main] INFO c.b.b.JobCompletionNotificationListener - נמצא בבסיס הנתונים. 17: 41: 16.337 [main] INFO c.b.b.JobCompletionNotificationListener - נמצא בבסיס הנתונים. ... 

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

8. מסקנה

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

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

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