Java 类org.springframework.batch.core.configuration.annotation.JobBuilderFactory 实例源码

@Bean
Job personEtl(JobBuilderFactory jobBuilderFactory,
        StepBuilderFactory stepBuilderFactory,
        FlatFileItemReader<Person> reader,
        JdbcBatchItemWriter<Person> writer
) {

    Step step = stepBuilderFactory.get("file-to-database")
            .<Person, Person>chunk(5)
            .reader(reader)
            .writer(writer)
            .build();

    return jobBuilderFactory.get("etl")
            .start(step)
            .build();
}

@Autowired
public DemoJobConfiguration(EntityManagerFactory entityManagerFactory, DemoJobListener demoJobListener, DemoJobStepListener demoJobStepListener, StepBuilderFactory stepBuilderFactory, JobBuilderFactory jobBuilderFactory) {
    this.entityManagerFactory = entityManagerFactory;
    this.demoJobListener = demoJobListener;
    this.demoJobStepListener = demoJobStepListener;
    this.stepBuilderFactory = stepBuilderFactory;
    this.jobBuilderFactory = jobBuilderFactory;
}

@Before
public void init() throws Exception {
    this.context.register(BatchConfiguration.class);
    this.context.refresh();
    JobRepository jobRepository = this.context.getBean(JobRepository.class);
    this.jobLauncher = this.context.getBean(JobLauncher.class);
    this.jobs = new JobBuilderFactory(jobRepository);
    PlatformTransactionManager transactionManager = this.context
            .getBean(PlatformTransactionManager.class);
    this.steps = new StepBuilderFactory(jobRepository, transactionManager);
    this.step = this.steps.get("step").tasklet(new Tasklet() {
        @Override
        public RepeatStatus execute(StepContribution contribution,
                ChunkContext chunkContext) throws Exception {
            return null;
        }
    }).build();
    this.job = this.jobs.get("job").start(this.step).build();
    this.jobExplorer = this.context.getBean(JobExplorer.class);
    this.runner = new JobLauncherCommandLineRunner(this.jobLauncher,
            this.jobExplorer);
    this.context.getBean(BatchConfiguration.class).clear();
}

@Before
public void init() throws Exception {
    this.context.register(BatchConfiguration.class);
    this.context.refresh();
    JobRepository jobRepository = this.context.getBean(JobRepository.class);
    this.jobLauncher = this.context.getBean(JobLauncher.class);
    this.jobs = new JobBuilderFactory(jobRepository);
    PlatformTransactionManager transactionManager = this.context
            .getBean(PlatformTransactionManager.class);
    this.steps = new StepBuilderFactory(jobRepository, transactionManager);
    this.step = this.steps.get("step").tasklet(new Tasklet() {
        @Override
        public RepeatStatus execute(StepContribution contribution,
                ChunkContext chunkContext) throws Exception {
            return null;
        }
    }).build();
    this.job = this.jobs.get("job").start(this.step).build();
    this.jobExplorer = this.context.getBean(JobExplorer.class);
    this.runner = new JobLauncherCommandLineRunner(this.jobLauncher,
            this.jobExplorer);
    this.context.getBean(BatchConfiguration.class).clear();
}

@Autowired
public BlackDuckFortifyPhoneHomeJobConfig(JobLauncher jobLauncher, JobBuilderFactory jobBuilderFactory,
        StepBuilderFactory stepBuilderFactory, HubServices hubServices, PropertyConstants propertyConstants) {
    this.jobLauncher = jobLauncher;
    this.jobBuilderFactory = jobBuilderFactory;
    this.stepBuilderFactory = stepBuilderFactory;
    this.hubServices = hubServices;
    this.propertyConstants = propertyConstants;
}

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

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

@Before
public void init() throws Exception {
    this.context.register(BatchConfiguration.class);
    this.context.refresh();
    JobRepository jobRepository = this.context.getBean(JobRepository.class);
    this.jobLauncher = this.context.getBean(JobLauncher.class);
    this.jobs = new JobBuilderFactory(jobRepository);
    PlatformTransactionManager transactionManager = this.context
            .getBean(PlatformTransactionManager.class);
    this.steps = new StepBuilderFactory(jobRepository, transactionManager);
    this.step = this.steps.get("step").tasklet(new Tasklet() {
        @Override
        public RepeatStatus execute(StepContribution contribution,
                ChunkContext chunkContext) throws Exception {
            return null;
        }
    }).build();
    this.job = this.jobs.get("job").start(this.step).build();
    this.jobExplorer = this.context.getBean(JobExplorer.class);
    this.runner = new JobLauncherCommandLineRunner(this.jobLauncher,
            this.jobExplorer);
    this.context.getBean(BatchConfiguration.class).clear();
}

@Bean
public Job importTicketsJob(final JobBuilderFactory jobs,
                            final Step importTicketStep,
                            final TicketImportJobExecutionListener ticketImportJobExecutionListener) {
    return jobs.get("importTicketsJob")
            .incrementer(new RunIdIncrementer())
            .listener(ticketImportJobExecutionListener)
            .flow(importTicketStep)
            .end()
            .build();
}

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

