Blog ENI : Toute la veille numérique !
Offre estivale️ ☀️ : de -20% à -30% sur les livres en ligne et vidéos, avec le code PLAGE Cliquez ici !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Java Spring
  3. Spring Batch
Extrait - Java Spring Le socle technique des applications Jakarta EE (5e édition)
Extraits du livre
Java Spring Le socle technique des applications Jakarta EE (5e édition) Revenir à la page d'achat du livre

Spring Batch

Introduction

Dans le monde de l’informatique, nous séparons souvent les traitements en trois grandes familles :

  • les traitements temps réels ;

  • les traitements par lots que l’on nomme batchs ;

  • une famille de traitements hybride, une composition des deux premiers comme le streaming qui traite de gros volumes en temps réel.

images/12EP5JASP01NEW.png

Les programmes de traitement par lots actuels découlent souvent de la migration et de la modernisation de systèmes plus anciens. Ils restent pertinents pour les opérations de traitement de données en masse classiques, et trouvent également leur utilité dans les contextes de Big Data des applications contemporaines. Néanmoins, l’approche moderne tend à délaisser les traitements par lots classiques au profit du traitement des données en temps réel ou via des mini-batchs, souvent orchestrés avec des fonctionnalités telles que @Scheduled de Spring.

Cependant, dans certaines situations, l’usage des batchs reste indispensable. Les traitements batchs traditionnels nécessitent généralement un accès complet et exclusif aux bases de données, ce qui peut entraîner une interruption des opérations impliquant des interfaces utilisateur. Dans un contexte de mondialisation et de besoins d’accès continu aux applications, cette exigence d’exclusivité des bases de données pendant les périodes de traitement par lots devient un défi de plus en plus difficile à gérer.

Dans le paysage actuel des applications, l’utilisation des batchs se concentre principalement sur le chargement ou l’exportation de données. En matière de Big Data, ces traitements...

Architecture d’un batch

L’architecture de Spring Batch se scinde en plusieurs composantes distinctes. D’une part, il y a un cadre technique, qui prend la forme d’un framework paramétrable fournissant les fonctionnalités de base et l’infrastructure nécessaire pour le traitement par lots. D’autre part, il existe une section dédiée aux traitements spécifiques, qui est adaptée aux besoins fonctionnels particuliers de chaque application. Cette partie est conçue pour être personnalisable, permettant ainsi aux développeurs d’intégrer des logiques métier spécifiques et de répondre aux exigences uniques de leurs projets.

Le batch est composé d’un lanceur : le Job launcher, qui lance des travaux dits Jobs composés d’étapes nommés Steps. Tout est tracé dans une base de données via le repository.

images/12EP5JASP03NEW.png

Des listeners permettent également l’appel de code via des notifications sur le cycle de vie des travaux et des étapes.

Chaque étape (Job) est décomposée en trois parties :

images/12EP5JASP04NEW.png

Le Reader qui lit les données appelées Items en entrée, le Processor qui traite ces données et le Writer qui écrit les données en sortie.

Description des éléments Spring Batch

1. Versions

Les dernières versions mineures pour chaque version majeure :

Version

Date de sortie

5.1.0

22 novembre 2023

5.0.0

24 novembre 2022

4.3.5

23 février 2022

4.0.0

1er décembre 2017

2. Nouveautés de la version 5.1.0

La mise à jour de Spring Batch 5.1.0 comprend des améliorations majeures, telles que la mise à niveau des dépendances Spring, le support des threads virtuels de JDK 21, l’amélioration de la gestion de la mémoire dans JpaItemWriter, et l’introduction de nouveaux décorateurs synchronisés pour les lecteurs et écrivains d’items. Cette version ajoute également un lecteur basé sur le curseur pour MongoDB, supporte les insertions en masse dans MongoItemWriter, et inclut de nouvelles implémentations pour RedisItemReader et RedisItemWriter. D’autres améliorations incluent une configuration automatique du JobRegistryBeanPostProcessor, la possibilité de démarrer un flux de job avec une décision, et l’option de fournir un générateur de clés de job personnalisé.

3. Migrer depuis Spring Batch 4

Pour migrer de Spring Batch 4 à Spring Batch 5.1.0, voici les étapes clés à suivre :

  • Montée en version du JDK : Spring Batch 5 est basé sur Spring Framework 6...

Exemple Spring Batch version 5

Nous codons maintenant un exemple de petit batch pour illustrer le fonctionnement de Spring Batch à travers un chargeur de fichier CSV dans une base H2.

1. Dépendance Maven

<dependencies> 
   <dependency> 
       <groupId>org.springframework.batch</groupId> 
       <artifactId>spring-batch-core</artifactId> 
       <version>5.1.0</version> 
   </dependency> 
  <dependency> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-batch</artifactId> 
  </dependency> 
</dependencies> 

2. Lanceur du batch

Créons une classe main pour exécuter le batch :

