如何在@Transactional SpringBootTest测试用例中测试spring批处理作业？

Question

我今天好像赢不了...

1. 有没有一种方法可以从Spock SpringBootTest集成测试中的oneTomany关系中读取，而无需将测试注释为@transactional或添加不切实际的spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true？
2. 或者，是否有方法从@transactional测试用例中启动Spring-Batch作业？

让我详细说明...

我试图为我的Spring Batch reporting流程提供一个简单的Spring Boot Integration测试，该测试从Dangled web of DB2表中读取数据，并为感兴趣的系统生成一系列更改消息。我使用的是Groovy Spock测试框架和一个H2内存数据库，其中填充了我的DB2表数据的代表性片段。

在测试开始时，我试图使用给定表中的每个实体在驱动消息传递的更改跟踪表中生成条目。

setup:
List allExistingTestPeople = peopleRepository.findAll()
Collections.shuffle(allExistingTestPeople)
allExistingTestPeople?.each { Person person ->
    Nickname nicknames = person.nicknames
    nicknames?.each { Nickname nickname ->
        changeTrackingRepository.save(new Change(personId: person.id, nicknameId: nickname.id, status: NEW))
    }
}

以下是我的DB2域类：

@Entity
@Table(name = "T_PERSON")
public class Person {

    @Id
    @Column(name = "P_ID")
    private Integer id;

    @Column(name = "P_NME")
    private String name;

    @OneToMany(targetEntity = Nickname.class, mappedBy = "person")
    private List<Nickname> nicknames;
}

@Entity
@Table(name = "T_NICKNAME")
public class Nickname{

    @EmbeddedId
    private PersonNicknamePK id;

    @Column(name = "N_NME")
    private String nickname;

    @ManyToOne(optional = false, targetEntity = Person.class)
    @JoinColumn(name = "P_ID", referencedColumnName="P_ID", insertable = false, updatable = false)
    private Person person;
}

@Embeddable
public class PersonNicknamePK implements Serializable {

    @Column(name="P_ID")
    private int personId;

    @Column(name="N_ID")
    private short nicknameId;
}

但是我得到了这个LazyInitializationException，尽管我是从测试用例上下文中的OneTomany关系中读取的...

org.hibernate.LazyInitializationException: failed to lazily initialize a collection of role: com.my.package.db2.model.Person.nicknames, could not initialize proxy - no Session
at org.hibernate.collection.internal.AbstractPersistentCollection.throwLazyInitializationException(AbstractPersistentCollection.java:602)
at org.hibernate.collection.internal.AbstractPersistentCollection.withTemporarySessionIfNeeded(AbstractPersistentCollection.java:217)
at org.hibernate.collection.internal.AbstractPersistentCollection.readSize(AbstractPersistentCollection.java:161)
at org.hibernate.collection.internal.PersistentBag.size(PersistentBag.java:350)

我在网上遇到了使用@transactional注释来注释测试用例的建议，这无疑让我更进一步，使我能够从这个oneTomany关系中阅读。但是，当我尝试启动Spring批处理作业时，我希望从when子句进行测试：

@Transactional
def "Happy path test to validate I can generate a report of changes"() {
    setup:
    //... See above

    when:
    service.launchBatchJob()

    then:
    //... Messages are generated
} 

我得到了一个异常，即Spring批处理作业不能从事务的上下文中启动！尽管我通过ResourceLesTransActionManager和MapJobRepositoryFactoryBean使用内存中的作业管理器，但由于这只是我编写的一个短期计划脚本······

java.lang.IllegalStateException: Existing transaction detected in JobRepository. Please fix this and try again (e.g. remove @Transactional annotations from client).
    at org.springframework.batch.core.repository.support.AbstractJobRepositoryFactoryBean$1.invoke(AbstractJobRepositoryFactoryBean.java:177)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:186)
    at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:212)
    at com.sun.proxy.$Proxy125.createJobExecution(Unknown Source)
    at org.springframework.batch.core.launch.support.SimpleJobLauncher.run(SimpleJobLauncher.java:134)
    at com.my.package.service.MyService.launchBatchJob(MyService.java:30)

