Spring Batch -项目读写

haketest lv.1

发布时间：2022-12-20 03:47:49 496

相关标签： # sql# 容器# 数据# 技术# 信息

Spring Batch -项目读写_bc

所有批处理都可以用最简单的形式描述为大量读取数据，执行某种类型的计算或转换，并写入结果外。Spring Batch 提供了三个关键接口来帮助执行批量读取和写入：、和。ItemReaderItemProcessorItemWriter

`ItemReader`

虽然一个简单的概念，但是提供来自许多数据的方法不同类型的输入。最一般的例子包括：ItemReader

平面文件：平面文件项读取器从平面文件中读取数据行，通常描述具有由文件中的固定位置定义或分隔的数据字段的记录通过一些特殊字符（如逗号）。
XML：XML 进程 XML，独立于用于解析的技术，映射和验证对象。输入数据允许验证 XML 文件针对 XSD 架构。ItemReaders
数据库：访问数据库资源以返回可映射到的结果集要处理的对象。默认的 SQL 实现调用 a 返回对象，如果需要重新启动，请跟踪当前行，存储基本统计信息，并提供一些稍后将介绍的事务增强功能。ItemReaderRowMapper

还有更多的可能性，但我们在本章中专注于基本的可能性。一个所有可用实现的完整列表可在附录 A 中找到。ItemReader

ItemReader是泛型的基本接口输入操作，如以下接口定义所示：

public interface ItemReader {

    T read() throws Exception, UnexpectedInputException, ParseException, NonTransientResourceException;

}

该方法定义了的最重要的协定。调用它返回一个项目，或者如果没有更多项目。项目可能表示文件、数据库中的行或 XML 文件中的元素。一般预计这些对象映射到可用的域对象（例如、或其他对象），但在那里合同中没有要求这样做。readItemReadernullTradeFoo

预计接口的实现仅是向前的。但是，如果基础资源是事务性的（例如 JMS 队列），则在回滚方案中，调用可能会在后续调用中返回相同的逻辑项。是的还值得注意的是，缺少要处理的项目不会导致要抛出的异常。例如，配置了返回 0 结果的查询在第一次调用时返回。ItemReaderreadItemReaderItemReadernullread

`ItemWriter`

ItemWriter在功能上类似于，但具有反向操作。资源仍然需要定位、打开和关闭，但它们的不同之处在于写出，而不是读入。对于数据库或队列，这些操作可以是插入、更新或发送。序列化的格式输出特定于每个批处理作业。ItemReaderItemWriter

与一样，是一个相当通用的接口，如以下接口定义所示：ItemReaderItemWriter

public interface ItemWriter {

    void write(Chunk<? extends T> items) throws Exception;

}

与 on 一样，提供了的基本协定。它尝试写出传入的项目列表，只要它处于打开状态。因为它是通常期望项目一起“批处理”成一个块，然后输出，接口接受项目列表，而不是项目本身。写出后列表，可以在从写入返回之前执行任何可能需要的刷新方法。例如，如果写入休眠DAO，则可以进行多次调用写入，每个项目一个。然后，编写器可以在之前调用休眠会话返回。readItemReaderwriteItemWriterflush

`ItemStream`

两者都很好地服务于各自的目的，但有一个他们俩的共同关注点是需要另一个界面。一般来说，作为批处理作业的一部分范围，需要打开、关闭读取器和写入器，并且需要一种持久状态的机制。该接口服务于此目的，如以下示例所示：ItemReadersItemWritersItemStream

public interface ItemStream {

    void open(ExecutionContext executionContext) throws ItemStreamException;

    void update(ExecutionContext executionContext) throws ItemStreamException;

    void close() throws ItemStreamException;
}

在描述每种方法之前，我们应该提到.同样实现的客户端应在调用之前调用，以便打开任何资源（如文件）或获取连接。一个类似的限制适用于实现的。如中所述第2章，如果在中找到预期数据，则可以使用它来启动或位于其初始状态以外的位置。相反，调用是为了确保安全释放在打开期间分配的任何资源。调用主要是为了确保当前被持有的任何状态都加载到提供的 .在提交之前调用此方法，以确保当前状态在提交之前保留在数据库中。ExecutionContextItemReaderItemStreamopenreadItemWriterItemStreamExecutionContextItemReaderItemWritercloseupdateExecutionContext

在特殊情况下，一个的客户端是（从 Spring 批处理核心），为每个步骤执行创建一个，以允许用户存储特定执行的状态，并期望在以下情况下返回该状态同样的事情再次开始。对于那些熟悉石英的人来说，语义与石英非常相似。ItemStreamStepExecutionContextJobInstanceJobDataMap

委托模式和注册步骤

请注意，这是委派模式的一个示例，即常见于春季批次。委托本身可以实现回调接口，如。如果有，并且是否与Spring结合使用批处理核心作为 a 的一部分，那么它们几乎肯定需要使用手动注册。直接的读取器、写入器或处理器如果它实现或接口，则自动连接到 Get 注册。但是，由于代表不为，它们需要作为侦听器或流（或两者，如果适用）注入。CompositeItemWriterStepListenerStepJobStepStepItemStreamStepListenerStep

下面的示例演示如何在 XML 中将委托作为流注入：

XML 配置

@Bean
public Job ioSampleJob(JobRepository jobRepository) {
  return new JobBuilder("ioSampleJob", jobRepository)
        .start(step1())
        .build();
}

@Bean
public Step step1(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
  return new StepBuilder("step1", jobRepository)
        .<String, String>chunk(2, transactionManager)
        .reader(fooReader())
        .processor(fooProcessor())
        .writer(compositeItemWriter())
        .stream(barWriter())
        .build();
}

@Bean
public CustomCompositeItemWriter compositeItemWriter() {

  CustomCompositeItemWriter writer = new CustomCompositeItemWriter();

  writer.setDelegate(barWriter());

  return writer;
}

@Bean
public BarWriter barWriter() {
  return new BarWriter();
}

下面的示例演示如何在 XML 中将委托作为流注入：

爪哇配置

@Bean
public Job ioSampleJob(JobRepository jobRepository) {
  return new JobBuilder("ioSampleJob", jobRepository)
        .start(step1())
        .build();
}

@Bean
public Step step1(JobRepository jobRepository, PlatformTransactionManager transactionManager) {
  return new StepBuilder("step1", jobRepository)
        .<String, String>chunk(2, transactionManager)
        .reader(fooReader())
        .processor(fooProcessor())
        .writer(compositeItemWriter())
        .stream(barWriter())
        .build();
}

@Bean
public CustomCompositeItemWriter compositeItemWriter() {

  CustomCompositeItemWriter writer = new CustomCompositeItemWriter();

  writer.setDelegate(barWriter());

  return writer;
}

@Bean
public BarWriter barWriter() {
  return new BarWriter();
}

平面文件

交换批量数据的最常见机制之一一直是平面文件。与XML不同，XML有一个商定的标准来定义它的结构（XSD），任何阅读平面文件的人都必须提前了解文件的确切情况。结构。通常，所有平面文件都分为两种类型：分隔文件和固定长度。分隔文件是指字段由分隔符（如逗号）分隔的文件。固定长度文件具有设定长度的字段。

这`FieldSet`

在 Spring 批处理中处理平面文件时，无论是用于输入还是输出，最重要的类之一是 .许多体系结构和库包含用于帮助您从文件中读入的抽象，但它们通常返回一个 OR 对象数组。这真的只能让你成功一半那里。A 是 Spring Batch 的抽象，用于启用字段的绑定文件资源。它允许开发人员以与它们将使用数据库输入。A 在概念上类似于 JDBC。A 只需要一个参数：一个令牌数组。或者，您还可以配置字段的名称，以便字段可以是按索引或名称访问，如之后的模式，如下所示例：FieldSetStringStringFieldSetFieldSetResultSetFieldSetStringResultSet

String[] tokens = new String[]{"foo", "1", "true"};
FieldSet fs = new DefaultFieldSet(tokens);
String name = fs.readString(0);
int value = fs.readInt(1);
boolean booleanValue = fs.readBoolean(2);

界面上还有更多选项，例如、long等。最大的优点是它提供了平面文件输入的一致解析。而不是每个批处理作业以不同的方式解析潜在的意外方式，它可以是一致的，无论是在处理由格式异常，或在执行简单数据转换时。FieldSetDateBigDecimalFieldSet

`FlatFileItemReader`

平面文件是最多包含二维（表格）数据的任何类型的文件。在 Spring Batch 框架中读取平面文件由名为的类提供读取和解析平面文件的基本功能文件。的两个最重要的必需依赖项是和。该界面将在下一页中进一步探讨部分。资源属性表示一个弹簧核心。文档解释如何制作这种类型的豆子可以在春天找到框架，第 5 章。资源。因此，本指南不详细介绍创建对象除了显示以下简单示例之外：FlatFileItemReaderFlatFileItemReaderResourceLineMapperLineMapperResourceResource

Resource resource = new FileSystemResource("resources/trades.csv");

在复杂的批处理环境中，目录结构通常由企业应用程序集成（EAI）管理基础结构，其中为移动文件建立外部接口的放置区从 FTP 位置到批处理位置，反之亦然。文件移动实用程序超出了 Spring Batch 架构的范围，但对于 batch 来说并不罕见作业流，将文件移动实用程序作为作业流中的步骤包括在内。批次体系结构只需要知道如何找到要处理的文件。春季批次从此起点开始将数据馈送到管道的过程。但是，Spring Integration提供了许多这些类型的服务。

中的其他属性允许您进一步指定数据的方式解释，如下表所述：FlatFileItemReader

表 1. 性能FlatFileItemReader

财产	类型	描述
评论	字符串[]	指定指示注释行的行前缀。
编码	字符串	指定要使用的文本编码。默认值为。`UTF-8`
行映射器	`LineMapper`	将 a 转换为表示项的。`String``Object`
行到跳过	国际	文件顶部要忽略的行数。
记录分隔符策略	记录分隔符策略	用于确定行尾的位置并执行诸如在引号字符串内以行结尾继续之类的操作。
资源	`Resource`	要从中读取的资源。
skippedLinesCallback	LineCallbackHandler	传递原始行内容的接口文件中要跳过的行。如果设置为 2，则此接口为叫了两次。`linesToSkip`
严格	布尔	在严格模式下，读取器在 if 输入资源不存在。否则，它会记录问题并继续。`ExecutionContext`

`LineMapper`

与一样，它采用低级构造，例如和返回平面文件处理需要相同的结构来转换一行到，如以下接口定义所示：RowMapperResultSetObjectStringObject

public interface LineMapper {

    T mapLine(String line, int lineNumber) throws Exception;

}

基本合同是，给定当前行和行号。关联时，映射器应返回生成的域对象。这类似于，因为每行都与其行号相关联，就像中的每一行都与其行号相关联一样。这允许将行号绑定到生成的域对象，用于标识比较或提供更多信息的日志记录。然而与不同的是，它被赋予了一条原始行，如上所述，它只让你走到一半。该行必须标记为，然后可以是映射到对象，如本文档后面所述。RowMapperResultSetRowMapperLineMapperFieldSet

`LineTokenizer`

将一行输入转换为 a 的抽象是必要的，因为存在可以是需要转换为的多种格式的平面文件数据。在弹簧批，这个接口是：FieldSetFieldSetLineTokenizer

public interface LineTokenizer {

    FieldSet tokenize(String line);

}

a的协定是这样的，给定一行输入（理论上可以包含不止一行），表示该行的a是返回。然后可以将其传递给 .春季批次包含以下实现：LineTokenizerStringFieldSetFieldSetFieldSetMapperLineTokenizer

DelimitedLineTokenizer：用于记录中的字段由定界符。最常见的分隔符是逗号，但经常使用管道或分号也。
FixedLengthTokenizer：用于记录中每个字段都是“固定”的文件宽度”。必须为每种记录类型定义每个字段的宽度。
PatternMatchingCompositeLineTokenizer：确定在应通过检查模式在特定行上使用分词器。LineTokenizer

`FieldSetMapper`

该接口定义了单个方法，该方法采用一个对象并将其内容映射到一个对象。此对象可能是自定义 DTO，一个域对象或数组，具体取决于作业的需要。这是与结合使用从资源转换一行数据到所需类型的对象中，如以下接口定义所示：FieldSetMappermapFieldSetFieldSetFieldSetMapperLineTokenizer

