Spring Batch输出数据通过ItemWriter接口的实现类来完成，包括FlatFileItemWriter文本数据输出、StaxEventItemWriter XML文件数据输出、JsonItemWriter JSON文件数据输出、JdbcBatchItemWriter数据库数据插入等实现，更多可用的实现可以参考：https://docs.spring.io/spring-batch/docs/4.2.x/reference/html/appendix.html#itemWritersAppendix，本文只介绍这四种比较常用的输出数据方式。

框架搭建

新建一个Spring Boot项目，版本为2.2.4.RELEASE，artifactId为spring-batch-itemwriter，项目结构如下图所示：

Spring Batch输出数据 - 图1

剩下的数据库层的准备，项目配置，依赖引入和Spring Batch入门文章中的框架搭建步骤一致，这里就不再赘述。

在介绍Spring Batch数据输出之前，我们先准备个简单的数据读取源。在cc.mrbird.batch包下新建entity包，然后在该包下新建TestData实体类：

  1. public class TestData {
  3.     private int id;
  4.     private String field1;
  5.     private String field2;
  6.     private String field3;
  7.     // get,set,toString略
  8. }

接着在cc.mrbird.batch包下新建reader包，然后在该包下创建ItemReaderConfigure：

  1. @Configuration
  2. public class ItemReaderConfigure {
  4.     @Bean
  5.     public ListItemReader<TestData> simpleReader() {
  6.         List<TestData> data = new ArrayList<>();
  7.         TestData testData1 = new TestData();
  8.         testData1.setId(1);
  9.         testData1.setField1("11");
  10.         testData1.setField2("12");
  11.         testData1.setField3("13");
  12.         data.add(testData1);
  13.         TestData testData2 = new TestData();
  14.         testData2.setId(2);
  15.         testData2.setField1("21");
  16.         testData2.setField2("22");
  17.         testData2.setField3("23");
  18.         data.add(testData2);
  19.         return new ListItemReader<>(data);
  20.     }
  21. }

上面注册了一个ItemReader类型的Bean，后续都用它作为读取数据的来源。

输出文本数据

在cc.mrbird.batch包下新建job包，然后在该包下新建FileItemWriterDemo，用于测试Spring Batch输出数据到文本文件：

  1. @Component
  2. public class FileItemWriterDemo {
  4.     @Autowired
  5.     private JobBuilderFactory jobBuilderFactory;
  6.     @Autowired
  7.     private StepBuilderFactory stepBuilderFactory;
  8.     @Autowired
  9.     private ListItemReader<TestData> simpleReader;
  11.     @Bean
  12.     public Job fileItemWriterJob() throws Exception {
  13.         return jobBuilderFactory.get("fileItemWriterJob")
  14.                 .start(step())
  15.                 .build();
  16.     }
  18.     private Step step() throws Exception {
  19.         return stepBuilderFactory.get("step")
  20.                 .<TestData, TestData>chunk(2)
  21.                 .reader(simpleReader)
  22.                 .writer(fileItemWriter())
  23.                 .build();
  24.     }
  26.     private FlatFileItemWriter<TestData> fileItemWriter() throws Exception {
  27.         FlatFileItemWriter<TestData> writer = new FlatFileItemWriter<>();
  29.         FileSystemResource file = new FileSystemResource("/Users/mrbird/Desktop/file");
  30.         Path path = Paths.get(file.getPath());
  31.         if (!Files.exists(path)) {
  32.             Files.createFile(path);
  33.         }
  34.         // 设置输出文件路径
  35.         writer.setResource(file); 
  37.         // 把读到的每个TestData对象转换为JSON字符串
  38.         LineAggregator<TestData> aggregator = item -> {
  39.             try {
  40.                 ObjectMapper mapper = new ObjectMapper();
  41.                 return mapper.writeValueAsString(item);
  42.             } catch (JsonProcessingException e) {
  43.                 e.printStackTrace();
  44.             }
  45.             return "";
  46.         };
  48.         writer.setLineAggregator(aggregator);
  49.         writer.afterPropertiesSet();
  50.         return writer;
  51.     }
  52. }

上面代码中，Step中的Reader使用的是我们上面创建的simpleReader，文本数据输出使用的是FlatFileItemWriter。fileItemWriter()方法的代码较为简单，这里就不赘述了。

启动项目后，在/Users/mrbird/Desktop目录下（也就是我的电脑桌面上）会多出个file文件：

Spring Batch输出数据 - 图2

输出xml数据

