如何成功地为Spring批处理JUnit5测试的Spring任务加载JobLauncherTestUtils类

Question

对于spring批处理测试，我有一个看似简单的配置。但是，测试无法加载上下文。该错误告诉我存在一个与数据源相关的不可解析循环引用。如果移除数据源，则错误将更改为未定义数据源。我所要实现的只是能够加载JobLauncherTestUtils，然后启动一个用于测试步骤的作业。它看起来很简单，但要加载一个简单的工作来进行测试却非常困难。我正在Java12、Spring5和spring batch 2.2.0发行版和JUnit5(Jupiter)上运行spring Boot2。配置有什么问题？我需要做什么改变。我认为您不必指定数据源配置，但如果不配置数据源，就无法实现加载。这是我的配置。我真的很感谢你帮我弄清楚我的配置有什么问题。我的目标只是成功地自动生成JobLauncherTestUtils类。

like 

class BatchTest {
   @Autowired
   JobLauncherTestUtils jobLauncherTestUtils;
}


import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
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.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.launch.support.SimpleJobLauncher;
import org.springframework.batch.core.repository.support.JobRepositoryFactoryBean;
import org.springframework.batch.test.JobLauncherTestUtils;
import org.springframework.batch.test.context.SpringBatchTest;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabase;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit.jupiter.SpringExtension;


@ExtendWith(SpringExtension.class)
@SpringBatchTest
@ContextConfiguration(classes = {BatchTest.BatchConfiguration.class, 
BatchAutoConfiguration.class})
@TestPropertySource(properties = "debug=true")
public class BatchTest {

@Autowired
private JobLauncherTestUtils jobLauncherTestUtils;

@Test
public void test() {
    this.jobLauncherTestUtils.launchStep("orderProcessingJob");
    //assertions 
}

    @Configuration
    @EnableBatchProcessing
    public static class BatchConfiguration {

    private  JobBuilderFactory jobBuilderFactory;

    @Bean(name="jobLauncherTestUtils")
    public JobLauncherTestUtils jobLauncherTestUtils() throws Exception {
        JobLauncherTestUtils jl = new JobLauncherTestUtils();
        jl.setJobLauncher(jobLauncher());
        jl.setJob(orderProcessorJob());
        jl.setJobRepository(jobRepository().getObject());
        return jl;
    }

        @Bean
        public JobRepositoryFactoryBean jobRepository() {
        JobRepositoryFactoryBean jobRepositoryFactoryBean = new JobRepositoryFactoryBean();
        jobRepositoryFactoryBean.setDataSource(dataSource());
        return jobRepositoryFactoryBean;
      }


    @Bean
    public Job orderProcessorJob() {
        return jobBuilderFactory.get("orderProcessingJob")
                .incrementer(new RunIdIncrementer())
                .flow(orderIntakeStep())
                .end()
                .build();
    }

    private Step orderIntakeStep() {
        // code for order Intake
    }

    @Bean
    public JobLauncher jobLauncher() throws Exception {
        SimpleJobLauncher jobLauncher = new SimpleJobLauncher();
        jobLauncher.setJobRepository(jobRepository().getObject());
        return jobLauncher;
    }


    private  StepBuilderFactory stepBuilderFactory;


    @Bean
    public EmbeddedDatabase dataSource() {
        return new EmbeddedDatabaseBuilder().build();
    }


    @Autowired
    public BatchConfiguration(JobBuilderFactory jobBuilderFactory , 
                                          StepBuilderFactory stepBuilderFactory) {
        this.jobBuilderFactory = jobBuilderFactory;
        this.stepBuilderFactory = stepBuilderFactory;
     }

    }
 }

原因：org.springframework.beans.factory.UnsatisfiedDependencyException：创建名为“BatchTest.BatchConfiguration”的bean时出错：

通过构造函数参数0表示的未满足的依赖项；嵌套异常

是org.springframework.beans.factory.unsatisfiedDependencyException：创建名为“org.springframework.batch.core.configuration.annotation.SimpleBatchConfiguration”的bean时出错：

通过字段“Data Source”表示的未满足的依赖关系；嵌套异常为org.SpringFramework.Beans.Factory.BeanCurrentlyIncreationException：

创建名为“BatchTest.BatchConfiguration”的bean时出错：请求的bean当前正在创建中：是否存在不可解析的循环引用？

Answer 1

通过字段“Data Source”表示的未满足的依赖关系；嵌套异常为org.SpringFramework.Beans.Factory.BeanCurrentlyIncreationException：

创建名为“BatchTest.BatchConfiguration”的bean时出错：请求的bean当前正在创建中：是否存在不可解析的循环引用？

您试图在BatchConfiguration#jobRepository()中注入的数据源是在同一类(datasource()方法）中创建的，因此出现错误。您需要在一个单独的类中提取数据源配置，如下所示：

@Configuration
public static class DataSourceConfig {
   @Bean
   public EmbeddedDatabase dataSource() {
      return new EmbeddedDatabaseBuilder().build();
   }
}

@Configuration
@Import(DataSourceConfig.class)
@EnableBatchProcessing
public static class BatchConfiguration {

   // ..       

   @Bean
   public JobRepositoryFactoryBean jobRepository(DataSource dataSource) {
      JobRepositoryFactoryBean jobRepositoryFactoryBean = new JobRepositoryFactoryBean();
      jobRepositoryFactoryBean.setDataSource(dataSource);
       return jobRepositoryFactoryBean;
  }
  
  // ..
}

我的目标只是成功地自动生成JobLauncherTestUtils类。

由于您使用的是@SpringBatchTest，因此不需要手动创建JobLauncherTestUtils（在您的JobLauncherTestUtils()方法中），这个注释的目标是为您导入它，查看它的Javadoc。下面是一个典型的用法：

@RunWith(SpringRunner.class)
@SpringBatchTest
@ContextConfiguration(classes = MyBatchJobConfiguration.class)
public class MyBatchJobTests {

    @@Autowired
    private JobLauncherTestUtils jobLauncherTestUtils;

    @@Autowired
    private JobRepositoryTestUtils jobRepositoryTestUtils;

    @Before
    public void clearJobExecutions() {
        this.jobRepositoryTestUtils.removeJobExecutions();
    }

    @Test
    public void testMyJob() throws Exception {
        // given
        JobParameters jobParameters = this.jobLauncherTestUtils.getUniqueJobParameters();

        // when
        JobExecution jobExecution = this.jobLauncherTestUtils.launchJob(jobParameters);

        // then
        Assert.assertEquals(ExitStatus.COMPLETED, jobExecution.getExitStatus());
    }

}