public interface FieldSetMapper {

    T mapFieldSet(FieldSet fieldSet) throws BindException;

}

使用的模式与使用的模式相同。RowMapperJdbcTemplate

`DefaultLineMapper`

现在，已经定义了用于读取平面文件的基本接口，它变为明确需要三个基本步骤：

从文件中读取一行。
将该行传递到方法中以检索 .StringLineTokenizer#tokenize()FieldSet
将返回的 from 标记化传递给，返回方法的结果。FieldSetFieldSetMapperItemReader#read()

上面描述的两个接口表示两个单独的任务：将行转换为 a 和将 a 映射到域对象。因为 a 的输入与（a 行）的输入匹配，而 a 的输出与的输出匹配，所以默认实现同时使用 A 和 A 提供。这在以下类定义中显示，表示大多数用户需要的行为：FieldSetFieldSetLineTokenizerLineMapperFieldSetMapperLineMapperLineTokenizerFieldSetMapperDefaultLineMapper

public class DefaultLineMapper implements LineMapper<>, InitializingBean {

    private LineTokenizer tokenizer;

    private FieldSetMapper fieldSetMapper;

    public T mapLine(String line, int lineNumber) throws Exception {
        return fieldSetMapper.mapFieldSet(tokenizer.tokenize(line));
    }

    public void setLineTokenizer(LineTokenizer tokenizer) {
        this.tokenizer = tokenizer;
    }

    public void setFieldSetMapper(FieldSetMapper fieldSetMapper) {
        this.fieldSetMapper = fieldSetMapper;
    }
}

上述功能在默认实现中提供，而不是构建进入阅读器本身（如在以前版本的框架中所做的那样）以允许用户在控制解析过程方面具有更大的灵活性，尤其是在访问原始数据时需要行。

简单分隔文件读取示例

下面的示例演示如何使用实际域方案读取平面文件。此特定批处理作业从以下文件中读取足球运动员：

ID,lastName,firstName,position,birthYear,debutYear
"AbduKa00,Abdul-Jabbar,Karim,rb,1974,1996",
"AbduRa00,Abdullah,Rabih,rb,1975,1999",
"AberWa00,Abercrombie,Walter,rb,1959,1982",
"AbraDa00,Abramowicz,Danny,wr,1945,1967",
"AdamBo00,Adams,Bob,te,1946,1969",
"AdamCh00,Adams,Charlie,wr,1979,2003"

此文件的内容映射到以下域对象：Player

public class Player implements Serializable {

    private String ID;
    private String lastName;
    private String firstName;
    private String position;
    private int birthYear;
    private int debutYear;

    public String toString() {
        return "PLAYER:ID=" + ID + ",Last Name=" + lastName +
            ",First Name=" + firstName + ",Position=" + position +
            ",Birth Year=" + birthYear + ",DebutYear=" +
            debutYear;
    }

    // setters and getters...
}

要将 a 映射到对象中，返回玩家需要要定义，如以下示例所示：FieldSetPlayerFieldSetMapper

protected static class PlayerFieldSetMapper implements FieldSetMapper {
    public Player mapFieldSet(FieldSet fieldSet) {
        Player player = new Player();

        player.setID(fieldSet.readString(0));
        player.setLastName(fieldSet.readString(1));
        player.setFirstName(fieldSet.readString(2));
        player.setPosition(fieldSet.readString(3));
        player.setBirthYear(fieldSet.readInt(4));
        player.setDebutYear(fieldSet.readInt(5));

        return player;
    }
}

然后可以通过正确构造和调用来读取该文件，如以下示例所示：FlatFileItemReaderread

FlatFileItemReader itemReader = new FlatFileItemReader<>();
itemReader.setResource(new FileSystemResource("resources/players.csv"));
DefaultLineMapper lineMapper = new DefaultLineMapper<>();
//DelimitedLineTokenizer defaults to comma as its delimiter
lineMapper.setLineTokenizer(new DelimitedLineTokenizer());
lineMapper.setFieldSetMapper(new PlayerFieldSetMapper());
itemReader.setLineMapper(lineMapper);
itemReader.open(new ExecutionContext());
Player player = itemReader.read();

每次调用都会从文件中的每一行返回一个新对象。当文件末尾到达，返回。readPlayernull

按名称映射字段

两者都允许还有一个附加功能，并且在功能上类似于京东 .字段的名称可以注入到这些实现中的任何一个中，以提高映射函数的可读性。首先，将平面文件中所有字段的列名注入到分词器中，如以下示例所示：DelimitedLineTokenizerFixedLengthTokenizerResultSetLineTokenizer

tokenizer.setNames(new String[] {"ID", "lastName", "firstName", "position", "birthYear", "debutYear"});

A 可以按如下方式使用此信息：FieldSetMapper

public class PlayerMapper implements FieldSetMapper {
    public Player mapFieldSet(FieldSet fs) {

       if (fs == null) {
           return null;
       }

       Player player = new Player();
       player.setID(fs.readString("ID"));
       player.setLastName(fs.readString("lastName"));
       player.setFirstName(fs.readString("firstName"));
       player.setPosition(fs.readString("position"));
       player.setDebutYear(fs.readInt("debutYear"));
       player.setBirthYear(fs.readInt("birthYear"));

       return player;
   }
}

自动将字段集映射到域对象

对于许多人来说，必须写一个特定的和写一样麻烦 a 特定 a .Spring Batch 通过提供通过将字段名称与资源库匹配来自动映射字段在对象上使用 JavaBean 规范。FieldSetMapperRowMapperJdbcTemplateFieldSetMapper

再次使用足球示例，配置看起来像 XML 中的以下代码片段：BeanWrapperFieldSetMapper

XML 配置

  <bean id="fieldSetMapper"

class="org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper">
<property name="prototypeBeanName" value="player" />
</bean>

<bean id="player"
class="org.springframework.batch.sample.domain.Player"
scope="prototype" />

再次使用足球示例，配置看起来像 Java 中的以下代码片段：BeanWrapperFieldSetMapper

@Bean
public FieldSetMapper fieldSetMapper() {
  BeanWrapperFieldSetMapper fieldSetMapper = new BeanWrapperFieldSetMapper();

  fieldSetMapper.setPrototypeBeanName("player");

  return fieldSetMapper;
}

@Bean
@Scope("prototype")
public Player player() {
  return new Player();
}

对于中的每个条目，映射器都会在新的对象的实例（因此，需要原型范围）在与 Spring 容器查找与属性名称匹配的二传手的方式相同。每个可用映射中的字段，并返回结果对象，没有代码必填。FieldSetPlayerFieldSetPlayer

固定长度文件格式

到目前为止，只详细讨论了分隔文件。但是，它们代表只有一半的文件读取图片。许多使用平面文件的组织使用固定长度格式。固定长度文件示例如下：

UK21341EAH4121131.11customer1
UK21341EAH4221232.11customer2
UK21341EAH4321333.11customer3
UK21341EAH4421434.11customer4
UK21341EAH4521535.11customer5

虽然这看起来像一个大字段，但它实际上表示 4 个不同的字段：

ISIN：所订购商品的唯一标识符 - 长度为 12 个字符。
数量：订购商品的编号 - 3 个字符长。
价格：商品价格 - 5 个字符长。
客户：订购商品的客户的 ID - 9 个字符长。

配置时，必须提供这些长度中的每一个以范围的形式。FixedLengthLineTokenizer

下面的示例演示如何为 .XML：FixedLengthLineTokenizer

XML 配置

      class="org.springframework.batch.item.file.transform.FixedLengthTokenizer">

因为使用相同的接口前面讨论过，它返回的内容与使用分隔符相同。这允许使用相同的方法来处理其输出，例如使用 .FixedLengthLineTokenizerLineTokenizerFieldSetBeanWrapperFieldSetMapper

要支持上述范围语法，需要在中配置专用属性编辑器。然而，这个豆子在使用批处理命名空间的位置中自动声明。`RangeArrayPropertyEditor``ApplicationContext``ApplicationContext`

下面的示例演示如何为爪哇岛：FixedLengthLineTokenizer

爪哇配置

@Bean
public FixedLengthTokenizer fixedLengthTokenizer() {
  FixedLengthTokenizer tokenizer = new FixedLengthTokenizer();

  tokenizer.setNames("ISIN", "Quantity", "Price", "Customer");
  tokenizer.setColumns(new Range(1, 12),
            new Range(13, 15),
            new Range(16, 20),
            new Range(21, 29));

  return tokenizer;
}

因为使用相同的接口上面讨论过，它返回的内容与使用分隔符相同。这允许使用相同的方法来处理其输出，例如使用 .FixedLengthLineTokenizerLineTokenizerFieldSetBeanWrapperFieldSetMapper

单个文件中的多种记录类型

到目前为止，所有文件读取示例都对简单起见：文件中的所有记录都具有相同的格式。但是，这可能会情况并非总是如此。一个文件可能具有不同需要以不同的方式标记化并映射到不同对象的格式。这以下文件摘录说明了这一点：

USER;Smith;Peter;;T;20014539;F
LINEA;1044391041ABC037.49G201XX1383.12H
LINEB;2134776319DEF422.99M005LI

在这个文件中，我们有三种类型的记录，“USER”、“LINEA”和“LINEB”。“用户”行对应于一个对象。“LINEA”和“LINEB”都对应对象，尽管“LINEA”比“LINEB”具有更多信息。UserLine

单独读取每一行，但我们必须指定不同的和对象，以便接收正确的项目。通过允许地图使这变得容易要配置的模式和要配置的模式。ItemReaderLineTokenizerFieldSetMapperItemWriterPatternMatchingCompositeLineMapperLineTokenizersFieldSetMappers

下面的示例演示如何为 .XML：FixedLengthLineTokenizer

      class="org.spr...PatternMatchingCompositeLineMapper">

@Bean
public PatternMatchingCompositeLineMapper orderFileLineMapper() {
  PatternMatchingCompositeLineMapper lineMapper =
    new PatternMatchingCompositeLineMapper();

  Map<String, LineTokenizer> tokenizers = new HashMap<>(3);
  tokenizers.put("USER*", userTokenizer());
  tokenizers.put("LINEA*", lineATokenizer());
  tokenizers.put("LINEB*", lineBTokenizer());

  lineMapper.setTokenizers(tokenizers);

  Map<String, FieldSetMapper> mappers = new HashMap<>(2);
  mappers.put("USER*", userFieldSetMapper());
  mappers.put("LINE*", lineFieldSetMapper());

  lineMapper.setFieldSetMappers(mappers);

  return lineMapper;
}

在此示例中，“LINEA”和“LINEB”具有单独的实例，但它们都使用一样。LineTokenizerFieldSetMapper

使用方法以便为每行选择正确的代表。允许两个具有特殊含义的通配符：问号（“？”）正好匹配一个字符，而星号（“*”）匹配零个或多个字符。请注意，在在配置之前，所有模式都以星号结尾，使它们有效地行的前缀。始终匹配最具体的模式可能，无论配置中的顺序如何。因此，如果“LINE*”和“LINEA*”是两者都列为模式，“LINEA”将匹配模式“LINEA*”，而“LINEB”将匹配模式“线*”。此外，单个星号（“*”）可以通过匹配作为默认值任何其他模式不匹配的任何线条。PatternMatchingCompositeLineMapperPatternMatcher#matchPatternMatcherPatternMatcher

下面的示例演示如何匹配 XML 中任何其他模式不匹配的行：

XML 配置

<entry key="*" value-ref="defaultLineTokenizer" />

以下示例演示如何匹配 Java 中任何其他模式不匹配的行：

...
tokenizers.put("*", defaultLineTokenizer());
...

还有一个可用于标记化独自。PatternMatchingCompositeLineTokenizer

平面文件包含每个记录跨越多行的记录也很常见。自处理这种情况，需要更复杂的策略。对此的演示在样本中可以找到常见的模式。multiLineRecords

平面文件中的异常处理

在许多情况下，标记行可能会导致引发异常。多平面文件不完美，包含格式不正确的记录。许多用户选择在记录问题、原始行和行时跳过这些错误行数。稍后可以手动检查这些日志，也可以通过其他批处理作业检查这些日志。为此原因，Spring Batch 提供了用于处理解析异常的异常层次结构：和。是当尝试读取文件。由接口的实现引发，指示标记化时遇到的更具体的错误。FlatFileParseExceptionFlatFileFormatExceptionFlatFileParseExceptionFlatFileItemReaderFlatFileFormatExceptionLineTokenizer

