Spring Batch - Guida rapida

Batch processingè una modalità di elaborazione che prevede l'esecuzione di serie di lavori complessi automatizzati senza l'interazione dell'utente. Un processo batch gestisce i dati in blocco e viene eseguito per molto tempo.

Diverse applicazioni aziendali richiedono l'elaborazione di dati enormi per eseguire operazioni che coinvolgono:

• Eventi basati sul tempo come calcoli periodici.

• Applicazioni periodiche che vengono elaborate ripetutamente su set di dati di grandi dimensioni.

• Applicazioni che si occupano dell'elaborazione e della convalida dei dati disponibili in modo transazionale.

Pertanto, l'elaborazione in batch viene utilizzata nelle applicazioni aziendali per eseguire tali transazioni.

Cos'è Spring Batch

Il lotto primaverile è un file lightweight framework che viene utilizzato per sviluppare Batch Applications che vengono utilizzati nelle applicazioni aziendali.

Oltre all'elaborazione in blocco, questo framework fornisce funzioni per:

• Compresi la registrazione e la traccia
• Gestione delle transazioni
• Statistiche sull'elaborazione del lavoro
• Riavvio del lavoro
• Salta e gestione delle risorse

È inoltre possibile ridimensionare le applicazioni batch di molle utilizzando le sue tecniche di porzionamento.

Caratteristiche di Spring Batch

Di seguito sono riportate le caratteristiche principali di Spring Batch:

• Flexibility- Le applicazioni Spring Batch sono flessibili. È sufficiente modificare un file XML per modificare l'ordine di elaborazione in un'applicazione.

• Maintainability- Le applicazioni Spring Batch sono di facile manutenzione. Un processo Spring Batch include passaggi e ogni passaggio può essere disaccoppiato, testato e aggiornato, senza influire sugli altri passaggi.

• Scalability- Utilizzando le tecniche di porzionatura, è possibile ridimensionare le applicazioni Spring Batch. Queste tecniche ti consentono di:

  • Eseguire le fasi di un lavoro in parallelo.

  • Esegui un singolo thread in parallelo.

• Reliability - In caso di guasto, è possibile riavviare il lavoro esattamente dal punto in cui era stato interrotto, disaccoppiando i passaggi.

• Support for multiple file formats - Spring Batch fornisce supporto per un ampio set di lettori e scrittori come XML, file flat, CSV, MYSQL, Hibernate, JDBC, Mongo, Neo4j, ecc.

• Multiple ways to launch a job - È possibile avviare un processo Spring Batch utilizzando applicazioni Web, programmi Java, riga di comando, ecc.

Oltre a questi, le applicazioni Spring Batch supportano:

• Riprova automatica in caso di errore.

• Monitoraggio dello stato e delle statistiche durante l'esecuzione del batch e dopo aver completato l'elaborazione del batch.

• Per eseguire lavori simultanei.

• Servizi come la registrazione, la gestione delle risorse, il salto e il riavvio dell'elaborazione.

In questo capitolo, spiegheremo come impostare l'ambiente Spring Batch in Eclipse IDE. Prima di procedere con l'installazione, assicurati di aver installato Eclipse nel tuo sistema. In caso contrario, scarica e installa Eclipse nel tuo sistema.

Per ulteriori informazioni su Eclipse, fare riferimento al nostro Tutorial Eclipse.

Impostazione di Spring Batch su Eclipse

Seguire i passaggi indicati di seguito per impostare l'ambiente Spring Batch su Eclipse.

Step 1 - Installa Eclipse e apri un Nuovo progetto come mostrato nella seguente schermata.

Step 2 - Creare un progetto Spring Batch di esempio come mostrato di seguito.

Step 3- Fare clic con il pulsante destro del mouse sul progetto e convertirlo in un progetto Maven come mostrato di seguito. Una volta convertito nel progetto Maven, ti darà un filePom.xmldove è necessario menzionare le dipendenze richieste. Successivamente, iljar i file di questi verranno automaticamente scaricati nel progetto.

