@Bean
public Job job() {
return jobBuilderFactory
.get("job")
.start(stepBuilderFactory.get("step1").tasklet(tasklet(null)).build())
.build();
}
@Bean
public Job importUserJob(
JobBuilderFactory jobs, @Qualifier("step1") Step s1, JobExecutionListener listener) {
return jobs.get("importUserJob")
.incrementer(new RunIdIncrementer())
.listener(listener)
.flow(s1)
.end()
.build();
}
@Bean
public Job splitJob(@Qualifier("foo") Flow foo, @Qualifier("foo") Flow bar) {
FlowBuilder<Flow> flowBuilder = new FlowBuilder<>("split");
Flow flow = flowBuilder.split(new SimpleAsyncTaskExecutor()).add(foo, bar).end();
return jobBuilderFactory
.get("splitJob")
.start(myStep1())
.next(myStep2())
.on("COMPLETED")
.to(flow)
.end()
.build();
}
@Bean
public Job job() {
return jobBuilderFactory
.get("job")
.start(startStep())
.next(decider())
.from(decider())
.on("ODD")
.to(oddStep())
.from(decider())
.on("EVEN")
.to(evenStep())
.from(oddStep())
.on("*")
.to(decider())
// .from(decider()).on("ODD").to(oddStep())
// .from(decider()).on("EVEN").to(evenStep())
.end()
.build();
}
@Bean
public Job importProductsJob(Tasklet dummyTasklet, ItemReader<Product> reader) {
Step decompress = stepBuilders.get("decompress").tasklet(dummyTasklet).build();
Step readWrite =
stepBuilders
.get("readWriteProducts")
.<Product, Product>chunk(100)
.reader(reader)
.writer(writer())
.faultTolerant()
.skipLimit(5)
.skip(FlatFileParseException.class)
.build();
Step generateReport = stepBuilders.get("generateReport").tasklet(dummyTasklet).build();
Step sendReport = stepBuilders.get("sendReport").tasklet(dummyTasklet).build();
Step clean = stepBuilders.get("clean").tasklet(dummyTasklet).build();
return jobBuilders
.get("importProductsJob")
.repository(jobRepository)
.listener(loggerListener)
.start(decompress)
.next(readWrite)
.next(skippedDecider())
.on("SKIPPED")
.to(generateReport)
.next(sendReport)
.from(skippedDecider())
.on("*")
.to(clean)
.end()
.build();
}
@Bean
public Job importGameInfo(JobBuilderFactory jobs, Step step1) {
return jobs.get("import").incrementer(new RunIdIncrementer()).flow(step1).end().build();
}
/**
* @param jobs
* @param s1 steps
* @return the Job
*/
@Bean
public Job importUserJob(JobBuilderFactory jobs, Step s1) {
return jobs.get("importUserJob").incrementer(new RunIdIncrementer()).flow(s1).end().build();
}
@Bean
Job job(JobBuilderFactory factory, Step step) {
return factory.get("etl").start(step).build();
}
@Bean
public Job job1(final Step step1) throws Exception {
return jobBuilderFactory.get("job1").incrementer(new RunIdIncrementer()).start(step1).build();
}
// or we can use composite item processor
@Bean
public Job operationsJob(final Step addition, final Step multiplication) {
return jobBuilderFactory.get("operationsJob").start(addition).next(multiplication).build();
}