Tutoriel sur la mise en oeuvre de Spring Batch avec Spring Boot

Georges KEMAYO

Le traitement par lot, communément appelé Batch dans le jargon informatique, est une problématique très répandue et quasiment incontournable au sein des entreprises et industries qui manipulent d'énormes masses de données. Dans cet article, nous allons vous présenter au travers d'un exemple d'application, la technologie Spring Batch/Spring Boot permettant de répondre à ce type de besoin. Cet article ne se veut pas et ne peut pas être exhaustif, car il s'agit d'une technologie immensément vaste. Mais les différents concepts présentés dans ce cours sont suffisants pour son appropriation.

Réagissez à cet article en faisant vos remarques ici : Commentez

- Titre : Tutoriel sur la mise en oeuvre de Spring Batch avec Spring Boot

- Auteur : Georges KEMAYO

- Parution : 25 mars 2020

- Public visé :

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2019 Georges KEMAYO. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Qu'est ce qu'un Batch ?

- II. Qu'est-ce que Spring Batch ? Et quel rôle joue Spring Boot ?

- III. Exemple d'application

- IV. Infrastructure et Modèle de données

- IV-A. Infrastructure

- IV-B. Modèle de données

- V. Mise en oeuvre de l'application

- V-A. Structure du projet et pom.xml

- V-B. L'application.properties

- V-C. La classe de configuration globale

- V-D. La classe de configuration Spring Data JDBC

- V-E. La Classe Reader

- V-F. La classe Processor

- V-G. La classe Writer

- V-H. La classe SkipPolicy

- V-I. La classe Listener

- VI. Le Test Unitaire/Intégration

- VI-A. Configurations requises

- VI-A-1. application-test.properties

- VI-A-2. Le dossier reports-repository

- VI-B. La classe de test

- VII. Démo de l'application

- VIII. Accéder au code source

- IX. Conclusion et perspectives

- X. References

- XI. Remerciements

I - Qu'est ce qu'un Batch ?

Un Batch est une application informatique dont la vocation est d'effectuer du traitement par lot sur une masse de données. En général ce type de programme s'exécute de façon autonome, peut potentiellement consommer beaucoup de ressources machine (CPU, mémoire, etc.) et peut avoir un temps d'exécution long (plusieurs minutes ou heures) lorsque le volume de données à traiter est consistant. Il est en général conçu pour se déclencher et s'exécuter de façon autonome, automatique et régulière/périodique, mais ce n'est pas obligatoire, car la gestion d'un batch peut tout à fait être manuelle. Un Batch a pour objectif de lire des données provenant de diverses sources homogènes ou hétérogènes (fichiers, bases de données, web, etc.), puis d'effectuer des traitements/transformations sur ces données lues afin d'en stocker le résultat dans un ou plusieurs conteneurs de destination (fichiers, bases de données, queue, etc.) dans le but de les exploiter. Nous pouvons résumer cette définition au travers de l'image ci-dessous :

II - Qu'est-ce que Spring Batch ? Et quel rôle joue Spring Boot ?

Spring Batch est un puissant framework Java basé sur Spring et qui permet de construire des programmes de traitement par lot. Si nous reprenons la figure de la section I, nous devinons donc que Spring Batch se positionne au centre entre les deux blocs rectangulaires au niveau de la roue dentée. Plus concrètement, il s'agit d'un framework qui fournit un ensemble de composants et de fonctionnalités réutilisables et personnalisables permettant de donner au programme de traitement par lot tous les éléments nécessaires à :

- la définition d'un cadre structuré pour implémenter les règles métier ;

- son démarrage et la gestion de son ordonnancement ;

- son monitoring et la réalisation de statistiques sur les données et tâches manipulées en son sein ;

- l'écoute et la capturation des évènements qui surviennent avant, pendant et après son exécution ;

- l'amélioration de la performance des traitements à travers des techniques de partitionnement et d'optimisation ;

- etc.

Nous pouvons représenter de façon macroscopique Spring Batch par la figure suivante :

Ce schéma illustre une vue architecturale générale et non détaillée du framework Spring Batch. Il présente plusieurs composants qui doivent être définis et configurés pour suivre le workflow dont le sens suit la numérotation qui accompagne chacun d'eux sur ce schéma.

- Le JobLauncher : il s'agit du composant chargé de lancer/démarrer le programme de traitement par lot (batch). Il peut être configuré pour s'autodéclencher ou pour être déclenché par un évènement extérieur (lancement manuel). Dans le worflow Spring Batch, le JobLauncher est chargé d'exécuter un Job (tâche).

- Le Job : il s'agit du composant qui représente la tâche à qui on délègue la responsabilité du besoin métier traité dans le programme. Il est chargé de lancer de façon séquentielle une ou plusieurs Step.

- La Step : c'est le composant qui enveloppe le cœur même du besoin métier à traiter. Il est chargé de définir trois sous-composants structurés comme suit :
(1) Le Reader : c'est le composant chargé de lire les données d'entrées à traiter. Elles peuvent provenir de diverses sources (bases de données, fichiers plats (csv, xml, xls, etc.), queue) ;
(2) Le Processor : c'est le composant responsable de la transformation des données lues. C'est en son sein que toutes les règles de gestion sont implémentées ;
(3) Le Writer : ce composant sauvegarde les données transformées par le processor dans un ou plusieurs conteneurs désirés (bases de données, fichiers plats (csv, xml, xls, etc.), cloud).

- Le Repository : c'est le composant chargé d'enregistrer les statistiques issues du monitoring sur le JobLauncher, le Job et la (ou les) Step à chaque exécution. Il offre deux techniques possibles pour stocker ces statistiques : le passage par une base de données ou le passage par une Map. Lorsque le stockage des statistiques est fait dans une base de données, et donc persisté de façon durable, cela permet le suivi continuel du Batch dans le temps à l'effet d'analyser les éventuels problèmes en cas d'échec. A contrario lorsque c'est dans une Map, les statistiques persistées seront perdues à la terminaison de chaque instance d'exécution du Batch. Dans tous les cas, il faut configurer l'un ou l'autre obligatoirement.

- Les Job et Step Listeners : ce sont chacun des composants facultatifs qui offrent un cadre pour l'implémentation des services de monitoring personnalisés. Ils sont très utiles pour journaliser (loguer) les états du Job/Step avant et après leur exécution.

Comme vous pouvez déjà vous en apercevoir au travers du schéma et des explications ci-dessus, Spring Batch est un framework complexe et pas très simple à appréhender. Il y a beaucoup de configurations à faire en plus de l'implémentation des règles de gestion constituant le cœur même du besoin métier à résoudre.
C'est à ce niveau que Spring Boot intervient et va nous aider à simplifier la configuration de Spring Batch afin d'améliorer la productivité. Dans l'article suivant, nous avions déjà expliqué et listé les avantages de Spring Boot. Ceux-ci s'appliquent entièrement également pour le cas Spring Batch et constituent la raison fondamentale d'utiliser de nos jours Spring Batch à travers Spring Boot lorsque l'environnement de travail nous en donne la possibilité.