`IncorrectTokenCountException`

两者都有能力指定可用于创建 .但是，如果列数名称与标记行时找到的列数不匹配，无法创建，并且抛出，其中包含遇到的令牌数和预期数，如以下示例所示：DelimitedLineTokenizerFixedLengthLineTokenizerFieldSetFieldSetIncorrectTokenCountException

tokenizer.setNames(new String[] {"A", "B", "C", "D"});

try {
    tokenizer.tokenize("a,b,c");
}
catch (IncorrectTokenCountException e) {
    assertEquals(4, e.getExpectedCount());
    assertEquals(3, e.getActualCount());
}

因为分词器配置了 4 个列名，但在文件，一个被抛出。IncorrectTokenCountException

`IncorrectLineLengthException`

以固定长度格式格式化的文件在解析时有其他要求因为，与分隔格式不同，每列都必须严格遵守其预定义的宽度。如果总行长不等于此列的最宽值，则引发异常，如以下示例所示：

tokenizer.setColumns(new Range[] { new Range(1, 5),
                                   new Range(6, 10),
                                   new Range(11, 15) });
try {
    tokenizer.tokenize("12345");
    fail("Expected IncorrectLineLengthException");
}
catch (IncorrectLineLengthException ex) {
    assertEquals(15, ex.getExpectedLength());
    assertEquals(5, ex.getActualLength());
}

上述分词器的配置范围为：1-5、6-10 和 11-15。因此线路总长度为15。但是，在前面的示例中，长度为 5 的行被传入，导致被扔出。投掷一个这里的异常，而不仅仅是映射第一列，允许处理行将更早失败，并且包含的信息比它所包含的信息更多，如果它失败了，则尝试在 .但是，在某些情况下线的长度并不总是恒定的。因此，线长度的验证可以通过“strict”属性关闭，如以下示例所示：IncorrectLineLengthExceptionFieldSetMapper

tokenizer.setColumns(new Range[] { new Range(1, 5), new Range(6, 10) });
tokenizer.setStrict(false);
FieldSet tokens = tokenizer.tokenize("12345");
assertEquals("12345", tokens.readString(0));
assertEquals("", tokens.readString(1));

前面的示例与前面的示例几乎相同，只是调用了该示例。此设置告知分词器不强制标记行时的行长度。A 现已正确创建，并且返回。但是，它仅包含其余值的空令牌。tokenizer.setStrict(false)FieldSet

`FlatFileItemWriter`

写出到平面文件具有与从文件读入相同的问题和问题必须克服。步骤必须能够以交易方式。

`LineAggregator`

正如接口需要将一个项目转换为，文件写入必须有一种方法将多个字段聚合成一个字符串用于写入文件。在春季批次中，这是，显示在以下接口定义：LineTokenizerStringLineAggregator

public interface LineAggregator {

    public String aggregate(T item);

}

与在逻辑上相反。取 a 并返回 a ，而取 a 并返回 .LineAggregatorLineTokenizerLineTokenizerStringFieldSetLineAggregatoritemString

`PassThroughLineAggregator`

接口最基本的实现是，它假定对象已经是一个字符串或它的字符串表示形式可以写入，如以下代码所示：LineAggregatorPassThroughLineAggregator

public class PassThroughLineAggregator implements LineAggregator {

    public String aggregate(T item) {
        return item.toString();
    }
}

如果直接控制创建字符串，则上述实现很有用必需但优点，例如事务和重新启动支持，是必要的。FlatFileItemWriter

简化文件写入示例

现在接口及其最基本的实现已经定义，基本的编写流程可以解释：LineAggregatorPassThroughLineAggregator

将要写入的对象传递给以获得 .LineAggregatorString
返回的将写入配置的文件。String

以下摘录在代码中表达了这一点：FlatFileItemWriter

public void write(T item) throws Exception {
    write(lineAggregator.aggregate(item) + LINE_SEPARATOR);
}

在 XML 中，一个简单的配置示例可能如下所示：

<bean id="itemWriter" class="org.spr...FlatFileItemWriter">
    <property name="resource" value="file:target/test-outputs/output.txt" />
    <property name="lineAggregator">
        <bean class="org.spr...PassThroughLineAggregator"/>
    </property>
</bean>

在 Java 中，一个简单的配置示例可能如下所示：

@Bean
public FlatFileItemWriter itemWriter() {
  return  new FlatFileItemWriterBuilder()
                .name("itemWriter")
                .resource(new FileSystemResource("target/test-outputs/output.txt"))
                .lineAggregator(new PassThroughLineAggregator<>())
                .build();
}

`FieldExtractor`

前面的示例对于写入文件的最基本用法可能很有用。但是，大多数用户都有一个需要写出来，因此必须转换为一行。在文件读取中，以下内容是必填：FlatFileItemWriter

从文件中读取一行。
将该行传递到方法中，以便检索 .LineTokenizer#tokenize()FieldSet
将返回的 from 标记化传递给，返回方法的结果。FieldSetFieldSetMapperItemReader#read()

文件写入具有类似但相反的步骤：

将要写入的项目传递给编写器。
将项目上的字段转换为数组。
将生成的数组聚合成一行。

因为框架无法知道对象的哪些字段需要被写出来，必须写才能完成翻转的任务项到数组中，如以下接口定义所示：FieldExtractor

public interface FieldExtractor {

    Object[] extract(T item);

}

接口的实现应从字段创建一个数组然后可以用分隔符写出提供的对象元素或作为固定宽度线的一部分。FieldExtractor

`PassThroughFieldExtractor`

在许多情况下，集合（如数组）或需要写出来。从这些集合类型之一中“提取”数组非常简单。为此，请将集合转换为数组。因此，在这种情况下应使用。应该指出的是，如果传入的对象不是一种集合类型，则返回一个仅包含要提取的项的数组。CollectionFieldSetPassThroughFieldExtractorPassThroughFieldExtractor

`BeanWrapperFieldExtractor`

与文件读取部分所述一样，它是通常最好配置如何将域对象转换为对象数组，而不是比自己写转换。提供这个功能，如以下示例所示：BeanWrapperFieldSetMapperBeanWrapperFieldExtractor

BeanWrapperFieldExtractor extractor = new BeanWrapperFieldExtractor<>();
extractor.setNames(new String[] { "first", "last", "born" });

String first = "Alan";
String last = "Turing";
int born = 1912;

Name n = new Name(first, last, born);
Object[] values = extractor.extract(n);

assertEquals(first, values[0]);
assertEquals(last, values[1]);
assertEquals(born, values[2]);

此提取器实现只有一个必需属性：要地图。正如需要字段名称将上的字段映射到所提供对象的 setter 一样，需要名称映射到用于创建对象数组的 getter。值得注意的是，该名称确定数组中字段的顺序。BeanWrapperFieldSetMapperFieldSetBeanWrapperFieldExtractor

分隔文件写入示例

最基本的平面文件格式是所有字段都由分隔符分隔的格式。这可以使用 .以下示例写入输出一个简单的域对象，该对象表示客户帐户的信用额度：DelimitedLineAggregator

public class CustomerCredit {

    private int id;
    private String name;
    private BigDecimal credit;

    //getters and setters removed for clarity
}

由于正在使用域对象，因此必须提供接口的实现以及要使用的分隔符。FieldExtractor

下面的示例演示如何在 XML 中使用 with 分隔符：FieldExtractor

XML 配置


    <bean id="itemWriter" class="org.springframework.batch.item.file.FlatFileItemWriter">

以下示例显示了如何在 Java 中使用 with 分隔符：FieldExtractor

@Bean
public FlatFileItemWriter itemWriter(Resource outputResource) throws Exception {
  BeanWrapperFieldExtractor fieldExtractor = new BeanWrapperFieldExtractor<>();
  fieldExtractor.setNames(new String[] {"name", "credit"});
  fieldExtractor.afterPropertiesSet();

  DelimitedLineAggregator lineAggregator = new DelimitedLineAggregator<>();
  lineAggregator.setDelimiter(",");
  lineAggregator.setFieldExtractor(fieldExtractor);

  return new FlatFileItemWriterBuilder()
        .name("customerCreditWriter")
        .resource(outputResource)
        .lineAggregator(lineAggregator)
        .build();
}

在前面的示例中，前面描述的章节用于将其中的名称和信用字段转换为对象数组，然后在每个字段之间用逗号写出。BeanWrapperFieldExtractorCustomerCredit

也可以使用自动创建 AND，如以下示例所示：FlatFileItemWriterBuilder.DelimitedBuilderBeanWrapperFieldExtractorDelimitedLineAggregator

@Bean
public FlatFileItemWriter itemWriter(Resource outputResource) throws Exception {
  return new FlatFileItemWriterBuilder()
        .name("customerCreditWriter")
        .resource(outputResource)
        .delimited()
        .delimiter("|")
        .names(new String[] {"name", "credit"})
        .build();
}

固定宽度文件写入示例

分隔不是平面文件格式的唯一类型。许多人喜欢使用设定的宽度在字段之间描绘的每一列，这通常称为“固定宽度”。 Spring Batch 在文件写入中支持此功能。FormatterLineAggregator

使用上述相同的域对象，它可以配置为在 XML 中遵循：CustomerCredit

<bean id="itemWriter" class="org.springframework.batch.item.file.FlatFileItemWriter">
    <property name="resource" ref="outputResource" />
    <property name="lineAggregator">
        <bean class="org.spr...FormatterLineAggregator">
            <property name="fieldExtractor">
                <bean class="org.spr...BeanWrapperFieldExtractor">
                    <property name="names" value="name,credit" />
                </bean>
            </property>
            <property name="format" value="%-9s%-2.0f" />
        </bean>
    </property>
</bean>

使用上述相同的域对象，它可以配置为在爪哇中遵循：CustomerCredit

@Bean
public FlatFileItemWriter itemWriter(Resource outputResource) throws Exception {
  BeanWrapperFieldExtractor fieldExtractor = new BeanWrapperFieldExtractor<>();
  fieldExtractor.setNames(new String[] {"name", "credit"});
  fieldExtractor.afterPropertiesSet();

  FormatterLineAggregator lineAggregator = new FormatterLineAggregator<>();
  lineAggregator.setFormat("%-9s%-2.0f");
  lineAggregator.setFieldExtractor(fieldExtractor);

  return new FlatFileItemWriterBuilder()
        .name("customerCreditWriter")
        .resource(outputResource)
        .lineAggregator(lineAggregator)
        .build();
}

前面的大多数示例应该看起来很熟悉。但是，格式的值物业很新。

下面的示例演示 XML 格式的格式属性：

<property name="format" value="%-9s%-2.0f" />

以下示例显示了 Java 中的格式属性：

...
FormatterLineAggregator lineAggregator = new FormatterLineAggregator<>();
lineAggregator.setFormat("%-9s%-2.0f");
...

底层实现是使用与 Java 5 相同的部分构建的。Java基于C编程的功能语言。有关如何配置格式化程序的大多数详细信息，请参见格式化程序的Javadoc。FormatterFormatterprintf

也可以使用自动创建 AND，如以下示例所示：FlatFileItemWriterBuilder.FormattedBuilderBeanWrapperFieldExtractorFormatterLineAggregator

@Bean
public FlatFileItemWriter itemWriter(Resource outputResource) throws Exception {
  return new FlatFileItemWriterBuilder()
        .name("customerCreditWriter")
        .resource(outputResource)
        .formatted()
        .format("%-9s%-2.0f")
        .names(new String[] {"name", "credit"})
        .build();
}

处理文件创建

FlatFileItemReader与文件资源的关系非常简单。当阅读器初始化后，它将打开文件（如果存在），如果不存在，则会引发异常。文件编写并不是那么简单。乍一看，似乎很相似应存在以下直接合约：如果文件已经存在，引发异常，如果不存在，则创建它并开始编写。然而重新启动可能会导致问题。在正常重启方案中，合约反转：如果文件存在，则从上一个已知良好的文件开始写入该文件位置，如果没有，则引发异常。但是，如果文件名因为这份工作总是一样吗？在这种情况下，如果文件，您可能需要删除该文件存在，除非重新启动。由于这种可能性，包含属性 .将此属性设置为 true 会导致打开编写器时要删除的同名现有文件。FlatFileItemWriterJobFlatFileItemWritershouldDeleteIfExists

