Spring Batch - Guide rapide

Batch processingest un mode de traitement qui implique l'exécution de séries de travaux complexes automatisés sans interaction de l'utilisateur. Un processus par lots gère les données en masse et s'exécute pendant une longue période.

Plusieurs applications d'entreprise nécessitent de traiter d'énormes données pour effectuer des opérations impliquant -

• Événements temporels tels que les calculs périodiques.

• Applications périodiques traitées de manière répétitive sur de grands ensembles de données.

• Applications traitant du traitement et de la validation des données disponibles de manière transactionnelle.

Par conséquent, le traitement par lots est utilisé dans les applications d'entreprise pour effectuer de telles transactions.

Qu'est-ce que Spring Batch

Le lot de printemps est un lightweight framework qui est utilisé pour développer Batch Applications qui sont utilisés dans les applications d'entreprise.

En plus du traitement en masse, ce framework fournit des fonctions pour -

• Y compris la journalisation et le traçage
• Gestion des transactions
• Statistiques de traitement des travaux
• Redémarrage du travail
• Gestion des sauts et des ressources

Vous pouvez également mettre à l'échelle des applications par lots de ressorts en utilisant ses techniques de portionnement.

Caractéristiques de Spring Batch

Voici les caractéristiques notables de Spring Batch -

• Flexibility- Les applications Spring Batch sont flexibles. Il vous suffit de modifier un fichier XML pour modifier l'ordre de traitement dans une application.

• Maintainability- Les applications Spring Batch sont faciles à entretenir. Un travail Spring Batch comprend des étapes et chaque étape peut être découplée, testée et mise à jour, sans affecter les autres étapes.

• Scalability- En utilisant les techniques de portionnement, vous pouvez mettre à l'échelle les applications Spring Batch. Ces techniques vous permettent de -

  • Exécutez les étapes d'un travail en parallèle.

  • Exécutez un seul thread en parallèle.

• Reliability - En cas d'échec, vous pouvez redémarrer le travail exactement là où il a été arrêté, en découplant les étapes.

• Support for multiple file formats - Spring Batch prend en charge un grand nombre de lecteurs et d'écrivains tels que XML, Flat file, CSV, MYSQL, Hibernate, JDBC, Mongo, Neo4j, etc.

• Multiple ways to launch a job - Vous pouvez lancer une tâche Spring Batch à l'aide d'applications Web, de programmes Java, de ligne de commande, etc.

En plus de cela, les applications Spring Batch prennent en charge -

• Nouvelle tentative automatique après échec.

• Suivi de l'état et des statistiques pendant l'exécution du lot et après la fin du traitement par lots.

• Pour exécuter des travaux simultanés.

• Services tels que la journalisation, la gestion des ressources, le saut et le redémarrage du traitement.

Dans ce chapitre, nous expliquerons comment définir l'environnement Spring Batch dans Eclipse IDE. Avant de procéder à l'installation, assurez-vous que vous avez installé Eclipse sur votre système. Sinon, téléchargez et installez Eclipse dans votre système.

Pour plus d'informations sur Eclipse, veuillez consulter notre Tutoriel Eclipse.

Définition de Spring Batch sur Eclipse

Suivez les étapes ci-dessous pour définir l'environnement Spring Batch sur Eclipse.

Step 1 - Installez Eclipse et ouvrez un nouveau projet comme indiqué dans la capture d'écran suivante.

Step 2 - Créez un exemple de projet Spring Batch comme indiqué ci-dessous.

Step 3- Cliquez avec le bouton droit sur le projet et convertissez-le en projet Maven comme indiqué ci-dessous. Une fois que vous l'avez converti en projet Maven, il vous donnera unPom.xmloù vous devez mentionner les dépendances requises. Par la suite, lejar les fichiers de ceux-ci seront automatiquement téléchargés dans votre projet.