III - Exemple d'application

Pour illustrer comment utiliser Spring Batch dans un programme de traitement par lot, nous allons définir ci-dessous un exemple de sujet qui va nous amener à atteindre notre objectif.

Sujet : notre exemple concerne la conception et le développement d'un Batch qui traitera les fichiers internes de commandes d'une société commerciale qui revend du matériel multimédia à grande échelle. L'objectif premier du Batch sera de lire continuellement les données de commandes contenues dans des fichiers csv que dépose, dans un répertoire commun, chaque responsable d'achat lorsqu'il reçoit ses commandes d'un ou plusieurs fournisseurs de la société. Ensuite, le Batch devra les traiter afin de les agréger pour ensuite les stocker dans un entrepôt de données. Nous pouvons résumer le processus d'achats par le workflow illustré par la figure ci-dessous :

Notre Batch jouera alors le rôle de ce que l'on qualifie dans le domaine de la Business Intelligence (BI), un ETL (Extract-Transform-Load). Les données agrégées et stockées dans l'entrepôt de données permettront d'aider à la prise de décision par le(s) responsable(s) de la société sur les orientations possibles de politiques d'achats.

Nous supposerons que chacun des fichiers csv déposés par un agent commercial d'achat est structuré de la façon suivante, où la première ligne représente l'entête composé de l'intitulé de chaque colonne. Les valeurs de chaque colonne sont séparées par des points-virgules :

e besoin métier voulu est de lire l'ensemble des fichiers déposés à un instant t sur le répertoire central du serveur et d'historiser les données lues dans un entrepôt de données de manière à ce que :

1. Pour chaque ligne lue, on puisse directement avoir accès à la somme totale des dépenses effectuées pour un article (somme totale = quantité*prix_unitaire) :

2. Pour chaque ligne lue, on n'effectue pas de doublon en écriture dans la base de données, des données concernant le fournisseur (Supplier), l'agent d'achat (Purchaser) et le produit de même type contenu dans les commandes (Order).

IV - Infrastructure et Modèle de données

IV-A - Infrastructure

Nous vous l'avons dit précédemment, nous construirons notre application à l'aide de Spring Boot auquel nous allons injecter le framework Spring Batch. Notre application sera packagée en jar. Pour ceux qui s'initient encore à la création d'un projet Spring Boot, vous pouvez suivre le tutoriel suivant où nous nous étions déjà appesantis sur la description du processus.

L'architecture de notre application va naturellement suivre celle illustrée à la figure section II déjà tracée par Spring Batch. La seule petite différence dans cet article est que nous ne créerons pas explicitement le composant JobLauncher. En effet, lorsque nous utilisons Spring Batch avec Spring Boot, il crée pour nous par défaut le composant JobLauncher pour permettre le lancement automatique du Batch dès qu'on exécute le jar de l'application (cf. java -jar xxx.jar).

Nous pouvons bien entendu désactiver ce comportement par défaut pour créer notre propre JobLauncher.
Propriété spring.batch.initializer.enabled=false à ajouter dans l'application.properties.

En somme, l'infrastructure de développement de notre application est la suivante :

- Eclipse SimRel 2018-12 : l'IDE de développement ;

- Spring Boot 2.2.4 : socle de construction du projet ;

- Spring web 5.2.3 : pour injecter le tomcat embarqué nécessaire au fonctionnement standalone de l'application ;

- Java 8 : langage applicatif utilisé ;

- Maven 3.2 : pour la gestion des dépendances ;

- Lombok 1.18.10 : pour la gestion des accesseurs des objets Java utilisés dans l'application ;

- Spring Batch 4.2.0 : pour permettre d'accéder aux composants permettant de construire notre Batch ;

- Spring Data JDBC 1.1.1 : pour la gestion de la persistance des données dans l'entrepôt de données ;

- H2 Database 1.4.200 : l'entrepôt de données de l'application.

IV-B - Modèle de données

D'après l'exposé du besoin métier décrit à la section III, nous proposons le modèle physique de données ci-dessous, où nous avons choisi d'utiliser les termes anglo-saxons pour qualifier nos entités.

Il s'agit d'un modèle en étoile dans lequel la table FACT_ORDER (table des Commandes) correspond à ce qu'on appelle la table des Faits et toutes les tables qui gravitent autour correspondent aux tables de Dimensions. Dans le cas d'espèce, DIM_PRODUCT (table qui recense sans doublon les produits), DIM_EMPLOYEE_PURCHASER (table qui recense sans doublon les agents d'achats), DIM_SUPPLIER (table qui recense sans doublon les fournisseurs), DIM_DATE (table qui recense sans doublon les dates d'achats) correspondent aux tables de Dimensions. Nous vous invitons à lire l'article suivant pour plus de détails sur la modélisation d'entrepôt de données.

V - Mise en oeuvre de l'application

V-A - Structure du projet et pom.xml

L'application baptisée datawarehouse-loader-batch que nous allons construire aura la structuration finale suivante sur Eclipse :

Le pom.xml résultant est le suivant :

1. <?xml version="1.0" encoding="UTF-8"?>

2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

3. xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

4. <modelVersion>4.0.0</modelVersion>

5. <parent>

6. <groupId>org.springframework.boot</groupId>

7. <artifactId>spring-boot-starter-parent</artifactId>

8. <version>2.2.4.RELEASE</version>

9. <relativePath/> <!-- lookup parent from repository -->

10. </parent>

11. <groupId>com.gkemayo</groupId>

12. <artifactId>datawarehouse-loader-batch</artifactId>

13. <version>0.0.1-SNAPSHOT</version>

14. <name>datawarehouse-loader-batch</name>

15. <description>Spring Batch project for extracting data on files resources and load them on a DataWarehouse</description>

17. <properties>

18. <java.version>1.8</java.version>

19. </properties>

21. <dependencies>

22. <dependency>

23. <groupId>org.springframework.boot</groupId>

24. <artifactId>spring-boot-starter-web</artifactId>

25. </dependency>

26. <dependency>

27. <groupId>org.springframework.boot</groupId>

28. <artifactId>spring-boot-starter-batch</artifactId>

29. </dependency>

30. <dependency>

31. <groupId>org.springframework.boot</groupId>

32. <artifactId>spring-boot-starter-data-jdbc</artifactId>

33. </dependency>

35. <dependency>

36. <groupId>com.h2database</groupId>

37. <artifactId>h2</artifactId>

38. <scope>runtime</scope>

39. </dependency>

40. <dependency>

41. <groupId>org.springframework.boot</groupId>

