Spring Batch - Guia rápido
Batch processingé um modo de processamento que envolve a execução de uma série de trabalhos complexos automatizados sem interação do usuário. Um processo em lote lida com dados em massa e é executado por um longo tempo.
Vários aplicativos corporativos exigem o processamento de dados enormes para realizar operações que envolvem -
Eventos baseados no tempo, como cálculos periódicos.
Aplicativos periódicos que são processados repetidamente em grandes conjuntos de dados.
Aplicativos que tratam do processamento e validação dos dados disponíveis de forma transacional.
Portanto, o processamento em lote é usado em aplicativos corporativos para realizar essas transações.
O que é Spring Batch
Lote de primavera é um lightweight framework que é usado para desenvolver Batch Applications que são usados em aplicativos corporativos.
Além do processamento em massa, esta estrutura fornece funções para -
- Incluindo registro e rastreamento
- Gestão de transações
- Estatísticas de processamento de trabalho
- Reinício de trabalho
- Pular e gerenciamento de recursos
Você também pode dimensionar aplicações de lote de primavera usando suas técnicas de porcionamento.
Características do Spring Batch
A seguir estão os recursos notáveis do Spring Batch -
Flexibility- Os aplicativos Spring Batch são flexíveis. Você simplesmente precisa alterar um arquivo XML para alterar a ordem de processamento em um aplicativo.
Maintainability- Os aplicativos Spring Batch são fáceis de manter. Uma tarefa Spring Batch inclui etapas e cada etapa pode ser desacoplada, testada e atualizada, sem afetar as outras etapas.
Scalability- Usando as técnicas de porcionamento, você pode dimensionar os aplicativos Spring Batch. Essas técnicas permitem que você -
Execute as etapas de um trabalho em paralelo.
Execute um único thread em paralelo.
Reliability - Em caso de alguma falha, você pode reiniciar o trabalho exatamente de onde foi interrompido, desacoplando as etapas.
Support for multiple file formats - Spring Batch fornece suporte para um grande conjunto de leitores e gravadores, como XML, arquivo simples, CSV, MYSQL, Hibernate, JDBC, Mongo, Neo4j, etc.
Multiple ways to launch a job - Você pode iniciar um trabalho Spring Batch usando aplicativos da web, programas Java, linha de comando, etc.
Além disso, os aplicativos Spring Batch suportam -
Nova tentativa automática após falha.
Status e estatísticas de rastreamento durante a execução em lote e após a conclusão do processamento em lote.
Para executar trabalhos simultâneos.
Serviços como registro, gerenciamento de recursos, ignorar e reiniciar o processamento.
Neste capítulo, explicaremos como definir o ambiente Spring Batch no Eclipse IDE. Antes de prosseguir com a instalação, certifique-se de ter instalado o Eclipse em seu sistema. Caso contrário, baixe e instale o Eclipse em seu sistema.
Para obter mais informações sobre o Eclipse, consulte nosso Tutorial do Eclipse.
Configurando Spring Batch no Eclipse
Siga as etapas fornecidas abaixo para definir o ambiente Spring Batch no Eclipse.
Step 1 - Instale o Eclipse e abra um Novo Projeto, conforme mostrado na captura de tela a seguir.
Step 2 - Crie um projeto Sample Spring Batch conforme mostrado abaixo.
Step 3- Clique com o botão direito no projeto e converta-o em um projeto Maven conforme mostrado abaixo. Depois de convertê-lo em projeto Maven, ele lhe dará umPom.xmlonde você precisa mencionar as dependências necessárias. Depois disso, ojar arquivos desses serão baixados automaticamente em seu projeto.
Step 4 - Agora, no pom.xml do projeto, copie e cole o seguinte conteúdo (dependências para o aplicativo de lote de primavera) e atualize o projeto.
<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>Finalmente, se você observar as dependências do Maven, poderá observar que todos os jar arquivos foram baixados.
A seguir está a representação esquemática da arquitetura do Spring Batch. Conforme representado na figura, a arquitetura contém três componentes principais, a saber,Application, Batch Coree Batch Infrastructure.
Application - Este componente contém todos os trabalhos e o código que escrevemos usando a estrutura Spring Batch.
Batch Core - Este componente contém todas as classes de API que são necessárias para controlar e iniciar um Batch Job.
Batch Infrastructure - Este componente contém os leitores, gravadores e serviços usados pelos componentes principais do aplicativo e do Batch.
Componentes do Spring Batch
A ilustração a seguir mostra os diferentes componentes do Spring Batch e como eles estão conectados entre si.
Trabalho
Em um aplicativo Spring Batch, um trabalho é o processo em lote que deve ser executado. Funciona do início ao fim, sem interrupção. Este trabalho é dividido em etapas (ou um trabalho contém etapas).
Vamos configurar um trabalho no Spring Batch usando um arquivo XML ou uma classe Java. A seguir está a configuração XML de um trabalho no Spring Batch.
<job id = "jobid">
<step id = "step1" next = "step2"/>
<step id = "step2" next = "step3"/>
<step id = "step3"/>
</job>Um trabalho em lote é configurado nas tags <job> </job>. Tem um atributo chamadoid. Dentro dessas tags, definimos a definição e a ordem das etapas.
Restartable - Em geral, quando um trabalho está em execução e tentamos reiniciá-lo, isso é considerado restarte será reiniciado. Para evitar isso, você precisa definir orestartable valor para false como mostrado abaixo.
<job id = "jobid" restartable = "false" >
</job>Degrau
UMA step é uma parte independente de um trabalho que contém as informações necessárias para definir e executar o trabalho (sua parte).
Conforme especificado no diagrama, cada etapa é composta por um ItemReader, ItemProcessor (opcional) e um ItemWriter. A job may contain one or more steps.
Leitores, escritores e processadores
A item reader lê dados em um aplicativo Spring Batch de uma fonte específica, enquanto um item writer grava dados do aplicativo Spring Batch em um destino específico.
A Item processoré uma classe que contém o código de processamento que processa os dados lidos no lote de primavera. Se o aplicativo lê"n" registros, então o código no processador será executado em cada registro.
Quando nenhum leitor e escritor são fornecidos, um taskletatua como um processador para SpringBatch. Ele processa apenas uma única tarefa. Por exemplo, se estivermos escrevendo um trabalho com uma etapa simples, onde lemos dados do banco de dados MySQL, processamos e gravamos em um arquivo (simples), então nossa etapa usa -
UMA reader que lê do banco de dados MySQL.
UMA writer que grava em um arquivo simples.
UMA custom processor que processa os dados conforme nosso desejo.
<job id = "helloWorldJob">
<step id = "step1">
<tasklet>
<chunk reader = "mysqlReader" writer = "fileWriter"
processor = "CustomitemProcessor" ></chunk>
</tasklet>
</step>
</ job>Spring Batch fornece uma longa lista de readers e writers. Usando essas classes predefinidas, podemos definir beans para elas. Vamos discutirreaders e writers com mais detalhes nos próximos capítulos.
JobRepository
Um repositório de Job em Spring Batch fornece operações Create, Retrieve, Update, and Delete (CRUD) para as implementações JobLauncher, Job e Step. Vamos definir um repositório de trabalhos em um arquivo XML, conforme mostrado abaixo.
<job-repository id = "jobRepository"/>Além de id, existem mais algumas opções (opcionais) disponíveis. A seguir está a configuração do repositório de tarefas com todas as opções e seus valores padrão.
<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 - Caso você não queira manter os objetos de domínio do Spring Batch no banco de dados, você pode configurar a versão na memória do jobRepository conforme mostrado abaixo.
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean ">
<property name = "transactionManager" ref = "transactionManager"/>
</bean>JobLauncher
JobLauncher é uma interface que inicia o trabalho Spring Batch com o given set of parameters. SampleJoblauncher é a classe que implementa o JobLauncherinterface. A seguir está a configuração do JobLauncher.
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>JobInstance
UMA JobInstancerepresenta a execução lógica de um trabalho; ele é criado quando executamos um trabalho. Cada instância da tarefa é diferenciada pelo nome da tarefa e pelos parâmetros passados a ela durante a execução.
Se a execução de JobInstance falhar, o mesmo JobInstance pode ser executado novamente. Portanto, cada JobInstance pode ter várias execuções de trabalho.
JobExecution e StepExecution
JobExecution e StepExecution são a representação da execução de um job / etapa. Eles contêm as informações de execução da tarefa / etapa, como hora de início (da tarefa / etapa), hora de término (da tarefa / etapa).
Quase todos os exemplos neste tutorial contêm os seguintes arquivos -
- Arquivo de configuração (arquivo XML)
- Tasklet / processador (classe Java)
- Classe Java com setters e getters (classe Java (bean))
- Classe Mapper (classe Java)
- Classe Launcher (classe Java)
Arquivo de configuração
O arquivo de configuração (XML) contém o seguinte -
o job e step definições.
Definição de feijão readers e writers.
Definição de componentes como JobLauncher, JobRepository, Transaction Manager e Data Source.
Em nossos exemplos, para melhor compreensão, dividimos isso em dois arquivos, job.xml arquivo (define trabalho, etapa, leitor e escritor) e context.xml arquivo (lançador de trabalhos, repositório de trabalhos, gerenciador de transações e fonte de dados).
Classe Mapper
A classe Mapper, dependendo do leitor, implementa interfaces como row mapper, field set mapper, etc. Ele contém o código para obter os dados do leitor e defini-los para uma classe Java com setter e getter métodos (Java Bean).
Classe Java Bean
Uma classe Java com setters e getters(Java bean) representa dados com vários valores. Ele atua como uma classe auxiliar. Vamos passar os dados de um componente (leitor, gravador, processador) para outro na forma de objeto desta classe.
Tasklet / processador
A classe Tasklet / processador contém o código de processamento do aplicativo Spring Batch. Um processador é uma classe que aceita um objeto que contém os dados lidos, os processa e retorna os dados processados (no objeto de formulário).
Classe lançador
Esta classe (App.java) contém o código para iniciar o aplicativo Spring Batch.
Ao escrever um aplicativo Spring Batch, configuraremos o trabalho, etapa, JobLauncher, JobRepository, Gerenciador de transações, leitores e gravadores usando as tags XML fornecidas no namespace Spring Batch. Portanto, você precisa incluir este namespace em seu arquivo XML, conforme mostrado abaixo.
<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">Nas seções a seguir, discutiremos as várias tags, seus atributos e exemplos, disponíveis no namespace Spring Batch.
Trabalho
Esta tag é usada para definir / configurar o trabalho do SpringBatch. Ele contém um conjunto de etapas e pode ser iniciado usando o JobLauncher.
Esta tag tem 2 atributos listados abaixo -
| S.Não | Atributo e descrição |
|---|---|
| 1 | Id É o Id do trabalho, é obrigatório especificar o valor para este atributo. |
| 2 | restartable Este é o atributo que é usado para especificar se o trabalho pode ser reiniciado ou não. Este atributo é opcional. |
A seguir está a configuração XML do trabalho de um SpringBatch.
<job id = "jobid" restartable = "false" >
. . . . . . . .
. . . . . . . .
. . . . . . . . // Step definitions
</job>Degrau
Esta tag é usada para definir / configurar as etapas de um trabalho SpringBatch. Ele tem os seguintes três atributos -
| S.Não | Atributo e descrição |
|---|---|
| 1 | Id É o Id do trabalho, é obrigatório especificar o valor para este atributo. |
| 2 | next É o atalho para especificar a próxima etapa. |
| 3 | parent É usado para especificar o nome do bean pai do qual a configuração deve herdar. |
A seguir está a configuração XML da etapa de um SpringBatch.
<job id = "jobid">
<step id = "step1" next = "step2"/>
<step id = "step2" next = "step3"/>
<step id = "step3"/>
</job>Pedaço
Esta tag é usada para definir / configurar um pedaço de um tasklet. Possui os seguintes quatro atributos -
| S.Não | Atributo e descrição |
|---|---|
| 1 | reader Ele representa o nome do bean do leitor de item. Aceita o valor do tipoorg.springframework.batch.item.ItemReader. |
| 2 | writer Ele representa o nome do bean do leitor de item. Aceita o valor do tipoorg.springframework.batch.item.ItemWriter. |
| 3 | processor Ele representa o nome do bean do leitor de item. Aceita o valor do tipoorg.springframework.batch.item.ItemProcessor. |
| 4 | commit-interval É usado para especificar o número de itens a serem processados antes de confirmar a transação. |
A seguir está a configuração XML do pedaço de um 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
O JobRepository Bean é usado para configurar o JobRepository usando um banco de dados relacional. Este bean está associado à classe do tipoorg.springframework.batch.core.repository.JobRepository.
| S.Não | Atributo e descrição |
|---|---|
| 1 | dataSource É usado para especificar o nome do bean que define a fonte de dados. |
| 2 | transactionManager É usado para especificar o nome do bean que define o gerenciador de transações. |
| 3 | databaseType Ele especifica o tipo de banco de dados relacional usado no repositório de tarefas. |
A seguir está o exemplo de configuração do 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
O bean JobLauncher é usado para configurar o JobLauncher. Está associado à classeorg.springframework.batch.core.launch.support.SimpleJobLauncher(em nossos programas). Este bean tem uma propriedade chamadajobrepository, e é usado para especificar o nome do bean que define o jobrepository.
A seguir está o exemplo de configuração do jobLauncher.
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>TransactionManager
O bean TransactionManager é usado para configurar o TransactionManager usando um banco de dados relacional. Este bean está associado à classe do tipoorg.springframework.transaction.platform.TransactionManager.
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />Fonte de dados
O bean da fonte de dados é usado para configurar o Datasource. Este bean está associado à classe do tipoorg.springframework.jdbc.datasource.DriverManagerDataSource.
| S.Não | Atributo e descrição |
|---|---|
| 1 | driverClassName Isso especifica o nome da classe do driver usado para se conectar ao banco de dados. |
| 2 | url Isso especifica a URL do banco de dados. |
| 3 | username Isso especifica o nome de usuário para se conectar ao banco de dados. |
| 4 | password Isso especifica a senha para se conectar ao banco de dados. |
A seguir está o exemplo de configuração do 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>A Item Reader lê dados no aplicativo de lote de primavera de uma fonte específica, enquanto um Item Writer grava dados do aplicativo Spring Batch em um destino específico.
A Item processoré uma classe que contém o código de processamento que processa os dados lidos no lote de primavera. Se o aplicativo ler n registros, o código no processador será executado em cada registro.
UMA chunk é um elemento filho de tasklet. É usado para executar operações de leitura, gravação e processamento. Podemos configurar leitor, gravador e processadores usando este elemento, em uma etapa conforme mostrado abaixo.
<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 fornece leitores e gravadores para ler e gravar dados de vários sistemas de arquivos / bancos de dados, como MongoDB, Neo4j, MySQL, XML, flatfile, CSV, etc.
Para incluir um leitor em seu aplicativo, você precisa definir um bean para esse leitor, fornecer valores para todas as propriedades necessárias dentro do bean e passar o id de tal bean como um valor para o atributo do elemento chunk reader (o mesmo para writer)
ItemReader
É a entidade de uma etapa (de um processo em lote) que lê os dados. Um ItemReader lê um item por vez. Spring Batch fornece uma interfaceItemReader. Todosreaders implementar esta interface.
A seguir estão algumas das classes ItemReader predefinidas fornecidas pelo Spring Batch para leitura de várias fontes.
| Leitor | Objetivo |
|---|---|
| FlatFIleItemReader | Para ler dados de arquivos simples. |
| StaxEventItemReader | Para ler dados de arquivos XML. |
| StoredProcedureItemReader | Para ler dados dos procedimentos armazenados de um banco de dados. |
| JDBCPagingItemReader | Para ler dados de banco de dados de banco de dados relacional. |
| MongoItemReader | Para ler dados do MongoDB. |
| Neo4jItemReader | Para ler dados do Neo4jItemReader. |
Precisamos configurar o ItemReaderscriando os grãos. A seguir está um exemplo deStaxEventItemReader que lê dados de um arquivo 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>Conforme observado, durante a configuração, precisamos especificar o respectivo nome de classe do leitor necessário e precisamos fornecer valores para todas as propriedades necessárias.
ItemWriter
É o elemento do stepde um processo em lote que grava dados. Um ItemWriter grava um item por vez. Spring Batch fornece uma interfaceItemWriter. Todos os escritores implementam essa interface.
A seguir estão algumas das classes ItemWriter predefinidas fornecidas pelo Spring Batch para leitura de várias fontes.
| Escritor | Objetivo |
|---|---|
| FlatFIleItemWriter | Para gravar dados em arquivos simples. |
| StaxEventItemWriter | Para gravar dados em arquivos XML. |
| StoredProcedureItemWriter | Para gravar dados nos procedimentos armazenados de um banco de dados. |
| JDBCPagingItemWriter | Para gravar dados em bancos de dados relacionais. |
| MongoItemWriter | Para gravar dados no MongoDB. |
| Neo4jItemWriter | Para gravar dados no Neo4j. |
Da mesma forma, precisamos configurar os ItemWriters criando os beans. A seguir está um exemplo deJdbcCursorItemReader que grava dados em um banco de dados 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>Processador de Item
ItemProcessor: Um ItemProcessor é usado para processar os dados. Quando o item fornecido não é válido, ele retornanull, caso contrário, ele processa o item fornecido e retorna o resultado processado. A interfaceItemProcessor<I,O> representa o processador.
Tasklet class - quando não reader e writersão fornecidos, um Tasklet atua como um processador para SpringBatch. Ele processa apenas uma tarefa.
Podemos definir um processador de item personalizado implementando a interface ItemProcessor do pacote org.springframework.batch.item.ItemProcessor. Esta classe ItemProcessor aceita um objeto e processa os dados e retorna os dados processados como outro objeto.
Em um processo em lote, se "n"registros ou elementos de dados são lidos e, para cada registro, ele lê os dados, processa-os e grava os dados no gravador. Para processar os dados, ele retransmite no processador passado.
Por exemplo, suponha que você tenha escrito um código para carregar um documento PDF específico, criar uma nova página, gravar o item de dados no PDF em um formato tabular. Se você executar este aplicativo, ele lerá todos os itens de dados do documento XML, os armazenará no banco de dados MySQL e os imprimirá no documento PDF fornecido em páginas individuais.
Exemplo
A seguir está um exemplo 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;
}
}Este capítulo mostra o aplicativo Spring Batch básico. Ele simplesmente executará umtasklet para exibir uma mensagem.
Nosso aplicativo Spring Batch contém os seguintes arquivos -
Configuration file- Este é um arquivo XML onde definimos o trabalho e as etapas do trabalho. (Se o aplicativo envolver leitores e escritores também, a configuração doreaders e writers também está incluído neste arquivo.)
Context.xml - Neste arquivo, definiremos os beans como repositório de trabalhos, lançador de trabalhos e gerenciador de transações.
Tasklet class - Nesta aula, vamos escrever o trabalho de código de processamento (neste caso, ele exibe uma mensagem simples)
Launcher class - nesta aula, iniciaremos o aplicativo em lote executando o lançador de trabalhos.
jobConfig.xml
A seguir está o arquivo de configuração de nosso aplicativo Spring Batch de amostra.
<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
A seguir está o context.xml de nosso aplicativo 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
A seguir está a classe Tasklet que exibe uma mensagem simples.
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
A seguir está o código que inicia o processo em lote.
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());
}
}Ao ser executado, o programa SpringBatch acima produzirá a seguinte saída -
Apr 24, 2017 4:40:54 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO:Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@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 : COMPLETEDNeste capítulo, criaremos um aplicativo Spring Batch que usa um XML Reader e um MySQL Writer.
Reader - O leitor que estamos usando no aplicativo é StaxEventItemReader para ler dados de documentos XML.
A seguir está o documento XML de entrada que estamos usando neste aplicativo. Este documento contém registros de dados que especificam detalhes como id do tutorial, autor do tutorial, título do tutorial, data de envio, ícone do tutorial e descrição do 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 - o writer que estamos usando no aplicativo é JdbcBatchItemWriterpara gravar os dados no banco de dados MySQL. Suponha que criamos uma tabela no MySQL dentro de um banco de dados chamado"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 - O processador que usamos na aplicação é um processador personalizado que grava os dados de cada registro no documento PDF.
No processo em lote, se "n"registros ou elementos de dados foram lidos, então para cada registro, ele irá ler os dados, processá-los e gravar os dados no Writer. Para processar os dados, ele retransmite no processador passado. Nesse caso, na classe de processador personalizado, escrevemos o código para carregar um documento PDF específico, criar uma nova página, gravar o item de dados no PDF em um formato tabular.
Finalmente, se você executar este aplicativo, ele lê todos os itens de dados do documento XML, os armazena no banco de dados MySQL e os imprime no documento PDF fornecido em páginas individuais.
jobConfig.xml
A seguir está o arquivo de configuração de nosso aplicativo Spring Batch de amostra. Neste arquivo definiremos o Job e as etapas. Além disso, também definimos os beans para ItemReader, ItemProcessor e ItemWriter. (Aqui, nós os associamos com suas respectivas classes e passamos os valores para as propriedades necessárias para configurá-los.)
<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
A seguir está o context.xmlde nosso aplicativo Spring Batch. Neste arquivo, definiremos os beans como repositório de trabalhos, lançador de trabalhos e gerenciador de transações.
<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
A seguir está o processorclasse. Nesta aula, escrevemos o código de processamento no aplicativo. Aqui, estamos carregando um documento PDF, criando uma nova página, criando uma tabela e inserindo os seguintes valores para cada registro: id do tutorial, nome do tutorial, autor, data de envio na tabela.
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
A seguir está a classe ReportFieldSetMapper, que define os dados para a 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
A seguir está o Tutorialclasse. É uma aula simples comsetter e getter métodos.
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
A seguir está o código que inicia o processo em lote. Nesta aula, iniciaremos o aplicativo em lote executando o 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());
}
}Ao executar este aplicativo, ele produzirá a seguinte saída.
May 05, 2017 4:39:22 PM org.springframework.context.support.ClassPathXmlApplicationContext
prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@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 : COMPLETEDSe você verificar o details.tutorial tabela no banco de dados, ele mostrará a seguinte saída -
| tutorial _id | tutorial _author | tutorial _title | data de submissão | tutorial _icon | tutorial _description |
|---|---|---|---|---|---|
| 1001 | Sanjay | Aprenda Java | 06-05-2007 | https: //www.tutorials point.com / java / images / java-mini-logo.jpg | Java é uma linguagem de programação de alto nível desenvolvida originalmente pela Sun Microsystems e lançada em 1995. Java é executado em uma variedade de plataformas. Este tutorial fornece uma compreensão completa do Java. |
| 1002 | Abdul S | Aprenda MySQL | 19-04-2007 | https: // www. tutorialspoint.com / mysql / images /mysql-minilogo.jpg | MySQL é o mais popular sistema de gerenciamento de banco de dados SQL Relacional de código aberto. MySQL é um dos melhores RDBMS usados para desenvolver aplicativos de software baseados na web. Este tutorial fornecerá um início rápido com o MySQL e deixará você confortável com a programação do MySQL. |
| 1003 | Aprenda JavaFX | Krishna Kasyap | 07/06/2017 | https: // www. tutorialspoint.com / javafx / images / javafx-minilogo.jpg | MySQL é o mais popular sistema de gerenciamento de banco de dados SQL Relacional de código aberto. MySQL é um dos melhores RDBMS usados para desenvolver aplicativos de software baseados na web. Este tutorial fornecerá um início rápido com o MySQL e deixará você confortável com a programação do MySQL. |
Isso irá gerar um PDF com os registros em cada página conforme mostrado abaixo.
Neste capítulo, criaremos um aplicativo Spring Batch simples que usa um CSV Reader e um XML Writer.
Reader - o reader que estamos usando no aplicativo é FlatFileItemReader para ler dados dos arquivos CSV.
A seguir está o arquivo CSV de entrada que estamos usando neste aplicativo. Este documento contém registros de dados que especificam detalhes como id do tutorial, autor do tutorial, título do tutorial, data de envio, ícone do tutorial e descrição do tutorial.
1001, "Sanjay", "Learn Java", 06/05/2007
1002, "Abdul S", "Learn MySQL", 19/04/2007
1003, "Krishna Kasyap", "Learn JavaFX", 06/07/2017Writer - O escritor que estamos usando no aplicativo é StaxEventItemWriter para gravar os dados no arquivo XML.
Processor - O processador que estamos usando no aplicativo é um processador personalizado que apenas imprime os registros lidos do arquivo CSV.
jobConfig.xml
A seguir está o arquivo de configuração de nosso aplicativo Spring Batch de amostra. Neste arquivo definiremos o Job e as etapas. Além disso, também definimos os beans para ItemReader, ItemProcessor e ItemWriter. (Aqui, nós os associamos às respectivas classes e passamos os valores para as propriedades necessárias para configurá-los.)
<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
A seguir está o context.xmlde nosso aplicativo Spring Batch. Neste arquivo, definiremos os beans como repositório de trabalhos, lançador de trabalhos e gerenciador de transações.
<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
A seguir está a classe Processor. Nesta aula, escrevemos o código de processamento no aplicativo. Aqui, estamos imprimindo o conteúdo de cada registro.
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
A seguir está a classe TutorialFieldSetMapper que define os dados para a 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;
}
}Classe Tutorial.java
A seguir está o Tutorialclasse. É uma classe Java simples comsetter e gettermétodos. Nesta classe, estamos usando anotações para associar os métodos desta classe às tags do arquivo 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
A seguir está o código que inicia o processo em lote. Nesta aula, iniciaremos o aplicativo em lote executando o 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());
}
}Ao executar este aplicativo, ele produzirá a seguinte saída.
May 08, 2017 10:10:12 AM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing
org.springframework.context.support.ClassPathXmlApplicationContext@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 : COMPLETEDIsso irá gerar um arquivo XML com o seguinte conteúdo.
<?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>Neste capítulo, criaremos um aplicativo Spring Batch que usa um leitor MySQL e um gravador XML.
Reader - O leitor que estamos usando no aplicativo é JdbcCursorItemReader para ler dados do banco de dados MySQL.
Suponha que criamos uma tabela no banco de dados MySQL conforme mostrado abaixo -
CREATE TABLE details.xml_mysql(
person_id int(10) NOT NULL,
sales VARCHAR(20),
qty int(3),
staffName VARCHAR(20),
date VARCHAR(20)
);Suponha que inserimos os seguintes registros nele.
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 - O escritor que estamos usando no aplicativo é StaxEventItemWriter para gravar os dados no arquivo XML.
Processor - O processador que estamos usando no aplicativo é um processador personalizado que apenas imprime os registros lidos do arquivo CSV.
jobConfig.xml
A seguir está o arquivo de configuração de nosso aplicativo Spring Batch de amostra. Neste arquivo, definiremos o Trabalho e as Etapas. Além disso, também definimos os beans para ItemReader, ItemProcessor e ItemWriter. (Aqui, nós os associamos com suas respectivas classes e passamos os valores para as propriedades necessárias para configurá-los.)
<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
A seguir está o context.xmlde nosso aplicativo Spring Batch. Neste arquivo, definiremos os beans como repositório de trabalhos, lançador de trabalhos e gerenciador de transações.
<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
A seguir está a classe Processor. Nesta aula, escrevemos o código de processamento no aplicativo. Aqui, estamos imprimindo o conteúdo de cada registro.
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
A seguir está o TutorialRowMapper classe que define os dados para o 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
A seguir está o Tutorialclasse. É uma classe Java simples comsetter e gettermétodos. Nesta classe, estamos usando anotações para associar os métodos desta classe às tags do arquivo 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
A seguir está o código que inicia o processo em lote. Nesta aula, iniciaremos o aplicativo em lote executando o 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());
}
}Ao executar este aplicativo, ele produzirá a seguinte saída.
May 08, 2017 11:32:06 AM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@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 : COMPLETEDIsso irá gerar um arquivo XML com o seguinte conteúdo.
<?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>Neste capítulo, criaremos um aplicativo Spring Batch que usa um MySQL Reader e um Flatfile Escritor (.txt).
Reader - O leitor que estamos usando no aplicativo é JdbcCursorItemReader para ler dados do banco de dados MySQL.
Suponha que criamos uma tabela no banco de dados MySQL, conforme mostrado abaixo.
CREATE TABLE details.xml_mysql(
person_id int(10) NOT NULL,
sales VARCHAR(20),
qty int(3),
staffName VARCHAR(20),
date VARCHAR(20)
);Suponha que inserimos os seguintes registros nele.
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 - O escritor que estamos usando no aplicativo é FlatFileItemWriter para escrever os dados para flatfile (.TXT).
Processor - O processador que estamos usando no aplicativo é um processador personalizado que apenas imprime os registros lidos do arquivo CSV.
jobConfig.xml
A seguir está o arquivo de configuração de nosso aplicativo Spring Batch de amostra. Neste arquivo, definiremos o Trabalho e as Etapas. Além disso, também definimos os beans para ItemReader, ItemProcessor e ItemWriter. (Aqui, nós os associamos às respectivas classes e passamos os valores para as propriedades necessárias para configurá-los.)
<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
A seguir está o context.xmlde nosso aplicativo Spring Batch. Neste arquivo, definiremos os beans como repositório de trabalhos, lançador de trabalhos e gerenciador de transações.
<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
A seguir está a classe Processor. Nesta aula, escrevemos o código de processamento no aplicativo. Aqui, estamos imprimindo o conteúdo de cada registro.
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
A seguir está o TutorialRowMapper classe que define os dados para o 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
A seguir está o Tutorialclasse. É uma classe Java simples comsetter e gettermétodos. Nesta classe, estamos usando anotações para associar os métodos desta classe às tags do arquivo 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
A seguir está o código que inicia o processo em lote. Nesta aula, iniciaremos o aplicativo em lote executando o 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());
}
}Ao executar este aplicativo, ele produzirá a seguinte saída.
May 09, 2017 5:44:48 PM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXml
ApplicationContext@3d646c37: 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 : COMPLETEDIsso irá gerar um .txt arquivo com o seguinte conteúdo.
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]