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]