XML 项目读取器和写入器

Spring Batch 为读取 XML 记录和将它们映射到 Java 对象以及将 Java 对象编写为 XML 记录。

对流式处理 XML 的约束 StAX API 用于 I/O，因为其他标准 XML 解析 API 不适合批处理处理要求（DOM 一次将整个输入加载到内存中，SAX 控件允许用户仅提供回调的解析过程）。

我们需要考虑 XML 输入和输出在 Spring Batch 中的工作方式。首先，有一个一些概念与文件读取和写入不同，但在 Spring Batch 中很常见 XML 处理。使用 XML 处理，而不是需要的记录行（实例）要进行标记化，假定 XML 资源是“片段”的集合对应于单个记录，如下图所示：FieldSet

Spring Batch -项目读写_spring_02

图1.XML 输入

在上述场景中，“trade”标签被定义为“根元素”。万事在“<贸易>”和“</贸易>”之间被认为是一个“片段”。春季批次使用对象/XML 映射（OXM）将片段绑定到对象。但是，春季批次不是绑定到任何特定的 XML 绑定技术。典型的用途是委托给Spring OXM，它为最流行的 OXM 技术提供统一的抽象。对 Spring OXM是可选的，您可以选择实现Spring Batch特定的接口如果需要。与 OXM 支持的技术的关系显示在下图：

Spring Batch -项目读写_spring_03

图2.OXM绑定

通过介绍 OXM 以及如何使用 XML 片段来表示记录，我们现在可以更仔细地检查读者和作者。

`StaxEventItemReader`

该配置为处理来自 XML 输入流的记录。首先，考虑以下一组 XML 记录，罐头工艺：StaxEventItemReaderStaxEventItemReader


<?xml versinotallow="1.0" encoding="UTF-8"?>
<records>
    <trade xmlns="https://springframework.org/batch/sample/io/oxm/domain">
        <isin>XYZ0001</isin>
        <quantity>5</quantity>
        <price>11.39</price>
        <customer>Customer1</customer>
    </trade>
    <trade xmlns="https://springframework.org/batch/sample/io/oxm/domain">
        <isin>XYZ0002</isin>
        <quantity>2</quantity>
        <price>72.99</price>
        <customer>Customer2c</customer>
    </trade>
    <trade xmlns="https://springframework.org/batch/sample/io/oxm/domain">
        <isin>XYZ0003</isin>
        <quantity>9</quantity>
        <price>99.99</price>
        <customer>Customer3</customer>
    </trade>
</records>

为了能够处理 XML 记录，需要以下各项：

根元素名称：构成要映射的对象。示例配置通过交易价值证明了这一点。
资源：表示要读取的文件的 Spring 资源。
Unmarshaller：Spring OXM提供的用于映射XML的解组工具片段到对象。

下面的示例演示如何定义适用于根的元素命名为、的资源和的解组器在 XML 中调用：StaxEventItemReadertradedata/iosample/input/input.xmltradeMarshaller

XML 配置

<bean id="itemReader" class="org.springframework.batch.item.xml.StaxEventItemReader">
    <property name="fragmentRootElementName" value="trade" />
    <property name="resource" value="org/springframework/batch/item/xml/domain/trades.xml" />
    <property name="unmarshaller" ref="tradeMarshaller" />
</bean>

下面的示例演示如何定义适用于根的元素命名为、的资源和的解组器在爪哇中调用：StaxEventItemReadertradedata/iosample/input/input.xmltradeMarshaller

爪哇配置

@Bean
public StaxEventItemReader itemReader() {
  return new StaxEventItemReaderBuilder()
      .name("itemReader")
      .resource(new FileSystemResource("org/springframework/batch/item/xml/domain/trades.xml"))
      .addFragmentRootElements("trade")
      .unmarshaller(tradeMarshaller())
      .build();

}

请注意，在此示例中，我们选择使用，它接受作为映射传入的别名，其中第一个键和值是片段的名称（即根元素）和要绑定的对象类型。然后，类似于，映射到对象类型中的字段的其他元素的名称描述为映射中的键/值对。在配置文件中，我们可以使用 Spring 配置用于描述所需别名的实用程序。XStreamMarshallerFieldSet

下面的示例演示如何在 XML 中描述别名：

XML 配置

<bean id="tradeMarshaller"
      class="org.springframework.oxm.xstream.XStreamMarshaller">
    <property name="aliases">
        <util:map id="aliases">
            <entry key="trade"
                   value="org.springframework.batch.sample.domain.trade.Trade" />
            <entry key="price" value="java.math.BigDecimal" />
            <entry key="isin" value="java.lang.String" />
            <entry key="customer" value="java.lang.String" />
            <entry key="quantity" value="java.lang.Long" />
        </util:map>
    </property>
</bean>

以下示例演示如何在 Java 中描述别名：

爪哇配置

@Bean
public XStreamMarshaller tradeMarshaller() {
  Map<String, Class> aliases = new HashMap<>();
  aliases.put("trade", Trade.class);
  aliases.put("price", BigDecimal.class);
  aliases.put("isin", String.class);
  aliases.put("customer", String.class);
  aliases.put("quantity", Long.class);

  XStreamMarshaller marshaller = new XStreamMarshaller();

  marshaller.setAliases(aliases);

  return marshaller;
}

在输入时，读取器读取 XML 资源，直到它识别出新片段即将开始。默认情况下，读取器匹配元素名称以识别新的片段即将开始。阅读器从片段并将文档传递给反序列化程序（通常是围绕 Spring 的包装器 OXM ）将 XML 映射到 Java 对象。Unmarshaller

总之，此过程类似于以下 Java 代码，它使用弹簧配置提供的注入：

StaxEventItemReader xmlStaxEventItemReader = new StaxEventItemReader<>();
Resource resource = new ByteArrayResource(xmlResource.getBytes());

Map aliases = new HashMap();
aliases.put("trade","org.springframework.batch.sample.domain.trade.Trade");
aliases.put("price","java.math.BigDecimal");
aliases.put("customer","java.lang.String");
aliases.put("isin","java.lang.String");
aliases.put("quantity","java.lang.Long");
XStreamMarshaller unmarshaller = new XStreamMarshaller();
unmarshaller.setAliases(aliases);
xmlStaxEventItemReader.setUnmarshaller(unmarshaller);
xmlStaxEventItemReader.setResource(resource);
xmlStaxEventItemReader.setFragmentRootElementName("trade");
xmlStaxEventItemReader.open(new ExecutionContext());

boolean hasNext = true;

Trade trade = null;

while (hasNext) {
    trade = xmlStaxEventItemReader.read();
    if (trade == null) {
        hasNext = false;
    }
    else {
        System.out.println(trade);
    }
}

`StaxEventItemWriter`

输出与输入对称工作。需要 a ， a 编组员，以及.Java 对象被传递给编组器（通常标准弹簧 OXM Marshaller），它通过使用自定义事件写入筛选为每个生成的和事件的编写器由 OXM 工具进行片段。StaxEventItemWriterResourcerootTagNameResourceStartDocumentEndDocument

以下 XML 示例使用：MarshallingEventWriterSerializer

XML 配置

<bean id="itemWriter" class="org.springframework.batch.item.xml.StaxEventItemWriter">
    <property name="resource" ref="outputResource" />
    <property name="marshaller" ref="tradeMarshaller" />
    <property name="rootTagName" value="trade" />
    <property name="overwriteOutput" value="true" />
</bean>

以下 Java 示例使用：MarshallingEventWriterSerializer

爪哇配置

@Bean
public StaxEventItemWriter itemWriter(Resource outputResource) {
  return new StaxEventItemWriterBuilder()
      .name("tradesWriter")
      .marshaller(tradeMarshaller())
      .resource(outputResource)
      .rootTagName("trade")
      .overwriteOutput(true)
      .build();

}

上述配置设置了三个必需的属性并设置了可选的属性，本章前面提到用于指定可以覆盖现有文件。overwriteOutput=true

以下 XML 示例使用的封送器与读取示例中使用的封送器相同在本章前面显示：

XML 配置

    <bean id="customerCreditMarshaller"

class="org.springframework.oxm.xstream.XStreamMarshaller">
<property name="aliases">
<util:map id="aliases">
<entry key="customer"
value="org.springframework.batch.sample.domain.trade.Trade" />
<entry key="price" value="java.math.BigDecimal" />
<entry key="isin" value="java.lang.String" />
<entry key="customer" value="java.lang.String" />
<entry key="quantity" value="java.lang.Long" />
</util:map>
</property>
</bean>

以下 Java 示例使用的编组器与阅读示例中使用的编组器相同在本章前面显示：

爪哇配置

@Bean
public XStreamMarshaller customerCreditMarshaller() {
  XStreamMarshaller marshaller = new XStreamMarshaller();

  Map<String, Class> aliases = new HashMap<>();
  aliases.put("trade", Trade.class);
  aliases.put("price", BigDecimal.class);
  aliases.put("isin", String.class);
  aliases.put("customer", String.class);
  aliases.put("quantity", Long.class);

  marshaller.setAliases(aliases);

  return marshaller;
}

为了总结一个 Java 示例，以下代码说明了所有要点讨论，演示所需属性的编程设置：

FileSystemResource resource = new FileSystemResource("data/outputFile.xml")

Map aliases = new HashMap();
aliases.put("trade","org.springframework.batch.sample.domain.trade.Trade");
aliases.put("price","java.math.BigDecimal");
aliases.put("customer","java.lang.String");
aliases.put("isin","java.lang.String");
aliases.put("quantity","java.lang.Long");
Marshaller marshaller = new XStreamMarshaller();
marshaller.setAliases(aliases);

StaxEventItemWriter staxItemWriter =
  new StaxEventItemWriterBuilder()
        .name("tradesWriter")
        .marshaller(marshaller)
        .resource(resource)
        .rootTagName("trade")
        .overwriteOutput(true)
        .build();

staxItemWriter.afterPropertiesSet();

ExecutionContext executionContext = new ExecutionContext();
staxItemWriter.open(executionContext);
Trade trade = new Trade();
trade.setPrice(11.39);
trade.setIsin("XYZ0001");
trade.setQuantity(5L);
trade.setCustomer("Customer1");
staxItemWriter.write(trade);

JSON 项目读取器和写入器

Spring Batch 支持以以下格式读取和写入 JSON 资源：

[
  {
    "isin": "123",
    "quantity": 1,
    "price": 1.2,
    "customer": "foo"
  },
  {
    "isin": "456",
    "quantity": 2,
    "price": 1.4,
    "customer": "bar"
  }
]

假定 JSON 资源是对应于单个项目。Spring Batch 不绑定到任何特定的 JSON 库。

`JsonItemReader`

委托 JSON 解析和绑定到接口的实现。此接口旨在通过使用流式处理 API 读取 JSON 对象来实现以块为单位。目前提供了两种实现：JsonItemReaderorg.springframework.batch.item.json.JsonObjectReader

杰克逊通过org.springframework.batch.item.json.JacksonJsonObjectReader
格森通过org.springframework.batch.item.json.GsonJsonObjectReader

为了能够处理 JSON 记录，需要以下内容：

Resource：表示要读取的 JSON 文件的 Spring 资源。
JsonObjectReader：用于解析 JSON 对象并将其绑定到项的 JSON 对象读取器

以下示例演示如何定义与以前的 JSON 资源和基于 Jackson 的 a：JsonItemReaderorg/springframework/batch/item/json/trades.jsonJsonObjectReader

@Bean
public JsonItemReader jsonItemReader() {
   return new JsonItemReaderBuilder()
                 .jsonObjectReader(new JacksonJsonObjectReader<>(Trade.class))
                 .resource(new ClassPathResource("trades.json"))
                 .name("tradeJsonItemReader")
                 .build();
}

`JsonFileItemWriter`

将项的封送委托给接口。合同这个接口是获取一个对象并将其编组到 JSON 中。目前提供了两种实现：JsonFileItemWriterorg.springframework.batch.item.json.JsonObjectMarshallerString

杰克逊通过org.springframework.batch.item.json.JacksonJsonObjectMarshaller
格森通过org.springframework.batch.item.json.GsonJsonObjectMarshaller

