Spring batch Spring批处理项读取器重复执行问题

我使用的是Spring批处理项目阅读器。在项读取器中读取调用存储过程的方法。一旦我们从存储过程中得到结果，它就会返回到writer。但它还是要读方法。所以read是重复执行的

有谁能建议我如何限制read方法只调用一次来执行作业

*注意：StoredprocedureitemReader不是我们的要求。我们需要使用itemreader只读

---

请在这方面提供帮助

如果我理解正确，你需要读一次，写多次。您可以使用存储过程在第一次调用

read（）

方法时获取结果，然后在所有剩余时间逐个返回已读取的对象。

下面是一个阅读器示例，它加载一个项目队列，然后从同一队列中读取。这类似于一次调用存储过程和多次“写入”的用例

package de.incompleteco.spring.batch.item；
导入java.util.PriorityQueue；
导入java.util.Queue；
导入java.util.UUID；
导入org.springframework.batch.item.ItemReader；
导入org.springframework.batch.item.NonTransientResourceException；
导入org.springframework.batch.item.ParseException；
导入org.springframework.batch.item.UnexpectedInputException；
导入de.incompleteco.spring.batch.domain.Record；
公共类SingleItemReader实现ItemReader{
私有队列值=null；
public Record read（）引发异常、UnexpectedInputException、ParseException、NonTransientResourceException{
//检查队列
如果（值==null）{
//装载
loadQueue（）；
}//如果结束
//返回
返回getRecord（values.poll（））；
}
私有记录getRecord（字符串值）{
//初始化
记录=空；
//检查空值
if（值！=null）{
记录=新记录（）；
record.setId（UUID.randomuid（））；
记录。设置值（值）；
}//如果结束
//返回
返回记录；
}
私有同步的void loadQueue（）{
//生成一组数据并添加到队列中
如果（值==null）{
System.out.println（“队列的调用加载”）；
值=新的优先级队列（）；
对于（int i=0；i
package de.incompleteco.spring.batch.item;

import java.util.PriorityQueue;
import java.util.Queue;
import java.util.UUID;

import org.springframework.batch.item.ItemReader;
import org.springframework.batch.item.NonTransientResourceException;
import org.springframework.batch.item.ParseException;
import org.springframework.batch.item.UnexpectedInputException;

import de.incompleteco.spring.batch.domain.Record;

public class SingleItemReader implements ItemReader<Record> {

    private Queue<String> values = null;

    public Record read() throws Exception, UnexpectedInputException,ParseException, NonTransientResourceException {
        //check the queue
        if (values == null) {
            //load
            loadQueue();
        }//end if
        //return
        return getRecord(values.poll());
    }

    private Record getRecord(String value) {
        //init
        Record record = null;
        //check for null
        if (value != null) {
            record = new Record();
            record.setId(UUID.randomUUID());
            record.setValue(value);
        }//end if
        //return
        return record;      
    }

    private synchronized void loadQueue() {
        //generate a bunch of data and add to the queue
        if (values == null) {
            System.out.println("calling load of the queue");
            values = new PriorityQueue<String>();
            for (int i=0;i<100;i++) {
                values.add("hello " + i);
            }//end for
        }//end if
    }

}

package de.incompleteco.spring.batch.item;

import java.util.List;

import org.springframework.batch.item.ItemWriter;

import de.incompleteco.spring.batch.domain.Record;

public class SystemItemWriter implements ItemWriter<Record> {

    public void write(List<? extends Record> items) throws Exception {
        System.out.println("starting write...");
        System.out.println(items);
        System.out.println("...finished write");
    }

}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:batch="http://www.springframework.org/schema/batch"
    xmlns:task="http://www.springframework.org/schema/task"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/batch http://www.springframework.org/schema/batch/spring-batch.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">

    <batch:job id="singleReadJob">
        <batch:step id="singleReadJob.step1">
            <batch:tasklet>
                <batch:chunk reader="singleReader" writer="multiWriter" commit-interval="10"/>
            </batch:tasklet>
        </batch:step>
    </batch:job>

    <bean id="singleReader" class="de.incompleteco.spring.batch.item.SingleItemReader"/>

    <bean id="multiWriter" class="de.incompleteco.spring.batch.item.SystemItemWriter"/>

    <bean id="jobRepository"
        class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean"/>

    <bean id="jobLauncher"
        class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
        <property name="jobRepository" ref="jobRepository"/>
        <property name="taskExecutor" ref="taskExecutor"/>
    </bean>

    <bean id="jobExplorer"
        class="org.springframework.batch.core.explore.support.MapJobExplorerFactoryBean">
        <property name="repositoryFactory" ref="&amp;jobRepository"/>
    </bean>

    <task:executor id="taskExecutor"/>

    <bean id="transactionManager"
        class="org.springframework.batch.support.transaction.ResourcelessTransactionManager"/>
</beans>