Step 4 - Maintenant, dans le pom.xml du projet, copiez et collez le contenu suivant (dépendances pour l'application Spring batch) et actualisez le projet.

<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 
   http://maven.apache.org/maven-v4_0_0.xsd"> 
   <modelVersion>4.0.0</modelVersion> 
   <groupId>com.tutorialspoint</groupId> 
   <artifactId>SpringBatchSample</artifactId> 
   <packaging>jar</packaging> 
   <version>1.0-SNAPSHOT</version> 
   <name>SpringBatchExample</name>
   <url>http://maven.apache.org</url>  
 
   <properties> 
      <jdk.version>1.8</jdk.version> 
      <spring.version>4.3.8.RELEASE</spring.version> 
      <spring.batch.version>3.0.7.RELEASE</spring.batch.version> 
      <mysql.driver.version>5.1.25</mysql.driver.version> 
      <junit.version>4.11</junit.version> 
   </properties>  
   
   <dependencies> 
      <!-- Spring Core --> 
      <dependency> 
         <groupId>org.springframework</groupId> 
         <artifactId>spring-core</artifactId> 
         <version>${spring.version}</version> 
      </dependency>  
      
      <!-- Spring jdbc, for database --> 
      <dependency> 
         <groupId>org.springframework</groupId> 
         <artifactId>spring-jdbc</artifactId> 
         <version>${spring.version}</version> 
      </dependency>  
      
      <!-- Spring XML to/back object --> 
      <dependency> 
         <groupId>org.springframework</groupId> 
         <artifactId>spring-oxm</artifactId> 
         <version>${spring.version}</version> 
      </dependency>  
   
      <!-- MySQL database driver --> 
      <dependency> 
         <groupId>mysql</groupId> 
         <artifactId>mysql-connector-java</artifactId>
         <version>${mysql.driver.version}</version> 
      </dependency>  
  
      <!-- Spring Batch dependencies --> 
      <dependency> 
         <groupId>org.springframework.batch</groupId> 
         <artifactId>spring-batch-core</artifactId> 
         <version>${spring.batch.version}</version> 
      </dependency> 
  
      <dependency> 
         <groupId>org.springframework.batch</groupId> 
         <artifactId>spring-batch-infrastructure</artifactId> 
         <version>${spring.batch.version}</version> 
      </dependency>  
  
      <!-- Spring Batch unit test --> 
      <dependency> 
         <groupId>org.springframework.batch</groupId> 
         <artifactId>spring-batch-test</artifactId> 
         <version>${spring.batch.version}</version> 
      </dependency>  
  
      <!-- Junit --> 
      <dependency> 
         <groupId>junit</groupId> 
         <artifactId>junit</artifactId> 
         <version>${junit.version}</version> 
         <scope>test</scope> 
      </dependency> 
   </dependencies> 
 
   <build> 
      <finalName>spring-batch</finalName> 
      <plugins> 
         <plugin> 
            <groupId>org.apache.maven.plugins</groupId> 
            <artifactId>maven-eclipse-plugin</artifactId>
            <version>2.9</version> 
            <configuration> 
               <downloadSources>true</downloadSources> 
               <downloadJavadocs>false</downloadJavadocs> 
            </configuration> 
         </plugin> 
      
         <plugin> 
            <groupId>org.apache.maven.plugins</groupId> 
            <artifactId>maven-compiler-plugin</artifactId> 
            <version>2.3.2</version> 
            <configuration> 
               <source>${jdk.version}</source> 
               <target>${jdk.version}</target> 
            </configuration> 
         </plugin> 
      </plugins> 
   </build> 
</project>

Enfin, si vous observez les dépendances Maven, vous pouvez observer que toutes les jar les fichiers ont été téléchargés.

Voici la représentation schématique de l'architecture de Spring Batch. Comme le montre la figure, l'architecture contient trois composants principaux à savoir,Application, Batch Core, et Batch Infrastructure.

Application - Ce composant contient tous les jobs et le code que nous écrivons à l'aide du framework Spring Batch.

Batch Core - Ce composant contient toutes les classes d'API nécessaires pour contrôler et lancer un travail par lots.

Batch Infrastructure - Ce composant contient les lecteurs, les rédacteurs et les services utilisés par les composants principaux de l'application et de Batch.

Composants de Spring Batch

L'illustration suivante montre les différents composants de Spring Batch et comment ils sont connectés les uns aux autres.

Emploi

Dans une application Spring Batch, un travail est le processus par lots qui doit être exécuté. Il fonctionne du début à la fin sans interruption. Ce travail est divisé en étapes (ou un travail contient des étapes).

Nous allons configurer un travail dans Spring Batch à l'aide d'un fichier XML ou d'une classe Java. Voici la configuration XML d'un Job dans Spring Batch.

<job id = "jobid"> 
   <step id = "step1" next = "step2"/> 
   <step id = "step2" next = "step3"/> 
   <step id = "step3"/> 
</job>

Un travail Batch est configuré dans les balises <job> </job>. Il a un attribut nomméid. Au sein de ces balises, nous définissons la définition et l'ordre des étapes.

Restartable - En général, lorsqu'un job est en cours et que nous essayons de le relancer, cela est restartet il sera recommencé. Pour éviter cela, vous devez définir lerestartable valeur à false comme indiqué ci-dessous.

<job id = "jobid" restartable = "false" >

</job>

Étape

UNE step est une partie indépendante d'un travail qui contient les informations nécessaires pour définir et exécuter le travail (sa partie).

Comme spécifié dans le diagramme, chaque étape est composée d'un ItemReader, d'un ItemProcessor (facultatif) et d'un ItemWriter. A job may contain one or more steps.

Lecteurs, rédacteurs et processeurs

Un item reader lit les données dans une application Spring Batch à partir d'une source particulière, alors qu'un item writer écrit les données de l'application Spring Batch vers une destination particulière.

Un Item processorest une classe qui contient le code de traitement qui traite les données lues dans le lot de ressorts. Si l'application lit"n" enregistrements, puis le code dans le processeur sera exécuté sur chaque enregistrement.

Lorsqu'aucun lecteur ni écrivain n'est donné, un taskletagit en tant que processeur pour SpringBatch. Il ne traite qu'une seule tâche. Par exemple, si nous écrivons un travail avec une étape simple dans laquelle nous lisons les données de la base de données MySQL et les traitons et les écrivons dans un fichier (plat), alors notre étape utilise -

• UNE reader qui lit à partir de la base de données MySQL.

• UNE writer qui écrit dans un fichier plat.

• UNE custom processor qui traite les données selon notre souhait.

<job id = "helloWorldJob"> 
   <step id = "step1"> 
      <tasklet> 
         <chunk reader = "mysqlReader" writer = "fileWriter" 
            processor = "CustomitemProcessor" ></chunk> 
      </tasklet> 
   </step> 
</ job>

Spring Batch fournit une longue liste de readers et writers. En utilisant ces classes prédéfinies, nous pouvons définir des beans pour elles. Nous discuteronsreaders et writers plus en détail dans les prochains chapitres.

JobRepository

Un référentiel de travaux dans Spring Batch fournit des opérations de création, de récupération, de mise à jour et de suppression (CRUD) pour les implémentations JobLauncher, Job et Step. Nous définirons un référentiel de travaux dans un fichier XML comme indiqué ci-dessous.

<job-repository id = "jobRepository"/>

En plus de id, d'autres options (facultatives) sont disponibles. Voici la configuration du référentiel de travaux avec toutes les options et leurs valeurs par défaut.

<job-repository id = "jobRepository" 
   data-source = "dataSource" 
   transaction-manager = "transactionManager" 
   isolation-level-for-create = "SERIALIZABLE" 
   table-prefix = "BATCH_" 
   max-varchar-length = "1000"/>

In-Memory Repository - Si vous ne souhaitez pas conserver les objets de domaine du Spring Batch dans la base de données, vous pouvez configurer la version en mémoire du jobRepository comme indiqué ci-dessous.

<bean id = "jobRepository" 
   class = "org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean ">
   <property name = "transactionManager" ref = "transactionManager"/>
</bean>

JobLauncher

JobLauncher est une interface qui lance le travail Spring Batch avec le given set of parameters. SampleJoblauncher est la classe qui implémente le JobLauncherinterface. Voici la configuration du JobLauncher.

<bean id = "jobLauncher" 
   class = "org.springframework.batch.core.launch.support.SimpleJobLauncher"> 
   <property name = "jobRepository" ref = "jobRepository" /> 
</bean>

JobInstance

UNE JobInstancereprésente l'exécution logique d'un travail; il est créé lorsque nous exécutons un travail. Chaque instance de travail est différenciée par le nom du travail et les paramètres qui lui sont transmis lors de l'exécution.

Si une exécution de JobInstance échoue, la même JobInstance peut être exécutée à nouveau. Par conséquent, chaque JobInstance peut avoir plusieurs exécutions de travaux.

JobExecution et StepExecution

JobExecution et StepExecution sont la représentation de l'exécution d'un travail / d'une étape. Ils contiennent les informations d'exécution du travail / de l'étape telles que l'heure de début (du travail / de l'étape), l'heure de fin (du travail / de l'étape).

Presque tous les exemples de ce didacticiel contiennent les fichiers suivants -

• Fichier de configuration (fichier XML)
• Tasklet / processeur (classe Java)
• Classe Java avec setters et getters (classe Java (bean))
• Classe Mapper (classe Java)
• Classe Launcher (classe Java)

Fichier de configuration

Le fichier de configuration (XML) contient les éléments suivants -

• le job et step définitions.

• Définition des haricots readers et writers.

• Définition de composants tels que JobLauncher, JobRepository, Transaction Manager et Data Source.

Dans nos exemples, pour une meilleure compréhension, nous avons divisé cela en deux fichiers le job.xml fichier (définit le travail, l'étape, le lecteur et l'écrivain) et context.xml fichier (lanceur de travaux, référentiel de travaux, gestionnaire de transactions et source de données).

Classe de mappeur

La classe Mapper, selon le lecteur, implémente des interfaces telles que row mapper, field set mapper, etc. Il contient le code permettant d'obtenir les données du lecteur et de le définir sur une classe Java avec setter et getter méthodes (Java Bean).

Classe Java Bean

Une classe Java avec setters et getters(Java bean) représente des données avec plusieurs valeurs. Il agit comme une classe d'assistance. Nous passerons les données d'un composant (lecteur, écrivain, processeur) à l'autre sous forme d'objet de cette classe.

Tasklet / processeur

La classe Tasklet / processor contient le code de traitement de l'application Spring Batch. Un processeur est une classe qui accepte un objet contenant les données lues, les traite et renvoie les données traitées (dans l'objet de formulaire).

Classe de lanceur

Cette classe (App.java) contient le code pour lancer l'application Spring Batch.

Lors de l'écriture d'une application Spring Batch, nous configurerons le travail, l'étape, le JobLauncher, le JobRepository, le Gestionnaire de transactions, les lecteurs et les rédacteurs à l'aide des balises XML fournies dans l'espace de noms Spring Batch. Par conséquent, vous devez inclure cet espace de noms dans votre fichier XML comme indiqué ci-dessous.

<beans xmlns = "http://www.springframework.org/schema/beans" 
   xmlns:batch = "http://www.springframework.org/schema/batch" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xsi:schemaLocation = "http://www.springframework.org/schema/batch 

   http://www.springframework.org/schema/batch/spring-batch-2.2.xsd 
   http://www.springframework.org/schema/bean   
   http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

Dans les sections suivantes, nous aborderons les différentes balises, leurs attributs et exemples, disponibles dans l'espace de noms Spring Batch.

Emploi

Cette balise est utilisée pour définir / configurer le travail du SpringBatch. Il contient un ensemble d'étapes et peut être lancé à l'aide du JobLauncher.

Cette balise a 2 attributs comme listés ci-dessous -

S. Non	Attribut et description
1	Id C'est l'Id du job, il est obligatoire de spécifier la valeur de cet attribut.
2	restartable Il s'agit de l'attribut utilisé pour spécifier si le travail peut être redémarré ou non. Cet attribut est facultatif.

Voici la configuration XML du travail d'un SpringBatch.

<job id = "jobid" restartable = "false" > 
   . . . . . . . .  
   . . . . . . . .  
   . . . . . . . . // Step definitions 
</job>

Étape

Cette balise est utilisée pour définir / configurer les étapes d'un travail SpringBatch. Il a les trois attributs suivants -

S. Non	Attribut et description
1	Id C'est l'Id du job, il est obligatoire de spécifier la valeur de cet attribut.
2	next C'est le raccourci pour spécifier l'étape suivante.
3	parent Il est utilisé pour spécifier le nom du bean parent dont la configuration doit hériter.

Voici la configuration XML de l'étape d'un SpringBatch.

<job id = "jobid"> 
   <step id = "step1" next = "step2"/> 
   <step id = "step2" next = "step3"/> 
   <step id = "step3"/> 
</job>

Tronçon

Cette balise est utilisée pour définir / configurer un morceau d'un tasklet. Il a les quatre attributs suivants -

S. Non	Attribut et description
1	reader Il représente le nom du bean de lecture d'élément. Il accepte la valeur du typeorg.springframework.batch.item.ItemReader.
2	writer Il représente le nom du bean de lecture d'élément. Il accepte la valeur du typeorg.springframework.batch.item.ItemWriter.
3	processor Il représente le nom du bean de lecture d'élément. Il accepte la valeur du typeorg.springframework.batch.item.ItemProcessor.
4	commit-interval Il est utilisé pour spécifier le nombre d'articles à traiter avant de valider la transaction.

Voici la configuration XML du morceau d'un SpringBatch.

<batch:step id = "step1"> 
   <batch:tasklet> 
      <batch:chunk reader = "xmlItemReader" 
         writer = "mysqlItemWriter" processor = "itemProcessor" commit-interval = "10"> 
      </batch:chunk> 
   </batch:tasklet> 
</batch:step>

JobRepository

Le JobRepository Bean est utilisé pour configurer le JobRepository à l'aide d'une base de données relationnelle. Ce bean est associé à la classe de typeorg.springframework.batch.core.repository.JobRepository.

S. Non	Attribut et description
1	dataSource Il est utilisé pour spécifier le nom du bean qui définit la source de données.
2	transactionManager Il est utilisé pour spécifier le nom du bean qui définit le gestionnaire de transaction.
3	databaseType Il spécifie le type de base de données relationnelle utilisée dans le référentiel de travaux.

Voici l'exemple de configuration du JobRepository.

<bean id = "jobRepository" 
   class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean"> 
   <property name = "dataSource" ref = "dataSource" /> 
   <property name = "transactionManager" ref="transactionManager" /> 
   <property name = "databaseType" value = "mysql" /> 
</bean>

JobLauncher

Le bean JobLauncher est utilisé pour configurer le JobLauncher. Il est associé à la classeorg.springframework.batch.core.launch.support.SimpleJobLauncher(dans nos programmes). Ce bean a une propriété nomméejobrepository, et il est utilisé pour spécifier le nom du bean qui définit le jobrepository.

Voici l'exemple de configuration du jobLauncher.

<bean id = "jobLauncher" 
   class = "org.springframework.batch.core.launch.support.SimpleJobLauncher"> 
   <property name = "jobRepository" ref = "jobRepository" /> 
</bean>

TransactionManager

Le bean TransactionManager est utilisé pour configurer le TransactionManager à l'aide d'une base de données relationnelle. Ce bean est associé à la classe de typeorg.springframework.transaction.platform.TransactionManager.

<bean id = "transactionManager"
   class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />

La source de données

Le bean de source de données est utilisé pour configurer le Datasource. Ce bean est associé à la classe de typeorg.springframework.jdbc.datasource.DriverManagerDataSource.

S. Non	Attribut et description
1	driverClassName Ceci spécifie le nom de classe du pilote utilisé pour se connecter à la base de données.
2	url Cela spécifie l'URL de la base de données.
3	username Cela spécifie le nom d'utilisateur pour se connecter à la base de données.
4	password Cela spécifie le mot de passe pour se connecter à la base de données.

Voici l'exemple de configuration du datasource.

<bean id = "dataSource" 
   class = "org.springframework.jdbc.datasource.DriverManagerDataSource"> 
   <property name = "driverClassName" value = "com.mysql.jdbc.Driver" /> 
   <property name = "url" value = "jdbc:mysql://localhost:3306/details" /> 
   <property name = "username" value = "myuser" /> 
   <property name = "password" value = "password" /> 
</bean>

Un Item Reader lit les données dans l'application Spring batch à partir d'une source particulière, alors qu'un Item Writer écrit les données de l'application Spring Batch vers une destination particulière.

Un Item processorest une classe qui contient le code de traitement qui traite les données lues dans le lot de ressorts. Si l'application lit n enregistrements, le code dans le processeur sera exécuté sur chaque enregistrement.

UNE chunk est un élément enfant de tasklet. Il est utilisé pour effectuer des opérations de lecture, d'écriture et de traitement. Nous pouvons configurer le lecteur, l'écrivain et les processeurs en utilisant cet élément, dans une étape comme indiqué ci-dessous.

<batch:job id = "helloWorldJob"> 
   <batch:step id = "step1"> 
      <batch:tasklet> 
         <batch:chunk reader = "cvsFileItemReader" writer = "xmlItemWriter" 
            processor = "itemProcessor" commit-interval = "10"> 
         </batch:chunk> 
      </batch:tasklet> 
   </batch:step> 
</batch:job>

Spring Batch fournit des lecteurs et des rédacteurs pour lire et écrire des données de divers systèmes de fichiers / bases de données tels que MongoDB, Neo4j, MySQL, XML, flatfile, CSV, etc.

Pour inclure un lecteur dans votre application, vous devez définir un bean pour ce lecteur, fournir des valeurs à toutes les propriétés requises dans le bean et passer le id d'un tel bean comme valeur de l'attribut de l'élément chunk reader (pareil pour writer).

ItemReader

C'est l'entité d'une étape (d'un traitement par lots) qui lit les données. Un ItemReader lit un élément à la fois. Spring Batch fournit une interfaceItemReader. Tous lesreaders implémentez cette interface.

Voici quelques-unes des classes ItemReader prédéfinies fournies par Spring Batch pour lire à partir de diverses sources.

Lecteur	Objectif
FlatFIleItemReader	Pour lire des données à partir de fichiers plats.
StaxEventItemReader	Pour lire des données à partir de fichiers XML.
StoredProcedureItemReader	Pour lire des données à partir des procédures stockées d'une base de données.
JDBCPagingItemReader	Pour lire les données de la base de données de bases de données relationnelles.
MongoItemReader	Pour lire les données de MongoDB.
Neo4jItemReader	Pour lire les données de Neo4jItemReader.

Nous devons configurer le ItemReadersen créant les haricots. Voici un exemple deStaxEventItemReader qui lit les données d'un fichier XML.

<bean id = "mysqlItemWriter" 
   class = "org.springframework.batch.item.xml.StaxEventItemWriter"> 
   <property name = "resource" value = "file:xml/outputs/userss.xml" /> 
   <property name = "marshaller" ref = "reportMarshaller" /> 
   <property name = "rootTagName" value = "Tutorial" /> 
</bean> 

<bean id = "reportMarshaller" 
   class = "org.springframework.oxm.jaxb.Jaxb2Marshaller"> 
   <property name = "classesToBeBound"> 
      <list> 
         <value>Tutorial</value> 
      </list> 
   </property> 
</bean>

Comme observé, lors de la configuration, nous devons spécifier le nom de classe respectif du lecteur requis et nous devons fournir des valeurs à toutes les propriétés requises.

ItemWriter

C'est l'élément de la stepd'un traitement par lots qui écrit des données. Un ItemWriter écrit un élément à la fois. Spring Batch fournit une interfaceItemWriter. Tous les rédacteurs implémentent cette interface.

Voici quelques-unes des classes ItemWriter prédéfinies fournies par Spring Batch pour lire à partir de diverses sources.

Écrivain	Objectif
FlatFIleItemWriter	Pour écrire des données dans des fichiers plats.
StaxEventItemWriter	Pour écrire des données dans des fichiers XML.
StoredProcedureItemWriter	Pour écrire des données dans les procédures stockées d'une base de données.
JDBCPagingItemWriter	Pour écrire des données dans la base de données de bases de données relationnelles.
MongoItemWriter	Pour écrire des données dans MongoDB.
Neo4jItemWriter	Pour écrire des données dans Neo4j.

De la même manière, nous devons configurer les ItemWriters en créant les beans. Voici un exemple deJdbcCursorItemReader qui écrit des données dans une base de données MySQL.

<bean id = "dbItemReader"
   class = "org.springframework.batch.item.database.JdbcCursorItemReader" scope = "step">
   <property name = "dataSource" ref = "dataSource" />
   <property name = "sql" value = "select * from tutorialsdata" />
   <property name = "rowMapper">
      <bean class = "TutorialRowMapper" /> 
   </property>
</bean>

Processeur d'articles

ItemProcessor: Un ItemProcessor est utilisé pour traiter les données. Lorsque l'élément donné n'est pas valide, il retournenull, sinon il traite l'élément donné et renvoie le résultat traité. L'interfaceItemProcessor<I,O> représente le processeur.

Tasklet class - Quand non reader et writersont donnés, un Tasklet agit comme un processeur pour SpringBatch. Il ne traite qu'une seule tâche.

Nous pouvons définir un processeur d'élément personnalisé en implémentant l'interface ItemProcessor du forfait org.springframework.batch.item.ItemProcessor. Cette classe ItemProcessor accepte un objet, traite les données et renvoie les données traitées comme un autre objet.

Dans un processus par lots, si "n"les enregistrements ou éléments de données sont lus, puis pour chaque enregistrement, il lira les données, les traitera et les écrit dans l'enregistreur. Pour traiter les données, il relais sur le processeur passé.

Par exemple, supposons que vous ayez écrit du code pour charger un document PDF particulier, créer une nouvelle page, écrire la donnée élémentaire sur le PDF dans un format tabulaire. Si vous exécutez cette application, elle lit tous les éléments de données du document XML, les stocke dans la base de données MySQL et les imprime dans le document PDF donné dans des pages individuelles.

Exemple

Voici un exemple de classe ItemProcessor.

import org.springframework.batch.item.ItemProcessor;  

public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {  
   
   @Override 
   public Tutorial process(Tutorial item) throws Exception {  
      System.out.println("Processing..." + item); 
      return item; 
   } 
}

Ce chapitre vous présente l'application de base Spring Batch. Il exécutera simplement untasklet pour afficher un message.

Notre application Spring Batch contient les fichiers suivants -

• Configuration file- Il s'agit d'un fichier XML dans lequel nous définissons le Job et les étapes du job. (Si l'application implique également des lecteurs et des rédacteurs, alors la configuration dereaders et writers est également inclus dans ce fichier.)

• Context.xml - Dans ce fichier, nous définirons les beans comme le référentiel de travaux, le lanceur de travaux et le gestionnaire de transactions.

• Tasklet class - Dans cette classe, nous écrirons le travail de code de traitement (dans ce cas, il affiche un message simple)

• Launcher class - dans cette classe, nous lancerons l'application Batch en exécutant le lanceur de jobs.

jobConfig.xml

Voici le fichier de configuration de notre exemple d'application Spring Batch.

<beans xmlns = "http://www.springframework.org/schema/beans" 
   xmlns:batch = "http://www.springframework.org/schema/batch" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xsi:schemaLocation = "http://www.springframework.org/schema/batch 
      http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
      http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd "> 
   <import resource="context.xml" />      
   <!-- Defining a bean --> 
   <bean id = "tasklet" class = "a_sample.MyTasklet" />  
   <!-- Defining a job--> 
   <batch:job id = "helloWorldJob">  
      <!-- Defining a Step --> 
      <batch:step id = "step1"> 
         <tasklet ref = "tasklet"/>   
      </batch:step>    
   </batch:job>  
</beans>

Context.xml

Voici le context.xml de notre application Spring Batch.

<beans xmlns = "http://www.springframework.org/schema/beans" 
   xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
   
   <bean id = "jobRepository"   
      class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean"> 
      <property name = "transactionManager" ref = "transactionManager" /> 
   </bean>     
     
   <bean id = "transactionManager" 
      class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />  
   <bean id = "jobLauncher" 
      class = "org.springframework.batch.core.launch.support.SimpleJobLauncher"> 
      <property name = "jobRepository" ref = "jobRepository" /> 
   </bean> 
</beans>

Tasklet.java

Voici la classe Tasklet qui affiche un message simple.

import org.springframework.batch.core.StepContribution; 
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;  

public class MyTasklet implements Tasklet { 
   
   @Override 
   public RepeatStatus execute(StepContribution arg0, ChunkContext arg1) throws Exception {  
      System.out.println("Hello This is a sample example of spring batch"); 
      return RepeatStatus.FINISHED; 
   } 
}

App.java

Voici le code qui lance le traitement par lots.

import org.springframework.batch.core.Job; 
import org.springframework.batch.core.JobExecution; 
import org.springframework.batch.core.JobParameters; 
import org.springframework.batch.core.launch.JobLauncher; 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App { 
   public static void main(String[] args)throws Exception { 
  
      // System.out.println("hello"); 
      String[] springConfig  =  {"a_sample/job_hello_world.xml"};  
      
      // Creating the application context object  
      ApplicationContext context = new ClassPathXmlApplicationContext(springConfig); 
      
      // Creating the job launcher 
      JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher"); 
  
      // Creating the job 
      Job job = (Job) context.getBean("helloWorldJob"); 
  
      // Executing the JOB 
      JobExecution execution = jobLauncher.run(job, new JobParameters()); 
      System.out.println("Exit Status : " + execution.getStatus()); 
   }    
}

Lors de l'exécution, le programme SpringBatch ci-dessus produira la sortie suivante -

Apr 24, 2017 4:40:54 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh 
INFO:Refreshing org[email protected]2ef1e4fa: startup date [Mon Apr 24 16:40:54 IST 2017]; root of context hierarchy 
Apr 24, 2017 4:40:54 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions INFO: Loading XML bean definitions  
Apr 24, 2017 4:40:54 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions  
INFO: Loading XML bean definitions 
Apr 24, 2017 4:40:54 PM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons 
Apr 24, 2017 4:40:55 PM org.springframework.batch.core.launch.support.SimpleJobLauncher afterPropertiesSet 
INFO: No TaskExecutor has been set, defaulting to synchronous executor. 
Apr 24, 2017 4:40:55 PM org.springframework.batch.core.launch.support.SimpleJobLauncher$1 run 
INFO: Job: [FlowJob: [name=helloWorldJob]] launched with the following parameters: [{}] 
Apr 24, 2017 4:40:55 PM org.springframework.batch.core.job.SimpleStepHandler handleStep INFO: Executing step: [step1] 
Hello This is a sample example of spring batch 
Apr 24, 2017 4:40:55 PM org.springframework.batch.core.launch.support.SimpleJobLauncher$1 run 
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters: [{}] and the following status: [COMPLETED] 
Exit Status : COMPLETED

Dans ce chapitre, nous allons créer une application Spring Batch qui utilise un lecteur XML et un enregistreur MySQL.

Reader - Le lecteur que nous utilisons dans l'application est StaxEventItemReader pour lire des données à partir de documents XML.

Voici le document XML d'entrée que nous utilisons dans cette application. Ce document contient des enregistrements de données qui spécifient des détails tels que l'identifiant du didacticiel, l'auteur du didacticiel, le titre du didacticiel, la date de soumission, l'icône du didacticiel et la description du didacticiel.

<?xml version="1.0" encoding="UTF-8"?> 
<tutorials> 
   <tutorial>      
      <tutorial_id>1001</tutorial_id> 
      <tutorial_author>Sanjay</tutorial_author> 
      <tutorial_title>Learn Java</tutorial_title> 
      <submission_date>06-05-2007</submission_date> 
      <tutorial_icon>https://www.tutorialspoint.com/java/images/java-minilogo.jpg</tutorial_icon> 
      <tutorial_description>Java is a high-level programming language originally 
         developed by Sun Microsystems and released in 1995. 
         Java runs on a variety of platforms. 
         This tutorial gives a complete understanding of Java.');</tutorial_description> 
   </tutorial> 
    
   <tutorial>      
      <tutorial_id>1002</tutorial_id> 
      <tutorial_author>Abdul S</tutorial_author> 
      <tutorial_title>Learn MySQL</tutorial_title> 
      <submission_date>19-04-2007</submission_date> 
      <tutorial_icon>https://www.tutorialspoint.com/mysql/images/mysql-minilogo.jpg</tutorial_icon> 
      <tutorial_description>MySQL is the most popular 
         Open Source Relational SQL database management system. 
         MySQL is one of the best RDBMS being used for developing web-based software applications. 
         This tutorial will give you quick start with MySQL 
         and make you comfortable with MySQL programming.</tutorial_description> 
   </tutorial> 
    
   <tutorial>
      <tutorial_id>1003</tutorial_id> 
      <tutorial_author>Krishna Kasyap</tutorial_author> 
      <tutorial_title>Learn JavaFX</tutorial_title> 
      <submission_date>06-07-2017</submission_date> 
      <tutorial_icon>https://www.tutorialspoint.com/javafx/images/javafx-minilogo.jpg</tutorial_icon> 
      <tutorial_description>JavaFX is a Java library used to build Rich Internet Applications. 
         The applications developed using JavaFX can run on various devices 
         such as Desktop Computers, Mobile Phones, TVs, Tablets, etc. 
         This tutorial, discusses all the necessary elements of JavaFX that are required
         to develop effective Rich Internet Applications</tutorial_description> 
   </tutorial> 
</tutorials>

Writer - Le writer que nous utilisons dans l'application est JdbcBatchItemWriterpour écrire les données dans la base de données MySQL. Supposons que nous ayons créé une table dans MySQL dans une base de données appelée"details".

CREATE TABLE details.TUTORIALS( 
   tutorial_id int(10) NOT NULL, 
   tutorial_author VARCHAR(20), 
   tutorial_title VARCHAR(50), 
   submission_date VARCHAR(20), 
   tutorial_icon VARCHAR(200), 
   tutorial_description VARCHAR(1000) 
);

Processor - Le processeur que nous utilisons dans l'application est un processeur personnalisé qui écrit les données de chaque enregistrement sur le document PDF.

En traitement par lots, si "n"des enregistrements ou des éléments de données ont été lus, puis pour chaque enregistrement, il lira les données, les traitera et les écrira dans l'enregistreur. Pour traiter les données, il relais sur le processeur passé. Dans ce cas, dans la classe de processeur personnalisé, nous avons écrit du code pour charger un document PDF particulier, créer une nouvelle page, écrire l'élément de données sur le PDF dans un format tabulaire.

Enfin, si vous exécutez cette application, elle lit tous les éléments de données du document XML, les stocke dans la base de données MySQL et les imprime dans le document PDF donné dans des pages individuelles.

jobConfig.xml

Voici le fichier de configuration de notre exemple d'application Spring Batch. Dans ce fichier, nous définirons le Job et les étapes. En plus de ceux-ci, nous définissons également les beans pour ItemReader, ItemProcessor et ItemWriter. (Ici, nous les associons à leurs classes respectives et transmettons les valeurs des propriétés requises pour les configurer.)

<beans xmlns = "http://www.springframework.org/schema/beans" 
   xmlns:batch = "http://www.springframework.org/schema/batch" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:util = "http://www.springframework.org/schema/util" 
   xsi:schemaLocation = "http://www.springframework.org/schema/batch 
    
      http://www.springframework.org/schema/batch/spring-batch-2.2.xsd 
      http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
      http://www.springframework.org/schema/util     
      http://www.springframework.org/schema/util/spring-util-3.0.xsd ">  
  
   <import resource = "../jobs/context.xml" /> 
  
   <bean id = "itemProcessor" class = "CustomItemProcessor" /> 
   <batch:job id = "helloWorldJob"> 
      <batch:step id = "step1"> 
         <batch:tasklet>           
            <batch:chunk reader = "xmlItemReader" writer = "mysqlItemWriter" processor = "itemProcessor">
            </batch:chunk> 
         </batch:tasklet> 
      </batch:step> 
   </batch:job> 
                
   <bean id = "xmlItemReader" 
      class = "org.springframework.batch.item.xml.StaxEventItemReader"> 
      <property name = "fragmentRootElementName" value = "tutorial" /> 
      <property name = "resource" value = "classpath:resources/tutorial.xml" /> 
      <property name = "unmarshaller" ref = "customUnMarshaller" /> 
   </bean> 
      
   <bean id = "customUnMarshaller" class = "org.springframework.oxm.xstream.XStreamMarshaller">
      <property name = "aliases"> 
         <util:map id = "aliases"> 
            <entry key = "tutorial" value = "Tutorial" />            
         </util:map> 
      </property> 
   </bean>  
   <bean id = "mysqlItemWriter" class = "org.springframework.batch.item.database.JdbcBatchItemWriter"> 
      <property name = "dataSource" ref = "dataSource" /> 
      <property name = "sql"> 
         <value> 
            <![CDATA[insert into details.tutorials (tutorial_id, tutorial_author, tutorial_title, 
               submission_date, tutorial_icon, tutorial_description) 
               values (:tutorial_id, :tutorial_author, :tutorial_title, :submission_date, 
               :tutorial_icon, :tutorial_description);]]>
         </value> 
      </property>   
      
      <property name = "itemSqlParameterSourceProvider"> 
         <bean class = "org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider" /> 
      </property> 
   </bean> 
</beans>

Context.xml

Voici le context.xmlde notre application Spring Batch. Dans ce fichier, nous définirons les beans tels que le référentiel de travaux, le lanceur de travaux et le gestionnaire de transactions.

<beans xmlns = "http://www.springframework.org/schema/beans" 
   xmlns:jdbc = "http://www.springframework.org/schema/jdbc" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
      http://www.springframework.org/schema/jdbc 
      http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd"> 
   
   <!-- stored job-meta in database -->
   <bean id = "jobRepository" 
      class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean"> 
      <property name = "dataSource" ref = "dataSource" /> 
      <property name = "transactionManager" ref = "transactionManager" /> 
      <property name = "databaseType" value = "mysql" /> 
   </bean>  
 
   <bean id = "transactionManager" 
   class = "org.springframework.batch.support.transaction.ResourcelessTransactionMana ger" />  
   <bean id = "jobLauncher" 
      class = "org.springframework.batch.core.launch.support.SimpleJobLauncher"> 
      <property name = "jobRepository" ref = "jobRepository" /> 
   </bean> 
  
   <!-- connect to MySQL database --> 
   <bean id = "dataSource" 
      class = "org.springframework.jdbc.datasource.DriverManagerDataSource"> 
      <property name = "driverClassName" value = "com.mysql.jdbc.Driver" /> 
      <property name = "url" value = "jdbc:mysql://localhost:3306/details" /> 
      <property name = "username" value = "myuser" /> 
      <property name = "password" value = "password" /> 
   </bean>  
 
   <!-- create job-meta tables automatically --> 
   <jdbc:initialize-database data-source = "dataSource">   
      <jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql"/>   
      <jdbc:script location = "org/springframework/batch/core/schema-mysql.sql"/> 
   </jdbc:initialize-database> 
</beans>

CustomItemProcessor.java

Voici le processorclasse. Dans cette classe, nous écrivons le code de traitement dans l'application. Ici, nous chargeons un document PDF, créons une nouvelle page, créons un tableau et insérons les valeurs suivantes pour chaque enregistrement: id du didacticiel, nom du didacticiel, auteur, date de soumission dans le tableau.

import java.io.File; 
import java.io.IOException;  

import org.apache.pdfbox.pdmodel.PDDocument; 
import org.apache.pdfbox.pdmodel.PDPage; 
import org.apache.pdfbox.pdmodel.PDPageContentStream; 
import org.apache.pdfbox.pdmodel.font.PDType1Font; 
import org.springframework.batch.item.ItemProcessor;  

public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {  
   
   public static void drawTable(PDPage page, PDPageContentStream contentStream, 
      float y, float margin, String[][] content) throws IOException { 
      final int rows = content.length; 
      final int cols = content[0].length; 
      final float rowHeight = 50; 
      final float tableWidth = page.getMediaBox().getWidth()-(2*margin); 
      final float tableHeight = rowHeight * rows; 
      final float colWidth = tableWidth/(float)cols; 
      final float cellMargin=5f;  
      
      // draw the rows 
      float nexty = y ; 
      for (int i = 0; i <= rows; i++) {   
         contentStream.drawLine(margin,nexty,margin+tableWidth,nexty); 
         nexty-= rowHeight; 
      }  
      
      //draw the columns 
      float nextx = margin; 
      for (int i = 0; i <= cols; i++) {
         contentStream.drawLine(nextx,y,nextx,y-tableHeight); 
         nextx += colWidth; 
      }  
      
      // now add the text    
      contentStream.setFont(PDType1Font.HELVETICA_BOLD,12);  
      
      float textx = margin+cellMargin; 
      float texty = y-15; 
      for(int i = 0; i < content.length; i++){ 
         for(int j = 0 ; j < content[i].length; j++){ 
            String text = content[i][j]; 
            contentStream.beginText(); 
            contentStream.moveTextPositionByAmount(textx,texty); 
            contentStream.drawString(text); 
            contentStream.endText(); 
            textx += colWidth; 
         } 
        
         texty-=rowHeight; 
         textx = margin+cellMargin; 
      } 
   }  
   
   @Override 
   public Tutorial process(Tutorial item) throws Exception { 
      System.out.println("Processing..." + item); 
   
      // Creating PDF document object 
      PDDocument doc = PDDocument.load(new File("C:/Examples/test.pdf"));     
      
      // Creating a blank page 
      PDPage page = new PDPage(); 
      doc.addPage( page ); 
      PDPageContentStream contentStream =  new PDPageContentStream(doc, page);  
      
      String[][] content = {{"Id",""+item.getTutorial_id()},
      {"Title", item.getTutorial_title()}, 
      {"Authour", item.getTutorial_author()}, 
      {"Submission Date", item.getSubmission_date()}} ;  
      drawTable(page, contentStream, 700, 100, content);       
      
      contentStream.close(); 
      doc.save("C:/Examples/test.pdf" ); 
      System.out.println("Hello"); 
      return item; 
   }    
}

TutorialFieldSetMapper.java

Voici la classe ReportFieldSetMapper qui définit les données dans la classe Tutorial.

import org.springframework.batch.item.file.mapping.FieldSetMapper; 
import org.springframework.batch.item.file.transform.FieldSet; 
import org.springframework.validation.BindException;  

public class TutorialFieldSetMapper implements FieldSetMapper<Tutorial> { 
   
   @Override 
   public Tutorial mapFieldSet(FieldSet fieldSet) throws BindException {   
      // instantiating the Tutorial class 
      Tutorial tutorial = new Tutorial(); 
   
      // Setting the fields from XML 
      tutorial.setTutorial_id(fieldSet.readInt(0));   
      tutorial.setTutorial_title(fieldSet.readString(1)); 
      tutorial.setTutorial_author(fieldSet.readString(2)); 
      tutorial.setTutorial_icon(fieldSet.readString(3)); 
      tutorial.setTutorial_description(fieldSet.readString(4));   
      return tutorial;  
   }  
}

Tutorial.java

Voici le Tutorialclasse. C'est une classe simple avecsetter et getter méthodes.

public class Tutorial { 
   private int tutorial_id; 
   private String tutorial_author; 
   private String tutorial_title; 
   private String submission_date; 
   private String tutorial_icon; 
   private String tutorial_description;   
   
   @Override 
   public String toString() { 
      return " [id=" + tutorial_id + ", author=" + tutorial_author  
         + ", title=" + tutorial_title + ", date=" + submission_date + ", icon =" 
         +tutorial_icon +", description = "+tutorial_description+"]"; 
   }  
   
   public int getTutorial_id() { 
      return tutorial_id; 
   }  
   
   public void setTutorial_id(int tutorial_id) { 
      this.tutorial_id = tutorial_id; 
   }  
   
   public String getTutorial_author() { 
      return tutorial_author; 
   }  
   
   public void setTutorial_author(String tutorial_author) { 
      this.tutorial_author = tutorial_author; 
   }  
   
   public String getTutorial_title() { 
      return tutorial_title; 
   } 
   
   public void setTutorial_title(String tutorial_title) { 
      this.tutorial_title = tutorial_title; 
   }  
   
   public String getSubmission_date() { 
      return submission_date; 
   }  
   
   public void setSubmission_date(String submission_date) { 
      this.submission_date = submission_date; 
   }  
   
   public String getTutorial_icon() { 
      return tutorial_icon; 
   }  
   
   public void setTutorial_icon(String tutorial_icon) { 
      this.tutorial_icon = tutorial_icon; 
   }  
   
   public String getTutorial_description() { 
      return tutorial_description; 
   }  
   
   public void setTutorial_description(String tutorial_description) { 
      this.tutorial_description = tutorial_description; 
   } 
}

App.java

Voici le code qui lance le traitement par lots. Dans cette classe, nous allons lancer l'application Batch en exécutant le JobLauncher.

public class App { 
   public static void main(String[] args) throws Exception { 
      String[] springConfig  = {    "jobs/job_hello_world.xml" };  
      
      // Creating the application context object  
      ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);  
      
      // Creating the job launcher 
      JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher"); 
   
      // Creating the job 
      Job job = (Job) context.getBean("helloWorldJob"); 
   
      // Executing the JOB 
      JobExecution execution = jobLauncher.run(job, new JobParameters()); 
      System.out.println("Exit Status : " + execution.getStatus()); 
   }    
}

Lors de l'exécution de cette application, elle produira la sortie suivante.

May 05, 2017 4:39:22 PM org.springframework.context.support.ClassPathXmlApplicationContext 
prepareRefresh 
INFO: Refreshing org[email protected]306a30c7: 
startup date [Fri May 05 16:39:22 IST 2017]; root of context hierarchy 
May 05, 2017 4:39:23 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions 
May 05, 2017 4:39:32 PM org.springframework.batch.core.job.SimpleStepHandler handleStep 
INFO: Executing step: [step1] 
Processing... [id=1001, author=Sanjay, title=Learn Java, date=06-05-2007, 
icon =https://www.tutorialspoint.com/java/images/java-mini-logo.jpg, 
description = Java is a high-level programming language originally developed by Sun Microsystems 
and released in 1995. Java runs on a variety of platforms. 
This tutorial gives a complete understanding of Java.');] 
Hello 
Processing.. [id=1002, author=Abdul S, title=Learn MySQL, date=19-04-2007, 
icon =https://www.tutorialspoint.com/mysql/images/mysql-mini-logo.jpg, 
description = MySQL is the most popular Open Source Relational SQL database management system. 
MySQL is one of the best RDBMS being used for developing web-based software applications. 
This tutorial will give you quick start with MySQL and make you comfortable with MySQL programming.] 
Hello 
Processing... [id=1003, author=Krishna Kasyap, title=Learn JavaFX, date=06-072017, 
icon =https://www.tutorialspoint.com/javafx/images/javafx-mini-logo.jpg,
description = JavaFX is a Java library used to build Rich Internet Applications. 
The applications developed using JavaFX can run on various devices 
such as Desktop Computers, Mobile Phones, TVs, Tablets, etc. 
This tutorial, discusses all the necessary elements of JavaFX 
that are required to develop effective Rich Internet Applications] 
Hello 
May 05, 2017 4:39:36 PM org.springframework.batch.core.launch.support.SimpleJobLauncher run 
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters: [{}] 
and the following status: [COMPLETED] 
Exit Status : COMPLETED

Si vous vérifiez le details.tutorial table dans la base de données, il vous montrera la sortie suivante -

tutoriel _id	tutoriel _author	tutoriel _title	date de soumission	didacticiel _icon	tutoriel _description
1001	Sanjay	Apprendre Java	06-05-2007	https: //www.tutorials point.com / java / images / java-mini-logo.jpg	Java est un langage de programmation de haut niveau développé à l'origine par Sun Microsystems et publié en 1995. Java fonctionne sur diverses plates-formes. Ce tutoriel donne une compréhension complète de Java.
1002	Abdul S	Apprenez MySQL	19-04-2007	https: // www. tutorialspoint.com / mysql / images /mysql-minilogo.jpg	MySQL est le système de gestion de base de données SQL relationnel Open Source le plus populaire. MySQL est l'un des meilleurs SGBDR utilisé pour développer des applications logicielles Web. Ce tutoriel vous permettra de démarrer rapidement avec MySQL et de vous familiariser avec la programmation MySQL.
1003	Apprenez JavaFX	Krishna Kasyap	06-07-2017	https: // www. tutorialspoint.com / javafx / images / javafx-minilogo.jpg	MySQL est le système de gestion de base de données SQL relationnel Open Source le plus populaire. MySQL est l'un des meilleurs SGBDR utilisé pour développer des applications logicielles Web. Ce tutoriel vous permettra de démarrer rapidement avec MySQL et de vous familiariser avec la programmation MySQL.

Cela générera un PDF avec les enregistrements sur chaque page comme indiqué ci-dessous.

Dans ce chapitre, nous allons créer une application Spring Batch simple qui utilise un lecteur CSV et un rédacteur XML.

Reader - Le reader que nous utilisons dans l'application est FlatFileItemReader pour lire les données des fichiers CSV.

Voici le fichier CSV d'entrée que nous utilisons dans cette application. Ce document contient des enregistrements de données qui spécifient des détails tels que l'identifiant du didacticiel, l'auteur du didacticiel, le titre du didacticiel, la date de soumission, l'icône du didacticiel et la description du didacticiel.

1001, "Sanjay", "Learn Java", 06/05/2007 
1002, "Abdul S", "Learn MySQL", 19/04/2007 
1003, "Krishna Kasyap", "Learn JavaFX", 06/07/2017

Writer - Le Writer que nous utilisons dans l'application est StaxEventItemWriter pour écrire les données dans un fichier XML.

Processor - Le processeur que nous utilisons dans l'application est un processeur personnalisé qui imprime simplement les enregistrements lus à partir du fichier CSV.

jobConfig.xml

Voici le fichier de configuration de notre exemple d'application Spring Batch. Dans ce fichier, nous définirons le Job et les étapes. En plus de ceux-ci, nous définissons également les beans pour ItemReader, ItemProcessor et ItemWriter. (Ici, nous les associons aux classes respectives et transmettons les valeurs des propriétés requises pour les configurer.)

<beans xmlns = " http://www.springframework.org/schema/beans" 
   xmlns:batch = "http://www.springframework.org/schema/batch" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xsi:schemaLocation = "http://www.springframework.org/schema/batch 
      http://www.springframework.org/schema/batch/spring-batch-2.2.xsd 
      http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
   
   <import resource = "../jobs/context.xml" />  
   
   <bean id = "report" class = "Report" scope = "prototype" /> 
   <bean id = "itemProcessor" class = "CustomItemProcessor" />  
   
   <batch:job id = "helloWorldJob"> 
   
      <batch:step id = "step1"> 
   
         <batch:tasklet> 
            <batch:chunk reader = "cvsFileItemReader" writer = "xmlItemWriter" 
               processor = "itemProcessor" commit-interval = "10"> 
            </batch:chunk> 
         </batch:tasklet> 
      </batch:step> 
   </batch:job>  
 
   <bean id = "cvsFileItemReader" 
      class = "org.springframework.batch.item.file.FlatFileItemReader">  
      <property name = "resource" value = "classpath:resources/report.csv" /> 
      <property name = "lineMapper"> 
         <bean 
            class = "org.springframework.batch.item.file.mapping.DefaultLineMapper"> 
            <property name = "lineTokenizer"> 
               <bean    
                  class = "org.springframework.batch.item.file.transform.DelimitedLineTokenizer"> 
                  <property name = "names" value = "tutorial_id, 
                     tutorial_author, Tutorial_title, submission_date" /> 
               </bean> 
            </property> 
      
            <property name = "fieldSetMapper"> 
               <bean class = "ReportFieldSetMapper" /> 
            </property> 
         </bean> 
      </property> 
   </bean>  
   
   <bean id = "xmlItemWriter" 
      class = "org.springframework.batch.item.xml.StaxEventItemWriter"> 
      <property name = "resource" value = "file:xml/outputs/tutorials.xml" /> 
      <property name = "marshaller" ref = "reportMarshaller" /> 
      <property name = "rootTagName" value = "tutorials" /> 
   </bean>  
 
   <bean id = "reportMarshaller" 
      class = "org.springframework.oxm.jaxb.Jaxb2Marshaller">
      <property name = "classesToBeBound"> 
         <list> 
            <value>Tutorial</value> 
         </list> 
      </property> 
   </bean> 
</beans>

Context.xml

Voici le context.xmlde notre application Spring Batch. Dans ce fichier, nous définirons les beans tels que le référentiel de travaux, le lanceur de travaux et le gestionnaire de transactions.

<beans xmlns = "http://www.springframework.org/schema/beans" 
   xmlns:jdbc = "http://www.springframework.org/schema/jdbc" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
      http://www.springframework.org/schema/jdbc 
      http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd">  
   <!-- stored job-meta in database --> 
   <bean id = "jobRepository" 
      class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean"> 
      <property name = "dataSource" ref = "dataSource" /> 
      <property name = "transactionManager" ref = "transactionManager" /> 
      <property name = "databaseType" value = "mysql" /> 
   </bean>  
 
   <bean id = "transactionManager" 
      class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />  
   <bean id = "jobLauncher" 
      class = "org.springframework.batch.core.launch.support.SimpleJobLauncher"> 
      <property name = "jobRepository" ref = "jobRepository" /> 
   </bean>  
   
   <bean id = "dataSource" class = "org.springframework.jdbc.datasource.DriverManagerDataSource"> 
      <property name = "driverClassName" value = "com.mysql.jdbc.Driver" /> 
      <property name = "url" value = "jdbc:mysql://localhost:3306/details" />
      <property name = "username" value = "myuser" /> 
      <property name = "password" value = "password" /> 
   </bean> 
  
   <!-- create job-meta tables automatically --> 
   <jdbc:initialize-database data-source = "dataSource">   
      <jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql" /> 
      <jdbc:script location = "org/springframework/batch/core/schema-mysql.sql" /> 
   </jdbc:initialize-database> 
</beans>

CustomItemProcessor.java

Voici la classe Processor. Dans cette classe, nous écrivons le code de traitement dans l'application. Ici, nous imprimons le contenu de chaque enregistrement.

import org.springframework.batch.item.ItemProcessor;  

public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {  
   
   @Override 
   public Tutorial process(Tutorial item) throws Exception {  
      System.out.println("Processing..." + item); 
      return item; 
   } 
}

TutorialFieldSetMapper.java

Voici la classe TutorialFieldSetMapper qui définit les données dans la classe Tutorial.

import org.springframework.batch.item.file.mapping.FieldSetMapper; 
import org.springframework.batch.item.file.transform.FieldSet; 
import org.springframework.validation.BindException;  

public class TutorialFieldSetMapper implements FieldSetMapper<Tutorial> {  

   @Override 
   public Tutorial mapFieldSet(FieldSet fieldSet) throws BindException {  
      
      //Instantiating the report object  
      Tutorial tutorial = new Tutorial(); 
       
      //Setting the fields  
      tutorial.setTutorial_id(fieldSet.readInt(0)); 
      tutorial.setTutorial_author(fieldSet.readString(1)); 
      tutorial.setTutorial_title(fieldSet.readString(2)); 
      tutorial.setSubmission_date(fieldSet.readString(3)); 
       
      return tutorial; 
   } 
}

Tutorial.java classe

Voici le Tutorialclasse. C'est une classe Java simple avecsetter et getterméthodes. Dans cette classe, nous utilisons des annotations pour associer les méthodes de cette classe aux balises du fichier XML.

import javax.xml.bind.annotation.XmlAttribute; 
import javax.xml.bind.annotation.XmlElement; 
import javax.xml.bind.annotation.XmlRootElement;  

@XmlRootElement(name = "tutorial") 
public class Tutorial {  
   private int tutorial_id; 
   private String tutorial_author; 
   private String tutorial_title;
   private String submission_date;  
 
   @XmlAttribute(name = "tutorial_id") 
   public int getTutorial_id() { 
      return tutorial_id; 
   }  
 
   public void setTutorial_id(int tutorial_id) { 
      this.tutorial_id = tutorial_id; 
   }  
 
   @XmlElement(name = "tutorial_author") 
   public String getTutorial_author() { 
      return tutorial_author; 
   }  
   public void setTutorial_author(String tutorial_author) { 
      this.tutorial_author = tutorial_author; 
   }  
      
   @XmlElement(name = "tutorial_title") 
   public String getTutorial_title() { 
      return tutorial_title; 
   }  
   
   public void setTutorial_title(String tutorial_title) { 
      this.tutorial_title = tutorial_title; 
   }  
   
   @XmlElement(name = "submission_date") 
   public String getSubmission_date() { 
      return submission_date; 
   }  
   
   public void setSubmission_date(String submission_date) { 
      this.submission_date = submission_date; 
   } 
   
   @Override 
   public String toString() { 
      return "  [Tutorial id=" + tutorial_id + ", 
         Tutorial Author=" + tutorial_author  + ", 
         Tutorial Title=" + tutorial_title + ", 
         Submission Date=" + submission_date + "]"; 
   } 
}

App.java

Voici le code qui lance le traitement par lots. Dans cette classe, nous allons lancer l'application batch en exécutant le JobLauncher.

import org.springframework.batch.core.Job; 
import org.springframework.batch.core.JobExecution; 
import org.springframework.batch.core.JobParameters; 
import org.springframework.batch.core.launch.JobLauncher; 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext;  

public class App {  
   public static void main(String[] args) throws Exception { 
     
      String[] springConfig  =  { "jobs/job_hello_world.xml" };  
      
      // Creating the application context object        
      ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);  
      
      // Creating the job launcher 
      JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher"); 
   
      // Creating the job 
      Job job = (Job) context.getBean("helloWorldJob"); 
   
      // Executing the JOB 
      JobExecution execution = jobLauncher.run(job, new JobParameters());
      System.out.println("Exit Status : " + execution.getStatus()); 
   } 
}