// Annotation qui dénote une application Spring Boot. 
@SpringBootApplication 
public class LanceurExempleBatch { 
 
  // Point d'entrée principal de l'application Java. 
  public static void main(String[] args) throws Exception { 
    // Lance l'application Spring Boot, en utilisant 
    // LanceurExempleBatch comme classe de configuration. 
    SpringApplication.run(LanceurExempleBatch.class, args); 
  } 
} 

3. Configuration du batch

Créons une classe de configuration pour configurer le batch avec un Job contenant un Step. Un Job est un ensemble de Step et qui exécutent chacun une opération élémentaire.

// Déclaration de la classe de configuration pour Spring Batch 
@Configuration 
public class BatchConfiguration { 
 
  // Injection de la source de données configurée dans Spring 
  @Autowired 
  public DataSource dataSource; 
 
  // Définition d'un bean pour lire les données depuis un fichier 
  // plat (CSV) 
  @Bean 
  public FlatFileItemReader<Departement> reader() { 
    // Création d'un lecteur pour un fichier CSV nommé 
    //...

Données traitées

Spring Batch est un framework flexible qui peut gérer une grande variété de formats de données, souvent déterminés par les types d’ItemReader et ItemWriter utilisés dans un job. Voici quelques exemples de types de messages ou de formats de données que Spring Batch peut traiter :

  • Fichiers plats (flat files) : Spring Batch peut lire et écrire des fichiers textuels plats, tels que des fichiers CSV ou à largeur fixe, en utilisant des lecteurs et des écrivains comme FlatFileItemReader et FlatFileItemWriter.

  • XML : le traitement de données au format XML est possible avec des classes comme StaxEventItemReader et StaxEventItemWriter.

  • JSON : bien que Spring Batch n’ait pas de lecteurs/écrivains JSON intégrés, il peut être étendu pour gérer les données JSON en utilisant des bibliothèques de parsing comme Jackson.

  • Base de données relationnelle : Spring Batch peut interagir avec des bases de données relationnelles via JdbcBatchItemWriter, JdbcCursorItemReader, JpaItemWriter, et d’autres.

  • Messages de file d’attente (queue messages) : bien que Spring Batch ne soit pas conçu principalement pour le traitement de messages en temps réel, il peut être intégré avec des systèmes de messagerie tels que JMS...

Batchs fictifs

Dans le cadre de nouveaux développements, la tendance est d’éviter autant que possible les batchs traditionnels. Au lieu de cela, une approche plus moderne et flexible est privilégiée, celle d’utiliser des tâches planifiées (scheduled tasks) gérées par Spring. Ces tâches programmées offrent plusieurs avantages par rapport aux batchs classiques :

  • Planification flexible : les tâches planifiées dans Spring sont souvent déclenchées par des planificateurs (schedulers) qui fonctionnent de manière similaire au service cron d’Unix. Ce système permet de configurer des tâches pour qu’elles s’exécutent à des moments précis, à des intervalles réguliers, ou selon des conditions spécifiques, offrant ainsi une grande flexibilité.

  • Intégration avec Spring : en utilisant les capacités de planification intégrées à Spring, comme @Scheduled, les développeurs peuvent facilement configurer et gérer des tâches programmées au sein de l’écosystème Spring. Cela permet une intégration étroite avec d’autres composants Spring et une gestion plus cohérente des tâches au sein de l’application.

  • Scalabilité et performance : les tâches...

Évolutions des batchs

Nous ne nous attarderons pas sur les détails techniques, mais il est important de noter que le domaine du traitement par lots se dirige vers une approche axée sur la gestion de processus externes. Cette évolution est motivée par le désir d’exploiter les avantages offerts par le cloud computing, étant donné que Spring Batch est traditionnellement conçu pour fonctionner sur une machine unique.

Dans ce contexte, nous allons nous tourner vers l’utilisation de Spring Cloud Data Flow, en conjonction avec Spring Boot Task et Spring Cloud Function. Spring Cloud Function offre la possibilité d’exécuter des fonctions à la demande, similaires aux lambdas d’AWS, permettant ainsi une grande flexibilité et une scalabilité. Spring Boot Task, quant à lui, facilite la gestion et l’ordonnancement de tâches individuelles.

L’intégration avec Spring Cloud Data Flow apporte une dimension supplémentaire à cette configuration. En incorporant la notion de flux, Spring Cloud Data Flow permet de créer un système d’ordonnancement beaucoup plus vaste et complexe. Ce niveau d’abstraction supplémentaire rend possibles la gestion et l’orchestration de processus de traitement par lots à une échelle beaucoup plus large, tirant parti de l’élasticité...

Points clés

Points à retenir :

  • Spring Batch est accessible même si on a peu d’expérience dans le domaine, car les problématiques techniques sont gérées automatiquement.

  • Spring Batch permet de convertir facilement des données d’un format à un autre.

  • Nous essayerons, autant que faire se peut, de traiter les données en temps réel pour minimiser le nombre de batchs.