42. <artifactId>spring-boot-configuration-processor</artifactId>

43. <optional>true</optional>

44. </dependency>

45. <dependency>

46. <groupId>org.projectlombok</groupId>

47. <artifactId>lombok</artifactId>

48. <optional>true</optional>

49. </dependency>

50. <dependency>

51. <groupId>org.springframework.boot</groupId>

52. <artifactId>spring-boot-starter-test</artifactId>

53. <scope>test</scope>

54. <exclusions>

55. <exclusion>

56. <groupId>org.junit.vintage</groupId>

57. <artifactId>junit-vintage-engine</artifactId>

58. </exclusion>

59. </exclusions>

60. </dependency>

61. <dependency>

62. <groupId>org.springframework.batch</groupId>

63. <artifactId>spring-batch-test</artifactId>

64. <scope>test</scope>

65. </dependency>

66. </dependencies>

68. <build>

69. <plugins>

70. <plugin>

71. <groupId>org.springframework.boot</groupId>

72. <artifactId>spring-boot-maven-plugin</artifactId>

73. </plugin>

74. </plugins>

75. </build>

76. </project>

- le starter spring-boot-starter-web injectera toutes les dépendances liées à Spring web ;

- le starter spring-boot-starter-batch injectera toutes les dépendances liées à Spring Batch ;

- le starter spring-boot-starter-data-jdbc injectera toutes les dépendances liées à Spring Data JDBC ;

- le starter spring-boot-starter-test injectera toutes les dépendances pour faire des tests unitaires et d'intégration ;

- la dépendance spring-batch-test met à disposition des composants permettant de faciliter le test d'un projet Spring Batch.

V-B - L'application.properties

1. ############# DataSource Config #################

2. spring.datasource.name=datawarehouse-db

3. spring.datasource.username=sa

4. spring.datasource.password=

5. spring.datasource.url= jdbc:h2:file:./src/main/resources/database/datawarehouse-db

6. spring.datasource.driver-class-name=org.h2.Driver

7. spring.datasource.sql-script-encoding= UTF-8

9. spring.datasource.schema = classpath:schema/datawarehouse-schema.sql

11. spring.h2.console.enabled=true

12. spring.h2.console.path=/h2-console

13. #http://localhost:8080/h2-console/

15. logging.level.root=info

16. logging.file.max-size=10MB

17. logging.file=./logs/batch-datawarehouse-loader.log

19. path.to.the.work.dir=../../datawarehouse-reports-repository

Explications :

- spring.datasource.* : ces paramètres permettent de configurer la datasource permettant d'accéder à la base de données H2 de l'application. Nous choisissons pour cet exemple l'application une persistance durable de type file. Dans une application d'envergure, il faut bien entendu une base de données d'entreprise telle que Oracle, Postgresql, SQL Server, MySQL, etc.

- spring.datasource.schema : permet au démarrage de l'application Spring Boot de créer le schéma (tables, index, etc.) de notre base de données (FACT_ORDER, DIM_SUPPLIER, DIM_PRODUCT, DIM_DATE, DIM_PURCHASER). Par défaut, Spring Boot crée le schéma des métadonnées Spring Batch (c'est-à-dire, les tables de statistiques de Spring Batch) lorsque le droit d'écriture sur la base de données est autorisé. Dans le cas contraire, il faut le jouer manuellement. Nous vous avons donc mis le script SQL concerné dans le fichier spring-batch-meta-data-schema.sql du projet.

- spring.h2.console.* : permet la visualisation web de la base de données H2 sur l'URL http://localhost:8080/h2-console/.

- logging.* : configure les paramètres permettant la journalisation (log) des événements qui surviennent dans l'application.

- path.to.the.work.dir : paramètre personnel qui indique l'endroit où trouver le répertoire central de dépôt des fichiers de commandes.

Pour rappel, l'ensemble des paramètres standards Spring Boot peuvent être retrouvés sur la page suivante.

V-C - La classe de configuration globale

1. package com.gkemayo.batch;

3. import javax.sql.DataSource;

5. import org.springframework.batch.core.Job;

6. import org.springframework.batch.core.Step;

7. import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;

8. import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;

9. import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;

10. import org.springframework.batch.core.launch.support.RunIdIncrementer;

11. import org.springframework.batch.core.repository.JobRepository;

12. import org.springframework.batch.core.repository.support.JobRepositoryFactoryBean;

13. import org.springframework.beans.factory.annotation.Autowired;

14. import org.springframework.beans.factory.annotation.Value;

15. import org.springframework.boot.SpringApplication;

16. import org.springframework.boot.autoconfigure.SpringBootApplication;

17. import org.springframework.context.annotation.Bean;

18. import org.springframework.scheduling.annotation.EnableScheduling;

19. import org.springframework.scheduling.annotation.Scheduled;

20. import org.springframework.transaction.PlatformTransactionManager;

22. import com.gkemayo.batch.batchutils.BatchJobListener;

23. import com.gkemayo.batch.batchutils.BatchStepSkipper;

24. import com.gkemayo.batch.dto.ConvertedInputData;

25. import com.gkemayo.batch.dto.InputData;

26. import com.gkemayo.batch.processor.BatchProcessor;

27. import com.gkemayo.batch.reader.BatchReader;

28. import com.gkemayo.batch.writer.BatchWriter;

30. @SpringBootApplication

31. @EnableBatchProcessing

32. public class BatchDatawarehouseLoaderApplication {

34. public static void main(String[] args) {

35. SpringApplication.run(BatchDatawarehouseLoaderApplication.class, args);

36. }

38. @Value("${path.to.the.work.dir}")

39. private String workDirPath ;

41. @Autowired

42. private DataSource dataSource;

44. @Autowired

45. PlatformTransactionManager transactionManager;

47. @Bean

48. public JobRepository jobRepositoryObj() throws Exception {

49. JobRepositoryFactoryBean jobRepoFactory = new JobRepositoryFactoryBean();

50. jobRepoFactory.setTransactionManager(transactionManager);

51. jobRepoFactory.setDataSource(dataSource);

52. return jobRepoFactory.getObject();

53. }

55. @Autowired

56. JobBuilderFactory jobBuilderFactory;

58. @Autowired

59. StepBuilderFactory stepBuilderFactory;

61. @Bean

62. public BatchReader batchReader() {

63. return new BatchReader(workDirPath);

64. }

66. @Bean

67. public BatchProcessor batchProcessor() {

68. return new BatchProcessor();

69. }

71. @Bean

72. public BatchWriter batchWriter() {

73. return new BatchWriter();

74. }

76. @Bean

77. public BatchJobListener batchJobListener() {

78. return new BatchJobListener();

79. }

81. @Bean

82. public BatchStepSkipper batchStepSkipper() {

83. return new BatchStepSkipper();

84. }

86. @Bean

87. public Step batchStep() {

88. return stepBuilderFactory.get("stepDatawarehouseLoader").transactionManager(transactionManager)

89. .<InputData, ConvertedInputData>chunk(1).reader(batchReader()).processor(batchProcessor())

90. .writer(batchWriter()).faultTolerant().skipPolicy(batchStepSkipper()).build();

91. }

93. @Bean

94. public Job jobStep() throws Exception {

95. return jobBuilderFactory.get("jobDatawarehouseLoader").repository(jobRepositoryObj()).incrementer(new RunIdIncrementer()).listener(batchJobListener())

96. .flow(batchStep()).end().build();

97. }

99. }

