Spring Batch单步骤作业出现reader-processor异常循环问题求助

出现无限循环的核心原因是代码实现违背了Spring Batch的执行契约，具体有3个问题：

• 对ItemReader的执行逻辑理解错误。Spring Batch 块（chunk）执行模型的规则是：循环调用reader的read()方法获取数据，直到read()返回null时，才判定所有数据读取完成，结束当前Step。你当前的Reader每次被调用都会重新执行两次SQL查询，只要查询结果不为空就返回非null值，框架永远收不到读取结束的信号，自然会无限重复「读取->处理->读取」的流程。
• Reader没有维护读取状态。你把两次全量查询的逻辑直接写在了read()方法里，每次调用都从头查一遍所有数据，没有记录当前读取到什么位置，本质上相当于每次循环都重新拉取全量数据，永远读不完。另外代码里还存在变量遮蔽问题：类中定义了成员变量private List<String> results;，在read()方法内又定义了同名局部变量List<String> results，成员变量完全没有被使用，属于无效代码。
• 额外的定时任务配置错误。你写的@Scheduled(cron = "* */3 * * * *") cron表达式不符合预期：Spring Schedule的cron是6位格式（秒 分 时 日 月 周），第一位*代表每秒触发，这个配置会在每3分钟的0-59秒每秒启动一次新的作业实例，会进一步加剧重复执行的问题。

另外补充说明：你的Processor中process方法返回null在Spring Batch的规则里代表过滤掉当前处理的条目，不会传递给writer执行写入，如果不需要过滤条目，建议返回处理后的结果，避免数据丢失。空实现的NoOpItemWriter不会直接导致循环，但生产环境不建议使用无任何逻辑的空写入组件，容易出现数据处理后无持久化、执行状态异常的问题。

根据你的数据量和业务需求，二选一即可：

方案1：数据量较大，需要用Spring Batch分块处理、重试/跳过能力 #

1. 修正Reader逻辑，只在第一次调用时执行全量查询，后续逐次返回单条记录，所有记录返回完后返回null，修正后的Reader示例：

// 注意泛型改成单条记录类型，不要直接返回List
public class MyReader implements ItemReader<String> {
    private final String hours;
    private final JdbcTemplate jdbcTemplate;
    private Iterator<String> dataIterator; // 用迭代器记录读取位置

    // 构造方法直接传入JdbcTemplate，不要在Reader中做@Autowired注入（Reader是Step Scope多例，注入容易出现上下文问题）
    public MyReader(String hours, JdbcTemplate jdbcTemplate) {
        this.hours = hours;
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public String read() throws Exception {
        // 第一次调用时初始化全量数据，仅查询一次
        if (dataIterator == null) {
            List<String> firstQueryResult = jdbcTemplate.queryForList(/* 第一次查询SQL */, String.class);
            if (firstQueryResult.isEmpty()) {
                return null;
            }
            List<String> finalResult = jdbcTemplate.queryForList(/* 第二次关联查询SQL，传入firstQueryResult作为查询参数 */, String.class);
            dataIterator = finalResult.iterator();
        }
        // 逐次返回单条数据，无剩余数据时返回null通知框架读取结束
        return dataIterator.hasNext() ? dataIterator.next() : null;
    }
}

2. 对应调整Step配置，匹配单条记录的泛型，根据实际处理能力设置chunk大小：

@Bean
public Step firstStep(MyReader reader, MyProcessor processor) {
    return stepBuilderFactory.get("firstStep")
            .<String, String>chunk(10) // 单条记录类型，每次凑够10条交给writer处理
            .reader(reader)
            .processor(processor)
            .writer(items -> {
                // 替换空Writer，在这里实现处理结果的持久化逻辑
            })
            .build();
}

3. 调整Processor逻辑处理单条记录，不需要过滤就返回处理后的结果：

public class MyProcessor implements ItemProcessor<String, String> {
    @Override
    public String process(String item) throws Exception {
        // 调用API处理单条记录
        return item;
    }
}

4. 修正定时任务cron表达式为0 */3 * * * ?，实现每3分钟整点启动一次作业，避免每秒重复触发。

方案2：数据量小，不需要分块处理、重试跳过能力 #

直接放弃ItemReader/Processor/Writer的分块模型，用TaskletStep实现一次性任务，逻辑更直白不会出现循环：

@Bean
public Step firstStep(JdbcTemplate jdbcTemplate) {
    return stepBuilderFactory.get("firstStep")
            .tasklet((contribution, chunkContext) -> {
                // 直接执行两次查询
                List<String> firstResult = jdbcTemplate.queryForList(/* 第一次查询SQL */, String.class);
                if (!firstResult.isEmpty()) {
                    List<String> finalResult = jdbcTemplate.queryForList(/* 第二次关联查询SQL */, String.class);
                    finalResult.forEach(result -> {
                        // 调用API处理每条记录
                    });
                }
                // 直接返回完成状态，不会循环执行
                return RepeatStatus.FINISHED;
            })
            .build();
}

这种写法不需要自定义Reader、Processor组件，所有逻辑集中在Tasklet中，执行完自动结束Step，适合轻量一次性任务场景。

内容的提问来源于stack exchange，提问作者CodeFarFarAway