<import resource="../config/context.xml" />
<import resource="../config/database.xml" />
<batch:job id="helloWorldJob">    //helloWorldJob Job consisting of steps,steps having chunk reader, writer, processor
	<batch:step id="step1"> 
		<batch:tasklet>   
			<batch:chunk reader="cvsFileItemReader" writer="xmlItemWriter" processor="itemProcessor" commit-interval="10"> //reader writer and processor dependency   
            </batch:chunk>
        </batch:tasklet>   
    </batch:step>
</batch:job>
...
<bean id="cvsFileItemReader" class="ExampleItemReader" scope="step"/>
<bean id="xmlItemWriter" class="ExampleItemWriter" scope="step"/>
<bean id="itemProcessor" class="ExampleItemProcessor" scope="step"/>

<bean id="jobLauncher"  class="org.springframework.batch.core.launch.support.SimpleJobLauncher"> //joblauncher having dependency of JobRepository  
    <property name="jobRepository" ref="jobRepository" /> 
</bean>
<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" />

<import resource="../config/context.xml" />
<import resource="../config/database.xml" />
<batch:step id="step1"> 
	<batch:job ref="helloWorldJob"/>  
</batch:step>
...
<bean id="cvsFileItemReader" class="ExampleItemReader" scope="step"/>
<bean id="xmlItemWriter" class="ExampleItemWriter" scope="step"/>
<bean id="itemProcessor" class="ExampleItemProcessor" scope="step"/>

<import resource="../config/context.xml" />
<import resource="../config/database.xml" />
<batch:job id="helloWorldJob">    //helloWorldJob Job consisting of steps,steps having tasklet   
	<batch:step id="step1"> 
		<batch:tasklet ref="exampleTasklet">
        </batch:tasklet>   
    </batch:step>
</batch:job>
...
<bean id="exampleTasklet" class="ExampleTasklet "scope="step">
	...
</bean>

import org.springframework.batch.core.ExitStatus;
import org.springframework.batch.core.step.tasklet.Tasklet;

public class ExampleTasklet implements Tasklet{
    @Override
	public ExitStatus execute(){
    	...
    }
}

import org.springframework.batch.item.ItemStreamReader;
import org.springframework.beans.factory.annotation.Autowired;

public class ExampleItemReader implements ItemReader<Class1>{
    @Override
	public Class1 read() throws Exception{
    	...
    }
}

import org.springframework.batch.item.ItemProcessor;
import org.springframework.beans.factory.annotation.Autowired;

public class ExampleItemProcessor implements ItemProcessor<Class1, Class2>{
    @Override
	public Class2 process(Class1 arg) throws Exception{
    	...
    }
}

import org.springframework.batch.item.ItemWriter;
import org.springframework.beans.factory.annotation.Autowired;

public class ExampleItemWriter implements ItemWriter<Class1>{
    @Override
	public void write(List<? extends Class1> items) throws Exception{
    	...
    }
}

import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobExecutionException;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.JobParametersBuilder;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
	public static void main(String [] args){
 
	String[] springConfig  =  {"spring/batch/jobs/job.xml" };  //Load the Job.xml file,this Job.xml has dependency on JobLauncher
                                                              // which will load the Repository  
 	ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
 	JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher"); //get the JobLauncher object 
	Job job = (Job) context.getBean("helloWorldJob");   //get the Job Object
 
	try {  
		JobExecution execution = jobLauncher.run(job, new JobParameters());	//start the job by calling the run method
        System.out.println("Exit Status : " + execution.getStatus());
 	} catch (Exception e) {  
		e.printStackTrace(); 
    } 
    }
}

<import resource="../config/context.xml" />
<import resource="../config/database.xml" />
<batch:job id="helloWorldJob">    //helloWorldJob Job consisting of steps,steps having tasklet   
	<batch:step id="step1"> 
		<batch:tasklet ref="exampleTasklet">
        </batch:tasklet>   
    </batch:step>
    <listeners>
        <listener ref="jobListener"></listener>
    </listeners>