Step 4 - Ora, nel pom.xml del progetto, copia e incolla il seguente contenuto (dipendenze per l'applicazione batch di primavera) e aggiorna il progetto.

<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>

Infine, se osservi le dipendenze Maven, puoi osservare che tutte le richieste jar i file sono stati scaricati.

Di seguito è riportata la rappresentazione schematica dell'architettura di Spring Batch. Come illustrato nella figura, l'architettura contiene tre componenti principali e cioè,Application, Batch Core, e Batch Infrastructure.

Application - Questo componente contiene tutti i lavori e il codice che scriviamo utilizzando il framework Spring Batch.

Batch Core - Questo componente contiene tutte le classi API necessarie per controllare e avviare un lavoro batch.

Batch Infrastructure - Questo componente contiene i lettori, i writer e i servizi utilizzati sia dall'applicazione che dai componenti principali di Batch.

Componenti di Spring Batch

La seguente illustrazione mostra i diversi componenti di Spring Batch e il modo in cui sono collegati tra loro.

Lavoro

In un'applicazione Spring Batch, un lavoro è il processo batch che deve essere eseguito. Funziona dall'inizio alla fine senza interruzioni. Questo lavoro è ulteriormente suddiviso in passaggi (o un lavoro contiene passaggi).

Configureremo un lavoro in Spring Batch utilizzando un file XML o una classe Java. Di seguito è riportata la configurazione XML di un lavoro in Spring Batch.

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

Un lavoro batch viene configurato all'interno dei tag <job> </job>. Ha un attributo denominatoid. All'interno di questi tag, definiamo la definizione e l'ordine dei passaggi.

Restartable - In generale, quando un lavoro è in esecuzione e proviamo a riavviarlo, viene considerato come restarte verrà riavviato. Per evitare ciò, è necessario impostare il filerestartable valore a false come mostrato di seguito.

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

</job>

Passo

UN step è una parte indipendente di un lavoro che contiene le informazioni necessarie per definire ed eseguire il lavoro (la sua parte).

Come specificato nel diagramma, ogni passaggio è composto da un ItemReader, ItemProcessor (opzionale) e un ItemWriter. A job may contain one or more steps.

Lettori, scrittori e processori

Un item reader legge i dati in un'applicazione Spring Batch da una particolare origine, mentre un file item writer scrive i dati dall'applicazione Spring Batch in una particolare destinazione.

Un Item processorè una classe che contiene il codice di elaborazione che elabora i dati letti nel batch di primavera. Se l'applicazione legge"n" record, quindi il codice nel processore verrà eseguito su ogni record.

Quando non viene fornito né lettore né scrittore, a taskletfunge da processore per SpringBatch. Elabora solo una singola attività. Ad esempio, se stiamo scrivendo un lavoro con un semplice passaggio in esso in cui leggiamo i dati dal database MySQL e li elaboriamo e li scriviamo in un file (flat), il nostro passaggio utilizza:

• UN reader che legge dal database MySQL.

• UN writer che scrive su un file flat.

• UN custom processor che elabora i dati secondo il nostro desiderio.

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

Spring Batch fornisce un lungo elenco di readers e writers. Usando queste classi predefinite, possiamo definire i bean per loro. Noi discuteremoreaders e writers in maggiore dettaglio nei prossimi capitoli.

JobRepository

Un repository di lavori in Spring Batch fornisce operazioni di creazione, recupero, aggiornamento ed eliminazione (CRUD) per le implementazioni JobLauncher, Job e Step. Definiremo un repository di lavori in un file XML come mostrato di seguito.

<job-repository id = "jobRepository"/>

Inoltre id, sono disponibili altre opzioni (opzionali). Di seguito è riportata la configurazione del repository dei lavori con tutte le opzioni ei loro valori predefiniti.

<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 - Nel caso in cui non si desideri rendere persistenti gli oggetti del dominio di Spring Batch nel database, è possibile configurare la versione in memoria del jobRepository come mostrato di seguito.

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

JobLauncher

JobLauncher è un'interfaccia che avvia il lavoro Spring Batch con l'estensione given set of parameters. SampleJoblauncher è la classe che implementa il JobLauncherinterfaccia. Di seguito è riportata la configurazione di JobLauncher.

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

JobInstance

UN JobInstancerappresenta l'esecuzione logica di un lavoro; viene creato quando eseguiamo un lavoro. Ciascuna istanza di lavoro è differenziata dal nome del lavoro e dai parametri ad essa passati durante l'esecuzione.

Se l'esecuzione di JobInstance non riesce, la stessa JobInstance può essere eseguita di nuovo. Quindi, ogni JobInstance può avere più esecuzioni di lavoro.

JobExecution e StepExecution

JobExecution e StepExecution sono la rappresentazione dell'esecuzione di un lavoro / passo. Contengono le informazioni di esecuzione del lavoro / passo come l'ora di inizio (del lavoro / passo), l'ora di fine (del lavoro / passo).

Quasi tutti gli esempi in questo tutorial contengono i seguenti file:

• File di configurazione (file XML)
• Tasklet / processore (classe Java)
• Classe Java con setter e getter (Java class (bean))
• Classe Mapper (classe Java)
• Classe Launcher (classe Java)

File di configurazione

Il file di configurazione (XML) contiene quanto segue:

• Il job e step definizioni.

• Definizione di fagioli readers e writers.

• Definizione di componenti come JobLauncher, JobRepository, Transaction Manager e Data Source.

Nei nostri esempi, per una migliore comprensione, abbiamo diviso questo in due file job.xml file (definisce lavoro, passo, lettore e scrittore) e context.xml file (avvio lavori, repository lavori, gestore transazioni e origine dati).

Classe Mapper

La classe Mapper, a seconda del lettore, implementa interfacce come row mapper, field set mapper, ecc. Contiene il codice per ottenere i dati dal lettore e impostarlo su una classe Java con setter e getter metodi (Java Bean).

Classe Java Bean

Una classe Java con setters e getters(Java bean) rappresenta i dati con più valori. Agisce come una classe di supporto. Passeremo i dati da un componente (lettore, scrittore, processore) ad un altro sotto forma di oggetto di questa classe.

Tasklet / processore

La classe Tasklet / processore contiene il codice di elaborazione dell'applicazione Spring Batch. Un processore è una classe che accetta un oggetto che contiene i dati letti, lo elabora e restituisce i dati elaborati (nel modulo oggetto).

Classe di avvio

Questa classe (App.java) contiene il codice per avviare l'applicazione Spring Batch.

Durante la scrittura di un'applicazione Spring Batch, configureremo il lavoro, il passaggio, JobLauncher, JobRepository, Transaction Manager, lettori e scrittori utilizzando i tag XML forniti nello spazio dei nomi Spring Batch. Pertanto, è necessario includere questo spazio dei nomi nel file XML come mostrato di seguito.

<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">

Nelle sezioni seguenti, discuteremo i vari tag, i loro attributi ed esempi, disponibili nello spazio dei nomi Spring Batch.

Lavoro

Questo tag viene utilizzato per definire / configurare il lavoro di SpringBatch. Contiene una serie di passaggi e può essere avviato utilizzando JobLauncher.

Questo tag ha 2 attributi elencati di seguito:

S.No	Attributo e descrizione
1	Id È l'ID del lavoro, è obbligatorio specificare un valore per questo attributo.
2	restartable Questo è l'attributo utilizzato per specificare se il lavoro è riavviabile o meno. Questo attributo è facoltativo.

Di seguito è riportata la configurazione XML del lavoro di uno SpringBatch.

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

Passo

Questo tag viene utilizzato per definire / configurare i passaggi di un lavoro SpringBatch. Ha i seguenti tre attributi:

S.No	Attributo e descrizione
1	Id È l'ID del lavoro, è obbligatorio specificare un valore per questo attributo.
2	next È la scorciatoia per specificare il passaggio successivo.
3	parent Viene utilizzato per specificare il nome del bean genitore da cui ereditare la configurazione.

Di seguito è riportata la configurazione XML della fase di uno SpringBatch.

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

Pezzo

Questo tag viene utilizzato per definire / configurare un blocco di un file tasklet. Ha i seguenti quattro attributi:

S.No	Attributo e descrizione
1	reader Rappresenta il nome del bean di lettura dell'elemento. Accetta il valore del tipoorg.springframework.batch.item.ItemReader.
2	writer Rappresenta il nome del bean di lettura dell'elemento. Accetta il valore del tipoorg.springframework.batch.item.ItemWriter.
3	processor Rappresenta il nome del bean di lettura dell'elemento. Accetta il valore del tipoorg.springframework.batch.item.ItemProcessor.
4	commit-interval Viene utilizzato per specificare il numero di articoli da elaborare prima di eseguire il commit della transazione.

Di seguito è riportata la configurazione XML del blocco di 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

Il bean JobRepository viene utilizzato per configurare JobRepository utilizzando un database relazionale. Questo bean è associato alla classe di tipoorg.springframework.batch.core.repository.JobRepository.

S.No	Attributo e descrizione
1	dataSource Viene utilizzato per specificare il nome del bean che definisce l'origine dati.
2	transactionManager Viene utilizzato per specificare il nome del bean che definisce il gestore delle transazioni.
3	databaseType Specifica il tipo di database relazionale utilizzato nel repository dei lavori.

Di seguito è riportata la configurazione di esempio di 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

Il bean JobLauncher viene utilizzato per configurare JobLauncher. È associato alla classeorg.springframework.batch.core.launch.support.SimpleJobLauncher(nei nostri programmi). Questo bean ha una proprietà denominatajobrepository, e viene utilizzato per specificare il nome del bean che definisce il file jobrepository.

Di seguito è riportata la configurazione di esempio del jobLauncher.

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

TransactionManager

Il bean TransactionManager viene utilizzato per configurare TransactionManager utilizzando un database relazionale. Questo bean è associato alla classe di tipoorg.springframework.transaction.platform.TransactionManager.

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

Fonte di dati

Il bean di origine dati viene utilizzato per configurare il file Datasource. Questo bean è associato alla classe di tipoorg.springframework.jdbc.datasource.DriverManagerDataSource.

S.No	Attributo e descrizione
1	driverClassName Specifica il nome della classe del driver utilizzato per connettersi al database.
2	url Specifica l'URL del database.
3	username Specifica il nome utente per connettersi al database.
4	password Specifica la password per connettersi al database.

Di seguito è riportata la configurazione di esempio di 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 legge i dati nell'applicazione batch di primavera da una particolare origine, mentre un file Item Writer scrive i dati dall'applicazione Spring Batch in una particolare destinazione.

Un Item processorè una classe che contiene il codice di elaborazione che elabora i dati letti nel batch di primavera. Se l'applicazione legge n record, il codice nel processore verrà eseguito su ogni record.

UN chunk è un elemento figlio di tasklet. Viene utilizzato per eseguire operazioni di lettura, scrittura ed elaborazione. Possiamo configurare lettore, scrittore e processori utilizzando questo elemento, in un passaggio come mostrato di seguito.

<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 fornisce a lettori e scrittori la lettura e la scrittura di dati da vari file system / database come MongoDB, Neo4j, MySQL, XML, flatfile, CSV, ecc.

Per includere un lettore nella tua applicazione, devi definire un bean per quel lettore, fornire valori a tutte le proprietà richieste all'interno del bean e passare il id di tale bean come valore per l'attributo dell'elemento chunk reader (lo stesso per writer).

ItemReader

È l'entità di una fase (di un processo batch) che legge i dati. Un ItemReader legge un elemento alla volta. Spring Batch fornisce un'interfacciaItemReader. Tutti ireaders implementare questa interfaccia.

Di seguito sono riportate alcune delle classi ItemReader predefinite fornite da Spring Batch per leggere da varie fonti.

Lettore	Scopo
FlatFIleItemReader	Per leggere dati da file flat.
StaxEventItemReader	Per leggere dati da file XML.
StoredProcedureItemReader	Per leggere i dati dalle procedure memorizzate di un database.
JDBCPagingItemReader	Per leggere i dati dal database dei database relazionali.
MongoItemReader	Per leggere i dati da MongoDB.
Neo4jItemReader	Per leggere i dati da Neo4jItemReader.

Dobbiamo configurare il file ItemReaderscreando i fagioli. Di seguito è riportato un esempio diStaxEventItemReader che legge i dati da un file 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>

Come osservato, durante la configurazione, dobbiamo specificare il rispettivo nome della classe del lettore richiesto e dobbiamo fornire valori a tutte le proprietà richieste.

ItemWriter

È l'elemento di stepdi un processo batch che scrive dati. Un ItemWriter scrive un elemento alla volta. Spring Batch fornisce un'interfacciaItemWriter. Tutti gli autori implementano questa interfaccia.

Di seguito sono riportate alcune delle classi ItemWriter predefinite fornite da Spring Batch per leggere da varie fonti.

scrittore	Scopo
FlatFIleItemWriter	Per scrivere dati in file flat.
StaxEventItemWriter	Per scrivere dati in file XML.
StoredProcedureItemWriter	Per scrivere dati nelle stored procedure di un database.
JDBCPagingItemWriter	Per scrivere dati nel database dei database relazionali.
MongoItemWriter	Per scrivere dati in MongoDB.
Neo4jItemWriter	Per scrivere dati in Neo4j.

Allo stesso modo, dobbiamo configurare gli ItemWriters creando i bean. Di seguito è riportato un esempio diJdbcCursorItemReader che scrive i dati su un database 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>

Item Processor

ItemProcessor: Un ItemProcessor viene utilizzato per elaborare i dati. Quando l'articolo fornito non è valido, ritornanull, altrimenti elabora l'elemento specificato e restituisce il risultato elaborato. L'interfacciaItemProcessor<I,O> rappresenta il processore.

Tasklet class - Quando no reader e writervengono forniti, un Tasklet funge da processore per SpringBatch. Elabora solo un singolo compito.

Possiamo definire un elaboratore di articoli personalizzato implementando l'interfaccia ItemProcessor del pacchetto org.springframework.batch.item.ItemProcessor. Questa classe ItemProcessor accetta un oggetto ed elabora i dati e restituisce i dati elaborati come un altro oggetto.

In un processo batch, se "n"record o elementi di dati vengono letti, quindi per ogni record leggerà i dati, li elaborerà e li scriverà nel writer. Per elaborare i dati, si riferisce al processore passato.

Ad esempio, supponiamo di aver scritto del codice per caricare un particolare documento PDF, creare una nuova pagina, scrivere l'elemento di dati sul PDF in un formato tabulare. Se esegui questa applicazione, legge tutti gli elementi di dati dal documento XML, li memorizza nel database MySQL e li stampa nel documento PDF fornito in singole pagine.

Esempio

Di seguito è una classe ItemProcessor di esempio.

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; 
   } 
}

