MultiResourceItemReader读取文件，并传递文件名到itemwrite

提示信息

MultiResourceItemReader读取文件，并传递文件名到itemwrite

死亡谷

10月08日发表在图文创作、问答社区 / My Coding Q&A Community 阅读 127 评论 20 | 免费使用 “AI大模型GPT4.0” 提问

在 Spring Batch 中，如果你需要在 MultiResourceItemReader 读取文件的同时传递文件名到 ItemWriter，那么你可能需要稍微改变一下你的处理策略。

首先，你的 domain 对象（例如 Person）需要有一个额外的字段用于存储文件名。

public class Person {  
    // 其他字段...  
    private String filename; // 新增的字段  
    // getters and setters...  
}

然后，你需要创建一个自定义的 FlatFileItemReader，并覆盖 doRead() 方法，以便在每次读取记录时添加文件名：

public class CustomFlatFileItemReader extends FlatFileItemReader<Person> {  
    private String filename;  
    public void setFilename(String filename) {  
        this.filename = filename;  
    }  
    @Override  
    protected Person doRead() throws Exception {  
        Person person = super.doRead();  
        if (person != null) {  
            person.setFilename(filename);  
        }  
        return person;  
    }  
}

现在，当你配置 MultiResourceItemReader 时，你可以为每个资源创建一个新的 CustomFlatFileItemReader ，并设置正确的文件名：