</batch:job>
...
<bean id="exampleTasklet" class="ExampleTasklet "scope="step">
	...
</bean>
<beans id="jobListener" class="ExampleListenerJob">
    ...
</bean>

<import resource="../config/context.xml" />
<import resource="../config/database.xml" />
<batch:job id="helloWorldJob">    //helloWorldJob Job consisting of steps,steps having tasklet   
	<batch:step id="step1"> 
		<batch:tasklet ref="exampleTasklet">
        </batch:tasklet>
        <listeners>
        	<listener ref="stepListener"></listener>
    	</listeners> 
    </batch:step>
</batch:job>
...
<bean id="exampleTasklet" class="ExampleTasklet "scope="step">
	...
</bean>
<beans id="stepListener" class="ExampleListenerStep">
    ...
</bean>

import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobExecutionListener;

public class ExampleJobExecutionListener implements JobExecutionListener
{
    @Override
    public void beforeJob(JobExecution jobExecution)
    {
        ...
    }
    @Override
    public void afterJob(JobExecution jobExecution)
    {
        ...
    }
}

<b:job id="helloWorldJob" job-repository="jobRepository"
		restartable="true">
	...
	<b:flow id="writeFlowStep">
		<b:step id="writeStartMessageStep" next="writeReturnStep">
			<b:tasklet ref="writeStartMessageTasklet" />
			<b:listeners>
				...
			</b:listeners>
		</b:step>
		<b:step id="writeReturnStep" next="writeAAAStep">
			<b:tasklet transaction-manager="transactionManager">
				...
			</b:tasklet>
			<b:listeners>
				<b:listener ref="itemFailureLoggerListener" />
			</b:listeners>
		</b:step>
		<b:step id="writeAAAStep" next="writeEndMessageStep" parent="writeReturnStep">
			<b:tasklet transaction-manager="transactionManager">
				...
			</b:tasklet>
		</b:step>
		<b:step id="writeEndMessageStep">
			<b:tasklet ref="ecrireFinMessageTasklet" />
			<b:listeners>
				...
			</b:listeners>
		</b:step>
	</b:flow>
	...
</b:job>

<b:job id="helloWorldJob" job-repository="jobRepository"
		restartable="true">	
	<b:split id="splitStep"
			task-executor="taskExecutor">
		<b:flow>
			<b:step id="step6"
				next="step7">
				<b:tasklet transaction-manager="transactionManager">
					<b:chunk
						commit-interval="${...}"
						processor="creerFichierProcessor"
						reader="creerFichierReader"
						writer="creerFichierWriter" />
				</b:tasklet>
				<b:listeners>
					<b:listener ref="itemListener" />
					<b:listener ref="stepListener" />
					<b:listener ref="chunkListener" />
				</b:listeners>
			</b:step>
			<b:step id="step7">
				<b:tasklet ref="fileDate" />
				<b:listeners>
					<b:listener ref="itemListener" />
				</b:listeners>
			</b:step>				
		</b:flow>
	</b:split>
</b:job>

<b:job id="helloWorldJob" job-repository="jobRepository"
		restartable="true">	
	<b:step id="step1" next="decision1">
		<b:tasklet ref="appelServiceSeuilRejetTasklet"/>
		<b:listeners>
			<b:listener ref="itemFailureLoggerListener" />
			<b:listener ref="sisoStepListener" />
		</b:listeners>
	</b:step>

	<b:decision decider="decider1" id="decision1">
		<b:next on="FAILED" to="step2" />
		<b:next on="COMPLETED" to="step3" />
	</b:decision>

	<b:step id="step3">
		<b:tasklet ref="VerifierListHabilitationsEmetteurTasklet" />
		<b:listeners>
			<b:listener ref="itemFailureLoggerListener" />
			<b:listener ref="sisoStepListener" />
		</b:listeners>
	</b:step>

	<b:decision id="step2"
		decider="genererBilanDecider">
		<b:next on="TRUE" to="step4" />
		<b:end on="COMPLETED"/>
	</b:decision>
		
	<b:step id="step4">
		<b:tasklet ref="debutFichierRetourTasklet" />
		<b:listeners>
			<b:listener ref="itemFailureLoggerListener" />
		</b:listeners>
	</b:step>