Questo capitolo mostra l'applicazione di base Spring Batch. Eseguirà semplicemente un filetasklet per visualizzare un messaggio.

La nostra applicazione Spring Batch contiene i seguenti file:

• Configuration file- Questo è un file XML in cui definiamo il lavoro e le fasi del lavoro. (Se l'applicazione coinvolge anche lettori e scrittori, la configurazione direaders e writers è incluso anche in questo file.)

• Context.xml - In questo file, definiremo i bean come il repository dei lavori, il lanciatore di lavori e il gestore delle transazioni.

• Tasklet class - In questa classe, scriveremo il lavoro del codice di elaborazione (in questo caso, viene visualizzato un semplice messaggio)

• Launcher class - in questa classe, lanceremo l'applicazione batch eseguendo il lanciatore di lavori.

jobConfig.xml

Di seguito è riportato il file di configurazione della nostra applicazione Spring Batch di esempio.

<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

Di seguito è riportato il file context.xml della nostra applicazione 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

Di seguito è riportata la classe Tasklet che visualizza un semplice messaggio.

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

Di seguito è riportato il codice che avvia il processo batch.

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()); 
   }    
}

All'esecuzione, il programma SpringBatch di cui sopra produrrà il seguente output:

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

In questo capitolo creeremo un'applicazione Spring Batch che utilizza un lettore XML e un writer MySQL.

