This is an introductory tutorial to Spring Batch. It does not aim to
provide a complete guide to the framework but rather to facilitate the
first contact. Spring Batch is quite rich in functionalities, and this
is basically how I started learning it.
Keep in mind that we will only be scratching the surface.
Before we start
All the examples will have the lofty task of printing "Hello World!"
though in different ways. They were developed with Spring Batch 1.0.
I'll provide a Maven 2 project and I'll run the examples with Maven but
of course it is not a requirement to work with Spring Batch.
Spring Batch in 2 Words
Fortunately, Spring Batch model objects have self-explanatory names.
Let's try to enumerate the most important and to link them together:
A batch Job
is composed of one or more Step
s. A JobInstance
represents a given Job
, parametrized with a set of typed properties called JobParameters
. Each run of of a JobInstance
is a JobExecution
.
Imagine a job reading entries from a data base and generating an xml
representation of it and then doing some clean-up. We have a Job
composed of 2 steps: reading/writing and clean-up. If we parametrize
this job by the date of the generated data then our Friday the 13th job
is a JobInstance
. Each time we run this instance (if a failure occurs for instance) is a JobExecution
.
This model gives a great flexibility regarding how jobs are launched and run.
This naturally brings us to launching jobs with their job parameters, which is the responsibility of JobLauncher
. Finally, various objects in the framework require a JobRepository
to store runtime information related to the batch execution. In fact,
Spring Batch domain model is much more elaborate but this will suffice
for our purpose.
Well, it took more than 2 words and I feel compelled to make a joke about it, but I won't. So let's move to the next section.
Common Objects
For each job, we will use a separate xml context definition file.
However there is a number of common objects that we will need
recurrently. I will group them in an applicationContext.xml which will
be imported from within job definitions. Let's go through these common
objects:
JobLauncher
JobLauncher
s are responsible for starting a Job with a given job parameters. The provided implementation, SimpleJobLauncher
, relies on a TaskExecutor
to launch the jobs. If no specific TaskExecutor
is set then a SyncTaskExecutor
is used.
JobRepository
We will use the SimpleJobRepository
implementation which requires a set of execution Daos to store its information.
JobInstanceDao, JobExecutionDao, StepExecutionDao
These data access objects are used by SimpleJobRepository
to store execution related information. Two sets of implementations are
provided by Spring Batch: Map based (in-memory) and Jdbc based. In a
real application the Jdbc variants are more suitable but we will use
the simpler in-memory alternative in this example.
Here's our applicationContext.xml:
<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-2.5.xsd">
<bean id="jobLauncher" class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name="jobRepository" ref="jobRepository"/>
</bean>
<bean id="jobRepository" class="org.springframework.batch.core.repository.support.SimpleJobRepository">
<constructor-arg>
<bean class="org.springframework.batch.core.repository.dao.MapJobInstanceDao"/>
</constructor-arg>
<constructor-arg>
<bean class="org.springframework.batch.core.repository.dao.MapJobExecutionDao" />
</constructor-arg>
<constructor-arg>
<bean class="org.springframework.batch.core.repository.dao.MapStepExecutionDao"/>
</constructor-arg>
</bean>
</beans>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="jobLauncher" class="org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name="jobRepository" ref="jobRepository"/>
</bean>
<bean id="jobRepository" class="org.springframework.batch.core.repository.support.SimpleJobRepository">
<constructor-arg>
<bean class="org.springframework.batch.core.repository.dao.MapJobInstanceDao"/>
</constructor-arg>
<constructor-arg>
<bean class="org.springframework.batch.core.repository.dao.MapJobExecutionDao" />
</constructor-arg>
<constructor-arg>
<bean class="org.springframework.batch.core.repository.dao.MapStepExecutionDao"/>
</constructor-arg>
</bean>
</beans>
Hello World with Tasklets
A tasklet is an object containing any custom logic to be executed as a part of a job. Tasklets are built by implementing the Tasklet
interface. Let's implement a simple tasklet that simply prints a message:
public class PrintTasklet implements Tasklet{
private String message;
public void setMessage(String message) {
this.message = message;
}
public ExitStatus execute() throws Exception {
System.out.print(message);
return ExitStatus.FINISHED;
}
}
public class PrintTasklet implements Tasklet{
private String message;
public void setMessage(String message) {
this.message = message;
}
public ExitStatus execute() throws Exception {
System.out.print(message);
return ExitStatus.FINISHED;
}
}
Notice that the execute
method returns an ExitStatus
to indicate the status of the execution of the tasklet.
We will define our first job now in a simpleJob.xml application context. We will use the SimpleJob
implementation which executes all of its steps sequentailly. In order to plug a tasklet into a job, we need a TaskletStep
. I also added an abstract bean definition for tasklet steps in order to simplify the configuration:
<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-2.5.xsd">
<import resource="applicationContext.xml"/>
<bean id="hello" class="helloworld.PrintTasklet">
<property name="message" value="Hello"/>
</bean>
<bean id="space" class="helloworld.PrintTasklet">
<property name="message" value=" "/>
</bean>
<bean id="world" class="helloworld.PrintTasklet">
<property name="message" value="World!"/>
</bean>
<bean id="taskletStep" abstract="true"
class="org.springframework.batch.core.step.tasklet.TaskletStep">
<property name="jobRepository" ref="jobRepository"/>
</bean>
<bean id="simpleJob" class="org.springframework.batch.core.job.SimpleJob">
<property name="name" value="simpleJob" />
<property name="steps">
<list>
<bean parent="taskletStep">
<property name="tasklet" ref="hello"/>
</bean>
<bean parent="taskletStep">
<property name="tasklet" ref="space"/>
</bean>
<bean parent="taskletStep">;
<property name="tasklet" ref="world"/>
</bean>
</list>
</property>
<property name="jobRepository" ref="jobRepository"/>
</bean>
</beans>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<import resource="applicationContext.xml"/>
<bean id="hello" class="helloworld.PrintTasklet">
<property name="message" value="Hello"/>
</bean>
<bean id="space" class="helloworld.PrintTasklet">
<property name="message" value=" "/>
</bean>
<bean id="world" class="helloworld.PrintTasklet">
<property name="message" value="World!"/>
</bean>
<bean id="taskletStep" abstract="true"
class="org.springframework.batch.core.step.tasklet.TaskletStep">
<property name="jobRepository" ref="jobRepository"/>
</bean>
<bean id="simpleJob" class="org.springframework.batch.core.job.SimpleJob">
<property name="name" value="simpleJob" />
<property name="steps">
<list>
<bean parent="taskletStep">
<property name="tasklet" ref="hello"/>
</bean>
<bean parent="taskletStep">
<property name="tasklet" ref="space"/>
</bean>
<bean parent="taskletStep">;
<property name="tasklet" ref="world"/>
</bean>
</list>
</property>
<property name="jobRepository" ref="jobRepository"/>
</bean>
</beans>
Running the Job
Now we need something to kick-start the execution of our jobs.
Spring Batch provides a convenient class to achieve that from the
command line: CommandLineJobRunner
.
In its simplest form this class takes 2 arguments: the xml application
context containing the job to launch and the bean id of that job. It
naturally requires a JobLauncher
to be
configured in the application context. Here's how to launch the job
with Maven. Of course, it can be run with the java command directly
(you need to specify the class path then):
mvn exec:java -Dexec.mainClass=
org.springframework.batch.core.launch.support.CommandLineJobRunner
-Dexec.args="simpleJob.xml simpleJob"
Hopefully, your efforts will be rewarded with a "Hello World!" printed on the console.
The code source can be downloaded here
.
分享到:
相关推荐
SpringBatch Tasklet sample
Spring Boot整合Spring Batch的一个小例子,在网上发现这方面的资源比较少,特此将其上传供大家学习。
Spring Batch是Spring的一个子项目,使用Java语言并基于Spring框架为基础开发,使得已经使用 Spring 框架的开发者或者企业更容易访问和利用企业服务。 Spring Batch 提供了大量可重用的组件,包括了日志、追踪、事务、...
Spring Batch API(Spring Batch 开发文档).CHM。 官网 Spring Batch API,Spring Batch 开发文档
The Definitive Guide to Spring Batch takes you from the “Hello, World!” of batch processing to complex scenarios demonstrating cloud native techniques for developing batch applications to be run on...
spring-batch4.0.0 batch spring-batch集成 spring-batch.jar
spring batch批处理框架和对应的源码资源 rar 可以直接运行的
Spring Batch是一个轻量级的,完全面向Spring的批处理框架,可以应用于企业级大量的数据处理系统。Spring Batch以POJO和大家熟知的Spring框架为基础,使开发者更容易的访问和利用企业级服务。Spring Batch可以提供...
SpringBatch 示例小程序源码(内含依赖的jar包) 本示例程序 使用 Spring 3 + Spring Batch 2.2.7
基于Spring Batch的大数据量并行处理 基于Spring Batch的大数据量并行处理
入门篇介绍了批处理、Spring Batch的基本特性和新特性,快速入门的Hello World等内容引领读者入门,从而进入数据批处理的世界。基本篇重点讲述了数据批处理的核心概念、典型的作业配置、作业步配置,以及Spring ...
Spring Batch 实例代码
最近在研究springBoot+springbatch ,按照官网的实例做了一个实例。 最近在研究springBoot+springbatch ,按照官网的实例做了一个实例。
DESCRIPTION Even though running batch processes is an ... KEY POINTS * Complete guide to the Spring Batch framework * Numerous real-world examples * Covers basics, best practices and advanced topics
主要给大家介绍了Spring Batch读取txt文件并写入数据库的方法,SpringBatch 是一个轻量级、全面的批处理框架。这里我们用它来实现文件的读取并将读取的结果作处理,处理之后再写入数据库中的功能。需要的朋友可以...
mybatis、springBatch、mysql、quartz、spring、springMVC 部署说明: 本项目为两个数据库,由一个数据库的表向另外一个数据库的表做数据迁移,其中数据库脚本在:/src/main/resources/sql/下面(其中data_rep中的表...
SpringBatch数据库建表语句,存储springBatch批处理过程中需要保存的数据和步骤信息