@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();
 }