Reader - Il lettore che stiamo usando nell'applicazione è StaxEventItemReader per leggere dati da documenti XML.

Di seguito è riportato il documento XML di input che stiamo utilizzando in questa applicazione. Questo documento contiene record di dati che specificano dettagli come ID tutorial, autore del tutorial, titolo del tutorial, data di invio, icona del tutorial e descrizione del tutorial.

<?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 - Il writer che stiamo usando nell'applicazione è JdbcBatchItemWriterper scrivere i dati nel database MySQL. Supponiamo di aver creato una tabella in MySQL all'interno di un database chiamato"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 - Il processore che stiamo utilizzando nell'applicazione è un processore personalizzato che scrive i dati di ogni record sul documento PDF.

Nel processo batch, se "n"record o elementi di dati sono stati letti, quindi per ogni record leggerà i dati, li elaborerà e scriverà i dati nel writer. Per elaborare i dati, si riferisce al processore passato. In questo caso, nella classe del processore personalizzato, abbiamo scritto il codice per caricare un particolare documento PDF, creare una nuova pagina, scrivere l'elemento di dati sul PDF in un formato tabulare.

Infine, se esegui questa applicazione, legge tutti gli elementi di dati dal documento XML, li memorizza nel database MySQL e li stampa nel documento PDF dato in singole pagine.