Explications

- Les annotations

- @SpringBootApplication : annotation Spring Boot qui encapsule les trois annotations suivantes : @Configuration, @EnableAutoConfiguration, @ComponentScan.

- @EnableBatchProcessing : annotation qui déclare une classe comme une qui va permettre de créer et configurer des composants Spring Batch.

- Les composants Spring Batch

- JobRepository : correspond au composant Repository de l'architecture Spring Batch numéroté 5 sur la figure de la section II.

- JobBuilderFactory : classe native Spring Batch qui offre des fonctionnalités permettant de créer et d'enrichir un Job de tous les éléments dont il a besoin.

- StepBuilderFactory : classe native Spring Batch qui offre des fonctionnalités aidant à créer et enrichir une Step de tous les éléments dont elle a besoin.

- BatchReader : classe qui effectuera la lecture des données dans les fichiers csv entrés.

- BatchProcessor : classe qui effectuera les traitements nécessaires sur les données lues.

- BatchWriter : classe qui va sauvegarder les données traitées dans l'entrepôt de données.

- BatchJobListener : classe qui permettra de journaliser les évènements pendant l'exécution du Job.

- BatchStepSkipper : classe qui va permettre la gestion de la tolérance aux fautes. En d'autres termes, cette classe va permettre au Batch de tolérer certaines lignes non conformes lues par le Reader en les sautant tout simplement, pour ne pas pénaliser toutes les autres lignes qui pourraient être conformes. En général un seuil est paramétré et c'est à l'atteinte de ce seuil que la tolérance aux fautes n'est plus acceptée et le Batch s'arrêtera donc.

