org.springframework.batch.core.launch.support.RunIdIncrementer Java Examples

@DirtiesContext
@Test
public void retryFailedExecutionOnNonRestartableJob() throws Exception {
	this.job = this.jobs.get("job").preventRestart()
			.start(this.steps.get("step").tasklet(throwingTasklet()).build())
			.incrementer(new RunIdIncrementer()).build();
	runFailedJob(new JobParameters());
	runFailedJob(new JobParameters());
	// A failed job that is not restartable does not re-use the job params of
	// the last execution, but creates a new job instance when running it again.
	assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(2);

	// try to re-run a failed execution
	Executable executable = () -> this.runner.execute(this.job,
			new JobParametersBuilder().addLong("run.id", 1L).toJobParameters());
	assertThatExceptionOfType(JobRestartException.class)
			.isThrownBy(executable::execute)
			.withMessage("JobInstance already exists and is not restartable");
}
 

@Override
public Job getObject() throws Exception {
	ComposedRunnerVisitor composedRunnerVisitor = new ComposedRunnerVisitor();

	TaskParser taskParser = new TaskParser("composed-task-runner",
			this.dsl,false,true);
	taskParser.parse().accept(composedRunnerVisitor);

	this.visitorDeque = composedRunnerVisitor.getFlow();

	FlowJobBuilder builder = this.jobBuilderFactory
			.get(this.taskNameResolver.getTaskName())
			.start(this.flowBuilder
					.start(createFlow())
					.end())
			.end();
	if(this.incrementInstanceEnabled) {
		builder.incrementer(new RunIdIncrementer());
	}
	return builder.build();
}
 

@Bean
public Job settleJob() {
    return jobBuilderFactory.get("settleJob")
            //使每个Job的运行ID都唯一
            .incrementer(new RunIdIncrementer())
            .listener(this.settleJobListeners)
            //.flow(step0001).split(new SimpleAsyncTaskExecutor("springbatch_seedboot")).add(flow04, flow05, flow06)
            //.start(step0001).split(new SimpleAsyncTaskExecutor("springbatch_seedboot")).add(flow04, flow05, flow06)
            //先执行step0001（注意：上面注释的这两种写法都不会step0001先执行然后再执行step0004...，他们都会使得step0001和step0004...同时执行）
            .flow(step0001)
            //然后step0004、step0005、step0006开始执行且三者是并行执行互不影响的
            .next(this.splitFlow())
            //接着等三者全都执行完毕才会去执行step0002
            .next(step0002)
            //最后执行step0003
            .next(step0003)
            .end()
            .build();
}
 

@Override
public Job getObject() throws Exception {
	ComposedRunnerVisitor composedRunnerVisitor = new ComposedRunnerVisitor();

	TaskParser taskParser = new TaskParser("composed-task-runner",
			this.dsl,false,true);
	taskParser.parse().accept(composedRunnerVisitor);

	this.visitorDeque = composedRunnerVisitor.getFlow();

	FlowJobBuilder builder = this.jobBuilderFactory
			.get(this.taskNameResolver.getTaskName())
			.start(this.flowBuilder
					.start(createFlow())
					.end())
			.end();
	if(this.incrementInstanceEnabled) {
		builder.incrementer(new RunIdIncrementer());
	}
	return builder.build();
}
 

@Bean
public Job importJob(JobBuilderFactory jobs, Step s1) {
    return jobs.get("importJob")
            .incrementer(new RunIdIncrementer())
            .flow(s1) //为 job 指定 step
            .end()
            .listener(csvJobListener()) //绑定监听器 csvJobListener
            .build();
}
 

@DirtiesContext
@Test
public void retryFailedExecutionWithDifferentNonIdentifyingParametersFromPreviousExecution()
		throws Exception {
	this.job = this.jobs.get("job")
			.start(this.steps.get("step").tasklet(throwingTasklet()).build())
			.incrementer(new RunIdIncrementer()).build();
	JobParameters jobParameters = new JobParametersBuilder().addLong("id", 1L, false)
			.addLong("foo", 2L, false).toJobParameters();
	runFailedJob(jobParameters);
	assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
	// try to re-run a failed execution with non identifying parameters
	runFailedJob(new JobParametersBuilder().addLong("run.id", 1L)
			.addLong("id", 2L, false).addLong("foo", 3L, false).toJobParameters());
	assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
	JobInstance jobInstance = this.jobExplorer.getJobInstance(0L);
	assertThat(this.jobExplorer.getJobExecutions(jobInstance)).hasSize(2);
	// first execution
	JobExecution firstJobExecution = this.jobExplorer.getJobExecution(0L);
	JobParameters parameters = firstJobExecution.getJobParameters();
	assertThat(parameters.getLong("run.id")).isEqualTo(1L);
	assertThat(parameters.getLong("id")).isEqualTo(1L);
	assertThat(parameters.getLong("foo")).isEqualTo(2L);
	// second execution
	JobExecution secondJobExecution = this.jobExplorer.getJobExecution(1L);
	parameters = secondJobExecution.getJobParameters();
	// identifying parameters should be the same as previous execution
	assertThat(parameters.getLong("run.id")).isEqualTo(1L);
	// non-identifying parameters should be the newly specified ones
	assertThat(parameters.getLong("id")).isEqualTo(2L);
	assertThat(parameters.getLong("foo")).isEqualTo(3L);
}
 

