This article is all about how to use Spring Batch jobs to read data from a Mongo Collection and generate an XML file. This will be very useful for generating reports out of mongoDB using Spring Batch. I was really struggling to get a running Maven project of Spring Batch with MongoDB read operations to generate XML when I was researching it via various internet sources. This running project might be helpful.

Technology stack:

• Java 8
• Maven 3.5.2
• Spring Boot 1.5.2
• MongoDB 3.6

The complete, running Maven project can be downloaded from my GitHub repo.

1. pom.xml File        

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-oxm</artifactId>
        <version>4.3.7.RELEASE</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-mongodb</artifactId>
        <version>1.9.8.RELEASE</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-batch</artifactId>
        <version>1.5.2.RELEASE</version>
        <scope>compile</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <version>1.5.2.RELEASE</version>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.0</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

2) application.properties

spring.data.mongodb.host=127.0.0.1
spring.data.mongodb.port=27017
spring.data.mongodb.database=batchdb

3) Spring Batch Jobs

Create a job that will read from Mongodb and write into an XML file.

package com.batch.mongo.mongotoxml.jobs;

import java.util.HashMap;
import java.util.Map;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.item.data.MongoItemReader;
import org.springframework.batch.item.xml.StaxEventItemWriter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.FileSystemResource;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.oxm.xstream.XStreamMarshaller;

import com.batch.mongo.mongotoxml.model.Employee;

@Configuration
@EnableBatchProcessing
public class MongoDBReader {

  @Autowired
  private JobBuilderFactory jobBuilderFactory;
  @Autowired
  private StepBuilderFactory stepBuilderFactory;

  @Autowired
  private MongoTemplate mongoTemplate;

  @Bean
  public Job readEmployee() throws Exception {
    return jobBuilderFactory.get("readEmployee").flow(step1()).end().build();
  }

  @Bean
  public Step step1() throws Exception {
    return stepBuilderFactory.get("step1").<Employee, Employee>chunk(10).reader(reader())
        .writer(writer()).build();
  }


@Bean
  public MongoItemReader<Employee> reader() {
    MongoItemReader<Employee> reader = new MongoItemReader<>();
    reader.setTemplate(mongoTemplate);
    reader.setSort(new HashMap<String, Sort.Direction>() {{
      put("_id", Direction.DESC);
    }});
    reader.setTargetType(Employee.class);
    reader.setQuery("{}");
    return reader;
  }

  @Bean
  public StaxEventItemWriter<Employee> writer() {
    StaxEventItemWriter<Employee> writer = new StaxEventItemWriter<>();
    writer.setResource(new FileSystemResource("xml/employees.xml"));
    writer.setMarshaller(userUnmarshaller());
    writer.setRootTagName("employees");
    return writer;
  }


@Bean
  public XStreamMarshaller userUnmarshaller() {
    XStreamMarshaller unMarshaller = new XStreamMarshaller();
    Map<String, Class> aliases = new HashMap<String, Class>();
    aliases.put("employee", Employee.class);
    unMarshaller.setAliases(aliases);
    return unMarshaller;
  }
}

4) Fetching a Record From the MongoDB Employee Collection to an Object and Writing it to an XML File.

import java.math.BigDecimal;
import lombok.Data;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.annotation.Id;

@Data
@Document(collection = "employee")
public class Employee {
	@Id
	private int id;
	private String firstName;
	private String lastName;
	private String department;
	private BigDecimal salary;
}

5) MongoDB Data Insert

{
    "_id" : 1,
    "firstName" : "Peter",
    "lastName" : "Stephen",
    "depertment" : "Technology",
    "salary" : 320.4
}

6) Run the Application

package com.batch.mongo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
public class Application {

  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

7) Output

<?xml version="1.0" encoding="UTF-8"?>
<employees>
    <employee>
        <id>3</id>
        <firstName>Joe</firstName>
        <lastName>Spen</lastName>
        <salary>5320.4</salary>
    </employee>
    <employee>
        <id>2</id>
        <firstName>John</firstName>
        <lastName>Sender</lastName>
        <salary>2320.4</salary>
    </employee>
    <employee>
        <id>1</id>
        <firstName>Peter</firstName>
        <lastName>Stephen</lastName>
        <salary>320.4</salary>
    </employee>
</employees>

Hope this will help you to understand Spring Batch with MongoDB read operations. Happy learning!