Lors de l'exécution de cette application, elle produira la sortie suivante.

May 08, 2017 10:10:12 AM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh 
INFO: Refreshing 
org[email protected]3d646c37: startup date 
[Mon May 08 10:10:12 IST 2017]; root of context hierarchy 
May 08, 2017 10:10:12 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions 
May 08, 2017 10:10:15 AM org.springframework.jdbc.datasource.init.ScriptUtils executeSqlScript 
INFO: Executing step: [step1] 
Processing...  [Tutorial id=1001, Tutorial Author=Sanjay, 
Tutorial Title=Learn Java, Submission Date=06/05/2007] 
Processing...  [Tutorial id=1002, Tutorial Author=Abdul S, 
Tutorial Title=Learn MySQL, Submission Date=19/04/2007] 
Processing...  [Tutorial id=1003, Tutorial Author=Krishna Kasyap, 
Tutorial Title=Learn JavaFX, Submission Date=06/07/2017] 
May 08, 2017 10:10:21 AM org.springframework.batch.core.launch.support.SimpleJobLauncher run 
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters: 
[{}] and the following status: [COMPLETED] 
Exit Status : COMPLETED

Cela générera un fichier XML avec le contenu suivant.

<?xml version = "1.0" encoding = "UTF-8"?> 
<tutorials> 
   <tutorial tutorial_id = "1001"> 
      <submission_date>06/05/2007</submission_date> 
      <tutorial_author>Sanjay</tutorial_author> 
      <tutorial_title>Learn Java</tutorial_title> 
   </tutorial> 
   
   <tutorial tutorial_id = "1002"> 
      <submission_date>19/04/2007</submission_date> 
      <tutorial_author>Abdul S</tutorial_author> 
      <tutorial_title>Learn MySQL</tutorial_title> 
   </tutorial> 
   
   <tutorial tutorial_id = "1003"> 
      <submission_date>06/07/2017</submission_date>
      <tutorial_author>Krishna Kasyap</tutorial_author> 
      <tutorial_title>Learn JavaFX</tutorial_title> 
   </tutorial> 
