Question

有两个示例，说明了如何在不将元数据持久保存到数据库的情况下使用Spring Batch。以下是有关此事的一些示例和相关问题：

但是我有一个稍微不同的用例：我有一些每小时运行一次的作业，我想将元数据保存到我的数据库中（例如，创建报告，运行一些测试，两者可能都略有不同）处理繁重）。我还有一些其他类型的作业每分钟左右运行一次（例如，解锁由于重复输入错误密码而被锁定的用户帐户等），这些作业不涉及很多处理，而是一个简单的sql查询。

这是两个部分的问题：

1。。有没有一种方法可以将第一类作业（例如报表处理）的元数据保留在数据库中，而根本不使用第二种作业的数据库持久性（例如解锁用户帐户））？

2。？或者，即使将Spring Batch用于第二种类型的工作也会过分/根本不需要吗？只需使用带有@Scheduled批注的方法就足够了？

Answer 1

有没有一种方法可以将第一类作业（例如报告处理）的元数据保留在数据库中，而根本不使用第二类作业的数据库持久性（例如解锁用户帐户）？

这是配置问题。您可以使用Spring profiles作为数据源。这个想法是定义一个持久的数据源和一个内存中的数据源。然后像往常一样使用数据源配置所有作业，并在运行时使用正确的配置文件运行它们。这是一个简单的示例：

import javax.sql.DataSource;

import com.zaxxer.hikari.HikariDataSource;

import org.springframework.batch.core.Job;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;

@Configuration
@EnableBatchProcessing
public class JobsConfiguration {

    @Bean
    public Job job1() {
        return null;
    }

    @Bean
    public Job job2() {
        return null;
    }

    @Bean
    @Profile("in-memory")
    public DataSource embeddedDataSource() {
        return new EmbeddedDatabaseBuilder()
                .setType(EmbeddedDatabaseType.HSQL)
                .addScript("/org/springframework/batch/core/schema-hsqldb.sql")
                .build();
    }

    @Bean
    @Profile("persistent")
    public DataSource persistentDataSource() {
        HikariDataSource hikariDataSource = new HikariDataSource();
        // TODO configure datasource
        return hikariDataSource;
    }
}

如果使用-Dspring.profiles.active=in-memory运行应用程序，则应用程序上下文中将只有嵌入式数据源bean，@EnableBatchProcessing自动配置的作业存储库将使用该嵌入式数据源bean。

或者，甚至将Spring Batch用于第二种类型的工作是否会过分/根本不需要？只需使用带有@Scheduled批注的方法就足够了？

which do not involve much of processing but a simple sql query：如果这是一个简单的sql查询，而您不需要保留元数据，那么最好使用以@Scheduled注释的方法，该方法使用{{1} }以运行查询。

Answer 2

关于Mahmoud Ben Hassine的建议（已删除@EnableBatchProcessing，针对一些不相关的问题-see here），这就是我实现所寻找的目标的方法：

我有两个配置类：

@Configuration
public class SpringBatchConfiguration extends DefaultBatchConfigurer {

    @Inject public SpringBatchConfiguration(DataSource dataSource) {
        super(dataSource);
    }

    @Bean(name = "persistentJobLauncher")
    public JobLauncher jobLauncher() throws Exception {
        return super.createJobLauncher();
    }

    @Bean
    @Primary
    public StepBuilderFactory stepBuilderFactory() {
        return new StepBuilderFactory(super.getJobRepository(), super.getTransactionManager());
    }

    @Bean
    @Primary
    public JobBuilderFactory jobBuilderFactory(){
        return new JobBuilderFactory(super.getJobRepository());
    }

    @Bean
    public JobExplorer jobExplorer() {
        return super.getJobExplorer();
    }

    @Bean
    public JobRepository jobRepository() {
        return super.getJobRepository();
    }

    @Bean
    public ListableJobLocator jobLocator() {
        return new MapJobRegistry();
    }
}

和内存中的一个：

@Configuration
public class SpringInMemoryBatchConfiguration extends DefaultBatchConfigurer {

    @Inject public SpringInMemoryBatchConfiguration() {
    }

    @Bean(name = "inMemoryJobLauncher")
    public JobLauncher inMemoryJobLauncher() throws Exception {
        return super.createJobLauncher();
    }

    @Bean(name = "inMemoryStepBuilderFactory")
    public StepBuilderFactory stepBuilderFactory() {
        return new StepBuilderFactory(super.getJobRepository(), super.getTransactionManager());
    }

    @Bean(name = "inMemoryJobBuilderFactory")
    public JobBuilderFactory inMemoryJobBuilderFactory(){
        return new JobBuilderFactory(super.getJobRepository());
    }
}

当我想开始“持久”工作时，我使用@Qualifier(value = "persistentJobLauncher") JobLauncher launcher并开始一个“内存中”任务：@Qualifier(value = "inMemoryJobLauncher") JobLauncher launcher。

有没有一种方法可以跳过仅针对特定作业的Spring Batch持久化元数据？

2 个答案: