Spring Batch - คู่มือฉบับย่อ
Batch processingเป็นโหมดการประมวลผลที่เกี่ยวข้องกับการดำเนินการชุดของงานอัตโนมัติที่ซับซ้อนโดยไม่ต้องโต้ตอบกับผู้ใช้ กระบวนการชุดจัดการข้อมูลจำนวนมากและดำเนินการเป็นเวลานาน
แอปพลิเคชันระดับองค์กรจำนวนมากจำเป็นต้องประมวลผลข้อมูลจำนวนมากเพื่อดำเนินการที่เกี่ยวข้องกับ -
เหตุการณ์ตามเวลาเช่นการคำนวณเป็นระยะ
แอปพลิเคชันเป็นระยะที่ประมวลผลซ้ำ ๆ บนชุดข้อมูลขนาดใหญ่
แอปพลิเคชันที่เกี่ยวข้องกับการประมวลผลและการตรวจสอบความถูกต้องของข้อมูลที่มีอยู่ในลักษณะธุรกรรม
ดังนั้นการประมวลผลแบบชุดจึงใช้ในแอปพลิเคชันระดับองค์กรเพื่อทำธุรกรรมดังกล่าว
Spring Batch คืออะไร
ชุดสปริงคือ lightweight framework ซึ่งใช้ในการพัฒนา Batch Applications ที่ใช้ใน Enterprise Applications
นอกเหนือจากการประมวลผลจำนวนมากแล้วเฟรมเวิร์กนี้ยังมีฟังก์ชันสำหรับ -
- รวมถึงการบันทึกและการติดตาม
- การจัดการธุรกรรม
- สถิติการประมวลผลงาน
- เริ่มงานใหม่
- การข้ามและการจัดการทรัพยากร
คุณยังสามารถปรับขนาดแอปพลิเคชันชุดสปริงโดยใช้เทคนิคการแบ่งส่วน
คุณสมบัติของ Spring Batch
คุณสมบัติเด่นของ Spring Batch -
Flexibility- การใช้งาน Spring Batch มีความยืดหยุ่น คุณเพียงแค่ต้องเปลี่ยนไฟล์ XML เพื่อแก้ไขลำดับการประมวลผลในแอปพลิเคชัน
Maintainability- การใช้งาน Spring Batch นั้นดูแลรักษาง่าย งาน Spring Batch ประกอบด้วยขั้นตอนและแต่ละขั้นตอนสามารถแยกออกทดสอบและอัปเดตได้โดยไม่ส่งผลกระทบต่อขั้นตอนอื่น ๆ
Scalability- ใช้เทคนิคการแบ่งส่วนคุณสามารถปรับขนาดแอปพลิเคชัน Spring Batch เทคนิคเหล่านี้ช่วยให้คุณ -
ดำเนินการตามขั้นตอนของงานควบคู่กันไป
ดำเนินการเธรดเดี่ยวแบบขนาน
Reliability - ในกรณีที่เกิดความล้มเหลวคุณสามารถเริ่มงานใหม่จากจุดที่หยุดทำงานได้โดยการแยกขั้นตอน
Support for multiple file formats - Spring Batch ให้การสนับสนุนสำหรับผู้อ่านและนักเขียนจำนวนมากเช่น XML, Flat file, CSV, MYSQL, Hibernate, JDBC, Mongo, Neo4j และอื่น ๆ
Multiple ways to launch a job - คุณสามารถเปิดงาน Spring Batch โดยใช้เว็บแอปพลิเคชันโปรแกรม Java Command Line และอื่น ๆ
นอกเหนือจากนี้แอปพลิเคชัน Spring Batch ยังรองรับ -
ลองใหม่โดยอัตโนมัติหลังจากความล้มเหลว
สถานะการติดตามและสถิติระหว่างการดำเนินการแบทช์และหลังจากเสร็จสิ้นการประมวลผลชุดงาน
เพื่อเรียกใช้งานพร้อมกัน
บริการต่างๆเช่นการบันทึกการจัดการทรัพยากรการข้ามและการเริ่มต้นการประมวลผลใหม่
ในบทนี้เราจะอธิบายวิธีตั้งค่าสภาพแวดล้อม Spring Batch ใน Eclipse IDE ก่อนดำเนินการติดตั้งตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง Eclipse ในระบบของคุณแล้ว หากไม่มีให้ดาวน์โหลดและติดตั้ง Eclipse ในระบบของคุณ
สำหรับข้อมูลเพิ่มเติมเกี่ยวกับ Eclipse โปรดดูบทช่วยสอน Eclipseของเรา
การตั้งค่า Spring Batch บน Eclipse
ทำตามขั้นตอนด้านล่างเพื่อตั้งค่าสภาพแวดล้อม Spring Batch บน Eclipse
Step 1 - ติดตั้ง Eclipse และเปิดโครงการใหม่ดังที่แสดงในภาพหน้าจอต่อไปนี้
Step 2 - สร้างโครงการ Spring Batch ตัวอย่างดังที่แสดงด้านล่าง
Step 3- คลิกขวาที่โปรเจ็กต์และแปลงเป็นโปรเจ็กต์ Maven ดังที่แสดงด้านล่าง เมื่อคุณแปลงเป็นโครงการ Maven มันจะให้ไฟล์Pom.xmlที่คุณต้องพูดถึงการอ้างอิงที่จำเป็น หลังจากนั้นjar ไฟล์เหล่านั้นจะถูกดาวน์โหลดลงในโปรเจ็กต์ของคุณโดยอัตโนมัติ
Step 4 - ตอนนี้ใน pom.xml ของโครงการคัดลอกและวางเนื้อหาต่อไปนี้ (การอ้างอิงสำหรับแอปพลิเคชันชุดสปริง) และรีเฟรชโครงการ
<project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tutorialspoint</groupId>
<artifactId>SpringBatchSample</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>SpringBatchExample</name>
<url>http://maven.apache.org</url>
<properties>
<jdk.version>1.8</jdk.version>
<spring.version>4.3.8.RELEASE</spring.version>
<spring.batch.version>3.0.7.RELEASE</spring.batch.version>
<mysql.driver.version>5.1.25</mysql.driver.version>
<junit.version>4.11</junit.version>
</properties>
<dependencies>
<!-- Spring Core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- Spring jdbc, for database -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- Spring XML to/back object -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-oxm</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- MySQL database driver -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.driver.version}</version>
</dependency>
<!-- Spring Batch dependencies -->
<dependency>
<groupId>org.springframework.batch</groupId>
<artifactId>spring-batch-core</artifactId>
<version>${spring.batch.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.batch</groupId>
<artifactId>spring-batch-infrastructure</artifactId>
<version>${spring.batch.version}</version>
</dependency>
<!-- Spring Batch unit test -->
<dependency>
<groupId>org.springframework.batch</groupId>
<artifactId>spring-batch-test</artifactId>
<version>${spring.batch.version}</version>
</dependency>
<!-- Junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>spring-batch</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.9</version>
<configuration>
<downloadSources>true</downloadSources>
<downloadJavadocs>false</downloadJavadocs>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<source>${jdk.version}</source>
<target>${jdk.version}</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
สุดท้ายหากคุณสังเกตการอ้างอิงของ Maven คุณสามารถสังเกตได้ว่าจำเป็นทั้งหมด jar ดาวน์โหลดไฟล์แล้ว
ต่อไปนี้คือการแสดงแผนผังของสถาปัตยกรรมของ Spring Batch ตามที่แสดงในรูปสถาปัตยกรรมประกอบด้วยองค์ประกอบหลักสามส่วน ได้แก่Application, Batch Coreและ Batch Infrastructure.
Application - ส่วนประกอบนี้ประกอบด้วยงานทั้งหมดและโค้ดที่เราเขียนโดยใช้ Spring Batch framework
Batch Core - ส่วนประกอบนี้มีคลาส API ทั้งหมดที่จำเป็นในการควบคุมและเปิดใช้งาน Batch Job
Batch Infrastructure - ส่วนประกอบนี้ประกอบด้วยผู้อ่านนักเขียนและบริการที่ใช้โดยทั้งแอปพลิเคชันและส่วนประกอบหลักของแบทช์
ส่วนประกอบของ Spring Batch
ภาพประกอบต่อไปนี้แสดงส่วนประกอบต่างๆของ Spring Batch และวิธีการเชื่อมต่อซึ่งกันและกัน
งาน
ในแอปพลิเคชัน Spring Batch งานคือกระบวนการแบตช์ที่จะดำเนินการ ทำงานตั้งแต่ต้นจนจบโดยไม่หยุดชะงัก งานนี้แบ่งออกเป็นขั้นตอนเพิ่มเติม (หรืองานมีขั้นตอน)
เราจะกำหนดค่างานใน Spring Batch โดยใช้ไฟล์ XML หรือคลาส Java ต่อไปนี้คือการกำหนดค่า XML ของงานใน Spring Batch
<job id = "jobid">
<step id = "step1" next = "step2"/>
<step id = "step2" next = "step3"/>
<step id = "step3"/>
</job>
ชุดงานถูกกำหนดค่าภายในแท็ก <job> </job> มีแอตทริบิวต์ชื่อid. ภายในแท็กเหล่านี้เรากำหนดนิยามและลำดับขั้นตอน
Restartable - โดยทั่วไปเมื่องานกำลังดำเนินอยู่และเราพยายามเริ่มต้นใหม่อีกครั้งซึ่งถือเป็น restartและจะเริ่มต้นใหม่อีกครั้ง เพื่อหลีกเลี่ยงปัญหานี้คุณต้องตั้งค่าไฟล์restartable มูลค่าถึง false ดังแสดงด้านล่าง
<job id = "jobid" restartable = "false" >
</job>
ขั้นตอน
ก step เป็นส่วนอิสระของงานซึ่งมีข้อมูลที่จำเป็นในการกำหนดและดำเนินงาน (ส่วนของงาน)
ตามที่ระบุไว้ในแผนภาพแต่ละขั้นตอนประกอบด้วย ItemReader, ItemProcessor (ทางเลือก) และ ItemWriter A job may contain one or more steps.
ผู้อ่านนักเขียนและผู้ประมวลผล
อัน item reader อ่านข้อมูลในแอปพลิเคชัน Spring Batch จากแหล่งเฉพาะในขณะที่ไฟล์ item writer เขียนข้อมูลจากแอปพลิเคชัน Spring Batch ไปยังปลายทางเฉพาะ
อัน Item processorเป็นคลาสที่มีรหัสการประมวลผลซึ่งประมวลผลข้อมูลที่อ่านลงในชุดสปริง หากแอปพลิเคชันอ่าน"n" จากนั้นรหัสในโปรเซสเซอร์จะถูกเรียกใช้ในแต่ละเร็กคอร์ด
เมื่อไม่มีผู้อ่านและนักเขียนให้ a taskletทำหน้าที่เป็นโปรเซสเซอร์สำหรับ SpringBatch มันประมวลผลงานเดียวเท่านั้น ตัวอย่างเช่นหากเรากำลังเขียนงานด้วยขั้นตอนง่ายๆที่เราอ่านข้อมูลจากฐานข้อมูล MySQL และประมวลผลและเขียนลงในไฟล์ (แบน) ขั้นตอนของเราจะใช้ -
ก reader ซึ่งอ่านจากฐานข้อมูล MySQL
ก writer ซึ่งเขียนลงในไฟล์แบบแบน
ก custom processor ซึ่งประมวลผลข้อมูลตามความต้องการของเรา
<job id = "helloWorldJob">
<step id = "step1">
<tasklet>
<chunk reader = "mysqlReader" writer = "fileWriter"
processor = "CustomitemProcessor" ></chunk>
</tasklet>
</step>
</ job>
Spring Batch มีรายการ readers และ writers. การใช้คลาสที่กำหนดไว้ล่วงหน้าเหล่านี้เราสามารถกำหนดถั่วให้กับพวกเขาได้ เราจะหารือreaders และ writers ในรายละเอียดเพิ่มเติมในบทต่อ ๆ ไป
JobRepository
ที่เก็บงานใน Spring Batch ให้การดำเนินการสร้างดึงข้อมูลอัปเดตและลบ (CRUD) สำหรับการใช้งาน JobLauncher งานและขั้นตอน เราจะกำหนดที่เก็บงานในไฟล์ XML ดังที่แสดงด้านล่าง
<job-repository id = "jobRepository"/>
นอกจาก idมีตัวเลือกเพิ่มเติม (ไม่บังคับ) ให้เลือก ต่อไปนี้คือการกำหนดค่าของที่เก็บงานพร้อมตัวเลือกทั้งหมดและค่าดีฟอลต์
<job-repository id = "jobRepository"
data-source = "dataSource"
transaction-manager = "transactionManager"
isolation-level-for-create = "SERIALIZABLE"
table-prefix = "BATCH_"
max-varchar-length = "1000"/>
In-Memory Repository - ในกรณีที่คุณไม่ต้องการคงวัตถุโดเมนของ Spring Batch ไว้ในฐานข้อมูลคุณสามารถกำหนดค่า jobRepository เวอร์ชันในหน่วยความจำดังที่แสดงด้านล่าง
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean ">
<property name = "transactionManager" ref = "transactionManager"/>
</bean>
JobLauncher
JobLauncher เป็นอินเทอร์เฟซที่เปิดใช้งาน Spring Batch ด้วยไฟล์ given set of parameters. SampleJoblauncher เป็นคลาสที่ใช้ JobLauncherอินเตอร์เฟซ. ต่อไปนี้คือการกำหนดค่า JobLauncher
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
JobInstance
ก JobInstanceแสดงถึงการรันตรรกะของงาน มันถูกสร้างขึ้นเมื่อเราเรียกใช้งาน แต่ละอินสแตนซ์ของงานมีความแตกต่างกันตามชื่อของงานและพารามิเตอร์ที่ส่งผ่านไปยังงานนั้นขณะรัน
หากการดำเนินการ JobInstance ล้มเหลวคุณสามารถดำเนินการ JobInstance เดียวกันได้อีกครั้ง ดังนั้น JobInstance แต่ละงานสามารถมีการดำเนินการหลายงาน
JobExecution และ StepExecution
JobExecution และ StepExecution เป็นการแสดงการดำเนินการของงาน / ขั้นตอน ประกอบด้วยข้อมูลการรันของงาน / ขั้นตอนเช่นเวลาเริ่มต้น (ของงาน / ขั้นตอน) เวลาสิ้นสุด (ของงาน / ขั้นตอน)
ตัวอย่างเกือบทั้งหมดในบทช่วยสอนนี้มีไฟล์ต่อไปนี้ -
- ไฟล์คอนฟิกูเรชัน (ไฟล์ XML)
- Tasklet / โปรเซสเซอร์ (คลาส Java)
- คลาส Java พร้อม setters และ getters (คลาส Java (bean))
- คลาส Mapper (คลาส Java)
- คลาส Launcher (คลาส Java)
ไฟล์กำหนดค่า
ไฟล์คอนฟิกูเรชัน (XML) มีดังต่อไปนี้ -
job และ step คำจำกัดความ
ถั่วกำหนด readers และ writers.
ความหมายของคอมโพเนนต์เช่น JobLauncher, JobRepository, Transaction Manager และ Data Source
ในตัวอย่างของเราเพื่อความเข้าใจที่ดีขึ้นเราได้แบ่งสิ่งนี้ออกเป็นสองไฟล์คือไฟล์ job.xml ไฟล์ (กำหนดงานขั้นตอนผู้อ่านและผู้เขียน) และ context.xml ไฟล์ (ตัวเรียกใช้งานที่เก็บงานตัวจัดการธุรกรรมและแหล่งข้อมูล)
คลาส Mapper
คลาส Mapper ขึ้นอยู่กับผู้อ่านใช้อินเทอร์เฟซเช่น row mapper, field set mapperฯลฯ มันมีรหัสสำหรับรับข้อมูลจากเครื่องอ่านและตั้งค่าเป็นคลาส Java ด้วย setter และ getter วิธีการ (Java Bean)
คลาส Java Bean
คลาส Java ที่มี setters และ getters(Java bean) แทนข้อมูลที่มีหลายค่า มันทำหน้าที่เป็นคลาสผู้ช่วย เราจะส่งผ่านข้อมูลจากส่วนประกอบหนึ่ง (ผู้อ่านตัวเขียนผู้ประมวลผล) ไปยังส่วนอื่น ๆ ในรูปแบบของวัตถุของคลาสนี้
Tasklet / โปรเซสเซอร์
คลาส Tasklet / โปรเซสเซอร์มีรหัสการประมวลผลของแอ็พพลิเคชัน Spring Batch ตัวประมวลผลคือคลาสที่ยอมรับอ็อบเจ็กต์ที่มีข้อมูลอ่านประมวลผลและส่งคืนข้อมูลที่ประมวลผลแล้ว (ในอ็อบเจ็กต์ฟอร์ม)
คลาสตัวเรียกใช้
คลาสนี้ (App.java) มีรหัสสำหรับเปิดแอปพลิเคชัน Spring Batch
ในขณะที่เขียนแอปพลิเคชัน Spring Batch เราจะกำหนดค่างานขั้นตอน JobLauncher JobRepository ตัวจัดการธุรกรรมผู้อ่านและผู้เขียนโดยใช้แท็ก XML ที่ให้ไว้ในเนมสเปซ Spring Batch ดังนั้นคุณต้องรวมเนมสเปซนี้ในไฟล์ XML ของคุณดังที่แสดงด้านล่าง
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/bean
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
ในส่วนต่อไปนี้เราจะพูดถึงแท็กต่างๆคุณลักษณะและตัวอย่างของแท็กที่มีอยู่ในเนมสเปซ Spring Batch
งาน
แท็กนี้ใช้เพื่อกำหนด / กำหนดค่างานของ SpringBatch ประกอบด้วยชุดขั้นตอนและสามารถเปิดใช้งานได้โดยใช้ JobLauncher
แท็กนี้มี 2 แอตทริบิวต์ตามรายการด้านล่าง -
ส. เลขที่ | คุณสมบัติและคำอธิบาย |
---|---|
1 | Id เป็นรหัสของงานจำเป็นต้องระบุค่าให้กับแอตทริบิวต์นี้ |
2 | restartable นี่คือแอตทริบิวต์ที่ใช้เพื่อระบุว่างานนั้นสามารถเริ่มต้นใหม่ได้หรือไม่ แอตทริบิวต์นี้เป็นทางเลือก |
ต่อไปนี้คือการกำหนดค่า XML ของงานของ SpringBatch
<job id = "jobid" restartable = "false" >
. . . . . . . .
. . . . . . . .
. . . . . . . . // Step definitions
</job>
ขั้นตอน
แท็กนี้ใช้เพื่อกำหนด / กำหนดค่าขั้นตอนของงาน SpringBatch มีคุณสมบัติสามประการดังต่อไปนี้ -
ส. เลขที่ | คุณสมบัติและคำอธิบาย |
---|---|
1 | Id เป็นรหัสของงานจำเป็นต้องระบุค่าให้กับแอตทริบิวต์นี้ |
2 | next เป็นทางลัดเพื่อระบุขั้นตอนต่อไป |
3 | parent ใช้เพื่อระบุชื่อของ parent bean ซึ่งการกำหนดค่าควรสืบทอด |
ต่อไปนี้คือการกำหนดค่า XML ของขั้นตอนของ SpringBatch
<job id = "jobid">
<step id = "step1" next = "step2"/>
<step id = "step2" next = "step3"/>
<step id = "step3"/>
</job>
ก้อน
แท็กนี้ใช้เพื่อกำหนด / กำหนดค่าส่วนของไฟล์ tasklet. มีคุณสมบัติสี่ประการดังต่อไปนี้ -
ส. เลขที่ | คุณสมบัติและคำอธิบาย |
---|---|
1 | reader แสดงถึงชื่อของถั่วผู้อ่านรายการ ยอมรับค่าของประเภทorg.springframework.batch.item.ItemReader. |
2 | writer แสดงถึงชื่อของถั่วผู้อ่านรายการ ยอมรับค่าของประเภทorg.springframework.batch.item.ItemWriter. |
3 | processor แสดงถึงชื่อของถั่วผู้อ่านรายการ ยอมรับค่าของประเภทorg.springframework.batch.item.ItemProcessor. |
4 | commit-interval ใช้เพื่อระบุจำนวนรายการที่ต้องดำเนินการก่อนที่จะทำธุรกรรม |
ต่อไปนี้คือการกำหนดค่า XML ของส่วนของ SpringBatch
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "xmlItemReader"
writer = "mysqlItemWriter" processor = "itemProcessor" commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>
JobRepository
JobRepository Bean ใช้เพื่อกำหนดค่า JobRepository โดยใช้ฐานข้อมูลเชิงสัมพันธ์ ถั่วนี้เกี่ยวข้องกับคลาสของชนิดorg.springframework.batch.core.repository.JobRepository.
ส. เลขที่ | คุณสมบัติและคำอธิบาย |
---|---|
1 | dataSource ใช้เพื่อระบุชื่อ bean ซึ่งกำหนดแหล่งข้อมูล |
2 | transactionManager ใช้ระบุชื่อของ bean ซึ่งกำหนดตัวจัดการธุรกรรม |
3 | databaseType ระบุชนิดของฐานข้อมูลเชิงสัมพันธ์ที่ใช้ในที่เก็บงาน |
ต่อไปนี้เป็นตัวอย่างการกำหนดค่า JobRepository
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref="transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>
JobLauncher
JobLauncher bean ใช้เพื่อกำหนดค่า JobLauncher มีความเกี่ยวข้องกับคลาสorg.springframework.batch.core.launch.support.SimpleJobLauncher(ในโปรแกรมของเรา). ถั่วนี้มีคุณสมบัติหนึ่งชื่อjobrepositoryและใช้เพื่อระบุชื่อของ bean ซึ่งกำหนด jobrepository.
ต่อไปนี้เป็นตัวอย่างการกำหนดค่า jobLauncher
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
TransactionManager
TransactionManager bean ใช้เพื่อกำหนดค่า TransactionManager โดยใช้ฐานข้อมูลเชิงสัมพันธ์ ถั่วนี้เกี่ยวข้องกับคลาสของชนิดorg.springframework.transaction.platform.TransactionManager.
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />
แหล่งข้อมูล
Datasource bean ใช้เพื่อกำหนดค่าไฟล์ Datasource. ถั่วนี้เกี่ยวข้องกับคลาสของชนิดorg.springframework.jdbc.datasource.DriverManagerDataSource.
ส. เลขที่ | คุณสมบัติและคำอธิบาย |
---|---|
1 | driverClassName สิ่งนี้ระบุชื่อคลาสของไดรเวอร์ที่ใช้เชื่อมต่อกับฐานข้อมูล |
2 | url สิ่งนี้ระบุ URL ของฐานข้อมูล |
3 | username สิ่งนี้ระบุชื่อผู้ใช้เพื่อเชื่อมต่อกับฐานข้อมูล |
4 | password สิ่งนี้ระบุรหัสผ่านเพื่อเชื่อมต่อกับฐานข้อมูล |
ต่อไปนี้เป็นตัวอย่างการกำหนดค่าของไฟล์ datasource.
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>
อัน Item Reader อ่านข้อมูลลงในแอปพลิเคชันชุดสปริงจากแหล่งเฉพาะในขณะที่ไฟล์ Item Writer เขียนข้อมูลจากแอปพลิเคชัน Spring Batch ไปยังปลายทางที่ต้องการ
อัน Item processorเป็นคลาสที่มีรหัสการประมวลผลซึ่งประมวลผลข้อมูลที่อ่านไปยังชุดสปริง หากแอปพลิเคชันอ่าน n บันทึกรหัสในโปรเซสเซอร์จะถูกเรียกใช้ในแต่ละเร็กคอร์ด
ก chunk เป็นองค์ประกอบลูกของ tasklet. ใช้เพื่อดำเนินการอ่านเขียนและประมวลผล เราสามารถกำหนดค่าตัวอ่านตัวเขียนและตัวประมวลผลโดยใช้องค์ประกอบนี้ภายในขั้นตอนดังที่แสดงด้านล่าง
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "cvsFileItemReader" writer = "xmlItemWriter"
processor = "itemProcessor" commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>
Spring Batch ให้ผู้อ่านและนักเขียนอ่านและเขียนข้อมูลจากระบบไฟล์ / ฐานข้อมูลต่างๆเช่น MongoDB, Neo4j, MySQL, XML, flatfile, CSV เป็นต้น
ในการรวมโปรแกรมอ่านไว้ในแอปพลิเคชันของคุณคุณต้องกำหนด bean สำหรับผู้อ่านนั้นระบุค่าให้กับคุณสมบัติที่จำเป็นทั้งหมดภายใน bean และส่งผ่าน id ของ bean ดังกล่าวเป็นค่าแอตทริบิวต์ขององค์ประกอบก้อน reader (เหมือนกันสำหรับ writer).
ItemReader
เป็นเอนทิตีของขั้นตอน (ของกระบวนการแบตช์) ซึ่งอ่านข้อมูล ItemReader อ่านหนึ่งรายการต่อครั้ง Spring Batch มีอินเทอร์เฟซItemReader. ทั้งหมดreaders ใช้อินเทอร์เฟซนี้
ต่อไปนี้เป็นคลาส ItemReader ที่กำหนดไว้ล่วงหน้าที่ Spring Batch จัดเตรียมไว้ให้อ่านจากแหล่งต่างๆ
ผู้อ่าน | วัตถุประสงค์ |
---|---|
FlatFIleItemReader | ในการอ่านข้อมูลจากไฟล์แบบแบน |
StaxEventItemReader | เพื่ออ่านข้อมูลจากไฟล์ XML |
StoredProcedureItemReader | เพื่ออ่านข้อมูลจากขั้นตอนการจัดเก็บของฐานข้อมูล |
JDBCPagingItemReader | เพื่ออ่านข้อมูลจากฐานข้อมูลเชิงสัมพันธ์ |
MongoItemReader | ในการอ่านข้อมูลจาก MongoDB |
Neo4jItemReader | ในการอ่านข้อมูลจาก Neo4jItemReader |
เราจำเป็นต้องกำหนดค่าไฟล์ ItemReadersโดยการสร้างถั่ว ต่อไปนี้เป็นตัวอย่างของStaxEventItemReader ซึ่งอ่านข้อมูลจากไฟล์ XML
<bean id = "mysqlItemWriter"
class = "org.springframework.batch.item.xml.StaxEventItemWriter">
<property name = "resource" value = "file:xml/outputs/userss.xml" />
<property name = "marshaller" ref = "reportMarshaller" />
<property name = "rootTagName" value = "Tutorial" />
</bean>
<bean id = "reportMarshaller"
class = "org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name = "classesToBeBound">
<list>
<value>Tutorial</value>
</list>
</property>
</bean>
ตามที่สังเกตในขณะกำหนดค่าเราจำเป็นต้องระบุชื่อคลาสตามลำดับของโปรแกรมอ่านที่ต้องการและเราจำเป็นต้องระบุค่าให้กับคุณสมบัติที่ต้องการทั้งหมด
ItemWriter
มันเป็นองค์ประกอบของ stepของกระบวนการแบตช์ที่เขียนข้อมูล ItemWriter เขียนหนึ่งรายการต่อครั้ง Spring Batch มีอินเทอร์เฟซItemWriter. นักเขียนทั้งหมดใช้อินเทอร์เฟซนี้
ต่อไปนี้เป็นคลาส ItemWriter ที่กำหนดไว้ล่วงหน้าซึ่งจัดทำโดย Spring Batch เพื่ออ่านจากแหล่งต่างๆ
นักเขียน | วัตถุประสงค์ |
---|---|
FlatFIleItemWriter | ในการเขียนข้อมูลลงในไฟล์แบบแบน |
StaxEventItemWriter | ในการเขียนข้อมูลลงในไฟล์ XML |
StoredProcedureItemWriter | เพื่อเขียนข้อมูลลงในขั้นตอนการจัดเก็บของฐานข้อมูล |
JDBCPagingItemWriter | เพื่อเขียนข้อมูลลงในฐานข้อมูลเชิงสัมพันธ์ |
MongoItemWriter | เพื่อเขียนข้อมูลลงใน MongoDB |
Neo4jItemWriter | ในการเขียนข้อมูลลงใน Neo4j |
ในทำนองเดียวกันเราต้องกำหนดค่า ItemWriters ด้วยการสร้างถั่ว ต่อไปนี้เป็นตัวอย่างของJdbcCursorItemReader ซึ่งเขียนข้อมูลไปยังฐานข้อมูล MySQL
<bean id = "dbItemReader"
class = "org.springframework.batch.item.database.JdbcCursorItemReader" scope = "step">
<property name = "dataSource" ref = "dataSource" />
<property name = "sql" value = "select * from tutorialsdata" />
<property name = "rowMapper">
<bean class = "TutorialRowMapper" />
</property>
</bean>
ตัวประมวลผลรายการ
ItemProcessor: ItemProcessor ใช้ในการประมวลผลข้อมูล เมื่อสินค้าที่ระบุไม่ถูกต้องจะส่งคืนnullมิฉะนั้นจะประมวลผลรายการที่กำหนดและส่งคืนผลลัพธ์ที่ประมวลผล อินเทอร์เฟซItemProcessor<I,O> แสดงถึงโปรเซสเซอร์
Tasklet class - เมื่อไม่มี reader และ writerได้รับ Tasklet ทำหน้าที่เป็นโปรเซสเซอร์สำหรับ SpringBatch มันประมวลผลงานเดียวเท่านั้น
เราสามารถกำหนดตัวประมวลผลรายการที่กำหนดเองได้โดยใช้อินเทอร์เฟซ ItemProcessor ของแพ็คเกจ org.springframework.batch.item.ItemProcessor. คลาส ItemProcessor นี้ยอมรับอ็อบเจ็กต์และประมวลผลข้อมูลและส่งคืนข้อมูลที่ประมวลผลเป็นอ็อบเจ็กต์อื่น
ในกระบวนการแบทช์ถ้า "n"เร็กคอร์ดหรือองค์ประกอบข้อมูลจะถูกอ่านจากนั้นสำหรับแต่ละเร็กคอร์ดจะอ่านข้อมูลประมวลผลและเขียนข้อมูลในตัวเขียน ในการประมวลผลข้อมูลจะถ่ายทอดผ่านโปรเซสเซอร์ที่ส่งผ่าน
ตัวอย่างเช่นสมมติว่าคุณได้เขียนโค้ดเพื่อโหลดเอกสาร PDF โดยเฉพาะสร้างหน้าใหม่เขียนรายการข้อมูลลงใน PDF ในรูปแบบตาราง หากคุณเรียกใช้แอปพลิเคชันนี้แอปพลิเคชันนี้จะอ่านรายการข้อมูลทั้งหมดจากเอกสาร XML จัดเก็บไว้ในฐานข้อมูล MySQL และพิมพ์ในเอกสาร PDF ที่กำหนดในแต่ละหน้า
ตัวอย่าง
ต่อไปนี้เป็นคลาส ItemProcessor ตัวอย่าง
import org.springframework.batch.item.ItemProcessor;
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
return item;
}
}
บทนี้จะแสดงแอปพลิเคชัน Spring Batch พื้นฐาน มันจะเรียกใช้ไฟล์tasklet เพื่อแสดงข้อความ
แอปพลิเคชัน Spring Batch ของเรามีไฟล์ดังต่อไปนี้ -
Configuration file- นี่คือไฟล์ XML ที่เรากำหนดงานและขั้นตอนของงาน (หากแอปพลิเคชันเกี่ยวข้องกับผู้อ่านและนักเขียนด้วยการกำหนดค่าของไฟล์readers และ writers รวมอยู่ในไฟล์นี้ด้วย)
Context.xml - ในไฟล์นี้เราจะกำหนดถั่วเช่นที่เก็บงานตัวเรียกใช้งานและตัวจัดการธุรกรรม
Tasklet class - ในคลาสนี้เราจะเขียนโค้ดการประมวลผล (ในกรณีนี้จะแสดงข้อความธรรมดา)
Launcher class - ในคลาสนี้เราจะเปิดตัว Batch Application โดยเรียกใช้งาน Job launcher
jobConfig.xml
ต่อไปนี้เป็นไฟล์กำหนดค่าของแอปพลิเคชัน Spring Batch ตัวอย่างของเรา
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd ">
<import resource="context.xml" />
<!-- Defining a bean -->
<bean id = "tasklet" class = "a_sample.MyTasklet" />
<!-- Defining a job-->
<batch:job id = "helloWorldJob">
<!-- Defining a Step -->
<batch:step id = "step1">
<tasklet ref = "tasklet"/>
</batch:step>
</batch:job>
</beans>
Context.xml
ต่อไปนี้คือไฟล์ context.xml ของแอปพลิเคชัน Spring Batch ของเรา
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<bean id = "jobRepository"
class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean">
<property name = "transactionManager" ref = "transactionManager" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
</beans>
Tasklet.java
ต่อไปนี้เป็นคลาส Tasklet ซึ่งแสดงข้อความง่ายๆ
import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
public class MyTasklet implements Tasklet {
@Override
public RepeatStatus execute(StepContribution arg0, ChunkContext arg1) throws Exception {
System.out.println("Hello This is a sample example of spring batch");
return RepeatStatus.FINISHED;
}
}
App.java
ต่อไปนี้เป็นรหัสที่เรียกใช้กระบวนการแบทช์
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args)throws Exception {
// System.out.println("hello");
String[] springConfig = {"a_sample/job_hello_world.xml"};
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}
ในการดำเนินการโปรแกรม SpringBatch ข้างต้นจะสร้างผลลัพธ์ต่อไปนี้ -
Apr 24, 2017 4:40:54 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO:Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@2ef1e4fa: startup date [Mon Apr 24 16:40:54 IST 2017]; root of context hierarchy
Apr 24, 2017 4:40:54 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions INFO: Loading XML bean definitions
Apr 24, 2017 4:40:54 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions
Apr 24, 2017 4:40:54 PM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
Apr 24, 2017 4:40:55 PM org.springframework.batch.core.launch.support.SimpleJobLauncher afterPropertiesSet
INFO: No TaskExecutor has been set, defaulting to synchronous executor.
Apr 24, 2017 4:40:55 PM org.springframework.batch.core.launch.support.SimpleJobLauncher$1 run
INFO: Job: [FlowJob: [name=helloWorldJob]] launched with the following parameters: [{}]
Apr 24, 2017 4:40:55 PM org.springframework.batch.core.job.SimpleStepHandler handleStep INFO: Executing step: [step1]
Hello This is a sample example of spring batch
Apr 24, 2017 4:40:55 PM org.springframework.batch.core.launch.support.SimpleJobLauncher$1 run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters: [{}] and the following status: [COMPLETED]
Exit Status : COMPLETED
ในบทนี้เราจะสร้างแอปพลิเคชัน Spring Batch ซึ่งใช้ XML Reader และ MySQL Writer
Reader - ผู้อ่านที่เราใช้ในแอปพลิเคชันคือ StaxEventItemReader เพื่ออ่านข้อมูลจากเอกสาร XML
ต่อไปนี้เป็นเอกสารอินพุต XML ที่เราใช้ในแอปพลิเคชันนี้ เอกสารนี้เก็บบันทึกข้อมูลซึ่งระบุรายละเอียดเช่นรหัสการสอนผู้เขียนบทช่วยสอนชื่อบทช่วยสอนวันที่ส่งไอคอนบทแนะนำและคำอธิบายบทช่วยสอน
<?xml version="1.0" encoding="UTF-8"?>
<tutorials>
<tutorial>
<tutorial_id>1001</tutorial_id>
<tutorial_author>Sanjay</tutorial_author>
<tutorial_title>Learn Java</tutorial_title>
<submission_date>06-05-2007</submission_date>
<tutorial_icon>https://www.tutorialspoint.com/java/images/java-minilogo.jpg</tutorial_icon>
<tutorial_description>Java is a high-level programming language originally
developed by Sun Microsystems and released in 1995.
Java runs on a variety of platforms.
This tutorial gives a complete understanding of Java.');</tutorial_description>
</tutorial>
<tutorial>
<tutorial_id>1002</tutorial_id>
<tutorial_author>Abdul S</tutorial_author>
<tutorial_title>Learn MySQL</tutorial_title>
<submission_date>19-04-2007</submission_date>
<tutorial_icon>https://www.tutorialspoint.com/mysql/images/mysql-minilogo.jpg</tutorial_icon>
<tutorial_description>MySQL is the most popular
Open Source Relational SQL database management system.
MySQL is one of the best RDBMS being used for developing web-based software applications.
This tutorial will give you quick start with MySQL
and make you comfortable with MySQL programming.</tutorial_description>
</tutorial>
<tutorial>
<tutorial_id>1003</tutorial_id>
<tutorial_author>Krishna Kasyap</tutorial_author>
<tutorial_title>Learn JavaFX</tutorial_title>
<submission_date>06-07-2017</submission_date>
<tutorial_icon>https://www.tutorialspoint.com/javafx/images/javafx-minilogo.jpg</tutorial_icon>
<tutorial_description>JavaFX is a Java library used to build Rich Internet Applications.
The applications developed using JavaFX can run on various devices
such as Desktop Computers, Mobile Phones, TVs, Tablets, etc.
This tutorial, discusses all the necessary elements of JavaFX that are required
to develop effective Rich Internet Applications</tutorial_description>
</tutorial>
</tutorials>
Writer - writer ที่เราใช้ในแอปพลิเคชั่นคือ JdbcBatchItemWriterเพื่อเขียนข้อมูลไปยังฐานข้อมูล MySQL สมมติว่าเราได้สร้างตารางใน MySQL ภายในฐานข้อมูลที่เรียกว่า"details".
CREATE TABLE details.TUTORIALS(
tutorial_id int(10) NOT NULL,
tutorial_author VARCHAR(20),
tutorial_title VARCHAR(50),
submission_date VARCHAR(20),
tutorial_icon VARCHAR(200),
tutorial_description VARCHAR(1000)
);
Processor - โปรเซสเซอร์ที่เราใช้ในแอปพลิเคชันเป็นโปรเซสเซอร์ที่กำหนดเองซึ่งเขียนข้อมูลของแต่ละเร็กคอร์ดในเอกสาร PDF
ในกระบวนการแบทช์ถ้า "n"มีการอ่านบันทึกหรือองค์ประกอบข้อมูลจากนั้นสำหรับแต่ละระเบียนจะอ่านข้อมูลประมวลผลและเขียนข้อมูลใน Writer ในการประมวลผลข้อมูลจะถ่ายทอดผ่านโปรเซสเซอร์ที่ส่งผ่าน ในกรณีนี้ในคลาสโปรเซสเซอร์ที่กำหนดเองเราได้เขียนโค้ดเพื่อโหลดเอกสาร PDF โดยเฉพาะสร้างเพจใหม่เขียนรายการข้อมูลลงใน PDF ในรูปแบบตาราง
สุดท้ายหากคุณใช้งานแอปพลิเคชันนี้แอปพลิเคชันนี้จะอ่านรายการข้อมูลทั้งหมดจากเอกสาร XML เก็บไว้ในฐานข้อมูล MySQL และพิมพ์ลงในเอกสาร PDF ที่กำหนดในแต่ละหน้า
jobConfig.xml
ต่อไปนี้เป็นไฟล์กำหนดค่าของแอปพลิเคชัน Spring Batch ตัวอย่างของเรา ในไฟล์นี้เราจะกำหนด Job และขั้นตอนต่างๆ นอกจากนี้เรายังกำหนดถั่วสำหรับ ItemReader, ItemProcessor และ ItemWriter (ที่นี่เราเชื่อมโยงพวกเขากับคลาสตามลำดับและส่งผ่านค่าสำหรับคุณสมบัติที่ต้องการเพื่อกำหนดค่า)
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:util = "http://www.springframework.org/schema/util"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-3.0.xsd ">
<import resource = "../jobs/context.xml" />
<bean id = "itemProcessor" class = "CustomItemProcessor" />
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "xmlItemReader" writer = "mysqlItemWriter" processor = "itemProcessor">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>
<bean id = "xmlItemReader"
class = "org.springframework.batch.item.xml.StaxEventItemReader">
<property name = "fragmentRootElementName" value = "tutorial" />
<property name = "resource" value = "classpath:resources/tutorial.xml" />
<property name = "unmarshaller" ref = "customUnMarshaller" />
</bean>
<bean id = "customUnMarshaller" class = "org.springframework.oxm.xstream.XStreamMarshaller">
<property name = "aliases">
<util:map id = "aliases">
<entry key = "tutorial" value = "Tutorial" />
</util:map>
</property>
</bean>
<bean id = "mysqlItemWriter" class = "org.springframework.batch.item.database.JdbcBatchItemWriter">
<property name = "dataSource" ref = "dataSource" />
<property name = "sql">
<value>
<![CDATA[insert into details.tutorials (tutorial_id, tutorial_author, tutorial_title,
submission_date, tutorial_icon, tutorial_description)
values (:tutorial_id, :tutorial_author, :tutorial_title, :submission_date,
:tutorial_icon, :tutorial_description);]]>
</value>
</property>
<property name = "itemSqlParameterSourceProvider">
<bean class = "org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider" />
</property>
</bean>
</beans>
Context.xml
ต่อไปนี้คือไฟล์ context.xmlของแอปพลิเคชัน Spring Batch ของเรา ในไฟล์นี้เราจะกำหนดถั่วเช่นที่เก็บงานตัวเรียกใช้งานและตัวจัดการธุรกรรม
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:jdbc = "http://www.springframework.org/schema/jdbc"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd">
<!-- stored job-meta in database -->
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref = "transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionMana ger" />
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
<!-- connect to MySQL database -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>
<!-- create job-meta tables automatically -->
<jdbc:initialize-database data-source = "dataSource">
<jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql"/>
<jdbc:script location = "org/springframework/batch/core/schema-mysql.sql"/>
</jdbc:initialize-database>
</beans>
CustomItemProcessor.java
ต่อไปนี้คือไฟล์ processorชั้นเรียน ในคลาสนี้เราเขียนโค้ดการประมวลผลในแอปพลิเคชัน ที่นี่เรากำลังโหลดเอกสาร PDF สร้างเพจใหม่สร้างตารางและแทรกค่าต่อไปนี้สำหรับแต่ละเร็กคอร์ด id บทช่วยสอนชื่อบทช่วยสอนผู้แต่งวันที่ส่งในตาราง
import java.io.File;
import java.io.IOException;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.PDPageContentStream;
import org.apache.pdfbox.pdmodel.font.PDType1Font;
import org.springframework.batch.item.ItemProcessor;
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
public static void drawTable(PDPage page, PDPageContentStream contentStream,
float y, float margin, String[][] content) throws IOException {
final int rows = content.length;
final int cols = content[0].length;
final float rowHeight = 50;
final float tableWidth = page.getMediaBox().getWidth()-(2*margin);
final float tableHeight = rowHeight * rows;
final float colWidth = tableWidth/(float)cols;
final float cellMargin=5f;
// draw the rows
float nexty = y ;
for (int i = 0; i <= rows; i++) {
contentStream.drawLine(margin,nexty,margin+tableWidth,nexty);
nexty-= rowHeight;
}
//draw the columns
float nextx = margin;
for (int i = 0; i <= cols; i++) {
contentStream.drawLine(nextx,y,nextx,y-tableHeight);
nextx += colWidth;
}
// now add the text
contentStream.setFont(PDType1Font.HELVETICA_BOLD,12);
float textx = margin+cellMargin;
float texty = y-15;
for(int i = 0; i < content.length; i++){
for(int j = 0 ; j < content[i].length; j++){
String text = content[i][j];
contentStream.beginText();
contentStream.moveTextPositionByAmount(textx,texty);
contentStream.drawString(text);
contentStream.endText();
textx += colWidth;
}
texty-=rowHeight;
textx = margin+cellMargin;
}
}
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
// Creating PDF document object
PDDocument doc = PDDocument.load(new File("C:/Examples/test.pdf"));
// Creating a blank page
PDPage page = new PDPage();
doc.addPage( page );
PDPageContentStream contentStream = new PDPageContentStream(doc, page);
String[][] content = {{"Id",""+item.getTutorial_id()},
{"Title", item.getTutorial_title()},
{"Authour", item.getTutorial_author()},
{"Submission Date", item.getSubmission_date()}} ;
drawTable(page, contentStream, 700, 100, content);
contentStream.close();
doc.save("C:/Examples/test.pdf" );
System.out.println("Hello");
return item;
}
}
TutorialFieldSetMapper.java
ต่อไปนี้คือคลาส ReportFieldSetMapper ซึ่งตั้งค่าข้อมูลเป็นคลาส Tutorial
import org.springframework.batch.item.file.mapping.FieldSetMapper;
import org.springframework.batch.item.file.transform.FieldSet;
import org.springframework.validation.BindException;
public class TutorialFieldSetMapper implements FieldSetMapper<Tutorial> {
@Override
public Tutorial mapFieldSet(FieldSet fieldSet) throws BindException {
// instantiating the Tutorial class
Tutorial tutorial = new Tutorial();
// Setting the fields from XML
tutorial.setTutorial_id(fieldSet.readInt(0));
tutorial.setTutorial_title(fieldSet.readString(1));
tutorial.setTutorial_author(fieldSet.readString(2));
tutorial.setTutorial_icon(fieldSet.readString(3));
tutorial.setTutorial_description(fieldSet.readString(4));
return tutorial;
}
}
Tutorial.java
ต่อไปนี้คือไฟล์ Tutorialชั้นเรียน เป็นคลาสง่ายๆด้วยsetter และ getter วิธีการ
public class Tutorial {
private int tutorial_id;
private String tutorial_author;
private String tutorial_title;
private String submission_date;
private String tutorial_icon;
private String tutorial_description;
@Override
public String toString() {
return " [id=" + tutorial_id + ", author=" + tutorial_author
+ ", title=" + tutorial_title + ", date=" + submission_date + ", icon ="
+tutorial_icon +", description = "+tutorial_description+"]";
}
public int getTutorial_id() {
return tutorial_id;
}
public void setTutorial_id(int tutorial_id) {
this.tutorial_id = tutorial_id;
}
public String getTutorial_author() {
return tutorial_author;
}
public void setTutorial_author(String tutorial_author) {
this.tutorial_author = tutorial_author;
}
public String getTutorial_title() {
return tutorial_title;
}
public void setTutorial_title(String tutorial_title) {
this.tutorial_title = tutorial_title;
}
public String getSubmission_date() {
return submission_date;
}
public void setSubmission_date(String submission_date) {
this.submission_date = submission_date;
}
public String getTutorial_icon() {
return tutorial_icon;
}
public void setTutorial_icon(String tutorial_icon) {
this.tutorial_icon = tutorial_icon;
}
public String getTutorial_description() {
return tutorial_description;
}
public void setTutorial_description(String tutorial_description) {
this.tutorial_description = tutorial_description;
}
}
App.java
ต่อไปนี้เป็นรหัสที่เรียกใช้กระบวนการแบทช์ ในคลาสนี้เราจะเปิด Batch Application โดยเรียกใช้ JobLauncher
public class App {
public static void main(String[] args) throws Exception {
String[] springConfig = { "jobs/job_hello_world.xml" };
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}
ในการเรียกใช้แอปพลิเคชันนี้จะให้ผลลัพธ์ดังต่อไปนี้
May 05, 2017 4:39:22 PM org.springframework.context.support.ClassPathXmlApplicationContext
prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@306a30c7:
startup date [Fri May 05 16:39:22 IST 2017]; root of context hierarchy
May 05, 2017 4:39:23 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
May 05, 2017 4:39:32 PM org.springframework.batch.core.job.SimpleStepHandler handleStep
INFO: Executing step: [step1]
Processing... [id=1001, author=Sanjay, title=Learn Java, date=06-05-2007,
icon =https://www.tutorialspoint.com/java/images/java-mini-logo.jpg,
description = Java is a high-level programming language originally developed by Sun Microsystems
and released in 1995. Java runs on a variety of platforms.
This tutorial gives a complete understanding of Java.');]
Hello
Processing.. [id=1002, author=Abdul S, title=Learn MySQL, date=19-04-2007,
icon =https://www.tutorialspoint.com/mysql/images/mysql-mini-logo.jpg,
description = MySQL is the most popular Open Source Relational SQL database management system.
MySQL is one of the best RDBMS being used for developing web-based software applications.
This tutorial will give you quick start with MySQL and make you comfortable with MySQL programming.]
Hello
Processing... [id=1003, author=Krishna Kasyap, title=Learn JavaFX, date=06-072017,
icon =https://www.tutorialspoint.com/javafx/images/javafx-mini-logo.jpg,
description = JavaFX is a Java library used to build Rich Internet Applications.
The applications developed using JavaFX can run on various devices
such as Desktop Computers, Mobile Phones, TVs, Tablets, etc.
This tutorial, discusses all the necessary elements of JavaFX
that are required to develop effective Rich Internet Applications]
Hello
May 05, 2017 4:39:36 PM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters: [{}]
and the following status: [COMPLETED]
Exit Status : COMPLETED
หากคุณตรวจสอบไฟล์ details.tutorial ตารางในฐานข้อมูลจะแสดงผลลัพธ์ต่อไปนี้ -
กวดวิชา _id | กวดวิชา _author | กวดวิชา _title | วันที่ยื่น | กวดวิชา _icon | กวดวิชา _description |
---|---|---|---|---|---|
1001 | ซานเจย์ | เรียนรู้ Java | 06-05-2007 | https: //www.tutorials point. com / java / images / java-mini-logo.jpg | Java เป็นภาษาโปรแกรมระดับสูงที่พัฒนาโดย Sun Microsystems และเผยแพร่ในปี 1995 Java ทำงานบนแพลตฟอร์มที่หลากหลาย บทช่วยสอนนี้ช่วยให้เข้าใจ Java ได้อย่างสมบูรณ์ |
1002 | อับดุลส | เรียนรู้ MySQL | 19-04-2550 | https: // www. tutorialspoint.com / mysql / images /mysql-minilogo.jpg | MySQL เป็นระบบจัดการฐานข้อมูล Open Source Relational SQL ที่ได้รับความนิยมสูงสุด MySQL เป็นหนึ่งใน RDBMS ที่ดีที่สุดที่ใช้สำหรับการพัฒนาแอพพลิเคชั่นซอฟต์แวร์บนเว็บ บทช่วยสอนนี้จะช่วยให้คุณเริ่มต้นใช้งาน MySQL ได้อย่างรวดเร็วและทำให้คุณสบายใจกับการเขียนโปรแกรม MySQL |
1003 | เรียนรู้ JavaFX | กฤษณะ Kasyap | 06-07-2560 | https: // www. tutorialspoint.com / javafx / images / javafx-minilogo.jpg | MySQL เป็นระบบจัดการฐานข้อมูล Open Source Relational SQL ที่ได้รับความนิยมสูงสุด MySQL เป็นหนึ่งใน RDBMS ที่ดีที่สุดที่ใช้สำหรับการพัฒนาแอพพลิเคชั่นซอฟต์แวร์บนเว็บ บทช่วยสอนนี้จะช่วยให้คุณเริ่มต้นใช้งาน MySQL ได้อย่างรวดเร็วและทำให้คุณสบายใจกับการเขียนโปรแกรม MySQL |
สิ่งนี้จะสร้าง PDF พร้อมบันทึกในแต่ละหน้าดังที่แสดงด้านล่าง
ในบทนี้เราจะสร้างแอปพลิเคชัน Spring Batch แบบง่ายซึ่งใช้ CSV Reader และ XML Writer
Reader - reader ที่เราใช้ในแอปพลิเคชั่นคือ FlatFileItemReader เพื่ออ่านข้อมูลจากไฟล์ CSV
ต่อไปนี้เป็นไฟล์ CSV อินพุตที่เราใช้ในแอปพลิเคชันนี้ เอกสารนี้เก็บบันทึกข้อมูลซึ่งระบุรายละเอียดเช่นรหัสการสอนผู้เขียนบทแนะนำชื่อบทช่วยสอนวันที่ส่งไอคอนบทแนะนำและคำอธิบายบทช่วยสอน
1001, "Sanjay", "Learn Java", 06/05/2007
1002, "Abdul S", "Learn MySQL", 19/04/2007
1003, "Krishna Kasyap", "Learn JavaFX", 06/07/2017
Writer - Writer ที่เราใช้ในแอปพลิเคชันคือ StaxEventItemWriter เพื่อเขียนข้อมูลลงในไฟล์ XML
Processor - โปรเซสเซอร์ที่เราใช้ในแอปพลิเคชันเป็นโปรเซสเซอร์แบบกำหนดเองซึ่งพิมพ์บันทึกที่อ่านจากไฟล์ CSV
jobConfig.xml
ต่อไปนี้เป็นไฟล์กำหนดค่าของแอปพลิเคชัน Spring Batch ตัวอย่างของเรา ในไฟล์นี้เราจะกำหนด Job และขั้นตอนต่างๆ นอกจากนี้เรายังกำหนดถั่วสำหรับ ItemReader, ItemProcessor และ ItemWriter (ที่นี่เราเชื่อมโยงกับคลาสที่เกี่ยวข้องและส่งผ่านค่าสำหรับคุณสมบัติที่ต้องการเพื่อกำหนดค่า)
<beans xmlns = " http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<import resource = "../jobs/context.xml" />
<bean id = "report" class = "Report" scope = "prototype" />
<bean id = "itemProcessor" class = "CustomItemProcessor" />
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "cvsFileItemReader" writer = "xmlItemWriter"
processor = "itemProcessor" commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>
<bean id = "cvsFileItemReader"
class = "org.springframework.batch.item.file.FlatFileItemReader">
<property name = "resource" value = "classpath:resources/report.csv" />
<property name = "lineMapper">
<bean
class = "org.springframework.batch.item.file.mapping.DefaultLineMapper">
<property name = "lineTokenizer">
<bean
class = "org.springframework.batch.item.file.transform.DelimitedLineTokenizer">
<property name = "names" value = "tutorial_id,
tutorial_author, Tutorial_title, submission_date" />
</bean>
</property>
<property name = "fieldSetMapper">
<bean class = "ReportFieldSetMapper" />
</property>
</bean>
</property>
</bean>
<bean id = "xmlItemWriter"
class = "org.springframework.batch.item.xml.StaxEventItemWriter">
<property name = "resource" value = "file:xml/outputs/tutorials.xml" />
<property name = "marshaller" ref = "reportMarshaller" />
<property name = "rootTagName" value = "tutorials" />
</bean>
<bean id = "reportMarshaller"
class = "org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name = "classesToBeBound">
<list>
<value>Tutorial</value>
</list>
</property>
</bean>
</beans>
Context.xml
ต่อไปนี้คือไฟล์ context.xmlของแอปพลิเคชัน Spring Batch ของเรา ในไฟล์นี้เราจะกำหนดถั่วเช่นที่เก็บงานตัวเรียกใช้งานและตัวจัดการธุรกรรม
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:jdbc = "http://www.springframework.org/schema/jdbc"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd">
<!-- stored job-meta in database -->
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref = "transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
<bean id = "dataSource" class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>
<!-- create job-meta tables automatically -->
<jdbc:initialize-database data-source = "dataSource">
<jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql" />
<jdbc:script location = "org/springframework/batch/core/schema-mysql.sql" />
</jdbc:initialize-database>
</beans>
CustomItemProcessor.java
ต่อไปนี้เป็นคลาสโปรเซสเซอร์ ในคลาสนี้เราเขียนโค้ดการประมวลผลในแอปพลิเคชัน ที่นี่เรากำลังพิมพ์เนื้อหาของแต่ละบันทึก
import org.springframework.batch.item.ItemProcessor;
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
return item;
}
}
TutorialFieldSetMapper.java
ต่อไปนี้เป็นคลาส TutorialFieldSetMapper ซึ่งตั้งค่าข้อมูลเป็นคลาส Tutorial
import org.springframework.batch.item.file.mapping.FieldSetMapper;
import org.springframework.batch.item.file.transform.FieldSet;
import org.springframework.validation.BindException;
public class TutorialFieldSetMapper implements FieldSetMapper<Tutorial> {
@Override
public Tutorial mapFieldSet(FieldSet fieldSet) throws BindException {
//Instantiating the report object
Tutorial tutorial = new Tutorial();
//Setting the fields
tutorial.setTutorial_id(fieldSet.readInt(0));
tutorial.setTutorial_author(fieldSet.readString(1));
tutorial.setTutorial_title(fieldSet.readString(2));
tutorial.setSubmission_date(fieldSet.readString(3));
return tutorial;
}
}
คลาส Tutorial.java
ต่อไปนี้คือไฟล์ Tutorialชั้นเรียน มันเป็นคลาส Java ง่ายๆที่มีไฟล์setter และ getterวิธีการ ในคลาสนี้เรากำลังใช้คำอธิบายประกอบเพื่อเชื่อมโยงเมธอดของคลาสนี้กับแท็กของไฟล์ XML
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "tutorial")
public class Tutorial {
private int tutorial_id;
private String tutorial_author;
private String tutorial_title;
private String submission_date;
@XmlAttribute(name = "tutorial_id")
public int getTutorial_id() {
return tutorial_id;
}
public void setTutorial_id(int tutorial_id) {
this.tutorial_id = tutorial_id;
}
@XmlElement(name = "tutorial_author")
public String getTutorial_author() {
return tutorial_author;
}
public void setTutorial_author(String tutorial_author) {
this.tutorial_author = tutorial_author;
}
@XmlElement(name = "tutorial_title")
public String getTutorial_title() {
return tutorial_title;
}
public void setTutorial_title(String tutorial_title) {
this.tutorial_title = tutorial_title;
}
@XmlElement(name = "submission_date")
public String getSubmission_date() {
return submission_date;
}
public void setSubmission_date(String submission_date) {
this.submission_date = submission_date;
}
@Override
public String toString() {
return " [Tutorial id=" + tutorial_id + ",
Tutorial Author=" + tutorial_author + ",
Tutorial Title=" + tutorial_title + ",
Submission Date=" + submission_date + "]";
}
}
App.java
ต่อไปนี้เป็นรหัสที่เรียกใช้กระบวนการแบทช์ ในคลาสนี้เราจะเปิดแอปพลิเคชันชุดงานโดยเรียกใช้ JobLauncher
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args) throws Exception {
String[] springConfig = { "jobs/job_hello_world.xml" };
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}
ในการเรียกใช้แอปพลิเคชันนี้จะให้ผลลัพธ์ดังต่อไปนี้
May 08, 2017 10:10:12 AM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing
org.springframework.context.support.ClassPathXmlApplicationContext@3d646c37: startup date
[Mon May 08 10:10:12 IST 2017]; root of context hierarchy
May 08, 2017 10:10:12 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
May 08, 2017 10:10:15 AM org.springframework.jdbc.datasource.init.ScriptUtils executeSqlScript
INFO: Executing step: [step1]
Processing... [Tutorial id=1001, Tutorial Author=Sanjay,
Tutorial Title=Learn Java, Submission Date=06/05/2007]
Processing... [Tutorial id=1002, Tutorial Author=Abdul S,
Tutorial Title=Learn MySQL, Submission Date=19/04/2007]
Processing... [Tutorial id=1003, Tutorial Author=Krishna Kasyap,
Tutorial Title=Learn JavaFX, Submission Date=06/07/2017]
May 08, 2017 10:10:21 AM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters:
[{}] and the following status: [COMPLETED]
Exit Status : COMPLETED
สิ่งนี้จะสร้างไฟล์ XML ที่มีเนื้อหาต่อไปนี้
<?xml version = "1.0" encoding = "UTF-8"?>
<tutorials>
<tutorial tutorial_id = "1001">
<submission_date>06/05/2007</submission_date>
<tutorial_author>Sanjay</tutorial_author>
<tutorial_title>Learn Java</tutorial_title>
</tutorial>
<tutorial tutorial_id = "1002">
<submission_date>19/04/2007</submission_date>
<tutorial_author>Abdul S</tutorial_author>
<tutorial_title>Learn MySQL</tutorial_title>
</tutorial>
<tutorial tutorial_id = "1003">
<submission_date>06/07/2017</submission_date>
<tutorial_author>Krishna Kasyap</tutorial_author>
<tutorial_title>Learn JavaFX</tutorial_title>
</tutorial>
</tutorials>
ในบทนี้เราจะสร้างแอปพลิเคชัน Spring Batch ซึ่งใช้โปรแกรมอ่าน MySQL และ XML Writer
Reader - ผู้อ่านที่เราใช้ในแอปพลิเคชันคือ JdbcCursorItemReader เพื่ออ่านข้อมูลจากฐานข้อมูล MySQL
สมมติว่าเราได้สร้างตารางในฐานข้อมูล MySQL ดังที่แสดงด้านล่าง -
CREATE TABLE details.xml_mysql(
person_id int(10) NOT NULL,
sales VARCHAR(20),
qty int(3),
staffName VARCHAR(20),
date VARCHAR(20)
);
สมมติว่าเราได้ใส่บันทึกต่อไปนี้เข้าไป
mysql> select * from tutorialsdata;
+-------------+-----------------+----------------+-----------------+
| tutorial_id | tutorial_author | tutorial_title | submission_date |
+-------------+-----------------+----------------+-----------------+
| 101 | Sanjay | Learn Java | 06-05-2007 |
| 102 | Abdul S | Learn MySQL | 19-04-2007 |
| 103 | Krishna Kasyap | Learn JavaFX | 06-07-2017 |
+-------------+-----------------+----------------+-----------------+
3 rows in set (0.00 sec)
Writer - Writer ที่เราใช้ในแอปพลิเคชันคือ StaxEventItemWriter เพื่อเขียนข้อมูลไปยังไฟล์ XML
Processor - โปรเซสเซอร์ที่เราใช้ในแอปพลิเคชันเป็นโปรเซสเซอร์แบบกำหนดเองซึ่งพิมพ์บันทึกที่อ่านจากไฟล์ CSV
jobConfig.xml
ต่อไปนี้เป็นไฟล์กำหนดค่าของแอปพลิเคชัน Spring Batch ตัวอย่างของเรา ในไฟล์นี้เราจะกำหนดงานและขั้นตอน นอกจากนี้เรายังกำหนดถั่วสำหรับ ItemReader, ItemProcessor และ ItemWriter (ที่นี่เราเชื่อมโยงพวกเขากับคลาสตามลำดับและส่งผ่านค่าสำหรับคุณสมบัติที่ต้องการเพื่อกำหนดค่า)
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:util = "http://www.springframework.org/schema/util"
xsi:schemaLocation = " http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<import resource = "../jobs/context.xml" />
<bean id = "report" class = "Report" scope = "prototype" />
<bean id = "itemProcessor" class = "CustomItemProcessor" />
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "dbItemReader"
writer = "mysqlItemWriter" processor = "itemProcessor" commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>
<bean id = "dbItemReader"
class = "org.springframework.batch.item.database.JdbcCursorItemReader" scope = "step">
<property name = "dataSource" ref = "dataSource" />
<property name = "sql" value = "select * from tutorials_data" />
<property name = "rowMapper">
<bean class = "TutorialRowMapper" />
</property>
</bean>
<bean id = "mysqlItemWriter"
class = "org.springframework.batch.item.xml.StaxEventItemWriter">
<property name = "resource" value = "file:xml/outputs/tutorials.xml" />
<property name = "marshaller" ref = "reportMarshaller" />
<property name = "rootTagName" value = "Tutorial" />
</bean>
<bean id = "reportMarshaller" class = "org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name = "classesToBeBound">
<list>
<value>Tutorial</value>
</list>
</property>
</bean>
</beans>
Context.xml
ต่อไปนี้คือไฟล์ context.xmlของแอปพลิเคชัน Spring Batch ของเรา ในไฟล์นี้เราจะกำหนดถั่วเช่นที่เก็บงานตัวเรียกใช้งานและตัวจัดการธุรกรรม
<beans xmlns = " http://www.springframework.org/schema/beans"
xmlns:jdbc = "http://www.springframework.org/schema/jdbc"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd ">
<!-- stored job-meta in database -->
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref = "transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionMana ger" />
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
<!-- connect to MySQL database -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>
<!-- create job-meta tables automatically -->
<jdbc:initialize-database data-source = "dataSource">
<jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql" />
<jdbc:script location = "org/springframework/batch/core/schema-mysql.sql" />
</jdbc:initialize-database>
</beans>
CustomItemProcessor.java
ต่อไปนี้เป็นคลาสโปรเซสเซอร์ ในคลาสนี้เราเขียนโค้ดการประมวลผลในแอปพลิเคชัน ที่นี่เรากำลังพิมพ์เนื้อหาของแต่ละบันทึก
import org.springframework.batch.item.ItemProcessor;
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
return item;
}
}
TutorialRowMapper.java
ต่อไปนี้คือไฟล์ TutorialRowMapper คลาสซึ่งตั้งค่าข้อมูลเป็น Tutorial ชั้นเรียน
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class TutorialRowMapper implements RowMapper<Tutorial> {
@Override
public Tutorial mapRow(ResultSet rs, int rowNum) throws SQLException {
Tutorial tutorial = new Tutorial();
tutorial.setTutorial_id(rs.getInt("tutorial_id"));
tutorial.setTutorial_author(rs.getString("tutorial_author"));
tutorial.setTutorial_title(rs.getString("tutorial_title"));
tutorial.setSubmission_date(rs.getString("submission_date"));
return tutorial;
}
}
Tutorial.java
ต่อไปนี้คือไฟล์ Tutorialชั้นเรียน มันเป็นคลาส Java ง่ายๆที่มีไฟล์setter และ getterวิธีการ ในคลาสนี้เรากำลังใช้คำอธิบายประกอบเพื่อเชื่อมโยงเมธอดของคลาสนี้กับแท็กของไฟล์ XML
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "details")
public class Tutorial {
int tutorial_id;
String tutorial_author;
String submission_date;
@XmlAttribute(name = "tutorial_id")
public int getTutorial_id() {
return tutorial_id;
}
public void setTutorial_id(int tutorial_id) {
this.tutorial_id = tutorial_id;
}
@XmlElement(name = "tutorial_author")
public String getTutorial_author() {
return tutorial_author;
}
public void setTutorial_author(String tutorial_author) {
this.tutorial_author = tutorial_author;
}
@XmlElement(name = "tutorial_title")
public String getTutorial_title() {
return tutorial_title;
}
public void setTutorial_title(String tutorial_title) {
this.tutorial_title = tutorial_title;
}
@XmlElement(name = "submission_date")
public String getSubmission_date() {
return submission_date;
}
public void setSubmission_date(String submission_date) {
this.submission_date = submission_date;
}
public String toString() {
return " [Tutorial Id=" + tutorial_id + ",
Tutorial Author =" + tutorial_author + ",
Tutorial Title =" + tutorial_title + ",
Submission Date =" + submission_date + "]";
}
}
App.java
ต่อไปนี้เป็นรหัสที่เรียกใช้กระบวนการแบทช์ ในคลาสนี้เราจะเปิด Batch Application โดยเรียกใช้ JobLauncher
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args) throws Exception {
String[] springConfig = { "jobs/job_hello_world.xml" };
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}
ในการเรียกใช้แอปพลิเคชันนี้จะให้ผลลัพธ์ดังต่อไปนี้
May 08, 2017 11:32:06 AM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@3d646c37:
startup date [Mon May 08 11:32:06 IST 2017]; root of context hierarchy
May 08, 2017 11:32:06 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [jobs/job_hello_world.xml]
May 08, 2017 11:32:07 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
May 08, 2017 11:32:14 AM org.springframework.batch.core.job.SimpleStepHandler handleStep
INFO: Executing step: [step1]
Processing... [Tutorial Id=101, Tutorial Author=Sanjay,
Tutorial Title=Learn Java, Submission Date=06-05-2007]
Processing... [Tutorial Id=102, Tutorial Author=Abdul S,
Tutorial Title=Learn MySQL, Submission Date=19-04-2007]
Processing... [Tutorial Id=103, Tutorial Author=Krishna Kasyap,
Tutorial Title=Learn JavaFX, Submission Date=06-07-2017]
May 08, 2017 11:32:14 AM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters:
[{}] and the following status: [COMPLETED]
Exit Status : COMPLETED
สิ่งนี้จะสร้างไฟล์ XML ที่มีเนื้อหาต่อไปนี้
<?xml version = "1.0" encoding = "UTF-8"?>
<Tutorial>
<details tutorial_id = "101">
<submission_date>06-05-2007</submission_date>
<tutorial_author>Sanjay</tutorial_author>
<tutorial_title>Learn Java</tutorial_title>
</details>
<details tutorial_id = "102">
<submission_date>19-04-2007</submission_date>
<tutorial_author>Abdul S</tutorial_author>
<tutorial_title>Learn MySQL</tutorial_title>
</details>
<details tutorial_id = "103">
<submission_date>06-07-2017</submission_date>
<tutorial_author>Krishna Kasyap</tutorial_author>
<tutorial_title>Learn JavaFX</tutorial_title>
</details>
</Tutorial>
ในบทนี้เราจะสร้างแอปพลิเคชัน Spring Batch ซึ่งใช้ MySQL Reader และไฟล์ Flatfile นักเขียน (.txt)
Reader - Reader ที่เราใช้ในแอปพลิเคชันคือ JdbcCursorItemReader เพื่ออ่านข้อมูลจากฐานข้อมูล MySQL
สมมติว่าเราได้สร้างตารางในฐานข้อมูล MySQL ดังที่แสดงด้านล่าง
CREATE TABLE details.xml_mysql(
person_id int(10) NOT NULL,
sales VARCHAR(20),
qty int(3),
staffName VARCHAR(20),
date VARCHAR(20)
);
สมมติว่าเราได้ใส่บันทึกต่อไปนี้เข้าไป
mysql> select * from tutorialsdata;
+-------------+-----------------+----------------+-----------------+
| tutorial_id | tutorial_author | tutorial_title | submission_date |
+-------------+-----------------+----------------+-----------------+
| 101 | Sanjay | Learn Java | 06-05-2007 |
| 102 | Abdul S | Learn MySQL | 19-04-2007 |
| 103 | Krishna Kasyap | Learn JavaFX | 06-07-2017 |
+-------------+-----------------+----------------+-----------------+
3 rows in set (0.00 sec)
Writer - Writer ที่เราใช้ในแอปพลิเคชันคือ FlatFileItemWriter เพื่อเขียนข้อมูล flatfile (.txt)
Processor - โปรเซสเซอร์ที่เราใช้ในแอปพลิเคชันเป็นโปรเซสเซอร์แบบกำหนดเองซึ่งพิมพ์บันทึกที่อ่านจากไฟล์ CSV
jobConfig.xml
ต่อไปนี้เป็นไฟล์กำหนดค่าของแอปพลิเคชัน Spring Batch ตัวอย่างของเรา ในไฟล์นี้เราจะกำหนดงานและขั้นตอน นอกจากนี้เรายังกำหนดถั่วสำหรับ ItemReader, ItemProcessor และ ItemWriter (ที่นี่เราเชื่อมโยงกับคลาสที่เกี่ยวข้องและส่งผ่านค่าสำหรับคุณสมบัติที่ต้องการเพื่อกำหนดค่า)
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:util = "http://www.springframework.org/schema/util"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<import resource = "../jobs/context.xml" />
<bean id = "tutorial" class = "Tutorial" scope = "prototype" />
<bean id = "itemProcessor" class = "CustomItemProcessor" />
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "mysqlItemReader"
writer = "flatFileItemWriter" processor = "itemProcessor"
commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>
<bean id = "mysqlItemReader"
class = "org.springframework.batch.item.database.JdbcCursorItemReader" >
<property name = "dataSource" ref = "dataSource" />
<property name = "sql" value = "select * from details.tutorialsdata" />
<property name = "rowMapper">
<bean class = "TutorialRowMapper" />
</property>
</bean>
<bean id = "flatFileItemWriter"
class = " org.springframework.batch.item.file.FlatFileItemWriter">
<property name = "resource" value = "file:target/outputfiles/employee_output.txt"/>
<property name = "lineAggregator">
<bean class = " org.springframework.batch.item.file.transform.PassThroughLineAggregator"/>
</property>
</bean>
</beans>
Context.xml
ต่อไปนี้คือไฟล์ context.xmlของแอปพลิเคชัน Spring Batch ของเรา ในไฟล์นี้เราจะกำหนดถั่วเช่นที่เก็บงานตัวเรียกใช้งานและตัวจัดการธุรกรรม
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:jdbc = "http://www.springframework.org/schema/jdbc"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd ">
<!-- stored job-meta in database -->
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref = "transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
<!-- create job-meta tables automatically -->
<jdbc:initialize-database data-source = "dataSource">
<jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql" />
<jdbc:script location = "org/springframework/batch/core/schema-mysql.sql" />
</jdbc:initialize-database>
</beans>
CustomItemProcessor.java
ต่อไปนี้เป็นคลาสโปรเซสเซอร์ ในคลาสนี้เราเขียนโค้ดการประมวลผลในแอปพลิเคชัน ที่นี่เรากำลังพิมพ์เนื้อหาของแต่ละบันทึก
import org.springframework.batch.item.ItemProcessor;
// Implementing the ItemProcessor interface
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
return item;
}
}
TutorialRowMapper.java
ต่อไปนี้คือไฟล์ TutorialRowMapper คลาสซึ่งตั้งค่าข้อมูลเป็น Tutorial ชั้นเรียน
public class TutorialRowMapper implements RowMapper<Tutorial> {
@Override
public Tutorial mapRow(ResultSet rs, int rowNum) throws SQLException {
Tutorial tutorial = new Tutorial();
tutorial.setTutorial_id(rs.getInt("tutorial_id"));
tutorial.setTutorial_title(rs.getString("tutorial_title"));
tutorial.setTutorial_author(rs.getString("tutorial_author"));
tutorial.setSubmission_date(rs.getString("submission_date"));
return tutorial;
}
}
Tutorial.java
ต่อไปนี้คือไฟล์ Tutorialชั้นเรียน มันเป็นคลาส Java ง่ายๆที่มีไฟล์setter และ getterวิธีการ ในคลาสนี้เรากำลังใช้คำอธิบายประกอบเพื่อเชื่อมโยงเมธอดของคลาสนี้กับแท็กของไฟล์ XML
public class Tutorial {
private int tutorial_id;
private String tutorial_title;
private String tutorial_author;
private String submission_date;
public int getTutorial_id() {
return tutorial_id;
}
public void setTutorial_id(int tutorial_id) {
this.tutorial_id = tutorial_id;
}
public String getTutorial_title() {
return tutorial_title;
}
public void setTutorial_title(String tutorial_title) {
this.tutorial_title = tutorial_title;
}
public String getTutorial_author() {
return tutorial_author;
}
public void setTutorial_author(String tutorial_author) {
this.tutorial_author = tutorial_author;
}
public String getSubmission_date() {
return submission_date;
}
public void setSubmission_date(String submission_date) {
this.submission_date = submission_date;
}
@Override
public String toString() {
return " [id=" + tutorial_id + ", title=" +
tutorial_title + ",
author=" + tutorial_author + ", date=" +
submission_date + "]";
}
}
App.java
ต่อไปนี้เป็นรหัสที่เรียกใช้กระบวนการแบทช์ ในคลาสนี้เราจะเปิด Batch Application โดยเรียกใช้ JobLauncher
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args) throws Exception {
String[] springConfig = { "jobs/job_hello_world.xml" };
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}
ในการเรียกใช้แอปพลิเคชันนี้จะให้ผลลัพธ์ดังต่อไปนี้
May 09, 2017 5:44:48 PM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXml
ApplicationContext@3d646c37: startup date [Tue May
09 17:44:48 IST 2017]; root of context hierarchy
May 09, 2017 5:44:48 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
May 09, 2017 5:44:56 PM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] launched
with the following parameters: [{}]
May 09, 2017 5:44:56 PM org.springframework.batch.core.job.SimpleStepHandler handleStep
INFO: Executing step: [step1]
Processing...Report [id=101, title=Learn Java, author=Sanjay, date=06-05-2007]
Processing...Report [id=102, title=Learn MySQL, author=Abdul S, date=19-04-2007]
Processing...Report [id=103, title=Learn JavaFX, author=Krishna Kasyap, date=0607-2017]
May 09, 2017 5:44:57 PM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters:
[{}] and the following status: [COMPLETED]
Hello
Exit Status : COMPLETED
สิ่งนี้จะสร้างไฟล์ .txt ไฟล์ที่มีเนื้อหาต่อไปนี้
Report [id=101, title=Learn Java, author=Sanjay, date=06-05-2007]
Report [id=102, title=Learn MySQL, author=Abdul S, date=19-04-2007]
Report [id=103, title=Learn JavaFX, author=Krishna Kasyap, date=06-07-2017]