Java RunIdIncrementer类代码示例

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
@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();
}
 

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
@Test
public void retryFailedExecutionOnNonRestartableJob() throws Exception {
	this.job = this.jobs.get("job").preventRestart()
			.start(this.steps.get("step").tasklet(new Tasklet() {
				@Override
				public RepeatStatus execute(StepContribution contribution,
						ChunkContext chunkContext) throws Exception {
					throw new RuntimeException("Planned");
				}
			}).build()).incrementer(new RunIdIncrementer()).build();
	this.runner.execute(this.job, new JobParameters());
	this.runner.execute(this.job, 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);
}
 

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
@Test
public void retryFailedExecutionWithNonIdentifyingParameters() throws Exception {
	this.job = this.jobs.get("job")
			.start(this.steps.get("step").tasklet(new Tasklet() {
				@Override
				public RepeatStatus execute(StepContribution contribution,
						ChunkContext chunkContext) throws Exception {
					throw new RuntimeException("Planned");
				}
			}).build()).incrementer(new RunIdIncrementer()).build();
	JobParameters jobParameters = new JobParametersBuilder().addLong("id", 1L, false)
			.addLong("foo", 2L, false).toJobParameters();
	this.runner.execute(this.job, jobParameters);
	this.runner.execute(this.job, jobParameters);
	assertThat(this.jobExplorer.getJobInstances("job", 0, 100)).hasSize(1);
}
 

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
/**
 * @return main job
 */
@Bean
public Job job() {
    return jobs.get("mainJob")
            .incrementer(new RunIdIncrementer())
            .flow(loadProcessedListIds())
            .next(new FlowBuilder<SimpleFlow>("splitFlow")
                    .start(loadScans())
                    .split(taskExecutor())
                    .add(new FlowBuilder<SimpleFlow>("loadTranscriptsFlow")
                            .start(loadTranscripts())
                            .build())
                    .build())
            .next(addSign())
            .end()
            .build();
}
 

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
@Test
public void retryFailedExecutionOnNonRestartableJob() throws Exception {
	this.job = this.jobs.get("job").preventRestart()
			.start(this.steps.get("step").tasklet(new Tasklet() {
				@Override
				public RepeatStatus execute(StepContribution contribution,
						ChunkContext chunkContext) throws Exception {
					throw new RuntimeException("Planned");
				}
			}).build()).incrementer(new RunIdIncrementer()).build();
	this.runner.execute(this.job, new JobParameters());
	this.runner.execute(this.job, 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.
	assertEquals(2, this.jobExplorer.getJobInstances("job", 0, 100).size());
}
 

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
@Test
public void retryFailedExecutionWithNonIdentifyingParameters() throws Exception {
	this.job = this.jobs.get("job")
			.start(this.steps.get("step").tasklet(new Tasklet() {
				@Override
				public RepeatStatus execute(StepContribution contribution,
						ChunkContext chunkContext) throws Exception {
					throw new RuntimeException("Planned");
				}
			}).build()).incrementer(new RunIdIncrementer()).build();
	JobParameters jobParameters = new JobParametersBuilder().addLong("id", 1L, false)
			.addLong("foo", 2L, false).toJobParameters();
	this.runner.execute(this.job, jobParameters);
	this.runner.execute(this.job, jobParameters);
	assertEquals(1, this.jobExplorer.getJobInstances("job", 0, 100).size());
}
 

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
@Bean(name = "demoJob")
public Job demoJob() throws Exception {
    return jobBuilderFactory.get("demoJob")
            .incrementer(new RunIdIncrementer())
            .listener(demoJobListener)
            .flow(demoStep1())
            .next(decideIfGoodToContinue())
            .on(c(NO))
            .end()
            .on(c(YES))
            .to(optionalStep())
            .end()
            .build();
}
 

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
@Bean(name = "githubJob")
public Job githubJob() throws Exception {
    return jobBuilderFactory.get("githubJob")
            .incrementer(new RunIdIncrementer())
            .listener(githubJobListener)
            .flow(githubStep1())
            .end()
            .build();
}
 

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
/**
 * Create job one.
 * 
 * @return Job job one
 */
@Bean
public Job oneJob() {
    return jobBuilderFactory.get("one-job") //
                            .incrementer(new RunIdIncrementer()) //
                            .listener(listener) //
                            .flow(oneStep()) //
                            .end() //
                            .build();
}
 

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
/**
 * @jobName job名称
 * 创建Job名称为jobName的任务
 */
public Job job(BatchRunConfDto conf, String jobName, String typeId, String scriptFile) {
    Step step = stepOne(conf, jobName, typeId, scriptFile);
    return jobBuilderFactory.get(jobName)
            .incrementer(new RunIdIncrementer())
            .start(step)
            .build();
}
 

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
/**
 * Create the job to push the vulnerability data from BlackDuck to Fortify Job
 *
 * @return Job
 */
@Bean
public Job pushBlackDuckScanToFortifyJob() {
    logger.info("Push Blackduck Scan data to Fortify Job");
    return jobBuilderFactory.get("Push Blackduck Scan data to Fortify Job")
            .incrementer(new RunIdIncrementer())
            .listener(this)
            .flow(createMappingParserStep())
            .end().build();
}
 

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
@Bean(name = JOB_NAME)
public Job lhClubImportJob(
        @Qualifier(DOWNLOAD_STEP) Step download,
        @Qualifier(TRUNCATE_STEP) Step truncate,
        @Qualifier(IMPORT_STEP) Step importStep,
        @Qualifier(SYNCHRONIZE_STEP) Step synchronizeStep) {
    return jobBuilderFactory.get(JOB_NAME)
            .incrementer(new RunIdIncrementer())
            .listener(new LHHuntingClubCSVCleaner())
            .start(download)
            .next(truncate)
            .next(importStep)
            .next(synchronizeStep)
            .build();
}
 

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
@Bean(name = JOB_NAME)
public Job innofactorImportJob(@Qualifier(STEP_NAME) Step innofactorImportStep) {
    return jobBuilder.get(JOB_NAME)
            .incrementer(new RunIdIncrementer())
            .validator(MetsastajaRekisteriJobParameters.createValidator())
            .start(innofactorImportStep)
            .next(innofactorArchiveStep())
            .next(innofactorPostProcessStep())
            .build();
}
 

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
@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);
}
 

import org.springframework.batch.core.launch.support.RunIdIncrementer; //导入依赖的package包/类
@Test
public void retryFailedExecution() throws Exception {
	this.job = this.jobs.get("job")
			.start(this.steps.get("step").tasklet(new Tasklet() {
				@Override
				public RepeatStatus execute(StepContribution contribution,
						ChunkContext chunkContext) throws Exception {
					throw new RuntimeException("Planned");
				}
			}).build()).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(1);
}