</tutorials>

Dans ce chapitre, nous allons créer une application Spring Batch qui utilise un lecteur MySQL et un rédacteur XML.

Reader - Le lecteur que nous utilisons dans l'application est JdbcCursorItemReader pour lire les données de la base de données MySQL.

Supposons que nous ayons créé une table dans la base de données MySQL comme indiqué ci-dessous -

CREATE TABLE details.xml_mysql( 
   person_id int(10) NOT NULL, 
   sales VARCHAR(20), 
   qty int(3), 
   staffName VARCHAR(20), 
   date VARCHAR(20) 
);

Supposons que nous y ayons inséré les enregistrements suivants.

mysql> select * from tutorialsdata; 
+-------------+-----------------+----------------+-----------------+ 
| tutorial_id | tutorial_author | tutorial_title | submission_date | 
+-------------+-----------------+----------------+-----------------+ 
|         101 | Sanjay          | Learn Java     | 06-05-2007      | 
|         102 | Abdul S         | Learn MySQL    | 19-04-2007      | 
|         103 | Krishna Kasyap  | Learn JavaFX   | 06-07-2017      | 
+-------------+-----------------+----------------+-----------------+ 
3 rows in set (0.00 sec)

Writer - Le Writer que nous utilisons dans l'application est StaxEventItemWriter pour écrire les données dans le fichier XML.

