Spring Batch: Un simple hola, mundo!!!

Spring Batch es una alternativa para el procesamiento por lotes y nos provee lo necesario para crear aplicaciones robustas.

Existen diversas formas para lanzar un proceso batch:

1. Desde la línea de comandos.
2. Programando un Job.
3. Desde un programa Java.
4. Desde una aplicación Web.

Para crear una aplicación Spring Batch es necesario tener este artifact:

spring-boot-starter-batch

Usando Maven:

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-batch -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-batch</artifactId>
    <version>2.1.8.RELEASE</version>
</dependency>

Usando Gradle:

compile group: 'org.springframework.boot', name: 'spring-boot-starter-batch', version: '2.1.8.RELEASE'

Nosotros emplearemos Maven. Nuestro pom.xml se verá de este modo:

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.1.8.RELEASE</version>
  <relativePath/> <!-- lookup parent from repository -->
 </parent>
 <groupId>com.inforhomex.batches</groupId>
 <artifactId>etl-spring-batch</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <name>etl-spring-batch</name>
 <description>Aplicación para batch</description>

 <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.slf4j</groupId>
   <artifactId>slf4j-log4j12</artifactId>
   <version>1.7.26</version>
   <scope>test</scope>
  </dependency>

  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-devtools</artifactId>
   <scope>runtime</scope>
   <optional>true</optional>
  </dependency>
  
 </dependencies>

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

</project>

Creamos una archivo de propiedades para especificar los valores necesarios para la aplicación.

application.properties

#BANNER
banner.charset= UTF-8
banner.location= banner.txt
spring.banner.image.location=imagen.png

#PROPIEDADES
programador.app=Curso Spring Batch

#BATCH
spring.batch.job.enabled=false
spring.batch.initialize-schema=always
input=file:AQUI PODRIAMOS PONER UN ARCHIVO CSV o TXT

Configuración Spring Batch

1. Por XML
2. Por configuración Java.

 Nosotros emplearemos XML para configurar los beans.

Creamos el archivo XML para especificar los beans (clases) necesarias para trabajar con Spring Batch.

context.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/batch"
xmlns:beans="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-3.0.xsd">

<!-- Donde se configura el jobRepository, el jobLauncher, etc.-->
<beans:bean id="jobRepository" class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean">
   <beans:property name="transactionManager" ref="transactionManager"/>
</beans:bean>

<beans:bean id="jobLauncher" class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
   <beans:property name="jobRepository" ref="jobRepository" />
</beans:bean>

<beans:bean id="transactionManager" class="org.springframework.batch.support.transaction.ResourcelessTransactionManager"/>
</beans:beans>

Creamos una clase llamada MyBatch.java

package com.inforhomex.batches.batch;

import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class MyBatch implements Tasklet {

    private static final Logger LOG = LoggerFactory.getLogger(MyBatch.class); 
    
    public RepeatStatus execute(StepContribution arg0,ChunkContext arg1) throws Exception {
        LOG.info("#Execute: "); 
        LOG.info("*** com.inforhomex.batches.batch.MyBatch ***");

        LOG.info("*** HOLA, MUNDO !!! ***");
        return RepeatStatus.FINISHED;
    }
}

Ahora debemos crear un archivo XML para especificar y definir el bean (MyBatch).

my-batch.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns ="http://www.springframework.org/schema/batch" 
xmlns:beans="http://www.springframework.org/schema/beans" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-3.0.xsd">
<beans:import resource="context.xml" />
   <beans:bean id="myBatch" class="com.inforhomex.batches.batch.MyBatch"/>
   <step id="myBatchStepOne">
      <tasklet ref="myBatch"/>
   </step>
   <job id="myBatchJob">
      <step id="stepOne" parent="myBatchStepOne"/>
    </job>
</beans:beans>

Finalmente desde la clase principal de nuestra aplicación ejecutamos el Batch.

MainApplication.java

package com.inforhomex.batches;

/**
*@author alquimista de código
*@date 15/09/2019
*/

import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import com.inforhomex.batches.batch.MyBatch;



@SpringBootApplication
public class MainApplication {

 private static final Logger LOG = LoggerFactory.getLogger(MyBatch.class); 
  
 public static void main(String[] args) {

  //SpringApplication.run(MainApplication.class, args);
  
  String[] config = {"my-batch.xml"};
  ApplicationContext context = new ClassPathXmlApplicationContext(config);
  JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
  Job job = (Job) context.getBean("myBatchJob");
  LOG.info("#Lanzando el Job: myBatchJob");
  try {
   JobExecution execution = jobLauncher.run(job, new JobParameters());
   LOG.info("#Exit Status (estado de la salida) : " + execution.getStatus());
   if(execution.isRunning()) {
    LOG.info("#El Job esta corriendo...");
   }
   LOG.info("#Version: "+execution.getVersion());
  }catch(Exception e) {
   LOG.error("#Ha ocurrido una Exception!!");
   e.printStackTrace();
  }finally {
   if(context != null){
    context = null;
   }
  }
  LOG.info("#Hecho!!");
 }

}

Nota: El código se tomó del libro Spring Batch Essentials.


Enlaces:
https://www.petrikainulainen.net/programming/spring-framework/spring-batch-tutorial-introduction/