同样的，xml格式数据输出需要借助spring-oxm框架，在pom中引入相关依赖：

  1. <dependency>
  2.     <groupId>org.springframework</groupId>
  3.     <artifactId>spring-oxm</artifactId>
  4. </dependency>
  5. <dependency>
  6.     <groupId>com.thoughtworks.xstream</groupId>
  7.     <artifactId>xstream</artifactId>
  8.     <version>1.4.11.1</version>
  9. </dependency>

然后在job包下新建XmlFileItemWriterDemo，用于测试Spring Batch输出数据到xml文件：

  1. @Component
  2. public class XmlFileItemWriterDemo {
  4.     @Autowired
  5.     private JobBuilderFactory jobBuilderFactory;
  6.     @Autowired
  7.     private StepBuilderFactory stepBuilderFactory;
  8.     @Autowired
  9.     private ListItemReader<TestData> simpleReader;
  11.     @Bean
  12.     public Job xmlFileItemWriterJob() throws Exception {
  13.         return jobBuilderFactory.get("xmlFileItemWriterJob")
  14.                 .start(step())
  15.                 .build();
  16.     }
  18.     private Step step() throws Exception {
  19.         return stepBuilderFactory.get("step")
  20.                 .<TestData, TestData>chunk(2)
  21.                 .reader(simpleReader)
  22.                 .writer(xmlFileItemWriter())
  23.                 .build();
  24.     }
  26.     private StaxEventItemWriter<TestData> xmlFileItemWriter() throws IOException {
  27.         StaxEventItemWriter<TestData> writer = new StaxEventItemWriter<>();
  29.         // 通过XStreamMarshaller将TestData转换为xml
  30.         XStreamMarshaller marshaller = new XStreamMarshaller();
  32.         Map<String,Class<TestData>> map = new HashMap<>(1);
  33.         map.put("test", TestData.class);
  35.         marshaller.setAliases(map); // 设置xml标签
  37.         writer.setRootTagName("tests"); // 设置根标签
  38.         writer.setMarshaller(marshaller);
  40.         FileSystemResource file = new FileSystemResource("/Users/mrbird/Desktop/file.xml");
  41.         Path path = Paths.get(file.getPath());
  42.         if (!Files.exists(path)) {
  43.             Files.createFile(path);
  44.         }
  46.         writer.setResource(file); // 设置目标文件路径
  47.         return writer;
  48.     }
  49. }

xml类型文件输出使用的是StaxEventItemWriter。

启动项目后，在/Users/mrbird/Desktop目录下会多出个file.xml文件：

Spring Batch输出数据 - 图3

输出JSON数据

在job包下新建JsonFileItemWriterDemo，用于测试Spring Batch输出数据到json文件：

  1. @Component
  2. public class JsonFileItemWriterDemo {
  4.     @Autowired
  5.     private JobBuilderFactory jobBuilderFactory;
  6.     @Autowired
  7.     private StepBuilderFactory stepBuilderFactory;
  8.     @Autowired
  9.     private ListItemReader<TestData> simpleReader;
  11.     @Bean
  12.     public Job jsonFileItemWriterJob() throws Exception {
  13.         return jobBuilderFactory.get("jsonFileItemWriterJob")
  14.                 .start(step())
  15.                 .build();
  16.     }
  18.     private Step step() throws Exception {
  19.         return stepBuilderFactory.get("step")
  20.                 .<TestData, TestData>chunk(2)
  21.                 .reader(simpleReader)
  22.                 .writer(jsonFileItemWriter())
  23.                 .build();
  24.     }
  26.     private JsonFileItemWriter<TestData> jsonFileItemWriter() throws IOException {
  27.         // 文件输出目标地址
  28.         FileSystemResource file = new FileSystemResource("/Users/mrbird/Desktop/file.json");
  29.         Path path = Paths.get(file.getPath());
  30.         if (!Files.exists(path)) {
  31.             Files.createFile(path);
  32.         }
  33.         // 将对象转换为json
  34.         JacksonJsonObjectMarshaller<TestData> marshaller = new JacksonJsonObjectMarshaller<>();
  35.         JsonFileItemWriter<TestData> writer = new JsonFileItemWriter<>(file, marshaller);
  36.         // 设置别名
  37.         writer.setName("testDatasonFileItemWriter");
  38.         return writer;
  39.     }
  40. }

json类型文件输出使用的是JsonFileItemWriter。

启动项目后，在/Users/mrbird/Desktop目录下会多出个file.json文件：

Spring Batch输出数据 - 图4

输出数据到数据库

