Spring Batch tutorial – JavaDream
August 23, 2020 | Spring boot complete tutorial with example | No Comments
In this post we will see about spring batch. So the first question will come in our mind is
What is Spring Boot Batch ?
Table of Contents
Spring boot batch is framework that is designed to execute large and robust batch application.
Batch application Example.
As we know we use spring boot batch to execute large task. So here are some application scenario where we use Batch framework.
1- Suppose we have a big CSV file which contains billions rerecords and i want to store that data in the MySQL database.
So if you try yo insert this billions record in one go your application takes a very very long time to execute this task.
And it may also be possible that your database not support this huge amount of insertion.
So in this case we will use Spring boot Batch framework and execute this task in batch chunks means we divide this task of insertion in chunks.
The above scenario we will cover in another application first we see some easy example to learn spring boot batch framework.
In this example we take a list of names and try to process this list data in batch.
Project Structure:

There are some keyword in spring boot batch framework. That we use to process our application.
- ItemReader
- ItemProcessor
- ItemWriter
- Step
- Job
- Job Listener
- JobBuilderFactory
- StepBuilderFactory
- JobLauncher
ItemReader :
ItemReader is like entry point it will read your data from file or from the source you define.
ItemProcessor :
ItemProcessor is process the data that you read using ItemReader.
For Example you read a List of names using ItemReader and you want to convert this name in uppercase. So this task is done by ItemProcessor.
ItemWriter :
After Process the data by ItemProcessor we have to write this data. So for this we use ItemWriter.
Step :
After process all above steps ItemReader, ItemProcessor, ItemWriter we will get the steps.
Job :
Now we have to create a Job that executes the Step. Job is an interface and resides in org.springframework.batch.core package.
Job Listener :
This class deines two methods beforeJob and afterJob. As the name suggest this function is used to perform task before and after job execution.
JobBuilderFactory :
JobBuilderFactory is a class that used to create the Job.
StepBuilderFactory :
StepBuilderFactory is a class that used to create the Step.
JobLauncher :
Till now we have create the Job. Now we have to excute this Job for this we will use JobLauncher.
Now Lets do a coding example. We Just create a List of names and print this List name in batch.
To create above Project we have to follow below steps:
1- Add required dependency in your pom.xml file or add from Maven Repositry.
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-batch</artifactId> </dependency>
2- Now create a class that implements ItemReader interface.
package com.vasu.springbatch; import org.springframework.batch.item.ItemReader; import org.springframework.batch.item.NonTransientResourceException; import org.springframework.batch.item.ParseException; import org.springframework.batch.item.UnexpectedInputException; public class Reader implements ItemReader<String> { private String[] names = {"Vasu","Vishu", "Ayush","Sushmita","konika"}; private int count; @Override public String read() throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException { System.out.println("Inside Read Method"); if(count < names.length) { return names[count++]; }else { count = 0; } return null; } }
3- Create a class that process above list and convert List names into UpperCase.
package com.vasu.springbatch; import org.springframework.batch.item.ItemProcessor; public class Processor implements ItemProcessor<String, String> { @Override public String process(String item) throws Exception { System.out.println("Inside Process method"); return "PROCESSED "+ item.toUpperCase(); } }
4- Create Writer class that implement ItemWriter.
package com.vasu.springbatch; import java.util.List; import org.springframework.batch.item.ItemWriter; public class Writer implements ItemWriter<String> { @Override public void write(List<? extends String> items) throws Exception { System.out.println("Inside Write method"); System.out.println("Data In UpperCase is " + items); } }
5- Create a Job Listener class .
package com.vasu.springbatch; import org.springframework.batch.core.JobExecution; import org.springframework.batch.core.JobExecutionListener; public class MyJobListener implements JobExecutionListener { @Override public void beforeJob(JobExecution jobExecution) { System.out.println("Before Job Started"); } @Override public void afterJob(JobExecution jobExecution) { System.out.println("After Job Ended " + jobExecution.getStatus().toString()); } }
6- Now Create a Config class and initialize all the above beans.
package com.vasu.springbatch; import org.springframework.batch.core.Job; import org.springframework.batch.core.Step; import org.springframework.batch.core.configuration.annotation.JobBuilderFactory; import org.springframework.batch.core.configuration.annotation.StepBuilderFactory; import org.springframework.batch.core.launch.support.RunIdIncrementer; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class BatchConfig { @Autowired private StepBuilderFactory sdf; @Autowired private JobBuilderFactory jbf; @Bean public Job job() { return jbf.get("myFirstBatchJob") .incrementer(new RunIdIncrementer()) .listener(listener()) .start(step()) .build(); } @Bean public Step step() { return sdf.get("myFirstBatchStep") .<String,String>chunk(3) .reader(reader()) .processor(processor()) .writer(writer()) .build(); } @Bean public Reader reader() { return new Reader(); } @Bean public Writer writer() { return new Writer(); } @Bean public Processor processor() { return new Processor(); } @Bean public MyJobListener listener() { return new MyJobListener(); } }
7- Use @EnableBatchProcessing annotation in your main class.
package com.vasu.springbatch; import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication @EnableBatchProcessing public class SpringbatchApplication { public static void main(String[] args) { SpringApplication.run(SpringbatchApplication.class, args); } }
8- Create a Test Class to test the batch process. In this class autowired JobLauncher.
package com.vasu.springbatch; import org.junit.jupiter.api.Test; import org.springframework.batch.core.Job; import org.springframework.batch.core.JobParameters; import org.springframework.batch.core.JobParametersBuilder; import org.springframework.batch.core.JobParametersInvalidException; import org.springframework.batch.core.launch.JobLauncher; import org.springframework.batch.core.repository.JobExecutionAlreadyRunningException; import org.springframework.batch.core.repository.JobInstanceAlreadyCompleteException; import org.springframework.batch.core.repository.JobRestartException; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; @SpringBootTest class SpringbatchApplicationTests { @Autowired JobLauncher launcher; @Autowired Job job; @Test void testBatch() throws JobExecutionAlreadyRunningException, JobRestartException, JobInstanceAlreadyCompleteException, JobParametersInvalidException { JobParameters jobParameters = new JobParametersBuilder() .addLong("todayTime", System.currentTimeMillis()) .toJobParameters(); launcher.run(job, jobParameters); } }
Now run this class as JUnit Test.
Output:

Complete code on Github- Spring batch Github
You may also like
Spring boot security using JWT ( JSON WEB TOKENS ).
Spring Boot with Apache kafka.
Profiles in Spring boot application