Manual Spring Batch

Manual: criando Jobs com Spring Batch

O objetivo deste manual é descrever os passos para a criação de Jobs com Spring Batch. As ferramentas utilizadas serão:

• VSCode
• JDK
• Maven
• Spring
• PostgreSQL

Criando uma máquina virtual

1. Instale o Oracle VirtualBox

2. Faça o download do Lubuntu

3. Crie uma nova máquina virtual e siga os passos para instalação do Lubuntu

4. No terminal, execute os seguintes comandos:

$ sudo apt-get update
$ sudo apt-get upgrade
$ sudo apt-get install gcc
$ sudo apt-get install make

5. Na máquina virtual, acesse o menu Dispositivos -> Inserir imagem do CD dos adicionais para convidado...

6. No terminal, navegue até o diretório montado e digite

$ sudo ./VBoxLinuxAdditions.run

7. Reinicie a VM

Configurando o ambiente de desenvolvimento

1. Crie um diretório e navegue para dentro dele

$ mkdir Tools
$ cd Tools

2. Dentro do diretório, crie o script configure.sh com o seguinte conteúdo

# Instalação e configuração do JDK
sudo apt-get install -y python-software-properties
sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install -y oracle-java8-installer

# Instalação do Maven
apt-cache search maven
sudo apt-get install maven

# Instalação e configuração do PostgreSQL
sudo apt-get install -q -y postgresql pgadmin3
sudo -u postgres psql -c "ALTER USER postgres WITH PASSWORD 'postgres';"
POSTGRESQL_DIR="$(find /etc/postgresql -type d | grep main)"
POSTGRESQL_CONF=$POSTGRESQL_DIR"/postgresql.conf"
sudo chmod 777 $POSTGRESQL_CONF
sudo sed -i "59s/.*/listen_addresses = '*'/" $POSTGRESQL_CONF
PG_HBA_CONF=$POSTGRESQL_DIR"/pg_hba.conf"
sudo chmod 777 $PG_HBA_CONF
sudo sed -i "85s/.*/local all postgres trust/" $PG_HBA_CONF
sudo echo "host all all all password" >> $PG_HBA_CONF
sudo /etc/init.d/postgresql restart

# Instalação do editor VSCode
wget -O VSCode.tar.gz https://go.microsoft.com/fwlink/?LinkID=620884; 
tar -xvzf VSCode.tar.gz; 
rm VSCode.tar.gz;
sudo ln -s $(pwd)/VSCode-linux-x64/code /usr/local/bin/code;
sudo apt-get install libgconf-2-4

cd ..
sudo chmod -R 777 Tools

3. Execute o script

$ sudo sh configure.sh | tee -a logfile

Criando a primeira aplicação

1. Dentro da pasta do projeto, crie a seguinte estrutura de diretório:

└── src
    └── main
        └── java
            └── hello

$ mkdir -p src/main/java/hello

2. Na raiz do projeto, crie o arquivo pom.xml com o seguinte conteúdo:

<?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>org.springframework</groupId>
    <artifactId>gs-batch-processing</artifactId>
    <version>0.1.0</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
    </parent>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-batch</artifactId>
        </dependency>
        <dependency>
            <groupId>org.hsqldb</groupId>
            <artifactId>hsqldb</artifactId>
        </dependency>
    </dependencies>


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

</project>

O arquivo pom.xml contém as dependências do projeto que serão baixadas e configuradas pelo Maven.

3. Configuração da persistência de dados

Inicialmente, a persistência de dados será realizada utilizando o HSQLDB (HyperSQL DataBase). Por padrão, o Spring utiliza o HSQLDB armazenando os dados em memória.

• Crie o arquivo src/main/resources/sample-data.csv com o seguinte conteúdo:

Jill,Doe
Joe,Doe
Justin,Doe
Jane,Doe
John,Doe

Este arquivo contém os registros de nome e sobrenome que serão carregados em uma tabela de banco de dados de pessoas.

• Crie o arquivo src/main/resources/schema-all.sql com o seguinte conteúdo:

DROP TABLE people IF EXISTS;

CREATE TABLE people  (
    person_id BIGINT IDENTITY NOT NULL PRIMARY KEY,
    first_name VARCHAR(20),
    last_name VARCHAR(20)
);

Os dados do arquivo anterior serão carregados nessa tabela.

Em sua configuração padrão, o Spring executa schema-@@platforma@@.sql para gerar o esquema. Ao utilizar -all, informamos ao Spring que o esquema poderá ser gerado em qualquer plataforma. Neste momento, será utilizado o esquema do HSQLDB.

3. Criação das classes do projeto

• Crie a classe src/main/java/hello/Person.java para encapsular os dados de pessoas vindos do banco.

package hello;

public class Person {

    private String lastName;
    private String firstName;

    public Person() {
    }

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    @Override
    public String toString() {
        return "firstName: " + firstName + ", lastName: " + lastName;
    }

}

• Crie um ItemProcessor para o job em src/main/java/hello/PersonItemProcessor.java com o seguinte conteúdo:

package hello;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.batch.item.ItemProcessor;

public class PersonItemProcessor implements ItemProcessor<Person, Person> {

    private static final Logger log = LoggerFactory.getLogger(PersonItemProcessor.class);

    @Override
    public Person process(final Person person) throws Exception {
        final String firstName = person.getFirstName().toUpperCase();
        final String lastName = person.getLastName().toUpperCase();

        final Person transformedPerson = new Person(firstName, lastName);

        log.info("Converting (" + person + ") into (" + transformedPerson + ")");

        return transformedPerson;
    }

}

O Processor é um componente que realiza a lógica de negócio para um Step. Por sua vez, o Step é um objeto que representa um passo individual de um Job. Em Xml, a estrutura ficaria da seguinte forma:

<job id="peopleJob">
  <step id="step1">
    <tasklet>
      <chunk processor="personItemProcessor"... />
    </tasklet>
 </step>
</job>

A figura a seguir ilustra a os relacionamentos entre Job, Step e Processor:

A lógica de negócio da classe PersonItemProcessor consiste em transformar o objeto em outro com os dados em caixa alta.

Referências

• Spring Documentation
• Maven Proxy Settings