在job包下新建DatabaseItemWriterDemo，用于测试Spring Batch输出数据到数据库：

  1. @Component
  2. public class DatabaseItemWriterDemo {
  4.     @Autowired
  5.     private JobBuilderFactory jobBuilderFactory;
  6.     @Autowired
  7.     private StepBuilderFactory stepBuilderFactory;
  8.     @Autowired
  9.     private ListItemReader<TestData> simpleReader;
  10.     @Autowired
  11.     private DataSource dataSource;
  13.     @Bean
  14.     public Job datasourceItemWriterJob() {
  15.         return jobBuilderFactory.get("datasourceItemWriterJob")
  16.                 .start(step())
  17.                 .build();
  18.     }
  20.     private Step step() {
  21.         return stepBuilderFactory.get("step")
  22.                 .<TestData, TestData>chunk(2)
  23.                 .reader(simpleReader)
  24.                 .writer(dataSourceItemWriter())
  25.                 .build();
  26.     }
  28.     private ItemWriter<TestData> dataSourceItemWriter() {
  29.         // ItemWriter的实现类之一，mysql数据库数据写入使用JdbcBatchItemWriter，
  30.         // 其他实现：MongoItemWriter,Neo4jItemWriter等
  31.         JdbcBatchItemWriter<TestData> writer = new JdbcBatchItemWriter<>();
  32.         writer.setDataSource(dataSource); // 设置数据源
  34.         String sql = "insert into TEST(id,field1,field2,field3) values (:id,:field1,:field2,:field3)";
  35.         writer.setSql(sql); // 设置插入sql脚本
  37.         // 映射TestData对象属性到占位符中的属性
  38.         BeanPropertyItemSqlParameterSourceProvider<TestData> provider = new BeanPropertyItemSqlParameterSourceProvider<>();
  39.         writer.setItemSqlParameterSourceProvider(provider);
  41.         writer.afterPropertiesSet(); // 设置一些额外属性
  42.         return writer;
  43.     }
  44. }

MySQL关系型数据数据写入使用的是JdbcBatchItemWriter。在测试之前，先清空springbatch数据库TEST表数据，然后启动项目，启动后，TEST表记录如下所示：

Spring Batch输出数据 - 图5

多文本输出

多文本输出和上一节介绍的多文本数据读取类似，都是需要通过代理来完成。我们模拟个同时输出xml格式和普通文本格式的例子。

在cc.mrbird.batch包下新建writer包，然后在该包下新建ItemWriterConfigure配置类：

  1. @Configuration
  2. public class ItemWriterConfigure {
  4.     @Bean
  5.     public FlatFileItemWriter<TestData> fileItemWriter() throws Exception {
  6.         FlatFileItemWriter<TestData> writer = new FlatFileItemWriter<>();
  8.         FileSystemResource file = new FileSystemResource("/Users/mrbird/Desktop/file");
  9.         Path path = Paths.get(file.getPath());
  10.         if (!Files.exists(path)) {
  11.             Files.createFile(path);
  12.         }
  14.         writer.setResource(file); // 设置目标文件路径
  16.         // 把读到的每个TestData对象转换为字符串
  17.         LineAggregator<TestData> aggregator = item -> {
  18.             try {
  19.                 ObjectMapper mapper = new ObjectMapper();
  20.                 return mapper.writeValueAsString(item);
  21.             } catch (JsonProcessingException e) {
  22.                 e.printStackTrace();
  23.             }
  24.             return "";
  25.         };
  27.         writer.setLineAggregator(aggregator);
  28.         writer.afterPropertiesSet();
  29.         return writer;
  30.     }
  32.     @Bean
  33.     public StaxEventItemWriter<TestData> xmlFileItemWriter() throws Exception {
  34.         StaxEventItemWriter<TestData> writer = new StaxEventItemWriter<>();
  36.         // 通过XStreamMarshaller将TestData转换为xml
  37.         XStreamMarshaller marshaller = new XStreamMarshaller();
  39.         Map<String, Class<TestData>> map = new HashMap<>(1);
  40.         map.put("test", TestData.class);
  42.         marshaller.setAliases(map); // 设置xml标签
  44.         writer.setRootTagName("tests"); // 设置根标签
  45.         writer.setMarshaller(marshaller);
  47.         FileSystemResource file = new FileSystemResource("/Users/mrbird/Desktop/file.xml");
  48.         Path path = Paths.get(file.getPath());
  49.         if (!Files.exists(path)) {
  50.             Files.createFile(path);
  51.         }
  53.         writer.setResource(file); // 设置目标文件路径
  54.         return writer;
  55.     }
  56. }