@DirtiesContext
@Test
public void retryFailedExecutionWithNonIdentifyingParameters() throws Exception {
	this.job = this.jobs.get("job")
			.start(this.steps.get("step").tasklet(throwingTasklet()).build())
			.incrementer(new RunIdIncrementer()).build();
	JobParameters jobParameters = new JobParametersBuilder().addLong("id", 1L, false)
			.addLong("foo", 2L, false).toJobParameters();
	runFailedJob(jobParameters);
	assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
	runFailedJob(new JobParametersBuilder(jobParameters).addLong("run.id", 1L)
			.toJobParameters());
	assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
}
 

@DirtiesContext
@Test
public void retryFailedExecution() throws Exception {
	this.job = this.jobs.get("job")
			.start(this.steps.get("step").tasklet(throwingTasklet()).build())
			.incrementer(new RunIdIncrementer()).build();
	runFailedJob(new JobParameters());
	runFailedJob(new JobParametersBuilder().addLong("run.id", 1L).toJobParameters());
	assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
}
 

@DirtiesContext
@Test
public void incrementExistingExecution() throws Exception {
	this.job = this.jobs.get("job").start(this.step)
			.incrementer(new RunIdIncrementer()).build();
	this.runner.execute(this.job, new JobParameters());
	this.runner.execute(this.job, new JobParameters());
	assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(2);
}
 

@Bean(name = "executionJob")
public Job reportsExecutionJob(CustomItemReader<List<Long>> reader, CustomItemProcessor processor,
		CustomItemWriter<List<PostDTO>> writer, TaskExecutor taskExecutor) {

	Step step = this.stepBuilderFactory.get("execution-step").allowStartIfComplete(true)
			.<List<Long>, List<PostDTO>>chunk(1).reader(reader).processor(processor).writer(writer)
			.taskExecutor(taskExecutor).build();

	return this.jobBuilderFactory.get("reporting-job").incrementer(new RunIdIncrementer()).listener(this)
			.start(step).build();
}
 

@Bean
public Job addressPrinterJob(final JobBuilderFactory jobBuilderFactory,
                             final Step addressPrinterStep,
                             final Step addressBatchTaskDeletionStep) throws Exception {
    return jobBuilderFactory
            .get("addressPrinterJob")
            .incrementer(new RunIdIncrementer())
            .start(addressPrinterStep)
            .next(addressBatchTaskDeletionStep)
            .build();
}
 

@Bean
public Job importUserJob(JobCompletionNotificationListener listener) {
    return jobBuilderFactory.get("importUserJob")
            .incrementer(new RunIdIncrementer())
            .listener(listener)
            .flow(step1())
            .end()
            .build();
}
 

@Bean
public Job job(Step step1) throws Exception {
  return jobBuilderFactory.get("job1")
      .incrementer(new RunIdIncrementer())
      .start(step1)
      .build();
}
 

@Bean
public Job importUserJob(JobBuilderFactory jobs, Step step1, Step step2, JobExecutionListener listener) {
       return jobs.get("importUserJob")
               .incrementer(new RunIdIncrementer())
               .listener(listener)
               .flow(step1)
               .next(step2)
               .end()
               .build();
 }
 

private Job job(String jobName, CountDownLatch latch) {
	return scheduler.jobs().get(jobName).incrementer(new RunIdIncrementer()) // adds unique parameter on each run so
																				// that createJob can be rerun
			.start(scheduler.steps().get("step").tasklet((contribution, chunkContext) -> {
				latch.countDown();
				return RepeatStatus.FINISHED;
			}).allowStartIfComplete(true).build()).build();
}
 

private Job job(String jobName) {
	return scheduler.jobs().get(jobName).incrementer(new RunIdIncrementer()) // adds unique parameter on each run so
																				// that createJob can be rerun
			.start(scheduler.steps().get("step").tasklet((contribution, chunkContext) -> {
				return RepeatStatus.FINISHED;
			}).allowStartIfComplete(true).build()).build();
}
 

@Bean
Job personJob(@Qualifier("personStep") Step personStep) {
    return adHocScheduler.schedule(PersonJobConfig.JOB_NAME, jobs.get(JOB_NAME)
            .incrementer(new RunIdIncrementer())
            .flow(personStep)
            .end()
            .build(), "0 0 12 * * ?");
}
 

@Bean
public Job importVoltageJob(NotificationListener listener, Step step1) {
    return jobBuilderFactory.get("importVoltageJob")
            .incrementer(new RunIdIncrementer())
            .listener(listener)
            .flow(step1)
            .end()
            .build();
}
 

