spring batch
v5.2.0
Spring Batch es un marco de trabajo por lotes completo y liviano diseñado para permitir el desarrollo de aplicaciones por lotes sólidas, vitales para las operaciones diarias de los sistemas empresariales. Spring Batch se basa en la productividad, el enfoque de desarrollo basado en POJO y las capacidades generales de facilidad de uso que la gente ha llegado a conocer gracias a Spring Framework, al tiempo que facilita a los desarrolladores el acceso y el aprovechamiento de servicios empresariales más avanzados cuando sea necesario.
Si está buscando una herramienta de orquestación en tiempo de ejecución para sus aplicaciones Batch o necesita una consola de administración para ver las ejecuciones actuales e históricas, eche un vistazo a Spring Cloud Data Flow. Es una herramienta de orquestación para implementar y ejecutar microservicios basados en integración de datos, incluidas aplicaciones Spring Batch.
Este rápido tutorial le muestra cómo configurar un proyecto mínimo para ejecutar un trabajo por lotes simple con Spring Batch.
En su IDE favorito, cree un nuevo proyecto Java 17+ basado en Maven y agregue las siguientes dependencias:
< dependencies >
< dependency >
< groupId >org.springframework.batch</ groupId >
< artifactId >spring-batch-core</ artifactId >
< version >${LATEST_VERSION}</ version >
</ dependency >
< dependency >
< groupId >org.hsqldb</ groupId >
< artifactId >hsqldb</ artifactId >
< version >${LATEST_VERSION}</ version >
< scope >runtime</ scope >
</ dependency >
</ dependencies >Luego, cree una clase de configuración para definir la fuente de datos y el administrador de transacciones que utilizará el repositorio de trabajos:
import javax . sql . DataSource ;
import org . springframework . context . annotation . Bean ;
import org . springframework . context . annotation . Configuration ;
import org . springframework . jdbc . support . JdbcTransactionManager ;
import org . springframework . jdbc . datasource . embedded . EmbeddedDatabaseBuilder ;
@ Configuration
public class DataSourceConfiguration {
@ Bean
public DataSource dataSource () {
return new EmbeddedDatabaseBuilder ()
. addScript ( "/org/springframework/batch/core/schema-hsqldb.sql" )
. build ();
}
@ Bean
public JdbcTransactionManager transactionManager ( DataSource dataSource ) {
return new JdbcTransactionManager ( dataSource );
}
}En este tutorial, se crea e inicializa una base de datos HSQLDB integrada con las tablas de metadatos de Spring Batch.
Finalmente, cree una clase para definir el trabajo por lotes:
import org . springframework . batch . core . Job ;
import org . springframework . batch . core . JobParameters ;
import org . springframework . batch . core . Step ;
import org . springframework . batch . core . configuration . annotation . EnableBatchProcessing ;
import org . springframework . batch . core . job . builder . JobBuilder ;
import org . springframework . batch . core . launch . JobLauncher ;
import org . springframework . batch . core . repository . JobRepository ;
import org . springframework . batch . core . step . builder . StepBuilder ;
import org . springframework . batch . repeat . RepeatStatus ;
import org . springframework . context . ApplicationContext ;
import org . springframework . context . annotation . AnnotationConfigApplicationContext ;
import org . springframework . context . annotation . Bean ;
import org . springframework . context . annotation . Configuration ;
import org . springframework . context . annotation . Import ;
import org . springframework . jdbc . support . JdbcTransactionManager ;
@ Configuration
@ EnableBatchProcessing
@ Import ( DataSourceConfiguration . class )
public class HelloWorldJobConfiguration {
@ Bean
public Step step ( JobRepository jobRepository , JdbcTransactionManager transactionManager ) {
return new StepBuilder ( "step" , jobRepository ). tasklet (( contribution , chunkContext ) -> {
System . out . println ( "Hello world!" );
return RepeatStatus . FINISHED ;
}, transactionManager ). build ();
}
@ Bean
public Job job ( JobRepository jobRepository , Step step ) {
return new JobBuilder ( "job" , jobRepository ). start ( step ). build ();
}
public static void main ( String [] args ) throws Exception {
ApplicationContext context = new AnnotationConfigApplicationContext ( HelloWorldJobConfiguration . class );
JobLauncher jobLauncher = context . getBean ( JobLauncher . class );
Job job = context . getBean ( Job . class );
jobLauncher . run ( job , new JobParameters ());
}
}El trabajo de este tutorial se compone de un solo paso que imprime "¡Hola mundo!" a la salida estándar.
Ahora puede ejecutar el método main de la clase HelloWorldJobConfiguration para iniciar el trabajo. El resultado debería ser similar al siguiente:
INFO: Finished Spring Batch infrastructure beans configuration in 8 ms.
INFO: Starting embedded database: url='jdbc:hsqldb:mem:testdb', username='sa'
INFO: No database type set, using meta data indicating: HSQL
INFO: No Micrometer observation registry found, defaulting to ObservationRegistry.NOOP
INFO: No TaskExecutor has been set, defaulting to synchronous executor.
INFO: Job: [SimpleJob: [name=job]] launched with the following parameters: [{}]
INFO: Executing step: [step]
Hello world!
INFO: Step: [step] executed in 10ms
INFO: Job: [SimpleJob: [name=job]] completed with the following parameters: [{}] and the following status: [COMPLETED] in 25ms
Esta guía es un tutorial más realista que muestra un trabajo por lotes ETL típico que lee datos de un archivo plano, los transforma y los escribe en una base de datos relacional. Es un proyecto Spring Batch basado en Spring Boot. Encontrará la Guía de introducción aquí: Creación de un servicio por lotes.
Puede encontrar varias muestras para probar aquí: Muestras de lotes de primavera.
Si tiene una pregunta o una solicitud de soporte, abra una nueva discusión en Discusiones de GitHub o haga una pregunta en StackOverflow.
No cree problemas en el Rastreador de problemas si tiene preguntas o solicitudes de soporte. Nos gustaría mantener el rastreador de problemas exclusivamente para informes de errores y solicitudes de funciones.
Spring Batch utiliza GitHub Issues para registrar errores y solicitudes de funciones. Si desea plantear un problema, siga las recomendaciones a continuación:
Para errores no triviales, cree un caso de prueba o un proyecto que replique el problema y adjúntelo al problema, como se detalla en las Pautas para informar problemas.
Por favor consulte nuestra política de seguridad.
Clona el repositorio de git usando la URL en la página de inicio de Github:
$ git clone [email protected]:spring-projects/spring-batch.git
$ cd spring-batch
Maven es la herramienta de compilación utilizada para Spring Batch. Puede construir el proyecto con el siguiente comando:
$ ./mvnw package
Si desea realizar una compilación completa con todas las pruebas de integración, ejecute:
$ ./mvnw verify
Tenga en cuenta que algunas pruebas de integración se basan en Docker, así que asegúrese de tener Docker en funcionamiento antes de ejecutar una compilación completa.
Para generar la documentación de referencia, ejecute los siguientes comandos:
$ cd spring-batch-docs
$ ../mvnw antora:antora
La documentación de referencia se puede encontrar en spring-batch-docs/target/anotra/site .
Si desea construir el proyecto en un contenedor Docker, puede proceder de la siguiente manera:
$> docker run -it --mount type=bind,source="$(pwd)",target=/spring-batch maven:3-openjdk-17 bash
#> cd spring-batch
#> ./mvnw package
Esto montará el código fuente que clonaste previamente en el host dentro del contenedor. Si desea trabajar en una copia del código fuente dentro del contenedor (sin efectos secundarios en el host), puede proceder de la siguiente manera:
$> docker run -it maven:3-openjdk-17 bash
#> git clone https://github.com/spring-projects/spring-batch.git
#> cd spring-batch
#> ./mvnw package
¡Agradecemos contribuciones de cualquier tipo! A continuación se muestran algunas formas de contribuir al proyecto:
Antes de aceptar solicitudes de extracción, necesitaremos que firme el acuerdo del colaborador. Firmar el acuerdo de colaborador no otorga a nadie derechos de compromiso sobre el repositorio principal, pero sí significa que podemos aceptar sus contribuciones y, si lo hacemos, obtendrá un crédito de autor. A los contribuyentes activos se les puede pedir que se unan al equipo central y se les puede dar la posibilidad de fusionar solicitudes de extracción.
Consulte nuestro código de conducta.
Spring Batch es un software de código abierto publicado bajo la licencia Apache 2.0.