</b:job>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:b="http://www.springframework.org/schema/batch"
	xmlns="http://www.springframework.org/schema/beans"
	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.xsd
	    				http://www.springframework.org/schema/beans 
						http://www.springframework.org/schema/beans/spring-beans.xsd">
	...
	<bean id="decider1"
		class="Decider">
	</bean>
	...
</beans>

import org.springframework.batch.core.job.flow.JobExecutionDecider;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.StepExecution;

public class Decider implements JobExecutionDecider {
	@Override
  	public FlowExecutionStatus decide(JobExecution jobExecution, StepExecution stepExecution) {
	...
	}
}

<import resource="../config/context.xml" />
<import resource="../config/database.xml" />
<batch:job id="helloWorldJob">    //helloWorldJob Job consisting of steps,steps having chunk reader, writer, processor
	<batch:step id="step1"> 
		<batch:tasklet>   
			<batch:chunk reader="infoItemReader" writer="infoItemWriter" processor="itemProcessor" commit-interval="10"> //reader writer and processor dependency   
            </batch:chunk>
        </batch:tasklet>   
    </batch:step>
</batch:job>
...
<bean id="infoItemReader" class="org.springframework.batch.item.database.JdbcCursorItemReader" scope="step">
	<property name="sql"
			value="SELECT * FROM INFORMATIONS"/>
</bean>

import javax.batch.operations.JobOperator;
import javax.batch.runtime.BatchRuntime;
import java.util.Properties;