为了能够写入 JSON 记录，需要以下内容：

Resource：表示要写入的 JSON 文件的 SpringResource
JsonObjectMarshaller：JSON 对象编组器，用于将对象编组为 JSON 格式

下面的示例演示如何定义：JsonFileItemWriter

@Bean
public JsonFileItemWriter jsonFileItemWriter() {
   return new JsonFileItemWriterBuilder()
                 .jsonObjectMarshaller(new JacksonJsonObjectMarshaller<>())
                 .resource(new ClassPathResource("trades.json"))
                 .name("tradeJsonFileItemWriter")
                 .build();
}

多文件输入

在单个 .假设文件都具有相同的格式，支持这种类型的 XML 和平面文件处理的输入。考虑目录中的以下文件：StepMultiResourceItemReader

file-1.txt  file-2.txt  ignored.txt

文件-1.txt 和文件-2.txt 的格式相同，出于业务原因，应为一起处理。可用于读取两个文件：使用通配符。MultiResourceItemReader

下面的示例演示如何在 XML 中读取带有通配符的文件：

XML 配置

<bean id="multiResourceReader" class="org.spr...MultiResourceItemReader">
    <property name="resources" value="classpath:data/input/file-*.txt" />
    <property name="delegate" ref="flatFileItemReader" />
</bean>

以下示例演示如何在 Java 中读取带有通配符的文件：

爪哇配置

@Bean
public MultiResourceItemReader multiResourceReader() {
  return new MultiResourceItemReaderBuilder()
          .delegate(flatFileItemReader())
          .resources(resources())
          .build();
}

引用的委托是一个简单的 .上面的配置如下：来自两个文件的输入，处理回滚和重新启动方案。应该指出的是，与任何一样，添加额外的输入（在本例中为文件）可能会导致潜在的重新启动时出现问题。建议批处理作业与自己的个人一起工作目录，直到成功完成。FlatFileItemReaderItemReader

	输入资源按 using 排序，以确保在重新启动方案中的作业运行之间保留资源顺序。`MultiResourceItemReader#setComparator(Comparator)`

数据库

与大多数企业应用程序样式一样，数据库是批。然而，批次与其他应用风格不同，因为系统必须使用的数据集。如果 SQL 语句返回 100 万行，则结果集可能会将所有返回的结果保存在内存中，直到读取所有行。 Spring Batch 针对此问题提供了两种类型的解决方案：

基于游标的 ItemReader 实现
分页项目读取器实现

基于游标的实现`ItemReader`

使用数据库游标通常是大多数批处理开发人员的默认方法，因为它是数据库对“流式传输”关系数据问题的解决方案。这 Java类本质上是一种面向对象的机制，用于操作光标。A 维护指向当前数据行的游标。调用会将此光标移动到下一行。Spring Batch 基于游标的实现在初始化时打开一个游标，并将游标向前移动一行每次调用，返回可用于处理的映射对象。然后调用该方法以确保释放所有资源。Spring 核心通过使用回调模式完全映射来解决这个问题 A 中的所有行，并在将控制权返回给方法调用方之前关闭。但是，在批处理中，这必须等到步骤完成。下图显示了基于游标的工作原理的通用图。请注意，虽然示例使用SQL（因为SQL广为人知），任何技术都可以实现基本的方法。ResultSetResultSetnextResultSetItemReaderreadcloseJdbcTemplateResultSetItemReader

Spring Batch -项目读写_XML_04

图3.游标示例

此示例说明了基本模式。给定一个包含三列的“FOO”表：、和，选择ID 大于 1 但小于 7 的所有行。这将光标的开头（第 1 行）放在 ID 2 上。此行的结果应为完全映射的对象。再次调用会将光标移动到下一行， ID 为 3。这些读取的结果在每次之后写出，允许对对象进行垃圾回收（假设没有实例变量维护对它们的引用）。IDNAMEBARFooread()Fooread

`JdbcCursorItemReader`

JdbcCursorItemReader是基于游标技术的 JDBC 实现。它有效直接使用 a 并需要 SQL 语句才能针对连接运行从 .以下数据库架构用作示例：ResultSetDataSource

CREATE TABLE CUSTOMER (
   ID BIGINT IDENTITY PRIMARY KEY,
   NAME VARCHAR(45),
   CREDIT FLOAT
);

许多人喜欢对每一行使用域对象，因此以下示例使用映射对象的接口的实现：RowMapperCustomerCredit

public class CustomerCreditRowMapper implements RowMapper {

    public static final String ID_COLUMN = "id";
    public static final String NAME_COLUMN = "name";
    public static final String CREDIT_COLUMN = "credit";

    public CustomerCredit mapRow(ResultSet rs, int rowNum) throws SQLException {
        CustomerCredit customerCredit = new CustomerCredit();

        customerCredit.setId(rs.getInt(ID_COLUMN));
        customerCredit.setName(rs.getString(NAME_COLUMN));
        customerCredit.setCredit(rs.getBigDecimal(CREDIT_COLUMN));

        return customerCredit;
    }
}

由于与共享密钥接口，因此请参阅如何使用读取此数据的示例，以便对其进行对比与 .出于此示例的目的，假设中有 1，000 行数据库。第一个示例使用：JdbcCursorItemReaderJdbcTemplateJdbcTemplateItemReaderCUSTOMERJdbcTemplate

//For simplicity sake, assume a dataSource has already been obtained
JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
List customerCredits = jdbcTemplate.query("SELECT ID, NAME, CREDIT from CUSTOMER",
                                          new CustomerCreditRowMapper());

运行上述代码片段后，该列表包含 1，000 个对象。在查询方法中，从获取连接，针对它运行提供的 SQL，并调用该方法 .将此方法与以下示例中所示的方法进行对比：customerCreditsCustomerCreditDataSourcemapRowResultSetJdbcCursorItemReader

JdbcCursorItemReader itemReader = new JdbcCursorItemReader();
itemReader.setDataSource(dataSource);
itemReader.setSql("SELECT ID, NAME, CREDIT from CUSTOMER");
itemReader.setRowMapper(new CustomerCreditRowMapper());
int counter = 0;
ExecutionContext executionContext = new ExecutionContext();
itemReader.open(executionContext);
Object customerCredit = new Object();
while(customerCredit != null){
    customerCredit = itemReader.read();
    counter++;
}
itemReader.close();

运行上述代码段后，计数器等于 1，000。如果上面的代码有将返回的放入列表中，结果将完全是与示例相同。但是，它的最大优点是它允许“流式传输”项目。该方法可以调用一次，该项可以通过写出，然后可以使用获得下一项。这允许在“块”中完成项目读取和写入并提交周期性，这是高性能批处理的本质。此外，它可轻松配置为注入弹簧批次。customerCreditJdbcTemplateItemReaderreadItemWriterreadStep

下面的示例演示如何在 XML 中注入：ItemReaderStep

XML 配置

<bean id="itemReader" class="org.spr...JdbcCursorItemReader">
    <property name="dataSource" ref="dataSource"/>
    <property name="sql" value="select ID, NAME, CREDIT from CUSTOMER"/>
    <property name="rowMapper">
        <bean class="org.springframework.batch.sample.domain.CustomerCreditRowMapper"/>
    </property>
</bean>

以下示例显示了如何在 Java 中将 a 注入到中：ItemReaderStep

爪哇配置

@Bean
public JdbcCursorItemReader itemReader() {
  return new JdbcCursorItemReaderBuilder()
      .dataSource(this.dataSource)
      .name("creditReader")
      .sql("select ID, NAME, CREDIT from CUSTOMER")
      .rowMapper(new CustomerCreditRowMapper())
      .build();

}

其他属性

因为在 Java 中打开游标有很多不同的选项，所以有很多可以设置的属性，如下所述桌子：JdbcCursorItemReader

表 2.JdbcCursorItemReader Properties

忽略警告	确定是记录 SQLWarnings 还是导致异常。默认值为（表示记录警告）。`true`
获取大小	为 JDBC 驱动程序提供有关应读取的行数的提示当使用的对象需要更多行时，从数据库。默认情况下，不会给出任何提示。`ResultSet``ItemReader`
最大行数	设置基础可以的最大行数的限制随时保持。`ResultSet`
查询超时	将驱动程序等待对象的秒数设置为跑。如果超出限制，则抛出 a。（请咨询您的司机供应商文档了解详细信息）。`Statement``DataAccessException`
验证光标位置	因为由持有的相同被传递给，用户可以称呼自己，这可能会导致读取器的内部计数出现问题。将此值设置为原因如果调用后的光标位置与之前不同，则会引发异常。`ResultSet``ItemReader``RowMapper``ResultSet.next()``true``RowMapper`
保存状态	指示是否应将读取器的状态保存在提供的中。缺省值为。`ExecutionContext``ItemStream#update(ExecutionContext)``true`
驱动程序支持绝对	指示 JDBC 驱动程序是否支持在上设置绝对行。建议将其设置为支持的 JDBC 驱动程序，因为它可能会提高性能，特别是当一个步骤在处理大型数据集时失败时。默认值为。`ResultSet``true``ResultSet.absolute()``false`
设置使用共享扩展连接	指示连接是否用于游标应由所有其他处理使用，因此共享相同的交易。如果设置为，则使用自己的连接打开光标并且不参与为其余步骤处理而启动的任何事务。如果将此标志设置为则必须将数据源包装在中，以防止连接被关闭和每次提交后释放。将此选项设置为时，语句用于打开使用“READ_ONLY”和“HOLD_CURSORS_OVER_COMMIT”选项创建光标。这允许在事务启动时保持游标打开并在步骤处理。要使用此功能，您需要一个支持此功能的数据库和一个 JDBC 支持 JDBC 3.0 或更高版本的驱动程序。默认值为。`false``true``ExtendedConnectionDataSourceProxy``true``false`

`HibernateCursorItemReader`

就像普通的Spring用户对是否使用ORM做出重要决定一样解决方案，这会影响他们是否使用 A 或 A ，Spring Batch 用户具有相同的选项。是游标技术的休眠实现。 Hibernate在批处理中的使用一直存在相当大的争议。这主要是因为 Hibernate最初是为了支持在线应用程序样式而开发的。然而，那并不意味着它不能用于批处理。最简单的解决方法此问题是使用 A 而不是标准会话。这将删除 Hibernate使用的所有缓存和脏检查都可能导致问题批处理方案。有关无状态和正常状态之间区别的更多信息休眠会话，请参阅特定休眠版本的文档。允许您声明一个 HQL 语句并传入一个，这将在每次调用中传回一个项目以在相同的基本中读取时尚作为.以下示例配置使用相同的作为 JDBC 读取器的“客户信用”示例：JdbcTemplateHibernateTemplateHibernateCursorItemReaderStatelessSessionHibernateCursorItemReaderSessionFactoryJdbcCursorItemReader

HibernateCursorItemReader itemReader = new HibernateCursorItemReader();
itemReader.setQueryString("from CustomerCredit");
//For simplicity sake, assume sessionFactory already obtained.
itemReader.setSessionFactory(sessionFactory);
itemReader.setUseStatelessSession(true);
int counter = 0;
ExecutionContext executionContext = new ExecutionContext();
itemReader.open(executionContext);
Object customerCredit = new Object();
while(customerCredit != null){
    customerCredit = itemReader.read();
    counter++;
}
itemReader.close();

此配置以完全相同的方式返回对象如中所述，假设休眠映射文件已为表正确创建。“useStatelessSession”属性默认值为 true，但此处已添加以提请注意打开或关闭它的能力。还值得注意的是，可以使用该属性设置基础游标的读取大小。与一样，配置为简单。ItemReaderCustomerCreditJdbcCursorItemReaderCustomersetFetchSizeJdbcCursorItemReader

下面的示例演示如何在 XML 中注入休眠：ItemReader

XML 配置

      class="org.springframework.batch.item.database.HibernateCursorItemReader">

以下示例显示了如何在 Java 中注入休眠：ItemReader

爪哇配置

@Bean
public HibernateCursorItemReader itemReader(SessionFactory sessionFactory) {
  return new HibernateCursorItemReaderBuilder()
      .name("creditReader")
      .sessionFactory(sessionFactory)
      .queryString("from CustomerCredit")
      .build();
}

`StoredProcedureItemReader`