jobConfig.xml

Di seguito è riportato il file di configurazione della nostra applicazione Spring Batch di esempio. In questo file definiremo il lavoro e i passaggi. Oltre a questi, definiamo anche i bean per ItemReader, ItemProcessor e ItemWriter. (Qui, li associamo alle rispettive classi e passiamo i valori per le proprietà richieste per configurarli.)

<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

Di seguito è riportato il file context.xmldella nostra applicazione Spring Batch. In questo file, definiremo i bean come il repository dei lavori, il lanciatore di lavori e il gestore delle transazioni.

<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

Di seguito è riportato il file processorclasse. In questa classe, scriviamo il codice di elaborazione nell'applicazione. Qui stiamo caricando un documento PDF, creando una nuova pagina, creando una tabella e inserendo i seguenti valori per ogni record: id tutorial, nome tutorial, autore, data di invio nella tabella.

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

Di seguito è riportata la classe ReportFieldSetMapper che imposta i dati sulla 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

Di seguito è riportato il file Tutorialclasse. È una classe semplice consetter e getter metodi.

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

Di seguito è riportato il codice che avvia il processo batch. In questa classe, lanceremo l'applicazione batch eseguendo 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()); 
   }    
}

Quando si esegue questa applicazione, produrrà il seguente output.

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

