| |
Procesamiento con Spring Batch 2.0
Spring Batch es el framework para procesamiento de lotes de Spring Framework. Este framework apunta a crear una plataforma que brinde servicios comunes para los programas batch.
Este curso es una guía para ir aprendiendo las diferentes características de Spring Batch 2.0, partiendo de ejemplos concretos.
Toda esta guía se basa en torno a un proyecto con ejemplos de Spring Batch, el cual contiene distintos casos de uso. Iremos explicando cada caso por separado.
Durante el curso veremos:
- Conceptos básicos de Spring Batch.
- Un primer Hola Mundo con Tasklets.
- Lectura de archivos.
- Escritura en archivos.
- Lectura de base de datos.
- Transformación de datos.
Dudas y consultasRealizá todas las consultas que necesites en el foro "Java" de Dos Ideas. ¡Siempre va a haber alguien para darte una mano! | | | | 1 |
Configuración del proyecto
Antes de comenzar descargaremos el proyecto de ejemplo (el cual contiene además todas las librerias necesarias) y configuraremos la base de datos que usaremos durante el curso.
Sobre el proyecto de ejemplo
El proyecto de ejemplo para descargar está dividido en paquetes independientes llamado demo0, demo1, demo2, demo3, etc. Cada paquete es independiente y contiene todas las clases y archivos de configuración para funcionar.
A su vez, cada paquete demo tiene asociado un test JUnit que lo ejecuta. Los fuentes se encuentran en el directorio src y los tests en el directorio test.
Cada demo es un ejemplo autocontenido que utiliza distintas funciones de Spring Batch. En los siguientes capítulos vamos a ir avanzando por cada una de estos paquete demo, explicando en detalle los conceptos nuevos y su funcionamiento.
| 
| | | 2 |
Demo #0: Hola Mundo
Spring Batch es un framework para el procesamiento por lotes (o ejecuciones "batch"). Spring Batch provee:
- un marco general para la creación de programas batch.
- almacenamiento de la información de ejecuciones.
- utilización de conceptos conocidos para el procesamiento batch (Job, Step, JobInstance, JobExecution).
- utilidades para realizar acciones comunes en procesamietos batch (lectura/escritura de archivos, acceso a base de datos, etc).
Los conceptos principales de Spring Batch son:
- Job: representa un trabajo a ejecutar. Es el trabajo batch. Está compuesto de uno o más Step (pasos), los cuales se ejecutan secuencialmente.
- Step: es un paso dentro de un Job. Representa una acción dentro de todo el Job. Un step puede leer un archivo, escribir en una base de datos, realizar una transformación, etc.
- JobRepository: es un repositorio donde se almacenan las ejecuciones de los Job. Usualmente es una base de datos con tablas propias de Spring Batch.
En el recurso siguiente vas a encontrar más información sobre estos conceptos básicos, y una explicación de la demo0 del proyecto.
| 
| | | 3 |
Demo #1: lectura de archivos
En el paquete "demo1" veremos como poder leer un archivo de texto separado por comas (archivo "planetas.csv"), y transformaremos cada línea a un objeto que la represente. Luego imprimiremos ese objeto por consola.
Las clases
Para esto deberemos desarrollar dos clases:
- Planeta, que representa cada una de las líneas del archivo.
- ConsolaItemWriter, el cual imprime por consola un objeto Planeta.
La configuración En el archivo de configuración spring-batch-demo.xml se ecuentra toda la configuración necesaria para Spring Batch. Los beans importantes declarados en este archivo:
- jobRepository, que será el repositorio para las ejecuciones de nuestra tarea. Este bean registrará en la base de datos información sobre la corrida.
- trabajoBatch, que es el Job (Trabajo) en cuestión. Hace referencia a un único Step (Paso), llamado imprimirPorConsola. El bean imprimirPorConsola contiene un lector de items (itemReader) y un procesador de items (itemWriter).
- planetaItemReader, que será el encargado de leer el archivo de texto separado por comas, y transformar cada línea a un objeto Planeta. El bean planetaFieldSetMapper indica que se usará la clase Planeta para transformar cada línea del archivo.
- consolaItemWriter, que será el encargado de procesar cada una de las líneas convertidas a Planeta por planetaItemReader.
El test ubicado en el paquete demo1 ejecuta esta tarea. | 
| | | 4 |
Demo #2: transformación de archivosEn el paquete demo2 veremos cómo leer un archivo de texto y realizar una transformación sobre cada una de las líneas, para generar un nuevo archivo resultante.
Las clases
Para esta solución se programan dos clases:
- Planeta, que representa cada una de las líneas del archivo.
- PlanetaFieldSetCreator, que se encargará de transformar un objeto Planeta en una linea nueva para el archivo resultante.
La configuración En el archivo de configuración spring-batch-demo.xml del paquete se ecuentra toda la configuración necesaria para Spring Batch. Los beans importantes declarados en este archivo:
- convertirArchivo, el cual es un paso que tiene un lector de items (itemReader) y un procesador de items (itemWriter).
- planetaItemReader, que es un ItemReader que se encarga de leer el archivo de origen y convertir cada línea en un objeto Planeta.
- archivoPlanoItemWriter, que es un ItemWriter que se encargará de tomar un Planeta y convertirlo a una línea de este archivo. Para hacer esto utiliza un fieldSetCreator creado por nosotros: la clase PlanetaFieldSetCreator.
| 
| | | 5 |
Demo #3: acceso a una base de datosEn la demo del paquete demo3 encontraremos cómo acceder a una base de datos utilizando un query SQL, convertir cada fila del resultado en un objeto y finalmente imprimirlo por consola.
Las clases
Para esto deberemos desarrollar dos clases:
- Planeta, que representa cada una de las filas resultantes del query.
- ConsolaItemWriter, el cual imprime por consola un objeto Planeta.
La configuraciónEn el archivo de configuración spring-batch-demo.xml se ecuentra toda la configuración necesaria para Spring Batch. Los beans importantes declarados en este archivo:
- trabajoBatch, que es el Job (Trabajo) en cuestión. Hace referencia a un único Step (Paso), llamado imprimirPorConsola. El bean imprimirPorConsola contiene un lector de items (itemReader) y un procesador de items (itemWriter).
- planetaItemReader, que será el encargado de ejecutar un query y transformar cada una de las filas en un objeto Planeta.
- consolaItemWriter, que será el encargado de procesar e imprimir por consola cada uno de los Planeta creados por planetaItemWriter.
| 
| | | 6 | Demo #4: exportando una tabla hacia archivoEn la demo del paquete demo3 encontraremos cómo acceder a una base de datos utilizando un query SQL, convertir cada fila del resultado en un objeto y finalmente imprimirlo por consola.
Las clases
Para esto deberemos desarrollar dos clases:
- Planeta, que representa cada una de las filas resultantes del query.
- PlanetaFieldSetCreator, que se encargará de transformar un objeto Planeta en una línea nueva para el archivo resultante
La configuraciónEn el archivo de configuración spring-batch-demo.xml se ecuentra toda la configuración necesaria para Spring Batch. Los beans importantes declarados en este archivo:
- trabajoBatch, que es el Job (Trabajo) en cuestión. Hace referencia a un único Step (Paso), el cual contiene un bean con un lector de items (itemReader) y un procesador de items (itemWriter).
- planetaItemReader, que será el encargado de ejecutar un query y transformar cada una de las filas en un objeto Planeta.
- archivoPlanoItemWriter, que será el encargado de procesar cada uno de los Planeta leídos por planetaItemReader y generar una línea en el archivo de texto resultante.
| 
| | | 7 |
Demo #5: integración con Compass y Lucene
Esta demo consta de dos steps, el primero “guardarIndice” donde se obtienen los registros de la tabla PLANETA, se convierte cada uno en un objeto planeta y por ultimo se crea el índice lucene que contendrá la información de los objetos. El segundo “leerIndice” realiza una búsqueda en el índice e imprime el resultado por pantalla.
Las clases
Las clases destacadas para esta demo son:
- Planeta, que representa cada una de las filas resultantes del Query y contiene las anotaciones de compass que nos permiten persistir y consultar la misma en los índices lucene.
- CompassItemWriter, que contiene el método que persiste cada objeto planeta en el índice lucene.
- IndiceItemReader, que contiene el método que realiza las consultas en los índices aplicando paginación.
La configuración
En el archivo de configuración spring-batch-demo.xml se encuentra toda la configuración necesaria para Spring Batch. Beans importantes declarados en este archivo:
- planetaItemReader, donde definimos el Query y el mapeo de la clase Planeta.
- Compass, es la factory de compass que nos permitirá trabajar con los índices.
- planetaItemWriter y indiceItemReader, ambos están creados con clases que extienden de CompassDaoSupport y es por esto que se les injecta la factory de compass.
| 
| | | 8 |
Demo #6: Manejo de excepciones
La demo del paquete demo6 amplía la demo1 (lectura de archivo e impresión por consola), considerando que algunas líneas del archivo de entrada podrían ser incorrectas desde el punto de vista del formato y ese no debería ser motivo para finalizar el job, sino que se debería continuar con la siguiente línea del archivo. Es importante tener en cuenta que cualquier exception lanzada durante la ejecución del job por defecto corta la ejecución del mismo.
Las clases
La única clase destacada para esta demo es:
- PlanetaItemListener. Por extender de la clase de spring batch ItemListenerSupport, en esta clase nos vemos obligados a implementar métodos abstractos para las acciones a seguir en caso de error en el reader, en el procesor y en el writer. Este listener es entonces un handler de los errores que sucedan durante la ejecución del job. En la demo sólo se imprime un warning por consola con las líneas del archivo que no pudieron ser parseadas correctamente.
La configuración
En el archivo de configuración spring-batch-demo.xml se ecuentra toda la configuración necesaria para Spring Batch. Beans importantes declarados en este archivo:
- imprimirPorConsola, notemos que en esta demo para el step no estamos utilizando la implementación más básica de spring batch (SimpleStepFactoryBean) como en las demos anteriores. En su lugar estamos utilizando una implementación más compleja: FaultTolerantStepFactoryBean, que provee funcionalidad muy interesante para el manejo de fallos. Algunos de los atributos que pueden setearse son:
- noRollbackExceptionClasses, indica la lista de excepciones “permitidas”: aquellas para las cuales no se corta la ejecución del job, sino que se continúa con el siguiente item sin realizar un rollback del chunk que se está procesando.
- skipLimit, cantidad máxima de items que podrán saltearse debido a las excepciones “permitidas”.
- listeners, lista de listeners asociados al step. En el ejemplo se ha desarrollado un listener como handler de errores (PlanetaItemListener). Spring batch provee otros tipos de listeners que podemos implementar, como ItemReadListener, que nos lleva a definir acciones a realizar antes del reader, después del reader y en caso de fallo en el reader. Para más información consultar la API de Spring Batch.
| 
| | | 9 |
Demo #7: ejecución en multihilos
La demo del paquete demo5 es básicamente la misma que la del paquete demo1 (lectura de archivo e impresión por consola), con el mismo código Java, pero con la incorporación de una ejecución concurrente por configuración. La cantidad de hilos que se ejecutan se configura en el Step (paso).
Las clases
Para esto deberemos desarrollar dos clases:
- Planeta, que representa cada una de las filas resultantes del query.
- PlanetaFieldSetCreator, que se encargará de transformar un objeto Planeta en una línea nueva para el archivo resultante
La configuraciónEn el archivo de configuración spring-batch-demo.xml se ecuentra toda la configuración necesaria para Spring Batch. Los beans importantes declarados en este archivo:
- trabajoBatchMultithread, que es el Job (Trabajo) en cuestión. Hace referencia a un único Step (Paso), el cual contiene un bean con un lector de items (itemReader) y un procesador de items (itemWriter). Además, e importante, este Step tiene configurado un taskExecutor, en el cual se indica que este step será ejecutado por 3 hilos concurrentes.
- planetaItemReader, que será el encargado de ejecutar un query y transformar cada una de las filas en un objeto Planeta.
- archivoPlanoItemWriter, que será el encargado de procesar cada uno de los Planeta leídos por planetaItemReader y generar una línea en el archivo de texto resultante.
| 
| | | 10 | Demo #8: procesamiento de datos
La demo del paquete demo8 contiene un ejemplo para realizar procesamiento de datos. A veces es necesario manipular los datos luego de ser leídos y antes de escribirlos en el destino. Para esto se utiliza la interfaz ItemProcessor, que recibe un objeto leído y devuelve un objeto procesado. El ItemProcessor se agrega como atributo de un Step (paso).
Las clases
Para esto deberemos desarrollar dos clases:
- Planeta, que representa cada una de las filas resultantes del query.
- PlanetaItemReader, que se encargará leer planetas de la tabla en una base de datos, devolviendo un objeto Planeta por cada fila.
- PlanetaProcessor, que recibe un Planeta (leído por el PlanetaItemReader) y lo procesa, pasándo a mayúsculas sus atributos.
- PlanetaItemWriter, que recibe un Planeta procesado (por el PlanetaProcessor) y lo muestra por consola.
La configuraciónEn el archivo de configuración spring-batch-demo.xml se ecuentra toda la configuración necesaria para Spring Batch. Los beans importantes declarados en este archivo:
- pasarAMayusculas, es el PlanetaProcessor que se encarga de recibir un Planeta, procesos sus atributos (pasarlos a mayúsculas) y devolver este Planeta procesado.
- imprimirPorConsola, que es el Step que se encarga de leer los planetas (itemReader), procesarlos (itemProcessor) y escribirlos por consola (itemWriter).
| 
| | | 11 | Demo #9: leer archivos con cabecera y compartir datos entre etapas de un Step
La demo del paquete demo9 contiene un ejemplo para leer archivos planos en los que se recibe una primera línea “cabecera” con datos generales del archivo y/o comunes a todos los registros, y las siguientes líneas son los registros que deben ser procesados individualmente.
Además veremos cómo se comparte información entre el reader y el writer, utilizando el contexto del step.
Las clases
Para esto deberemos desarrollar dos clases:
- CabeceraHandler, maneja el registro cabecera, leyéndolo y creando con sus datos el objeto de tipo CabeceraArchivo que se compartirá entre el reader y el writer. Para compartirlo lo guarda en el contexto del step. Este contexto lo setea spring-batch al encontrar en un método la anotación @BeforeStep. Además es necesario que el bean esté declarado como listener en el step.
- ConsolaItemWriter, cuyo bean también está declarado como listener del step, utiliza en esta ocacion los datos de la cabecera para imprimir por consola.
La configuración
En el archivo de configuración spring-batch-demo.xml se ecuentra toda la configuración necesaria para Spring Batch. Los beans importantes declarados en este archivo:
- cabeceraHandler, es el CabeceraHandler que se encarga de manipular la cabecera y dejarla disponible para el writer.
- cabeceraArchivo, es el nuevo bean en el que se mapeará el registro cabecera.
| 
| |
| |