将作业配置导入通用作业配置类（注释配置）

Question

我正在重构一个传统的基于Spring Batch XML的应用程序，以使用注释配置。我想了解如何将以下XML文件转换为基于注释的配置，并保持相同的关注分离。

为了便于讨论，这里有一个简单的例子。

job-config-1.xml

<job id="job1" xmlns="http://www.springframework.org/schema/batch">
               <batch:step id="step1">
                    <batch:tasklet throttle-limit="20" task-executor="taskExecutor">
                        <batch:chunk reader="reader1"
                            writer="writer1" commit-interval="500" />
                    </batch:tasklet>
                </batch:step>
</job>

job-config-2.xml

<job id="job2" xmlns="http://www.springframework.org/schema/batch">
                   <batch:step id="step2">
                        <batch:tasklet throttle-limit="20" task-executor="taskExecutor">
                            <batch:chunk reader="reader2"
                                writer="writer2" commit-interval="500" />
                        </batch:tasklet>
                    </batch:step>
</job>

job-config-3。xml

<import
        resource="classpath*:/spring/jobs/job-config-1.xml" />
<import
        resource="classpath*:/spring/jobs/job-config-2.xml" />
<batch:job id="jobFlow">

            
    <batch:step id="step1" next="step2">
        <job ref="job1" job-launcher="jobLauncher" />
    </batch:step>

    <batch:step id="step2">
        <job ref="job2" job-launcher="jobLauncher" />
    </batch:step>
    
</batch:job>

我想从XML配置转移到Java配置。我想为每个XML创建3个作业配置类。比如说JobConfig1。java，JobConfig2。java和JobConfig3。JAVA

JobConfig3.java将导入JobConfig1.java和JobConfig2.java；然而，我在文档中找不到这种结构的示例。我该怎么做呢？

注意：我不打算使用Spring Boot。只需通过注释配置常规Spring Batch。

Answer 1

您可以使用JobStep来定义步骤，例如在Job3中，step1应该如下所示：

@Autowired
ApplicationContext context;

public Step step1() {
    return stepBuilderFactory.get("step1").job(context.getBean("job1", Job.class))
            .parametersExtractor(new DefaultJobParametersExtractor()).build();
}

从这里，您可以像运行任何其他步骤一样运行step1，但当job3将调用此步骤时，将执行job1的所有步骤job1是您的校长的子作业job3。

对于job1，他的定义应该是这样的：（与JobConfig2相同）

@Configuration
class JobConfig1 {

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

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

    // definition of steps
    public Step step1() {
        return null;
    }
}

Answer 2

与XML配置等效的方法是在每个作业自己的配置类中定义每个作业，然后在主作业的配置中导入这些类。下面是一个简单的例子：

import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
// @Import({Job1Config.class, Job2Config.class}) // use this if the classes where you define sub jobs are not nested
@EnableBatchProcessing
public class MainJobConfig {

    @Bean
    public Job mainJob(JobBuilderFactory jobs, StepBuilderFactory steps, Job job1, Job job2, JobLauncher jobLauncher) {
        return jobs.get("mainJob")
                .start(steps.get("subJob1").job(job1).launcher(jobLauncher).build())
                .next(steps.get("subJob2").job(job2).launcher(jobLauncher).build())
                .build();
    }
    
    @Configuration
    static class Job1Config {
        // define job 1 artefacts (reader, writer, steps, etc)
        // for simplicity, the step is inlined in the job definition
        @Bean
        public Job job1(JobBuilderFactory jobs, StepBuilderFactory steps) {
            return jobs.get("job1")
                    .start(steps.get("job1Step1").tasklet((contribution, chunkContext) -> {
                        System.out.println("job1");
                        return RepeatStatus.FINISHED;
                    }).build())
                    .build();
        }
    }

    @Configuration
    static class Job2Config {
        // define job 2 artefacts (reader, writer, steps, etc)
        // for simplicity, the step is inlined in the job definition
        @Bean
        public Job job2(JobBuilderFactory jobs, StepBuilderFactory steps) {
            return jobs.get("job2")
                    .start(steps.get("job2Step1").tasklet((contribution, chunkContext) -> {
                        System.out.println("job2");
                        return RepeatStatus.FINISHED;
                    }).build())
                    .build();
        }
    }

    public static void main(String[] args) throws Exception {
        ApplicationContext context = new AnnotationConfigApplicationContext(MainJobConfig.class);
        JobLauncher jobLauncher = context.getBean(JobLauncher.class);
        Job job = context.getBean("mainJob", Job.class);
        jobLauncher.run(job, new JobParameters());
    }

}