有时需要使用存储过程获取游标数据。作品喜欢，除了，相反在运行查询以获取游标时，它运行返回游标的存储过程。存储过程可以通过三种不同的方式返回游标：StoredProcedureItemReaderJdbcCursorItemReader

作为返回（由SQL Server，Sybase，DB2，Derby和MySQL使用）。ResultSet
作为 ref-cursor 作为 out 参数返回（由 Oracle 和 PostgreSQL 使用）。
作为存储函数调用的返回值。

以下 XML 示例配置使用与前面相同的“客户信用”示例例子：

XML 配置


    <bean id="reader" class="o.s.batch.item.database.StoredProcedureItemReader">
    <property name="dataSource" ref="dataSource"/>
    <property name="procedureName" value="sp_customer_credit"/>
    <property name="rowMapper">
        <bean class="org.springframework.batch.sample.domain.CustomerCreditRowMapper"/>
    </property>
</bean>

以下 Java 示例配置使用与早期的例子：

爪哇配置

@Bean
public StoredProcedureItemReader reader(DataSource dataSource) {
  StoredProcedureItemReader reader = new StoredProcedureItemReader();

  reader.setDataSource(dataSource);
  reader.setProcedureName("sp_customer_credit");
  reader.setRowMapper(new CustomerCreditRowMapper());

  return reader;
}

前面的示例依赖于存储过程提供作为返回的结果（前面的选项 1）。ResultSet

如果存储过程返回（选项 2），那么我们需要提供返回的 out 参数的位置。ref-cursorref-cursor

下面的示例演示如何使用第一个参数作为 ref 游标 .XML：

XML 配置


    
    <bean id="reader" class="o.s.batch.item.database.StoredProcedureItemReader">

下面的示例演示如何使用第一个参数作为 ref 游标爪哇岛：

爪哇配置

@Bean
public StoredProcedureItemReader reader(DataSource dataSource) {
  StoredProcedureItemReader reader = new StoredProcedureItemReader();

  reader.setDataSource(dataSource);
  reader.setProcedureName("sp_customer_credit");
  reader.setRowMapper(new CustomerCreditRowMapper());
  reader.setRefCursorPosition(1);

  return reader;
}

如果游标是从存储函数返回的（选项 3），我们需要设置属性“函数”到。默认为 .truefalse

下面的示例演示 XML 中的属性：true

XML 配置

<bean id="reader" class="o.s.batch.item.database.StoredProcedureItemReader">
    <property name="dataSource" ref="dataSource"/>
    <property name="procedureName" value="sp_customer_credit"/>
    <property name="function" value="true"/>
    <property name="rowMapper">
        <bean class="org.springframework.batch.sample.domain.CustomerCreditRowMapper"/>
    </property>
</bean>

以下示例显示了 Java 中的属性：true

爪哇配置

@Bean
public StoredProcedureItemReader reader(DataSource dataSource) {
  StoredProcedureItemReader reader = new StoredProcedureItemReader();

  reader.setDataSource(dataSource);
  reader.setProcedureName("sp_customer_credit");
  reader.setRowMapper(new CustomerCreditRowMapper());
  reader.setFunction(true);

  return reader;
}

在所有这些情况下，我们需要定义 a 以及 a 和实际过程名称。RowMapperDataSource

如果存储过程或函数接受参数，则必须声明它们并使用该属性设置。以下示例（对于 Oracle）声明了三个参数。第一个是返回 ref 光标的参数，以及第二个和第三个位于采用类型值的参数中。parametersoutINTEGER

下面的示例演示如何使用 XML 中的参数：

XML 配置


    <bean id="reader" class="o.s.batch.item.database.StoredProcedureItemReader">
    <property name="dataSource" ref="dataSource"/>
    <property name="procedureName" value="spring.cursor_func"/>
    <property name="parameters">
        <list>
            <bean class="org.springframework.jdbc.core.SqlOutParameter">
                <constructor-arg index="0" value="newid"/>
                <constructor-arg index="1">
                    <util:constant static-field="oracle.jdbc.OracleTypes.CURSOR"/>
                </constructor-arg>
            </bean>
            <bean class="org.springframework.jdbc.core.SqlParameter">
                <constructor-arg index="0" value="amount"/>
                <constructor-arg index="1">
                    <util:constant static-field="java.sql.Types.INTEGER"/>
                </constructor-arg>
            </bean>
            <bean class="org.springframework.jdbc.core.SqlParameter">
                <constructor-arg index="0" value="custid"/>
                <constructor-arg index="1">
                    <util:constant static-field="java.sql.Types.INTEGER"/>
                </constructor-arg>
            </bean>
        </list>
    </property>
    <property name="refCursorPosition" value="1"/>
    <property name="rowMapper" ref="rowMapper"/>
    <property name="preparedStatementSetter" ref="parameterSetter"/>
</bean>

以下示例显示了如何在 Java 中使用参数：

爪哇配置