Se verifichi il file details.tutorial tabella nel database, ti mostrerà il seguente output:

tutorial _id	tutorial _author	tutorial _title	data di presentazione	tutorial _icon	tutorial _description
1001	Sanjay	Impara Java	06-05-2007	https: //www.tutorials point.com / java / images / java-mini-logo.jpg	Java è un linguaggio di programmazione di alto livello originariamente sviluppato da Sun Microsystems e rilasciato nel 1995. Java può essere eseguito su una varietà di piattaforme. Questo tutorial fornisce una comprensione completa di Java.
1002	Abdul S	Impara MySQL	19-04-2007	https: // www. tutorialspoint.com / mysql / images /mysql-minilogo.jpg	MySQL è il più popolare sistema di gestione di database SQL relazionale open source. MySQL è uno dei migliori RDBMS utilizzati per lo sviluppo di applicazioni software basate sul web. Questo tutorial ti darà un rapido avvio con MySQL e ti farà sentire a tuo agio con la programmazione MySQL.
1003	Impara JavaFX	Krishna Kasyap	06-07-2017	https: // www. tutorialspoint.com / javafx / images / javafx-minilogo.jpg	MySQL è il più popolare sistema di gestione di database SQL relazionale open source. MySQL è uno dei migliori RDBMS utilizzati per lo sviluppo di applicazioni software basate sul web. Questo tutorial ti darà un rapido avvio con MySQL e ti farà sentire a tuo agio con la programmazione MySQL.

Questo genererà un PDF con i record su ogni pagina come mostrato di seguito.

In questo capitolo creeremo una semplice applicazione Spring Batch che utilizza un lettore CSV e un writer XML.

Reader - Il reader che stiamo usando nell'applicazione è FlatFileItemReader per leggere i dati dai file CSV.

Di seguito è riportato il file CSV di input che stiamo utilizzando in questa applicazione. Questo documento contiene record di dati che specificano dettagli come l'ID del tutorial, l'autore del tutorial, il titolo del tutorial, la data di invio, l'icona del tutorial e la descrizione del tutorial.

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

Writer - Il writer che stiamo utilizzando nell'applicazione è StaxEventItemWriter per scrivere i dati nel file XML.

Processor - Il processore che stiamo utilizzando nell'applicazione è un processore personalizzato che stampa solo i record letti dal file CSV.

jobConfig.xml

Di seguito è riportato il file di configurazione della nostra applicazione Spring Batch di esempio. In questo file definiremo il lavoro e i passaggi. Oltre a questi, definiamo anche i bean per ItemReader, ItemProcessor e ItemWriter. (Qui, li associamo alle rispettive classi e passiamo i valori per le proprietà richieste per configurarli.)

<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

Di seguito è riportato il file context.xmldella nostra applicazione Spring Batch. In questo file, definiremo i bean come il repository dei lavori, il lanciatore di lavori e il gestore delle transazioni.

<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

Di seguito è riportata la classe Processor. In questa classe, scriviamo il codice di elaborazione nell'applicazione. Qui stiamo stampando il contenuto di ogni record.

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

Di seguito è riportata la classe TutorialFieldSetMapper che imposta i dati sulla 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

