Aller au contenu

Découverte rapide de Spring Batch

Intérêt

Spring Batch est un projet du framework Spring qui offre une solution complète pour le traitement en batch de grands volumes de données. Il est conçu pour automatiser les tâches de traitement de données en masse, telles que la lecture, la transformation et l’écriture de données dans différents formats, tels que les fichiers plats, les bases de données, les files d’attente, etc…

Lien vers un autre exemple

Il fournit également des fonctionnalités avancées telles que :

Le fonctionnement de Spring Batch repose sur le concept de “job” (tâche) et de “step” (étape).

Un job est une séquence d’étapes qui sont exécutées les unes après les autres pour accomplir une tâche de traitement de données.

Chaque étape est responsable d’une partie spécifique du traitement, comme la lecture des données, leur transformation et leur écriture.

Spring Batch fournit un certain nombre :

Tous, prédéfinis pour les formats de données couramment utilisés, cependant, vous pouvez également créer vos propres implémentations personnalisées pour gérer des formats de données spécifiques.

Exemples

Voici un exemple simple de code Spring Batch pour lire des données depuis un fichier CSV, les transformer en ajoutant un préfixe à chaque ligne, et les écrire dans un fichier plat :

  1. Définir un objet de configuration de job
@Configuration
@EnableBatchProcessing
public class BatchConfiguration {

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Bean
    public Job myJob() {
        return jobBuilderFactory.get("myJob")
            .incrementer(new RunIdIncrementer())
            .start(step1())
            .build();
    }

    @Bean
    public Step step1() {
        return stepBuilderFactory.get("step1")
            .<String, String>chunk(10)
            .reader(reader())
            .processor(processor())
            .writer(writer())
            .build();
    }

    @Bean
    public FlatFileItemReader<String> reader() {
        return new FlatFileItemReaderBuilder<String>()
            .name("reader")
            .resource(new ClassPathResource("data.csv"))
            .lineMapper(new PassThroughLineMapper())
            .build();
    }

    @Bean
    public ItemProcessor<String, String> processor() {
        return new ItemProcessor<String, String>() {
            @Override
            public String process(String item) throws Exception {
                return "PREFIX_" + item;
            }
        };
    }

    @Bean
    public FlatFileItemWriter<String> writer() {
        return new FlatFileItemWriterBuilder<String>()
            .name("writer")
            .resource(new FileSystemResource("output.txt"))
            .lineAggregator(new PassThroughLineAggregator<>())
            .build();
    }
}

Dans cet exemple, nous définissons un job “myJob” avec une étape “step1”.

L’étape utilise :

  1. Définir les dépendances dans le fichier pom.xml (maven)
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-batch</artifactId>
<version>VERSION_SPRING_BATCH</version>
</dependency>

Assurez-vous de remplacer VERSION_SPRING_BATCH par la version de Spring Batch que vous souhaitez utiliser, par exemple 4.0.0-RC1 pour la version sur mvnrepository.

  1. Préparer le fichier de données data.csv dans le classpath du projet avec les données à traiter.

  2. Exécuter l’application Spring Boot et le job sera lancé automatiquement, traitant les données selon les étapes définies dans la configuration du job.

Notez que ceci est un exemple simple et que Spring Batch offre de nombreuses autres fonctionnalités avancées pour la gestion des transactions, la gestion des erreurs, la planification des tâches, etc. Vous pouvez consulter la documentation officielle de Spring Batch pour en savoir plus sur les fonctionnalités avancées et les meilleures pratiques de développement.

Types de données

Spring Batch est un outil de traitement de données en lots conçu pour traiter de grands volumes de manière efficace et fiable. Il peut être utilisé pour traiter différents types de données, notamment :

En résumé, Spring Batch est capable de traiter une grande variété de types de données, y compris les fichiers plats, les bases de données, les services web et d’autres types de données, ce qui en fait un outil polyvalent pour le traitement de données en lots dans les applications d’entreprise.

Utilisation de ObjectMapper

Vous pouvez utiliser l’objet ObjectMapper de Java, fourni par la bibliothèque Jackson pour traiter les données en entrée avec Spring Batch.

ObjectMapper peut être utilisé pour lire et écrire des données sous forme de JSON, XML, CSV, et d’autres formats.

Voici un exemple simple de code pour lire des données XML avec Spring Batch en utilisant un fichier fictif de données XML et l’objet ObjectMapper :

  1. Créer un modèle de données pour représenter les éléments du fichier XML. Par exemple, si nous avons un fichier XML avec des objets Personne contenant des informations sur les personnes, nous pouvons créer un modèle de données comme suit :
public class Personne {
    private String firstName;
    private String lastName;
    private int age;
    // Getters and Setters
}
  1. Configurer le lecteur (Reader) dans Spring Batch pour lire le fichier XML en utilisant l’objet ObjectMapper pour convertir les données XML en objets Java

@Bean
public StaxEventItemReader<Personne> personneItemReader() {
    StaxEventItemReader<Personne> reader = new StaxEventItemReader<>();
    reader.setResource(new ClassPathResource("data.xml"));                  // Spécifiez le chemin du fichier XML
    reader.setFragmentRootElementName("personne");                            // Spécifiez le nom de l'élément racine des objets dans le fichier XML
    reader.setUnmarshaller(new Jackson2XmlMarshaller());                    // Utilisez l'objet ObjectMapper pour convertir les données XML en objets Java
    return reader;
}
  1. Configurer les étapes suivantes du traitement en utilisant d’autres fonctionnalités, telles que les processeurs (Processors) pour effectuer des transformations sur les objets lus, et les écrivains (Writers) pour écrire les objets transformés dans une autre destination, telle qu’une base de données, un fichier, etc.

Cet exemple montre comment vous pouvez utiliser l’objet ObjectMapper de Java en combinaison avec Spring Batch pour lire des données XML et les traiter dans une application Spring Batch. Notez que vous devrez ajouter les dépendances nécessaires à Jackson et à Spring Batch dans votre projet Maven ou Gradle pour utiliser cette fonctionnalité.

Dépendances

Voici un exemple de dépendances Gradle à ajouter dans votre fichier build.gradle pour utiliser Spring Batch avec l’objet ObjectMapper de Jackson pour lire des données XML :

dependencies {
    // Dépendance Spring Batch
    implementation 'org.springframework.batch:spring-batch-core:4.3.3.RELEASE'
    
    // Dépendance pour lire des données XML avec Spring Batch
    implementation 'org.springframework.batch:spring-batch-item:4.3.3.RELEASE'
    
    // Dépendance pour utiliser l'objet ObjectMapper de Jackson pour la conversion XML <-> Java
    implementation 'com.fasterxml.jackson.dataformat:jackson-dataformat-xml:2.13.0'
}

Explications

N’oubliez pas de vérifier la dernière version des dépendances et de les mettre à jour en fonction de vos besoins et de la version de Spring que vous utilisez dans votre projet.