@Bean
public Job writeJsonFormatJob(JobBuilderFactory jobs, Step stepOne, JobExecutionListener listener) {
    return jobs.get("JsonWriter")
            .incrementer(new RunIdIncrementer())
            .listener(listener)
            .flow(stepOne)
            .end()
            .build();
}

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

@Bean
public Job job(JobBuilderFactory jobBuilderFactory, Step step1, Step step2) {
    return jobBuilderFactory.get(JOB_NAME)
            .start(step1)
            .next(step2)
            .incrementer(new RunIdIncrementer())
            .build();
}

@Bean
Job tweetInfluencers(JobBuilderFactory jobs, Step hiveInfluencers, Step exportInfluencers, Step results) throws Exception {
    return jobs.get("TweetInfluencers")
            .start(hiveInfluencers)
            .next(exportInfluencers)
            .next(results)
            .build();
}

@Bean
Job tweetHashtags(JobBuilderFactory jobs, Step initScript, Step sparkTopHashtags) throws Exception {
    return jobs.get("TweetTopHashtags")
            .start(initScript)
            .next(sparkTopHashtags)
            .build();
}

@Bean
public Job plantUmlJob(JobBuilderFactory jobs, Step s1) {
    return jobs.get("plantUmlJob")
        .incrementer(new RunIdIncrementer())
        .flow(s1)
        .end()
        .build();
}

@Bean
public JobTemplate jobTemplate(final JobLauncher jobLauncher, final JobBuilderFactory jobBuilders,
                               final StepBuilderFactory stepBuilders) {
    return new JobTemplate(jobLauncher, jobBuilders, stepBuilders);
}

/**
 * This method declare the steps that the batch has to follow
 *
 * @param jobs
 * @param s1
 * @return
 */
@Bean
public Job importPerson(JobBuilderFactory jobs, Step s1) {

    return jobs.get("import")
            .incrementer(new RunIdIncrementer()) // because a spring config bug, this incrementer is not really useful
            .flow(s1)
            .end()
            .build();
}

@Bean
public Job customerLoaderJob(JobBuilderFactory jobs, @Qualifier(readCsvFileIntoTableStep) Step s1) {
    return jobs.get(customerLoaderJob)
            .flow(s1)
            .end()
            .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();
 }

public GithubJobConfiguration(JobBuilderFactory jobBuilderFactory, StepBuilderFactory stepBuilderFactory, GithubJobListener githubJobListener, GithubJobUI githubJobUI) {
    this.jobBuilderFactory = jobBuilderFactory;
    this.stepBuilderFactory = stepBuilderFactory;
    this.githubJobListener = githubJobListener;
    this.githubJobUI = githubJobUI;
}

@Bean
@ConditionalOnMissingBean(JobBuilderFactory.class)
public JobBuilderFactory jobBuilderFactory(JobRepository jobRepository) throws Exception {
    return new JobBuilderFactory(jobRepository);
}

@Bean
public JobBuilderFactory jobBuilderFactory() throws Exception {
    return new JobBuilderFactory(jobRepository().getObject());
}

@Bean
public JobBuilderFactory jobBuilders() throws Exception {
    return new JobBuilderFactory(jobRepository());
}

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

public Job1(JobBuilderFactory jobBuilderFactory, Step step1) {
    this.jobBuilderFactory = jobBuilderFactory;
    this.step1 = step1;
}

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

@Bean(name="firstJob")
public Job firstJob(JobBuilderFactory jobs,ItemReader<String> firstReader, ItemWriter<String> firstWriter) throws Exception {
  return jobs.get("firstJob").start(firstStep(firstReader,firstWriter)).build();
}

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

@Bean
public Job job(JobBuilderFactory jobBuilderFactory, @Qualifier("step1") Step step1) {
    return jobBuilderFactory.get("importRdfFromFileJob").start(step1).build();
}

public JobTemplate(final JobLauncher jobLauncher, final JobBuilderFactory jobBuilders,
    final StepBuilderFactory stepBuilders) {
    this.jobLauncher = jobLauncher;
    this.jobBuilders = jobBuilders;
    this.stepBuilders = stepBuilders;
}

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

@Bean
public JobBuilderFactory jobBuilderFactory() {
    return new JobBuilderFactory(jobRepository);
}

@Bean
public JobBuilderFactory jobBuilderFactory(JobRepository jobRepository){
    return new JobBuilderFactory(jobRepository);
}

@Bean
public JobBuilderFactory jobBuilderFactory() throws Exception {
    return new JobBuilderFactory(jobRepository());
}

@Bean
public JobBuilderFactory jobBuilderFactory(JobRepository jobRepository) throws Exception {
    return new JobBuilderFactory(jobRepository);
}

@Bean
public JobBuilderFactory jobBuilderFactory(JobRepository jobRepository) throws Exception {
    return new JobBuilderFactory(jobRepository);
}

@Bean
public JobBuilderFactory jobBuilderFactory() throws Exception {
    return new JobBuilderFactory(jobRepository());
}

/**
 * Defines the Spring Batch job. All we need here is to give it a name.
 *
 * @param jobBuilderFactory
 * @param step
 * @return
 */
@Bean
public Job job(JobBuilderFactory jobBuilderFactory, Step step) {
    return jobBuilderFactory.get("migrationJob").start(step).build();
}