@Bean
public Job jobUseFlatFileWithRepositoryItemWriter(RepositoryItemWriterJobListener listener) {
    return jobBuilderFactory
            .get("jobUseFlatFileWithRepositoryItemWriter")
            .incrementer(new RunIdIncrementer())
            .listener(listener)
            .flow(repositoryItemWriterStep)
            .end()
            .build();
}
 

@Bean
public Job jobUseFlatFileWithJdbcBatchItemWriter(JdbcBatchItemWriterJobListener listener) {
    return jobBuilderFactory.get("jobUseFlatFileWithJdbcBatchItemWriter")
            .incrementer(new RunIdIncrementer())
            .listener(listener)
            .flow(jdbcBatchItemWriterStep)
            .end()
            .build();
}
 

@Bean
public Job jobWithRepositoryStepWithParams(@Autowired CommonJobListener commonJobListener) {
    return jobBuilderFactory.get("jobWithRepositoryStepWithParams")
            .incrementer(new RunIdIncrementer())
            .listener(commonJobListener)
            .flow(stepWithRepositoryReaderAndWriter)
            .end()
            .build();
}
 

@Bean
public Job jobWithRepositoryStep(@Autowired CommonJobListener commonJobListener) {
    return jobBuilderFactory.get("jobWithRepositoryStep")
            .incrementer(new RunIdIncrementer())
            .listener(commonJobListener)
            .flow(stepWithRepository)
            .end()
            .build();
}
 

@Bean
public Job jobInJpaPagingWithJdbcBatchItemWriter(JpaPagingBatchJobListener listener) {
    return jobBuilderFactory
            .get("jobInJpaPagingWithJdbcBatchItemWriter")
            .incrementer(new RunIdIncrementer())
            .listener(listener)
            .flow(stepInJpaPagingWithJdbcBatchItemWriter)
            .end()
            .build();
}
 

@Bean
public Job jobInJpaPagingWithRepositoryItemWriter(JpaPagingBatchJobListener listener) {
    return jobBuilderFactory
            .get("jobInJpaPagingWithJdbcBatchItemWriter")
            .incrementer(new RunIdIncrementer())
            .listener(listener)
            .flow(stepInJpaPagingWithRepositoryItemWriter)
            .end()
            .build();
}
 

@Bean
public Job importPayRollJob(JobCompletionPayRollListener listener, Step step1) {
    return jobBuilderFactory.get("importPayRollJob")
            .incrementer(new RunIdIncrementer())
            .listener(listener)
            .flow(step1)
            .end()
            .build();
}
 

@Bean
public Job job(Step ourBatchStep) throws Exception {
	return jobBuilderFactory.get("jobPackPub1")
			.incrementer(new RunIdIncrementer())
			.start(ourBatchStep)
			.build();
}
 

/**
 * Job定义，我们要实际执行的任务，包含一个或多个Step
 *
 * @param jobBuilderFactory
 * @param s1
 * @return
 */
@Bean(name = "vtollJob")
public Job vtollJob(JobBuilderFactory jobBuilderFactory, @Qualifier("vtollStep1") Step s1) {
    return jobBuilderFactory.get("vtollJob")
            .incrementer(new RunIdIncrementer())
            .flow(s1)//为Job指定Step
            .end()
            .listener(new MyJobListener())//绑定监听器csvJobListener
            .build();
}
 

/**
 * Job定义，我们要实际执行的任务，包含一个或多个Step
 *
 * @param jobBuilderFactory
 * @param s1
 * @return
 */
@Bean(name = "cantonJob")
public Job cantonJob(JobBuilderFactory jobBuilderFactory, @Qualifier("cantonStep1") Step s1) {
    return jobBuilderFactory.get("cantonJob")
            .incrementer(new RunIdIncrementer())
            .flow(s1)//为Job指定Step
            .end()
            .listener(new MyJobListener())//绑定监听器csvJobListener
            .build();
}
 

/**
 * Job定义，我们要实际执行的任务，包含一个或多个Step
 *
 * @param jobBuilderFactory
 * @param s1
 * @return
 */
@Bean(name = "zlogJob")
public Job zlogJob(JobBuilderFactory jobBuilderFactory, @Qualifier("logStep1") Step s1) {
    return jobBuilderFactory.get("zlogJob")
            .incrementer(new RunIdIncrementer())
            .flow(s1)//为Job指定Step
            .end()
            .listener(new MyJobListener())//绑定监听器csvJobListener
            .build();
}
 

/**
 * Job定义，我们要实际执行的任务，包含一个或多个Step
 *
 * @param jobBuilderFactory
 * @param s1
 * @return
 */
@Bean(name = "zappJob")
public Job zappJob(JobBuilderFactory jobBuilderFactory, @Qualifier("zappStep1") Step s1) {
    return jobBuilderFactory.get("zappJob")
            .incrementer(new RunIdIncrementer())
            .flow(s1)//为Job指定Step
            .end()
            .listener(new MyJobListener())//绑定监听器csvJobListener
            .build();
}