Java 在该场景中使用Tasklet或Chunk

我有一个工作/任务来

读取
给定文件夹/路径的子文件夹/目录
。路径是动态的，我们从
Controller
获取它。目前，我使用了
Tasklet
，有3个Tasklet，一个用于读取子目录，另一个用于处理它以准备保存到数据库的对象，最后一个用于将处理后的数据对象写入数据库。
文件夹可以有任意数量的子文件夹。目前，我使用了以下代码：

 Path start = Paths.get("x:\\data\\");
    Stream<Path> stream = Files.walk(start, 1);
List<String> collect = stream
                .map(String::valueOf)
                .sorted()
                .collect(Collectors.toList());

Path start=Path.get（“x:\\data\\”；
Stream=Files.walk（开始，1）；
列表收集=流
.map（字符串：：valueOf）
.已排序（）
.collect（Collectors.toList（））；

一次读取所有子文件夹。
我遵循了这个
https://www.baeldung.com/spring-batch-tasklet-chunk
为此目的而实施的
Tasklet
示例。这是正确的方法吗？我还需要使用多线程异步运行作业。
由于子文件夹数量巨大，
因此可以有大量的
行
或
列表
数据要处理并写入数据库。

请提出适当的方法。
我正在学习
springbatch
，也做了一些关于
文件读取/处理/写入
的示例，并为此使用了
块
方法。
但我的工作是读取文件夹/路径的子目录，因此我无法决定采用哪种方法。
我有一个类似的场景：我需要从文件夹中读取所有文件，处理并在db中写入（）

@配置
@启用批处理
公共类BatchConfig{
@豆子
公共工作工作（JobBuilderFactory JobBuilderFactory，
步骤（主要步骤）{
返回jobBuilderFactory.get（“MainJob”）
.incrementer（新的RunIdIncrementer（））
.流程（主步骤）
(完)
.build（）；
}
@豆子
公共Step主Step（StepBuilderFactory StepBuilderFactory，
JdbcBatchItemWriter编写器，
项目阅读器，
TransactionItemProcessor（处理器）{
返回stepBuilderFactory.get（“Main”）
.chunk（2）
.读卡器（读卡器）
.处理器（处理器）
.作者（作者）
**.taskExecutor（作业taskExecutor（））**
.listener（新的ItemReaderListener（））
.build（）；
}
@豆子
公共任务执行器作业任务执行器（）{
ThreadPoolTaskExecutor taskExecutor=新的ThreadPoolTaskExecutor（）；
taskExecutor.setCorePoolSize（2）；
taskExecutor.setMaxPoolSize（10）；
taskExecutor.AfterPropertieSet（）；
返回任务执行器；
}
@豆子
@步进镜
公共ItemReader读取器（@Value（#{stepExecution}）stepExecution-stepExecution）抛出IOException{
路径开始=路径。获取（“D:\\test”）；
List inputFile=Files.walk（开始，1）
.map（字符串：：valueOf）
.已排序（）
.collect（Collectors.toList（））；
返回新的IteratorItemReader（inputFile）；
}
@豆子
@步进镜
公共TransactionItemProcessor处理器（@Value（“#{stepExecution}”）stepExecution stepExecution）{
返回新的TransactionItemProcessor（）；
}
@豆子
@步进镜
公共JdbcBatchItemWriter编写器（数据源数据源）{
返回新的JdbcBatchItemWriterBuilder（）
.itemSqlParameterSourceProvider（新的BeanPropertyItemSqlParameterSourceProvider（））
.sql（“插入事务（id、日期、类型）值（：id、日期、类型）”）
.dataSource（数据源）
.build（）；
}

}
，谢谢您的回复。在我的上下文中，我只需要获取子文件夹的路径，不需要读取文件。例如，主文件夹=//a和子文件夹/a/b、/a/c、/a/d等，创建对象列表包含要保存到DB的父路径和子文件夹路径。所以我的问题是，如果我遵循你的方法，它会一次读取所有子文件夹还是一块一块地读取？你的例子是一种基于块的方法。如果我们想用Tasklet方法来实现，那会是什么样的方法呢？你能修改一下这个例子，让它像我的代码片段一样读取路径吗？在做了一些测试之后，我认为最好的方法是使用块，我编辑了代码。添加TaskExecutor允许您添加多线程，如果您想要更好的性能，可以检查远程分块。我编辑了代码主步骤中的
TaskExecutor
set？在哪里
@Configuration
@EnableBatchProcessing
public class BatchConfig {

@Bean
public Job job(JobBuilderFactory jobBuilderFactory,
               Step masterStep) {
    return jobBuilderFactory.get("MainJob")
            .incrementer(new RunIdIncrementer())
            .flow(masterStep)
            .end()
            .build();
}

@Bean
public Step mainStep(StepBuilderFactory stepBuilderFactory,
                     JdbcBatchItemWriter<Transaction> writer,
                     ItemReader<String> reader,
                     TransactionItemProcessor processor) {
    return stepBuilderFactory.get("Main")
            .<String, Transaction>chunk(2)
            .reader(reader)
            .processor(processor)
            .writer(writer)
            **.taskExecutor(jobTaskExecutor())**
            .listener(new ItemReaderListener())
            .build();
}

@Bean
public TaskExecutor jobTaskExecutor() {
    ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
    taskExecutor.setCorePoolSize(2);
    taskExecutor.setMaxPoolSize(10);
    taskExecutor.afterPropertiesSet();
    return taskExecutor;
}

@Bean
@StepScope
public ItemReader<String> reader(@Value("#{stepExecution}") StepExecution stepExecution) throws IOException {
    Path start = Paths.get("D:\\test");
    List<String> inputFile = Files.walk(start, 1)
            .map(String::valueOf)
            .sorted()
            .collect(Collectors.toList());
    return new IteratorItemReader<>(inputFile);
}

@Bean
@StepScope
public TransactionItemProcessor processor(@Value("#{stepExecution}") StepExecution stepExecution) {

    return new TransactionItemProcessor();
}

@Bean
@StepScope
public JdbcBatchItemWriter<Transaction> writer(DataSource dataSource) {

    return new JdbcBatchItemWriterBuilder<Transaction>()
            .itemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<>())
            .sql("INSERT INTO transaction (id, date, type) VALUES (:id, :date, :type)")
            .dataSource(dataSource)
            .build();
}