上面的配置类中，配置了FlatFileItemWriter和StaxEventItemWriter类型的ItemWriter Bean，代码步骤和前面介绍的一致。

然后在job包下新建MultiFileItemWriteDemo，用于测试多文本输出：

  1. @Component
  2. public class MultiFileItemWriteDemo {
  4.     @Autowired
  5.     private JobBuilderFactory jobBuilderFactory;
  6.     @Autowired
  7.     private StepBuilderFactory stepBuilderFactory;
  8.     @Autowired
  9.     private DataSource dataSource;
  10.     @Autowired
  11.     private ListItemReader<TestData> simpleReader;
  12.     @Autowired
  13.     private ItemStreamWriter<TestData> fileItemWriter;
  14.     @Autowired
  15.     private ItemStreamWriter<TestData> xmlFileItemWriter;
  17.     @Bean
  18.     public Job multiFileItemWriterJob() {
  19.         return jobBuilderFactory.get("multiFileItemWriterJob")
  20.                 .start(step())
  21.                 .build();
  22.     }
  24.     private Step step() {
  25.         return stepBuilderFactory.get("step")
  26.                 .<TestData, TestData>chunk(2)
  27.                 .reader(simpleReader)
  28.                 .writer(classifierMultiFileItemWriter())
  29.                 .stream(fileItemWriter)
  30.                 .stream(xmlFileItemWriter)
  31.                 .build();
  32.     }
  34.     // 将数据分类，然后分别输出到对应的文件(此时需要将writer注册到ioc容器，否则报
  35.     // WriterNotOpenException: Writer must be open before it can be written to)
  36.     private ClassifierCompositeItemWriter<TestData> classifierMultiFileItemWriter() {
  37.         ClassifierCompositeItemWriter<TestData> writer = new ClassifierCompositeItemWriter<>();
  38.         writer.setClassifier((Classifier<TestData, ItemWriter<? super TestData>>) testData -> {
  39.             try {
  40.                 // id能被2整除则输出到普通文本，否则输出到xml文本
  41.                 return testData.getId() % 2 == 0 ? fileItemWriter : xmlFileItemWriter;
  42.             } catch (Exception e) {
  43.                 e.printStackTrace();
  44.             }
  45.             return null;
  46.         });
  47.         return writer;
  48.     }
  49. }

ClassifierCompositeItemWriter可以设置不同条件下使用不同的ItemWriter输出数据，此外在Step中，还需通过StepBuilderFactory的stream()方法传入使用到的ItemWriter（这里需要注意的是，注入的时候，类型应选择ItemStreamWriter）。

在启动项目前，先删掉/Users/mrbird/Desktop目录下的文件。删掉后，启动项目，结果如下：

Spring Batch输出数据 - 图6

Spring Batch输出数据 - 图7

如果不想用分类，希望所有数据都输出到对应格式的文本中，则可以使用CompositeItemWriter作为代理输出，修改MultiFileItemWriteDemo：

  1. @Component
  2. public class MultiFileItemWriteDemo {
  4.     @Autowired
  5.     private JobBuilderFactory jobBuilderFactory;
  6.     @Autowired
  7.     private StepBuilderFactory stepBuilderFactory;
  8.     @Autowired
  9.     private ListItemReader<TestData> simpleReader;
  10.     @Autowired
  11.     private ItemStreamWriter<TestData> fileItemWriter;
  12.     @Autowired
  13.     private ItemStreamWriter<TestData> xmlFileItemWriter;
  15.     @Bean
  16.     public Job multiFileItemWriterJob() {
  17.         return jobBuilderFactory.get("multiFileItemWriterJob2")
  18.                 .start(step())
  19.                 .build();
  20.     }
  22.     private Step step() {
  23.         return stepBuilderFactory.get("step")
  24.                 .<TestData, TestData>chunk(2)
  25.                 .reader(simpleReader)
  26.                 .writer(multiFileItemWriter())
  27.                 .build();
  28.     }
  30.     // 输出数据到多个文件
  31.     private CompositeItemWriter<TestData> multiFileItemWriter() {
  32.         // 使用CompositeItemWriter代理
  33.         CompositeItemWriter<TestData> writer = new CompositeItemWriter<>();
  34.         // 设置具体写代理
  35.         writer.setDelegates(Arrays.asList(fileItemWriter, xmlFileItemWriter));
  36.         return writer;
  37.     }
  38. }

在启动项目前，先删掉/Users/mrbird/Desktop目录下的文件。删掉后，启动项目，结果如下：

Spring Batch输出数据 - 图8