public class Main {
	public static void main(String [] args){
        JobOperator operator = BatchRuntime.getJobOperator();
        jobOperator.start("helloWorldJob", new Properties()); 
}

<job id="helloWorldJob">    //helloWorldJob Job consisting of steps,steps having chunk reader, writer, processor
	<step id="step1"> 
		<chunk>   
			<reader="cvsFileItemReader">
            <writer="xmlItemWriter">
            <processor="itemProcessor" commit-interval="10">   
        </chunk>   
    </step>
</job>

Job job = jobBuilderFactory
        .get("financialsJob")
        .incrementer(new RunIdIncrementer())
        .flow(statementsSteps)
        .end()
        .build();

@Bean
  public Step statementsSteps(ItemReader<String> statementsReader,
      ItemWriter<Map<Integer, List<StatementHeader>>> changeAlertsWriter,
      ItemProcessor<? super String, ? extends Map<Integer, List<StatementHeader>>> statementsProcessor) {
    return stepBuilderFactory
        .get("statementsSteps")
        .chunk(1)
        .reader(statementsReader)
        .processor(statementsProcessor)
        .writer(changeAlertsWriter).build();

...
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
...


@Configuration
@EnableBatchProcessing
public class SpringBatchConfiguration {

    private static Logger LOGGER = LoggerFactory.getLogger(SpringBatchConfiguration.class);

    private static final String[] TOKENS = { "bookname", "bookauthor", "bookformat", "isbn", "publishyear" };

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    ...

    @Bean
    public Step step1(ItemReader<BookRecord> csvItemReader, ItemWriter<Book> jsonItemWriter) throws IOException {
        return stepBuilderFactory
          .get("step1")
          .<BookRecord, Book> chunk(3)
          .reader(csvItemReader)
          .processor(bookItemProcessor())
          .writer(jsonItemWriter)
          .build();
    }

    @Bean
    public Step step2(ItemReader<BookRecord> csvItemReader, ItemWriter<BookDetails> listItemWriter) {
        return stepBuilderFactory
          .get("step2")
          .<BookRecord, BookDetails> chunk(3)
          .reader(csvItemReader)
          .processor(bookDetailsItemProcessor())
          .writer(listItemWriter)
          .build();
    }

    @Bean(name = "transformBooksRecords")
    public Job transformBookRecords(Step step1, Step step2) throws IOException {
        return jobBuilderFactory
          .get("transformBooksRecords")
          .flow(step1)
          .next(step2)
          .end()
          .build();
    }

}

import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;

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 javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Qualifier;
import com.job.listener.methods.JobTRExecutionListener;


public class SpringBatchConfig {
    
    @Autowired
    private JobBuilderFactory jobs;

    @Autowired
    private StepBuilderFactory steps;

    @Value("input/record.csv")
    private Resource inputCsv;

    @Value("file:xml/output.xml")
    private Resource outputXml;
    
    private JobTRExecutionListener listener;

    ...

    @Bean
    protected Step step1(ItemReader<Transaction> reader,
      ItemProcessor<Transaction, Transaction> processor,
      ItemWriter<Transaction> writer) {
        return steps.get("step1").chunk(10)
          .reader(reader).processor(processor).writer(writer).build();
    }

    @Bean(name = "firstBatchJob")
    public Job job(@Qualifier("step1") Step step1) {
        return jobs.get("firstBatchJob").listener(listener).start(step1).build();
    }
}

import org.springframework.batch.item.ItemProcessor;
import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.ItemWriter;

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 javax.annotation.Resource;
import org.springframework.beans.factory.annotation.Qualifier;

import com.jobs.scheduler.tasklets.AcquisitionTasklet;


public class SpringBatchConfigFlow {
	@Autowired
    private JobBuilderFactory jobs;

    @Autowired
    private StepBuilderFactory steps;
	
	private AcquisitionTasklet tasklet;

	@Bean
    protected Step step2(ItemReader<Transaction> reader,
      ItemProcessor<Transaction, Transaction> processor,
      ItemWriter<Transaction> writer) {
        return steps.get("step2").tasklet(tasklet).build();
    }
	...
}

package com.jobs.scheduler.tasklets;

import org.springframework.batch.core.ExitStatus;
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;
import org.springframework.http.HttpStatus;

import com.sncf.eva.tr.jobs.rest.client.JobsClientRest;

public class AcquisitionTasklet implements Tasklet {
    /**
     * Logger
     */
    public static final org.slf4j.Logger LOG = org.slf4j.LoggerFactory.getLogger(AcquisitionTasklet.class);

    public static final String PARAM_TASKLET_DATE = "date";

    private JobsClientRest jobsClientRest;

    @Override
    public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
        LOG.info("Execution de la tasklet acquisition pour les paramètres : Context - {}",
            getParam(chunkContext, PARAM_TASKLET_DATE));

        contribution.incrementFilterCount(1);

        executeServices(contribution);

        return RepeatStatus.FINISHED;
    }
	...

import com.baeldung.batch.model.Transaction;
import com.baeldung.batch.service.RecordFieldSetMapper;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
...

@Configuration
@EnableBatchProcessing
public class SpringbatchPartitionConfig {

    @Autowired
    private JobBuilderFactory jobs;

    @Autowired
    private StepBuilderFactory steps;

    @Bean(name = "partitionerJob")
    public Job partitionerJob() throws UnexpectedInputException, MalformedURLException, ParseException {
        return jobs.get("partitionerJob")
          .start(partitionStep())
          .build();
    }

    @Bean
    public Step partitionStep() throws UnexpectedInputException, MalformedURLException, ParseException {
        return steps.get("partitionStep")
          .partitioner("slaveStep", partitioner())
          .step(slaveStep())
          .taskExecutor(taskExecutor())
          .build();
    }

    @Bean
    public Step slaveStep() throws UnexpectedInputException, MalformedURLException, ParseException {
        return steps.get("slaveStep")
          .<Transaction, Transaction>chunk(1)
          .reader(itemReader(null))
          .writer(itemWriter(marshaller(), null))
          .build();
    }
    ...
}