Processor - Le processeur que nous utilisons dans l'application est un processeur personnalisé qui imprime simplement les enregistrements lus à partir du fichier CSV.

jobConfig.xml

Voici le fichier de configuration de notre exemple d'application Spring Batch. Dans ce fichier, nous définirons le Job et les étapes. En plus de ceux-ci, nous définissons également les beans pour ItemReader, ItemProcessor et ItemWriter. (Ici, nous les associons à leurs classes respectives et transmettons les valeurs des propriétés requises pour les configurer.)

<beans xmlns = "http://www.springframework.org/schema/beans" 
   xmlns:batch = "http://www.springframework.org/schema/batch" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:util = "http://www.springframework.org/schema/util" 
   xsi:schemaLocation = " http://www.springframework.org/schema/batch 
      http://www.springframework.org/schema/batch/spring-batch-2.2.xsd 
      http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
   
   <import resource = "../jobs/context.xml" /> 
  
   <bean id = "report" class = "Report" scope = "prototype" /> 
   <bean id = "itemProcessor" class = "CustomItemProcessor" />  
   
   <batch:job id = "helloWorldJob"> 
      <batch:step id = "step1"> 
         <batch:tasklet> 
            <batch:chunk reader = "dbItemReader" 
               writer = "mysqlItemWriter" processor = "itemProcessor" commit-interval = "10">
            </batch:chunk> 
         </batch:tasklet> 
      </batch:step> 
   </batch:job> 
         
   <bean id = "dbItemReader" 
      class = "org.springframework.batch.item.database.JdbcCursorItemReader" scope = "step"> 
      <property name = "dataSource" ref = "dataSource" /> 
      <property name = "sql" value = "select * from tutorials_data" /> 
      <property name = "rowMapper"> 
         <bean class = "TutorialRowMapper" /> 
      </property> 
   </bean>             
   <bean id = "mysqlItemWriter" 
      class = "org.springframework.batch.item.xml.StaxEventItemWriter"> 
      <property name = "resource" value = "file:xml/outputs/tutorials.xml" /> 
      <property name = "marshaller" ref = "reportMarshaller" />
      <property name = "rootTagName" value = "Tutorial" /> 
   </bean>  
   
   <bean id = "reportMarshaller" class = "org.springframework.oxm.jaxb.Jaxb2Marshaller"> 
      <property name = "classesToBeBound"> 
         <list> 
            <value>Tutorial</value> 
         </list> 
      </property> 
   </bean> 
</beans>

Context.xml

Voici le context.xmlde notre application Spring Batch. Dans ce fichier, nous définirons les beans tels que le référentiel de travaux, le lanceur de travaux et le gestionnaire de transactions.

<beans xmlns = " http://www.springframework.org/schema/beans" 
   xmlns:jdbc = "http://www.springframework.org/schema/jdbc" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
      http://www.springframework.org/schema/jdbc 
      http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd "> 
   
   <!-- stored job-meta in database --> 
   <bean id = "jobRepository"  
      class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean"> 
      <property name = "dataSource" ref = "dataSource" /> 
      <property name = "transactionManager" ref = "transactionManager" /> 
      <property name = "databaseType" value = "mysql" /> 
   </bean>  
   
   <bean id = "transactionManager" 
      class = "org.springframework.batch.support.transaction.ResourcelessTransactionMana ger" />  
   <bean id = "jobLauncher"
      class = "org.springframework.batch.core.launch.support.SimpleJobLauncher"> 
      <property name = "jobRepository" ref = "jobRepository" /> 
   </bean> 
  
   <!-- connect to MySQL database --> 
   <bean id = "dataSource" 
      class = "org.springframework.jdbc.datasource.DriverManagerDataSource"> 
      <property name = "driverClassName" value = "com.mysql.jdbc.Driver" /> 
      <property name = "url" value = "jdbc:mysql://localhost:3306/details" /> 
      <property name = "username" value = "myuser" /> 
      <property name = "password" value = "password" /> 
   </bean> 
  
   <!-- create job-meta tables automatically --> 
   <jdbc:initialize-database data-source = "dataSource">   
      <jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql" />   
      <jdbc:script location = "org/springframework/batch/core/schema-mysql.sql" /> 
   </jdbc:initialize-database> 
