Per esplorare i concetti di base di Spring Batch creeremo un semplice job di batch per leggere, trasformare e scrivere dati. Useremo anche esempi di codice dettagliati per illustrare ogni passo del processo.
Spring Batch è un framework open source per l'elaborazione di dati in batch. È particolarmente utile quando si deve gestire un grande volume di dati in modo affidabile. Spring Batch offre funzionalità per la lettura, la trasformazione e la scrittura dei dati, la gestione delle transazioni, il monitoraggio e la gestione delle eccezioni.
Vediamo alcuni punti fondamentali da conoscere:
Job di batch: Un job di batch in Spring Batch è un processo che viene eseguito in modo autonomo. Per crearlo, definisci un'istanza di Job nel tuo codice e assegna ad essa uno o più step.
Step di un job e il concetto di chunk processing: Un job è suddiviso in uno o più step, ciascuno dei quali è responsabile di una parte specifica del processo di elaborazione. Un concetto chiave è il "chunk processing", che prevede la lettura di un certo numero di record, la loro trasformazione e la scrittura in un'altra destinazione. Puoi configurare il numero di record da elaborare in un singolo chunk.
Lettura e scrittura di dati: Spring Batch offre supporto per la lettura e la scrittura di dati da diverse fonti e destinazioni, tra cui database, file CSV, XML, JSON e altro ancora. Puoi personalizzare il comportamento di lettura e scrittura attraverso configurazioni e classi specifiche.
Gestione delle transazioni: Spring Batch gestisce automaticamente le transazioni per garantire che i tuoi job siano coerenti e affidabili. Puoi configurare il livello di isolamento delle transazioni e definire le condizioni di commit o rollback.
Esecuzione e monitoraggio dei job: Puoi eseguire i tuoi job di batch manualmente o pianificare l'esecuzione in base a una programmazione specifica. Spring Batch offre anche strumenti per il monitoraggio e la gestione dei job in esecuzione, consentendo di identificare e risolvere eventuali problemi.
Prima di tutto, crea un nuovo progetto Spring Boot utilizzando il Spring Initializer o il tuo IDE preferito. Assicurati di includere la dipendenza "Spring Batch" nel tuo progetto.
Ecco un file pom.xml con la dipendenza per Spring Batch:
<?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>3.1.4</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>it.saverioriotto.tutorial</groupId>
<artifactId>batch</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-batch-tutorial</name>
<description>Tutorial introduttivo di Spring Batch</description>
<properties>
<java.version>17</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-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.batch</groupId>
<artifactId>spring-batch-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>2.1.214</version>
<scope>runtime</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>Assicurati di sostituire e con i valori appropriati per il tuo progetto. Questo pom.xml include la dipendenza di base per Spring Boot e la dipendenza specifica per Spring Batch (spring-boot-starter-batch). Puoi aggiungere ulteriori dipendenze, se necessario, nel blocco.
Per il nostro tutorial creeremo un semplice job di batch che legge dati da un file CSV, li trasforma in maiuscolo e li scrive in un file, sempre csv, di output.
@Configuration
public class BatchConfiguration {
@Bean
public FlatFileItemReader reader() {
FlatFileItemReader reader = new FlatFileItemReader<>();
reader.setResource(new ClassPathResource("input.csv"));
reader.setLineMapper(new DefaultLineMapper() {
{
setLineTokenizer(new DelimitedLineTokenizer() {
{
setNames(new String[] {"firstName", "lastName"});
}
});
setFieldSetMapper(new BeanWrapperFieldSetMapper() {
{
setTargetType(User.class);
}
});
}
});
return reader;
}
@Bean
public UserItemProcessor processor() {
return new UserItemProcessor();
}
@Bean
public FlatFileItemWriter writer() {
FlatFileItemWriter writer = new FlatFileItemWriter<>();
writer.setResource(new FileSystemResource("output.csv"));
writer.setLineAggregator(new DelimitedLineAggregator() {
{
setDelimiter(",");
setFieldExtractor(new BeanWrapperFieldExtractor() {
{
setNames(new String[] {"firstName", "lastName"});
}
});
}
});
return writer;
}
@Bean
public Job importUserJob(JobRepository jobRepository, JobCompletionNotificationListener listener, Step step1) {
return new JobBuilder("importUserJob", jobRepository)
.incrementer(new RunIdIncrementer())
.listener(listener)
.flow(step1)
.end()
.build();
}
@Bean
public Step step1(JobRepository jobRepository, PlatformTransactionManager transactionManager, FlatFileItemWriter writer) {
return new StepBuilder("step1", jobRepository)
.<User, User> chunk(10, transactionManager)
.reader(reader())
.processor(processor())
.writer(writer)
.build();
}
}Nell'esempio sopra, abbiamo definito un job di batch chiamato importUserJob con un unico step step1. Abbiamo anche configurato un reader per leggere dati da un file CSV, un processor per trasformare i dati in maiuscolo e un writer per scrivere i dati in un file di output.
Per esegure il job lanciamo l'applicazion spring batch e attendiamo che i processi finiscano. Al termine dovremmo ritrovare un nuovo file (output.csv) con i dati elaborati
JILL,DOE
JOE,DOE
JUSTIN,DOE
JANE,DOE
JOHN,DOEInoltre per il nostro esempio abbiamo implemntato la JobExecutionListener per stampare sui Log la fine del Job.
@Component
public class JobCompletionNotificationListener implements JobExecutionListener {
private static final Logger LOG = LoggerFactory.getLogger(JobCompletionNotificationListener.class);
@Override
public void afterJob(JobExecution jobExecution) {
if(jobExecution.getStatus() == BatchStatus.COMPLETED) {
LOG.info("JOB FINISHED!");
}
}
}Dopo averlo eseguito, possiamo ottenere lo stato dell'esecuzione del job utilizzando jobExecution.getStatus(). Questo stato può assumere uno dei seguenti valori:
- BatchStatus.COMPLETED: Il job è stato completato con successo.
- BatchStatus.FAILED: Il job è fallito durante l'esecuzione.
- BatchStatus.STOPPED: Il job è stato fermato manualmente.
- BatchStatus.UNKNOWN: Lo stato del job non è noto o indefinito.
In questo tutorial, abbiamo imparato a configurare un progetto Spring Batch e a creare un semplice job di batch per leggere, trasformare e scrivere dati. Abbiamo fornito esempi di codice dettagliati per illustrare ogni passo del processo. Spring Batch è un potente framework per l'elaborazione dati in batch nelle applicazioni aziendali, e speriamo che questo tutorial ti abbia dato una buona introduzione su come utilizzarlo.
Il codice sorgente completo lo trovi su github.
Programmatore informatico italiano, mi occupo di sviluppo sia Front-end che Back-end presso una grande azienda. La programmazione è stata la mia passione, insieme allo sport e al teatro che pratico tutt'ora. Ho deciso di aprire questo blog per dare consigli e condividerli con chi, come me, porta con sé questa passione. [..]
