内存中的Spring批处理（MapJobRepositoryFactoryBean）清除旧作业而不是正在运行的作业

我使用SpringBatch将批处理作业ie安排在内存中，作为项目特定的需求（ie不在生产中，仅用于测试环境），下面是我的配置类

// Batch Scheulder class
    package org.learning.scheduler
    import org.springframework.batch.core.explore.JobExplorer;
    import org.springframework.batch.core.explore.support.SimpleJobExplorer;
    import org.springframework.batch.core.launch.support.SimpleJobLauncher;
    import org.springframework.batch.core.repository.JobRepository;
    import org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean;
    import org.springframework.batch.support.transaction.ResourcelessTransactionManager;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.task.SimpleAsyncTaskExecutor;
    import org.springframework.scheduling.annotation.EnableScheduling;

    /**
     * Job Inmemory Config
     * 
     */
    @EnableScheduling
    @Configuration
    public class InmemoryJobConfig  {


        @Bean
        public ResourcelessTransactionManager transactionManager() {
            return new ResourcelessTransactionManager();
        }

        @Bean
        public MapJobRepositoryFactoryBean mapJobRepositoryFactoryBean(ResourcelessTransactionManager resourcelessTransactionManager) throws Exception {
            MapJobRepositoryFactoryBean factoryBean = new MapJobRepositoryFactoryBean(resourcelessTransactionManager);
            factoryBean.afterPropertiesSet();
            return factoryBean;
        }

        @Bean
        public JobRepository jobRepository(MapJobRepositoryFactoryBean factoryBean) throws Exception{
            return (JobRepository) factoryBean.getObject();
        }
        @Bean
        public JobExplorer jobExplorer(MapJobRepositoryFactoryBean repositoryFactory) {
            return new SimpleJobExplorer(repositoryFactory.getJobInstanceDao(), repositoryFactory.getJobExecutionDao(),
                    repositoryFactory.getStepExecutionDao(), repositoryFactory.getExecutionContextDao());
        }

        @Bean
        public SimpleJobLauncher jobLauncher(JobRepository jobRepository) throws Exception {
            SimpleJobLauncher simpleJobLauncher = new SimpleJobLauncher();
            simpleJobLauncher.setJobRepository(jobRepository);
            simpleJobLauncher.setTaskExecutor(new SimpleAsyncTaskExecutor());

            return simpleJobLauncher;
        }
    }

//Job ConfiguratinClass

/**
 * Batch Entry Point for Scheduler for all Jobs
 *
 * 
 */
@Import({InmemoryJobConfig.class})
@EnableBatchProcessing
@Configuration
@Slf4j
public class BatchScheduler {


    @Autowired
    private JobBuilderFactory jobs;

    @Autowired
    private StepBuilderFactory steps;

    @Autowired
    private SimpleJobLauncher jobLauncher;


    @Autowired
    private JobExplorer jobExplorer;

    @Autowired
    private MapJobRepositoryFactoryBean mapJobRepositoryFactoryBean;


    @Bean
    public ItemReader<UserDTO> userReader() {
        return new UserReader();

    }

    @Bean
    public ItemWriter<User> userWriter() {
        return new UserWriter();

    }

    @Bean
    public ItemReader<OrderDTO> orderReader() {
        return new OrderReader();
    }

    @Bean
    public ItemWriter<Order> orderWriter() {
        return new OrderWriter();
    }

    @Bean
    public Step userStep(ItemReader<UserDTO> reader, ItemWriter<User> writer) {
        return steps.get("userStep")
                .<UserDTO, User>chunk(20)
                .reader(userReader())
                .processor(new UserProcessor())
                .writer(userWriter())
                .build();
    }

    @Bean
    public Step orderStep(ItemReader<OrderDTO> reader, ItemWriter<Order> writer) {
        return steps.get("orderStep")
                .<OrderDTO, Order>chunk(20)
                .reader(orderReader())
                .processor(new OrderProcessor())
                .writer(orderWriter())
                .build();
    }


    @Bean
    public Job userJob() {
        return jobs.get("userJob").incrementer(new RunIdIncrementer()).start(userStep(userReader(), userWriter())).build();
    }

    @Bean
    public Job orderJob() {
        return jobs.get("orderJob").incrementer(new RunIdIncrementer()).start(orderStep(orderReader(), orderWriter())).build();
    }


    @Scheduled(cron = "0 0/15 * * *  ?")
    public void scheduleUserJob() throws JobExecutionException {
        Set<JobExecution> runningJob = jobExplorer.findRunningJobExecutions("userJob");

        if (!runningJob.isEmpty()) {
            throw new JobExecutionException(" User Job  is already in Start State  ");
        }

        JobParameters userParam =
                new JobParametersBuilder().addLong("date", System.currentTimeMillis())
                        .toJobParameters();
        jobLauncher.run(userJob(), userParam);

    }

    @Scheduled(cron = "0 0/15 * * *  ?")
    public void scheduleOrderJob() throws JobExecutionException {
        Set<JobExecution> runningJob = jobExplorer.findRunningJobExecutions("orderJob");

        if (!runningJob.isEmpty()) {
            throw new JobExecutionException(" Order Job  is already in Start State  ");
        }

        JobParameters orderParam =
                new JobParametersBuilder().addLong("date", System.currentTimeMillis())
                        .toJobParameters();
        jobLauncher.run(orderJob(), orderParam);

    }

