Spring Batch

pom.xml

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.techprimers</groupId>
<artifactId>spring-batch-example-1</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>

<name>spring-batch-example-1</name>
<description>Demo project for Spring Boot</description>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.14.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>

<properties>
<project.build.sourceEncoding>UTF-
8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-
8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-batch</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-
jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
 <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.batch</groupId>
<artifactId>spring-batch-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>

<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-
plugin</artifactId>
</plugin>
</plugins>
</build>

</project>

application.properties

server.port=8081

spring.batch.job.enabled=false

input=file:C:\\Users\\DELL\\Documents\\programacion\\testRepositories\\spring-batch-example-
1\\src\\main\\resources\\users.csv

#BANNER

banner.charset= UTF-8

banner.location= banner.txt
user.csv

id,name,dept,salary

1,Joaquin,001,12000

2,Samuel,002,13000

3,Rachel,003,10000

4,Ana,004,11000

User.java
package com.techprimers.springbatchexample1.model;

import javax.persistence.Entity;
import javax.persistence.Id;
import java.util.Date;

@Entity
public class User {

@Id
private Integer id;
private String name;
private String dept;
private Integer salary;
private Date time;

public User(Integer id, String name, String dept, Integer salary,

Date time) {
this.id = id;
this.name = name;
this.dept = dept;
this.salary = salary;
this.time = time;
}

public User() {
}

public Integer getId() {

return id;
}

public void setId(Integer id) {

this.id = id;
}
 public String getName() {
return name;
}

public void setName(String name) {

this.name = name;
}

public String getDept() {

return dept;
}

public void setDept(String dept) {

this.dept = dept;
}

public Integer getSalary() {

return salary;
}

public void setSalary(Integer salary) {

this.salary = salary;
}

@Override
public String toString() {
final StringBuffer sb = new StringBuffer("User{");
sb.append("id=").append(id);
sb.append(", name='").append(name).append('\'');
sb.append(", dept='").append(dept).append('\'');
sb.append(", salary=").append(salary);
sb.append('}');
return sb.toString();
}

public Date getTime() {

return time;
}

public void setTime(Date time) {

this.time = time;
}
}

UserRepository.java

package com.techprimers.springbatchexample1.repository;
import com.techprimers.springbatchexample1.model.User;

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Integer> {

LoadController.java

package com.techprimers.springbatchexample1.controller;

import org.springframework.batch.core.*;

import org.springframework.batch.core.launch.JobLauncher;

import org.springframework.batch.core.repository.JobExecutionAlreadyRunningException;

import org.springframework.batch.core.repository.JobInstanceAlreadyCompleteException;

import org.springframework.batch.core.repository.JobRestartException;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import java.util.HashMap;

import java.util.Map;

@RestController

@RequestMapping("/load")

public class LoadController {

@Autowired

JobLauncher jobLauncher;
 @Autowired

Job job;

@GetMapping

public BatchStatus load() throws JobParametersInvalidException,

JobExecutionAlreadyRunningException, JobRestartException,
JobInstanceAlreadyCompleteException {

Map<String, JobParameter> maps = new HashMap<>();

maps.put("time", new JobParameter(System.currentTimeMillis()));

JobParameters parameters = new JobParameters(maps);

JobExecution jobExecution = jobLauncher.run(job, parameters);

System.out.println("JobExecution: " + jobExecution.getStatus());

System.out.println("El batch esta corriendo...");

while (jobExecution.isRunning()) {

System.out.println("...");

return jobExecution.getStatus();

SpringBatchConfig.java

package com.techprimers.springbatchexample1.config;
import com.techprimers.springbatchexample1.model.User;

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.core.launch.support.RunIdIncrementer;

import org.springframework.batch.item.ItemProcessor;

import org.springframework.batch.item.ItemReader;

import org.springframework.batch.item.ItemWriter;

import org.springframework.batch.item.file.FlatFileItemReader;

import org.springframework.batch.item.file.LineMapper;

import org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper;

import org.springframework.batch.item.file.mapping.DefaultLineMapper;

import org.springframework.batch.item.file.transform.DelimitedLineTokenizer;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.core.io.Resource;

@Configuration

@EnableBatchProcessing

public class SpringBatchConfig {

@Bean

public Job job(JobBuilderFactory jobBuilderFactory,

StepBuilderFactory stepBuilderFactory,

ItemReader<User> itemReader,

ItemProcessor<User, User> itemProcessor,

 ItemWriter<User> itemWriter

){

Step step = stepBuilderFactory.get("ETL-file-load")

.<User, User>chunk(100)

.reader(itemReader)

.processor(itemProcessor)

.writer(itemWriter)

.build();

return jobBuilderFactory.get("ETL-Load")

.incrementer(new RunIdIncrementer())

.start(step)

.build();

@Bean

public FlatFileItemReader<User> itemReader(@Value("${input}") Resource resource) {

FlatFileItemReader<User> flatFileItemReader = new FlatFileItemReader<>();

flatFileItemReader.setResource(resource);

flatFileItemReader.setName("CSV-Reader");

flatFileItemReader.setLinesToSkip(1);

flatFileItemReader.setLineMapper(lineMapper());

return flatFileItemReader;

@Bean
 public LineMapper<User> lineMapper() {

DefaultLineMapper<User> defaultLineMapper = new DefaultLineMapper<>();

DelimitedLineTokenizer lineTokenizer = new DelimitedLineTokenizer();

lineTokenizer.setDelimiter(",");

lineTokenizer.setStrict(false);

lineTokenizer.setNames(new String[]{"id", "name", "dept", "salary"});

BeanWrapperFieldSetMapper<User> fieldSetMapper = new

BeanWrapperFieldSetMapper<>();

fieldSetMapper.setTargetType(User.class);

defaultLineMapper.setLineTokenizer(lineTokenizer);

defaultLineMapper.setFieldSetMapper(fieldSetMapper);

return defaultLineMapper;

Processor.java

package com.techprimers.springbatchexample1.batch;

import com.techprimers.springbatchexample1.model.User;

import org.springframework.batch.item.ItemProcessor;

import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;

import java.util.Map;

@Component

public class Processor implements ItemProcessor<User, User> {

private static final Map<String, String> DEPT_NAMES =

new HashMap<>();

public Processor() {

DEPT_NAMES.put("001", "Technology");

DEPT_NAMES.put("002", "Operations");

DEPT_NAMES.put("003", "Accounts");

@Override

public User process(User user) throws Exception {

String deptCode = user.getDept();

String dept = DEPT_NAMES.get(deptCode);

user.setDept(dept);

user.setTime(new Date());

System.out.println(String.format("Converted from [%s] to [%s]", deptCode, dept));

return user;

DBWriter.java

package com.techprimers.springbatchexample1.batch;
import com.techprimers.springbatchexample1.model.User;

import com.techprimers.springbatchexample1.repository.UserRepository;

import org.springframework.batch.item.ItemWriter;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import java.util.List;

@Component

public class DBWriter implements ItemWriter<User> {

@Autowired

private UserRepository userRepository;

@Override

public void write(List<? extends User> users) throws Exception {

System.out.println("Data Saved for Users: " + users);

userRepository.save(users);