</beans>

CustomItemProcessor.java

Voici la classe Processor. Dans cette classe, nous écrivons le code de traitement dans l'application. Ici, nous imprimons le contenu de chaque enregistrement.

import org.springframework.batch.item.ItemProcessor;  

public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {  

   @Override 
   public Tutorial process(Tutorial item) throws Exception { 
      System.out.println("Processing..." + item); 
      return item; 
   } 
}

TutorialRowMapper.java

Voici le TutorialRowMapper classe qui définit les données sur Tutorial classe.

import java.sql.ResultSet; 
import java.sql.SQLException; 
import org.springframework.jdbc.core.RowMapper;  

public class TutorialRowMapper implements RowMapper<Tutorial> {  
   
   @Override 
   public Tutorial mapRow(ResultSet rs, int rowNum) throws SQLException {  
      
      Tutorial tutorial = new Tutorial();  
      tutorial.setTutorial_id(rs.getInt("tutorial_id")); 
      tutorial.setTutorial_author(rs.getString("tutorial_author")); 
      tutorial.setTutorial_title(rs.getString("tutorial_title")); 
      tutorial.setSubmission_date(rs.getString("submission_date"));  
      return tutorial; 
   } 
}

Tutorial.java

Voici le Tutorialclasse. C'est une classe Java simple avecsetter et getterméthodes. Dans cette classe, nous utilisons des annotations pour associer les méthodes de cette classe aux balises du fichier XML.

import javax.xml.bind.annotation.XmlAttribute; 
import javax.xml.bind.annotation.XmlElement; 
import javax.xml.bind.annotation.XmlRootElement;  

@XmlRootElement(name = "details") 
public class Tutorial {  
   
   int tutorial_id; 
   String tutorial_author;
   String submission_date; 
  
   @XmlAttribute(name = "tutorial_id") 
   public int getTutorial_id() { 
      return tutorial_id; 
   }  
   
   public void setTutorial_id(int tutorial_id) { 
      this.tutorial_id = tutorial_id; 
   }  
 
   @XmlElement(name = "tutorial_author") 
   public String getTutorial_author() { 
      return tutorial_author; 
   }  
   
   public void setTutorial_author(String tutorial_author) { 
      this.tutorial_author = tutorial_author; 
   }  
 
   @XmlElement(name = "tutorial_title") 
   public String getTutorial_title() { 
      return tutorial_title; 
   } 
  
   public void setTutorial_title(String tutorial_title) { 
      this.tutorial_title = tutorial_title; 
   }  
 
   @XmlElement(name = "submission_date") 
   public String getSubmission_date() { 
      return submission_date; 
   }

   public void setSubmission_date(String submission_date) { 
      this.submission_date = submission_date; 
   }  

   public String toString() { 
      return " [Tutorial Id=" + tutorial_id + ", 
      Tutorial Author =" + tutorial_author  + ", 
      Tutorial Title =" + tutorial_title + ", 
      Submission Date =" + submission_date + "]"; 
   } 
}

App.java

Voici le code qui lance le traitement par lots. Dans cette classe, nous allons lancer l'application Batch en exécutant le JobLauncher.

import org.springframework.batch.core.Job; 
import org.springframework.batch.core.JobExecution; 
import org.springframework.batch.core.JobParameters; 
import org.springframework.batch.core.launch.JobLauncher; 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext;  

public class App {  
   public static void main(String[] args) throws Exception { 
     
      String[] springConfig  =  { "jobs/job_hello_world.xml" };  
      
      // Creating the application context object  
      ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);  
      
      // Creating the job launcher 
      JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher"); 
    
      // Creating the job 
      Job job = (Job) context.getBean("helloWorldJob");
      
      // Executing the JOB 
      JobExecution execution = jobLauncher.run(job, new JobParameters()); 
      System.out.println("Exit Status : " + execution.getStatus()); 
   } 
}

Lors de l'exécution de cette application, elle produira la sortie suivante.

May 08, 2017 11:32:06 AM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh 
INFO: Refreshing org[email protected]3d646c37: 
startup date [Mon May 08 11:32:06 IST 2017]; root of context hierarchy 
May 08, 2017 11:32:06 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions 
INFO: Loading XML bean definitions from class path resource [jobs/job_hello_world.xml] 
May 08, 2017 11:32:07 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions   
May 08, 2017 11:32:14 AM org.springframework.batch.core.job.SimpleStepHandler handleStep 
INFO: Executing step: [step1] 
Processing... [Tutorial Id=101, Tutorial Author=Sanjay, 
Tutorial Title=Learn Java, Submission Date=06-05-2007] 
Processing... [Tutorial Id=102, Tutorial Author=Abdul S, 
Tutorial Title=Learn MySQL, Submission Date=19-04-2007] 
Processing... [Tutorial Id=103, Tutorial Author=Krishna Kasyap, 
Tutorial Title=Learn JavaFX, Submission Date=06-07-2017] 
May 08, 2017 11:32:14 AM org.springframework.batch.core.launch.support.SimpleJobLauncher run 
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters: 
[{}] and the following status: [COMPLETED] 
Exit Status : COMPLETED

Cela générera un fichier XML avec le contenu suivant.

<?xml version = "1.0" encoding = "UTF-8"?> 
<Tutorial> 
   <details tutorial_id = "101"> 
      <submission_date>06-05-2007</submission_date> 
      <tutorial_author>Sanjay</tutorial_author> 
      <tutorial_title>Learn Java</tutorial_title> 
   </details> 
   
   <details tutorial_id = "102"> 
      <submission_date>19-04-2007</submission_date> 
      <tutorial_author>Abdul S</tutorial_author> 
      <tutorial_title>Learn MySQL</tutorial_title> 
   </details>  
   
   <details tutorial_id = "103"> 
      <submission_date>06-07-2017</submission_date> 
      <tutorial_author>Krishna Kasyap</tutorial_author> 
      <tutorial_title>Learn JavaFX</tutorial_title> 
   </details> 