    @Scheduled(cron = "0 0/30 * * *  ?")
    public void scheduleCleanupMemoryJob() throws BatchException {
        Set<JobExecution> orderRunningJob = jobExplorer.findRunningJobExecutions("orderJob");
        Set<JobExecution> userRunningJob = jobExplorer.findRunningJobExecutions("userJob");
        if (!orderRunningJob.isEmpty() || !userRunningJob.isEmpty()) {
            throw new BatchException(" Order/user Job  is running state , cleanup job is aborted  ");
        }

        mapJobRepositoryFactoryBean.clear();

    }
}

//批处理Scheulder类
包org.learning.scheduler
导入org.springframework.batch.core.explore.JobExplorer；
导入org.springframework.batch.core.explore.support.SimpleJobExplorer；
导入org.springframework.batch.core.launch.support.simplejoblancher；
导入org.springframework.batch.core.repository.JobRepository；
导入org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean；
导入org.springframework.batch.support.transaction.ResourcesTranslationManager；
导入org.springframework.context.annotation.Bean；
导入org.springframework.context.annotation.Configuration；
导入org.springframework.core.task.SimpleAsyncTaskExecutor；
导入org.springframework.scheduling.annotation.EnableScheduling；
/**
*内存配置中的作业
* 
*/
@使能调度
@配置
MemoryJobConfig中的公共类{
@豆子
公共资源事务管理器事务管理器（）{
返回新的ResourcesTransactionManager（）；
}
@豆子
公共映射JobRepositoryFactoryBean映射JobRepositoryFactoryBean（ResourcelessTransactionManager ResourcelessTransactionManager）引发异常{
MapJobRepositoryFactoryBean factoryBean=新的MapJobRepositoryFactoryBean（resourcelessTransactionManager）；
factoryBean.AfterPropertieSet（）；
返回factoryBean；
}
@豆子
public JobRepository JobRepository（MapJobRepositoryFactoryBean factoryBean）引发异常{
返回（JobRepository）factoryBean.getObject（）；
}
@豆子
public JobExplorer JobExplorer（MapJobRepositoryFactoryBean repositoryFactory）{
返回新的SimpleJobExplorer（repositoryFactory.getJobInstanceDao（），repositoryFactory.getJobExecutionDao（），
repositoryFactory.getStepExecutionDao（），repositoryFactory.getExecutionContextDao（））；
}
@豆子
公共SimpleJobLauncher jobLauncher（JobRepository JobRepository）引发异常{
simplejoblancher simplejoblancher=新的simplejoblancher（）；
setJobRepository（jobRepository）；
setTaskExecutor（新的SimpleAsyncTaskExecutor（））；
返回simplejoblancher；
}
}
//作业配置类
/**
*所有作业的计划程序的批处理入口点
*
* 
*/
@导入（{InmemoryJobConfig.class}）
@启用批处理
@配置
@Slf4j
公共类批处理调度器{
@自动连线
私人建筑工地；
@自动连线
私人StepBuilderFactorySteps；
@自动连线
私有simplejoblancher作业启动器；
@自动连线
私人JobExplorer；
@自动连线
私有MapJobRepositoryFactoryBean MapJobRepositoryFactoryBean；
@豆子
public ItemReader userReader（）{
返回新的UserReader（）；
}
@豆子
public ItemWriter userWriter（）{
返回新的UserWriter（）；
}
@豆子
public ItemReader orderReader（）{
返回新的OrderReader（）；
}
@豆子
公共ItemWriter orderWriter（）{
返回新的OrderWriter（）；
}
@豆子
公共步骤userStep（ItemReader读取器、ItemWriter编写器）{
返回steps.get（“userStep”）
.chunk（20）
.reader（userReader（））
.processor（新的UserProcessor（））
.writer（userWriter（））
.build（）；
}
@豆子
公共步骤orderStep（ItemReader reader、ItemWriter writer）{
返回步骤。获取（“orderStep”）
.chunk（20）
.reader（orderReader（））
.processor（新的OrderProcessor（））
.writer（orderWriter（））
.build（）；
}
@豆子
公共作业userJob（）{
返回jobs.get（“userJob”）.incrementer（new RunIdIncrementer（））.start（userStep（userReader（），userWriter（））.build（）；
}
@豆子
公共作业订单作业（）{
return jobs.get（“orderJob”）.incrementer（new RunIdIncrementer（））.start（orderStep（orderReader（），orderWriter（））.build（）；
}
@计划（cron=“0/15***？”）
public void scheduleUserJob（）引发JobExecutionException异常{
设置runningJob=jobExplorer.findRunningJobExecutions（“用户作业”）；
如果（！runningJob.isEmpty（））{
抛出新JobExecutionException（“用户作业已处于启动状态”）；
}
JobParameters用户参数=
新作业参数builder（）.addLong（“日期”，System.currentTimeMillis（））
.toJobParameters（）；
运行（userJob（），userParam）；
}
@计划（cron=“0/15***？”）
public void scheduleOrderJob（）引发JobExecutionException异常{
设置runningJob=jobExplorer.findRunningJobExecutions（“orderJob”）；
如果（！runningJob.isEmpty（））{
抛出新JobExecutionException（“订单作业已处于启动状态”）；
}
作业参数orderParam=
新作业参数builder（）.addLong（“日期”，System.currentTimeMillis（））
.toJobParameters（）；
运行（orderJob（），orderParam）；
}
@计划（cron=“0/30***？”）
public void scheduleCleanupMemoryJob（）引发BatchException{
设置orderRunningJob=jobExplorer.findRunningJobExecutions（“orderJob”）；
设置userRunningJob=jobExplorer.findRunningJobExecutions（“userJob”）；
如果（！orderRunningJob.isEmpty（）| |！userRunningJob.isEmpty（））{
抛出新的BatchException（“订单/用户作业处于运行状态，清理作业中止”）；
}
mapJobRepositoryFactoryBean.clear（）；
}
}

我