到目前为止，唯一可行的方法是取消@transactional注释，而是将spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true添加到我的application-test.properties文件中。但是，这似乎不是一个很好的主意，因为它不现实--如果我添加了这个，那么即使代码中有一个错误是由于惰性初始化异常造成的，我也不会在测试中看到它。

对不起小说，希望有人能给我指明正确的方向：（

编辑：

还有我的内存Spring-Batch配置，在其中我尝试关闭事务验证。不幸的是，虽然这让我更进一步，Spring Batch Partioner的autowired EntityManager突然无法在H2数据库中运行查询。

@Configuration
@EnableBatchProcessing
public class InMemoryBatchManagementConfig {

    @Bean
    public ResourcelessTransactionManager resourceslessTransactionManager() {
        ResourcelessTransactionManager resourcelessTransactionManager = new ResourcelessTransactionManager();
        resourcelessTransactionManager.setNestedTransactionAllowed(true);
        resourcelessTransactionManager.setValidateExistingTransaction(false);
        return resourcelessTransactionManager;
    }

    @Bean
    public MapJobRepositoryFactoryBean mapJobRepositoryFactory(ResourcelessTransactionManager txManager)
            throws Exception {
        MapJobRepositoryFactoryBean factory = new MapJobRepositoryFactoryBean(txManager);
        factory.setValidateTransactionState(false);
        factory.afterPropertiesSet();
        return factory;
    }

    @Bean
    public JobRepository jobRepository(MapJobRepositoryFactoryBean factory) throws Exception {
        return factory.getObject();
    }

    @Bean
    public SimpleJobLauncher jobLauncher(JobRepository jobRepository) throws Exception {
        SimpleJobLauncher launcher = new SimpleJobLauncher();
        launcher.setJobRepository(jobRepository);
        launcher.afterPropertiesSet();
        return launcher;
    }

    @Bean
    public JobExplorer jobExplorer(MapJobRepositoryFactoryBean factory) {
        return new SimpleJobExplorer(factory.getJobInstanceDao(), factory.getJobExecutionDao(),
                factory.getStepExecutionDao(), factory.getExecutionContextDao());
    }

    @Bean
    public BatchConfigurer batchConfigurer(MapJobRepositoryFactoryBean mapJobRepositoryFactory,
                                           ResourcelessTransactionManager resourceslessTransactionManager,
                                           SimpleJobLauncher jobLauncher,
                                           JobExplorer jobExplorer) {
        return new BatchConfigurer() {
            @Override
            public JobRepository getJobRepository() throws Exception {
                return mapJobRepositoryFactory.getObject();
            }

            @Override
            public PlatformTransactionManager getTransactionManager() throws Exception {
                return resourceslessTransactionManager;
            }

            @Override
            public JobLauncher getJobLauncher() throws Exception {
                return jobLauncher;
            }

            @Override
            public JobExplorer getJobExplorer() throws Exception {
                return jobExplorer;
            }
        };
    }
}

Answer 1

发生此错误是因为您的代码已经在Spring Batch驱动的事务中执行。因此在事务范围内运行作业是不正确的。但是，如果您仍然希望禁用由作业存储库完成的事务验证，可以将validateTransactionState设置为false，请参见AbstractJobRepositoryFactoryBean#SetValidateTransactionState。

也就是说，在事务中运行作业不是修复org.hibernate.lazyInitializationException的方法。属性spring.jpa.properties.hibernate.enable_lazy_load_no_trans=true的存在是有原因的，如果它适合您，我相信它是一种比在事务中运行整个作业更好的方法（顺便说一句，如果必须为此使用事务，我会将其范围缩小到最小（例如步骤），而不是整个作业）。