@Bean
public StoredProcedureItemReader reader(DataSource dataSource) {
  List parameters = new ArrayList<>();
  parameters.add(new SqlOutParameter("newId", OracleTypes.CURSOR));
  parameters.add(new SqlParameter("amount", Types.INTEGER);
  parameters.add(new SqlParameter("custId", Types.INTEGER);

  StoredProcedureItemReader reader = new StoredProcedureItemReader();

  reader.setDataSource(dataSource);
  reader.setProcedureName("spring.cursor_func");
  reader.setParameters(parameters);
  reader.setRefCursorPosition(1);
  reader.setRowMapper(rowMapper());
  reader.setPreparedStatementSetter(parameterSetter());

  return reader;
}

除了参数声明之外，我们还需要指定一个为调用设置参数值的实现。这与以上。其他属性中列出的所有其他属性也适用于。PreparedStatementSetterJdbcCursorItemReaderStoredProcedureItemReader

分页实现`ItemReader`

使用数据库游标的替代方法是运行多个查询，其中每个查询获取部分结果。我们将此部分称为页面。每个查询必须指定起始行号和我们希望在页面中返回的行数。

`JdbcPagingItemReader`

分页的一种实现是 .需要负责提供 SQL 用于检索构成页面的行的查询。由于每个数据库都有自己的数据库为了提供分页支持，我们需要对每种受支持的数据库类型使用不同的。还有自动检测正在使用的数据库并确定适当的实现。这简化了配置，并且是建议的最佳做法。ItemReaderJdbcPagingItemReaderJdbcPagingItemReaderPagingQueryProviderPagingQueryProviderSqlPagingQueryProviderFactoryBeanPagingQueryProvider

要求您指定子句和子句。您还可以提供可选子句。这些条款和必需用于构建 SQL 语句。SqlPagingQueryProviderFactoryBeanselectfromwheresortKey

	重要的是要有一个唯一的键约束，以保证执行之间不会丢失任何数据。`sortKey`

打开读取器后，它会在每次调用中传回一个项目基本时尚和其他任何.寻呼发生在幕后，当需要额外的行。readItemReader

以下 XML 示例配置使用与前面显示的基于游标的：ItemReaders

XML 配置


    <bean id="itemReader" class="org.spr...JdbcPagingItemReader">

以下 Java 示例配置使用与前面显示的基于游标的：ItemReaders

爪哇配置

@Bean
public JdbcPagingItemReader itemReader(DataSource dataSource, PagingQueryProvider queryProvider) {
  Map<String, Object> parameterValues = new HashMap<>();
  parameterValues.put("status", "NEW");

  return new JdbcPagingItemReaderBuilder()
                  .name("creditReader")
                  .dataSource(dataSource)
                  .queryProvider(queryProvider)
                  .parameterValues(parameterValues)
                  .rowMapper(customerCreditMapper())
                  .pageSize(1000)
                  .build();
}

@Bean
public SqlPagingQueryProviderFactoryBean queryProvider() {
  SqlPagingQueryProviderFactoryBean provider = new SqlPagingQueryProviderFactoryBean();

  provider.setSelectClause("select id, name, credit");
  provider.setFromClause("from customer");
  provider.setWhereClause("where status=:status");
  provider.setSortKey("id");

  return provider;
}

此配置使用，返回对象，必须指定。“pageSize”属性确定读取的实体数从数据库进行每次查询运行。ItemReaderCustomerCreditRowMapper

“参数值”属性可用于指定查询。如果在子句中使用命名参数，则每个条目的键应匹配命名参数的名称。如果使用传统的“？”占位符，则每个条目的键应为占位符的编号，从 1 开始。Mapwhere

`JpaPagingItemReader`

分页的另一个实现是 .JPA做没有类似于冬眠的概念，所以我们不得不使用其他 JPA 规范提供的功能。由于 JPA 支持分页，因此这是很自然的选择使用 JPA 进行批处理。阅读每页后，实体变得分离并清除持久性上下文，以允许实体处理页面后进行垃圾回收。ItemReaderJpaPagingItemReaderStatelessSession

允许您声明 JPQL 语句并传入 .然后，它每次调用传回一个项目以读取相同的基本时尚和其他任何.寻呼发生在幕后，当附加需要实体。JpaPagingItemReaderEntityManagerFactoryItemReader

以下 XML 示例配置使用与前面显示的 JDBC 读取器：

XML 配置

<bean id="itemReader" class="org.spr...JpaPagingItemReader">
    <property name="entityManagerFactory" ref="entityManagerFactory"/>
    <property name="queryString" value="select c from CustomerCredit c"/>
    <property name="pageSize" value="1000"/>
</bean>

以下 Java 示例配置使用与前面显示的 JDBC 读取器：

爪哇配置

@Bean
public JpaPagingItemReader itemReader() {
  return new JpaPagingItemReaderBuilder()
                  .name("creditReader")
                  .entityManagerFactory(entityManagerFactory())
                  .queryString("select c from CustomerCredit c")
                  .pageSize(1000)
                  .build();
}

此配置以与上述描述，假设对象具有更正 JPA 注释或 ORM 映射文件。“页面大小”属性确定每次查询执行从数据库中读取的实体数。ItemReaderCustomerCreditJdbcPagingItemReaderCustomerCredit

数据库项编写器

虽然平面文件和 XML 文件都有特定的实例，但没有完全相同的等效实例在数据库世界中。这是因为事务提供了所有需要的功能。实现对于文件是必需的，因为它们必须像事务性一样运行，跟踪书面项目并在适当的时间刷新或清除。数据库不需要此功能，因为写入已包含在交易。用户可以创建自己的DAO来实现接口或使用为一般处理问题编写的自定义中的一个。也方式，他们应该没有任何问题地工作。需要注意的一件事是性能以及通过批处理输出提供的错误处理功能。这是最使用休眠作为时很常见，但在使用 JDBC 批处理模式。批处理数据库输出没有任何固有缺陷，假设我们小心刷新，数据中没有错误。但是，任何错误写作会引起混乱，因为无法知道哪个单独的项目导致了例外情况，甚至任何单个项目负责，如下图：ItemWriterItemWriterItemWriterItemWriterItemWriter

Spring Batch -项目读写_spring_05

图4.刷新时出错

如果在写入之前缓冲了项目，则在缓冲区在提交之前刷新。例如，假设每个块写入 20 个项目，第 15 项抛出 .就而言，所有 20 个项目都写得成功，因为没有办法知道在实际写入之前会发生错误。一旦被调用，清空缓冲区并命中异常。在这一点上，无能为力。必须回滚事务。通常，此异常可能会导致要跳过的项目（取决于跳过/重试策略），然后不写入再。但是，在批处理方案中，无法知道哪个项目导致了问题。发生故障时，正在写入整个缓冲区。唯一的出路解决此问题是在每个项目后刷新，如下图所示：DataIntegrityViolationExceptionStepSession#flush()Step

Spring Batch -项目读写_spring_06

图5.写入时出错

这是一个常见的用例，尤其是在使用 Hibernate 时，以及的实现要在每次调用时刷新。这样做允许对于要可靠地跳过的项目，Spring Batch 内部负责错误后调用的粒度。ItemWriterwrite()ItemWriter

重用现有服务

批处理系统通常与其他应用程序样式结合使用。最常见的是在线系统，但它也可能支持集成甚至胖客户端通过移动每种应用程序样式使用的必要批量数据来应用。为此原因，许多用户希望重用现有的DAO或其他服务是很常见的。他们的批处理作业。Spring 容器本身通过允许任何要注入的必要类。但是，在某些情况下，现有服务需要充当 or ，以满足另一个春季批次类，或者因为它确实是一个步骤的主要内容。是的为每个需要包装的服务编写适配器类相当简单，但是因为它是一个常见的问题，Spring Batch 提供了实现：和 .两个类都实现了标准的弹簧方法通过调用委托模式，并且设置起来相当简单。ItemReaderItemWriterItemReaderItemReaderAdapterItemWriterAdapter

以下 XML 示例使用：ItemReaderAdapter

XML 配置

<bean id="itemReader" class="org.springframework.batch.item.adapter.ItemReaderAdapter">
    <property name="targetObject" ref="fooService" />
    <property name="targetMethod" value="generateFoo" />
</bean>

<bean id="fooService" class="org.springframework.batch.item.sample.FooService" />

以下 Java 示例使用：ItemReaderAdapter

爪哇配置

@Bean
public ItemReaderAdapter itemReader() {
  ItemReaderAdapter reader = new ItemReaderAdapter();

  reader.setTargetObject(fooService());
  reader.setTargetMethod("generateFoo");

  return reader;
}

@Bean
public FooService fooService() {
  return new FooService();
}

需要注意的一点是，合同必须相同作为合约：用尽时返回。否则，它将返回一个 .其他任何事情都会阻止框架知道处理何时应该结束，导致无限循环或不正确的故障，具体取决于实现的 .targetMethodreadnullObjectItemWriter

以下 XML 示例使用：ItemWriterAdapter

XML 配置


<bean id="itemWriter" class="org.springframework.batch.item.adapter.ItemWriterAdapter">
    <property name="targetObject" ref="fooService" />
    <property name="targetMethod" value="processFoo" />
</bean>

<bean id="fooService" class="org.springframework.batch.item.sample.FooService" />

以下 Java 示例使用：ItemWriterAdapter

爪哇配置

@Bean
public ItemWriterAdapter itemWriter() {
  ItemWriterAdapter writer = new ItemWriterAdapter();

  writer.setTargetObject(fooService());
  writer.setTargetMethod("processFoo");

  return writer;
}

@Bean
public FooService fooService() {
  return new FooService();
}

防止状态持久性

默认情况下，所有和实现都存储其当前提交之前的状态。但是，这可能并不总是所需的行为。例如，许多开发人员选择制作他们的数据库读取器通过使用过程指示器“可重新运行”。将额外列添加到输入数据中指示是否已处理。当正在读取特定记录时（或写入）处理的标志从翻转到。然后，SQL 语句可以在子句中包含额外的语句，例如，从而确保在重新启动时仅返回未处理的记录。在在这种情况下，最好不要存储任何状态，例如当前行号，因为它在重新启动时无关紧要。因此，所有读者和作者都包括 “保存状态”属性。ItemReaderItemWriterExecutionContextfalsetruewherewhere PROCESSED_IND = false

以下 Bean 定义显示了如何防止 XML 中的状态持久性：

XML 配置

<bean id="playerSummarizationSource" class="org.spr...JdbcCursorItemReader">
    <property name="dataSource" ref="dataSource" />
    <property name="rowMapper">
        <bean class="org.springframework.batch.sample.PlayerSummaryMapper" />
    </property>
    <property name="saveState" value="false" />
    <property name="sql">
        <value>
            SELECT games.player_id, games.year_no, SUM(COMPLETES),
            SUM(ATTEMPTS), SUM(PASSING_YARDS), SUM(PASSING_TD),
            SUM(INTERCEPTIONS), SUM(RUSHES), SUM(RUSH_YARDS),
            SUM(RECEPTIONS), SUM(RECEPTIONS_YARDS), SUM(TOTAL_TD)
            from games, players where players.player_id =
            games.player_id group by games.player_id, games.year_no
        </value>
    </property>
</bean>

以下 Bean 定义显示了如何在 Java 中防止状态持久性：

爪哇配置

@Bean
public JdbcCursorItemReader playerSummarizationSource(DataSource dataSource) {
  return new JdbcCursorItemReaderBuilder()
        .dataSource(dataSource)
        .rowMapper(new PlayerSummaryMapper())
        .saveState(false)
        .sql("SELECT games.player_id, games.year_no, SUM(COMPLETES),"
          + "SUM(ATTEMPTS), SUM(PASSING_YARDS), SUM(PASSING_TD),"
          + "SUM(INTERCEPTIONS), SUM(RUSHES), SUM(RUSH_YARDS),"
          + "SUM(RECEPTIONS), SUM(RECEPTIONS_YARDS), SUM(TOTAL_TD)"
          + "from games, players where players.player_id ="
          + "games.player_id group by games.player_id, games.year_no")
        .build();

}

上面配置的不会在 for 中进行任何条目它参与的任何处决。ItemReaderExecutionContext

创建自定义条目读取器和条目编写器

到目前为止，本章已经讨论了春季阅读和写作的基本契约批处理和一些用于执行此操作的常见实现。然而，这些都是公平的通用，并且有许多潜在的方案可能无法被开箱即用的涵盖实现。本节通过使用一个简单的示例来展示如何创建自定义和实现并正确实现其协定。还实现了，以说明如何使读者或编写器可重新启动。ItemReaderItemWriterItemReaderItemStream

自定义示例`ItemReader`

出于此示例的目的，我们创建了一个简单的实现从提供的列表读取。我们首先实现最基本的契约，方法，如下面的代码所示：ItemReaderItemReaderread

public class CustomItemReader implements ItemReader {

    List items;

    public CustomItemReader(List items) {
        this.items = items;
    }

    public T read() throws Exception, UnexpectedInputException,
       NonTransientResourceException, ParseException {

        if (!items.isEmpty()) {
            return items.remove(0);
        }
        return null;
    }
}

前面的类获取项目列表，并一次返回一个项目，并删除每个从列表中。当列表为空时，它返回，从而满足最基本的的要求，如以下测试代码所示：nullItemReader

List items = new ArrayList<>();
items.add("1");
items.add("2");
items.add("3");

ItemReader itemReader = new CustomItemReader<>(items);
assertEquals("1", itemReader.read());
assertEquals("2", itemReader.read());
assertEquals("3", itemReader.read());
assertNull(itemReader.read());

使`ItemReader`

最后一个挑战是使可重新启动。目前，如果处理中断并重新开始，必须从头开始。这是实际上在许多情况下都有效，但有时最好是批处理作业从中断的地方重新启动。关键的判别因素通常是读者是否是有状态的或无国籍。无状态读取器无需担心可重启性，但有状态的必须在重新启动时尝试重建其最后一个已知状态。出于这个原因，我们建议您尽可能保持自定义读取器无状态，因此您不必担心关于可重启性。ItemReaderItemReader

如果确实需要存储状态，则应使用该接口：ItemStream

public class CustomItemReader implements ItemReader, ItemStream {

    List items;
    int currentIndex = 0;
    private static final String CURRENT_INDEX = "current.index";

    public CustomItemReader(List items) {
        this.items = items;
    }

    public T read() throws Exception, UnexpectedInputException,
        ParseException, NonTransientResourceException {

        if (currentIndex < items.size()) {
            return items.get(currentIndex++);
        }

        return null;
    }

    public void open(ExecutionContext executionContext) throws ItemStreamException {
        if (executionContext.containsKey(CURRENT_INDEX)) {
            currentIndex = new Long(executionContext.getLong(CURRENT_INDEX)).intValue();
        }
        else {
            currentIndex = 0;
        }
    }

    public void update(ExecutionContext executionContext) throws ItemStreamException {
        executionContext.putLong(CURRENT_INDEX, new Long(currentIndex).longValue());
    }

    public void close() throws ItemStreamException {}
}

在每次调用该方法时，的当前索引都存储在提供的键“current.index”中。调用该方法时，将检查以查看它是否包含具有该键的条目。如果找到该键，则当前索引将移动到那个位置。这是一个相当微不足道的例子，但它仍然符合总合同：ItemStreamupdateItemReaderExecutionContextItemStreamopenExecutionContext

ExecutionContext executionContext = new ExecutionContext();
((ItemStream)itemReader).open(executionContext);
assertEquals("1", itemReader.read());
((ItemStream)itemReader).update(executionContext);

List items = new ArrayList<>();
items.add("1");
items.add("2");
items.add("3");
itemReader = new CustomItemReader<>(items);

((ItemStream)itemReader).open(executionContext);
assertEquals("2", itemReader.read());

大多数都有更复杂的重启逻辑。例如，将上次处理的行的行 ID 存储在光标。ItemReadersJdbcCursorItemReader

还值得注意的是，其中使用的密钥不应该是琐碎。那是因为相同的用于所有内部一个。在大多数情况下，只需在键前面加上类名就足够了以保证唯一性。但是，在极少数情况下，在同一步骤中使用两个相同类型的（如果需要两个文件，则可能会发生这种情况）输出），需要一个更独特的名称。出于这个原因，许多 Spring 批处理和实现都有一个属性，允许键名称被覆盖。ExecutionContextExecutionContextItemStreamsStepItemStreamItemReaderItemWritersetName()

自定义示例`ItemWriter`

实现自定义在许多方面与示例相似以上，但在足够多的地方有所不同，以保证它自己的例子。但是，添加可重启性本质上是相同的，因此此示例不涉及它。与示例一样，使用 a 以使示例保持简单可能：ItemWriterItemReaderItemReaderList

public class CustomItemWriter implements ItemWriter {

    List output = TransactionAwareProxyFactory.createTransactionalList();

    public void write(Chunk<? extends T> items) throws Exception {
        output.addAll(items);
    }

    public List getOutput() {
        return output;
    }
}

使`ItemWriter`

为了使可重新启动，我们将遵循与相同的过程，添加和实现接口以同步执行上下文。在示例中，我们可能必须计算处理的项目数并将其添加为页脚记录。如果我们需要这样做，我们可以在我们的中实现，以便从执行中重组计数器上下文（如果流已重新打开）。ItemWriterItemReaderItemStreamItemStreamItemWriter

在许多现实情况下，习俗也会委托给另一个作家，即可重新启动（例如，写入文件时），否则它会写入事务资源等不需要重新启动，因为它是无状态的。当你有一个有状态的编写器时，你可能应该确保实现为以及.还要记住，作家的客户需要知道，因此您可能需要在配置中将其注册为流。ItemWritersItemStreamItemWriterItemStream

项目读取器和编写器实现

在本节中，我们将向您介绍尚未进入的读者和作家在前面的部分中进行了讨论。

装饰

在某些情况下，用户需要将专用行为附加到预先存在的 .Spring Batch 提供了一些开箱即用的装饰器，可以添加对你和实现的其他行为。ItemReaderItemReaderItemWriter

春季批次包括以下装饰器：

SynchronizedItemStreamReader
SingleItemPeekableItemReader
SynchronizedItemStreamWriter
MultiResourceItemWriter
ClassifierCompositeItemWriter
ClassifierCompositeItemProcessor

`SynchronizedItemStreamReader`

当使用非线程安全时，Spring Batch 提供了装饰器，可用于使线程安全。Spring Batch 提供了一个的实例。ItemReaderSynchronizedItemStreamReaderItemReaderSynchronizedItemStreamReaderBuilderSynchronizedItemStreamReader

`SingleItemPeekableItemReader`

Spring Batch 包含一个装饰器，用于向 .此一瞥方法允许用户提前查看一个项目。重复调用速览返回相同的项，这是从该方法返回的下一项。Spring Batch 提供了一个构造 .ItemReaderreadSingleItemPeekableItemReaderBuilderSingleItemPeekableItemReader

SingleItemPeekableItemReader 的 peek 方法不是线程安全的，因为它不会可以在多个线程中遵循窥视。只有一个线程偷看将在下一次调用中读取该项目。

`SynchronizedItemStreamWriter`

当使用非线程安全时，Spring Batch 提供了装饰器，可用于使线程安全。Spring Batch 提供了一个的实例。ItemWriterSynchronizedItemStreamWriterItemWriterSynchronizedItemStreamWriterBuilderSynchronizedItemStreamWriter

`MultiResourceItemWriter`

换行并创建一个新的当前资源中写入的项目数超过 .春季批次提供了一个构造的实例。MultiResourceItemWriterResourceAwareItemWriterItemStreamitemCountLimitPerResourceMultiResourceItemWriterBuilderMultiResourceItemWriter

`ClassifierCompositeItemWriter`

调用每个项目的实现集合之一，基于通过提供的 .如果所有委托都是线程安全的，则实现是线程安全的。春天批处理提供了一个用于构造 .ClassifierCompositeItemWriterItemWriterClassifierClassifierCompositeItemWriterBuilderClassifierCompositeItemWriter

`ClassifierCompositeItemProcessor`

是一个调用一个基于实现的路由器模式的实现集合通过提供的.Spring Batch 提供了一个构造 .ClassifierCompositeItemProcessorItemProcessorItemProcessorClassifierClassifierCompositeItemProcessorBuilderClassifierCompositeItemProcessor

消息传递阅读器和写入器

Spring Batch 为常用的消息传递系统提供以下阅读器和写入器：

AmqpItemReader
AmqpItemWriter
JmsItemReader
JmsItemWriter
KafkaItemReader
KafkaItemWriter

`AmqpItemReader`

是使用接收或转换来自交易所的消息。Spring Batch 提供了一个的实例。AmqpItemReaderItemReaderAmqpTemplateAmqpItemReaderBuilderAmqpItemReader

`AmqpItemWriter`

是使用将消息发送到 AMQP交易所。如果名称未在提供的 .春季批处理提供了一个构造的实例。AmqpItemWriterItemWriterAmqpTemplateAmqpTemplateAmqpItemWriterBuilderAmqpItemWriter

`JmsItemReader`

对于使用 .模板应具有默认目标，用于为方法提供项。Spring Batch 提供了一个构造 .JmsItemReaderItemReaderJmsTemplateread()JmsItemReaderBuilderJmsItemReader

`JmsItemWriter`

对于使用 .模板应具有默认目标，用于在中发送项目。春天批处理提供了一个用于构造 .JmsItemWriterItemWriterJmsTemplatewrite(List)JmsItemWriterBuilderJmsItemWriter

`KafkaItemReader`

这是一个Apache Kafka主题。可以配置从同一主题的多个分区读取消息。它存储消息偏移在执行上下文中支持重启功能。Spring Batch 提供了一个构造 .KafkaItemReaderItemReaderKafkaItemReaderBuilderKafkaItemReader

`KafkaItemWriter`

对于 Apache Kafka，它使用 a 到将事件发送到默认主题。春季批次提供了一个构造的实例。KafkaItemWriterItemWriterKafkaTemplateKafkaItemWriterBuilderKafkaItemWriter

数据库读取器

Spring Batch提供以下数据库阅读器：

Neo4jItemReader
MongoItemReader
HibernateCursorItemReader
HibernatePagingItemReader
RepositoryItemReader

`Neo4jItemReader`

这是一个从图形数据库 Neo4j 读取对象的通过使用分页技术。春季批次提供了一个构造的实例。Neo4jItemReaderItemReaderNeo4jItemReaderBuilderNeo4jItemReader

`MongoItemReader`

这是一个通过使用 MongoDB 从 MongoDB 读取文档分页技术。Spring Batch 提供了一个来构造一个的实例。MongoItemReaderItemReaderMongoItemReaderBuilderMongoItemReader

`HibernateCursorItemReader`

用于读取数据库记录建立在冬眠之上。它执行 HQL 查询，然后在初始化时迭代在调用方法时对结果集进行，连续返回一个对象对应于当前行。Spring Batch 提供了一个构造 .HibernateCursorItemReaderItemStreamReaderread()HibernateCursorItemReaderBuilderHibernateCursorItemReader

`HibernatePagingItemReader`

是用于读取数据库记录构建在 Hibernate顶部，一次最多只能读取固定数量的项目。春季批次提供了一个用于构造的实例。HibernatePagingItemReaderItemReaderHibernatePagingItemReaderBuilderHibernatePagingItemReader

`RepositoryItemReader`

是使用 .春季批次提供了一个构造的实例。RepositoryItemReaderItemReaderPagingAndSortingRepositoryRepositoryItemReaderBuilderRepositoryItemReader

数据库编写器

Spring Batch提供以下数据库编写器：

Neo4jItemWriter
MongoItemWriter
RepositoryItemWriter
HibernateItemWriter
JdbcBatchItemWriter
JpaItemWriter

`Neo4jItemWriter`

这是一个写入 Neo4j 数据库的实现。 Spring Batch 提供了一个构造 .Neo4jItemWriterItemWriterNeo4jItemWriterBuilderNeo4jItemWriter

`MongoItemWriter`

这是一个写入MongoDB存储的实现使用 Spring 数据的实现。Spring Batch 提供了一个构造 .MongoItemWriterItemWriterMongoOperationsMongoItemWriterBuilderMongoItemWriter

`RepositoryItemWriter`

这是来自春天的包装器数据。Spring Batch 提供了一个构造实例这。RepositoryItemWriterItemWriterCrudRepositoryRepositoryItemWriterBuilderRepositoryItemWriter

`HibernateItemWriter`

是使用休眠会话来保存或更新不属于当前休眠会话的实体。春季批次提供 a 来构造 .HibernateItemWriterItemWriterHibernateItemWriterBuilderHibernateItemWriter

`JdbcBatchItemWriter`

这是一个使用批处理功能，为提供的所有项目执行一批语句。 Spring Batch 提供了一个构造 .JdbcBatchItemWriterItemWriterNamedParameterJdbcTemplateJdbcBatchItemWriterBuilderJdbcBatchItemWriter

`JpaItemWriter`

是使用 JPA 进行合并不属于持久性上下文的任何实体。Spring Batch 提供了一个构造 .JpaItemWriterItemWriterEntityManagerFactoryJpaItemWriterBuilderJpaItemWriter

专业读者

Spring Batch提供以下专业阅读器：

LdifReader
MappingLdifReader
AvroItemReader

`LdifReader`

从、中读取 LDIF（LDAP 数据交换格式）记录。解析它们，并为每个执行的内容返回一个对象。春季批次提供了一个用于构造的实例。LdifReaderResourceLdapAttributereadLdifReaderBuilderLdifReader

`MappingLdifReader`

从中读取 LDIF（LDAP 数据交换格式）记录，解析它们，然后将每个 LDIF 记录映射到 POJO（普通旧 Java 对象）。每次读取都会返回一个 POJO。Spring Batch 提供了一个的实例。MappingLdifReaderResourceMappingLdifReaderBuilderMappingLdifReader

`AvroItemReader`

从资源读取序列化的 Avro 数据。每次读取都返回由 Java 类或 Avro 模式指定的类型的实例。可以选择将读取器配置为嵌入或不嵌入 Avro 架构的输入。 Spring Batch 提供了一个用于构造 .AvroItemReaderAvroItemReaderBuilderAvroItemReader

专业作家

Spring Batch提供以下专业作家：

SimpleMailMessageItemWriter
AvroItemWriter

`SimpleMailMessageItemWriter`

这是一个可以发送邮件消息。它将消息的实际发送委托给的实例。春季批次提供了一个用于构造的实例。SimpleMailMessageItemWriterItemWriterMailSenderSimpleMailMessageItemWriterBuilderSimpleMailMessageItemWriter

`AvroItemWriter`

根据给定的类型或模式将 Java 对象序列化为 WriteableResource。可以选择将编写器配置为在输出中嵌入或不嵌入 Avro 架构。 Spring Batch 提供了一个用于构造 .AvroItemWriteAvroItemWriterBuilderAvroItemWriter

专用处理器

Spring Batch提供以下专用处理器：

ScriptItemProcessor

`ScriptItemProcessor`

是将当前项目传递给处理的到提供的脚本，脚本的结果由处理器返回。春天批处理提供了一个用于构造 .ScriptItemProcessorItemProcessorScriptItemProcessorBuilderScriptItemProcessor

文章来源： https://blog.51cto.com/u_15326439/5947233

特别声明：以上内容（图片及文字）均为互联网收集或者用户上传发布，本站仅提供信息存储服务！如有侵权或有涉及法律问题请联系我们。

Spring Batch -项目读写

​​ItemReader​​

​​ItemWriter​​

​​ItemStream​​

委托模式和注册步骤

平面文件

这​​FieldSet​​

​​FlatFileItemReader​​

​​LineMapper​​

​​LineTokenizer​​

​​FieldSetMapper​​

​​DefaultLineMapper​​

简单分隔文件读取示例

按名称映射字段

自动将字段集映射到域对象

固定长度文件格式

单个文件中的多种记录类型

平面文件中的异常处理

​​IncorrectTokenCountException​​

​​IncorrectLineLengthException​​

​​FlatFileItemWriter​​

​​LineAggregator​​

​​PassThroughLineAggregator​​

简化文件写入示例

​​FieldExtractor​​

​​PassThroughFieldExtractor​​

​​BeanWrapperFieldExtractor​​

分隔文件写入示例

固定宽度文件写入示例

处理文件创建

XML 项目读取器和写入器

​​StaxEventItemReader​​

​​StaxEventItemWriter​​

JSON 项目读取器和写入器

​​JsonItemReader​​

​​JsonFileItemWriter​​

多文件输入

数据库

基于游标的实现​​ItemReader​​

​​JdbcCursorItemReader​​

其他属性

​​HibernateCursorItemReader​​

​​StoredProcedureItemReader​​

分页实现​​ItemReader​​

​​JdbcPagingItemReader​​

​​JpaPagingItemReader​​

数据库项编写器

重用现有服务

防止状态持久性

创建自定义条目读取器和条目编写器

自定义示例​​ItemReader​​

使​​ItemReader​​

自定义示例​​ItemWriter​​

使​​ItemWriter​​

项目读取器和编写器实现

装饰

​​SynchronizedItemStreamReader​​

​​SingleItemPeekableItemReader​​

​​SynchronizedItemStreamWriter​​

​​MultiResourceItemWriter​​

​​ClassifierCompositeItemWriter​​

​​ClassifierCompositeItemProcessor​​

消息传递阅读器和写入器

​​AmqpItemReader​​

​​AmqpItemWriter​​

​​JmsItemReader​​

​​JmsItemWriter​​

​​KafkaItemReader​​

​​KafkaItemWriter​​

数据库读取器

​​Neo4jItemReader​​

​​MongoItemReader​​

​​HibernateCursorItemReader​​

​​HibernatePagingItemReader​​

​​RepositoryItemReader​​

数据库编写器

​​Neo4jItemWriter​​

​​MongoItemWriter​​

​​RepositoryItemWriter​​

​​HibernateItemWriter​​

`ItemReader`

`ItemWriter`

`ItemStream`

这`FieldSet`

`FlatFileItemReader`

`LineMapper`

`LineTokenizer`

`FieldSetMapper`

`DefaultLineMapper`

`IncorrectTokenCountException`

`IncorrectLineLengthException`

`FlatFileItemWriter`

`LineAggregator`

`PassThroughLineAggregator`

`FieldExtractor`

`PassThroughFieldExtractor`

`BeanWrapperFieldExtractor`

`StaxEventItemReader`

`StaxEventItemWriter`

`JsonItemReader`

`JsonFileItemWriter`

基于游标的实现`ItemReader`

`JdbcCursorItemReader`

`HibernateCursorItemReader`

`StoredProcedureItemReader`

分页实现`ItemReader`

`JdbcPagingItemReader`

`JpaPagingItemReader`

自定义示例`ItemReader`

使`ItemReader`

自定义示例`ItemWriter`

使`ItemWriter`

`SynchronizedItemStreamReader`

`SingleItemPeekableItemReader`

`SynchronizedItemStreamWriter`

`MultiResourceItemWriter`

`ClassifierCompositeItemWriter`

`ClassifierCompositeItemProcessor`

`AmqpItemReader`

`AmqpItemWriter`

`JmsItemReader`

`JmsItemWriter`

`KafkaItemReader`

`KafkaItemWriter`

`Neo4jItemReader`

`MongoItemReader`

`HibernateCursorItemReader`

`HibernatePagingItemReader`

`RepositoryItemReader`

`Neo4jItemWriter`

`MongoItemWriter`

`RepositoryItemWriter`

`HibernateItemWriter`

`JdbcBatchItemWriter`

`JpaItemWriter`

`LdifReader`

`MappingLdifReader`

`AvroItemReader`

`SimpleMailMessageItemWriter`

`AvroItemWriter`

`ScriptItemProcessor`