Di seguito è riportato il file Tutorialclasse. È una semplice classe Java consetter e gettermetodi. In questa classe, stiamo usando le annotazioni per associare i metodi di questa classe ai tag del file 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

Di seguito è riportato il codice che avvia il processo batch. In questa classe, lanceremo l'applicazione batch eseguendo 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()); 
   } 
}

Quando si esegue questa applicazione, produrrà il seguente output.

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

Questo genererà un file XML con i seguenti contenuti.

<?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>

In questo capitolo creeremo un'applicazione Spring Batch che utilizza un lettore MySQL e un writer XML.

Reader - Il lettore che stiamo usando nell'applicazione è JdbcCursorItemReader per leggere i dati dal database MySQL.

Supponiamo di aver creato una tabella nel database MySQL come mostrato di seguito -

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

Supponiamo di aver inserito i seguenti record in esso.

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 - Il writer che stiamo utilizzando nell'applicazione è StaxEventItemWriter per scrivere i dati nel file XML.

Processor - Il processore che stiamo utilizzando nell'applicazione è un processore personalizzato che stampa solo i record letti dal file CSV.

jobConfig.xml

Di seguito è riportato il file di configurazione della nostra applicazione Spring Batch di esempio. In questo file definiremo il lavoro e i passaggi. Oltre a questi, definiamo anche i bean per ItemReader, ItemProcessor e ItemWriter. (Qui, li associamo alle rispettive classi e passiamo i valori per le proprietà richieste per configurarli.)

<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

Di seguito è riportato il file context.xmldella nostra applicazione Spring Batch. In questo file, definiremo i bean come il repository dei lavori, il lanciatore di lavori e il gestore delle transazioni.

<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

Di seguito è riportata la classe Processor. In questa classe, scriviamo il codice di elaborazione nell'applicazione. Qui stiamo stampando il contenuto di ogni record.

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

Di seguito è riportato il file TutorialRowMapper classe che imposta i dati su 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

Di seguito è riportato il file Tutorialclasse. È una semplice classe Java consetter e gettermetodi. In questa classe, stiamo usando le annotazioni per associare i metodi di questa classe ai tag del file 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

Di seguito è riportato il codice che avvia il processo batch. In questa classe, lanceremo l'applicazione batch eseguendo 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()); 
   } 
}

Quando si esegue questa applicazione, produrrà il seguente output.

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

Questo genererà un file XML con i seguenti contenuti.

<?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>

In questo capitolo, creeremo un'applicazione Spring Batch che utilizza un MySQL Reader e un file Flatfile Writer (.txt).

Reader - Il Reader che stiamo utilizzando nell'applicazione è JdbcCursorItemReader per leggere i dati dal database MySQL.

Supponiamo di aver creato una tabella nel database MySQL come mostrato di seguito.

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

Supponiamo di aver inserito i seguenti record in esso.

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 - Il writer che stiamo utilizzando nell'applicazione è FlatFileItemWriter in cui scrivere i dati flatfile (.testo).

Processor - Il processore che stiamo utilizzando nell'applicazione è un processore personalizzato che stampa solo i record letti dal file CSV.

jobConfig.xml

Di seguito è riportato il file di configurazione della nostra applicazione Spring Batch di esempio. In questo file definiremo il lavoro e i passaggi. Oltre a questi, definiamo anche i bean per ItemReader, ItemProcessor e ItemWriter. (Qui, li associamo alle rispettive classi e passiamo i valori per le proprietà richieste per configurarli.)

<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

Di seguito è riportato il file context.xmldella nostra applicazione Spring Batch. In questo file, definiremo i bean come il repository dei lavori, il lanciatore di lavori e il gestore delle transazioni.

<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

Di seguito è riportata la classe Processor. In questa classe, scriviamo il codice di elaborazione nell'applicazione. Qui stiamo stampando il contenuto di ogni record.

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

Di seguito è riportato il file TutorialRowMapper classe che imposta i dati su 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

Di seguito è riportato il file Tutorialclasse. È una semplice classe Java consetter e gettermetodi. In questa classe, stiamo usando le annotazioni per associare i metodi di questa classe ai tag del file 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

Di seguito è riportato il codice che avvia il processo batch. In questa classe, lanceremo l'applicazione batch eseguendo 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()); 
   } 
}

Quando si esegue questa applicazione, produrrà il seguente output.

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

Questo genererà un file .txt file con i seguenti contenuti.

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]