```
public MultiResourceItemReader multiResourceItemReader(Resource[] resources) {
MultiResourceItemReader resourceItemReader = new MultiResourceItemReader<>();
ResourceAwareItemReaderItemStream<? extends Person>[] readers = new ResourceAwareItemReaderItemStream[resources.length];
for (int i = 0; i < resources.length; i++) {
CustomFlatFileItemReader reader = new CustomFlatFileItemReader();
reader.setResource

遇到难题？ "AI大模型GPT4.0、GPT" 是你的私人解答专家！点击按钮去提问......

死亡谷赞 | 0

最近一次登录：2023-10-09 12:50:55

暂时还没有签名，请关注我或评论我的文章

20条评论

按时间正序按时间倒序按喜欢排序

红颜为谁美

10月16日

解决文件名传递很实用，建议多讲些配置细节。

赞 0 回复举报

缠绵： @红颜为谁美

对于多资源读取问题，文件名的传递确实是一个相对常被忽视的细节。可以考虑在配置 MultiResourceItemReader 时，利用 StepExecution 或 ExecutionContext 来存储文件名，并在 ItemWriter 中进行读取。

以下是一个简化的代码示例，供参考：

@Bean
public MultiResourceItemReader<MyItem> multiResourceItemReader(JobExecution jobExecution) {
    MultiResourceItemReader<MyItem> reader = new MultiResourceItemReader<>();
    Resource[] resources = new Resource[] {
        new FileSystemResource("file1.txt"),
        new FileSystemResource("file2.txt")
    };

    reader.setResources(resources);
    reader.setDelegate(myItemReader());

    // 保存文件名到 ExecutionContext
    jobExecution.getExecutionContext().put("currentFile", resources[0].getFilename());

    return reader;
}

@Bean
public ItemWriter<MyItem> itemWriter(JobExecution jobExecution) {
    return items -> {
        String currentFile = jobExecution.getExecutionContext().getString("currentFile");
        for (MyItem item : items) {
            // 这里可以使用 currentFile 来处理对应的条目
            System.out.println("Processing item from " + currentFile + ": " + item);
        }
    };
}

通过这种方式，文件名能够被有效传递给 ItemWriter。在实际应用时，可以根据项目的需求拓展更多的配置细节，确保文件处理的灵活性和可维护性。

感兴趣的还可以参考 Spring Batch Documentation 来获取更多关于步骤和读取配置的丰富信息。

11月11日回复举报

添加新评论

解思量

10月23日

自定义FlatFileItemReader的实现很巧妙，这种方法可以很容易将文件元数据传递到处理逻辑中，提高了数据处理的灵活性。

赞 0 回复举报

繁华似锦： @解思量

自定义FlatFileItemReader的方式确实为数据处理提供了更大的灵活性，特别是在需要将文件名或其他元数据传递给ItemWriter时。这样的实现能够让我们在处理不同来源的文件时，轻松识别每个文件的数据上下文。在实际应用中，可以考虑如下示例：

public class CustomFlatFileItemReader extends FlatFileItemReader<MyItem> {
    private String fileName;

    @Override
    public MyItem read() throws Exception {
        MyItem item = super.read();
        if (item != null) {
            item.setFileName(fileName);
        }
        return item;
    }

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }
}

在ItemWriter中接收这个元数据时，可以直接通过MyItem来访问文件名：

public class MyItemWriter implements ItemWriter<MyItem> {
    @Override
    public void write(List<? extends MyItem> items) throws Exception {
        for (MyItem item : items) {
            System.out.println("Processing item from file: " + item.getFileName());
            // 处理逻辑
        }
    }
}

这样的设计不仅让处理逻辑更清晰，还能减少在不同场景下所需的配置，提高了重用性和可维护性。此外，结合Spring Batch的文档Spring Batch Documentation进行深入研究，能帮助你更好地理解如何实现自定义读取器及其使用场景。

11月11日回复举报

添加新评论

韦煜娴

10月26日

文章中给出的代码示例非常清晰，尤其是覆盖doRead方法并在其中追加文件名的思路，为开发者提供了一个极具参考价值的实现方案。

赞 0 回复举报

暖眸： @韦煜娴

在处理多文件读取的情况下，继承MultiResourceItemReader并在doRead方法中增加文件名确实是一个值得借鉴的思路。这不仅有助于追踪处理过程中的每个文件，对于调试和日志记录也是非常有益的。为了更好地理解这个实现，可以考虑以下的代码补充：

@Override
protected T doRead() throws Exception {
    T item = super.doRead();
    if (item != null) {
        String fileName = getCurrentResource().getFilename();
        // 这里可以将文件名附加到item中
        ((YourItemType) item).setSourceFileName(fileName);
    }
    return item;
}

这样的实现使得每个读取的项目都有一个来源文件名，可以在后续的ItemWriter中方便地进行处理和记录。此外，建议参考Spring Batch的官方文档，其中对于ItemReader和ItemWriter的使用有更详细的范例和指导，网址是 Spring Batch Documentation。使用相关的文档和示例可以帮助更深入地理解如何在多资源处理时优化代码架构。

7天前回复举报

添加新评论

那些年

11月02日

将filename整合到domain对象中确保数据完整性，但要注意代码的可维护性。

赞 0 回复举报

柔情缱绻： @那些年

对于将文件名整合到领域对象中的做法，有其合理性，可以确保每条数据都与源文件关联，从而在后续处理中保持数据的完整性。然而，过于依赖该方式可能会导致领域对象的职责变得复杂，影响代码的可维护性。

为了在保证数据完整性的同时保持代码的清晰，可以考虑设计一个新的模型，例如一个传输对象（DTO），来专门承载文件名和读取的数据。在进行写入时，将文件名作为额外的字段传输，这样领域对象则可以保持专注于业务逻辑。

以下是一个简单的代码示例：

public class DataItem {
    private String dataField;
    // additional fields...

    // Getters and setters...
}

public class DataItemWithFileName {
    private DataItem dataItem;
    private String fileName;

    public DataItemWithFileName(DataItem dataItem, String fileName) {
        this.dataItem = dataItem;
        this.fileName = fileName;
    }

    // Getters and setters...
}

// 在读取数据时
MultiResourceItemReader<DataItem> reader = new MultiResourceItemReader<>();
// ... 配置reader...

// 在写入数据时，传递文件名
itemWriter.write(Collections.singletonList(new DataItemWithFileName(dataItem, fileName)));

建议在进行设计时，关注代码的可读性和易于维护性，可以参考一些设计原则如单一职责原则（SRP）和开放-关闭原则（OCP）。可以访问 Martin Fowler's Refactoring 了解更多关于重构和设计模式的内容，这将有助于提升代码的质量和可维护性。

11月14日回复举报

添加新评论

生死

11月11日

建议补充完整代码及配置说明，方便读者更好地理解如何使用Spring Batch来处理批量文件。

赞 0 回复举报

浮夸： @生死

对于MultiResourceItemReader的使用来说，提供完整的实现示例和配置说明确实是非常重要的。通过这样的方法，更容易帮助大家理解如何高效地利用Spring Batch处理多个文件的数据。

可以考虑以下示例配置，展示如何通过MultiResourceItemReader读取文件，并将文件名传递给ItemWriter：

@Bean
public MultiResourceItemReader<MyItem> multiResourceItemReader() {
    MultiResourceItemReader<MyItem> reader = new MultiResourceItemReader<>();
    Resource[] resources = new Resource[] {
        new FileSystemResource("file1.txt"),
        new FileSystemResource("file2.txt"),
        // 可以添加更多文件
    };
    reader.setResources(resources);
    // 配置ItemReader，譬如使用FlatFileItemReader等
    return reader;
}

@Bean
public ItemWriter<MyItem> itemWriter() {
    return items -> {
        for (MyItem item : items) {
            // 此处可以添加获取文件名的逻辑
            System.out.println("Processing item from file: " + /* 当前位置的文件名 */);
            // 写入逻辑
        }
    };
}

在Writer中，可以考虑传递上下文信息，使用ExecutionContext来存储和获取当前文件名。建议参照官方文档中的Spring Batch参考指南来了解更多配置细节。

希望这样的示例和说明能帮助到更多人。

6天前回复举报

添加新评论

mail1974

11月14日

代码分层清晰，说明很详细，但多资源读取时资源管理可能需要注意。

赞 0 回复举报

浮光掠影： @mail1974

对于使用 MultiResourceItemReader 读取多个文件并将文件名传递给 ItemWriter 的实现，资源管理确实是一个值得关注的问题。在处理多个资源时，确保每个资源正确打开、读取并在完成后关闭是非常重要的，以防资源泄漏或其他潜在问题。

可以考虑利用 Spring Batch 的 ResourceAware 接口，来更好地管理资源。例如，你可以在 ItemWriter 中使用 ResourceAware 接口，接收当前读到的资源信息。如下所示：

public class CustomItemWriter<T> implements ItemWriter<T>, ResourceAware {

    private Resource resource;

    @Override
    public void setResource(Resource resource) {
        this.resource = resource;
    }

    @Override
    public void write(List<? extends T> items) throws Exception {
        // Process items and use the resource name
        String resourceName = resource.getFilename();
        // 进行一些写入操作
        System.out.println("Writing items from resource: " + resourceName);
    }
}

在此示例中，CustomItemWriter 实现了 ResourceAware 接口，从而在写入过程中可以访问当前资源的文件名。这不仅提高了代码的可读性，也简化了资源管理。

希望大家在实现类似功能时，能够更加关注资源的管理问题。如果想了解更多相关的内容，建议参考 Spring Batch Documentation。

11月11日回复举报

添加新评论

若即若离

11月17日

扩展了Spring Batch的功能，通过设置文件名，个性化处理成为可能，但多文件处理时要考虑线程安全问题。

赞 0 回复举报

随风： @若即若离

在处理多文件的场景下，确保线程安全确实是一个值得关注的话题。可以考虑使用ThreadLocal变量来存储每个线程的上下文数据，确保在并发处理文件时不会产生数据竞争。

另外，可以利用Spring Batch的ExecutionContext来存储文件名信息，然后在ItemWriter中提取。具体实现可以如下：

public class CustomItemReader extends MultiResourceItemReader<MyItem> {
    @Override
    protected MyItem doRead() {
        MyItem item = super.doRead();
        // 获取当前处理的文件名
        String fileName = this.getCurrentResource().getFilename();
        // 将文件名存储到ExecutionContext中
        ExecutionContext executionContext = getExecutionContext();
        executionContext.put("currentFileName", fileName);
        return item;
    }
}

而在ItemWriter中：

public class CustomItemWriter implements ItemWriter<MyItem> {
    @Override
    public void write(List<? extends MyItem> items) throws Exception {
        ExecutionContext executionContext = ...; // 获取ExecutionContext
        String currentFileName = executionContext.getString("currentFileName");

        // 在此处根据`currentFileName`进行个性化处理
        for (MyItem item : items) {
            // 写入操作，例如:
            System.out.println("Writing item from file: " + currentFileName);
        }
    }
}

参考文献可见于Spring Batch官方文档 Spring Batch Reference。这样做不仅能增强处理灵活性，同时也能更好应对多文件处理带来的挑战。

3天前回复举报

添加新评论

文道寺

11月24日

内容涵盖了从domain到reader配置的完整流程，对Spring Batch不熟的人来说很有帮助。建议提供完整的项目结构示例。

赞 0 回复举报

每天快乐一点： @文道寺

在讨论MultiResourceItemReader如何读取多个文件时，确实在传递文件名给ItemWriter方面存在一些技术挑战。引用代码示例或方法会明显有助于理解。可以考虑使用JobExecutionContext来存储每次读取的文件名，这样在ItemWriter中就能方便地获取并处理。

public class FileNameItemListener extends StepExecutionListener {
    @Override
    public void beforeStep(StepExecution stepExecution) {
        // 清除已有的数据
        stepExecution.getExecutionContext().clear();
    }

    public void itemRead(String fileName) {
        // 将文件名存入ExecutionContext
        stepExecution.getExecutionContext().put("currentFileName", fileName);
    }
}

在你的ItemWriter中，可以这样读取文件名：

public class CustomItemWriter implements ItemWriter<MyItem> {
    @Override
    public void write(List<? extends MyItem> items) {
        String currentFileName = (String) stepExecution.getExecutionContext().get("currentFileName");
        // 处理写入逻辑
    }
}

同时，关于项目结构的示例，可以参考Spring Batch的官方文档，这里有一个很好的入门指南 Spring Batch Reference。这样可以进一步帮助理解各个组件的配置和协作。

5天前回复举报

添加新评论

aocool

11月29日

思路清晰，代码示例具有良好的指导性，有助于增强对Spring Batch多文件读取的理解。

赞 0 回复举报

经年未变： @aocool

很高兴看到对MultiResourceItemReader的讨论，尤其是在将文件名传递给ItemWriter的这一思路上。通过这种方式，可以更直观地在处理每个文件时保留上下文信息，这对于后续的记录和错误处理尤其有用。

例如，在ItemWriter中获取文件名，可以像这样实现：

public class CustomItemWriter implements ItemWriter<MyItem> {
    private String fileName;

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    @Override
    public void write(List<? extends MyItem> items) throws Exception {
        for (MyItem item : items) {
            // 这里可以加入文件名用于记录或其他逻辑
            System.out.println("Processing item from file: " + fileName + " " + item);
        }
    }
}

在Job的配置中，可以通过JobExecutionContext或StepExecutionContext来传递文件名，确保在每个步骤执行时能准确获取当前处理的文件。

关于更多Spring Batch高级特性，可以参考Spring Batch官方文档以获取进一步的信息和示例，帮助进一步深化理解。

11月14日回复举报

添加新评论

期待等待

12月04日

代码描述细致，为实现特定需求提供了有效思路，值得借鉴。同时，注意资源泄露及异常处理。

赞 0 回复举报

韦文柳： @期待等待

在处理文件读取时，确保资源的有效管理确实非常重要。在使用 MultiResourceItemReader 时，除了将文件名传递给 ItemWriter，也可以考虑增加日志记录，以便于跟踪读取流程和处理结果。例如，可以通过实现 ItemStream 接口来确保在读取和写入过程中正确关闭资源：

public class CustomItemWriter implements ItemWriter<MyItem>, ItemStream {

    @Override
    public void write(List<? extends MyItem> items) throws Exception {
        for (MyItem item : items) {
            // 处理每个项
            System.out.println("Writing item: " + item);
        }
    }

    @Override
    public void open(ExecutionContext executionContext) {
        // 初始化资源
    }

    @Override
    public void update(ExecutionContext executionContext) {
        // 更新资源
    }

    @Override
    public void close() {
        // 清理资源，防止泄露
    }
}

此外，在异常处理上，添加重试机制可能也是一种提升系统健壮性的方法。推荐参考 Spring Batch Documentation，以获取更多关于流式处理和异常管理的案例，帮助深入理解如何优化读取和写入过程。

6天前回复举报

添加新评论

免费图表工具，画流程图、架构图

MultiResourceItemReader读取文件，并传递文件名到itemwrite

举报评论

删除

删除后，将不可回复，确认要删除？

提示

复制代码，请先登录