</Tutorial>

Dans ce chapitre, nous allons créer une application Spring Batch qui utilise un lecteur MySQL et un Flatfile Rédacteur (.txt).

Reader - Le lecteur que nous utilisons dans l'application est JdbcCursorItemReader pour lire les données de la base de données MySQL.

Supposons que nous ayons créé une table dans la base de données MySQL comme indiqué ci-dessous.

CREATE TABLE details.xml_mysql( 
   person_id int(10) NOT NULL, 
   sales VARCHAR(20), 
   qty int(3), 
   staffName VARCHAR(20), 
   date VARCHAR(20) 
);

Supposons que nous y ayons inséré les enregistrements suivants.

mysql> select * from tutorialsdata; 
+-------------+-----------------+----------------+-----------------+ 
| tutorial_id | tutorial_author | tutorial_title | submission_date | 
+-------------+-----------------+----------------+-----------------+ 
|         101 | Sanjay          | Learn Java     | 06-05-2007      | 
|         102 | Abdul S         | Learn MySQL    | 19-04-2007      | 
|         103 | Krishna Kasyap  | Learn JavaFX   | 06-07-2017      | 
+-------------+-----------------+----------------+-----------------+ 
3 rows in set (0.00 sec)

Writer - Le Writer que nous utilisons dans l'application est FlatFileItemWriter pour écrire les données dans flatfile (.SMS).

Processor - Le processeur que nous utilisons dans l'application est un processeur personnalisé qui imprime simplement les enregistrements lus à partir du fichier CSV.

jobConfig.xml

Voici le fichier de configuration de notre exemple d'application Spring Batch. Dans ce fichier, nous définirons le Job et les étapes. En plus de ceux-ci, nous définissons également les beans pour ItemReader, ItemProcessor et ItemWriter. (Ici, nous les associons aux classes respectives et transmettons les valeurs des propriétés requises pour les configurer.)

<beans xmlns = "http://www.springframework.org/schema/beans" 
   xmlns:batch = "http://www.springframework.org/schema/batch" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:util = "http://www.springframework.org/schema/util" 
   xsi:schemaLocation = "http://www.springframework.org/schema/batch 
   
      http://www.springframework.org/schema/batch/spring-batch-2.2.xsd 
      http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">  
   
   <import resource = "../jobs/context.xml" />  
   <bean id = "tutorial" class = "Tutorial" scope = "prototype" /> 
   <bean id = "itemProcessor" class = "CustomItemProcessor" />  
   
   <batch:job id = "helloWorldJob"> 
      <batch:step id = "step1"> 
         <batch:tasklet> 
            <batch:chunk reader = "mysqlItemReader" 
               writer = "flatFileItemWriter" processor = "itemProcessor" 
               commit-interval = "10"> 
            </batch:chunk> 
         </batch:tasklet> 
      </batch:step> 
   </batch:job> 
         
   <bean id = "mysqlItemReader" 
      class = "org.springframework.batch.item.database.JdbcCursorItemReader" > 
      <property name = "dataSource" ref = "dataSource" /> 
      <property name = "sql" value = "select * from details.tutorialsdata" /> 
      <property name = "rowMapper">  
         <bean class = "TutorialRowMapper" /> 
      </property> 
   </bean>
   
   <bean id = "flatFileItemWriter" 
      class = " org.springframework.batch.item.file.FlatFileItemWriter">      
      <property name = "resource" value = "file:target/outputfiles/employee_output.txt"/> 
      <property name = "lineAggregator"> 
         <bean class = " org.springframework.batch.item.file.transform.PassThroughLineAggregator"/> 
      </property> 
   </bean> 
</beans>

Context.xml

Voici le context.xmlde notre application Spring Batch. Dans ce fichier, nous définirons les beans tels que le référentiel de travaux, le lanceur de travaux et le gestionnaire de transactions.

<beans xmlns = "http://www.springframework.org/schema/beans" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
   xmlns:jdbc = "http://www.springframework.org/schema/jdbc" 
   xsi:schemaLocation = "http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
      http://www.springframework.org/schema/jdbc 
      http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd "> 
   
   <!-- stored job-meta in database --> 
   <bean id = "jobRepository"  
      class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean"> 
      <property name = "dataSource" ref = "dataSource" /> 
      <property name = "transactionManager" ref = "transactionManager" /> 
      <property name = "databaseType" value = "mysql" /> 
   </bean>  
 
   <bean id = "transactionManager"  
      class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />  
   
   <bean id = "dataSource" 
      class = "org.springframework.jdbc.datasource.DriverManagerDataSource"> 
      <property name = "driverClassName" value = "com.mysql.jdbc.Driver" /> 
      <property name = "url" value = "jdbc:mysql://localhost:3306/details" /> 
      <property name = "username" value = "myuser" /> 
      <property name = "password" value = "password" /> 
   </bean> 
    
   <bean id = "jobLauncher"  
      class = "org.springframework.batch.core.launch.support.SimpleJobLauncher"> 
      <property name = "jobRepository" ref = "jobRepository" /> 
   </bean> 
  
   <!-- create job-meta tables automatically --> 
   <jdbc:initialize-database data-source = "dataSource">   
      <jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql" />   
      <jdbc:script location = "org/springframework/batch/core/schema-mysql.sql" /> 
   </jdbc:initialize-database> 
</beans>

CustomItemProcessor.java

Voici la classe Processor. Dans cette classe, nous écrivons le code de traitement dans l'application. Ici, nous imprimons le contenu de chaque enregistrement.

import org.springframework.batch.item.ItemProcessor;  

// Implementing the ItemProcessor interface 
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {  
 
   @Override 
   public Tutorial process(Tutorial item) throws Exception { 
      System.out.println("Processing..." + item); 
      return item; 
   } 
}

TutorialRowMapper.java

Voici le TutorialRowMapper classe qui définit les données sur Tutorial classe.

public class TutorialRowMapper implements RowMapper<Tutorial> {  
   
   @Override 
   public Tutorial mapRow(ResultSet rs, int rowNum) throws SQLException {  
  
      Tutorial tutorial = new Tutorial();  
  
      tutorial.setTutorial_id(rs.getInt("tutorial_id")); 
      tutorial.setTutorial_title(rs.getString("tutorial_title")); 
      tutorial.setTutorial_author(rs.getString("tutorial_author")); 
      tutorial.setSubmission_date(rs.getString("submission_date"));  
      return tutorial; 
   } 
}

Tutorial.java

Voici le Tutorialclasse. C'est une classe Java simple avecsetter et getterméthodes. Dans cette classe, nous utilisons des annotations pour associer les méthodes de cette classe aux balises du fichier XML.

public class Tutorial { 
   private int tutorial_id; 
   private String tutorial_title; 
   private String tutorial_author; 
   private String submission_date; 
  
   public int getTutorial_id() { 
      return tutorial_id; 
   }  
   
   public void setTutorial_id(int tutorial_id) { 
      this.tutorial_id = tutorial_id; 
   }
   
   public String getTutorial_title() { 
      return tutorial_title; 
   }   
 
   public void setTutorial_title(String tutorial_title) { 
      this.tutorial_title = tutorial_title; 
   }  
   
   public String getTutorial_author() { 
      return tutorial_author; 
   }  
 
   public void setTutorial_author(String tutorial_author) { 
      this.tutorial_author = tutorial_author; 
   }  
 
   public String getSubmission_date() { 
      return submission_date; 
   }  
   public void setSubmission_date(String submission_date) { 
      this.submission_date = submission_date; 
   }  
 
   @Override 
   public String toString() { 
      return " [id=" + tutorial_id + ", title=" + 
      tutorial_title                      + ", 
      author=" + tutorial_author + ", date=" + 
      submission_date + "]"; 
   } 
}

App.java

Voici le code qui lance le traitement par lots. Dans cette classe, nous allons lancer l'application Batch en exécutant le JobLauncher.

import org.springframework.batch.core.Job; 
import org.springframework.batch.core.JobExecution; 
import org.springframework.batch.core.JobParameters; 
import org.springframework.batch.core.launch.JobLauncher; 
import org.springframework.context.ApplicationContext; 
import org.springframework.context.support.ClassPathXmlApplicationContext;  

public class App {  
   
   public static void main(String[] args) throws Exception { 
     
      String[] springConfig  =  { "jobs/job_hello_world.xml" };  
      
      // Creating the application context object  
      ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);  
      
      // Creating the job launcher 
      JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher"); 
    
      // Creating the job 
      Job job = (Job) context.getBean("helloWorldJob"); 
    
      // Executing the JOB 
      JobExecution execution = jobLauncher.run(job, new JobParameters()); 
      System.out.println("Exit Status : " + execution.getStatus()); 
   } 
}

Lors de l'exécution de cette application, elle produira la sortie suivante.

May 09, 2017 5:44:48 PM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh 
INFO: Refreshing org.springframework.context.support.ClassPathXml
[email protected]: startup date [Tue May 
09 17:44:48 IST 2017]; root of context hierarchy 
May 09, 2017 5:44:48 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions  
May 09, 2017 5:44:56 PM org.springframework.batch.core.launch.support.SimpleJobLauncher run 
INFO: Job: [FlowJob: [name=helloWorldJob]] launched 
with the following parameters: [{}] 
May 09, 2017 5:44:56 PM org.springframework.batch.core.job.SimpleStepHandler handleStep 
INFO: Executing step: [step1] 
Processing...Report [id=101, title=Learn Java, author=Sanjay, date=06-05-2007] 
Processing...Report [id=102, title=Learn MySQL, author=Abdul S, date=19-04-2007] 
Processing...Report [id=103, title=Learn JavaFX, author=Krishna Kasyap, date=0607-2017] 
May 09, 2017 5:44:57 PM org.springframework.batch.core.launch.support.SimpleJobLauncher run 
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters: 
[{}] and the following status: [COMPLETED] 
Hello 
Exit Status : COMPLETED

Cela générera un .txt fichier avec le contenu suivant.

Report [id=101, title=Learn Java, author=Sanjay, date=06-05-2007] 
Report [id=102, title=Learn MySQL, author=Abdul S, date=19-04-2007] 
Report [id=103, title=Learn JavaFX, author=Krishna Kasyap, date=06-07-2017]