- Step : classe native Spring Batch à laquelle on enrichira le Reader, le Processor et le Writer du Batch. De plus, on va lui indiquer le Pojo dans lequel seront enregistrées les données lues par le Reader depuis les fichiers d'entrées (ici, InputData) et sous quel format le Processor après les avoir transformées les délivrera au Writer (ici, ConvertedInputData). L'argument chunk définit le nombre de données lues et traitées à la fois par le Reader. À savoir qu'un Reader Spring Batch partitionne les données d'entrées et les lit par lot (défini donc par le chunk). Enfin, nous valorisons le champ skipPolicy avec le bean qui va se charger de gérer la tolérance aux fautes (en l'occurrence, BatchStepSkipper).

- Job : classe native Spring Batch dans laquelle on enrichira notre Step précédente, le listener et le jobRepository.

Vous avez pu remarquer que l'ensemble de ces composants/classes Spring Batch sont targués par les annotations @Autowired et @Bean. Ce qui signifie qu'ils sont injectés dans l'application comme des beans Spring, et donc sont des singletons.

V-D - La classe de configuration Spring Data JDBC

Spring Data JDBC est un framework permettant la gestion de la persistance des données dans une application. Il s'agit d'une couche d'abstraction placée au-dessus de l'API (Application Programming Interface) JDBC que vous connaissez tous. Spring Data JDBC est une version allégée de Spring Data JPA comme vous pouvez le voir dans sa documentation officielle suivante.

Ce qui nous a motivés à choisir Spring Data JDBC dans cette application est que nous n'avions pas besoin d'effectuer des opérations complexes sur les entités telles que le Lazy loading, les mapping ORM complexes, les transactions. En effet, une contrainte de notre entrepôt de données, à savoir ne pas enregistrer les données en doublon, nous oblige à commiter après chaque opération de sauvegarde (cf. chunk(1))...

1. package com.gkemayo.batch.entitiesrepository;

3. import javax.sql.DataSource;

5. import org.springframework.beans.factory.annotation.Autowired;

6. import org.springframework.context.annotation.Bean;

7. import org.springframework.context.annotation.Configuration;

8. import org.springframework.data.jdbc.repository.config.AbstractJdbcConfiguration;

9. import org.springframework.data.jdbc.repository.config.EnableJdbcRepositories;

10. import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;

11. import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;

13. @Configuration

14. @EnableJdbcRepositories

15. public class BatchRepositoryConfig extends AbstractJdbcConfiguration {

17. @Autowired

18. private DataSource dataSource;

20. @Bean

21. NamedParameterJdbcOperations operations() {

22. return new NamedParameterJdbcTemplate(dataSource);

23. }

25. }

Explications

Pour utiliser Spring Data JDBC dans une application, il faut lui créer une classe de configuration (qui sera targuée @Configuration) Spring à laquelle on ajoutera l'annotation @EnableJdbcRepositories. Cette classe devra également étendre la classe AbstractJdbcConfiguration. Enfin, dans la classe de configuration, il faudra définir un Bean NamedParameterJdbcOperations qui indiquera à Spring Data JDBC où trouver la datasource de l'application.

V-E - La Classe Reader

1. package com.gkemayo.batch.reader;

3. import java.io.File;

4. import java.util.ArrayList;

5. import java.util.Arrays;

6. import java.util.List;

7. import java.util.stream.Collectors;

9. import org.slf4j.Logger;

10. import org.slf4j.LoggerFactory;

11. import org.springframework.batch.item.file.FlatFileItemReader;

12. import org.springframework.batch.item.file.MultiResourceItemReader;

13. import org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper;

14. import org.springframework.batch.item.file.mapping.DefaultLineMapper;

15. import org.springframework.batch.item.file.mapping.FieldSetMapper;

16. import org.springframework.batch.item.file.transform.DelimitedLineTokenizer;

17. import org.springframework.batch.item.file.transform.FieldSet;

18. import org.springframework.core.io.FileSystemResource;

19. import org.springframework.validation.BindException;

21. import com.gkemayo.batch.dto.InputData;

23. import lombok.extern.slf4j.Slf4j;

25. /**

26. * Spring batch reader : read all the input data files

27. *

28. * @author Georges Kemayo

29. *

30. */

31. @Slf4j

32. public class BatchReader extends MultiResourceItemReader<InputData>{

34. Logger log = LoggerFactory.getLogger(BatchReader.class);

36. public BatchReader(String workDirPath) {

37. log.info("Batch reader starting to read input data in repository : " + workDirPath);

38. this.setResources(getInputResources(workDirPath));

39. this.setDelegate(readOneFile());

40. }

42. /**

43. * Get all the resources (files) to be readen by this spring batch reader.

44. *

45. * @param workDirPath

46. * @return

47. */

48. private FileSystemResource[] getInputResources(String workDirPath) {

50. File inputDir = new File(workDirPath);

51. File[] files = inputDir.listFiles();

52. List<File> filesList = Arrays.asList(files);

54. List<FileSystemResource> inputResources = filesList.stream().filter(file -> file != null && file.isFile())

55. .peek(file -> log.info("Reading file : " + file.getAbsolutePath()))

56. .map(file -> new FileSystemResource(file))

57. .collect(Collectors.toList());

59. return inputResources.toArray(new FileSystemResource[inputResources.size()]);

60. }

62. /**

63. * Set and return a FlatFileItemReader to read one resource.

64. *

65. * @return

66. */

67. private FlatFileItemReader<InputData> readOneFile() {

69. FlatFileItemReader<InputData> resourceReader = new FlatFileItemReader<InputData>();

71. //skip the first line which is the file header

72. resourceReader.setLinesToSkip(1);

74. resourceReader.setLineMapper(new DefaultLineMapper<InputData>() {

76. private DelimitedLineTokenizer lineTokenizer = new DelimitedLineTokenizer(";");

77. private FieldSetMapper<InputData> fieldSetMapper = new BeanWrapperFieldSetMapper<InputData>() {

78. @Override

79. public InputData mapFieldSet(FieldSet pFielSet) throws BindException {

80. InputData inputData = new InputData();

81. inputData.setProductName(pFielSet.readString("productName"));

82. inputData.setProductEanCode(pFielSet.readString("productEanCode"));

83. inputData.setProductType(pFielSet.readString("productType"));

84. inputData.setProductAmount(pFielSet.readDouble("productAmount"));

85. inputData.setProductQuantity(pFielSet.readInt("productQuantity"));

86. inputData.setSupplierName(pFielSet.readString("supplierName"));

87. inputData.setSupplierAddress(pFielSet.readString("supplierAddress"));

88. inputData.setPurchaserEmail(pFielSet.readString("purchaserEmail"));

89. inputData.setPurchaserFirstName(pFielSet.readString("purchaserFirstName"));

90. inputData.setPurchaserLastName(pFielSet.readString("purchaserLastName"));

91. inputData.setTransactionDate(pFielSet.readDate("transactionDate"));

92. return inputData;

94. }

95. };

97. @Override

98. public InputData mapLine(String pLine, int pLineNumber) throws Exception {

100. lineTokenizer.setNames(new String[]{"productName", "productEanCode", "productType", "productQuantity",

101. "productAmount", "supplierName", "supplierAddress", "purchaserFirstName",

102. "purchaserLastName", "purchaserEmail", "transactionDate"});

103. return fieldSetMapper.mapFieldSet(lineTokenizer.tokenize(pLine));

104. }

106. });

108. return resourceReader;

109. }

111. }

Avec InputData égale à :

1. package com.gkemayo.batch.dto;

3. import java.util.Date;

5. import lombok.EqualsAndHashCode;

6. import lombok.Getter;

7. import lombok.RequiredArgsConstructor;

8. import lombok.Setter;

9. import lombok.ToString;

11. @Setter

12. @Getter

13. @ToString

14. @EqualsAndHashCode

15. @RequiredArgsConstructor

16. public class InputData {

18. private String productName;

20. private String productType;

22. private String productEanCode;

24. private Double productAmount;

26. private Integer productQuantity;

28. private String purchaserFirstName;

30. private String purchaserLastName;

32. private String purchaserEmail;

34. private String supplierName;

36. private String supplierAddress;

38. private Date transactionDate;

39. }

Explications

Spring Batch offre plusieurs classes de type Reader fournissant des fonctionnalités permettant de répondre à certains besoins de base : le besoin lire des données dans une base de données, le besoin des données dans un fichier plat, le besoin de lire des données dans plusieurs fichiers plats à la fois, le besoin de lire des données dans un fichier XML, etc. Voici quelques-unes de ces classes : ItemReader, FlatFileItemReader, MultiResourceItemReader, StaxEventItemReader, JdbcPagingItemReader, JpaPagingItemReader, JmsItemReader, JsonItemReader, KafkaItemReader, etc. Pour plus de détails, regarder le lien suivant.

Dans notre exemple et conformément au besoin métier décrit à la section III, nous avons besoin de lire dans plusieurs fichiers plats (de type csv) à la fois. C'est pourquoi notre classe BatchReader étend naturellement la classe MultiResourceItemReader. Les développements effectués dans notre classe BatchReader sont des développements qui suivent le canevas conventionnel tracé par Spring Batch, à savoir définir ou créer des objets permettant de parser chaque fichier d'entrée et de transformer chaque ligne lue en un objet Java (ici, InputData). On indique ainsi, le délimiteur/séparateur (ici le ;) entre les différents champs d'une ligne. L'ordre de valorisation des propriétés de InputData est important, il va de la gauche vers la droite pour chaque ligne lue.

V-F - La classe Processor

1. package com.gkemayo.batch.processor;

3. import org.springframework.batch.item.ItemProcessor;

4. import org.springframework.beans.factory.annotation.Autowired;

6. import com.gkemayo.batch.dto.ConvertedInputData;

7. import com.gkemayo.batch.dto.InputData;

8. import com.gkemayo.batch.entities.Order;

9. import com.gkemayo.batch.entities.Product;

10. import com.gkemayo.batch.entities.PurchaseDate;

11. import com.gkemayo.batch.entities.Purchaser;

12. import com.gkemayo.batch.entities.Supplier;

13. import com.gkemayo.batch.entitiesrepository.ProductRepository;

14. import com.gkemayo.batch.entitiesrepository.PurchaseDateRepository;

15. import com.gkemayo.batch.entitiesrepository.PurchaserRepository;

16. import com.gkemayo.batch.entitiesrepository.SupplierRepository;

18. public class BatchProcessor implements ItemProcessor<InputData, ConvertedInputData> {

20. @Autowired

21. private SupplierRepository supplierRepository;

23. @Autowired

24. private PurchaserRepository purchaserRepository;

26. @Autowired

27. private ProductRepository productRepository;

29. @Autowired

30. private PurchaseDateRepository purchaseDateRepository;

32. @Override

33. public ConvertedInputData process(InputData item) throws Exception {

35. ConvertedInputData convertedInputData = new ConvertedInputData();

36. Order order = new Order();

38. Supplier supplier = supplierRepository.findByName(item.getSupplierName());

39. Purchaser purchaser = purchaserRepository.findByEmail(item.getPurchaserEmail());

40. Product product = productRepository.findByEanCode(item.getProductEanCode());

41. PurchaseDate purchaseDate = purchaseDateRepository.findByDate(item.getTransactionDate());

43. if(supplier == null) {

44. supplier = Supplier.of(null, item.getSupplierName(), item.getSupplierAddress());

45. convertedInputData.setSupplier(supplier);

46. }else {

47. order.setSupplierId(supplier.getId());

48. }

50. if(purchaser == null) {

51. purchaser = Purchaser.of(null, item.getPurchaserFirstName(), item.getPurchaserLastName(), item.getPurchaserEmail());

52. convertedInputData.setPurchaser(purchaser);

53. }else {

54. order.setPurchaserId(purchaser.getId());

55. }

57. if(product == null) {

58. product = Product.of(null, item.getProductName(), item.getProductType(), item.getProductEanCode());

59. convertedInputData.setProduct(product);

60. order.setQuantity(item.getProductQuantity());

61. order.setAmount(item.getProductAmount()*item.getProductQuantity());

62. }else {

63. order.setProductId(product.getId());

64. order.setQuantity(item.getProductQuantity());

65. order.setAmount(item.getProductAmount()*item.getProductQuantity());

66. }

68. if(purchaseDate == null) {

69. purchaseDate = PurchaseDate.of(null, item.getTransactionDate());

70. convertedInputData.setPurchaseDate(purchaseDate);

71. }else {

72. order.setDateId(purchaseDate.getId());

73. }

75. convertedInputData.setOrder(order);

77. return convertedInputData;

78. }

80. }

Avec ConvertedInputData égale à :

1. package com.gkemayo.batch.dto;

3. import com.gkemayo.batch.entities.Supplier;

4. import com.gkemayo.batch.entities.Order;

5. import com.gkemayo.batch.entities.Product;

6. import com.gkemayo.batch.entities.Purchaser;

7. import com.gkemayo.batch.entities.PurchaseDate;

9. import lombok.Data;

11. @Data

12. public class ConvertedInputData {

14. private Supplier supplier;

16. private Purchaser purchaser;

18. private Product product;

20. private PurchaseDate purchaseDate;

22. private Order order;

23. }

Explications

Spring Batch offre également plusieurs classes de type Processor en fonction des besoins : ItemProcessor, AsyncItemProcessor, BeanValidatingItemProcessor, FunctionItemProcessor, ItemProcessorAdapter, PassThroughItemProcessor, ScriptItemProcessor, ValidatingItemProcessor, etc.
Dans notre exemple, nous effectuons un traitement simple sur les données lues. Notre classe BatchProcessor implémente donc simplement l'interface de base Spring Batch ItemProcessor. Notre Processor se chargera d'agréger les données InputData lues par le Reader dans un autre objet ConvertedInputData dans lequel elles sont regroupées par entités (Product, Purchaser, etc.) en veillant à ne pas en créer une si elle existe déjà en base.

V-G - La classe Writer

1. package com.gkemayo.batch.writer;

3. import java.util.List;

5. import org.springframework.batch.item.ItemWriter;

6. import org.springframework.beans.factory.annotation.Autowired;

8. import com.gkemayo.batch.dto.ConvertedInputData;

9. import com.gkemayo.batch.entities.Supplier;

10. import com.gkemayo.batch.entities.Product;

11. import com.gkemayo.batch.entities.Purchaser;

12. import com.gkemayo.batch.entities.PurchaseDate;

13. import com.gkemayo.batch.entitiesrepository.SupplierRepository;

14. import com.gkemayo.batch.entitiesrepository.OrderRepository;

15. import com.gkemayo.batch.entitiesrepository.ProductRepository;

16. import com.gkemayo.batch.entitiesrepository.PurchaserRepository;

17. import com.gkemayo.batch.entitiesrepository.PurchaseDateRepository;

19. public class BatchWriter implements ItemWriter<ConvertedInputData> {

21. @Autowired

22. private SupplierRepository supplierRepository;

24. @Autowired

25. private PurchaserRepository purchaserRepository;

27. @Autowired

28. private ProductRepository productRepository;

30. @Autowired

31. private PurchaseDateRepository purchaseDateRepository;

33. @Autowired

34. private OrderRepository commandRepository;

36. @Override

37. public void write(List<? extends ConvertedInputData> items) throws Exception {

38. items.stream().forEach(item -> {

39. Supplier supplier = null;

40. Purchaser purchaser = null;

41. Product product = null;

42. PurchaseDate purchaseDate = null;

43. if(item.getOrder().getSupplierId() == null) {

44. supplier = supplierRepository.save(item.getSupplier());

45. item.getOrder().setSupplierId(supplier.getId());

46. }

47. if(item.getOrder().getPurchaserId() == null) {

48. purchaser = purchaserRepository.save(item.getPurchaser());

49. item.getOrder().setPurchaserId(purchaser.getId());

50. }

51. if(item.getOrder().getProductId() == null) {

52. product = productRepository.save(item.getProduct());

53. item.getOrder().setProductId(product.getId());

54. }

55. if(item.getOrder().getDateId() == null) {

56. purchaseDate = purchaseDateRepository.save(item.getPurchaseDate());

57. item.getOrder().setDateId(purchaseDate.getId());

58. }

59. commandRepository.save(item.getOrder());

60. });

61. }

63. }

Explications

Spring Batch offre enfin plusieurs classes de type Writer en fonction des besoins : ItemWriter, HibernateItemWriter, FlatFileItemWriter, JmsItemWriter, JpaItemWriter, KafkaItemWriter, MongoItemWriter, etc. Pour plus de détails, regarder le lien suivant.
Notre classe BatchWriter implémente l'interface de base ItemWriter et effectue des enregistrements platoniques en base.

V-H - La classe SkipPolicy

1. package com.gkemayo.batch.batchutils;

3. import org.slf4j.Logger;

4. import org.slf4j.LoggerFactory;

5. import org.springframework.batch.core.step.skip.SkipLimitExceededException;

6. import org.springframework.batch.core.step.skip.SkipPolicy;

7. import org.springframework.batch.item.file.FlatFileParseException;

9. import lombok.extern.slf4j.Slf4j;

11. @Slf4j

12. public class BatchStepSkipper implements SkipPolicy {

14. Logger log = LoggerFactory.getLogger(BatchStepSkipper.class);

16. private static Integer SKIP_THRESHOLD = 3;

18. @Override

19. public boolean shouldSkip(Throwable t, int skipCount) throws SkipLimitExceededException {

20. if(t instanceof FlatFileParseException && skipCount < SKIP_THRESHOLD) {

21. log.info(((FlatFileParseException) t).getLineNumber() + ": " +((FlatFileParseException) t).getInput() + " -- " + ((FlatFileParseException) t).getMessage());

22. return true;

23. }

24. return false;

25. }

29. }

Explications

Pour qu'une classe soit vue par Spring Batch comme une classe de gestion de la tolérance aux fautes, il faut qu'elle implémente l'interface SkipPolicy. C'est le cas de notre classe BatchStepSkipper. Cette classe implémentera ainsi la méthode shouldSkip() dans laquelle on indiquera de tolérer au plus trois fois des erreurs de type FlatFileParseException dans un fichier d'entrées lu par le BatchReader.

V-I - La classe Listener

1. package com.gkemayo.batch.batchutils;

3. import org.slf4j.Logger;

4. import org.slf4j.LoggerFactory;

5. import org.springframework.batch.core.JobExecution;

6. import org.springframework.batch.core.JobExecutionListener;

8. import lombok.extern.slf4j.Slf4j;

10. @Slf4j

11. public class BatchJobListener implements JobExecutionListener {

13. Logger log = LoggerFactory.getLogger(BatchJobListener.class);

15. @Override

16. public void beforeJob(JobExecution jobExecution) {

17. log.info("Begining of job  " + jobExecution.getJobInstance().getJobName() + " at " + jobExecution.getStartTime());

18. }

20. @Override

21. public void afterJob(JobExecution jobExecution) {

22. String exitCode = jobExecution.getExitStatus().getExitCode();

23. log.info("End of job  " + jobExecution.getJobInstance().getJobName() + " at " + jobExecution.getEndTime() + " with status " + exitCode);

24. }

26. }

Explications

Spring Batch propose plusieurs types de Listener pour chacun de ces composants. On peut citer le JobExecutionListener, StepExecutionListener, ItemReadListener, ItemProcessListener, ItemWriteListener, SkipListener. Pour rappel, un Listener Spring Batch est une Interface qui offre des méthodes standards qui permettront au développeur d'ajouter sa propre implémentation à l'effet d'observer et de journaliser les évènements qui surviennent dans un composant durant l'exécution d'une instance du Batch. Son utilisation est facultative.
Pour notre exemple, nous avons implémenté la classe BatchJobListener qui sera associée au Job du Batch. Elle a pour but de dire à quelle heure le job s'est démarré, et dans quel état et à quelle heure il s'est terminé.

VI - Le Test Unitaire/Intégration

Le test unitaire est une procédure qui permet de vérifier que le fonctionnement de chaque méthode développée dans un programme correspond aux besoins attendus. Quant au test d'intégration, il permet de vérifier le bon fonctionnement de l'intercommunication entre différents composants intégrés ensemble dans le programme. Pour y arriver, en général il faut mettre en place des configurations donnant la possibilité de réaliser ces tests. Spring Boot comme Spring Batch offrent des outils qui facilitent l'écriture de tests. Nous allons réaliser un petit test d'intégration pour notre exemple. Nous vous laissons le soin de vous en inspirer pour aller plus loin.

VI-A - Configurations requises

Pour faire fonctionner notre test, la capture ci-dessous montre à travers le rectangle au trait rouge les configurations que nous allons réaliser :

VI-A-1 - application-test.properties

1. ############# DataSource Config #################

2. spring.datasource.name=datawarehouse-db-test

3. spring.datasource.username=sa

4. spring.datasource.password=

5. spring.datasource.url= jdbc:h2:mem:datawarehouse-db-test

6. spring.datasource.driver-class-name=org.h2.Driver

7. spring.datasource.sql-script-encoding= UTF-8

9. spring.datasource.schema = classpath:schema/datawarehouse-schema.sql

11. spring.h2.console.enabled=true

12. spring.h2.console.path=/h2-console

13. #http://localhost:8080/h2-console/

15. path.to.the.work.dir=./src/test/resources/reports-repository

Explicatioons :

Par défaut, Spring Boot en environnement de test chargera le contexte Spring de l'application (à savoir la classe BatchDatawarehouseLoaderApplication), mais aussi le fichier de configuration application.properties que nous avons présenté précédemment. Une conséquence de laisser les choses telles qu'elles, sera que vous pourrez via votre test laisser écrire des données pourries dans votre base de données de production. C'est pourquoi Spring Boot donne la possibilité de définir un fichier de configuration propre au test qui conventionnellement est défini sous le format application-yyy.properties. yyy correspond à ce qu'on appelle un profile et dans notre cas, il est égal à test.

Dans notre fichier application-test.properties ci-dessus, nous redéfinissons presque tous les paramètres utiles qui ont été déclarés dans l'application.properties. On peut y retenir deux choses : l'utilisation d'une base de données mémoire H2 (datawarehouse-db-test) pour notre test, et la définition d'un dossier devant contenir les jeux de données de notre test, à savoir quelques fichiers que doit lire le batch. Ce dossier est placé directement dans le classpath de l'application pour lui permettre de le rejouer autant de fois que possible sans aucun problème de portabilité (./src/test/resources/reports-repository).

VI-A-2 - Le dossier reports-repository

Il contient comme on peut le voir sur la figure de la section VI-A, nos trois fichiers de JDD donc voici le contenu :

Fichier 1 (contenant deux lignes en erreur):

1. PRDT_NAME;PRDT_EAN_CODE;PRDT_TYPE;PRDT_QTE;PRDT_AMOUNT;SUPPLIER_NAME;SUPPLIER_ADDRESS;PURCHASER_FIRST_NAME;PURCHASER_LAST_NAME;PURCHASER_EMAIL;TRANSACTION_DATE

2. ZenPhone5;EAN2918098;Phone;2;300.0;ASUS;7 Place Vendome Paris France;Eric;Dupont;ericdupont@yopmail.com;2019-12-18T17:09:42.411

3. XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

4. YYYYYYYYYYYYYYYYYYYYYY

Fichier 2 :

1. PRDT_NAME;PRDT_EAN_CODE;PRDT_TYPE;PRDT_QTE;PRDT_AMOUNT;SUPPLIER_NAME;SUPPLIER_ADDRESS;PURCHASER_FIRST_NAME;PURCHASER_LAST_NAME;PURCHASER_EMAIL;TRANSACTION_DATE

2. ZenPhone5;EAN2918098;Phone;2;300.0;ASUS;7 Place Vendome Paris France;Eric;Dupont;ericdupont@yopmail.com;2019-12-15T17:09:42.411

Fichier 3 :

1. PRDT_NAME;PRDT_EAN_CODE;PRDT_TYPE;PRDT_QTE;PRDT_AMOUNT;SUPPLIER_NAME;SUPPLIER_ADDRESS;PURCHASER_FIRST_NAME;PURCHASER_LAST_NAME;PURCHASER_EMAIL;TRANSACTION_DATE

2. USBZEN;EAN10000;USB KEY;8;15,99;Cdiscount;27 Boulevard des Nations Nantes France;Eric;Dupont;ericdupont@yopmail.com;2019-12-15

3. CameraZEN;EAN5000;Camera;12;160,57;Cdiscount;27 Boulevard des Nations Nantes France;Samuel;Marimont;samuelmarimont@yopmail.com;2019-12-15

VI-B - La classe de test

1. package com.gkemayo.batch;

3. import org.junit.Assert;

4. import org.junit.jupiter.api.Test;

5. import org.junit.runner.RunWith;

6. import org.springframework.batch.core.BatchStatus;

7. import org.springframework.batch.core.JobExecution;

8. import org.springframework.batch.test.JobLauncherTestUtils;

9. import org.springframework.batch.test.context.SpringBatchTest;

10. import org.springframework.beans.factory.annotation.Autowired;

11. import org.springframework.boot.test.context.SpringBootTest;

12. import org.springframework.test.context.ActiveProfiles;

13. import org.springframework.test.context.TestPropertySource;

14. import org.springframework.test.context.junit4.SpringRunner;

16. @RunWith(SpringRunner.class)

17. @SpringBootTest

18. @SpringBatchTest

19. @ActiveProfiles("test")

20. @TestPropertySource(locations = "classpath:application-test.properties")

21. class BatchDatawarehouseLoaderApplicationTests {

23. @Autowired

24. JobLauncherTestUtils jobLaucherTestUtils;

26. @Test

27. public void testBatchDatawarehouseLoader() throws Exception {

28. JobExecution jobExecution = jobLaucherTestUtils.launchJob();

30. Assert.assertEquals(BatchStatus.COMPLETED, jobExecution.getStatus());

31. }

32. }

Explications

- @RunWith(SpringRunner.class) : invoque le runner SpringRunner pour notre classe de test.

- @SpringBootTest : utilisé en environnement Spring Boot et invoque dans notre classe de test : le contexte d'application Spring, JUnit, les outils de bouchonnage tels que MockBean, etc.

- @SpringBatchTest : donne la possibilité d'utiliser dans notre classe de test, des objets Spring Batch conçus pour faire du test tel JobLauncherTestUtils. JobLauncherTestUtils est une classe Spring Batch disposant des fonctionnalités permettant de lancer dans les conditions réelles un Batch dans un test d'intégration.

- @ActiveProfiles(« test ») : active le profile test pour notre la classe de test.

- @TestPropertySource(locations = « classpath:application-test.properties ») : permet que le contexte d'application Spring de notre test utilise les propriétés contenues dans le fichier application-test.properties.

VII - Démo de l'application

Animation en format "mp4" non supportée.
Contenu uniquement consultable en ligne à cette adresse :
https://gkemayo.developpez.com/tutoriels/java/tutoriel-sur-mise-oeuvre-spring-batch-avec-spring-boot/springbatch-demo.mp4

VIII - Accéder au code source

Le code source de l'application se trouve ici : https://gitlab.com/gkemayo/datawarehouse-loader-batch.

IX - Conclusion et perspectives

Il existe dans ce forum, d'excellents tutoriels qui ont déjà écrit sur le framework Spring Batch. Vous pouvez les consulter ici. Vous pourrez d'ailleurs compléter les notions que vous aurez apprises dans cet article en lisant celles de ces tutoriels. Chacun d'entre eux présente certains concepts précis du framework que nous n'avons pu aborder ici. Notamment par exemple, l'autonettoyage de Spring Batch, la notion de Tasklet, la parallélisation des traitements Spring Batch, le scheduling automatisé de Batch, etc. Dans ces différents tutoriels, vous apprendrez comment utiliser Spring Batch en dehors de Spring Boot, ce qui est un peu l'ancienne école dans un monde où Spring Boot a tendance à devenir incontournable dans l'écosystème Spring.

Au terme de notre article donc, nous vous avons présenté comment utiliser Spring Batch via Spring Boot pour résoudre un problème de traitement par lot sur un exemple d'application. Notre souci majeur avant tout a été d'abord de vous montrer comment on schématise conceptuellement une problématique de traitement par lot et comment Spring Batch se positionne dans ce schéma (cf. figure de la section II). Cela parce que nous avons remarqué que beaucoup de tutoriels existants autour de Spring Batch, entrent directement dans les aspects techniques du framework sans jamais se préoccuper de l'immersion du lecteur dans la problématique du traitement par lot. Nous pensons que c'est un élément important qui donne les armes mentales à quelqu'un qui débute de garder un fil conducteur. Nous vous avons aussi présenté comment utiliser Spring Batch dans l'écosystème Spring Boot afin de tirer profit des avantages de ce dernier qui peuvent se résumer à l'autoconfiguration et l'amélioration de la productivité. Enfin, nous rappelons que toutes les configurations de beans sont faites en JavaConfig et non en XML. Ce qui est plutôt la tendance actuellement.

Pour finir et comme nous le disions, nous avons utilisé un exemple d'application pour guider cet article. Un exemple d'application ne pouvant permettre d'aborder de façon exhaustive les contours de Spring Batch, nous nous sommes focalisés sur les fonctionnalités du framework qui permettent de résoudre notre problème. Nous avons mis en avant la structuration d'un batch construit avec Spring Batch, nous avons donné les avantages et les inconvénients de ce dernier, nous avons présenté théoriquement et techniquement tous les concepts Spring Batch utilisés dans cet article en tâchant de faire un petit état de l'art d'autres concepts connexes non abordés dans cet article. Notamment sur les différentes classes d'implémentation possibles des interfaces ItemReader, ItemProcessor et ItemWriter. Ensuite, notre exemple nous a amenés à aborder de façon succincte la notion d'entrepôt de données (data warehouse) que vous pourrez approfondir au travers du lien de référence donné dans la section suivante. Nous avons également profité pour vous montrer l'utilisation des frameworks tels que Lombok ou encore Spring Data JDBC qui ont concouru à la construction complète de notre application. Nous avons terminé en présentant comment construire un test d'intégration de notre projet Spring Batch.

X - References

- https://spring.io/projects/spring-batch

- https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-documentation

- https://gkemayo.developpez.com/tutoriels/java/tutoriel-sur-creation-application-web-avec-angular7-et-spring-boot-2/?page=creation-du-projet-spring-boot#LIII

- https://docs.spring.io/spring-batch/docs/current/reference/html/schema-appendix.html

- https://www.cartelis.com/blog/data-warehouse-modelisation-etoile/

- Spring Data JDBC : https://spring.io/blog/2018/09/17/introducing-spring-data-jdbc

- Spring Data JPA : https://docs.spring.io/spring-data/jpa/docs/1.5.0.RELEASE/reference/html/repositories.html

- Appendix A. Common application properties

- https://docs.spring.io/spring-batch/docs/current-SNAPSHOT/reference/html/appendix.html

XI - Remerciements

Je voudrais dire un grand merci à :

- Mickael Baron pour sa relecture technique et pour ses remarques
- Claude Leloup et à escartefigue pour la relecture orthographique